ioquake/jedi-academy
0
0
Fork 0
mirror of https://github.com/ioquake/jedi-academy.git synced 2024-11-22 12:22:23 +00:00
Code Issues Projects Releases Packages Wiki Activity
jedi-academy/code/game/AI_Utils.cpp

1056 lines
26 KiB
C++
Raw Blame History

// These utilities are meant for strictly non-player, non-team NPCs.
// These functions are in their own file because they are only intended
// for use with NPCs who's logic has been overriden from the original
// AI code, and who's code resides in files with the AI_ prefix.
// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
#include "g_headers.h"
#include "b_local.h"
#include "g_nav.h"
#include "g_navigator.h"
#define MAX_RADIUS_ENTS 128
#define DEFAULT_RADIUS 45
//extern CNavigator navigator;
extern cvar_t *d_noGroupAI;
qboolean AI_ValidateGroupMember( AIGroupInfo_t *group, gentity_t *member );
/*
-------------------------
AI_GetGroupSize
-------------------------
*/
int AI_GetGroupSize( vec3_t origin, int radius, team_t playerTeam, gentity_t *avoid )
{
gentity_t *radiusEnts[ MAX_RADIUS_ENTS ];
vec3_t mins, maxs;
int numEnts, realCount = 0;
//Setup the bbox to search in
for ( int i = 0; i < 3; i++ )
{
mins[i] = origin[i] - radius;
maxs[i] = origin[i] + radius;
}
//Get the number of entities in a given space
numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
//Cull this list
for ( int j = 0; j < numEnts; j++ )
{
//Validate clients
if ( radiusEnts[ j ]->client == NULL )
continue;
//Skip the requested avoid ent if present
if ( ( avoid != NULL ) && ( radiusEnts[ j ] == avoid ) )
continue;
//Must be on the same team
if ( radiusEnts[ j ]->client->playerTeam != playerTeam )
continue;
//Must be alive
if ( radiusEnts[ j ]->health <= 0 )
continue;
realCount++;
}
return realCount;
}
//Overload
int AI_GetGroupSize( gentity_t *ent, int radius )
{
if ( ( ent == NULL ) || ( ent->client == NULL ) )
return -1;
return AI_GetGroupSize( ent->currentOrigin, radius, ent->client->playerTeam, ent );
}
void AI_SetClosestBuddy( AIGroupInfo_t *group )
{
int i, j;
int dist, bestDist;
for ( i = 0; i < group->numGroup; i++ )
{
group->member[i].closestBuddy = ENTITYNUM_NONE;
bestDist = Q3_INFINITE;
for ( j = 0; j < group->numGroup; j++ )
{
dist = DistanceSquared( g_entities[group->member[i].number].currentOrigin, g_entities[group->member[j].number].currentOrigin );
if ( dist < bestDist )
{
bestDist = dist;
group->member[i].closestBuddy = group->member[j].number;
}
}
}
}
void AI_SortGroupByPathCostToEnemy( AIGroupInfo_t *group )
{
AIGroupMember_t bestMembers[MAX_GROUP_MEMBERS];
int i, j, k;
qboolean sort = qfalse;
if ( group->enemy != NULL )
{//FIXME: just use enemy->waypoint?
group->enemyWP = NAV::GetNearestNode(group->enemy);
}
else
{
group->enemyWP = WAYPOINT_NONE;
}
for ( i = 0; i < group->numGroup; i++ )
{
if ( group->enemyWP == WAYPOINT_NONE )
{//FIXME: just use member->waypoint?
group->member[i].waypoint = WAYPOINT_NONE;
group->member[i].pathCostToEnemy = Q3_INFINITE;
}
else
{//FIXME: just use member->waypoint?
group->member[i].waypoint = NAV::GetNearestNode(group->enemy);
if ( group->member[i].waypoint != WAYPOINT_NONE )
{
group->member[i].pathCostToEnemy = NAV::EstimateCostToGoal( group->member[i].waypoint, group->enemyWP );
//at least one of us has a path, so do sorting
sort = qtrue;
}
else
{
group->member[i].pathCostToEnemy = Q3_INFINITE;
}
}
}
//Now sort
if ( sort )
{
//initialize bestMembers data
for ( j = 0; j < group->numGroup; j++ )
{
bestMembers[j].number = ENTITYNUM_NONE;
}
for ( i = 0; i < group->numGroup; i++ )
{
for ( j = 0; j < group->numGroup; j++ )
{
if ( bestMembers[j].number != ENTITYNUM_NONE )
{//slot occupied
if ( group->member[i].pathCostToEnemy < bestMembers[j].pathCostToEnemy )
{//this guy has a shorter path than the one currenly in this spot, bump him and put myself in here
for ( k = group->numGroup; k > j; k++ )
{
memcpy( &bestMembers[k], &bestMembers[k-1], sizeof( bestMembers[k] ) );
}
memcpy( &bestMembers[j], &group->member[i], sizeof( bestMembers[j] ) );
break;
}
}
else
{//slot unoccupied, reached end of list, throw self in here
memcpy( &bestMembers[j], &group->member[i], sizeof( bestMembers[j] ) );
break;
}
}
}
//Okay, now bestMembers is a sorted list, just copy it into group->members
for ( i = 0; i < group->numGroup; i++ )
{
memcpy( &group->member[i], &bestMembers[i], sizeof( group->member[i] ) );
}
}
}
qboolean AI_FindSelfInPreviousGroup( gentity_t *self )
{//go through other groups made this frame and see if any of those contain me already
int i, j;
for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
{
if ( level.groups[i].numGroup )//&& level.groups[i].enemy != NULL )
{//check this one
for ( j = 0; j < level.groups[i].numGroup; j++ )
{
if ( level.groups[i].member[j].number == self->s.number )
{
self->NPC->group = &level.groups[i];
return qtrue;
}
}
}
}
return qfalse;
}
void AI_InsertGroupMember( AIGroupInfo_t *group, gentity_t *member )
{
//okay, you know what? Check this damn group and make sure we're not already in here!
int i;
for ( i = 0; i < group->numGroup; i++ )
{
if ( group->member[i].number == member->s.number )
{//already in here
break;
}
}
if ( i < group->numGroup )
{//found him in group already
}
else
{//add him in
group->member[group->numGroup++].number = member->s.number;
group->numState[member->NPC->squadState]++;
}
if ( !group->commander || (member->NPC->rank > group->commander->NPC->rank) )
{//keep track of highest rank
group->commander = member;
}
member->NPC->group = group;
}
qboolean AI_TryJoinPreviousGroup( gentity_t *self )
{//go through other groups made this frame and see if any of those have the same enemy as me... if so, add me in!
int i;
for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
{
if ( level.groups[i].numGroup
&& level.groups[i].numGroup < (MAX_GROUP_MEMBERS - 1)
//&& level.groups[i].enemy != NULL
&& level.groups[i].enemy == self->enemy )
{//has members, not full and has my enemy
if ( AI_ValidateGroupMember( &level.groups[i], self ) )
{//I am a valid member for this group
AI_InsertGroupMember( &level.groups[i], self );
return qtrue;
}
}
}
return qfalse;
}
qboolean AI_GetNextEmptyGroup( gentity_t *self )
{
if ( AI_FindSelfInPreviousGroup( self ) )
{//already in one, no need to make a new one
return qfalse;
}
if ( AI_TryJoinPreviousGroup( self ) )
{//try to just put us in one that already exists
return qfalse;
}
//okay, make a whole new one, then
for ( int i = 0; i < MAX_FRAME_GROUPS; i++ )
{
if ( !level.groups[i].numGroup )
{//make a new one
self->NPC->group = &level.groups[i];
return qtrue;
}
}
//if ( i >= MAX_FRAME_GROUPS )
{//WTF? Out of groups!
self->NPC->group = NULL;
return qfalse;
}
}
qboolean AI_ValidateNoEnemyGroupMember( AIGroupInfo_t *group, gentity_t *member )
{
if ( !group )
{
return qfalse;
}
vec3_t center;
if ( group->commander )
{
VectorCopy( group->commander->currentOrigin, center );
}
else
{//hmm, just pick the first member
if ( group->member[0].number < 0 || group->member[0].number >= ENTITYNUM_WORLD )
{
return qfalse;
}
VectorCopy( g_entities[group->member[0].number].currentOrigin, center );
}
//FIXME: maybe it should be based on the center of the mass of the group, not the commander?
if ( DistanceSquared( center, member->currentOrigin ) > 147456/*384*384*/ )
{
return qfalse;
}
if ( !gi.inPVS( member->currentOrigin, center ) )
{//not within PVS of the group enemy
return qfalse;
}
return qtrue;
}
qboolean AI_ValidateGroupMember( AIGroupInfo_t *group, gentity_t *member )
{
//Validate ents
if ( member == NULL )
return qfalse;
//Validate clients
if ( member->client == NULL )
return qfalse;
//Validate NPCs
if ( member->NPC == NULL )
return qfalse;
//must be aware
if ( member->NPC->confusionTime > level.time )
return qfalse;
//must be allowed to join groups
if ( member->NPC->scriptFlags&SCF_NO_GROUPS )
return qfalse;
//Must not be in another group
if ( member->NPC->group != NULL && member->NPC->group != group )
{//FIXME: if that group's enemy is mine, why not absorb that group into mine?
return qfalse;
}
//Must be alive
if ( member->health <= 0 )
return qfalse;
//can't be in an emplaced gun
if( member->s.eFlags & EF_LOCKED_TO_WEAPON )
return qfalse;
if( member->s.eFlags & EF_HELD_BY_RANCOR )
return qfalse;
if( member->s.eFlags & EF_HELD_BY_SAND_CREATURE )
return qfalse;
if( member->s.eFlags & EF_HELD_BY_WAMPA )
return qfalse;
//Must be on the same team
if ( member->client->playerTeam != group->team )
return qfalse;
if ( member->client->ps.weapon == WP_SABER ||//!= self->s.weapon )
member->client->ps.weapon == WP_THERMAL ||
member->client->ps.weapon == WP_DISRUPTOR ||
member->client->ps.weapon == WP_EMPLACED_GUN ||
member->client->ps.weapon == WP_BOT_LASER || // Probe droid - Laser blast
member->client->ps.weapon == WP_MELEE ||
member->client->ps.weapon == WP_TURRET || // turret guns
member->client->ps.weapon == WP_ATST_MAIN ||
member->client->ps.weapon == WP_ATST_SIDE ||
member->client->ps.weapon == WP_TIE_FIGHTER )
{//not really a squad-type guy
return qfalse;
}
if ( member->client->NPC_class == CLASS_ATST ||
member->client->NPC_class == CLASS_PROBE ||
member->client->NPC_class == CLASS_SEEKER ||
member->client->NPC_class == CLASS_REMOTE ||
member->client->NPC_class == CLASS_SENTRY ||
member->client->NPC_class == CLASS_INTERROGATOR ||
member->client->NPC_class == CLASS_MINEMONSTER ||
member->client->NPC_class == CLASS_HOWLER ||
member->client->NPC_class == CLASS_RANCOR ||
member->client->NPC_class == CLASS_MARK1 ||
member->client->NPC_class == CLASS_MARK2 )
{//these kinds of enemies don't actually use this group AI
return qfalse;
}
//should have same enemy
if ( member->enemy != group->enemy )
{
if ( member->enemy != NULL )
{//he's fighting someone else, leave him out
return qfalse;
}
if ( !gi.inPVS( member->currentOrigin, group->enemy->currentOrigin ) )
{//not within PVS of the group enemy
return qfalse;
}
}
else if ( group->enemy == NULL )
{//if the group is a patrol group, only take those within the room and radius
if ( !AI_ValidateNoEnemyGroupMember( group, member ) )
{
return qfalse;
}
}
//must be actually in combat mode
if ( !TIMER_Done( member, "interrogating" ) )
return qfalse;
//FIXME: need to have a route to enemy and/or clear shot?
return qtrue;
}
/*
-------------------------
AI_GetGroup
-------------------------
*/
//#define MAX_WAITERS 128
void AI_GetGroup( gentity_t *self )
{
int i;
gentity_t *member;//, *waiter;
//int waiters[MAX_WAITERS];
if ( !self || !self->NPC )
{
return;
}
if ( d_noGroupAI->integer )
{
self->NPC->group = NULL;
return;
}
if ( !self->client )
{
self->NPC->group = NULL;
return;
}
if ( self->NPC->scriptFlags&SCF_NO_GROUPS )
{
self->NPC->group = NULL;
return;
}
if ( self->enemy && (!self->enemy->client || (level.time - self->NPC->enemyLastSeenTime > 7000 )))
{
self->NPC->group = NULL;
return;
}
if ( !AI_GetNextEmptyGroup( self ) )
{//either no more groups left or we're already in a group built earlier
return;
}
//create a new one
memset( self->NPC->group, 0, sizeof( AIGroupInfo_t ) );
self->NPC->group->enemy = self->enemy;
self->NPC->group->team = self->client->playerTeam;
self->NPC->group->processed = qfalse;
self->NPC->group->commander = self;
self->NPC->group->memberValidateTime = level.time + 2000;
self->NPC->group->activeMemberNum = 0;
if ( self->NPC->group->enemy )
{
self->NPC->group->lastSeenEnemyTime = level.time;
self->NPC->group->lastClearShotTime = level.time;
VectorCopy( self->NPC->group->enemy->currentOrigin, self->NPC->group->enemyLastSeenPos );
}
// for ( i = 0, member = &g_entities[0]; i < globals.num_entities ; i++, member++)
for ( i = 0; i < globals.num_entities ; i++)
{
if(!PInUse(i))
continue;
member = &g_entities[i];
if ( !AI_ValidateGroupMember( self->NPC->group, member ) )
{//FIXME: keep track of those who aren't angry yet and see if we should wake them after we assemble the core group
continue;
}
//store it
AI_InsertGroupMember( self->NPC->group, member );
if ( self->NPC->group->numGroup >= (MAX_GROUP_MEMBERS - 1) )
{//full
break;
}
}
/*
//now go through waiters and see if any should join the group
//NOTE: Some should hang back and probably not attack, so we can ambush
//NOTE: only do this if calling for reinforcements?
for ( i = 0; i < numWaiters; i++ )
{
waiter = &g_entities[waiters[i]];
for ( j = 0; j < self->NPC->group->numGroup; j++ )
{
member = &g_entities[self->NPC->group->member[j];
if ( gi.inPVS( waiter->currentOrigin, member->currentOrigin ) )
{//this waiter is within PVS of a current member
}
}
}
*/
if ( self->NPC->group->numGroup <= 0 )
{//none in group
self->NPC->group = NULL;
return;
}
AI_SortGroupByPathCostToEnemy( self->NPC->group );
AI_SetClosestBuddy( self->NPC->group );
}
void AI_SetNewGroupCommander( AIGroupInfo_t *group )
{
gentity_t *member = NULL;
group->commander = NULL;
for ( int i = 0; i < group->numGroup; i++ )
{
member = &g_entities[group->member[i].number];
if ( !group->commander || (member && member->NPC && group->commander->NPC && member->NPC->rank > group->commander->NPC->rank) )
{//keep track of highest rank
group->commander = member;
}
}
}
void AI_DeleteGroupMember( AIGroupInfo_t *group, int memberNum )
{
if ( group->commander && group->commander->s.number == group->member[memberNum].number )
{
group->commander = NULL;
}
if ( g_entities[group->member[memberNum].number].NPC )
{
g_entities[group->member[memberNum].number].NPC->group = NULL;
}
for ( int i = memberNum; i < (group->numGroup-1); i++ )
{
memcpy( &group->member[i], &group->member[i+1], sizeof( group->member[i] ) );
}
if ( memberNum < group->activeMemberNum )
{
group->activeMemberNum--;
if ( group->activeMemberNum < 0 )
{
group->activeMemberNum = 0;
}
}
group->numGroup--;
if ( group->numGroup < 0 )
{
group->numGroup = 0;
}
AI_SetNewGroupCommander( group );
}
void AI_DeleteSelfFromGroup( gentity_t *self )
{
//FIXME: if killed, keep track of how many in group killed? To affect morale?
for ( int i = 0; i < self->NPC->group->numGroup; i++ )
{
if ( self->NPC->group->member[i].number == self->s.number )
{
AI_DeleteGroupMember( self->NPC->group, i );
return;
}
}
}
extern void ST_AggressionAdjust( gentity_t *self, int change );
extern void ST_MarkToCover( gentity_t *self );
extern void ST_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int minTime, int maxTime );
void AI_GroupMemberKilled( gentity_t *self )
{
/* AIGroupInfo_t *group = self->NPC->group;
gentity_t *member;
qboolean noflee = qfalse;
if ( !group )
{//what group?
return;
}
if ( !self || !self->NPC || self->NPC->rank < RANK_ENSIGN )
{//I'm not an officer, let's not really care for now
return;
}
//temporarily drop group morale for a few seconds
group->moraleAdjust -= self->NPC->rank;
//go through and drop aggression on my teammates (more cover, worse aim)
for ( int i = 0; i < group->numGroup; i++ )
{
member = &g_entities[group->member[i].number];
if ( member == self )
{
continue;
}
if ( member->NPC->rank > RANK_ENSIGN )
{//officers do not panic
noflee = qtrue;
}
else
{
ST_AggressionAdjust( member, -1 );
member->NPC->currentAim -= Q_irand( 0, 10 );//Q_irand( 0, 2);//drop their aim accuracy
}
}
//okay, if I'm the group commander, make everyone else flee
if ( group->commander != self )
{//I'm not the commander... hmm, should maybe a couple flee... maybe those near me?
return;
}
//now see if there is another of sufficient rank to keep them from fleeing
if ( !noflee )
{
self->NPC->group->speechDebounceTime = 0;
for ( int i = 0; i < group->numGroup; i++ )
{
member = &g_entities[group->member[i].number];
if ( member == self )
{
continue;
}
if ( member->NPC->rank < RANK_ENSIGN )
{//grunt
if ( group->enemy && DistanceSquared( member->currentOrigin, group->enemy->currentOrigin ) < 65536 )//256*256
{//those close to enemy run away!
ST_StartFlee( member, group->enemy, member->currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
}
else if ( DistanceSquared( member->currentOrigin, self->currentOrigin ) < 65536 )
{//those close to me run away!
ST_StartFlee( member, group->enemy, member->currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
}
else
{//else, maybe just a random chance
if ( Q_irand( 0, self->NPC->rank ) > member->NPC->rank )
{//lower rank they are, higher rank I am, more likely they are to flee
ST_StartFlee( member, group->enemy, member->currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
}
else
{
ST_MarkToCover( member );
}
}
member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more
}
member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more
}
}*/
}
void AI_GroupUpdateEnemyLastSeen( AIGroupInfo_t *group, vec3_t spot )
{
if ( !group )
{
return;
}
group->lastSeenEnemyTime = level.time;
VectorCopy( spot, group->enemyLastSeenPos );
}
void AI_GroupUpdateClearShotTime( AIGroupInfo_t *group )
{
if ( !group )
{
return;
}
group->lastClearShotTime = level.time;
}
void AI_GroupUpdateSquadstates( AIGroupInfo_t *group, gentity_t *member, int newSquadState )
{
if ( !group )
{
member->NPC->squadState = newSquadState;
return;
}
for ( int i = 0; i < group->numGroup; i++ )
{
if ( group->member[i].number == member->s.number )
{
group->numState[member->NPC->squadState]--;
member->NPC->squadState = newSquadState;
group->numState[member->NPC->squadState]++;
return;
}
}
}
qboolean AI_RefreshGroup( AIGroupInfo_t *group )
{
gentity_t *member;
int i;//, j;
//see if we should merge with another group
for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
{
if ( &level.groups[i] == group )
{
break;
}
else
{
if ( level.groups[i].enemy == group->enemy )
{//2 groups with same enemy
if ( level.groups[i].numGroup+group->numGroup < (MAX_GROUP_MEMBERS - 1) )
{//combining the members would fit in one group
qboolean deleteWhenDone = qtrue;
//combine the members of mine into theirs
for ( int j = 0; j < group->numGroup; j++ )
{
member = &g_entities[group->member[j].number];
if ( level.groups[i].enemy == NULL )
{//special case for groups without enemies, must be in range
if ( !AI_ValidateNoEnemyGroupMember( &level.groups[i], member ) )
{
deleteWhenDone = qfalse;
continue;
}
}
//remove this member from this group
AI_DeleteGroupMember( group, j );
//keep marker at same place since we deleted this guy and shifted everyone up one
j--;
//add them to the earlier group
AI_InsertGroupMember( &level.groups[i], member );
}
//return and delete this group
if ( deleteWhenDone )
{
return qfalse;
}
}
}
}
}
//clear numStates
for ( i = 0; i < NUM_SQUAD_STATES; i++ )
{
group->numState[i] = 0;
}
//go through group and validate each membership
group->commander = NULL;
for ( i = 0; i < group->numGroup; i++ )
{
/*
//this checks for duplicate copies of one member in a group
for ( j = 0; j < group->numGroup; j++ )
{
if ( i != j )
{
if ( group->member[i].number == group->member[j].number )
{
break;
}
}
}
if ( j < group->numGroup )
{//found a dupe!
gi.Printf( S_COLOR_RED"ERROR: member %s(%d) a duplicate group member!!!\n", g_entities[group->member[i].number].targetname, group->member[i].number );
AI_DeleteGroupMember( group, i );
i--;
continue;
}
*/
member = &g_entities[group->member[i].number];
//Must be alive
if ( member->health <= 0 )
{
AI_DeleteGroupMember( group, i );
//keep marker at same place since we deleted this guy and shifted everyone up one
i--;
}
else if ( group->memberValidateTime < level.time && !AI_ValidateGroupMember( group, member ) )
{
//remove this one from the group
AI_DeleteGroupMember( group, i );
//keep marker at same place since we deleted this guy and shifted everyone up one
i--;
}
else
{//membership is valid
//keep track of squadStates
group->numState[member->NPC->squadState]++;
if ( !group->commander || member->NPC->rank > group->commander->NPC->rank )
{//keep track of highest rank
group->commander = member;
}
}
}
if ( group->memberValidateTime < level.time )
{
group->memberValidateTime = level.time + Q_irand( 500, 2500 );
}
//Now add any new guys as long as we're not full
/*
for ( i = 0, member = &g_entities[0]; i < globals.num_entities && group->numGroup < (MAX_GROUP_MEMBERS - 1); i++, member++)
{
if ( !AI_ValidateGroupMember( group, member ) )
{//FIXME: keep track of those who aren't angry yet and see if we should wake them after we assemble the core group
continue;
}
if ( member->NPC->group == group )
{//DOH, already in our group
continue;
}
//store it
AI_InsertGroupMember( group, member );
}
*/
//calc the morale of this group
group->morale = group->moraleAdjust;
for ( i = 0; i < group->numGroup; i++ )
{
member = &g_entities[group->member[i].number];
if ( member->NPC->rank < RANK_ENSIGN )
{//grunts
group->morale++;
}
else
{
group->morale += member->NPC->rank;
}
if ( group->commander && debugNPCAI->integer )
{
G_DebugLine( group->commander->currentOrigin, member->currentOrigin, FRAMETIME, 0x00ff00ff, qtrue );
}
}
if ( group->enemy )
{//modify morale based on enemy health and weapon
if ( group->enemy->health < 10 )
{
group->morale += 10;
}
else if ( group->enemy->health < 25 )
{
group->morale += 5;
}
else if ( group->enemy->health < 50 )
{
group->morale += 2;
}
switch( group->enemy->s.weapon )
{
case WP_SABER:
group->morale -= 5;
break;
case WP_BRYAR_PISTOL:
case WP_BLASTER_PISTOL:
group->morale += 3;
break;
case WP_DISRUPTOR:
group->morale += 2;
break;
case WP_REPEATER:
group->morale -= 1;
break;
case WP_FLECHETTE:
group->morale -= 2;
break;
case WP_ROCKET_LAUNCHER:
group->morale -= 10;
break;
case WP_CONCUSSION:
group->morale -= 12;
break;
case WP_THERMAL:
group->morale -= 5;
break;
case WP_TRIP_MINE:
group->morale -= 3;
break;
case WP_DET_PACK:
group->morale -= 10;
break;
case WP_MELEE: // Any ol' melee attack
group->morale += 20;
break;
case WP_STUN_BATON:
group->morale += 10;
break;
case WP_EMPLACED_GUN:
group->morale -= 8;
break;
case WP_ATST_MAIN:
group->morale -= 8;
break;
case WP_ATST_SIDE:
group->morale -= 20;
break;
}
}
if ( group->moraleDebounce < level.time )
{//slowly degrade whatever moraleAdjusters we may have
if ( group->moraleAdjust > 0 )
{
group->moraleAdjust--;
}
else if ( group->moraleAdjust < 0 )
{
group->moraleAdjust++;
}
group->moraleDebounce = level.time + 1000;//FIXME: define?
}
//mark this group as not having been run this frame
group->processed = qfalse;
return (group->numGroup>0);
}
void AI_UpdateGroups( void )
{
if ( d_noGroupAI->integer )
{
return;
}
//Clear all Groups
for ( int i = 0; i < MAX_FRAME_GROUPS; i++ )
{
if ( !level.groups[i].numGroup || AI_RefreshGroup( &level.groups[i] ) == qfalse )//level.groups[i].enemy == NULL ||
{
memset( &level.groups[i], 0, sizeof( level.groups[i] ) );
}
}
}
qboolean AI_GroupContainsEntNum( AIGroupInfo_t *group, int entNum )
{
if ( !group )
{
return qfalse;
}
for ( int i = 0; i < group->numGroup; i++ )
{
if ( group->member[i].number == entNum )
{
return qtrue;
}
}
return qfalse;
}
//Overload
/*
void AI_GetGroup( AIGroupInfo_t &group, gentity_t *ent, int radius )
{
if ( ent->client == NULL )
return;
vec3_t temp, angles;
//FIXME: This is specialized code.. move?
if ( ent->enemy )
{
VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, temp );
VectorNormalize( temp ); //FIXME: Needed?
vectoangles( temp, angles );
}
else
{
VectorCopy( ent->currentAngles, angles );
}
AI_GetGroup( group, ent->currentOrigin, ent->currentAngles, DEFAULT_RADIUS, radius, ent->client->playerTeam, ent, ent->enemy );
}
*/
/*
-------------------------
AI_DistributeAttack
-------------------------
*/
#define MAX_RADIUS_ENTS 128
gentity_t *AI_DistributeAttack( gentity_t *attacker, gentity_t *enemy, team_t team, int threshold )
{
//Don't take new targets
if ( NPC->svFlags & SVF_LOCKEDENEMY )
return enemy;
int numSurrounding = AI_GetGroupSize( enemy->currentOrigin, 48, team, attacker );
//First, see if we should look for the player
if ( enemy != &g_entities[0] )
{
int aroundPlayer = AI_GetGroupSize( g_entities[0].currentOrigin, 48, team, attacker );
//See if we're above our threshold
if ( aroundPlayer < threshold )
{
return &g_entities[0];
}
}
//See if our current enemy is still ok
if ( numSurrounding < threshold )
return enemy;
//Otherwise we need to take a new enemy if possible
vec3_t mins, maxs;
//Setup the bbox to search in
for ( int i = 0; i < 3; i++ )
{
mins[i] = enemy->currentOrigin[i] - 512;
maxs[i] = enemy->currentOrigin[i] + 512;
}
//Get the number of entities in a given space
gentity_t *radiusEnts[ MAX_RADIUS_ENTS ];
int numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
//Cull this list
for ( int j = 0; j < numEnts; j++ )
{
//Validate clients
if ( radiusEnts[ j ]->client == NULL )
continue;
//Skip the requested avoid ent if present
if ( ( radiusEnts[ j ] == enemy ) )
continue;
//Must be on the same team
if ( radiusEnts[ j ]->client->playerTeam != enemy->client->playerTeam )
continue;
//Must be alive
if ( radiusEnts[ j ]->health <= 0 )
continue;
//Must not be overwhelmed
if ( AI_GetGroupSize( radiusEnts[j]->currentOrigin, 48, team, attacker ) > threshold )
continue;
return radiusEnts[j];
}
return NULL;
}
Reference in a new issue View git blame Copy permalink