raven/heretic2-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases 4 Packages Wiki Activity
heretic2-sdk/Toolkit/Programming/GameCode/game/mg_ai.c
archive b278eb67c9 as released 1998-11-24
1998-11-24 00:00:00 +00:00

2923 lines
No EOL
74 KiB
C
Raw Blame History

/*
==============================
MG AI
NEW LOW-LEVEL MOVEMENT CODE
==============================
*/
#include <assert.h>
#include "g_local.h"
#include "g_monster.h"
#include "Random.h"
#include "vector.h"
#include "buoy.h"
#include "g_HitLocation.h"
#include "Utilities.h"
#include "m_stats.h"
#include "g_playstats.h"
#include "fx.h"
#define STEPSIZE 18
#define YAW_IDEAL 1
#define YAW_BEST_MOVE 0
extern cvar_t *maxclients;
//void gkrokon_maintain_waypoints(edict_t *self, float mintel, float foo1, float foo2);
void ssithraCheckJump (edict_t *self);
void SV_FixCheckBottom (edict_t *ent);
qboolean clear_visible (edict_t *self, edict_t *other);
float ai_face_goal (edict_t *self);
void ai_flee (edict_t *self, float dist);
void pitch_roll_for_slope (edict_t *forwhom, vec3_t *slope);
void BecomeDebris(edict_t *self);
qboolean MG_MoveToGoal (edict_t *self, float dist);
void MG_BuoyNavigate(edict_t *self);
qboolean MG_GoToRandomBuoy(edict_t *self);
qboolean TB_CheckBottom (edict_t *self);
qboolean TB_CheckJump (edict_t *self);
// AI Targeting Globals
qboolean enemy_vis; // TRUE if enemy is visible
qboolean enemy_infront; // TRUE if enemy is in front
int enemy_range; // range from enemy RANGE_MELEE, RANGE_NEAR, RANGE_MID, RANGE_FAR
float enemy_yaw; // ideal yaw to face enemy
vec3_t JUMP_MINS = {-8, -8, 0};
vec3_t JUMP_MAXS = {8, 8, 4};
char *HitLocName [hl_Max] =
{
"NonSpecific",//0
"Head",//1
"TorsoFront",
"TorsoBack",
"ArmUpperLeft",
"ArmLowerLeft",
"ArmUpperRight",
"ArmLowerRight",
"LegUpperLeft",
"LegLowerLeft",
"LegUpperRight",
"LegLowerRight",
"BipedPoints",
"WingedPoints",
"extra14",
"extra15",
"MeleeHit",//16
};
//============================================================================
/*
=============
ahead
returns 1 if the entity is in front (dot > 0.8) of self
=============
*/
qboolean ahead (edict_t *self, edict_t *other)
{
vec3_t vec;
float dot;
vec3_t forward, check_angles;
if(Vec3NotZero(self->v_angle_ofs))
VectorAdd(self->v_angle_ofs,self->s.angles,check_angles);
else
VectorCopy(self->s.angles,check_angles);
AngleVectors (check_angles, forward, NULL, NULL);
VectorSubtract (other->s.origin, self->s.origin, vec);
VectorNormalize (vec);
dot = DotProduct (vec, forward);
if (dot > 0.8)
return true;
return false;
}
/*
=============
LOS
returns true if there is an unobstructed spot from point1 to point2
=============
*/
qboolean LOS (edict_t *self, vec3_t point1, vec3_t point2)
{
trace_t trace;
gi.trace (point1, vec3_origin, vec3_origin, point2, self, MASK_SOLID,&trace);
if (trace.fraction == 1.0)
return true;
return false;
}
/*
=============
visible_pos
returns 1 if the entity is visible to self, even if not infront ()
=============
*/
qboolean visible_pos (edict_t *self, vec3_t spot2)
{
vec3_t spot1;
trace_t trace;
VectorCopy (self->s.origin, spot1);
spot1[2] += self->viewheight;
gi.trace (spot1, vec3_origin, vec3_origin, spot2, self, MASK_OPAQUE,&trace);
if (trace.fraction == 1.0)
return true;
return false;
}
/*
=============
MG_CheckBottom
Returns false if any 2 adjacent cornerpoints of the bottom of the
entity is off an edge that is not a staircase.
=============
*/
qboolean MG_CheckBottom (edict_t *ent)
{
vec3_t mins, maxs, start, stop;
trace_t trace;
int x, y, corner;
float stepsize;
qboolean corner_ok[4];
qboolean easy_ok[2][2];
qboolean realcheck = false;
//normal corner checking
if(ent->classID==CID_TBEAST)
{
return TB_CheckBottom(ent);
// VectorAdd (ent->s.origin, ent->mins, mins);
// VectorAdd (ent->s.origin, ent->maxs, maxs);
// stepsize = 54;//ent->size[2];//very lenient for stepping off stuff
}
else//lenient, max 16 corner checking
{
VectorCopy (ent->mins, mins);
VectorCopy (ent->maxs, maxs);
//some leniency is ok here, no?
mins[0] *= 0.75;
mins[1] *= 0.75;
maxs[0] *= 0.75;
maxs[1] *= 0.75;
//keep corner checks within 16 of center
if(mins[0] < -16)
mins[0] = -16;
if(mins[1] < -16)
mins[1] = -16;
if(maxs[0] > 16)
maxs[0] = 16;
if(maxs[1] > 16)
maxs[1] = 16;
if(ent->maxs[0] > maxs[0])
stepsize = STEPSIZE + (ent->maxs[0] - maxs[0]);
VectorAdd (ent->s.origin, mins, mins);
VectorAdd (ent->s.origin, maxs, maxs);
}
// if all of the points under the corners are solid world, don't bother
// with the tougher checks
// the corners must be within 16 of the midpoint
start[2] = mins[2] - 1;
corner = 0;
for (x=0 ; x<=1 ; x++)//0, 0; 0, 1; 1, 0; 1, 1;
{
for (y=0 ; y<=1 ; y++)
{
start[0] = x ? maxs[0] : mins[0];
start[1] = y ? maxs[1] : mins[1];
if (gi.pointcontents (start) != CONTENTS_SOLID)
{//only do realcheck if two adjecent corners off ledge
switch(corner)
{
case 0:
break;
case 1:
case 2:
if(!corner_ok[0])
realcheck = true;
break;
case 3:
if(!corner_ok[2] || !corner_ok[1])
realcheck = true;
break;
}
easy_ok[x][y] = corner_ok[corner] = false;
}
else
{
// if(ent->classID==CID_TBEAST)
// {
// ent->groundentity = world;
// return true;//super hack- let big guy go up slopes
// }
//check them all to make realcheck faster
easy_ok[x][y] = corner_ok[corner] = true;
}
corner++;
}
}
if(!realcheck)
return true; // we got out easy
//
// check it for real...
//
start[2] = mins[2];//bottom
stop[2] = start[2] - stepsize + 1;//2*STEPSIZE;//bottom - 36
// the corners must be within 16 of the midpoint
corner = 0;
for (x=0 ; x<=1 ; x++)
{
for (y=0 ; y<=1 ; y++)
{
if(!easy_ok[x][y])
{//don't trace the ones that were ok in the easy check
start[0] = stop[0] = x ? maxs[0] : mins[0];
start[1] = stop[1] = y ? maxs[1] : mins[1];
gi.trace (start, vec3_origin, vec3_origin, stop, ent, MASK_MONSTERSOLID,&trace);
if (trace.fraction >= 1.0)// || start[2] - trace.endpos[2] > STEPSIZE)
{//this point is off too high of a step
switch(corner)
{
case 0:
break;
case 1:
case 2:
if(!corner_ok[0])
return false;
break;
case 3:
if(!corner_ok[2] || !corner_ok[1])
return false;
break;
}
corner_ok[corner] = false;
}
else//only return false if two adjacent corners off a ledge
{
if(ent->classID==CID_TBEAST)
{
// ent->groundentity = trace.ent;
return true;//super hack- let big guy go up slopes
}
corner_ok[corner] = true;
}
}
else
corner_ok[corner] = true;
corner++;
}
}
return true;
}
/*
=============
MG_MoveStep
Called by monster program code.
The move will be adjusted for slopes and stairs, but if the move isn't
possible, no move is done, false is returned, and
pr_global_struct->trace_normal is set to the normal of the blocking wall
=============
*/
//FIXME since we need to test end position contents here, can we avoid doing
//it again later in catagorize position?
trace_t MG_MoveStep (edict_t *self, vec3_t move, qboolean relink)
{//only relinks if move succeeds
float dz;
vec3_t save_org, test_org, end;
trace_t trace;
int i;
float stepsize;
vec3_t test;
int contents, clipmask;
qboolean slip_under = false;
trace.succeeded = false;
// try the move
VectorCopy (self->s.origin, save_org);
if(self->monsterinfo.scale)
{//scale movement by monster's scale
//scale here, not before since any function can call this
VectorScale(move, self->monsterinfo.scale, move);
}
VectorAdd (self->s.origin, move, test_org);
//SWIM AND FLY MONSTERS
// flying monsters don't step up
if ( self->flags & (FL_SWIM | FL_FLY) )
{
// try one move with vertical motion, then one without
for (i=0 ; i<2 ; i++)
{
VectorAdd (self->s.origin, move, test_org);
if (i == 0 && self->enemy)
{
if (!self->goalentity)
self->goalentity = self->enemy;
dz = self->s.origin[2] - self->goalentity->s.origin[2];
if (self->goalentity->client)
{
if (dz > 40)
test_org[2] -= 8;
if (!((self->flags & FL_SWIM) && (self->waterlevel < 2)))
if (dz < 30)
test_org[2] += 8;
}
else
{
if (dz > 8)
test_org[2] -= 8;
else if (dz > 0)
test_org[2] -= dz;
else if (dz < -8)
test_org[2] += 8;
else
test_org[2] += dz;
}
}
gi.trace (self->s.origin, self->mins, self->maxs, test_org, self, MASK_MONSTERSOLID,&trace);
// fly monsters don't enter water voluntarily
if (self->flags & FL_FLY)
{
if (!self->waterlevel)
{
test[0] = trace.endpos[0];
test[1] = trace.endpos[1];
test[2] = trace.endpos[2] + self->mins[2] + 1;
contents = gi.pointcontents(test);
if (contents & MASK_WATER)
{
QPostMessage(self, MSG_BLOCKED, PRI_DIRECTIVE, NULL);
return trace;
}
}
}
// swim monsters don't exit water voluntarily
if (self->flags & FL_SWIM)
{
if (self->waterlevel < 2)
{
test[0] = trace.endpos[0];
test[1] = trace.endpos[1];
test[2] = trace.endpos[2] + self->mins[2] + 1;
contents = gi.pointcontents(test);
if (!(contents & MASK_WATER))
{
QPostMessage(self, MSG_BLOCKED, PRI_DIRECTIVE, NULL);
return trace;
}
}
}
if (trace.fraction == 1)
{
VectorCopy (trace.endpos, self->s.origin);
if (relink)
{
gi.linkentity (self);
G_TouchTriggers (self);
}
return trace;//true
}
if (!self->enemy)
break;
}
return trace;
}
//WALK MONSTERS
// push down from a step height above the wished position
clipmask = MASK_MONSTERSOLID;
if (!(self->monsterinfo.aiflags & AI_NOSTEP))
{
if(self->classID==CID_TBEAST)
{
clipmask = MASK_SOLID;
stepsize = STEPSIZE * 3;
}
else
stepsize = STEPSIZE;
}
else
stepsize = 1;
test_org[2] += stepsize;
VectorCopy (test_org, end);
end[2] -= stepsize*2;
gi.trace (test_org, self->mins, self->maxs, end, self, clipmask,&trace);
if (trace.allsolid)
{//the step up/down is all solid in front
QPostMessage(self, MSG_BLOCKED, PRI_DIRECTIVE, NULL);
return trace;
}
//NOTE: if did the forward trace above, CAN'T have startsolid, so this is ok
if (trace.startsolid)
{//can't step up, try down
test_org[2] -= stepsize;
gi.trace (test_org, self->mins, self->maxs, end, self, clipmask,&trace);
if (trace.allsolid || trace.startsolid)
{
if(trace.ent)
{
if(trace.ent->client)
{
slip_under = true;//lets rats walk between legs
}
}
if(!slip_under)
{
QPostMessage(self, MSG_BLOCKED, PRI_DIRECTIVE, NULL);
return trace;
}
}
}
// don't go in to water unless only 40% hieght deep or an amphibian
if (self->waterlevel == 0)
{//not currently in water
test[0] = trace.endpos[0];
test[1] = trace.endpos[1];
test[2] = trace.endpos[2] + self->mins[2];// + 1;
test[2] += (self->maxs[2] - self->mins[2]) * 0.4;
contents = gi.pointcontents(test);
if (contents & MASK_WATER && !(self->flags & FL_AMPHIBIAN))
return trace;
}
if (trace.fraction == 1)
{//too long of a step down
if ( self->flags & FL_PARTIALGROUND ||
self->svflags & SVF_FLOAT ||
self->classID == CID_TBEAST ||
(contents&MASK_WATER && self->flags & FL_AMPHIBIAN))//allow swimming monsters to step off ledges into water
{// if monster had the ground pulled out, go ahead and fall
//DO THE MOVE!
VectorAdd (self->s.origin, move, self->s.origin);
if (relink)
{
gi.linkentity (self);
G_TouchTriggers (self);
}
self->groundentity = NULL;
// SV_Printf ("fall down\n");
trace.succeeded = true;
return trace;//true!
}
QPostMessage(self, MSG_BLOCKED, PRI_DIRECTIVE, NULL);
return trace; // walked off an edge
}
// check point traces down for dangling corners
//DO THE MOVE!
//ok, put me there
VectorCopy (trace.endpos, self->s.origin);
if(contents&MASK_WATER && self->flags & FL_AMPHIBIAN);
else if (!MG_CheckBottom(self))// && self->classID!=CID_TBEAST)
{//uh oh, not completely on solid ground
if ( self->flags & FL_PARTIALGROUND || self->svflags & SVF_FLOAT)
{ // entity had floor mostly pulled out from underneath it
// and is trying to correct or can float
if (relink)
{
gi.linkentity (self);
G_TouchTriggers (self);
}
trace.succeeded = true;
return trace;//true!
}
//whoops, let's not make that move after all
VectorCopy (save_org, self->s.origin);
QPostMessage(self, MSG_BLOCKED, PRI_DIRECTIVE, NULL);
return trace;
}
//OK, we're on the ground completely now
if ( self->flags & FL_PARTIALGROUND )
{
self->flags &= ~FL_PARTIALGROUND;
}
self->groundentity = trace.ent;
self->groundentity_linkcount = trace.ent->linkcount;
// the move is ok
if (relink)
{
gi.linkentity (self);
G_TouchTriggers (self);
}
else
VectorCopy (save_org, self->s.origin);
trace.succeeded = true;
return trace;//true!
}
/*
===============
MG_ChangeYaw
===============
*/
float MG_ChangeWhichYaw (edict_t *self, qboolean ideal_yaw)
{
float ideal;
float current;
float move;
float speed;
current = anglemod(self->s.angles[YAW]);
if(ideal_yaw)
ideal = self->ideal_yaw;
else
ideal = self->best_move_yaw;
if (current == ideal)
return false;
move = ideal - current;
speed = self->yaw_speed;
if (ideal > current)
{
if (move >= 180)
move = move - 360;
}
else
{
if (move <= -180)
move = move + 360;
}
if (move > 0)
{
if (move > speed)
move = speed;
}
else
{
if (move < -speed)
move = -speed;
}
//normal anglemod doesn't have the precision I need to slide along walls
self->s.angles[YAW] = anglemod_old(current + move);
return move;
}
float MG_ChangeYaw (edict_t *self)
{
return MG_ChangeWhichYaw(self, YAW_IDEAL);
}
qboolean MG_GetGoalPos (edict_t *self, vec3_t goalpos)
{
qboolean charge_enemy = false;
if(self->monsterinfo.aiflags&AI_STRAIGHT_TO_ENEMY && self->enemy)
charge_enemy = true;
if (self->monsterinfo.searchType == SEARCH_BUOY && !charge_enemy)
{
if(self->buoy_index < 0 || self->buoy_index > level.active_buoys)
{
#ifdef _DEVEL
gi.dprintf("Error: SEARCH_BUOY but invalid index!!!\n");
#endif
return false;
}
VectorCopy(level.buoy_list[self->buoy_index].origin, self->monsterinfo.nav_goal);
VectorCopy(self->monsterinfo.nav_goal, goalpos);
}
else if(self->goalentity && !charge_enemy)
{
if(self->goalentity == self->enemy && self->ai_mood_flags & AI_MOOD_FLAG_PREDICT && !(self->spawnflags & MSF_FIXED))
{//predict where he's goin
M_PredictTargetPosition( self->enemy, self->enemy->velocity, 8, goalpos);
}
else
{
VectorCopy(self->goalentity->s.origin, goalpos);
}
}
else if(self->enemy)
{
if (self->ai_mood_flags & AI_MOOD_FLAG_PREDICT && !(self->spawnflags & MSF_FIXED))
{//predict where he's goin
M_PredictTargetPosition( self->enemy, self->enemy->velocity, 8, goalpos);
}
else
{
VectorCopy(self->enemy->s.origin, goalpos);
}
}
else
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("No goal to face!\n");
#endif
VectorClear(goalpos);
return false;
}
return true;
}
float MG_FaceGoal (edict_t *self, qboolean doturn)
{
vec3_t vec, goalpos;
if(MG_GetGoalPos(self, goalpos))
{
VectorSubtract(goalpos, self->s.origin, vec);
}
else
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("No goal to face!\n");
#endif
return false;
}
self->ideal_yaw = vectoyaw(vec);
if(doturn)
return MG_ChangeYaw(self);
return 0;
}
/*
======================
MG_StepDirection
Turns to the movement direction, and walks the current distance if
facing it.
======================
*/
qboolean MG_StepDirection (edict_t *self, float yaw, float dist)
{
vec3_t move, forward, test_angles;
trace_t trace;
//find vector offset (move to add to origin)
test_angles[PITCH] = test_angles[ROLL] = 0;
test_angles[YAW] = yaw;
AngleVectors(test_angles, forward, NULL, NULL);
VectorScale(forward, dist, move);
//see if can move that way, but don't actually move
trace = MG_MoveStep (self, move, false);
if (trace.succeeded)
{//move was allowed
self->best_move_yaw = yaw;//new
self->monsterinfo.idle_time = level.time + flrand(0.5, 1.25);
// MG_ChangeWhichYaw (self, YAW_BEST_MOVE);//new
return true;
}
return false;
}
/*
================
MG_NewDir
================
*/
#define DI_NODIR -1
void MG_NewDir (edict_t *self, float dist)
{
float deltax, deltay;
float d[3];
float test_ideal_yaw, old_yaw, turnaround;//, save_yaw;
vec3_t goal_org;
//FIXME: how did we get here with no enemy
if(!MG_GetGoalPos (self, goal_org))
return;
old_yaw = anglemod( (int)(self->ideal_yaw/45)*45 );
turnaround = anglemod(old_yaw - 180);
deltax = goal_org[0] - self->s.origin[0];
deltay = goal_org[1] - self->s.origin[1];
if (deltax>10)
d[1]= 0;
else if (deltax<-10)
d[1]= 180;
else
d[1]= DI_NODIR;
if (deltay<-10)
d[2]= 270;
else if (deltay>10)
d[2]= 90;
else
d[2]= DI_NODIR;
// try direct route
if (d[1] != DI_NODIR && d[2] != DI_NODIR)
{
if (d[1] == 0)
test_ideal_yaw = d[2] == 90 ? 45 : 315;
else
test_ideal_yaw = d[2] == 90 ? 135 : 215;
if (test_ideal_yaw != turnaround && MG_StepDirection(self, test_ideal_yaw, dist))
return;
}
// try other directions
if ( irand(0, 1) || abs(deltay)>abs(deltax))
{
test_ideal_yaw=d[1];
d[1]=d[2];
d[2]=test_ideal_yaw;
}
if (d[1]!=DI_NODIR && d[1]!=turnaround
&& MG_StepDirection(self, d[1], dist))
return;
if (d[2]!=DI_NODIR && d[2]!=turnaround
&& MG_StepDirection(self, d[2], dist))
return;
/* there is no direct path to the player, so pick another direction */
if (old_yaw!=DI_NODIR && MG_StepDirection(self, old_yaw, dist))
return;
if (irand(0, 1)) /*randomly determine direction of search*/
{
for (test_ideal_yaw=0 ; test_ideal_yaw<=315 ; test_ideal_yaw += 45)
if (test_ideal_yaw!=turnaround && MG_StepDirection(self, test_ideal_yaw, dist) )
return;
}
else
{
for (test_ideal_yaw=315 ; test_ideal_yaw >=0 ; test_ideal_yaw -= 45)
if (test_ideal_yaw!=turnaround && MG_StepDirection(self, test_ideal_yaw, dist) )
return;
}
if (turnaround != DI_NODIR && MG_StepDirection(self, turnaround, dist) )
return;
// can't move, restore yaw?
// if a bridge was pulled out from underneath a monster, it may not have
// a valid standing position at all
if (!MG_CheckBottom (self))// && self->classID!=CID_TBEAST)
SV_FixCheckBottom (self);
}
/*
=============
infront_pos
returns 1 if the spot is in front (in sight) of self
=============
*/
qboolean infront_pos (edict_t *self, vec3_t pos)
{
vec3_t vec;
float dot;
vec3_t forward, check_angles;
if(Vec3NotZero(self->v_angle_ofs))
VectorAdd(self->v_angle_ofs,self->s.angles,check_angles);
else
VectorCopy(self->s.angles,check_angles);
AngleVectors (check_angles, forward, NULL, NULL);
VectorSubtract (pos, self->s.origin, vec);
VectorNormalize (vec);
dot = DotProduct (vec, forward);
if (dot > 0.3)
return true;
return false;
}
qboolean MG_ExtraCheckJump (edict_t *self)
{
vec3_t vf, source, source2, targ_org, targ_mins;
vec3_t maxs, mins, save_org;
trace_t trace;
float hgt_diff, jump_fdist;
qboolean jump_up_check = false;
qboolean check_down = false;
qboolean can_move = false;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Extra Check Jump\n");
#endif
if (self->monsterinfo.searchType == SEARCH_BUOY)
{
if(self->buoy_index < 0 || self->buoy_index > level.active_buoys)
return false;
VectorCopy(level.buoy_list[self->buoy_index].origin, targ_org);
if (!(infront_pos(self, targ_org)))
return false;
if (targ_org[2] < self->s.origin[2] - 28)
{
check_down = true;
}
else
{
check_down = false;
}
VectorClear(targ_mins);
}
else
{
if(!self->goalentity)
return false;
if (!(infront(self, self->goalentity)))
return false;
if (self->goalentity->s.origin[2] < self->s.origin[2] - 28)
{
check_down = true;
}
else
{
check_down = false;
}
VectorCopy(self->goalentity->s.origin, targ_org);
VectorCopy(self->goalentity->mins, targ_mins);
}
if (check_down)
{//jumping down
//Setup the trace
int inwater;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("check jump down\n");
#endif
inwater = (gi.pointcontents(self->s.origin) & CONTENTS_WATER);
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("checking jump down: ");
#endif
if(inwater)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("checkdown allsolid\n");
#endif
return false;
}
VectorCopy(self->maxs, maxs);
VectorCopy(self->s.origin, source);
AngleVectors(self->s.angles, vf, NULL, NULL);
jump_fdist = vhlen(targ_org, self->s.origin);
if(jump_fdist > 128)
jump_fdist = 128;
VectorMA(source, 128, vf, source);
maxs[2] += 16;
gi.trace (self->s.origin, self->mins, maxs, source, self, MASK_MONSTERSOLID,&trace);
if (trace.fraction == 1)
{//clear ahead and above
VectorCopy(source, source2);
source2[2] -= 1024;
//trace down
gi.trace (source, self->mins, self->maxs, source2, self, MASK_ALL,&trace);
if (trace.allsolid || trace.startsolid)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("checkdown allsolid\n");
#endif
return false;
}
if (trace.fraction == 1)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("checkdown- too far\n");
#endif
return false;
}
else
{
if (trace.contents != CONTENTS_SOLID && trace.ent != self->enemy)
{//didn't hit ground
return false;
}
else
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("checkjump down->whichjump\n");
#endif
VectorSubtract(trace.endpos, self->s.origin, source2);
VectorNormalize(source2);
self->ideal_yaw = vectoyaw(source2);
VectorMA(self->velocity, 300, vf, self->velocity);
self->velocity[2]+=150;
if(classStatics[self->classID].msgReceivers[MSG_JUMP])
{
if(self->classID != CID_RAT && self->classID != CID_SSITHRA)
{//save vel so can crouch first
VectorCopy(self->velocity, self->movedir);
VectorClear(self->velocity);
}
QPostMessage(self, MSG_JUMP, PRI_DIRECTIVE, NULL);
self->nextthink = level.time + 0.01;
}
else
self->nextthink = level.time + 0.3;
self->monsterinfo.jump_time = level.time + 1;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Extra jump down\n");
#endif
}
}
}
#ifdef _DEVEL
else if(MGAI_DEBUG)
gi.dprintf("checkdown: not clear infront\n");
#endif
}
else
{
VectorCopy(self->s.origin, save_org);
can_move = M_walkmove (self, self->s.angles[YAW], 64);
VectorCopy(save_org, self->s.origin);
if(can_move)
return false;
else
{//check to jump over something
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("check jump over\n");
#endif
AngleVectors(self->s.angles, vf, NULL, NULL);
VectorCopy(self->s.origin, source);
VectorMA(source, 128, vf, source2);
VectorCopy(self->mins, mins);
mins[2]+=24;//can clear it
gi.trace(source, mins, self->maxs, source2, self, MASK_SOLID,&trace);
if((!trace.allsolid&&!trace.startsolid&&trace.fraction==1.0) || trace.ent == self->enemy)
{//Go for it!
VectorMA(self->velocity, 500*trace.fraction, vf, self->velocity);
self->velocity[2] += 225;
if(classStatics[self->classID].msgReceivers[MSG_JUMP])
{
if(self->classID != CID_RAT && self->classID != CID_SSITHRA)
{//save vel so can crouch first
VectorCopy(self->velocity, self->movedir);
VectorClear(self->velocity);
}
QPostMessage(self, MSG_JUMP, PRI_DIRECTIVE, NULL);
self->nextthink = level.time + 0.01;
}
else
self->nextthink = level.time + 0.3;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Extra jump over\n");
#endif
}
else
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("check jump up\n");
#endif
VectorCopy(self->maxs, maxs);
VectorCopy(self->s.origin, source);
hgt_diff = (targ_org[2] + targ_mins[2]) - (self->s.origin[2] + self->mins[2]) + 32;
source[2] += hgt_diff;
gi.trace (self->s.origin, self->mins, self->maxs, source, self, MASK_MONSTERSOLID,&trace);
if (trace.fraction == 1)
{//clear above
VectorCopy(source, source2);
AngleVectors(self->s.angles, vf, NULL, NULL);
VectorMA(source, 64, vf, source2);
source2[2] -= 24;
//trace forward and down a little
gi.trace (source, self->mins, self->maxs, source2, self, MASK_ALL,&trace);
if (trace.allsolid || trace.startsolid)
return false;
if (trace.fraction < 0.1)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Can't jump up, no ledge\n");
#endif
return false;
}
// {
// if (stricmp(trace.ent->classname, "worldspawn"))
// return;
// }
else
{
VectorSubtract(trace.endpos, self->s.origin, source2);
source2[2] = 0;
VectorNormalize(source2);
self->ideal_yaw = vectoyaw(source2);
VectorMA(self->s.origin, 64, source2, source);
gi.trace(self->s.origin, vec3_origin, vec3_origin, source, self, MASK_SOLID,&trace);
VectorScale(source2, 480*trace.fraction, self->velocity);
self->velocity[2] = hgt_diff*3 + 200;
if(classStatics[self->classID].msgReceivers[MSG_JUMP])
{
if(self->classID != CID_RAT && self->classID != CID_SSITHRA)
{//save vel so can crouch first
VectorCopy(self->velocity, self->movedir);
VectorClear(self->velocity);
}
QPostMessage(self, MSG_JUMP, PRI_DIRECTIVE, NULL);
self->nextthink = level.time + 0.01;
}
else
self->nextthink = level.time + 0.3;
self->monsterinfo.jump_time = level.time + 1;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Extra jump up\n");
#endif
}
}
else
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Can't jump up, blocked\n");
#endif
return false;
}
}
}
}
return true;
}
/*
==================================================================
MG_CheckJump()
Checks to see if the enemy is not at the same level as monster
or something is blocking the path of the monster. If there is
a clear jump arc to the enemy and the monster will not land in
water or lava, the monster will attempt to jump the distance.
==================================================================
*/
qboolean MG_CheckJump (edict_t *self)
{
vec3_t spot1, spot2, jumpdir, forward, right, targ_absmin;
vec3_t up, cont_spot, vis_check_spot, end_spot, targ_org;
float jump_height, sub_len;
int contents;
qboolean ignore_height;
qboolean jumpup = false;
trace_t trace;
if(irand(1,100) > self->jump_chance)//JumpChanceForClass[self->classID])
return false;
if(self->classID == CID_TBEAST)
return TB_CheckJump(self);
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Check Jump\n");
#endif
//FIXME: Allow jump in/out of water if not too deep
if(self->flags & FL_INWATER)// && !(self->flags&FL_AMPHIBIAN))?
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Can't jump- inwater\n");
#endif
return false;
}
if (self->monsterinfo.searchType == SEARCH_BUOY)
{
if(self->buoy_index < 0 || self->buoy_index > level.active_buoys)
return false;
VectorCopy(level.buoy_list[self->buoy_index].origin, targ_org);
VectorCopy(targ_org, targ_absmin);
if (!(infront_pos(self, targ_org)))
return false;
}
else
{
if(!self->goalentity)
return false;
if (!(infront(self, self->goalentity)))
return false;
if(!self->goalentity->groundentity && self->classID != CID_GORGON)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("goalentity in air\n");
#endif
return false;
}
VectorCopy(self->goalentity->s.origin, targ_org);
VectorAdd(targ_org, self->goalentity->mins, targ_absmin);
}
AngleVectors(self->s.angles, forward, right, up);
VectorSubtract(targ_org, self->s.origin, jumpdir);
VectorNormalize(jumpdir);
jumpdir[2] = 0;
jump_height=DotProduct(jumpdir, forward);
if(jump_height<0.3)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("jump direction more than 60 degrees off of forward\n");
#endif
return false;
}
VectorCopy(self->s.origin, spot1);
VectorCopy(targ_org, spot2);
jump_height = 16;
VectorMA(spot1, 24, forward, cont_spot);
cont_spot[2] -= 10;
if(!(gi.pointcontents(cont_spot)&CONTENTS_SOLID))
ignore_height = true;
sub_len = vhlen(spot1, spot2);
// if(self->classname!="monster_mezzoman"&&!self->spiderType&&self->model!="models/yakman.mdl")
if(sub_len > 256)
ignore_height = false;
VectorMA(spot1, self->size[0] * 2, forward, vis_check_spot);
VectorMA(vis_check_spot, self->size[2] * 1.5, up, vis_check_spot);
//also check to make sure you can't walkmove forward
if(self->monsterinfo.jump_time > level.time) //Don't jump too many times in a row
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("just jumped\n");
#endif
return false;
}
else if(!ignore_height&&targ_absmin[2]+36>=self->absmin[2])//&&self->think!=SpiderJumpBegin&&self->classname!="monster_mezzoman"&&self->model!="models/yakman.mdl")
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("not above goalentity, and not spider\n");
#endif
return false;
}
else if(!self->groundentity)//flags&FL_ONGROUND)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("not on ground\n");
#endif
return false;
}
else if(sub_len>777 && !ignore_height)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("too far away\n");
#endif
return false;
}
else if(sub_len <= 100)//&&self->think!=SpiderMeleeBegin)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("too close & not spider\n");
#endif
return false;
}
//sfs--sure, it's just a dotproduct, but the other checks are a little cheaper
else if(!infront_pos(self, targ_org))
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("goalentity not in front\n");
#endif
return false;
}
//sfs--save the trace line for after the easy checks
else if(!clear_visible_pos(self, targ_org)&&!LOS(self, vis_check_spot, spot2))
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("can't see goalentity\n");
#endif
return false;
}
//sfs--holding off on the point contents too
contents = gi.pointcontents(spot2);
if(!(self->monsterinfo.aiflags&AI_SWIM_OK)&&
(contents&CONTENTS_WATER||contents&CONTENTS_SLIME||contents&CONTENTS_LAVA))
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("goalentity in water or lava\n");
#endif
return false;
}
VectorCopy(self->s.origin, spot1);
// spot1=self->s.origin;
spot1[2] += self->maxs[2];
//spot1_z=self->absmax_z;
VectorCopy(spot1, spot2);
//spot2=spot1;
spot2[2] += 36;
//spot2_z+=36;
gi.trace(spot1, self->mins, self->maxs, spot2, self, MASK_MONSTERSOLID,&trace);
if(trace.fraction<1.0||trace.allsolid||trace.startsolid)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("not enough room above\n");
#endif
return false;
}
if(!jumpup) // This variable is used without being initialised
{
// spot1+=normalize(v_forward)*((self->maxs_x+self->maxs_y)*0.5);
VectorMA(spot1, (self->maxs[0]+self->maxs[1])*0.5, jumpdir, spot1);
//spot1+=jumpdir*((self->maxs_x+self->maxs_y)*0.5);
VectorCopy(spot1, end_spot);
end_spot[2] += 36;
gi.trace(self->s.origin, self->mins, self->maxs, end_spot, self, MASK_MONSTERSOLID,&trace);
if(trace.fraction<1.0||trace.allsolid||trace.startsolid)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("not enough room in front\n");
#endif
return false;
}
VectorMA(spot1, 64, jumpdir, end_spot);
end_spot[2] -= 500;
gi.trace(spot1, JUMP_MINS, JUMP_MAXS, end_spot, self, MASK_MONSTERSOLID,&trace);
// traceline(spot1,spot1+jumpdir*64 - '0 0 500',false,self);
contents = gi.pointcontents(trace.endpos);
if(contents&CONTENTS_WATER||contents&CONTENTS_SLIME||contents&CONTENTS_LAVA)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("won't jump in water\n");
#endif
return false;
}
}
MG_FaceGoal(self, true);
//FIXME: make them do whatever jump function they have if they have one
self->monsterinfo.jump_time = level.time + 2; //Only try to jump once every 7 seconds
if(!self->s.scale)
self->s.scale = 1.0;
if(!jumpup)
{
VectorScale(jumpdir, jump_height*18*self->s.scale, self->velocity);
//self->velocity=jumpdir*jump_height*18*self->scale;//was 18
self->velocity[2] = jump_height*14*self->s.scale;//was 12
}
else
{
VectorScale(jumpdir, jump_height*14*self->s.scale, self->velocity);
//self->velocity=jumpdir*jump_height*14*self->scale;//was 10
self->velocity[2] = jump_height*17*self->s.scale;//was 14
}
//self->groundentity = NULL?
if(classStatics[self->classID].msgReceivers[MSG_JUMP])
{
if(self->classID != CID_RAT && self->classID != CID_SSITHRA)
{//save vel so can crouch first
VectorCopy(self->velocity, self->movedir);
VectorClear(self->velocity);
}
QPostMessage(self, MSG_JUMP, PRI_DIRECTIVE, NULL);
self->nextthink = level.time + 0.01;
}
else
self->nextthink = level.time + 0.3;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("JUMP!!!\n");
#endif
return true;
}
/*
===============
MG_WalkMove
Tries to step forward dist, returns the trace
===============
*/
trace_t MG_WalkMove (edict_t *self, float yaw, float dist)
{
vec3_t move, endpos;
trace_t trace;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
trace = MG_MoveStep(self, move, true);
if(trace.succeeded)
{
return trace;
}
//FaileD? ok, so what's in front of us
VectorAdd(self->s.origin, move, endpos);
//up mins for stairs?
gi.trace(self->s.origin, self->mins, self->maxs, endpos, self, MASK_MONSTERSOLID,&trace);
trace.succeeded = false;
return trace;
}
/*
===============
MG_BoolWalkMove
Tries to step forward dist, returns true/false
===============
*/
qboolean MG_BoolWalkMove (edict_t *self, float yaw, float dist)
{
vec3_t move;
trace_t trace;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
trace = MG_MoveStep(self, move, true);
if(trace.succeeded)
{
return true;
}
return false;
}
/*
===============
MG_TestMove
Sees if it can step dist in yaw, but doesn't do the move
===============
*/
qboolean MG_TestMove (edict_t *self, float yaw, float dist)
{
vec3_t move;
trace_t trace;
yaw = yaw*M_PI*2 / 360;
move[0] = cos(yaw)*dist;
move[1] = sin(yaw)*dist;
move[2] = 0;
trace = MG_MoveStep(self, move, false);
if(trace.succeeded)
return true;
return false;
}
void MG_CheckEvade (edict_t *self)
{//FIXME: only check my enemy? See if he's fired (last_attack) recently?
int hl;
float ent_dist, proj_offset;
vec3_t proj_dir, endpos, bad_dir;
trace_t trace;
edict_t *ent = NULL;
vec3_t total_dist;
float eta;
if(!skill->value)
return;
//else if(flrand(0, 3) > skill->value)
// return;
while(ent = findradius(ent, self->s.origin, 500))
{
if(ent->movetype == MOVETYPE_FLYMISSILE && ent->solid && ent->owner!=self)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Monster checking evade from %s projectile\n", ent->classname);
#endif
if(Vec3IsZero(ent->velocity))
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("ERROR: NULL velocity on %s projectile!\n", ent->classname);
#endif
}
else
{
VectorCopy(ent->velocity, proj_dir);
VectorNormalize(proj_dir);
VectorMA(ent->s.origin, 600, proj_dir, endpos);
gi.trace(ent->s.origin, ent->mins, ent->maxs, endpos, ent, MASK_MONSTERSOLID,&trace);
if(trace.ent == self)
{//going to get hit!
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Dodging projectile impact, going to hit %s\n", HitLocName[hl]);
#endif
hl = T_GetHitLocation(self, ent, trace.endpos);
VectorSubtract(trace.endpos, ent->s.origin, total_dist);
eta = VectorLength(total_dist)/VectorLength(ent->velocity);
QPostMessage(self, MSG_EVADE, PRI_DIRECTIVE, "eif", ent, hl, eta);
}
else if(!irand(0,2))
{
VectorSubtract(self->s.origin, ent->s.origin, bad_dir);
ent_dist = VectorNormalize(bad_dir);
proj_offset = DotProduct(bad_dir, proj_dir);
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Proj dot prod: %f\n", proj_offset);
#endif
if(proj_offset > ent_dist/600)//farther it is, smaller angle deviation allowed for evasion
{//coming pretty close
VectorMA(ent->s.origin, ent_dist, proj_dir, endpos);//extrapolate to close to me
gi.trace(endpos, ent->mins, ent->maxs, self->s.origin, ent, MASK_MONSTERSOLID,&trace);
if(trace.ent == self)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Dodging projectile close pass, going to hit %s\n", HitLocName[hl]);
#endif
hl = T_GetHitLocation(self, ent, trace.endpos);
VectorSubtract(trace.endpos, ent->s.origin, total_dist);
eta = VectorLength(total_dist)/VectorLength(ent->velocity);
QPostMessage(self, MSG_EVADE, PRI_DIRECTIVE, "eif", ent, hl, eta);
}
}
}
}
}
}
}
/*
=============
ai_run
The monster has an enemy it is trying to kill or the monster is fleeing
=============
*/
void old_ai_run (edict_t *self, float dist);
void ai_run (edict_t *self, float dist)
{
float turnamt, i;
//if dumb fleeing or fleeing and can't use buoys...
if((DEACTIVATE_BUOYS||!(self->monsterinfo.aiflags & AI_USING_BUOYS))
&&
(self->monsterinfo.aiflags & AI_COWARD ||
(self->monsterinfo.aiflags&AI_FLEE
&&
self->monsterinfo.flee_finished >= level.time)
)
)
{
ai_flee(self, dist);
return;
}
else if(self->ai_mood_flags & AI_MOOD_FLAG_DUMB_FLEE)
{
if(MG_GoToRandomBuoy(self))
self->monsterinfo.searchType = SEARCH_BUOY;
else
{
ai_flee(self, dist);
return;
}
}
if(!DEACTIVATE_BUOYS)
{
if(self->monsterinfo.aiflags & AI_USING_BUOYS)
{
if(!(self->monsterinfo.aiflags&AI_STRAIGHT_TO_ENEMY))
{
if(self->pathfind_nextthink<=level.time)
{
MG_BuoyNavigate(self);
self->pathfind_nextthink = level.time + 0.1;//0.3;-maybe TOO optimized, trying every frame again, take out of generic mood think?
//don't pathfind for the next 3 frames.
}
}
}
}
if (self->monsterinfo.aiflags & AI_STAND_GROUND)
{//just face enemy
turnamt = Q_fabs(ai_face_goal(self));
return;
}
#ifdef _DEVEL
if(self->goalentity == self->enemy)
{
//sfs--only do this visibility check when debugging (gets expensive at big distances)
if(MGAI_DEBUG && !visible(self, self->enemy))
{
gi.dprintf("ERROR: goal is invis enemy!\n");
}
}
#endif
if(dist)
if(!MG_MoveToGoal (self, dist))
{
if(self->classID == CID_SSITHRA)
ssithraCheckJump(self);
}
else
i = 0;
if(self->classID!=CID_ASSASSIN)//does his own checks
if(classStatics[self->classID].msgReceivers[MSG_EVADE])
{//check for if going to be hit and evade
MG_CheckEvade(self);
}
}
void mg_ai_charge (edict_t *self, float dist)
{
vec3_t v;
if(!self->enemy)
{
#ifdef _DEVEL
gi.dprintf("ERROR: AI_CHARGE at a NULL enemy!\n");
#endif
return;//send stand MSG?
}
VectorSubtract (self->enemy->s.origin, self->s.origin, v);
self->ideal_yaw = vectoyaw(v);
MG_ChangeYaw (self);
if (dist)
MG_WalkMove (self, self->s.angles[YAW], dist);
if(self->classID!=CID_ASSASSIN)//does his own checks
if(classStatics[self->classID].msgReceivers[MSG_EVADE])
{//check for if going to be hit and evade
MG_CheckEvade(self);
}
}
qboolean canmove (edict_t *self)
{
if( self->movetype!=PHYSICSTYPE_NONE &&
self->movetype!=PHYSICSTYPE_PUSH)
return true;
return false;
}
void mg_remove_body(edict_t *self)
{
vec3_t origin;
int flag = 0;
VectorCopy(self->s.origin, origin);
origin[2] += (self->mins[2] + 8.0f);
if(self->classID == CID_RAT)
flag |= CEF_FLAG6;
gi.CreateEffect(NULL, FX_CORPSE_REMOVE, flag, origin, "");
G_SetToFree(self);
}
void body_phase_out (edict_t *self)
{
int interval = 30;
if(self->s.color.a > interval)
{
self->s.color.a -= irand(interval/2, interval);
self->post_think = body_phase_out;
self->next_post_think = level.time + 0.05;
}
else
{
self->s.color.a = 0;
self->post_think = NULL;
self->next_post_think = -1;
G_SetToFree(self);
}
}
trace_t MG_AirMove(edict_t *self, vec3_t goalpos, float dist)
{
trace_t trace;
vec3_t endpos, movedir;
VectorSubtract(goalpos, self->s.origin, movedir);
VectorNormalize(movedir);
VectorMA(self->s.origin, dist, movedir, endpos);
gi.trace(self->s.origin, self->mins, self->maxs, endpos, self, MASK_MONSTERSOLID, &trace);
if(trace.allsolid || trace.startsolid || trace.fraction <= 0.01)
{
trace.succeeded = false;
return trace;
}
VectorCopy(trace.endpos, self->s.origin);
gi.linkentity(self);
trace.succeeded = true;
return trace;
}
static int FRONT = 0;
static int BACK = 1;
static int RIGHT = 2;
static int LEFT = 3;
static float MIN_DROP_DIST = 0.125f;
void MG_PostDeathThink (edict_t *self)
{
float mostdist;
trace_t trace1, trace2, trace3, trace4, movetrace;
vec3_t org, endpos, startpos, forward, right;
int whichtrace = 0;
float cornerdist[4];
qboolean frontbackbothclear = false;
qboolean rightleftbothclear = false;
self->post_think = body_phase_out;
self->next_post_think = level.time + 10;
if(!self->groundentity || Vec3NotZero(self->velocity))
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Falling!\n");
#endif
if(self->groundentity&&self->friction == 1.0)//check avelocity?
pitch_roll_for_slope(self, NULL);
self->post_think = MG_PostDeathThink;
self->next_post_think = level.time + 0.1;
return;
}
cornerdist[FRONT] = cornerdist[BACK] = cornerdist[RIGHT] = cornerdist[LEFT] = 0.0f;
mostdist = MIN_DROP_DIST;
AngleVectors(self->s.angles, forward, right, NULL);
VectorCopy(self->s.origin, org);
org[2]+=self->mins[2];
VectorMA(org, self->dead_size, forward, startpos);
VectorCopy(startpos, endpos);
endpos[2]-=128;
gi.trace(startpos, vec3_origin, vec3_origin, endpos, self, MASK_SOLID,&trace1);
if(!trace1.allsolid&&!trace1.startsolid)
{
cornerdist[FRONT] = trace1.fraction;
if(trace1.fraction>mostdist)
{
mostdist = trace1.fraction;
whichtrace = 1;
}
}
VectorMA(org, -self->dead_size, forward, startpos);
VectorCopy(startpos, endpos);
endpos[2]-=128;
gi.trace(startpos, vec3_origin, vec3_origin, endpos, self, MASK_SOLID,&trace2);
if(!trace2.allsolid&&!trace2.startsolid)
{
cornerdist[BACK] = trace2.fraction;
if(trace2.fraction>mostdist)
{
mostdist = trace2.fraction;
whichtrace = 2;
}
}
VectorMA(org, self->dead_size/2, right, startpos);
VectorCopy(startpos, endpos);
endpos[2]-=128;
gi.trace(startpos, vec3_origin, vec3_origin, endpos, self, MASK_SOLID,&trace3);
if(!trace3.allsolid&&!trace3.startsolid)
{
cornerdist[RIGHT] = trace3.fraction;
if(trace3.fraction>mostdist)
{
mostdist = trace3.fraction;
whichtrace = 3;
}
}
VectorMA(org, -self->dead_size/2, right, startpos);
VectorCopy(startpos, endpos);
endpos[2]-=128;
gi.trace(startpos, vec3_origin, vec3_origin, endpos, self, MASK_SOLID,&trace4);
if(!trace4.allsolid&&!trace4.startsolid)
{
cornerdist[LEFT] = trace4.fraction;
if(trace4.fraction>mostdist)
{
mostdist = trace4.fraction;
whichtrace = 4;
}
}
//OK! Now if two opposite sides are hanging, use a third if any, else, do nothing
if(cornerdist[FRONT] > MIN_DROP_DIST && cornerdist[BACK] > MIN_DROP_DIST)
frontbackbothclear = true;
if(cornerdist[RIGHT] > MIN_DROP_DIST && cornerdist[LEFT] > MIN_DROP_DIST)
rightleftbothclear = true;
if(frontbackbothclear && rightleftbothclear)
return;
if(frontbackbothclear)
{
if(cornerdist[RIGHT] > MIN_DROP_DIST)
whichtrace = 3;
else if(cornerdist[LEFT] > MIN_DROP_DIST)
whichtrace = 4;
else
return;
}
if(rightleftbothclear)
{
if(cornerdist[FRONT] > MIN_DROP_DIST)
whichtrace = 1;
else if(cornerdist[BACK] > MIN_DROP_DIST)
whichtrace = 2;
else
return;
}
switch(whichtrace)
{//check for stuck
case 1:
VectorMA(self->s.origin, self->maxs[0], forward, endpos);
gi.trace(self->s.origin, self->mins, self->maxs, endpos, self, MASK_MONSTERSOLID,&movetrace);
if(movetrace.allsolid||movetrace.startsolid||movetrace.fraction<1.0)
if(canmove(movetrace.ent))
whichtrace = -1;
else
whichtrace = 0;
break;
case 2:
VectorMA(self->s.origin, -self->maxs[0], forward, endpos);
gi.trace(self->s.origin, self->mins, self->maxs, endpos, self, MASK_MONSTERSOLID,&movetrace);
if(movetrace.allsolid||movetrace.startsolid||movetrace.fraction<1.0)
if(canmove(movetrace.ent))
whichtrace = -1;
else
whichtrace = 0;
break;
case 3:
VectorMA(self->s.origin, self->maxs[0], right, endpos);
gi.trace(self->s.origin, self->mins, self->maxs, endpos, self, MASK_MONSTERSOLID,&movetrace);
if(movetrace.allsolid||movetrace.startsolid||movetrace.fraction<1.0)
if(canmove(movetrace.ent))
whichtrace = -1;
else
whichtrace = 0;
break;
case 4:
VectorMA(self->s.origin, -self->maxs[0], right, endpos);
gi.trace(self->s.origin, self->mins, self->maxs, endpos, self, MASK_MONSTERSOLID,&movetrace);
if(movetrace.allsolid||movetrace.startsolid||movetrace.fraction<1.0)
if(canmove(movetrace.ent))
whichtrace = -1;
else
whichtrace = 0;
break;
}
switch(whichtrace)
{
case 1:
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Forward trace %f\n", trace1.fraction);
#endif
VectorMA(self->velocity, 200, forward, self->velocity);
if(trace1.fraction >= 0.9)
{
//can't anymore, origin not in center of deathframe!
// self->avelocity[PITCH] = -300;
self->friction = 1.0;
}
else
{
pitch_roll_for_slope(self, &trace1.plane.normal);
self->friction = trace1.plane.normal[2] * 0.1;
}
self->post_think = MG_PostDeathThink;
self->next_post_think = level.time + 0.1;
return;
break;
case 2:
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("back trace %f\n", trace2.fraction);
#endif
VectorMA(self->velocity, -200, forward, self->velocity);
if(trace2.fraction >= 0.9)
{
//can't anymore, origin not in center of deathframe!
// self->avelocity[PITCH] = 300;
self->friction = 1.0;
}
else
{
pitch_roll_for_slope(self, &trace2.plane.normal);
self->friction = trace2.plane.normal[2] * 0.1;
}
self->post_think = MG_PostDeathThink;
self->next_post_think = level.time + 0.1;
return;
break;
case 3:
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Right trace %f\n", trace3.fraction);
#endif
VectorMA(self->velocity, 200, right, self->velocity);
if(trace3.fraction >= 0.9)
{
//can't anymore, origin not in center of deathframe!
// self->avelocity[ROLL] = -300;
self->friction = 1.0;
}
else
{
pitch_roll_for_slope(self, &trace3.plane.normal);
self->friction = trace3.plane.normal[2] * 0.1;
}
self->post_think = MG_PostDeathThink;
self->next_post_think = level.time + 0.1;
return;
break;
case 4:
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Left trace %f\n", trace4.fraction);
#endif
VectorMA(self->velocity, -200, right, self->velocity);
if(trace4.fraction >= 0.9)
{
//can't anymore, origin not in center of deathframe!
// self->avelocity[ROLL] = 300;
self->friction = 1.0;
}
else
{
pitch_roll_for_slope(self, &trace4.plane.normal);
self->friction = trace4.plane.normal[2] * 0.1;
}
self->post_think = MG_PostDeathThink;
self->next_post_think = level.time + 0.1;
return;
break;
}
//on solid ground
if(whichtrace == -1)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Deadmonster slide = stuck! (size is %4.2f)\n", self->dead_size);
#endif
self->post_think = MG_PostDeathThink;
self->next_post_think = level.time + 2;
return;
}
#ifdef _DEVEL
else if(MGAI_DEBUG)
gi.dprintf("Deadmonster slide = On ground (size was %4.2f)\n", self->dead_size);
#endif
self->friction = 1.0;
VectorClear(self->avelocity);
pitch_roll_for_slope(self, NULL);
if(!self->s.color.r)
self->s.color.r = 255;
if(!self->s.color.g)
self->s.color.g = 255;
if(!self->s.color.b)
self->s.color.b = 255;
self->s.color.a = 255;
self->post_think = body_phase_out;
if(self->classID == CID_RAT)
self->next_post_think = level.time + flrand(3, 7);
else
self->next_post_think = level.time + flrand(10, 20);
gi.linkentity (self);
}
void MG_CheckLanded (edict_t *self, float next_anim)
{
vec3_t pos;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("self->velocity %f %f %f\n", self->velocity[0], self->velocity[1], self->velocity[2]);
#endif
if(self->groundentity)
SetAnim(self, (int)next_anim);
else if(self->velocity[2]<0)
{
VectorCopy(self->s.origin, pos);
pos[2] += self->mins[2];
VectorMA(pos, 0.5, self->velocity, pos);
if(gi.pointcontents(pos)&CONTENTS_SOLID)
SetAnim(self, (int)next_anim);
}
}
void MG_InAirMove (edict_t *self, float fwdspd,float upspd,float rtspd)
{//simple addition of velocity, if on ground or not
vec3_t up, forward, right;
if(self->groundentity)//on ground
return;
AngleVectors(self->s.angles, forward, right, up);
VectorMA(self->velocity, upspd, up, self->velocity);
VectorMA(self->velocity, fwdspd, forward, self->velocity);
VectorMA(self->velocity, rtspd, right, self->velocity);
}
void MG_ApplyJump (edict_t *self)
{
self->jump_time = level.time + 0.5;
VectorCopy(self->movedir, self->velocity);
VectorNormalize(self->movedir);
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Jump velocity will be: %4.2f %4.2f %4.2f\n", self->velocity[0], self->velocity[1], self->velocity[2]);
#endif
self->monsterinfo.aiflags &= ~AI_OVERRIDE_GUIDE;
}
void MG_NoBlocking (edict_t *self)
{
self->svflags |= SVF_DEADMONSTER; // now treat as a different content type
self->msgHandler = DeadMsgHandler; // no more messages at all
}
qboolean MG_GetTargOrg (edict_t *self, vec3_t targ_org)
{
if (self->monsterinfo.searchType == SEARCH_BUOY)
{
if(self->buoy_index < 0 || self->buoy_index > level.active_buoys)
{
VectorClear(targ_org);
return false;
}
VectorCopy(level.buoy_list[self->buoy_index].origin, self->monsterinfo.nav_goal);
VectorCopy(self->monsterinfo.nav_goal, targ_org);
}
else
{
if(!self->goalentity)
{
VectorClear(targ_org);
return false;
}
VectorCopy(self->goalentity->s.origin, targ_org);
}
return true;
}
/*
qboolean EqualAngle(float angle1, float angle2, float leniency)
Sees if the two angles are within leniency degrees of each other
*/
qboolean EqualAngle(float angle1, float angle2, float leniency)
{
float diff;
if(angle1 < -180)
angle1 += 360;
else if(angle1 > 180)
angle1 -= 360;
if(angle2 < -180)
angle2 += 360;
else if(angle2 > 180)
angle2 -= 360;
diff = angle1 - angle2;
if(diff < -180)
diff += 360;
else if(diff > 180)
diff -= 360;
if(fabs(diff) > leniency)
return false;
return true;
}
/*
qboolean ok_to_break (edict_t *target)
Ok to just smash this damn thing in my way?
*/
qboolean ok_to_break (edict_t *target)
{
if(!target)
return false;
if(!target->takedamage)
return false;
if(target->health>MAX_BLOCKING_THING_HEALTH)//general damage for pots, barrels, etc.
return false;
if(target->targetname)//supposed to be triggered for some reason
return false;
if(target->svflags&SVF_MONSTER)//another monster
return false;
if(Vec3IsZero(target->s.origin))//breakable_brushes have no origin
return false;
return true;//break it!
}
qboolean MG_MoveToGoal (edict_t *self, float dist)
{
trace_t trace;
float turnamt, distloss, adj_dist, save_yaw, save_yaw_speed, WallDot;//, save_ideal_yaw;
vec3_t mins, maxs, source, goal_dir;//, vec, save_org;
qboolean goal_vis=false, hitworld = false, new_best_yaw = false;
float stepsize, goal_dist, oby;
if(self->classID == CID_TBEAST)
stepsize = STEPSIZE * 3;
else
stepsize = STEPSIZE;
if(!self->groundentity&&!(self->flags&FL_SWIM)&&!(self->flags&FL_FLY))
return false;//in air!
trace.succeeded = false;
if(self->classID != CID_GORGON)//they do their own yawing
MG_FaceGoal(self, false);//get ideal yaw, but don't turn
//are we very close to our goal? problem: what if something in between?
if(!EqualAngle(self->s.angles[YAW], self->ideal_yaw, self->yaw_speed))
{//we aren't really facing our ideal yet
if(self->monsterinfo.searchType == SEARCH_BUOY||self->ai_mood == AI_MOOD_NAVIGATE)
{
VectorSubtract(self->monsterinfo.nav_goal, self->s.origin, goal_dir);
goal_dist = VectorNormalize(goal_dir);
if(goal_dist < (self->maxs[0] + 24 + dist))
{//we're close to our goal
MG_ChangeWhichYaw(self, YAW_IDEAL);
return true;//so close to enemy, just turn, no movement - not if rat?
}
}
else if(self->enemy)
{
VectorSubtract(self->monsterinfo.nav_goal, self->s.origin, goal_dir);
goal_dist = VectorNormalize(goal_dir);
if(goal_dist < (self->maxs[0] + self->enemy->maxs[0] + dist*2))
{//we're close to our goal
MG_ChangeWhichYaw(self, YAW_IDEAL);
return true;//so close to enemy, just turn, no movement - not if rat?
}
}
}
if(self->monsterinfo.idle_time == -1)
{//have been told to just turn to ideal_yaw
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_IDEAL));
//keep turning towards ideal until facing it
if(turnamt < 1)
self->monsterinfo.idle_time = 0;
else
return true;
}
else if(self->monsterinfo.idle_time > level.time)
{//using best_move_yaw
if(EqualAngle(self->s.angles[YAW], self->best_move_yaw, 5))
{//do a test move in the direction I would like to go:
if(MG_TestMove(self, self->ideal_yaw, dist))
{//can move in that dir turn there for rest of this
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move in ideal tested true while using best_move...!\n");
#endif
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_IDEAL));
//keep turning towards ideal until facing it
if(turnamt < 1)
self->monsterinfo.idle_time = 0;
else
{
self->monsterinfo.idle_time = -1;
return true;
}
}
}
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));//turn to temp yaw
}
else
{//using ideal_yaw
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_IDEAL));
}
distloss = turnamt/self->yaw_speed * 0.8;//0.3;
adj_dist = dist - (dist * distloss);
trace = MG_WalkMove(self, self->s.angles[YAW], dist);
if(trace.succeeded)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move forward succeeded!\n");
#endif
return true;
}
else if(self->classID == CID_TBEAST)
{
if(trace.fraction<1.0)
VectorCopy(trace.endpos, self->s.origin);
}
//if facing best_move_yaw and can't move that way, stop trying in that dir now.
if(self->monsterinfo.idle_time > level.time && self->s.angles[YAW] == self->best_move_yaw)
{
new_best_yaw = true;
oby = self->best_move_yaw;
self->monsterinfo.idle_time = 0;
}
//bumped into something
if(trace.ent)
{
if(!stricmp(trace.ent->classname, "worldspawn"))
hitworld = true;
else
hitworld = false;
if(trace.ent == self->enemy)
{//bumped into enemy, go get him!
if(!(self->monsterinfo.aiflags & AI_COWARD) &&
(!(self->monsterinfo.aiflags&AI_FLEE) || self->monsterinfo.flee_finished < level.time))
{
if(!(self->monsterinfo.aiflags&AI_NO_MELEE))
{
if(!(self->ai_mood_flags&AI_MOOD_FLAG_IGNORE_ENEMY))
{
if(classStatics[self->classID].msgReceivers[MSG_MELEE] && infront(self, self->enemy))
{
QPostMessage(self, MSG_MELEE, PRI_DIRECTIVE, NULL);
return true;
}
}
}
}
}
else if(trace.ent->svflags & SVF_MONSTER)
{//if bumped into a monster that's not after an enemy but not ambushing, bring him along
if(!trace.ent->enemy)
{
if(trace.ent->health>0 && !trace.ent->monsterinfo.awake)
{
if(!(trace.ent->spawnflags & MSF_AMBUSH))
{
if(self->enemy)
{
if(self->enemy->client)
{
trace.ent->enemy = self->enemy;
FoundTarget(trace.ent, false);
}
}
}
}
}
}
/*
//FIXME: this needs to make sure they can break it
//also: do not do this if the monsters' enemy is visible (MASK_SOLID check, though)
else if(!irand(0, 5))
{//fixme: need to make sure the melee anims can break this
if(self->classID > CID_RAT && classStatics[self->classID].msgReceivers[MSG_MELEE])
{
if(!(self->monsterinfo.aiflags&AI_NO_MELEE))
{
if(ok_to_break(trace.ent))
{
if(infront(self, trace.ent))
{//smash it!
if(MGAI_DEBUG)
gi.dprintf("%s breaking blocking %s!\n", self->classname, trace.ent->classname);
self->monsterinfo.aiflags |= AI_STRAIGHT_TO_ENEMY;//go straight at enemy, not buoys
self->oldenemy_debounce_time = level.time + 7;//attack it for 7 seconds max
self->oldenemy = self->enemy;//remember who I was after
self->enemy = self->goalentity = trace.ent;//let's nail this sucker
QPostMessage(self, MSG_MELEE, PRI_DIRECTIVE, NULL);//SMACK!
return true;
}
}
}
}
}
*/
if(!hitworld)
{
if(self->monsterinfo.idle_time < level.time)
{//not already following a weird dir
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move forward hit wall, newdir\n");
#endif
self->monsterinfo.idle_time = level.time + flrand(0.5, 1.2);
self->best_move_yaw = anglemod(180 + self->ideal_yaw);
MG_NewDir(self, dist);
}
return false;
}
#ifdef _DEVEL
else if(MGAI_DEBUG)
gi.dprintf("Bumped world - t_f: %f t_allsolid: %d, t_startsolid %d\n",trace.fraction, trace.allsolid, trace.startsolid);
#endif
}
//Ledge?
if((trace.fraction >= 0.5 + distloss ||self->classID == CID_ASSASSIN) && !trace.allsolid && !trace.startsolid)//a ledge
{//why not tracefraction == 1.0?
if(!(self->spawnflags & MSF_FIXED))
{
if(MG_CheckJump(self))//can jump off it
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move forward jumped off ledge!\n");
#endif
return true;
}
else if(self->classID == CID_ASSASSIN)
{
if(MG_ExtraCheckJump(self))
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move straight to goal extra jumped off ledge!\n");
#endif
return true;
}
}
}
if(trace.fraction >= 0.5)//even assassins skip this
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Can't jump off, getting newdir\n");
#endif
if(self->monsterinfo.idle_time < level.time)
{//not already following some other dir, pick one
self->monsterinfo.idle_time = level.time + flrand(1, 2);
self->best_move_yaw = anglemod(180 + self->ideal_yaw);
MG_NewDir(self, dist);//what if this fails to set one?
}
return false;
}
}
#ifdef _DEVEL
if(MGAI_DEBUG)
if(trace.allsolid || trace.startsolid)
gi.dprintf("Move forward allsolid or startsolid!\n");
#endif
//FROM HERE ON, ONLY CHANGES DIR, WILL NOT MOVE!
//otherwise, go around it... this ONLY???
//lock into this new yaw for a bit
if(self->monsterinfo.idle_time > level.time)
{//heading somewhere for a few secs, turn here
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Turning to newdir, not bumping\n");
#endif
/* turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));
distloss = turnamt/self->yaw_speed * 0.3;
dist -= (dist * distloss);*/
return false;
}
if((hitworld || irand(0,10)<6)&&!goal_vis)
self->monsterinfo.idle_time = level.time + flrand(1, 2);
else
self->monsterinfo.idle_time = level.time + flrand(0.5, 1.25);
self->best_move_yaw = anglemod(180 + self->ideal_yaw);
//if hit a wall and close to ideal yaw (with 5), try a new dir
if(Vec3NotZero(trace.plane.normal)&&
EqualAngle(self->s.angles[YAW], self->ideal_yaw, 5))
{//a wall?
vec3_t wall_angles, wall_right, self_forward, new_forward, vf;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move forward hit wall, checking left/right/back...\n");
#endif
//If facing a wall, turn faster, more facing the wall, faster the turn
save_yaw_speed = self->yaw_speed;
AngleVectors(self->s.angles, self_forward, NULL, NULL);
WallDot = DotProduct(trace.plane.normal, self_forward);
if(WallDot>0)
WallDot = 0;//-1 to 0
self->yaw_speed *= 1.25 - WallDot;//facing wall head-on = 2.25 times normal yaw speed
vectoangles(trace.plane.normal, wall_angles);
AngleVectors(wall_angles, NULL, wall_right, NULL);
if(goal_vis)
{//can see goal, turn towards IT first
VectorSubtract(self->goalentity->s.origin, self->s.origin, self_forward);
VectorNormalize(self_forward);
}
//Get closest angle off that wall to move in
if(DotProduct(wall_right,self_forward)>0)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turning left\n");
#endif
VectorCopy(wall_right, new_forward);
}
else
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turning right\n");
#endif
VectorScale(wall_right, -1, new_forward);
}
if(irand(0,10)<3)//30% chance of trying other way first
VectorScale(new_forward, -1, new_forward);
self->best_move_yaw=vectoyaw(new_forward);
if(new_best_yaw && self->best_move_yaw == oby)
{
VectorScale(new_forward, -1, new_forward);
self->best_move_yaw=vectoyaw(new_forward);
}
//make sure we can move in chosen dir
//set up mins and maxes for these moves
VectorCopy(self->mins, mins);
VectorCopy(self->maxs, maxs);
//Account for STEPSIZE
mins[2] += stepsize;
if(mins[2] >= self->maxs[2])
mins[2] = self->maxs[2] - 1;
//remember yaw in case all these fail!
save_yaw = self->s.angles[YAW];
//Haven't yawed yet, so this is okay
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));
distloss = turnamt/self->yaw_speed * 0.8;//0.3;
adj_dist = dist - (dist * distloss);
VectorCopy(new_forward, vf);
//AngleVectors(self->s.angles, vf, NULL, NULL);
VectorCopy(self->s.origin, source);
VectorMA(source, adj_dist, vf, source);
gi.trace (self->s.origin, mins, self->maxs, source, self, MASK_SOLID,&trace);//was MASK_SHOT
if (trace.fraction < 1||trace.allsolid||trace.startsolid)
{//Uh oh, try other way
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turn other way\n");
#endif
VectorScale(new_forward, -1, new_forward);
self->best_move_yaw=vectoyaw(new_forward);
//restore yaw
self->s.angles[YAW] = save_yaw;
//try new dir
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));
distloss = turnamt/self->yaw_speed * 0.8;//0.3;
adj_dist = dist - (dist * distloss);
VectorCopy(new_forward, vf);
//AngleVectors(self->s.angles, vf, NULL, NULL);
VectorMA(source, adj_dist, vf, source);
//Account for STEPSIZE
mins[2] += stepsize;
if(mins[2] >= self->maxs[2])
mins[2] = self->maxs[2] - 1;
gi.trace (self->s.origin, mins, self->maxs, source, self, MASK_SOLID,&trace);//was MASK_SHOT
if (trace.fraction < 1||trace.allsolid||trace.startsolid)
{//Uh oh! Go straight away from wall
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turn all the way around\n");
#endif
self->best_move_yaw=wall_angles[YAW];
//restore yaw
self->s.angles[YAW] = save_yaw;
//start turning this move, but don't actually move until next time
MG_ChangeWhichYaw(self, YAW_BEST_MOVE);
}
}
self->yaw_speed = save_yaw_speed;
return false;
}
else//keep turning to ideal
self->monsterinfo.idle_time = 0;
//Must have bumped into something very strange (other monster?)
//just pick a new random dir
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Don't know what I hit, choosing newdir for a second\n");
#endif
MG_NewDir(self, dist);
return false;
}
qboolean MG_SwimFlyToGoal (edict_t *self, float dist)
{
trace_t trace;
float turnamt, distloss, adj_dist, save_yaw, save_yaw_speed, WallDot;//, save_ideal_yaw;
vec3_t mins, maxs, source, goal_dir, goalpos;//, vec, save_org;
qboolean goal_vis=false, hitworld = false, new_best_yaw = false;
float goal_dist, oby;
trace.succeeded = false;
if(self->classID != CID_GORGON)//they do their own yawing
MG_FaceGoal(self, false);//get ideal yaw, but don't turn
//are we very close to our goal? problem: what if something in between?
if(!EqualAngle(self->s.angles[YAW], self->ideal_yaw, self->yaw_speed))
{//we aren't really facing our ideal yet
if(self->monsterinfo.searchType == SEARCH_BUOY||self->ai_mood == AI_MOOD_NAVIGATE)
{
VectorSubtract(self->monsterinfo.nav_goal, self->s.origin, goal_dir);
goal_dist = VectorNormalize(goal_dir);
if(goal_dist < (self->maxs[0] + 24 + dist))
{//we're close to our goal
MG_ChangeWhichYaw(self, YAW_IDEAL);
return true;//so close to enemy, just turn, no movement - not if rat?
}
}
else if(self->enemy)
{
VectorSubtract(self->monsterinfo.nav_goal, self->s.origin, goal_dir);
goal_dist = VectorNormalize(goal_dir);
if(goal_dist < (self->maxs[0] + self->enemy->maxs[0] + dist*2))
{//we're close to our goal
MG_ChangeWhichYaw(self, YAW_IDEAL);
return true;//so close to enemy, just turn, no movement - not if rat?
}
}
}
if(self->monsterinfo.idle_time == -1)
{//have been told to just turn to ideal_yaw
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_IDEAL));
//keep turning towards ideal until facing it
if(turnamt < 1)
self->monsterinfo.idle_time = 0;
else
return true;
}
else if(self->monsterinfo.idle_time > level.time)
{//using best_move_yaw
if(EqualAngle(self->s.angles[YAW], self->best_move_yaw, 5))
{//do a test move in the direction I would like to go:
if(MG_TestMove(self, self->ideal_yaw, dist))
{//can move in that dir turn there for rest of this
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move in ideal tested true while using best_move...!\n");
#endif
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_IDEAL));
//keep turning towards ideal until facing it
if(turnamt < 1)
self->monsterinfo.idle_time = 0;
else
{
self->monsterinfo.idle_time = -1;
return true;
}
}
}
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));//turn to temp yaw
}
else
{//using ideal_yaw
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_IDEAL));
}
distloss = turnamt/self->yaw_speed * 0.8;//0.3;
adj_dist = dist - (dist * distloss);
MG_GetGoalPos(self, goalpos);
trace = MG_AirMove(self, goalpos, dist);
if(trace.succeeded)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move forward succeeded!\n");
#endif
return true;
}
//if facing best_move_yaw and can't move that way, stop trying in that dir now.
if(self->monsterinfo.idle_time > level.time && self->s.angles[YAW] == self->best_move_yaw)
{
new_best_yaw = true;
oby = self->best_move_yaw;
self->monsterinfo.idle_time = 0;
}
//bumped into something
if(trace.ent)
{
if(!stricmp(trace.ent->classname, "worldspawn"))
hitworld = true;
else
hitworld = false;
if(trace.ent == self->enemy)
{//bumped into enemy, go get him!
if(!(self->monsterinfo.aiflags & AI_COWARD) &&
(!(self->monsterinfo.aiflags&AI_FLEE) || self->monsterinfo.flee_finished < level.time))
{
if(!(self->monsterinfo.aiflags&AI_NO_MELEE))
{
if(!(self->ai_mood_flags&AI_MOOD_FLAG_IGNORE_ENEMY))
{
if(classStatics[self->classID].msgReceivers[MSG_MELEE] && infront(self, self->enemy))
{
QPostMessage(self, MSG_MELEE, PRI_DIRECTIVE, NULL);
return true;
}
}
}
}
}
else if(trace.ent->svflags & SVF_MONSTER)
{//if bumped into a monster that's not after an enemy but not ambushing, bring him along
if(!trace.ent->enemy)
{
if(trace.ent->health>0 && !trace.ent->monsterinfo.awake)
{
if(!(trace.ent->spawnflags & MSF_AMBUSH))
{
if(self->enemy)
{
if(self->enemy->client)
{
trace.ent->enemy = self->enemy;
FoundTarget(trace.ent, false);
}
}
}
}
}
}
if(!hitworld)
{
if(self->monsterinfo.idle_time < level.time)
{//not already following a weird dir
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move forward hit wall, newdir\n");
#endif
self->monsterinfo.idle_time = level.time + flrand(0.5, 1.2);
self->best_move_yaw = anglemod(180 + self->ideal_yaw);
MG_NewDir(self, dist);
}
return false;
}
#ifdef _DEVEL
else if(MGAI_DEBUG)
gi.dprintf("Bumped world - t_f: %f t_allsolid: %d, t_startsolid %d\n",trace.fraction, trace.allsolid, trace.startsolid);
#endif
}
//Ledge?
/* if(trace.fraction >= 0.5 + distloss && !trace.allsolid && !trace.startsolid)//a ledge
{//why not tracefraction == 1.0?
if(trace.fraction >= 0.5)//even assassins skip this
{
if(MGAI_DEBUG)
gi.dprintf("Can't jump off, getting newdir\n");
if(self->monsterinfo.idle_time < level.time)
{//not already following some other dir, pick one
self->monsterinfo.idle_time = level.time + flrand(1, 2);
self->best_move_yaw = anglemod(180 + self->ideal_yaw);
MG_NewDir(self, dist);//what if this fails to set one?
}
return false;
}
}*/
#ifdef _DEVEL
if(MGAI_DEBUG)
if(trace.allsolid || trace.startsolid)
gi.dprintf("Move forward allsolid or startsolid!\n");
#endif
//FROM HERE ON, ONLY CHANGES DIR, WILL NOT MOVE!
//otherwise, go around it... this ONLY???
//lock into this new yaw for a bit
if(self->monsterinfo.idle_time > level.time)
{//heading somewhere for a few secs, turn here
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Turning to newdir, not bumping\n");
#endif
/* turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));
distloss = turnamt/self->yaw_speed * 0.3;
dist -= (dist * distloss);*/
return false;
}
if((hitworld || irand(0,10)<6)&&!goal_vis)
self->monsterinfo.idle_time = level.time + flrand(1, 2);
else
self->monsterinfo.idle_time = level.time + flrand(0.5, 1.25);
self->best_move_yaw = anglemod(180 + self->ideal_yaw);
//if hit a wall and close to ideal yaw (with 5), try a new dir
if(Vec3NotZero(trace.plane.normal)&&
EqualAngle(self->s.angles[YAW], self->ideal_yaw, 5))
{//a wall?
vec3_t wall_angles, wall_right, self_forward, new_forward, vf;
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Move forward hit wall, checking left/right/back...\n");
#endif
//If facing a wall, turn faster, more facing the wall, faster the turn
save_yaw_speed = self->yaw_speed;
AngleVectors(self->s.angles, self_forward, NULL, NULL);
WallDot = DotProduct(trace.plane.normal, self_forward);
if(WallDot>0)
WallDot = 0;//-1 to 0
self->yaw_speed *= 1.25 - WallDot;//facing wall head-on = 2.25 times normal yaw speed
vectoangles(trace.plane.normal, wall_angles);
AngleVectors(wall_angles, NULL, wall_right, NULL);
if(goal_vis)
{//can see goal, turn towards IT first
VectorSubtract(self->goalentity->s.origin, self->s.origin, self_forward);
VectorNormalize(self_forward);
}
//Get closest angle off that wall to move in
if(DotProduct(wall_right,self_forward)>0)
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turning left\n");
#endif
VectorCopy(wall_right, new_forward);
}
else
{
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turning right\n");
#endif
VectorScale(wall_right, -1, new_forward);
}
if(irand(0,10)<3)//30% chance of trying other way first
VectorScale(new_forward, -1, new_forward);
self->best_move_yaw=vectoyaw(new_forward);
if(new_best_yaw && self->best_move_yaw == oby)
{
VectorScale(new_forward, -1, new_forward);
self->best_move_yaw=vectoyaw(new_forward);
}
//make sure we can move in chosen dir
//set up mins and maxes for these moves
VectorCopy(self->mins, mins);
VectorCopy(self->maxs, maxs);
//remember yaw in case all these fail!
save_yaw = self->s.angles[YAW];
//Haven't yawed yet, so this is okay
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));
distloss = turnamt/self->yaw_speed * 0.8;//0.3;
adj_dist = dist - (dist * distloss);
VectorCopy(new_forward, vf);
//AngleVectors(self->s.angles, vf, NULL, NULL);
VectorCopy(self->s.origin, source);
VectorMA(source, adj_dist, vf, source);
gi.trace (self->s.origin, mins, self->maxs, source, self, MASK_SOLID,&trace);//was MASK_SHOT
if (trace.fraction < 1||trace.allsolid||trace.startsolid)
{//Uh oh, try other way
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turn other way\n");
#endif
VectorScale(new_forward, -1, new_forward);
self->best_move_yaw=vectoyaw(new_forward);
//restore yaw
self->s.angles[YAW] = save_yaw;
//try new dir
turnamt = Q_fabs(MG_ChangeWhichYaw(self, YAW_BEST_MOVE));
distloss = turnamt/self->yaw_speed * 0.8;//0.3;
adj_dist = dist - (dist * distloss);
VectorCopy(new_forward, vf);
//AngleVectors(self->s.angles, vf, NULL, NULL);
VectorMA(source, adj_dist, vf, source);
gi.trace (self->s.origin, mins, self->maxs, source, self, MASK_SOLID,&trace);//was MASK_SHOT
if (trace.fraction < 1||trace.allsolid||trace.startsolid)
{//Uh oh! Go straight away from wall
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("turn all the way around\n");
#endif
self->best_move_yaw=wall_angles[YAW];
//restore yaw
self->s.angles[YAW] = save_yaw;
//start turning this move, but don't actually move until next time
MG_ChangeWhichYaw(self, YAW_BEST_MOVE);
}
}
self->yaw_speed = save_yaw_speed;
return false;
}
else//keep turning to ideal
self->monsterinfo.idle_time = 0;
//Must have bumped into something very strange (other monster?)
//just pick a new random dir
#ifdef _DEVEL
if(MGAI_DEBUG)
gi.dprintf("Don't know what I hit, choosing newdir for a second\n");
#endif
MG_NewDir(self, dist);
return false;
}
Reference in a new issue View git blame Copy permalink