g_ai.c File Reference

#include "g_local.h"

Go to the source code of this file.

Functions
qboolean	FindTarget (edict_t *self)
qboolean	ai_checkattack (edict_t *self, float dist)
void	AI_SetSightClient (void)
void	ai_move (edict_t *self, float dist)
void	ai_stand (edict_t *self, float dist)
void	ai_walk (edict_t *self, float dist)
void	ai_charge (edict_t *self, float dist)
void	ai_turn (edict_t *self, float dist)
int	range (edict_t *self, edict_t *other)
qboolean	visible (edict_t *self, edict_t *other)
qboolean	infront (edict_t *self, edict_t *other)
void	HuntTarget (edict_t *self)
void	FoundTarget (edict_t *self)
qboolean	FacingIdeal (edict_t *self)
qboolean	M_CheckAttack (edict_t *self)
void	ai_run_melee (edict_t *self)
void	ai_run_missile (edict_t *self)
void	ai_run_slide (edict_t *self, float distance)
void	ai_run (edict_t *self, float dist)

Variables
cvar_t *	maxclients
qboolean	enemy_vis
qboolean	enemy_infront
int	enemy_range
float	enemy_yaw

Function Documentation

ai_charge()

void ai_charge	(	edict_t *	self,
		float	dist
	)

Definition at line 194 of file g_ai.c.

{
    vec3_t  v;
 
    VectorSubtract (self->enemy->s.origin, self->s.origin, v);
    self->ideal_yaw = vectoyaw(v);
    M_ChangeYaw (self);
 
    if (dist)
        M_walkmove (self, self->s.angles[YAW], dist);
}

ai_checkattack()

qboolean ai_checkattack	(	edict_t *	self,
		float	dist
	)

Definition at line 771 of file g_ai.c.

{
    vec3_t      temp;
    qboolean    hesDeadJim;
 
// this causes monsters to run blindly to the combat point w/o firing
    if (self->goalentity)
    {
        if (self->monsterinfo.aiflags & AI_COMBAT_POINT)
            return false;
 
        if (self->monsterinfo.aiflags & AI_SOUND_TARGET)
        {
            if ((level.time - self->enemy->teleport_time) > 5.0)
            {
                if (self->goalentity == self->enemy) {
                    if (self->movetarget)
                        self->goalentity = self->movetarget;
                    else
                        self->goalentity = NULL;
                }
                self->monsterinfo.aiflags &= ~AI_SOUND_TARGET;
                if (self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND)
                    self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND);
            }
            else
            {
                self->show_hostile = level.time + 1;
                return false;
            }
        }
    }
 
    enemy_vis = false;
 
// see if the enemy is dead
    hesDeadJim = false;
    if ((!self->enemy) || (!self->enemy->inuse))
    {
        hesDeadJim = true;
    }
    else if (self->monsterinfo.aiflags & AI_MEDIC)
    {
        if (self->enemy->health > 0)
        {
            hesDeadJim = true;
            self->monsterinfo.aiflags &= ~AI_MEDIC;
        }
    }
    else
    {
        if (self->monsterinfo.aiflags & AI_BRUTAL)
        {
            if (self->enemy->health <= -80)
                hesDeadJim = true;
        }
        else
        {
            if (self->enemy->health <= 0)
                hesDeadJim = true;
        }
    }
 
    if (hesDeadJim)
    {
        self->enemy = NULL;
    // FIXME: look all around for other targets
        if (self->oldenemy && self->oldenemy->health > 0)
        {
            self->enemy = self->oldenemy;
            self->oldenemy = NULL;
            HuntTarget (self);
        }
        else
        {
            if (self->movetarget)
            {
                self->goalentity = self->movetarget;
                self->monsterinfo.walk (self);
            }
            else
            {
                // we need the pausetime otherwise the stand code
                // will just revert to walking with no target and
                // the monsters will wonder around aimlessly trying
                // to hunt the world entity
                self->monsterinfo.pausetime = level.time + 100000000;
                self->monsterinfo.stand (self);
            }
            return true;
        }
    }
 
    self->show_hostile = level.time + 1;        // wake up other monsters
 
// check knowledge of enemy
    enemy_vis = visible(self, self->enemy);
    if (enemy_vis)
    {
        self->monsterinfo.search_time = level.time + 5;
        VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting);
    }
 
// look for other coop players here
//  if (coop && self->monsterinfo.search_time < level.time)
//  {
//      if (FindTarget (self))
//          return true;
//  }
 
    enemy_infront = infront(self, self->enemy);
    enemy_range = range(self, self->enemy);
    VectorSubtract (self->enemy->s.origin, self->s.origin, temp);
    enemy_yaw = vectoyaw(temp);
 
 
    // JDC self->ideal_yaw = enemy_yaw;
 
    if (self->monsterinfo.attack_state == AS_MISSILE)
    {
        ai_run_missile (self);
        return true;
    }
    if (self->monsterinfo.attack_state == AS_MELEE)
    {
        ai_run_melee (self);
        return true;
    }
 
    // if enemy is not currently visible, we will never attack
    if (!enemy_vis)
        return false;
 
    return self->monsterinfo.checkattack (self);
}

Referenced by ai_run(), and ai_stand().

ai_move()

void ai_move	(	edict_t *	self,
		float	dist
	)

Definition at line 92 of file g_ai.c.

{
    M_walkmove (self, self->s.angles[YAW], dist);
}

ai_run()

void ai_run	(	edict_t *	self,
		float	dist
	)

Definition at line 915 of file g_ai.c.

{
    vec3_t      v;
    edict_t     *tempgoal;
    edict_t     *save;
    qboolean    new;
    edict_t     *marker;
    float       d1, d2;
    trace_t     tr;
    vec3_t      v_forward, v_right;
    float       left, center, right;
    vec3_t      left_target, right_target;
 
    // if we're going to a combat point, just proceed
    if (self->monsterinfo.aiflags & AI_COMBAT_POINT)
    {
        M_MoveToGoal (self, dist);
        return;
    }
 
    if (self->monsterinfo.aiflags & AI_SOUND_TARGET)
    {
        VectorSubtract (self->s.origin, self->enemy->s.origin, v);
        if (VectorLength(v) < 64)
        {
            self->monsterinfo.aiflags |= (AI_STAND_GROUND | AI_TEMP_STAND_GROUND);
            self->monsterinfo.stand (self);
            return;
        }
 
        M_MoveToGoal (self, dist);
 
        if (!FindTarget (self))
            return;
    }
 
    if (ai_checkattack (self, dist))
        return;
 
    if (self->monsterinfo.attack_state == AS_SLIDING)
    {
        ai_run_slide (self, dist);
        return;
    }
 
    if (enemy_vis)
    {
//      if (self.aiflags & AI_LOST_SIGHT)
//          dprint("regained sight\n");
        M_MoveToGoal (self, dist);
        self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
        VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting);
        self->monsterinfo.trail_time = level.time;
        return;
    }
 
    // coop will change to another enemy if visible
    if (coop->value)
    {   // FIXME: insane guys get mad with this, which causes crashes!
        if (FindTarget (self))
            return;
    }
 
    if ((self->monsterinfo.search_time) && (level.time > (self->monsterinfo.search_time + 20)))
    {
        M_MoveToGoal (self, dist);
        self->monsterinfo.search_time = 0;
//      dprint("search timeout\n");
        return;
    }
 
    save = self->goalentity;
    tempgoal = G_Spawn();
    self->goalentity = tempgoal;
 
    new = false;
 
    if (!(self->monsterinfo.aiflags & AI_LOST_SIGHT))
    {
        // just lost sight of the player, decide where to go first
//      dprint("lost sight of player, last seen at "); dprint(vtos(self.last_sighting)); dprint("\n");
        self->monsterinfo.aiflags |= (AI_LOST_SIGHT | AI_PURSUIT_LAST_SEEN);
        self->monsterinfo.aiflags &= ~(AI_PURSUE_NEXT | AI_PURSUE_TEMP);
        new = true;
    }
 
    if (self->monsterinfo.aiflags & AI_PURSUE_NEXT)
    {
        self->monsterinfo.aiflags &= ~AI_PURSUE_NEXT;
//      dprint("reached current goal: "); dprint(vtos(self.origin)); dprint(" "); dprint(vtos(self.last_sighting)); dprint(" "); dprint(ftos(vlen(self.origin - self.last_sighting))); dprint("\n");
 
        // give ourself more time since we got this far
        self->monsterinfo.search_time = level.time + 5;
 
        if (self->monsterinfo.aiflags & AI_PURSUE_TEMP)
        {
//          dprint("was temp goal; retrying original\n");
            self->monsterinfo.aiflags &= ~AI_PURSUE_TEMP;
            marker = NULL;
            VectorCopy (self->monsterinfo.saved_goal, self->monsterinfo.last_sighting);
            new = true;
        }
        else if (self->monsterinfo.aiflags & AI_PURSUIT_LAST_SEEN)
        {
            self->monsterinfo.aiflags &= ~AI_PURSUIT_LAST_SEEN;
            marker = PlayerTrail_PickFirst (self);
        }
        else
        {
            marker = PlayerTrail_PickNext (self);
        }
 
        if (marker)
        {
            VectorCopy (marker->s.origin, self->monsterinfo.last_sighting);
            self->monsterinfo.trail_time = marker->timestamp;
            self->s.angles[YAW] = self->ideal_yaw = marker->s.angles[YAW];
//          dprint("heading is "); dprint(ftos(self.ideal_yaw)); dprint("\n");
 
//          debug_drawline(self.origin, self.last_sighting, 52);
            new = true;
        }
    }
 
    VectorSubtract (self->s.origin, self->monsterinfo.last_sighting, v);
    d1 = VectorLength(v);
    if (d1 <= dist)
    {
        self->monsterinfo.aiflags |= AI_PURSUE_NEXT;
        dist = d1;
    }
 
    VectorCopy (self->monsterinfo.last_sighting, self->goalentity->s.origin);
 
    if (new)
    {
//      gi.dprintf("checking for course correction\n");
 
        tr = gi.trace(self->s.origin, self->mins, self->maxs, self->monsterinfo.last_sighting, self, MASK_PLAYERSOLID);
        if (tr.fraction < 1)
        {
            VectorSubtract (self->goalentity->s.origin, self->s.origin, v);
            d1 = VectorLength(v);
            center = tr.fraction;
            d2 = d1 * ((center+1)/2);
            self->s.angles[YAW] = self->ideal_yaw = vectoyaw(v);
            AngleVectors(self->s.angles, v_forward, v_right, NULL);
 
            VectorSet(v, d2, -16, 0);
            G_ProjectSource (self->s.origin, v, v_forward, v_right, left_target);
            tr = gi.trace(self->s.origin, self->mins, self->maxs, left_target, self, MASK_PLAYERSOLID);
            left = tr.fraction;
 
            VectorSet(v, d2, 16, 0);
            G_ProjectSource (self->s.origin, v, v_forward, v_right, right_target);
            tr = gi.trace(self->s.origin, self->mins, self->maxs, right_target, self, MASK_PLAYERSOLID);
            right = tr.fraction;
 
            center = (d1*center)/d2;
            if (left >= center && left > right)
            {
                if (left < 1)
                {
                    VectorSet(v, d2 * left * 0.5, -16, 0);
                    G_ProjectSource (self->s.origin, v, v_forward, v_right, left_target);
//                  gi.dprintf("incomplete path, go part way and adjust again\n");
                }
                VectorCopy (self->monsterinfo.last_sighting, self->monsterinfo.saved_goal);
                self->monsterinfo.aiflags |= AI_PURSUE_TEMP;
                VectorCopy (left_target, self->goalentity->s.origin);
                VectorCopy (left_target, self->monsterinfo.last_sighting);
                VectorSubtract (self->goalentity->s.origin, self->s.origin, v);
                self->s.angles[YAW] = self->ideal_yaw = vectoyaw(v);
//              gi.dprintf("adjusted left\n");
//              debug_drawline(self.origin, self.last_sighting, 152);
            }
            else if (right >= center && right > left)
            {
                if (right < 1)
                {
                    VectorSet(v, d2 * right * 0.5, 16, 0);
                    G_ProjectSource (self->s.origin, v, v_forward, v_right, right_target);
//                  gi.dprintf("incomplete path, go part way and adjust again\n");
                }
                VectorCopy (self->monsterinfo.last_sighting, self->monsterinfo.saved_goal);
                self->monsterinfo.aiflags |= AI_PURSUE_TEMP;
                VectorCopy (right_target, self->goalentity->s.origin);
                VectorCopy (right_target, self->monsterinfo.last_sighting);
                VectorSubtract (self->goalentity->s.origin, self->s.origin, v);
                self->s.angles[YAW] = self->ideal_yaw = vectoyaw(v);
//              gi.dprintf("adjusted right\n");
//              debug_drawline(self.origin, self.last_sighting, 152);
            }
        }
//      else gi.dprintf("course was fine\n");
    }
 
    M_MoveToGoal (self, dist);
 
    G_FreeEdict(tempgoal);
 
    if (self)
        self->goalentity = save;
}

ai_run_melee()

void ai_run_melee

(

edict_t *

self

)

Definition at line 703 of file g_ai.c.

{
    self->ideal_yaw = enemy_yaw;
    M_ChangeYaw (self);
 
    if (FacingIdeal(self))
    {
        self->monsterinfo.melee (self);
        self->monsterinfo.attack_state = AS_STRAIGHT;
    }
}

Referenced by ai_checkattack().

ai_run_missile()

void ai_run_missile

(

edict_t *

self

)

Definition at line 723 of file g_ai.c.

{
    self->ideal_yaw = enemy_yaw;
    M_ChangeYaw (self);
 
    if (FacingIdeal(self))
    {
        self->monsterinfo.attack (self);
        self->monsterinfo.attack_state = AS_STRAIGHT;
    }
}

Referenced by ai_checkattack().

ai_run_slide()

void ai_run_slide	(	edict_t *	self,
		float	distance
	)

Definition at line 743 of file g_ai.c.

{
    float   ofs;
    
    self->ideal_yaw = enemy_yaw;
    M_ChangeYaw (self);
 
    if (self->monsterinfo.lefty)
        ofs = 90;
    else
        ofs = -90;
    
    if (M_walkmove (self, self->ideal_yaw + ofs, distance))
        return;
        
    self->monsterinfo.lefty = 1 - self->monsterinfo.lefty;
    M_walkmove (self, self->ideal_yaw - ofs, distance);
}

Referenced by ai_run().

AI_SetSightClient()

void AI_SetSightClient

(

void

)

Definition at line 50 of file g_ai.c.

{
    edict_t *ent;
    int     start, check;
 
    if (level.sight_client == NULL)
        start = 1;
    else
        start = level.sight_client - g_edicts;
 
    check = start;
    while (1)
    {
        check++;
        if (check > game.maxclients)
            check = 1;
        ent = &g_edicts[check];
        if (ent->inuse
            && ent->health > 0
            && !(ent->flags & FL_NOTARGET) )
        {
            level.sight_client = ent;
            return;     // got one
        }
        if (check == start)
        {
            level.sight_client = NULL;
            return;     // nobody to see
        }
    }
}

Referenced by G_RunFrame().

ai_stand()

void ai_stand	(	edict_t *	self,
		float	dist
	)

Definition at line 106 of file g_ai.c.

{
    vec3_t  v;
 
    if (dist)
        M_walkmove (self, self->s.angles[YAW], dist);
 
    if (self->monsterinfo.aiflags & AI_STAND_GROUND)
    {
        if (self->enemy)
        {
            VectorSubtract (self->enemy->s.origin, self->s.origin, v);
            self->ideal_yaw = vectoyaw(v);
            if (self->s.angles[YAW] != self->ideal_yaw && self->monsterinfo.aiflags & AI_TEMP_STAND_GROUND)
            {
                self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND);
                self->monsterinfo.run (self);
            }
            M_ChangeYaw (self);
            ai_checkattack (self, 0);
        }
        else
            FindTarget (self);
        return;
    }
 
    if (FindTarget (self))
        return;
    
    if (level.time > self->monsterinfo.pausetime)
    {
        self->monsterinfo.walk (self);
        return;
    }
 
    if (!(self->spawnflags & 1) && (self->monsterinfo.idle) && (level.time > self->monsterinfo.idle_time))
    {
        if (self->monsterinfo.idle_time)
        {
            self->monsterinfo.idle (self);
            self->monsterinfo.idle_time = level.time + 15 + random() * 15;
        }
        else
        {
            self->monsterinfo.idle_time = level.time + random() * 15;
        }
    }
}

ai_turn()

void ai_turn	(	edict_t *	self,
		float	dist
	)

Definition at line 215 of file g_ai.c.

{
    if (dist)
        M_walkmove (self, self->s.angles[YAW], dist);
 
    if (FindTarget (self))
        return;
    
    M_ChangeYaw (self);
}

ai_walk()

void ai_walk	(	edict_t *	self,
		float	dist
	)

Definition at line 163 of file g_ai.c.

{
    M_MoveToGoal (self, dist);
 
    // check for noticing a player
    if (FindTarget (self))
        return;
 
    if ((self->monsterinfo.search) && (level.time > self->monsterinfo.idle_time))
    {
        if (self->monsterinfo.idle_time)
        {
            self->monsterinfo.search (self);
            self->monsterinfo.idle_time = level.time + 15 + random() * 15;
        }
        else
        {
            self->monsterinfo.idle_time = level.time + random() * 15;
        }
    }
}

FacingIdeal()

qboolean FacingIdeal

(

edict_t *

self

)

Definition at line 594 of file g_ai.c.

{
    float   delta;
 
    delta = anglemod(self->s.angles[YAW] - self->ideal_yaw);
    if (delta > 45 && delta < 315)
        return false;
    return true;
}

Referenced by ai_run_melee(), and ai_run_missile().

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

FoundTarget()

void FoundTarget

(

edict_t *

self

)

Definition at line 347 of file g_ai.c.

{
    // let other monsters see this monster for a while
    if (self->enemy->client)
    {
        level.sight_entity = self;
        level.sight_entity_framenum = level.framenum;
        level.sight_entity->light_level = 128;
    }
 
    self->show_hostile = level.time + 1;        // wake up other monsters
 
    VectorCopy(self->enemy->s.origin, self->monsterinfo.last_sighting);
    self->monsterinfo.trail_time = level.time;
 
    if (!self->combattarget)
    {
        HuntTarget (self);
        return;
    }
 
    self->goalentity = self->movetarget = G_PickTarget(self->combattarget);
    if (!self->movetarget)
    {
        self->goalentity = self->movetarget = self->enemy;
        HuntTarget (self);
        gi.dprintf("%s at %s, combattarget %s not found\n", self->classname, vtos(self->s.origin), self->combattarget);
        return;
    }
 
    // clear out our combattarget, these are a one shot deal
    self->combattarget = NULL;
    self->monsterinfo.aiflags |= AI_COMBAT_POINT;
 
    // clear the targetname, that point is ours!
    self->movetarget->targetname = NULL;
    self->monsterinfo.pausetime = 0;
 
    // run for it
    self->monsterinfo.run (self);
}

Referenced by FindTarget(), M_ReactToDamage(), medic_cable_attack(), medic_idle(), medic_run(), medic_search(), monster_triggered_spawn(), and monster_use().

HuntTarget()

void HuntTarget

(

edict_t *

self

)

Definition at line 331 of file g_ai.c.

{
    vec3_t  vec;
 
    self->goalentity = self->enemy;
    if (self->monsterinfo.aiflags & AI_STAND_GROUND)
        self->monsterinfo.stand (self);
    else
        self->monsterinfo.run (self);
    VectorSubtract (self->enemy->s.origin, self->s.origin, vec);
    self->ideal_yaw = vectoyaw(vec);
    // wait a while before first attack
    if (!(self->monsterinfo.aiflags & AI_STAND_GROUND))
        AttackFinished (self, 1);
}

Referenced by ai_checkattack(), and FoundTarget().

infront()

qboolean infront	(	edict_t *	self,
		edict_t *	other
	)

Definition at line 312 of file g_ai.c.

{
    vec3_t  vec;
    float   dot;
    vec3_t  forward;
    
    AngleVectors (self->s.angles, forward, NULL, NULL);
    VectorSubtract (other->s.origin, self->s.origin, vec);
    VectorNormalize (vec);
    dot = DotProduct (vec, forward);
    
    if (dot > 0.3)
        return true;
    return false;
}

Referenced by ai_checkattack(), Boss2_CheckAttack(), boss2_reattack_mg(), check_dodge(), FindTarget(), Jorg_CheckAttack(), and Makron_CheckAttack().

M_CheckAttack()

qboolean M_CheckAttack

(

edict_t *

self

)

Definition at line 607 of file g_ai.c.

{
    vec3_t  spot1, spot2;
    float   chance;
    trace_t tr;
 
    if (self->enemy->health > 0)
    {
    // see if any entities are in the way of the shot
        VectorCopy (self->s.origin, spot1);
        spot1[2] += self->viewheight;
        VectorCopy (self->enemy->s.origin, spot2);
        spot2[2] += self->enemy->viewheight;
 
        tr = gi.trace (spot1, NULL, NULL, spot2, self, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_SLIME|CONTENTS_LAVA|CONTENTS_WINDOW);
 
        // do we have a clear shot?
        if (tr.ent != self->enemy)
            return false;
    }
    
    // melee attack
    if (enemy_range == RANGE_MELEE)
    {
        // don't always melee in easy mode
        if (skill->value == 0 && (rand()&3) )
            return false;
        if (self->monsterinfo.melee)
            self->monsterinfo.attack_state = AS_MELEE;
        else
            self->monsterinfo.attack_state = AS_MISSILE;
        return true;
    }
    
// missile attack
    if (!self->monsterinfo.attack)
        return false;
        
    if (level.time < self->monsterinfo.attack_finished)
        return false;
        
    if (enemy_range == RANGE_FAR)
        return false;
 
    if (self->monsterinfo.aiflags & AI_STAND_GROUND)
    {
        chance = 0.4;
    }
    else if (enemy_range == RANGE_MELEE)
    {
        chance = 0.2;
    }
    else if (enemy_range == RANGE_NEAR)
    {
        chance = 0.1;
    }
    else if (enemy_range == RANGE_MID)
    {
        chance = 0.02;
    }
    else
    {
        return false;
    }
 
    if (skill->value == 0)
        chance *= 0.5;
    else if (skill->value >= 2)
        chance *= 2;
 
    if (random () < chance)
    {
        self->monsterinfo.attack_state = AS_MISSILE;
        self->monsterinfo.attack_finished = level.time + 2*random();
        return true;
    }
 
    if (self->flags & FL_FLY)
    {
        if (random() < 0.3)
            self->monsterinfo.attack_state = AS_SLIDING;
        else
            self->monsterinfo.attack_state = AS_STRAIGHT;
    }
 
    return false;
}

Referenced by medic_checkattack(), and monster_start().

range()

int range	(	edict_t *	self,
		edict_t *	other
	)

Definition at line 264 of file g_ai.c.

{
    vec3_t  v;
    float   len;
 
    VectorSubtract (self->s.origin, other->s.origin, v);
    len = VectorLength (v);
    if (len < MELEE_DISTANCE)
        return RANGE_MELEE;
    if (len < 500)
        return RANGE_NEAR;
    if (len < 1000)
        return RANGE_MID;
    return RANGE_FAR;
}

Referenced by ai_checkattack(), and FindTarget().

visible()

qboolean visible	(	edict_t *	self,
		edict_t *	other
	)

Definition at line 287 of file g_ai.c.

{
    vec3_t  spot1;
    vec3_t  spot2;
    trace_t trace;
 
    VectorCopy (self->s.origin, spot1);
    spot1[2] += self->viewheight;
    VectorCopy (other->s.origin, spot2);
    spot2[2] += other->viewheight;
    trace = gi.trace (spot1, vec3_origin, vec3_origin, spot2, self, MASK_OPAQUE);
    
    if (trace.fraction == 1.0)
        return true;
    return false;
}

Referenced by ai_checkattack(), chick_rerocket(), ClientBeginServerFrame(), FindTarget(), gunner_refire_chain(), hover_reattack(), jorg_reattack1(), M_ReactToDamage(), medic_continue(), medic_FindDeadMonster(), PlayerTrail_PickFirst(), supertank_reattack1(), tank_reattack_blaster(), tank_refire_rocket(), and turret_driver_think().

Variable Documentation

enemy_infront

qboolean enemy_infront

Definition at line 30 of file g_ai.c.

Referenced by ai_checkattack(), Boss2_CheckAttack(), Jorg_CheckAttack(), and Makron_CheckAttack().

enemy_range

int enemy_range

Definition at line 31 of file g_ai.c.

Referenced by ai_checkattack(), Boss2_CheckAttack(), Jorg_CheckAttack(), M_CheckAttack(), and Makron_CheckAttack().

enemy_vis

qboolean enemy_vis

Definition at line 29 of file g_ai.c.

Referenced by ai_checkattack(), and ai_run().

enemy_yaw

float enemy_yaw

Definition at line 32 of file g_ai.c.

Referenced by ai_checkattack(), ai_run_melee(), ai_run_missile(), ai_run_slide(), Boss2_CheckAttack(), Jorg_CheckAttack(), and Makron_CheckAttack().

maxclients

cvar_t* maxclients

Definition at line 44 of file g_main.c.

Referenced by BeginIntermission(), ChaseNext(), ChasePrev(), ClientConnect(), ClientThink(), Cmd_PlayerList_f(), Cmd_Players_f(), CopyToBodyQue(), G_CheckChaseStats(), G_FreeEdict(), G_Spawn(), GetChaseTarget(), InitGame(), PF_centerprintf(), PF_cprintf(), PF_Unicast(), PlayersRangeFromSpot(), ReadLevel(), SP_worldspawn(), spectator_respawn(), StartServerActionFunc(), SV_EmitPacketEntities(), SV_GameMap_f(), SV_InitGame(), SV_Savegame_f(), SV_SetPlayer(), and SV_SpawnServer().