//==========================================
// AI_MoveToGoalEntity
// Set bot to move to it's movetarget. Short range goals
//==========================================
qboolean AI_MoveToGoalEntity(edict_t *self, usercmd_t *ucmd)
{
if (!self->movetarget || !self->client)
return false;
// If a rocket or grenade is around deal with it
// Simple, but effective (could be rewritten to be more accurate)
if(!Q_stricmp(self->movetarget->classname,"rocket") ||
!Q_stricmp(self->movetarget->classname,"grenade") ||
!Q_stricmp(self->movetarget->classname,"hgrenade"))
{
VectorSubtract (self->movetarget->s.origin, self->s.origin, self->ai.move_vector);
AI_ChangeAngle(self);
// if(AIDevel.debugChased && bot_showcombat->value)
// G_PrintMsg (AIDevel.chaseguy, PRINT_HIGH, "%s: Oh crap a rocket!\n",self->ai.pers.netname);
// strafe left/right
if(rand()%1 && AI_CanMove(self, BOT_MOVE_LEFT))
ucmd->sidemove = -400;
else if(AI_CanMove(self, BOT_MOVE_RIGHT))
ucmd->sidemove = 400;
return true;
}
// Set bot's movement direction
VectorSubtract (self->movetarget->s.origin, self->s.origin, self->ai.move_vector);
AI_ChangeAngle(self);
if(!AI_CanMove(self, BOT_MOVE_FORWARD) )
{
self->movetarget = NULL;
ucmd->forwardmove = -400;
return false;
}
//Move
ucmd->forwardmove = 400;
return true;
}
void BOT_DMclass_Move( edict_t *self, usercmd_t *ucmd )
{
#define BOT_FORWARD_EPSILON 0.5f
int i;
unsigned int linkType;
bool printLink = false;
bool nodeReached = false;
bool specialMovement = false;
vec3_t v1, v2;
vec3_t lookdir, pathdir;
float lookDot;
if( self->ai->next_node == NODE_INVALID || self->ai->goal_node == NODE_INVALID )
{
BOT_DMclass_MoveWander( self, ucmd );
return;
}
linkType = AI_CurrentLinkType( self );
specialMovement = ( self->ai->path.numNodes >= MIN_BUNNY_NODES ) ? true : false;
if( AI_GetNodeFlags( self->ai->next_node ) & (NODEFLAGS_REACHATTOUCH|NODEFLAGS_ENTITYREACH) )
specialMovement = false;
if( linkType & (LINK_JUMP|LINK_JUMPPAD|LINK_CROUCH|LINK_FALL|LINK_WATER|LINK_LADDER|LINK_ROCKETJUMP) )
specialMovement = false;
if( self->ai->pers.skillLevel < 0.33f )
specialMovement = false;
if( specialMovement == false || self->groundentity )
self->ai->is_bunnyhop = false;
VectorSubtract( nodes[self->ai->next_node].origin, self->s.origin, self->ai->move_vector );
// 2D, normalized versions of look and path directions
pathdir[0] = self->ai->move_vector[0];
pathdir[1] = self->ai->move_vector[1];
pathdir[2] = 0.0f;
VectorNormalize( pathdir );
AngleVectors( self->s.angles, lookdir, NULL, NULL );
lookdir[2] = 0.0f;
VectorNormalize( lookdir );
lookDot = DotProduct( lookdir, pathdir );
// Ladder movement
if( self->is_ladder )
{
ucmd->forwardmove = 0;
ucmd->upmove = 1;
ucmd->sidemove = 0;
if( nav.debugMode && printLink )
G_PrintChasersf( self, "LINK_LADDER\n" );
nodeReached = AI_NodeReached_Generic( self );
}
else if( linkType & LINK_JUMPPAD )
{
VectorCopy( self->s.origin, v1 );
VectorCopy( nodes[self->ai->next_node].origin, v2 );
v1[2] = v2[2] = 0;
if( DistanceFast( v1, v2 ) > 32 && lookDot > BOT_FORWARD_EPSILON ) {
ucmd->forwardmove = 1; // push towards destination
ucmd->buttons |= BUTTON_WALK;
}
nodeReached = self->groundentity != NULL && AI_NodeReached_Generic( self );
}
// Platform riding - No move, riding elevator
else if( linkType & LINK_PLATFORM )
{
VectorCopy( self->s.origin, v1 );
VectorCopy( nodes[self->ai->next_node].origin, v2 );
v1[2] = v2[2] = 0;
if( DistanceFast( v1, v2 ) > 32 && lookDot > BOT_FORWARD_EPSILON )
ucmd->forwardmove = 1; // walk to center
ucmd->buttons |= BUTTON_WALK;
ucmd->upmove = 0;
ucmd->sidemove = 0;
if( nav.debugMode && printLink )
G_PrintChasersf( self, "LINK_PLATFORM (riding)\n" );
self->ai->move_vector[2] = 0; // put view horizontal
nodeReached = AI_NodeReached_PlatformEnd( self );
}
// entering platform
else if( AI_GetNodeFlags( self->ai->next_node ) & NODEFLAGS_PLATFORM )
{
ucmd->forwardmove = 1;
ucmd->upmove = 0;
ucmd->sidemove = 0;
if( lookDot <= BOT_FORWARD_EPSILON )
ucmd->buttons |= BUTTON_WALK;
if( nav.debugMode && printLink )
G_PrintChasersf( self, "NODEFLAGS_PLATFORM (moving to plat)\n" );
// is lift down?
for( i = 0; i < nav.num_navigableEnts; i++ )
{
if( nav.navigableEnts[i].node == self->ai->next_node )
{
//testing line
//vec3_t tPoint;
//int j;
//for(j=0; j<3; j++)//center of the ent
// tPoint[j] = nav.ents[i].ent->s.origin[j] + 0.5*(nav.ents[i].ent->r.mins[j] + nav.ents[i].ent->r.maxs[j]);
//tPoint[2] = nav.ents[i].ent->s.origin[2] + nav.ents[i].ent->r.maxs[2];
//tPoint[2] += 8;
//AITools_DrawLine( self->s.origin, tPoint );
//if not reachable, wait for it (only height matters)
if( ( nav.navigableEnts[i].ent->s.origin[2] + nav.navigableEnts[i].ent->r.maxs[2] ) > ( self->s.origin[2] + self->r.mins[2] + AI_JUMPABLE_HEIGHT ) &&
nav.navigableEnts[i].ent->moveinfo.state != STATE_BOTTOM )
{
self->ai->blocked_timeout = level.time + 10000;
ucmd->forwardmove = 0;
}
}
}
nodeReached = AI_NodeReached_PlatformStart( self );
}
// Falling off ledge or jumping
else if( !self->groundentity && !self->is_step && !self->is_swim && !self->ai->is_bunnyhop )
{
ucmd->upmove = 0;
ucmd->sidemove = 0;
ucmd->forwardmove = 0;
if( lookDot > BOT_FORWARD_EPSILON )
{
ucmd->forwardmove = 1;
// add fake strafe accel
if( !(linkType & LINK_FALL) || linkType & (LINK_JUMP|LINK_ROCKETJUMP) )
{
if( linkType & LINK_JUMP )
{
if( AI_AttemptWalljump( self ) ) {
ucmd->buttons |= BUTTON_SPECIAL;
}
if( VectorLengthFast( tv( self->velocity[0], self->velocity[1], 0 ) ) < 600 )
VectorMA( self->velocity, 6.0f, lookdir, self->velocity );
}
else
{
if( VectorLengthFast( tv( self->velocity[0], self->velocity[1], 0 ) ) < 450 )
VectorMA( self->velocity, 1.0f, lookdir, self->velocity );
}
}
}
else if( lookDot < -BOT_FORWARD_EPSILON )
ucmd->forwardmove = -1;
if( nav.debugMode && printLink )
G_PrintChasersf( self, "FLY MOVE\n" );
nodeReached = AI_NodeReached_Generic( self );
}
else // standard movement
{
ucmd->forwardmove = 1;
ucmd->upmove = 0;
ucmd->sidemove = 0;
// starting a jump
if( ( linkType & LINK_JUMP ) )
{
if( self->groundentity )
{
trace_t trace;
vec3_t v1, v2;
if( nav.debugMode && printLink )
G_PrintChasersf( self, "LINK_JUMP\n" );
//check floor in front, if there's none... Jump!
VectorCopy( self->s.origin, v1 );
VectorNormalize2( self->ai->move_vector, v2 );
VectorMA( v1, 18, v2, v1 );
v1[2] += self->r.mins[2];
VectorCopy( v1, v2 );
v2[2] -= AI_JUMPABLE_HEIGHT;
G_Trace( &trace, v1, vec3_origin, vec3_origin, v2, self, MASK_AISOLID );
if( !trace.startsolid && trace.fraction == 1.0 )
{
//jump!
// prevent double jumping on crates
VectorCopy( self->s.origin, v1 );
v1[2] += self->r.mins[2];
G_Trace( &trace, v1, tv( -12, -12, -8 ), tv( 12, 12, 0 ), v1, self, MASK_AISOLID );
if( trace.startsolid )
ucmd->upmove = 1;
}
}
nodeReached = AI_NodeReached_Generic( self );
}
// starting a rocket jump
else if( ( linkType & LINK_ROCKETJUMP ) )
{
if( nav.debugMode && printLink )
G_PrintChasersf( self, "LINK_ROCKETJUMP\n" );
if( !self->ai->rj_triggered && self->groundentity && ( self->s.weapon == WEAP_ROCKETLAUNCHER ) )
{
self->s.angles[PITCH] = 170;
ucmd->upmove = 1;
ucmd->buttons |= BUTTON_ATTACK;
self->ai->rj_triggered = true;
}
nodeReached = AI_NodeReached_Generic( self );
}
else
{
// Move To Short Range goal (not following paths)
// plats, grapple, etc have higher priority than SR Goals, cause the bot will
// drop from them and have to repeat the process from the beginning
if( AI_MoveToShortRangeGoalEntity( self, ucmd ) )
{
nodeReached = AI_NodeReached_Generic( self );
}
else if( specialMovement && !self->is_swim ) // bunny-hopping movement here
{
BOT_DMclass_SpecialMove( self, lookdir, pathdir, ucmd );
nodeReached = AI_NodeReached_Special( self );
}
else
{
nodeReached = AI_NodeReached_Generic( self );
}
}
// if static assume blocked and try to get free
if( VectorLengthFast( self->velocity ) < 37 && ( ucmd->forwardmove || ucmd->sidemove || ucmd->upmove ) )
{
if( random() > 0.1 && AI_SpecialMove( self, ucmd ) ) // jumps, crouches, turns...
return;
self->s.angles[YAW] += brandom( -90, 90 );
}
}
// swimming
if( self->is_swim )
{
if( !( G_PointContents( nodes[self->ai->next_node].origin ) & MASK_WATER ) ) // Exit water
ucmd->upmove = 1;
}
AI_ChangeAngle( self );
if( nodeReached )
AI_NodeReached( self );
#undef BOT_FORWARD_EPSILON
}
//==========================================
// BOT_DMclass_FireWeapon
// Fire if needed
//==========================================
static bool BOT_DMclass_FireWeapon( edict_t *self, usercmd_t *ucmd )
{
#define WFAC_GENERIC_PROJECTILE 300.0
#define WFAC_GENERIC_INSTANT 150.0
float firedelay;
vec3_t target;
int weapon, i;
float wfac;
vec3_t fire_origin;
trace_t trace;
bool continuous_fire = false;
firedef_t *firedef = GS_FiredefForPlayerState( &self->r.client->ps, self->r.client->ps.stats[STAT_WEAPON] );
if( !self->enemy )
return false;
weapon = self->s.weapon;
if( weapon < 0 || weapon >= WEAP_TOTAL )
weapon = 0;
if( !firedef )
return false;
// Aim to center of the box
for( i = 0; i < 3; i++ )
target[i] = self->enemy->s.origin[i] + ( 0.5f * ( self->enemy->r.maxs[i] + self->enemy->r.mins[i] ) );
fire_origin[0] = self->s.origin[0];
fire_origin[1] = self->s.origin[1];
fire_origin[2] = self->s.origin[2] + self->viewheight;
if( self->s.weapon == WEAP_LASERGUN || self->s.weapon == WEAP_PLASMAGUN )
continuous_fire = true;
if( !continuous_fire && !BOT_DMclass_CheckShot( self, target ) )
return false;
// find out our weapon AIM style
if( AIWeapons[weapon].aimType == AI_AIMSTYLE_PREDICTION_EXPLOSIVE )
{
// in the lowest skill level, don't predict projectiles
if( self->ai->pers.skillLevel >= 0.33f )
BOT_DMclass_PredictProjectileShot( self, fire_origin, firedef->speed, target, self->enemy->velocity );
wfac = WFAC_GENERIC_PROJECTILE * 1.3;
// aim to the feet when enemy isn't higher
if( fire_origin[2] > ( target[2] + ( self->enemy->r.mins[2] * 0.8 ) ) )
{
vec3_t checktarget;
VectorSet( checktarget,
self->enemy->s.origin[0],
self->enemy->s.origin[1],
self->enemy->s.origin[2] + self->enemy->r.mins[2] + 4 );
G_Trace( &trace, fire_origin, vec3_origin, vec3_origin, checktarget, self, MASK_SHOT );
if( trace.fraction == 1.0f || ( trace.ent > 0 && game.edicts[trace.ent].takedamage ) )
VectorCopy( checktarget, target );
}
else if( !AI_IsStep( self->enemy ) )
wfac *= 2.5; // more imprecise for air rockets
}
else if( AIWeapons[weapon].aimType == AI_AIMSTYLE_PREDICTION )
{
if( self->s.weapon == WEAP_PLASMAGUN )
wfac = WFAC_GENERIC_PROJECTILE * 0.5;
else
wfac = WFAC_GENERIC_PROJECTILE;
// in the lowest skill level, don't predict projectiles
if( self->ai->pers.skillLevel >= 0.33f )
BOT_DMclass_PredictProjectileShot( self, fire_origin, firedef->speed, target, self->enemy->velocity );
}
else if( AIWeapons[weapon].aimType == AI_AIMSTYLE_DROP )
{
//jalToDo
wfac = WFAC_GENERIC_PROJECTILE;
// in the lowest skill level, don't predict projectiles
if( self->ai->pers.skillLevel >= 0.33f )
BOT_DMclass_PredictProjectileShot( self, fire_origin, firedef->speed, target, self->enemy->velocity );
}
else // AI_AIMSTYLE_INSTANTHIT
{
if( self->s.weapon == WEAP_ELECTROBOLT )
wfac = WFAC_GENERIC_INSTANT;
else if( self->s.weapon == WEAP_LASERGUN )
wfac = WFAC_GENERIC_INSTANT * 1.5;
else
wfac = WFAC_GENERIC_INSTANT;
}
wfac = 25 + wfac * ( 1.0f - self->ai->pers.skillLevel );
// look to target
VectorSubtract( target, fire_origin, self->ai->move_vector );
if( self->r.client->ps.weaponState == WEAPON_STATE_READY ||
self->r.client->ps.weaponState == WEAPON_STATE_REFIRE ||
self->r.client->ps.weaponState == WEAPON_STATE_REFIRESTRONG )
{
// in continuous fire weapons don't add delays
if( self->s.weapon == WEAP_LASERGUN || self->s.weapon == WEAP_PLASMAGUN )
firedelay = 1.0f;
else
firedelay = ( 1.0f - self->ai->pers.skillLevel ) - ( random()-0.25f );
if( firedelay > 0.0f )
{
if( G_InFront( self, self->enemy ) ) {
ucmd->buttons |= BUTTON_ATTACK; // could fire, but wants to?
}
// mess up angles only in the attacking frames
if( self->r.client->ps.weaponState == WEAPON_STATE_READY ||
self->r.client->ps.weaponState == WEAPON_STATE_REFIRE ||
self->r.client->ps.weaponState == WEAPON_STATE_REFIRESTRONG )
{
if( (self->s.weapon == WEAP_LASERGUN) || (self->s.weapon == WEAP_PLASMAGUN) ) {
target[0] += sinf( (float)level.time/100.0) * wfac;
target[1] += cosf( (float)level.time/100.0) * wfac;
}
else
{
target[0] += ( random()-0.5f ) * wfac;
target[1] += ( random()-0.5f ) * wfac;
}
}
}
}
//update angles
VectorSubtract( target, fire_origin, self->ai->move_vector );
AI_ChangeAngle( self );
if( nav.debugMode && bot_showcombat->integer )
G_PrintChasersf( self, "%s: attacking %s\n", self->ai->pers.netname, self->enemy->r.client ? self->enemy->r.client->netname : self->classname );
return true;
}
//==========================================
// M_default_Move
// movement following paths code
//==========================================
//void M_default_Move( edict_t *self, usercmd_t *ucmd )
//{
// BOT_DMclass_Move( self, ucmd );
//}
void M_default_Move(edict_t *self, usercmd_t *ucmd)
{
int current_node_flags = 0;
int next_node_flags = 0;
int current_link_type = 0;
// int i;
current_node_flags = nodes[self->ai->current_node].flags;
next_node_flags = nodes[self->ai->next_node].flags;
if( AI_PlinkExists( self->ai->current_node, self->ai->next_node ))
{
current_link_type = AI_PlinkMoveType( self->ai->current_node, self->ai->next_node );
//Com_Printf("%s\n", AI_LinkString( current_link_type ));
}
// Falling off ledge
if(!self->groundentity && !self->is_step && !self->is_swim )
{
AI_ChangeAngle(self);
if (current_link_type == LINK_JUMPPAD ) {
ucmd->forwardmove = 100;
} else if( current_link_type == LINK_JUMP ) {
self->velocity[0] = self->ai->move_vector[0] * 280;
self->velocity[1] = self->ai->move_vector[1] * 280;
} else {
self->velocity[0] = self->ai->move_vector[0] * 160;
self->velocity[1] = self->ai->move_vector[1] * 160;
}
return;
}
// swimming
if( self->is_swim )
{
// We need to be pointed up/down
AI_ChangeAngle(self);
//if( !(trap_PointContents(nodes[self->ai->next_node].origin) & MASK_WATER) ) // Exit water
if( !(gi.pointcontents(nodes[self->ai->next_node].origin) & MASK_WATER) ) // Exit water
ucmd->upmove = 400;
ucmd->forwardmove = 300;
return;
}
// Check to see if stuck, and if so try to free us
if(VectorCompare(self->s.old_origin, self->s.origin))
{
// Keep a random factor just in case....
if( random() > 0.1 && AI_SpecialMove(self, ucmd) ) //jumps, crouches, turns...
return;
self->s.angles[YAW] += random() * 180 - 90;
AI_ChangeAngle(self);
ucmd->forwardmove = 400;
return;
}
AI_ChangeAngle(self);
// Otherwise move as fast as we can...
ucmd->forwardmove = 400;
}
