mirror of
https://github.com/blendogames/thirtyflightsofloving.git
synced 2024-11-15 00:41:21 +00:00
ed34b3b8ed
Added custom sound support to func_door_secret2 in missionpack DLL. Changed missionpack DLL to use maptype_t enum in level_locals_t instead of constantly calling utility functions which contain multiple string compares.
2217 lines
56 KiB
C
2217 lines
56 KiB
C
// g_ai.c
|
|
|
|
#include "g_local.h"
|
|
|
|
qboolean FindTarget (edict_t *self);
|
|
extern cvar_t *maxclients;
|
|
//float min (float a, float b);
|
|
qboolean ai_checkattack (edict_t *self, float dist);
|
|
|
|
qboolean enemy_vis;
|
|
qboolean enemy_infront;
|
|
int enemy_range;
|
|
float enemy_yaw;
|
|
|
|
// ROGUE STUFF
|
|
#define SLIDING_TROOPS 1
|
|
#define MAX_SIDESTEP 8.0
|
|
//
|
|
|
|
//============================================================================
|
|
|
|
|
|
/*
|
|
=================
|
|
AI_SetSightClient
|
|
|
|
Called once each frame to set level.sight_client to the
|
|
player to be checked for in findtarget.
|
|
|
|
If all clients are either dead or in notarget, sight_client
|
|
will be null.
|
|
|
|
In coop games, sight_client will cycle between the clients.
|
|
=================
|
|
*/
|
|
void AI_SetSightClient (void)
|
|
{
|
|
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|FL_DISGUISED)) )
|
|
{
|
|
// If player is using func_monitor, make
|
|
// the sight_client = the fake player at the
|
|
// monitor currently taking the player's place.
|
|
// Do NOT do this for players using a
|
|
// target_monitor, though... in this case
|
|
// both player and fake player are ignored.
|
|
if (ent->client && ent->client->camplayer)
|
|
{
|
|
if (ent->client->spycam)
|
|
{
|
|
level.sight_client = ent->client->camplayer;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.sight_client = ent;
|
|
return; // got one
|
|
}
|
|
}
|
|
if (check == start)
|
|
{
|
|
level.sight_client = NULL;
|
|
return; // nobody to see
|
|
}
|
|
}
|
|
}
|
|
|
|
//============================================================================
|
|
|
|
/*
|
|
=============
|
|
ai_move
|
|
|
|
Move the specified distance at current facing.
|
|
This replaces the QC functions: ai_forward, ai_back, ai_pain, and ai_painforward
|
|
==============
|
|
*/
|
|
void ai_move (edict_t *self, float dist)
|
|
{
|
|
M_walkmove (self, self->s.angles[YAW], dist);
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
ai_stand
|
|
|
|
Used for standing around and looking for players
|
|
Distance is for slight position adjustments needed by the animations
|
|
==============
|
|
*/
|
|
void ai_stand (edict_t *self, float dist)
|
|
{
|
|
vec3_t v;
|
|
// PMM
|
|
qboolean retval;
|
|
|
|
if (dist)
|
|
M_walkmove (self, self->s.angles[YAW], dist);
|
|
|
|
if (self->monsterinfo.aiflags & AI_FOLLOW_LEADER)
|
|
{
|
|
if (!self->enemy || !self->enemy->inuse)
|
|
{
|
|
self->movetarget = self->goalentity = self->monsterinfo.leader;
|
|
self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND);
|
|
self->monsterinfo.pausetime = 0;
|
|
}
|
|
}
|
|
|
|
if ( (self->monsterinfo.aiflags & AI_CHICKEN) )
|
|
{
|
|
if ( (level.framenum - self->monsterinfo.chicken_framenum > 200) ||
|
|
(self->enemy && (self->enemy->last_attacked_framenum > level.framenum - 2) ) )
|
|
{
|
|
self->monsterinfo.aiflags &= ~(AI_CHICKEN | AI_STAND_GROUND);
|
|
self->monsterinfo.pausetime = 0;
|
|
if (self->enemy)
|
|
FoundTarget(self);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
M_ChangeYaw (self);
|
|
// PMM
|
|
// find out if we're going to be shooting
|
|
retval = ai_checkattack (self, 0);
|
|
// record sightings of player
|
|
if ((self->enemy) && (self->enemy->inuse) && (visible(self, self->enemy)))
|
|
{
|
|
self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting);
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.blind_fire_target);
|
|
self->monsterinfo.trail_time = level.time;
|
|
self->monsterinfo.blind_fire_delay = 0;
|
|
}
|
|
// check retval to make sure we're not blindfiring
|
|
else if (!retval)
|
|
{
|
|
FindTarget (self);
|
|
return;
|
|
}
|
|
// ai_checkattack (self, 0);
|
|
// pmm
|
|
}
|
|
else
|
|
FindTarget (self);
|
|
return;
|
|
}
|
|
|
|
if (FindTarget (self))
|
|
return;
|
|
|
|
if (level.time > self->monsterinfo.pausetime)
|
|
{
|
|
// Lazarus: Solve problem of monsters pausing at path_corners, taking off in
|
|
// original direction
|
|
if (self->enemy && self->enemy->inuse)
|
|
VectorSubtract (self->enemy->s.origin, self->s.origin, v);
|
|
else if (self->goalentity)
|
|
VectorSubtract (self->goalentity->s.origin, self->s.origin, v);
|
|
else {
|
|
self->monsterinfo.pausetime = level.time + random() * 15;
|
|
return;
|
|
}
|
|
self->ideal_yaw = vectoyaw (v);
|
|
|
|
// Lazarus: Let misc_actors who are following their leader RUN even when not mad
|
|
if ( (self->monsterinfo.aiflags & AI_FOLLOW_LEADER) && (self->movetarget) &&
|
|
(self->movetarget->inuse) )
|
|
{
|
|
float R;
|
|
R = realrange(self,self->movetarget);
|
|
if (R > ACTOR_FOLLOW_RUN_RANGE)
|
|
self->monsterinfo.run (self);
|
|
else if (R > ACTOR_FOLLOW_STAND_RANGE || !self->movetarget->client)
|
|
self->monsterinfo.walk (self);
|
|
}
|
|
else
|
|
self->monsterinfo.walk (self);
|
|
return;
|
|
}
|
|
|
|
if (!(self->spawnflags & SF_MONSTER_SIGHT) && (self->monsterinfo.idle) && (level.time > self->monsterinfo.idle_time))
|
|
{
|
|
if (self->monsterinfo.aiflags & AI_MEDIC)
|
|
abortHeal(self,false, false, false);
|
|
|
|
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_walk
|
|
|
|
The monster is walking it's beat
|
|
=============
|
|
*/
|
|
void ai_walk (edict_t *self, float dist)
|
|
{
|
|
|
|
// Lazarus: If we're following the leader and have no enemy, run to him
|
|
if ((!self->enemy) && (self->monsterinfo.aiflags & AI_FOLLOW_LEADER))
|
|
self->movetarget = self->goalentity = self->monsterinfo.leader;
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
ai_charge
|
|
|
|
Turns towards target and advances
|
|
Use this call with a distance of 0 to replace ai_face
|
|
==============
|
|
*/
|
|
void ai_charge (edict_t *self, float dist)
|
|
{
|
|
vec3_t v;
|
|
// PMM
|
|
float ofs;
|
|
// PMM
|
|
|
|
// PMM - made AI_MANUAL_STEERING affect things differently here .. they turn, but
|
|
// don't set the ideal_yaw
|
|
|
|
// Zaero add
|
|
if (self->monsterinfo.aiflags2 & AI2_ONESHOTTARGET)
|
|
{
|
|
VectorSubtract (self->monsterinfo.shottarget, self->s.origin, v);
|
|
}
|
|
// end Zaero
|
|
|
|
// This is put in there so monsters won't move towards the origin after killing
|
|
// a tesla. This could be problematic, so keep an eye on it.
|
|
if (!self->enemy || !self->enemy->inuse) //PGM
|
|
return; //PGM
|
|
|
|
// PMM - save blindfire target
|
|
if (visible(self, self->enemy))
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.blind_fire_target);
|
|
// pmm
|
|
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
{
|
|
VectorSubtract (self->enemy->s.origin, self->s.origin, v);
|
|
self->ideal_yaw = vectoyaw(v);
|
|
// gi.dprintf ("enemy = %s\n", vtos (self->enemy->s.origin));
|
|
// gi.dprintf ("enemy: ideal yaw is %f\n", self->ideal_yaw);
|
|
}
|
|
// if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
M_ChangeYaw (self);
|
|
// PMM
|
|
// if (dist)
|
|
// M_walkmove (self, self->s.angles[YAW], dist);
|
|
|
|
if (dist)
|
|
{
|
|
if (self->monsterinfo.aiflags & AI_CHARGING)
|
|
{
|
|
M_MoveToGoal (self, dist);
|
|
return;
|
|
}
|
|
// circle strafe support
|
|
if (self->monsterinfo.attack_state == AS_SLIDING)
|
|
{
|
|
// if we're fighting a tesla, NEVER circle strafe
|
|
if ((self->enemy) && (self->enemy->classname) && (!strcmp(self->enemy->classname, "tesla")))
|
|
ofs = 0;
|
|
else if (self->monsterinfo.lefty)
|
|
ofs = 90;
|
|
else
|
|
ofs = -90;
|
|
|
|
if (M_walkmove (self, self->ideal_yaw + ofs, dist))
|
|
return;
|
|
|
|
self->monsterinfo.lefty = 1 - self->monsterinfo.lefty;
|
|
M_walkmove (self, self->ideal_yaw - ofs, dist);
|
|
}
|
|
else
|
|
M_walkmove (self, self->s.angles[YAW], dist);
|
|
}
|
|
// PMM
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
ai_turn
|
|
|
|
don't move, but turn towards ideal_yaw
|
|
Distance is for slight position adjustments needed by the animations
|
|
=============
|
|
*/
|
|
void ai_turn (edict_t *self, float dist)
|
|
{
|
|
if (dist)
|
|
M_walkmove (self, self->s.angles[YAW], dist);
|
|
|
|
if (FindTarget (self))
|
|
return;
|
|
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
M_ChangeYaw (self);
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
.enemy
|
|
Will be world if not currently angry at anyone.
|
|
|
|
.movetarget
|
|
The next path spot to walk toward. If .enemy, ignore .movetarget.
|
|
When an enemy is killed, the monster will try to return to it's path.
|
|
|
|
.hunt_time
|
|
Set to time + something when the player is in sight, but movement straight for
|
|
him is blocked. This causes the monster to use wall following code for
|
|
movement direction instead of sighting on the player.
|
|
|
|
.ideal_yaw
|
|
A yaw angle of the intended direction, which will be turned towards at up
|
|
to 45 deg / state. If the enemy is in view and hunt_time is not active,
|
|
this will be the exact line towards the enemy.
|
|
|
|
.pausetime
|
|
A monster will leave it's stand state and head towards it's .movetarget when
|
|
time > .pausetime.
|
|
|
|
walkmove(angle, speed) primitive is all or nothing
|
|
*/
|
|
|
|
/*
|
|
=============
|
|
range
|
|
|
|
returns the range catagorization of an entity reletive to self
|
|
0 melee range, will become hostile even if back is turned
|
|
1 visibility and infront, or visibility and show hostile
|
|
2 infront and show hostile
|
|
3 only triggered by damage
|
|
=============
|
|
*/
|
|
int range (edict_t *self, edict_t *other)
|
|
{
|
|
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 < self->monsterinfo.max_range)
|
|
return RANGE_MID;
|
|
return RANGE_FAR;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
visible
|
|
|
|
returns 1 if the entity is visible to self, even if not infront ()
|
|
=============
|
|
*/
|
|
qboolean visible (edict_t *self, edict_t *other)
|
|
{
|
|
vec3_t spot1;
|
|
vec3_t spot2;
|
|
trace_t trace;
|
|
|
|
// Zaero add
|
|
// Monsters blinded by flare can't see anything!
|
|
if (self->monsterinfo.flashTime > 0)
|
|
return false;
|
|
// end Zaero
|
|
|
|
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);
|
|
|
|
// Lazarus: Take fog into account for monsters
|
|
|
|
if ( (trace.fraction == 1.0) || (trace.ent == other))
|
|
{
|
|
if ( (level.active_fog) && (self->svflags & SVF_MONSTER) )
|
|
{
|
|
fog_t *pfog;
|
|
float r;
|
|
float dw;
|
|
vec3_t v;
|
|
|
|
pfog = &level.current_fog;
|
|
VectorSubtract(spot2,spot1,v);
|
|
r = VectorLength(v);
|
|
switch (pfog->Model)
|
|
{
|
|
case 1:
|
|
dw = pfog->Density/10000. * r;
|
|
self->monsterinfo.visibility = exp( -dw );
|
|
break;
|
|
case 2:
|
|
dw = pfog->Density/10000. * r;
|
|
self->monsterinfo.visibility = exp( -dw*dw );
|
|
break;
|
|
default:
|
|
if ((r < pfog->Near) || (pfog->Near == pfog->Far))
|
|
self->monsterinfo.visibility = 1.0;
|
|
else if (r > pfog->Far)
|
|
self->monsterinfo.visibility = 0.0;
|
|
else
|
|
self->monsterinfo.visibility = 1.0 - (r - pfog->Near)/(pfog->Far - pfog->Near);
|
|
break;
|
|
}
|
|
// if (developer->value)
|
|
// gi.dprintf("r=%g, vis=%g\n",r,self->monsterinfo.visibility);
|
|
if (self->monsterinfo.visibility < 0.05)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
self->monsterinfo.visibility = 1.0;
|
|
return true;
|
|
}
|
|
}
|
|
if (trace.fraction == 1.0 || trace.ent == other) // PGM
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
=============
|
|
infront
|
|
|
|
returns 1 if the entity is in front (in sight) of self
|
|
=============
|
|
*/
|
|
qboolean infront (edict_t *self, edict_t *other)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
canReach
|
|
|
|
similar to visible, but uses a different mask
|
|
=============
|
|
*/
|
|
qboolean canReach (edict_t *self, edict_t *other)
|
|
{
|
|
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_SHOT|MASK_WATER);
|
|
|
|
if (trace.fraction == 1.0 || trace.ent == other) // PGM
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
//============================================================================
|
|
|
|
void HuntTarget (edict_t *self)
|
|
{
|
|
vec3_t vec;
|
|
|
|
// Lazarus: avert impending disaster
|
|
if (self->monsterinfo.aiflags & AI_DUCKED)
|
|
return;
|
|
|
|
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);
|
|
}
|
|
|
|
void FoundTarget (edict_t *self)
|
|
{
|
|
edict_t *goodguy;
|
|
vec3_t v;
|
|
// trace_t tr;
|
|
|
|
// Lazarus: avert impending disaster
|
|
if (self->monsterinfo.aiflags & AI_DUCKED)
|
|
return;
|
|
|
|
if (self->monsterinfo.aiflags & AI_CHICKEN)
|
|
return;
|
|
|
|
// Lazarus reflections
|
|
// let other monsters see this monster for a while, but not if
|
|
// it's simply a reflection
|
|
if (self->enemy->client && !(self->enemy->flags & FL_REFLECT))
|
|
{
|
|
// if (self->enemy->flags & FL_DISGUISED)
|
|
// {
|
|
// level.disguise_violator = self->enemy;
|
|
// level.disguise_violation_framenum = level.framenum + 5;
|
|
self->enemy->flags &= ~FL_DISGUISED;
|
|
// }
|
|
|
|
level.sight_entity = self;
|
|
level.sight_entity_framenum = level.framenum;
|
|
level.sight_entity->light_level = 128;
|
|
|
|
goodguy = NULL;
|
|
goodguy = G_Find(NULL,FOFS(dmgteam), "player");
|
|
while (goodguy)
|
|
{
|
|
if (goodguy->health > 0)
|
|
{
|
|
if (!goodguy->enemy)
|
|
{
|
|
if (goodguy->monsterinfo.aiflags & AI_ACTOR)
|
|
{
|
|
// Can he see enemy?
|
|
// tr = gi.trace(goodguy->s.origin,vec3_origin,vec3_origin,self->enemy->s.origin,goodguy,MASK_OPAQUE);
|
|
// if (tr.fraction == 1.0)
|
|
if (gi.inPVS(goodguy->s.origin,self->enemy->s.origin))
|
|
{
|
|
goodguy->monsterinfo.aiflags |= AI_FOLLOW_LEADER;
|
|
goodguy->monsterinfo.old_leader = NULL;
|
|
goodguy->monsterinfo.leader = self->enemy;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
goodguy = G_Find(goodguy,FOFS(dmgteam),"player");
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
// PMM
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.blind_fire_target);
|
|
self->monsterinfo.blind_fire_delay = 0;
|
|
// PMM
|
|
|
|
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;
|
|
}
|
|
|
|
// Lazarus: Huh? How come yaw for combattarget isn't set?
|
|
VectorSubtract(self->movetarget->s.origin, self->s.origin, v);
|
|
self->ideal_yaw = vectoyaw(v);
|
|
|
|
// 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!
|
|
// Lazarus: Why, why, why???? This doesn't remove the point_combat, only makes it inaccessible!
|
|
// to other monsters.
|
|
// self->movetarget->targetname = NULL;
|
|
self->monsterinfo.pausetime = 0;
|
|
|
|
// run for it
|
|
self->monsterinfo.run (self);
|
|
}
|
|
|
|
|
|
/*
|
|
===========
|
|
FindTarget
|
|
|
|
Self is currently not attacking anything, so try to find a target
|
|
|
|
Returns TRUE if an enemy was sighted
|
|
|
|
When a player fires a missile, the point of impact becomes a fakeplayer so
|
|
that monsters that see the impact will respond as if they had seen the
|
|
player.
|
|
|
|
To avoid spending too much time, only a single client (or fakeclient) is
|
|
checked each frame. This means multi player games will have slightly
|
|
slower noticing monsters.
|
|
============
|
|
*/
|
|
|
|
qboolean FindTarget (edict_t *self)
|
|
{
|
|
edict_t *client;
|
|
qboolean heardit;
|
|
int r;
|
|
// Lazarus reflections
|
|
edict_t *reflection = NULL;
|
|
edict_t *self_reflection = NULL;
|
|
|
|
// if ((self->monsterinfo.aiflags & AI_CHASE_THING) || (self->monsterinfo.aiflags2 & AI2_HINT_TEST) )
|
|
// return false;
|
|
|
|
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;
|
|
}
|
|
|
|
// Lazarus: Look for monsters
|
|
if (!self->enemy)
|
|
{
|
|
if ( self->monsterinfo.aiflags & AI_FOLLOW_LEADER )
|
|
{
|
|
int i;
|
|
edict_t *e;
|
|
edict_t *best=NULL;
|
|
vec_t dist, best_dist;
|
|
|
|
best_dist = self->monsterinfo.max_range;
|
|
for (i=game.maxclients+1; i<globals.num_edicts; i++)
|
|
{
|
|
e = &g_edicts[i];
|
|
if (!e->inuse)
|
|
continue;
|
|
if (!(e->svflags & SVF_MONSTER))
|
|
continue;
|
|
if (e->svflags & SVF_NOCLIENT)
|
|
continue;
|
|
if (e->solid == SOLID_NOT)
|
|
continue;
|
|
if (e->monsterinfo.aiflags & AI_GOOD_GUY)
|
|
continue;
|
|
if (!visible(self,e))
|
|
continue;
|
|
if ( self->monsterinfo.aiflags & AI_BRUTAL )
|
|
{
|
|
if (e->health <= e->gib_health)
|
|
continue;
|
|
}
|
|
else if (e->health <= 0)
|
|
continue;
|
|
dist = realrange(self,e);
|
|
if (dist < best_dist)
|
|
{
|
|
best_dist = dist;
|
|
best = e;
|
|
}
|
|
}
|
|
if (best)
|
|
{
|
|
self->enemy = best;
|
|
FoundTarget(self);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
else if (level.time < self->monsterinfo.pausetime )
|
|
return false;
|
|
else
|
|
{
|
|
if (!visible (self, self->enemy))
|
|
return false;
|
|
else
|
|
{
|
|
FoundTarget(self);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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 & SF_MONSTER_SIGHT) )
|
|
{
|
|
client = level.sight_entity;
|
|
if (client->enemy == self->enemy) //crashes here
|
|
return false;
|
|
}
|
|
else if (level.disguise_violation_framenum > level.framenum)
|
|
client = level.disguise_violator;
|
|
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 & SF_MONSTER_SIGHT) )
|
|
{
|
|
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 || !client->inuse)
|
|
return false;
|
|
|
|
if (client == self->enemy)
|
|
return true; // JDC false;
|
|
|
|
// Lazarus: Force idle medics to look for dead monsters
|
|
if (!self->enemy && !Q_stricmp(self->classname,"monster_medic"))
|
|
{
|
|
if (medic_FindDeadMonster(self))
|
|
return true;
|
|
}
|
|
|
|
//PMM - hintpath coop fix
|
|
// in coop mode, ignore sounds if we're following a hint_path
|
|
if ((self->monsterinfo.aiflags & AI_HINT_PATH) && (coop) && (coop->value))
|
|
{
|
|
// if ((heardit) && (g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf ("ignoring coop sound target\n");
|
|
heardit = false;
|
|
}
|
|
// PMM
|
|
|
|
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)
|
|
{
|
|
// PGM - a little more paranoia won't hurt....
|
|
if ((client->owner) && (client->owner->flags & FL_NOTARGET))
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
|
|
// Lazarus reflections
|
|
if (level.num_reflectors)
|
|
{
|
|
int i;
|
|
edict_t *ref;
|
|
|
|
for (i=0; i<6 && !reflection; i++)
|
|
{
|
|
ref = client->reflection[i];
|
|
if (ref && visible(self,ref) && infront(self,ref))
|
|
{
|
|
reflection = ref;
|
|
self_reflection = self->reflection[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
// Lazarus reflections
|
|
vec3_t temp;
|
|
|
|
if (!reflection)
|
|
return false;
|
|
|
|
self->goalentity = self->movetarget = reflection;
|
|
VectorSubtract(reflection->s.origin,self->s.origin,temp);
|
|
self->ideal_yaw = vectoyaw(temp);
|
|
M_ChangeYaw (self);
|
|
// If MORON (=4) is set, then the reflection becomes the
|
|
// enemy. Otherwise if DUMMY (=8) is set, reflection
|
|
// becomes the enemy ONLY if the monster cannot see his
|
|
// own reflection in the same mirror. And if neither situation
|
|
// applies, then reflection is treated identically
|
|
// to a player noise.
|
|
// Don't do the MORON/DUMMY bit if SF_MONSTER_KNOWS_MIRRORS
|
|
// is set (set automatically for melee-only monsters, and
|
|
// turned on once other monsters have figured out the truth)
|
|
if (!(self->spawnflags & SF_MONSTER_KNOWS_MIRRORS))
|
|
{
|
|
if (reflection->activator->spawnflags & 4)
|
|
{
|
|
self->monsterinfo.attack_state = 0;
|
|
self->enemy = reflection;
|
|
goto got_one;
|
|
}
|
|
if (reflection->activator->spawnflags & 8)
|
|
{
|
|
if (!self_reflection || !visible(self,self_reflection))
|
|
{
|
|
self->monsterinfo.attack_state = 0;
|
|
self->enemy = reflection;
|
|
goto got_one;
|
|
}
|
|
}
|
|
}
|
|
self->monsterinfo.pausetime = 0;
|
|
self->monsterinfo.aiflags &= ~AI_STAND_GROUND;
|
|
self->monsterinfo.run(self);
|
|
return false;
|
|
// end Lazarus reflections
|
|
}
|
|
|
|
// Lazarus reflections
|
|
// Knightmare- commented this out because it causes a crash
|
|
/*if (reflection && !(self->spawnflags & SF_MONSTER_KNOWS_MIRRORS) &&
|
|
!infront(self,client))
|
|
{
|
|
// Client is visible but behind monster.
|
|
// If MORON or DUMMY for the parent func_reflect is set,
|
|
// attack the reflection (in the case of DUMMY, only
|
|
// if monster doesn't see himself in the same mirror)
|
|
if ( (reflection->activator->spawnflags & 4) ||
|
|
( (reflection->activator->spawnflags & 8) &&
|
|
(!self_reflection || !visible(self,self_reflection)) ) ) // crashes here
|
|
{
|
|
vec3_t temp;
|
|
|
|
self->goalentity = self->movetarget = reflection;
|
|
VectorSubtract(reflection->s.origin,self->s.origin,temp);
|
|
self->ideal_yaw = vectoyaw(temp);
|
|
M_ChangeYaw (self);
|
|
self->enemy = reflection;
|
|
goto got_one;
|
|
}
|
|
}*/
|
|
|
|
if (!reflection)
|
|
{
|
|
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;
|
|
|
|
// Skid - No spawnflag check for noise for Q1 monsters - they seem excessively stupid that way
|
|
if ( (self->spawnflags & SF_MONSTER_SIGHT) || (self->flags & FL_Q1_MONSTER) )
|
|
{
|
|
if (!visible (self, client))
|
|
return false;
|
|
}
|
|
else if (!(client->flags & FL_REFLECT)) // Lazarus reflections
|
|
{ // Knightmare- exclude turret drivers from this check
|
|
if (!gi.inPHS(self->s.origin, client->s.origin) && strcmp(self->classname, "turret_driver"))
|
|
return false;
|
|
}
|
|
|
|
VectorSubtract (client->s.origin, self->s.origin, temp);
|
|
|
|
if (VectorLength(temp) > self->monsterinfo.max_range) // too far to hear - was 1000
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// check area portals - if they are different and not connected then we can't hear it
|
|
if (!(client->flags & FL_REFLECT)) // Lazarus reflections
|
|
{
|
|
if (client->areanum != self->areanum) {
|
|
// Skid - Q1 monsters dont hear too far
|
|
if ( (!gi.AreasConnected(self->areanum, client->areanum)) || (self->flags & (FL_Q1_MONSTER)) )
|
|
return false;
|
|
}
|
|
}
|
|
|
|
self->ideal_yaw = vectoyaw(temp);
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
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:
|
|
|
|
//
|
|
// got one
|
|
//
|
|
// PMM - if we got an enemy, we need to bail out of hint paths, so take over here
|
|
if (self->monsterinfo.aiflags & AI_HINT_PATH)
|
|
{
|
|
// if (g_showlogic && g_showlogic->value)
|
|
// gi.dprintf("stopped following hint paths in FindTarget\n");
|
|
|
|
// this calls foundtarget for us
|
|
hintpath_stop (self);
|
|
}
|
|
else if (self->monsterinfo.aiflags & AI_MEDIC_PATROL)
|
|
{
|
|
medic_StopPatrolling (self);
|
|
}
|
|
else
|
|
FoundTarget (self);
|
|
// pmm
|
|
if (!(self->monsterinfo.aiflags & AI_SOUND_TARGET) && (self->monsterinfo.sight))
|
|
self->monsterinfo.sight (self, self->enemy);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
|
|
/*
|
|
============
|
|
FacingIdeal
|
|
============
|
|
*/
|
|
qboolean FacingIdeal(edict_t *self)
|
|
{
|
|
float delta;
|
|
|
|
delta = anglemod(self->s.angles[YAW] - self->ideal_yaw);
|
|
if (delta > 45 && delta < 315)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
#define SOLDIER_LASERGUN_THROUGH_GLASS 32
|
|
|
|
qboolean M_CheckAttack (edict_t *self)
|
|
{
|
|
vec3_t spot1, spot2;
|
|
float chance;
|
|
trace_t tr;
|
|
|
|
// Lazarus: Paranoia check
|
|
if (!self->enemy)
|
|
return false;
|
|
|
|
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;
|
|
|
|
// Knightmare- laser grunts can shoot through glass
|
|
if (!strcmp(self->classname, "monster_soldier_lasergun") && (self->spawnflags & SOLDIER_LASERGUN_THROUGH_GLASS))
|
|
tr = gi.trace (spot1, NULL, NULL, spot2, self, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_SLIME|CONTENTS_LAVA);
|
|
else
|
|
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)
|
|
{
|
|
// Knightmare- Lazarus reflect check would be here
|
|
// if (!(self->enemy->flags & FL_REFLECT))
|
|
// return false;
|
|
// if (tr.ent != world)
|
|
// return false;
|
|
|
|
// PGM - we want them to go ahead and shoot at info_notnulls if they can.
|
|
if ( !(self->enemy->flags & FL_REFLECT) // Knightmare- do the blindfire only if it's not a reflection
|
|
&& (self->enemy->solid != SOLID_NOT || tr.fraction < 1.0) ) // PGM
|
|
{
|
|
// PMM - if we can't see our target, and we're not blocked by a monster, go into blind fire if available
|
|
if ((!(tr.ent->svflags & SVF_MONSTER)) && (!visible(self, self->enemy)))
|
|
{ // Knightmare- disable blindfire for Zaero maps, as it causes undesired behavior in zdef4
|
|
// if ((self->monsterinfo.blindfire) && (self->monsterinfo.blind_fire_delay <= 20.0))
|
|
if ( (level.maptype != MAPTYPE_ZAERO) && (self->monsterinfo.blindfire) && (self->monsterinfo.blind_fire_delay <= 20.0) )
|
|
{
|
|
if (level.time < self->monsterinfo.attack_finished)
|
|
{
|
|
return false;
|
|
}
|
|
if (level.time < (self->monsterinfo.trail_time + self->monsterinfo.blind_fire_delay))
|
|
{
|
|
// wait for our time
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// gi.WriteByte (svc_temp_entity);
|
|
// gi.WriteByte (TE_DEBUGTRAIL);
|
|
// gi.WritePosition (spot1);
|
|
// gi.WritePosition (self->monsterinfo.blind_fire_target);
|
|
// gi.multicast (self->s.origin, MULTICAST_ALL);
|
|
// make sure we're not going to shoot a monster
|
|
tr = gi.trace (spot1, NULL, NULL, self->monsterinfo.blind_fire_target, self, CONTENTS_MONSTER);
|
|
if (tr.allsolid || tr.startsolid || ((tr.fraction < 1.0) && (tr.ent != self->enemy)))
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf ("blindfire blocked\n");
|
|
return false;
|
|
}
|
|
|
|
self->monsterinfo.attack_state = AS_BLIND;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
// pmm
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// melee attack
|
|
if (enemy_range == RANGE_MELEE)
|
|
{
|
|
// don't always melee in easy mode
|
|
if ( (skill->value == 0) && (rand()&3) )
|
|
{
|
|
// PMM - fix for melee only monsters & strafing
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
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)
|
|
{
|
|
// PMM - fix for melee only monsters & strafing
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
return false;
|
|
}
|
|
|
|
if (level.time < self->monsterinfo.attack_finished)
|
|
return false;
|
|
|
|
if (enemy_range == RANGE_FAR)
|
|
return false;
|
|
|
|
// Lazarus reflections
|
|
if (self->enemy->flags & FL_REFLECT)
|
|
{
|
|
// no waiting for reflections - shoot 'em NOW
|
|
chance = 2.0;
|
|
}
|
|
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;
|
|
|
|
// PGM - go ahead and shoot every time if it's a info_notnull
|
|
if ((random () < chance) || (self->enemy->solid == SOLID_NOT))
|
|
{
|
|
self->monsterinfo.attack_state = AS_MISSILE;
|
|
self->monsterinfo.attack_finished = level.time + 2*random();
|
|
return true;
|
|
}
|
|
|
|
// PMM -daedalus should strafe more .. this can be done here or in a customized
|
|
// check_attack code for the hover.
|
|
if (self->flags & FL_FLY)
|
|
{
|
|
// originally, just 0.3
|
|
float strafe_chance;
|
|
if (!(strcmp(self->classname, "monster_daedalus")))
|
|
strafe_chance = 0.8;
|
|
else
|
|
strafe_chance = 0.6;
|
|
|
|
// if enemy is tesla, never strafe
|
|
if ((self->enemy) && (self->enemy->classname) && (!strcmp(self->enemy->classname, "tesla")))
|
|
strafe_chance = 0;
|
|
|
|
if (random() < strafe_chance)
|
|
self->monsterinfo.attack_state = AS_SLIDING;
|
|
else
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
}
|
|
// do we want the monsters strafing?
|
|
#ifdef SLIDING_TROOPS
|
|
else
|
|
{
|
|
if (random() < 0.4)
|
|
self->monsterinfo.attack_state = AS_SLIDING;
|
|
else
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
}
|
|
#endif
|
|
//-PMM
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
ai_run_melee
|
|
|
|
Turn and close until within an angle to launch a melee attack
|
|
=============
|
|
*/
|
|
void ai_run_melee(edict_t *self)
|
|
{
|
|
self->ideal_yaw = enemy_yaw;
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
M_ChangeYaw (self);
|
|
|
|
if (FacingIdeal(self))
|
|
{
|
|
if (self->monsterinfo.melee) // FS: Coop: Crash from m_insane when hit by another enemy. Problem on SGC11-3.BSP
|
|
self->monsterinfo.melee (self);
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
ai_run_missile
|
|
|
|
Turn in place until within an angle to launch a missile attack
|
|
=============
|
|
*/
|
|
void ai_run_missile(edict_t *self)
|
|
{
|
|
self->ideal_yaw = enemy_yaw;
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
M_ChangeYaw (self);
|
|
|
|
if (FacingIdeal(self))
|
|
{
|
|
if (self->monsterinfo.attack) // FS: Coop: Crash from m_insane when hit by another enemy. Problem on SGC11-3.BSP
|
|
self->monsterinfo.attack (self);
|
|
// if (self->monsterinfo.attack_state == AS_MISSILE)
|
|
if ((self->monsterinfo.attack_state == AS_MISSILE) || (self->monsterinfo.attack_state == AS_BLIND))
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
// else if (self->monsterinfo.attack_state != AS_SLIDING)
|
|
// gi.dprintf ("ai_run_missile: Unexpected attack state %d !\n", self->monsterinfo.attack_state);
|
|
}
|
|
};
|
|
|
|
|
|
/*
|
|
=============
|
|
ai_run_slide
|
|
|
|
Strafe sideways, but stay at aproximately the same range
|
|
=============
|
|
*/
|
|
void ai_run_slide(edict_t *self, float distance)
|
|
{
|
|
float ofs;
|
|
float angle;
|
|
|
|
self->ideal_yaw = enemy_yaw;
|
|
|
|
// if (self->flags & FL_FLY)
|
|
// angle = 90;
|
|
// else
|
|
// angle = 45;
|
|
|
|
angle = 90;
|
|
|
|
if (self->monsterinfo.lefty)
|
|
ofs = angle;
|
|
else
|
|
ofs = -angle;
|
|
//
|
|
// if (!(self->flags & FL_FLY))
|
|
// {
|
|
// // non fliers should actually turn towards the direction their trying to run
|
|
// self->ideal_yaw += ofs;
|
|
// }
|
|
//
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
M_ChangeYaw (self);
|
|
|
|
/*
|
|
if (!(self->flags & FL_FLY))
|
|
{
|
|
if (M_walkmove (self, self->ideal_yaw + ofs, distance))
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (M_walkmove (self, self->ideal_yaw, distance))
|
|
return;
|
|
}
|
|
*/
|
|
// PMM - clamp maximum sideways move for non flyers to make them look less jerky
|
|
if (!self->flags & FL_FLY)
|
|
distance = min (distance, MAX_SIDESTEP);
|
|
if (M_walkmove (self, self->ideal_yaw + ofs, distance))
|
|
return;
|
|
// PMM - if we're dodging, give up on it and go straight
|
|
if (self->monsterinfo.aiflags & AI_DODGING)
|
|
{
|
|
monster_done_dodge (self);
|
|
// by setting as_straight, caller will know to try straight move
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
return;
|
|
}
|
|
|
|
self->monsterinfo.lefty = 1 - self->monsterinfo.lefty;
|
|
if (M_walkmove (self, self->ideal_yaw - ofs, distance))
|
|
return;
|
|
// PMM - if we're dodging, give up on it and go straight
|
|
if (self->monsterinfo.aiflags & AI_DODGING)
|
|
monster_done_dodge (self);
|
|
|
|
// PMM - the move failed, so signal the caller (ai_run) to try going straight
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
/*
|
|
if (!(self->flags & FL_FLY))
|
|
{
|
|
M_walkmove (self, self->ideal_yaw + ofs, distance);
|
|
}
|
|
else
|
|
{
|
|
M_walkmove (self, self->ideal_yaw, distance);
|
|
}*/
|
|
}
|
|
/*
|
|
===========
|
|
min
|
|
returns smaller value
|
|
=============
|
|
*/
|
|
/*float min (float a, float b)
|
|
{
|
|
if (a < b)
|
|
return a;
|
|
if (b < a)
|
|
return b;
|
|
if (a == b)
|
|
return a;
|
|
} */
|
|
/*
|
|
=============
|
|
ai_checkattack
|
|
|
|
Decides if we're going to attack or do something else
|
|
used by ai_run and ai_stand
|
|
=============
|
|
*/
|
|
qboolean ai_checkattack (edict_t *self, float dist)
|
|
{
|
|
vec3_t temp;
|
|
qboolean hesDeadJim;
|
|
// PMM
|
|
qboolean retval;
|
|
|
|
// 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 ( !visible(self, self->goalentity) && (self->monsterinfo.aiflags & AI_SOUND_TARGET) )
|
|
{
|
|
if (self->enemy && (level.time - self->enemy->teleport_time) > 5.0) //mxd. Added self->enemy check
|
|
{
|
|
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->inuse) || (self->enemy->health > 0))
|
|
{
|
|
hesDeadJim = true;
|
|
// self->monsterinfo.aiflags &= ~AI_MEDIC;
|
|
}
|
|
}
|
|
// Lazarus reflections
|
|
else if (self->enemy->flags & FL_REFLECT)
|
|
{
|
|
hesDeadJim = false;
|
|
}
|
|
else
|
|
{
|
|
if (self->monsterinfo.aiflags & AI_BRUTAL)
|
|
{
|
|
// Lazarus: This value should be enemy class-dependent
|
|
//if (self->enemy->health <= -80)
|
|
if (self->enemy->health <= self->enemy->gib_health)
|
|
hesDeadJim = true;
|
|
}
|
|
else
|
|
{
|
|
if (self->enemy->health <= 0)
|
|
hesDeadJim = true;
|
|
}
|
|
}
|
|
|
|
if (hesDeadJim)
|
|
{
|
|
self->monsterinfo.aiflags &= ~AI_MEDIC;
|
|
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);
|
|
}
|
|
//ROGUE - multiple teslas make monsters lose track of the player.
|
|
else if (self->monsterinfo.last_player_enemy && self->monsterinfo.last_player_enemy->health > 0)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf("resorting to last_player_enemy...\n");
|
|
self->enemy = self->monsterinfo.last_player_enemy;
|
|
self->oldenemy = NULL;
|
|
self->monsterinfo.last_player_enemy = NULL;
|
|
HuntTarget (self);
|
|
}
|
|
//ROGUE
|
|
else
|
|
{
|
|
if (self->movetarget)
|
|
{
|
|
self->goalentity = self->movetarget;
|
|
// Lazarus: Let misc_actors who are following their leader RUN even when not mad
|
|
if ( (self->monsterinfo.aiflags & AI_FOLLOW_LEADER) &&
|
|
(self->movetarget) &&
|
|
(self->movetarget->inuse) )
|
|
{
|
|
float R;
|
|
|
|
R = realrange(self,self->movetarget);
|
|
if (R > ACTOR_FOLLOW_RUN_RANGE)
|
|
self->monsterinfo.run (self);
|
|
else if (R > ACTOR_FOLLOW_STAND_RANGE || !self->movetarget->client)
|
|
self->monsterinfo.walk (self);
|
|
else
|
|
{
|
|
self->monsterinfo.pausetime = level.time + 0.5;
|
|
self->monsterinfo.stand (self);
|
|
}
|
|
}
|
|
else
|
|
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);
|
|
// PMM
|
|
self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
|
|
self->monsterinfo.trail_time = level.time;
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.blind_fire_target);
|
|
self->monsterinfo.blind_fire_delay = 0;
|
|
// pmm
|
|
}
|
|
|
|
// look for other coop players here
|
|
// if (coop->value && self->monsterinfo.search_time < level.time)
|
|
// {
|
|
// if (FindTarget (self))
|
|
// return true;
|
|
// }
|
|
|
|
|
|
if (self->monsterinfo.aiflags & AI_CHICKEN)
|
|
{
|
|
if (enemy_vis)
|
|
{
|
|
if (ai_chicken(self,self->enemy))
|
|
return false;
|
|
else
|
|
{
|
|
self->monsterinfo.aiflags &= ~(AI_CHICKEN | AI_STAND_GROUND);
|
|
self->monsterinfo.pausetime = 0;
|
|
FoundTarget(self);
|
|
}
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
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;
|
|
|
|
// PMM -- reordered so the monster specific checkattack is called before the run_missle/melee/checkvis
|
|
// stuff .. this allows for, among other things, circle strafing and attacking while in ai_run
|
|
|
|
|
|
retval = self->monsterinfo.checkattack (self);
|
|
if (retval)
|
|
{
|
|
// PMM
|
|
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;
|
|
}
|
|
// PMM -- added so monsters can shoot blind
|
|
if (self->monsterinfo.attack_state == AS_BLIND)
|
|
{
|
|
ai_run_missile (self);
|
|
return true;
|
|
}
|
|
// pmm
|
|
|
|
// if enemy is not currently visible, we will never attack
|
|
if (!enemy_vis)
|
|
return false;
|
|
// PMM
|
|
}
|
|
return retval;
|
|
// PMM
|
|
// return self->monsterinfo.checkattack (self);
|
|
}
|
|
|
|
#define HINT_PATH_START_TIME 3
|
|
#define HINT_PATH_RESTART_TIME 5
|
|
|
|
/*
|
|
=============
|
|
ai_run
|
|
|
|
The monster has an enemy it is trying to kill
|
|
=============
|
|
*/
|
|
void ai_run (edict_t *self, float dist)
|
|
{
|
|
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;
|
|
//PMM
|
|
qboolean retval;
|
|
qboolean alreadyMoved = false;
|
|
qboolean gotcha = false;
|
|
edict_t *realEnemy;
|
|
|
|
// Zaero add
|
|
// Monsters try to run away from flares
|
|
if (self->monsterinfo.flashTime > 0)
|
|
{
|
|
M_MoveAwayFromFlare (self, dist);
|
|
return;
|
|
}
|
|
// end Zaero
|
|
|
|
// if we're going to a combat point, just proceed
|
|
if (self->monsterinfo.aiflags & (AI_COMBAT_POINT | AI_CHASE_THING))
|
|
{
|
|
M_MoveToGoal (self, dist);
|
|
return;
|
|
}
|
|
if ( self->monsterinfo.aiflags & AI_MEDIC_PATROL )
|
|
{
|
|
if (!FindTarget(self))
|
|
{
|
|
M_MoveToGoal(self,dist);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// PMM
|
|
if (self->monsterinfo.aiflags & AI_DUCKED)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf ("%s - duck flag cleaned up!\n", self->classname);
|
|
self->monsterinfo.aiflags &= ~AI_DUCKED;
|
|
}
|
|
if (self->maxs[2] != self->monsterinfo.base_height)
|
|
{
|
|
// if ((g_showlogic) && (g_showlogic->value))
|
|
// gi.dprintf ("%s - ducked height corrected!\n", self->classname);
|
|
monster_duck_up (self);
|
|
}
|
|
|
|
/* if ((self->monsterinfo.aiflags & AI_MANUAL_STEERING) && (strcmp(self->classname, "monster_turret")))
|
|
{
|
|
if ((g_showlogic) && (g_showlogic->value))
|
|
gi.dprintf ("%s - manual steering in ai_run!\n", self->classname);
|
|
}*/
|
|
// pmm
|
|
|
|
|
|
// Lazarus reflections
|
|
// If currently mad at a reflection, AND we've already shot at it once, set
|
|
// flag indicating that this monster got suddenly smarter about mirrors, and
|
|
// turn him on the real enemy
|
|
if (self->enemy && (self->enemy->flags & FL_REFLECT))
|
|
{
|
|
if ( (self->enemy->last_attacked_framenum > 0) &&
|
|
(self->enemy->last_attacked_framenum < level.framenum-5) )
|
|
{
|
|
self->enemy->last_attacked_framenum = 0;
|
|
self->spawnflags |= SF_MONSTER_KNOWS_MIRRORS;
|
|
self->enemy = self->enemy->owner;
|
|
self->movetarget = self->goalentity = self->enemy;
|
|
VectorSubtract(self->enemy->s.origin,self->s.origin,v);
|
|
self->ideal_yaw = vectoyaw(v);
|
|
if (!alreadyMoved)
|
|
M_MoveToGoal(self,dist);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Lazarus: If running at a reflection, go ahead, until source of reflection
|
|
// is visible
|
|
if (!self->enemy && self->movetarget && (self->movetarget->flags & FL_REFLECT))
|
|
{
|
|
if (!visible(self,self->movetarget->owner))
|
|
{
|
|
M_MoveToGoal(self,dist);
|
|
return;
|
|
}
|
|
}
|
|
// end Lazarus reflections
|
|
|
|
// Lazarus: If we're following the leader and have no enemy, go ahead
|
|
if ((!self->enemy) && (self->monsterinfo.aiflags & AI_FOLLOW_LEADER))
|
|
{
|
|
self->movetarget = self->goalentity = self->monsterinfo.leader;
|
|
if (!self->movetarget)
|
|
{
|
|
self->monsterinfo.pausetime = level.time + 2;
|
|
self->monsterinfo.stand(self);
|
|
return;
|
|
}
|
|
self->monsterinfo.aiflags &= ~(AI_STAND_GROUND | AI_TEMP_STAND_GROUND);
|
|
self->monsterinfo.pausetime = 0;
|
|
M_MoveToGoal (self, dist);
|
|
return;
|
|
}
|
|
//==========
|
|
//PGM
|
|
// if we're currently looking for a hint path
|
|
if (self->monsterinfo.aiflags & AI_HINT_PATH)
|
|
{
|
|
// determine direction to our destination hintpath.
|
|
// FIXME - is this needed EVERY time? I was having trouble with them
|
|
// sometimes not going after it, and this fixed it.
|
|
// VectorSubtract(self->movetarget->s.origin, self->s.origin, v);
|
|
// vectoangles(v, v_forward);
|
|
// self->ideal_yaw = v_forward[YAW];
|
|
// gi.dprintf("seeking hintpath. origin: %s %0.1f\n", vtos(v), self->ideal_yaw);
|
|
M_MoveToGoal (self, dist);
|
|
if (!self->inuse)
|
|
return; // PGM - g_touchtrigger free problem
|
|
// return;
|
|
|
|
// if we've already seen the player, and can't see him now, return
|
|
// if (self->enemy && !visible(self, self->enemy))
|
|
// return;
|
|
|
|
// if not and can't find the player, return
|
|
// if (!FindTarget(self))
|
|
// return;
|
|
|
|
// first off, make sure we're looking for the player, not a noise he made
|
|
if (self->enemy)
|
|
{
|
|
if (self->enemy->inuse)
|
|
{
|
|
if (strcmp(self->enemy->classname, "player_noise") != 0)
|
|
realEnemy = self->enemy;
|
|
else if (self->enemy->owner)
|
|
realEnemy = self->enemy->owner;
|
|
else // uh oh, can't figure out enemy, bail
|
|
{
|
|
self->enemy = NULL;
|
|
hintpath_stop (self);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self->enemy = NULL;
|
|
hintpath_stop (self);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hintpath_stop (self);
|
|
return;
|
|
}
|
|
|
|
if (coop && coop->value)
|
|
{
|
|
// if we're in coop, check my real enemy first .. if I SEE him, set gotcha to true
|
|
if (self->enemy && visible(self, realEnemy))
|
|
gotcha = true;
|
|
else // otherwise, let FindTarget bump us out of hint paths, if appropriate
|
|
FindTarget(self);
|
|
}
|
|
else
|
|
{
|
|
if (self->enemy && visible(self, realEnemy))
|
|
gotcha = true;
|
|
}
|
|
|
|
// if we see the player, stop following hintpaths.
|
|
if (gotcha)
|
|
{
|
|
// if (g_showlogic && g_showlogic->value)
|
|
// gi.dprintf("stopped following hint paths in ai_run\n");
|
|
|
|
// disconnect from hintpaths and start looking normally for players.
|
|
hintpath_stop (self);
|
|
// pmm - no longer needed, since hintpath_stop does it
|
|
// HuntTarget(self);
|
|
}
|
|
return;
|
|
}
|
|
//PGM
|
|
//==========
|
|
|
|
if (self->monsterinfo.aiflags & AI_SOUND_TARGET)
|
|
{
|
|
// PMM - paranoia checking
|
|
if (self->enemy)
|
|
VectorSubtract (self->s.origin, self->enemy->s.origin, v);
|
|
|
|
if ((!self->enemy) || (VectorLength(v) < 64))
|
|
// pmm
|
|
{
|
|
self->monsterinfo.aiflags |= (AI_STAND_GROUND | AI_TEMP_STAND_GROUND);
|
|
self->monsterinfo.stand (self);
|
|
return;
|
|
}
|
|
|
|
M_MoveToGoal (self, dist);
|
|
// PMM - prevent double moves for sound_targets
|
|
alreadyMoved = true;
|
|
// pmm
|
|
if (!self->inuse)
|
|
return; // PGM - g_touchtrigger free problem
|
|
|
|
if (!FindTarget (self))
|
|
return;
|
|
}
|
|
|
|
// PMM -- moved ai_checkattack up here so the monsters can attack while strafing or charging
|
|
|
|
// PMM -- if we're dodging, make sure to keep the attack_state AS_SLIDING
|
|
|
|
retval = ai_checkattack (self, dist);
|
|
|
|
// Knightmare- hack to fix actors not attacking monsters
|
|
// Thanx to Yuri for pointing this out
|
|
if (!strcmp(self->classname, "misc_actor") && retval)
|
|
return;
|
|
|
|
// PMM - don't strafe if we can't see our enemy
|
|
if ((!enemy_vis) && (self->monsterinfo.attack_state == AS_SLIDING))
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
// unless we're dodging (dodging out of view looks smart)
|
|
if (self->monsterinfo.aiflags & AI_DODGING)
|
|
self->monsterinfo.attack_state = AS_SLIDING;
|
|
// pmm
|
|
|
|
if (self->monsterinfo.attack_state == AS_SLIDING)
|
|
{
|
|
// PMM - protect against double moves
|
|
if (!alreadyMoved)
|
|
ai_run_slide (self, dist);
|
|
// PMM
|
|
// we're using attack_state as the return value out of ai_run_slide to indicate whether or not the
|
|
// move succeeded. If the move succeeded, and we're still sliding, we're done in here (since we've
|
|
// had our chance to shoot in ai_checkattack, and have moved).
|
|
// if the move failed, our state is as_straight, and it will be taken care of below
|
|
if ((!retval) && (self->monsterinfo.attack_state == AS_SLIDING))
|
|
return;
|
|
}
|
|
else if (self->monsterinfo.aiflags & AI_CHARGING)
|
|
{
|
|
self->ideal_yaw = enemy_yaw;
|
|
if (!(self->monsterinfo.aiflags & AI_MANUAL_STEERING))
|
|
M_ChangeYaw (self);
|
|
}
|
|
if (retval)
|
|
{
|
|
// PMM - is this useful? Monsters attacking usually call the ai_charge routine..
|
|
// the only monster this affects should be the soldier
|
|
if ((dist != 0) && (!alreadyMoved) && (self->monsterinfo.attack_state == AS_STRAIGHT) && (!(self->monsterinfo.aiflags & AI_STAND_GROUND)))
|
|
{
|
|
M_MoveToGoal (self, dist);
|
|
}
|
|
if ((self->enemy) && (self->enemy->inuse) && (enemy_vis))
|
|
{
|
|
self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting);
|
|
self->monsterinfo.trail_time = level.time;
|
|
//PMM
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.blind_fire_target);
|
|
self->monsterinfo.blind_fire_delay = 0;
|
|
//pmm
|
|
}
|
|
return;
|
|
}
|
|
//PMM
|
|
// if (ai_checkattack (self, dist))
|
|
// return;
|
|
|
|
// if (self->monsterinfo.attack_state == AS_SLIDING)
|
|
// {
|
|
// ai_run_slide (self, dist);
|
|
// return;
|
|
// }
|
|
|
|
// PGM - added a little paranoia checking here... 9/22/98
|
|
if ((self->enemy) && (self->enemy->inuse) && (enemy_vis))
|
|
{
|
|
// if (self->monsterinfo.aiflags & AI_LOST_SIGHT)
|
|
// gi.dprintf("regained sight\n");
|
|
// PMM - check for alreadyMoved
|
|
if (!alreadyMoved)
|
|
M_MoveToGoal (self, dist);
|
|
if (!self->inuse)
|
|
return; // PGM - g_touchtrigger free problem
|
|
|
|
self->monsterinfo.aiflags &= ~AI_LOST_SIGHT;
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.last_sighting);
|
|
self->monsterinfo.trail_time = level.time;
|
|
// PMM
|
|
VectorCopy (self->enemy->s.origin, self->monsterinfo.blind_fire_target);
|
|
self->monsterinfo.blind_fire_delay = 0;
|
|
// pmm
|
|
return;
|
|
}
|
|
|
|
//=======
|
|
//PGM
|
|
// if we've been looking (unsuccessfully) for the player for 10 seconds
|
|
// PMM - reduced to 5, makes them much nastier
|
|
if ((self->monsterinfo.trail_time + 5) <= level.time)
|
|
{
|
|
// and we haven't checked for valid hint paths in the last 10 seconds
|
|
if ((self->monsterinfo.last_hint_time + 10) <= level.time)
|
|
{
|
|
// check for hint_paths.
|
|
self->monsterinfo.last_hint_time = level.time;
|
|
if (monsterlost_checkhint(self))
|
|
return;
|
|
}
|
|
}
|
|
//PGM
|
|
//=======
|
|
|
|
// PMM - moved down here to allow monsters to get on hint paths
|
|
// 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;
|
|
}
|
|
// pmm
|
|
|
|
if ((self->monsterinfo.search_time) && (level.time > (self->monsterinfo.search_time + 20)))
|
|
{
|
|
// PMM - double move protection
|
|
if (!alreadyMoved)
|
|
M_MoveToGoal (self, dist);
|
|
self->monsterinfo.search_time = 0;
|
|
// gi.dprintf("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
|
|
// gi.dprintf("lost sight of player, last seen at %s\n", vtos(self->monsterinfo.last_sighting));
|
|
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)
|
|
{
|
|
// vec3_t debug_vec;
|
|
|
|
self->monsterinfo.aiflags &= ~AI_PURSUE_NEXT;
|
|
// VectorSubtract(self->monsterinfo.last_sighting, self->s.origin, debug_vec);
|
|
// gi.dprintf("reached current goal: %s %s %f", vtos(self->s.origin), vtos(self->monsterinfo.last_sighting), VectorLength(debug_vec));
|
|
|
|
// give ourself more time since we got this far
|
|
self->monsterinfo.search_time = level.time + 5;
|
|
|
|
if (self->monsterinfo.aiflags & AI_PURSUE_TEMP)
|
|
{
|
|
// gi.dprintf("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];
|
|
// gi.dprintf("heading is %0.1f\n", self->ideal_yaw);
|
|
|
|
// 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);
|
|
if (!self->inuse)
|
|
return; // PGM - g_touchtrigger free problem
|
|
|
|
G_FreeEdict(tempgoal);
|
|
|
|
if (self)
|
|
self->goalentity = save;
|
|
}
|
|
|
|
static int chase_angle[] = {270,450,225,495,540};
|
|
qboolean ai_chicken (edict_t *self, edict_t *badguy)
|
|
{
|
|
int i;
|
|
edict_t *thing;
|
|
vec3_t atk, dir, best_dir, end, forward;
|
|
vec_t travel, yaw;
|
|
vec3_t mins, maxs;
|
|
vec3_t testpos;
|
|
vec_t best_dist=0;
|
|
trace_t trace1, trace2;
|
|
|
|
// No point in hiding from attacker if he's gone
|
|
if (!badguy || !badguy->inuse)
|
|
return false;
|
|
|
|
if (!self || !self->inuse || (self->health <= 0))
|
|
return false;
|
|
|
|
if (!actorchicken->value)
|
|
return false;
|
|
|
|
// If we've already been here, quit
|
|
if (self->monsterinfo.aiflags & AI_CHICKEN)
|
|
{
|
|
if (self->movetarget && !Q_stricmp(self->movetarget->classname,"thing"))
|
|
return true;
|
|
}
|
|
|
|
VectorCopy(self->mins,mins);
|
|
mins[2] += 18;
|
|
if (mins[2] > 0) mins[2] = 0;
|
|
VectorCopy(self->maxs,maxs);
|
|
|
|
// Find a vector that will hide the actor from his enemy
|
|
VectorCopy(badguy->s.origin,atk);
|
|
atk[2] += badguy->viewheight;
|
|
VectorClear(best_dir);
|
|
AngleVectors(self->s.angles,forward,NULL,NULL);
|
|
dir[2] = 0;
|
|
for (travel=512; travel>63 && best_dist == 0; travel /= 2)
|
|
{
|
|
for (i=0; i<5 && best_dist == 0; i++)
|
|
{
|
|
yaw = self->s.angles[YAW] + chase_angle[i];
|
|
yaw = (int)(yaw/45)*45;
|
|
yaw = anglemod(yaw);
|
|
yaw *= M_PI/180;
|
|
dir[0] = cos(yaw);
|
|
dir[1] = sin(yaw);
|
|
VectorMA(self->s.origin,travel,dir,end);
|
|
trace1 = gi.trace(self->s.origin,mins,maxs,end,self,MASK_MONSTERSOLID);
|
|
// Test whether proposed position can be seen by badguy. Test
|
|
// isn't foolproof - tests against 1) new origin, 2) new origin + maxs,
|
|
// 3) new origin + mins, and 4) new origin + min x,y, max z.
|
|
trace2 = gi.trace(trace1.endpos,NULL,NULL,atk,self,MASK_SOLID);
|
|
if (trace2.fraction == 1.0) continue;
|
|
|
|
VectorAdd(trace1.endpos,self->maxs,testpos);
|
|
trace2 = gi.trace(testpos,NULL,NULL,atk,self,MASK_SOLID);
|
|
if (trace2.fraction == 1.0) continue;
|
|
|
|
VectorAdd(trace1.endpos,self->mins,testpos);
|
|
trace2 = gi.trace(testpos,NULL,NULL,atk,self,MASK_SOLID);
|
|
if (trace2.fraction == 1.0) continue;
|
|
|
|
testpos[2] = trace1.endpos[2] + self->maxs[2];
|
|
trace2 = gi.trace(testpos,NULL,NULL,atk,self,MASK_SOLID);
|
|
if (trace2.fraction == 1.0) continue;
|
|
|
|
best_dist = trace1.fraction * travel;
|
|
if (best_dist < 32) // not much point to this move
|
|
continue;
|
|
VectorCopy(dir,best_dir);
|
|
}
|
|
}
|
|
return false;
|
|
|
|
if (best_dist < 32)
|
|
return false;
|
|
|
|
// This snaps the angles, which may not be all that good but it sure
|
|
// is quicker than turning in place
|
|
vectoangles(best_dir,self->s.angles);
|
|
thing = SpawnThing();
|
|
VectorMA(self->s.origin,best_dist,best_dir,thing->s.origin);
|
|
thing->touch_debounce_time = level.time + 3.0;
|
|
thing->target_ent = self;
|
|
ED_CallSpawn(thing);
|
|
self->movetarget = self->goalentity = thing;
|
|
self->monsterinfo.aiflags &= ~(AI_SOUND_TARGET | AI_STAND_GROUND | AI_TEMP_STAND_GROUND);
|
|
self->monsterinfo.pausetime = 0;
|
|
self->monsterinfo.aiflags |= (AI_CHASE_THING | AI_CHICKEN);
|
|
gi.linkentity(self);
|
|
self->monsterinfo.run(self);
|
|
self->monsterinfo.chicken_framenum = level.framenum;
|
|
return true;
|
|
}
|