thirtyflightsofloving/zaero/z_ai.c

491 lines
8.9 KiB
C
Raw Normal View History

#include "g_local.h"
#define Z_RADUISLISTSIZE 2000
void ai_run_melee(edict_t *self);
qboolean FindTarget (edict_t *self);
qboolean SV_StepDirection (edict_t *ent, float yaw, float dist);
void SV_NewChaseDir (edict_t *actor, vec3_t eOrigin, float dist);
#if 0
void z_aiMoveTo(edict_t *self, float dist)
{
// sanity check
if (!(self->monsterinfo.scriptState & MSS_AIMOVETO))
return;
#if 0
if (!SV_StepDirection (self, self->ideal_yaw, dist))
{
SV_NewChaseDir (self, self->monsterinfo.aiMoveTo, dist);
}
#endif
}
#endif
/*
=============
zSchoolAllVisiable
Creates a list of all entities in the raduis of Z_RADUISLISTSIZE
==============
*/
void zCreateRaduisList(edict_t *self)
{
edict_t *head, *list;
vec3_t vec;
if(self->zRaduisList)
{ // already created for this think, don't bother doing it again...
return;
}
head = NULL;
list = self;
while(1)
{
head = findradius(head, self->s.origin, Z_RADUISLISTSIZE);
if(head == NULL)
break;
if(head != self)
{
list->zRaduisList = head;
VectorSubtract(self->s.origin, head->s.origin, vec);
head->zDistance = VectorLength(vec);
list = head;
}
}
list->zRaduisList = NULL;
};
/*
=============
zSchoolAllVisiable
Create list of monsters of the same schooling type that are ahead of you.
==============
*/
int zSchoolAllVisiable(edict_t *self)
{
int max;
edict_t *head, *list;
max = 0;
zCreateRaduisList(self);
head = self->zRaduisList;
list = self;
while (head)
{
if (strcmp(head->classname, self->classname) == 0
&& (self->monsterinfo.aiflags & AI_SCHOOLING) && (head->health > 0)
&& (head->zDistance <= self->monsterinfo.zSchoolSightRadius)
&& (visible(self, head)) && (infront(self, head)) )
{
list->zSchoolChain = head;
list = head;
max++;
}
head = head->zRaduisList;
}
list->zSchoolChain = NULL;
return max;
}
/*
=============
zFindRoamYaw
Check direction moving in does not hit a wall... if it does change direction.
==============
*/
int zFindRoamYaw(edict_t *self, float distcheck)
{
vec3_t forward, end, angles;
trace_t tr;
float current = anglemod(self->s.angles[YAW]);
if (current <= self->ideal_yaw - 1 || current > self->ideal_yaw + 1)
{
if(fabs(current - self->ideal_yaw) <= 359.0)
{
return 0;
}
}
AngleVectors (self->s.angles, forward, NULL, NULL);
VectorMA (self->s.origin, distcheck, forward, end);
tr = gi.trace (self->s.origin, self->mins, self->maxs, end, self, MASK_SOLID);
if (tr.fraction < 1.0)
{
if (random() > 0.75)
{
self->ideal_yaw = vectoyaw(forward);
self->ideal_yaw = self->ideal_yaw + 180;
}
else
{
float dir = random() > 0.5 ? -45 : 45;
float maxtrys = 100;
VectorCopy(self->s.angles, angles);
while (tr.fraction < 1.0 && maxtrys)
{
// blocked, change ideal yaw...
self->ideal_yaw = vectoyaw(forward);
self->ideal_yaw = self->ideal_yaw + (random() * dir);
// self->ideal_yaw = self->ideal_yaw + (-45 + (random() * 90));
angles[YAW] = anglemod (self->ideal_yaw);
AngleVectors (angles, forward, NULL, NULL);
VectorMA (self->s.origin, distcheck, forward, end);
tr = gi.trace (self->s.origin, self->mins, self->maxs, end, self, MASK_SOLID);
maxtrys--;
}
}
return 1;
}
return 0;
};
/*
=============
zSchoolMonsters
Roaming schooling ai.
==============
*/
int zSchoolMonsters(edict_t *self, float dist, int runStyle, float *currentSpeed)
{
int maxInsight;
int newRunStyle;
maxInsight = zSchoolAllVisiable(self);
// If you're not out in front
if (maxInsight > 0)
{
float totalSpeed;
float totalBearing;
float distanceToNearest, distanceToLeader, dist;
edict_t *nearestEntity, *list;
vec3_t vec;
totalSpeed = 0;
totalBearing = 0;
distanceToNearest = 10000;
distanceToLeader = 0;
list = self->zSchoolChain;
while (list)
{
// Gather data on those you see
totalSpeed += list->speed;
totalBearing += anglemod(list->s.angles[YAW]);
VectorSubtract(self->s.origin, list->s.origin, vec);
dist = VectorLength(vec);
if (dist < distanceToNearest)
{
distanceToNearest = dist;
nearestEntity = list;
}
if (dist > distanceToLeader)
{
distanceToLeader = dist;
}
list = list->zSchoolChain;
}
// Rule 1) Match average speed of those in the list
self->speed = (totalSpeed / maxInsight) * 1.5;
// Rule 2) Move towards the perceived center of gravity of the herd
self->ideal_yaw = totalBearing / maxInsight;
// check if hitting something
if (!zFindRoamYaw(self, 10))
{
// Rule 3) Maintain a minimum distance from those around you
if (distanceToNearest <= self->monsterinfo.zSchoolMinimumDistance)
{
self->ideal_yaw = nearestEntity->s.angles[YAW];
self->speed = nearestEntity->speed;
}
}
}
else
{ //You are in front, so slow down a bit
edict_t *head;
self->speed = (self->speed * self->monsterinfo.zSchoolDecayRate);
// check direction
zFindRoamYaw(self, 100);
// change directions of the monsters following you...
zCreateRaduisList(self);
head = self->zRaduisList;
while (head)
{
if (strcmp(head->classname, self->classname) == 0 && (head->health > 0) &&
(head->zDistance <= self->monsterinfo.zSchoolSightRadius) && (visible(self, head)))
{
head->ideal_yaw = self->ideal_yaw + (-20 + (random() * 40));
}
head = head->zRaduisList;
}
}
// if(self.rm_schoolFlags & 1)
// { // check to see is I keep away from "other" entities...
// zSchoolCheckForOtherEntities(checkOtherRaduis);
// }
if (self->speed > self->monsterinfo.zSchoolMaxSpeed)
{
self->speed = self->monsterinfo.zSchoolMaxSpeed;
}
if (self->speed < self->monsterinfo.zSchoolMinSpeed)
{
self->speed = self->monsterinfo.zSchoolMinSpeed;
}
if (self->speed <= self->monsterinfo.zSpeedStandMax)
{
newRunStyle = 0;
if(newRunStyle != runStyle)
{
*currentSpeed = 1;
}
else
{
*currentSpeed = (self->speed - self->monsterinfo.zSchoolMinSpeed) + 1;
}
}
else if (self->speed <= self->monsterinfo.zSpeedWalkMax)
{
newRunStyle = 1;
if (newRunStyle != runStyle)
{
*currentSpeed = 1;
}
else
{
*currentSpeed = (self->speed - self->monsterinfo.zSpeedStandMax) + 1;
}
}
else
{
newRunStyle = 2;
if(newRunStyle != runStyle)
{
*currentSpeed = 1;
}
else
{
*currentSpeed = (self->speed - self->monsterinfo.zSpeedWalkMax) + 1;
}
}
return newRunStyle;
}
/*
=============
ai_schoolStand
Used for standing around and looking for players / schooling monsters of the same type.
Distance is for slight position adjustments needed by the animations
==============
*/
void ai_schoolStand (edict_t *self, float dist)
{
float speed;
if (!(self->monsterinfo.aiflags & AI_SCHOOLING))
{
ai_stand(self, dist);
return;
}
// init school var's for this frame
self->zRaduisList = NULL;
if (self->enemy || FindTarget(self))
{
ai_stand(self, dist);
return;
}
else
{
// run schooling routines
switch (zSchoolMonsters(self, dist, 0, &speed))
{
case 1:
self->monsterinfo.walk (self);
break;
case 2:
self->monsterinfo.run (self);
break;
}
}
// do the normal stand stuff
if (dist)
M_walkmove (self, self->ideal_yaw, dist);
// M_walkmove (self, self->ideal_yaw, dist * speed);
}
/*
=============
ai_schoolRun
The monster has an enemy it is trying to kill
=============
*/
void ai_schoolRun (edict_t *self, float dist)
{
float speed;
if (!(self->monsterinfo.aiflags & AI_SCHOOLING))
{
ai_run(self, dist);
return;
}
// init school var's for this frame
self->zRaduisList = NULL;
if (self->enemy || FindTarget(self))
{
ai_run(self, dist);
return;
}
else
{
// run schooling routines
switch (zSchoolMonsters(self, dist, 2, &speed))
{
case 0:
self->monsterinfo.stand (self);
break;
case 1:
self->monsterinfo.walk (self);
break;
}
}
// do the normal run stuff
SV_StepDirection (self, self->ideal_yaw, dist);
// SV_StepDirection (self, self->ideal_yaw, dist * speed);
}
/*
=============
ai_schoolWalk
The monster is walking it's beat
=============
*/
void ai_schoolWalk (edict_t *self, float dist)
{
float speed;
if (!(self->monsterinfo.aiflags & AI_SCHOOLING))
{
ai_walk(self, dist);
return;
}
// init school var's for this frame
self->zRaduisList = NULL;
if (self->enemy || FindTarget(self))
{
ai_walk(self, dist);
return;
}
else
{
// run schooling routines
switch (zSchoolMonsters(self, dist, 1, &speed))
{
case 0:
self->monsterinfo.stand (self);
break;
case 2:
self->monsterinfo.run (self);
break;
}
}
// do the normal walk stuff
SV_StepDirection (self, self->ideal_yaw, dist);
// SV_StepDirection (self, self->ideal_yaw, dist * speed);
}
/*
=============
ai_schoolCharge
Turns towards target and advances
Use this call with a distnace of 0 to replace ai_face
==============
*/
void ai_schoolCharge (edict_t *self, float dist)
{
/*
if(!(self->monsterinfo.aiflags & AI_SCHOOLING))
{
ai_charge(self, dist);
return;
}
*/
ai_charge(self, dist);
}