g_turret.c File Reference

#include "g_local.h"

Go to the source code of this file.

Functions
void	AnglesNormalize (vec3_t vec)
float	SnapToEights (float x)
void	turret_blocked (edict_t *self, edict_t *other)
void	turret_breach_fire (edict_t *self)
void	turret_breach_think (edict_t *self)
void	turret_breach_finish_init (edict_t *self)
void	SP_turret_breach (edict_t *self)
void	SP_turret_base (edict_t *self)
void	infantry_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage)
void	infantry_stand (edict_t *self)
void	monster_use (edict_t *self, edict_t *other, edict_t *activator)
void	turret_driver_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
qboolean	FindTarget (edict_t *self)
void	turret_driver_think (edict_t *self)
void	turret_driver_link (edict_t *self)
void	SP_turret_driver (edict_t *self)

Function Documentation

AnglesNormalize()

void AnglesNormalize

(

vec3_t

vec

)

Definition at line 25 of file g_turret.c.

{
    while(vec[0] > 360)
        vec[0] -= 360;
    while(vec[0] < 0)
        vec[0] += 360;
    while(vec[1] > 360)
        vec[1] -= 360;
    while(vec[1] < 0)
        vec[1] += 360;
}

Referenced by turret_breach_think(), and turret_driver_link().

FindTarget()

qboolean FindTarget

(

edict_t *

self

)

Definition at line 407 of file g_ai.c.

{
    edict_t     *client;
    qboolean    heardit;
    int         r;
 
    if (self->monsterinfo.aiflags & AI_GOOD_GUY)
    {
        if (self->goalentity && self->goalentity->inuse && self->goalentity->classname)
        {
            if (strcmp(self->goalentity->classname, "target_actor") == 0)
                return false;
        }
 
        //FIXME look for monsters?
        return false;
    }
 
    // if we're going to a combat point, just proceed
    if (self->monsterinfo.aiflags & AI_COMBAT_POINT)
        return false;
 
// if the first spawnflag bit is set, the monster will only wake up on
// really seeing the player, not another monster getting angry or hearing
// something
 
// revised behavior so they will wake up if they "see" a player make a noise
// but not weapon impact/explosion noises
 
    heardit = false;
    if ((level.sight_entity_framenum >= (level.framenum - 1)) && !(self->spawnflags & 1) )
    {
        client = level.sight_entity;
        if (client->enemy == self->enemy)
        {
            return false;
        }
    }
    else if (level.sound_entity_framenum >= (level.framenum - 1))
    {
        client = level.sound_entity;
        heardit = true;
    }
    else if (!(self->enemy) && (level.sound2_entity_framenum >= (level.framenum - 1)) && !(self->spawnflags & 1) )
    {
        client = level.sound2_entity;
        heardit = true;
    }
    else
    {
        client = level.sight_client;
        if (!client)
            return false;   // no clients to get mad at
    }
 
    // if the entity went away, forget it
    if (!client->inuse)
        return false;
 
    if (client == self->enemy)
        return true;    // JDC false;
 
    if (client->client)
    {
        if (client->flags & FL_NOTARGET)
            return false;
    }
    else if (client->svflags & SVF_MONSTER)
    {
        if (!client->enemy)
            return false;
        if (client->enemy->flags & FL_NOTARGET)
            return false;
    }
    else if (heardit)
    {
        if (client->owner->flags & FL_NOTARGET)
            return false;
    }
    else
        return false;
 
    if (!heardit)
    {
        r = range (self, client);
 
        if (r == RANGE_FAR)
            return false;
 
// this is where we would check invisibility
 
        // is client in an spot too dark to be seen?
        if (client->light_level <= 5)
            return false;
 
        if (!visible (self, client))
        {
            return false;
        }
 
        if (r == RANGE_NEAR)
        {
            if (client->show_hostile < level.time && !infront (self, client))
            {
                return false;
            }
        }
        else if (r == RANGE_MID)
        {
            if (!infront (self, client))
            {
                return false;
            }
        }
 
        self->enemy = client;
 
        if (strcmp(self->enemy->classname, "player_noise") != 0)
        {
            self->monsterinfo.aiflags &= ~AI_SOUND_TARGET;
 
            if (!self->enemy->client)
            {
                self->enemy = self->enemy->enemy;
                if (!self->enemy->client)
                {
                    self->enemy = NULL;
                    return false;
                }
            }
        }
    }
    else    // heardit
    {
        vec3_t  temp;
 
        if (self->spawnflags & 1)
        {
            if (!visible (self, client))
                return false;
        }
        else
        {
            if (!gi.inPHS(self->s.origin, client->s.origin))
                return false;
        }
 
        VectorSubtract (client->s.origin, self->s.origin, temp);
 
        if (VectorLength(temp) > 1000)  // too far to hear
        {
            return false;
        }
 
        // check area portals - if they are different and not connected then we can't hear it
        if (client->areanum != self->areanum)
            if (!gi.AreasConnected(self->areanum, client->areanum))
                return false;
 
        self->ideal_yaw = vectoyaw(temp);
        M_ChangeYaw (self);
 
        // hunt the sound for a bit; hopefully find the real player
        self->monsterinfo.aiflags |= AI_SOUND_TARGET;
        self->enemy = client;
    }
 
//
// got one
//
    FoundTarget (self);
 
    if (!(self->monsterinfo.aiflags & AI_SOUND_TARGET) && (self->monsterinfo.sight))
        self->monsterinfo.sight (self, self->enemy);
 
    return true;
}

Referenced by ai_run(), ai_stand(), ai_turn(), ai_walk(), and turret_driver_think().

infantry_die()

void infantry_die	(	edict_t *	self,
		edict_t *	inflictor,
		edict_t *	attacker,
		int	damage
	)

Referenced by turret_driver_die().

infantry_stand()

void infantry_stand

(

edict_t *

self

)

Definition at line 75 of file m_infantry.c.

{
    self->monsterinfo.currentmove = &infantry_move_stand;
}

Referenced by SP_monster_infantry(), and SP_turret_driver().

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().

SnapToEights()

float SnapToEights

(

float

x

)

Definition at line 37 of file g_turret.c.

{
    x *= 8.0;
    if (x > 0.0)
        x += 0.5;
    else
        x -= 0.5;
    return 0.125 * (int)x;
}

Referenced by turret_breach_think().

SP_turret_base()

void SP_turret_base

(

edict_t *

self

)

Definition at line 259 of file g_turret.c.

{
    self->solid = SOLID_BSP;
    self->movetype = MOVETYPE_PUSH;
    gi.setmodel (self, self->model);
    self->blocked = turret_blocked;
    gi.linkentity (self);
}

SP_turret_breach()

void SP_turret_breach

(

edict_t *

self

)

Definition at line 220 of file g_turret.c.

{
    self->solid = SOLID_BSP;
    self->movetype = MOVETYPE_PUSH;
    gi.setmodel (self, self->model);
 
    if (!self->speed)
        self->speed = 50;
    if (!self->dmg)
        self->dmg = 10;
 
    if (!st.minpitch)
        st.minpitch = -30;
    if (!st.maxpitch)
        st.maxpitch = 30;
    if (!st.maxyaw)
        st.maxyaw = 360;
 
    self->pos1[PITCH] = -1 * st.minpitch;
    self->pos1[YAW]   = st.minyaw;
    self->pos2[PITCH] = -1 * st.maxpitch;
    self->pos2[YAW]   = st.maxyaw;
 
    self->ideal_yaw = self->s.angles[YAW];
    self->move_angles[YAW] = self->ideal_yaw;
 
    self->blocked = turret_blocked;
 
    self->think = turret_breach_finish_init;
    self->nextthink = level.time + FRAMETIME;
    gi.linkentity (self);
}

SP_turret_driver()

void SP_turret_driver

(

edict_t *

self

)

Definition at line 387 of file g_turret.c.

{
    if (deathmatch->value)
    {
        G_FreeEdict (self);
        return;
    }
 
    self->movetype = MOVETYPE_PUSH;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/infantry/tris.md2");
    VectorSet (self->mins, -16, -16, -24);
    VectorSet (self->maxs, 16, 16, 32);
 
    self->health = 100;
    self->gib_health = 0;
    self->mass = 200;
    self->viewheight = 24;
 
    self->die = turret_driver_die;
    self->monsterinfo.stand = infantry_stand;
 
    self->flags |= FL_NO_KNOCKBACK;
 
    level.total_monsters++;
 
    self->svflags |= SVF_MONSTER;
    self->s.renderfx |= RF_FRAMELERP;
    self->takedamage = DAMAGE_AIM;
    self->use = monster_use;
    self->clipmask = MASK_MONSTERSOLID;
    VectorCopy (self->s.origin, self->s.old_origin);
    self->monsterinfo.aiflags |= AI_STAND_GROUND|AI_DUCKED;
 
    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);
    }
 
    self->think = turret_driver_link;
    self->nextthink = level.time + FRAMETIME;
 
    gi.linkentity (self);
}

turret_blocked()

void turret_blocked	(	edict_t *	self,
		edict_t *	other
	)

Definition at line 48 of file g_turret.c.

{
    edict_t *attacker;
 
    if (other->takedamage)
    {
        if (self->teammaster->owner)
            attacker = self->teammaster->owner;
        else
            attacker = self->teammaster;
        T_Damage (other, self, attacker, vec3_origin, other->s.origin, vec3_origin, self->teammaster->dmg, 10, 0, MOD_CRUSH);
    }
}

Referenced by SP_turret_base(), and SP_turret_breach().

turret_breach_finish_init()

void turret_breach_finish_init

(

edict_t *

self

)

Definition at line 201 of file g_turret.c.

{
    // get and save info for muzzle location
    if (!self->target)
    {
        gi.dprintf("%s at %s needs a target\n", self->classname, vtos(self->s.origin));
    }
    else
    {
        self->target_ent = G_PickTarget (self->target);
        VectorSubtract (self->target_ent->s.origin, self->s.origin, self->move_origin);
        G_FreeEdict(self->target_ent);
    }
 
    self->teammaster->dmg = self->dmg;
    self->think = turret_breach_think;
    self->think (self);
}

Referenced by SP_turret_breach().

turret_breach_fire()

void turret_breach_fire

(

edict_t *

self

)

Definition at line 78 of file g_turret.c.

{
    vec3_t  f, r, u;
    vec3_t  start;
    int     damage;
    int     speed;
 
    AngleVectors (self->s.angles, f, r, u);
    VectorMA (self->s.origin, self->move_origin[0], f, start);
    VectorMA (start, self->move_origin[1], r, start);
    VectorMA (start, self->move_origin[2], u, start);
 
    damage = 100 + random() * 50;
    speed = 550 + 50 * skill->value;
    fire_rocket (self->teammaster->owner, start, f, damage, speed, 150, damage);
    gi.positioned_sound (start, self, CHAN_WEAPON, gi.soundindex("weapons/rocklf1a.wav"), 1, ATTN_NORM, 0);
}

Referenced by turret_breach_think().

turret_breach_think()

void turret_breach_think

(

edict_t *

self

)

Definition at line 96 of file g_turret.c.

{
    edict_t *ent;
    vec3_t  current_angles;
    vec3_t  delta;
 
    VectorCopy (self->s.angles, current_angles);
    AnglesNormalize(current_angles);
 
    AnglesNormalize(self->move_angles);
    if (self->move_angles[PITCH] > 180)
        self->move_angles[PITCH] -= 360;
 
    // clamp angles to mins & maxs
    if (self->move_angles[PITCH] > self->pos1[PITCH])
        self->move_angles[PITCH] = self->pos1[PITCH];
    else if (self->move_angles[PITCH] < self->pos2[PITCH])
        self->move_angles[PITCH] = self->pos2[PITCH];
 
    if ((self->move_angles[YAW] < self->pos1[YAW]) || (self->move_angles[YAW] > self->pos2[YAW]))
    {
        float   dmin, dmax;
 
        dmin = fabs(self->pos1[YAW] - self->move_angles[YAW]);
        if (dmin < -180)
            dmin += 360;
        else if (dmin > 180)
            dmin -= 360;
        dmax = fabs(self->pos2[YAW] - self->move_angles[YAW]);
        if (dmax < -180)
            dmax += 360;
        else if (dmax > 180)
            dmax -= 360;
        if (fabs(dmin) < fabs(dmax))
            self->move_angles[YAW] = self->pos1[YAW];
        else
            self->move_angles[YAW] = self->pos2[YAW];
    }
 
    VectorSubtract (self->move_angles, current_angles, delta);
    if (delta[0] < -180)
        delta[0] += 360;
    else if (delta[0] > 180)
        delta[0] -= 360;
    if (delta[1] < -180)
        delta[1] += 360;
    else if (delta[1] > 180)
        delta[1] -= 360;
    delta[2] = 0;
 
    if (delta[0] > self->speed * FRAMETIME)
        delta[0] = self->speed * FRAMETIME;
    if (delta[0] < -1 * self->speed * FRAMETIME)
        delta[0] = -1 * self->speed * FRAMETIME;
    if (delta[1] > self->speed * FRAMETIME)
        delta[1] = self->speed * FRAMETIME;
    if (delta[1] < -1 * self->speed * FRAMETIME)
        delta[1] = -1 * self->speed * FRAMETIME;
 
    VectorScale (delta, 1.0/FRAMETIME, self->avelocity);
 
    self->nextthink = level.time + FRAMETIME;
 
    for (ent = self->teammaster; ent; ent = ent->teamchain)
        ent->avelocity[1] = self->avelocity[1];
 
    // if we have adriver, adjust his velocities
    if (self->owner)
    {
        float   angle;
        float   target_z;
        float   diff;
        vec3_t  target;
        vec3_t  dir;
 
        // angular is easy, just copy ours
        self->owner->avelocity[0] = self->avelocity[0];
        self->owner->avelocity[1] = self->avelocity[1];
 
        // x & y
        angle = self->s.angles[1] + self->owner->move_origin[1];
        angle *= (M_PI*2 / 360);
        target[0] = SnapToEights(self->s.origin[0] + cos(angle) * self->owner->move_origin[0]);
        target[1] = SnapToEights(self->s.origin[1] + sin(angle) * self->owner->move_origin[0]);
        target[2] = self->owner->s.origin[2];
 
        VectorSubtract (target, self->owner->s.origin, dir);
        self->owner->velocity[0] = dir[0] * 1.0 / FRAMETIME;
        self->owner->velocity[1] = dir[1] * 1.0 / FRAMETIME;
 
        // z
        angle = self->s.angles[PITCH] * (M_PI*2 / 360);
        target_z = SnapToEights(self->s.origin[2] + self->owner->move_origin[0] * tan(angle) + self->owner->move_origin[2]);
 
        diff = target_z - self->owner->s.origin[2];
        self->owner->velocity[2] = diff * 1.0 / FRAMETIME;
 
        if (self->spawnflags & 65536)
        {
            turret_breach_fire (self);
            self->spawnflags &= ~65536;
        }
    }
}

Referenced by turret_breach_finish_init().

turret_driver_die()

void turret_driver_die	(	edict_t *	self,
		edict_t *	inflictor,
		edict_t *	attacker,
		int	damage,
		vec3_t	point
	)

Definition at line 278 of file g_turret.c.

{
    edict_t *ent;
 
    // level the gun
    self->target_ent->move_angles[0] = 0;
 
    // remove the driver from the end of them team chain
    for (ent = self->target_ent->teammaster; ent->teamchain != self; ent = ent->teamchain)
        ;
    ent->teamchain = NULL;
    self->teammaster = NULL;
    self->flags &= ~FL_TEAMSLAVE;
 
    self->target_ent->owner = NULL;
    self->target_ent->teammaster->owner = NULL;
 
    infantry_die (self, inflictor, attacker, damage);
}

Referenced by SP_turret_driver().

turret_driver_link()

void turret_driver_link

(

edict_t *

self

)

Definition at line 354 of file g_turret.c.

{
    vec3_t  vec;
    edict_t *ent;
 
    self->think = turret_driver_think;
    self->nextthink = level.time + FRAMETIME;
 
    self->target_ent = G_PickTarget (self->target);
    self->target_ent->owner = self;
    self->target_ent->teammaster->owner = self;
    VectorCopy (self->target_ent->s.angles, self->s.angles);
 
    vec[0] = self->target_ent->s.origin[0] - self->s.origin[0];
    vec[1] = self->target_ent->s.origin[1] - self->s.origin[1];
    vec[2] = 0;
    self->move_origin[0] = VectorLength(vec);
 
    VectorSubtract (self->s.origin, self->target_ent->s.origin, vec);
    vectoangles (vec, vec);
    AnglesNormalize(vec);
    self->move_origin[1] = vec[1];
 
    self->move_origin[2] = self->s.origin[2] - self->target_ent->s.origin[2];
 
    // add the driver to the end of them team chain
    for (ent = self->target_ent->teammaster; ent->teamchain; ent = ent->teamchain)
        ;
    ent->teamchain = self;
    self->teammaster = self->target_ent->teammaster;
    self->flags |= FL_TEAMSLAVE;
}

Referenced by SP_turret_driver().

turret_driver_think()

void turret_driver_think

(

edict_t *

self

)

Definition at line 300 of file g_turret.c.

{
    vec3_t  target;
    vec3_t  dir;
    float   reaction_time;
 
    self->nextthink = level.time + FRAMETIME;
 
    if (self->enemy && (!self->enemy->inuse || self->enemy->health <= 0))
        self->enemy = NULL;
 
    if (!self->enemy)
    {
        if (!FindTarget (self))
            return;
        self->monsterinfo.trail_time = level.time;
        self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
    }
    else
    {
        if (visible (self, self->enemy))
        {
            if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
            {
                self->monsterinfo.trail_time = level.time;
                self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
            }
        }
        else
        {
            self->monsterinfo.aiflags |= AI_LOST_SIGHT;
            return;
        }
    }
 
    // let the turret know where we want it to aim
    VectorCopy (self->enemy->s.origin, target);
    target[2] += self->enemy->viewheight;
    VectorSubtract (target, self->target_ent->s.origin, dir);
    vectoangles (dir, self->target_ent->move_angles);
 
    // decide if we should shoot
    if (level.time < self->monsterinfo.attack_finished)
        return;
 
    reaction_time = (3 - skill->value) * 1.0;
    if ((level.time - self->monsterinfo.trail_time) < reaction_time)
        return;
 
    self->monsterinfo.attack_finished = level.time + reaction_time + 1.0;
    //FIXME how do we really want to pass this along?
    self->target_ent->spawnflags |= 65536;
}

Referenced by turret_driver_link().