//------------------------------------
void Seeker_FollowPlayer( void )
{
Seeker_MaintainHeight();
float dis = DistanceHorizontalSquared( NPC->currentOrigin, g_entities[0].currentOrigin );
vec3_t pt, dir;
float minDistSqr = MIN_DISTANCE_SQR;
if ( NPC->client->NPC_class == CLASS_BOBAFETT )
{
if ( TIMER_Done( NPC, "flameTime" ) )
{
minDistSqr = 200*200;
}
}
if ( dis < minDistSqr )
{
// generally circle the player closely till we take an enemy..this is our target point
if ( NPC->client->NPC_class == CLASS_BOBAFETT )
{
pt[0] = g_entities[0].currentOrigin[0] + cos( level.time * 0.001f + NPC->random ) * 250;
pt[1] = g_entities[0].currentOrigin[1] + sin( level.time * 0.001f + NPC->random ) * 250;
if ( NPC->client->jetPackTime < level.time )
{
pt[2] = NPC->currentOrigin[2] - 64;
}
else
{
pt[2] = g_entities[0].currentOrigin[2] + 200;
}
}
else
{
pt[0] = g_entities[0].currentOrigin[0] + cos( level.time * 0.001f + NPC->random ) * 56;
pt[1] = g_entities[0].currentOrigin[1] + sin( level.time * 0.001f + NPC->random ) * 56;
pt[2] = g_entities[0].currentOrigin[2] + 40;
}
VectorSubtract( pt, NPC->currentOrigin, dir );
VectorMA( NPC->client->ps.velocity, 0.8f, dir, NPC->client->ps.velocity );
}
else
{
if ( NPC->client->NPC_class != CLASS_BOBAFETT )
{
if ( TIMER_Done( NPC, "seekerhiss" ))
{
TIMER_Set( NPC, "seekerhiss", 1000 + random() * 1000 );
G_Sound( NPC, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
}
}
// Hey come back!
NPCInfo->goalEntity = &g_entities[0];
NPCInfo->goalRadius = 32;
NPC_MoveToGoal( qtrue );
NPC->owner = &g_entities[0];
}
if ( NPCInfo->enemyCheckDebounceTime < level.time )
{
// check twice a second to find a new enemy
Seeker_FindEnemy();
NPCInfo->enemyCheckDebounceTime = level.time + 500;
}
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_Think ( gentity_t *self)//, int msec )
{
vector3 oldMoveDir;
int i = 0;
gentity_t *player;
self->nextthink = level.time + FRAMETIME;
SetNPCGlobals( self );
memset( &ucmd, 0, sizeof( ucmd ) );
VectorCopy( &self->client->ps.moveDir, &oldMoveDir );
if (self->s.NPC_class != CLASS_VEHICLE)
{ //YOU ARE BREAKING MY PREDICTION. Bad clear.
VectorClear( &self->client->ps.moveDir );
}
if(!self || !self->NPC || !self->client)
{
return;
}
// dead NPCs have a special think, don't run scripts (for now)
//FIXME: this breaks deathscripts
if ( self->health <= 0 )
{
DeadThink();
if ( NPCInfo->nextBStateThink <= level.time )
{
trap->ICARUS_MaintainTaskManager(self->s.number);
}
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
return;
}
// see if NPC ai is frozen
if ( d_npcfreeze.value || (NPC->r.svFlags&SVF_ICARUS_FREEZE) )
{
NPC_UpdateAngles( qtrue, qtrue );
ClientThink(self->s.number, &ucmd);
//VectorCopy(self->s.origin, self->s.origin2 );
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
return;
}
self->nextthink = level.time + FRAMETIME/2;
while (i < MAX_CLIENTS)
{
player = &g_entities[i];
if (player->inuse && player->client && player->client->sess.sessionTeam != TEAM_SPECTATOR &&
!(player->client->ps.pm_flags & PMF_FOLLOW))
{
//if ( player->client->ps.viewEntity == self->s.number )
if (0) //rwwFIXMEFIXME: Allow controlling ents
{//being controlled by player
G_DroidSounds( self );
//FIXME: might want to at least make sounds or something?
//NPC_UpdateAngles(qtrue, qtrue);
//Which ucmd should we send? Does it matter, since it gets overridden anyway?
NPCInfo->last_ucmd.serverTime = level.time - 50;
ClientThink( NPC->s.number, &ucmd );
//VectorCopy(self->s.origin, self->s.origin2 );
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
return;
}
}
i++;
}
if ( self->client->NPC_class == CLASS_VEHICLE)
{
if (self->client->ps.m_iVehicleNum)
{//we don't think on our own
//well, run scripts, though...
trap->ICARUS_MaintainTaskManager(self->s.number);
return;
}
else
{
VectorClear(&self->client->ps.moveDir);
self->client->pers.cmd.forwardmove = 0;
self->client->pers.cmd.rightmove = 0;
self->client->pers.cmd.upmove = 0;
self->client->pers.cmd.buttons = 0;
memcpy(&self->m_pVehicle->m_ucmd, &self->client->pers.cmd, sizeof(usercmd_t));
}
}
else if ( NPC->s.m_iVehicleNum )
{//droid in a vehicle?
G_DroidSounds( self );
}
if ( NPCInfo->nextBStateThink <= level.time
&& !NPC->s.m_iVehicleNum )//NPCs sitting in Vehicles do NOTHING
{
#if AI_TIMERS
int startTime = GetTime(0);
#endif// AI_TIMERS
if ( NPC->s.eType != ET_NPC )
{//Something drastic happened in our script
return;
}
if ( NPC->s.weapon == WP_SABER && g_spSkill.integer >= 2 && NPCInfo->rank > RANK_LT_JG )
{//Jedi think faster on hard difficulty, except low-rank (reborn)
NPCInfo->nextBStateThink = level.time + FRAMETIME/2;
}
else
{//Maybe even 200 ms?
NPCInfo->nextBStateThink = level.time + FRAMETIME;
}
//nextthink is set before this so something in here can override it
if (self->s.NPC_class != CLASS_VEHICLE ||
!self->m_pVehicle)
{ //ok, let's not do this at all for vehicles.
NPC_ExecuteBState( self );
}
#if AI_TIMERS
int addTime = GetTime( startTime );
if ( addTime > 50 )
{
Com_Printf( S_COLOR_RED"ERROR: NPC number %d, %s %s at %s, weaponnum: %d, using %d of AI time!!!\n", NPC->s.number, NPC->NPC_type, NPC->targetname, vtos(NPC->r.currentOrigin), NPC->s.weapon, addTime );
}
AITime += addTime;
#endif// AI_TIMERS
}
else
{
VectorCopy( &oldMoveDir, &self->client->ps.moveDir );
//or use client->pers.lastCommand?
NPCInfo->last_ucmd.serverTime = level.time - 50;
if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
{//If we were following a roff, we don't do normal pmoves.
//FIXME: firing angles (no aim offset) or regular angles?
NPC_UpdateAngles(qtrue, qtrue);
memcpy( &ucmd, &NPCInfo->last_ucmd, sizeof( usercmd_t ) );
ClientThink(NPC->s.number, &ucmd);
}
else
{
NPC_ApplyRoff();
}
//VectorCopy(self->s.origin, self->s.origin2 );
}
//must update icarus *every* frame because of certain animation completions in the pmove stuff that can leave a 50ms gap between ICARUS animation commands
trap->ICARUS_MaintainTaskManager(self->s.number);
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
}
void NPC_BSWander (void)
{//FIXME: don't actually go all the way to the next waypoint, just move in fits and jerks...?
if ( !NPCInfo->investigateDebounceTime )
{//Starting out
float minGoalReachedDistSquared = 64;//32*32;
vec3_t vec;
//Keep moving toward our tempGoal
NPCInfo->goalEntity = NPCInfo->tempGoal;
VectorSubtract ( NPCInfo->tempGoal->currentOrigin, NPC->currentOrigin, vec);
if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
{
minGoalReachedDistSquared = 64;
}
if ( VectorLengthSquared( vec ) < minGoalReachedDistSquared )
{
//Close enough, just got there
NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
if( !Q_irand(0, 1) )
{
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_NORMAL);
}
else
{
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_IDLE1, SETANIM_FLAG_NORMAL);
}
//Just got here, so Look around for a while
NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
}
else
{
//Keep moving toward goal
NPC_MoveToGoal( qtrue );
}
}
else
{
//We're there
if ( NPCInfo->investigateDebounceTime > level.time )
{
//Still waiting around for a bit
//Turn angles every now and then to look around
if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
{
if ( !Q_irand( 0, 30 ) )
{
int numEdges = navigator.GetNodeNumEdges( NPCInfo->tempGoal->waypoint );
if ( numEdges != WAYPOINT_NONE )
{
int branchNum = Q_irand( 0, numEdges - 1 );
vec3_t branchPos, lookDir;
int nextWp = navigator.GetNodeEdge( NPCInfo->tempGoal->waypoint, branchNum );
navigator.GetNodePosition( nextWp, branchPos );
VectorSubtract( branchPos, NPCInfo->tempGoal->currentOrigin, lookDir );
NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + Q_flrand( -45, 45 ) );
}
}
}
}
else
{//Just finished waiting
NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
if ( NPC->waypoint != WAYPOINT_NONE )
{
int numEdges = navigator.GetNodeNumEdges( NPC->waypoint );
if ( numEdges != WAYPOINT_NONE )
{
int branchNum = Q_irand( 0, numEdges - 1 );
int nextWp = navigator.GetNodeEdge( NPC->waypoint, branchNum );
navigator.GetNodePosition( nextWp, NPCInfo->tempGoal->currentOrigin );
NPCInfo->tempGoal->waypoint = nextWp;
}
NPCInfo->investigateDebounceTime = 0;
//Start moving toward our tempGoal
NPCInfo->goalEntity = NPCInfo->tempGoal;
NPC_MoveToGoal( qtrue );
}
}
}
NPC_UpdateAngles( qtrue, qtrue );
}
//added from SP
static qboolean NPC_Howler_Move( int randomJumpChance )
{
if ( !TIMER_Done( NPC, "standing" ) )
{//standing around
return qfalse;
}
if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
{//in air, don't do anything
return qfalse;
}
if ( (!NPC->enemy&&TIMER_Done( NPC, "running" )) || !TIMER_Done( NPC, "walking" ) )
{
ucmd.buttons |= BUTTON_WALKING;
}
if ( (!randomJumpChance||Q_irand( 0, randomJumpChance ))
&& NPC_MoveToGoal( qtrue ) )
{
if ( VectorCompare( NPC->client->ps.moveDir, vec3_origin )
|| !NPC->client->ps.speed )
{//uh.... wtf? Got there?
if ( NPCInfo->goalEntity )
{
NPC_FaceEntity( NPCInfo->goalEntity, qfalse );
}
else
{
NPC_UpdateAngles( qfalse, qtrue );
}
return qtrue;
}
//TEMP: don't want to strafe
VectorClear( NPC->client->ps.moveDir );
ucmd.rightmove = 0.0f;
// Com_Printf( "Howler moving %d\n",ucmd.forwardmove );
//if backing up, go slow...
if ( ucmd.forwardmove < 0.0f )
{
ucmd.buttons |= BUTTON_WALKING;
//if ( NPC->client->ps.speed > NPCInfo->stats.walkSpeed )
{//don't walk faster than I'm allowed to
NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
}
}
else
{
if ( (ucmd.buttons&BUTTON_WALKING) )
{
NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
}
else
{
NPC->client->ps.speed = NPCInfo->stats.runSpeed;
}
}
NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
NPC_UpdateAngles( qfalse, qtrue );
}
else if ( NPCInfo->goalEntity )
{//couldn't get where we wanted to go, try to jump there
NPC_FaceEntity( NPCInfo->goalEntity, qfalse );
NPC_TryJump_Gent( NPCInfo->goalEntity, 400.0f, -256.0f );
}
return qtrue;
}
/*
-------------------------
Interrogator_MaintainHeight
-------------------------
*/
void Interrogator_MaintainHeight( void )
{
float dif;
// vec3_t endPos;
// trace_t trace;
NPC->s.loopSound = G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_lp" );
// Update our angles regardless
NPC_UpdateAngles( qtrue, qtrue );
// If we have an enemy, we should try to hover at about enemy eye level
if ( NPC->enemy )
{
// Find the height difference
dif = (NPC->enemy->currentOrigin[2] + NPC->enemy->maxs[2]) - NPC->currentOrigin[2];
// cap to prevent dramatic height shifts
if ( fabs( dif ) > 2 )
{
if ( fabs( dif ) > 16 )
{
dif = ( dif < 0 ? -16 : 16 );
}
NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
}
}
else
{
gentity_t *goal = NULL;
if ( NPCInfo->goalEntity ) // Is there a goal?
{
goal = NPCInfo->goalEntity;
}
else
{
goal = NPCInfo->lastGoalEntity;
}
if ( goal )
{
dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
if ( fabs( dif ) > 24 )
{
ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
}
else
{
if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
{
NPC->client->ps.velocity[2] = 0;
}
}
}
}
// Apply friction
else if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
{
NPC->client->ps.velocity[2] = 0;
}
}
}
// Apply friction
if ( NPC->client->ps.velocity[0] )
{
NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
{
NPC->client->ps.velocity[0] = 0;
}
}
if ( NPC->client->ps.velocity[1] )
{
NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
{
NPC->client->ps.velocity[1] = 0;
}
}
}
void NPC_BSGrenadier_Attack( void )
{
//Don't do anything if we're hurt
if ( NPC->painDebounceTime > level.time )
{
NPC_UpdateAngles( qtrue, qtrue );
return;
}
//NPC_CheckEnemy( qtrue, qfalse );
//If we don't have an enemy, just idle
if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//
{
NPC->enemy = NULL;
NPC_BSGrenadier_Patrol();//FIXME: or patrol?
return;
}
if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
{//going to run
NPC_UpdateAngles( qtrue, qtrue );
return;
}
if ( !NPC->enemy )
{//WTF? somehow we lost our enemy?
NPC_BSGrenadier_Patrol();//FIXME: or patrol?
return;
}
enemyLOS = enemyCS = qfalse;
move = qtrue;
faceEnemy = qfalse;
shoot = qfalse;
enemyDist = DistanceSquared( NPC->enemy->currentOrigin, NPC->currentOrigin );
//See if we should switch to melee attack
if ( enemyDist < 16384 && (!NPC->enemy->client||NPC->enemy->client->ps.weapon != WP_SABER||!NPC->enemy->client->ps.saberActive) )//128
{//enemy is close and not using saber
if ( NPC->client->ps.weapon == WP_THERMAL )
{//grenadier
trace_t trace;
gi.trace ( &trace, NPC->currentOrigin, NPC->enemy->mins, NPC->enemy->maxs, NPC->enemy->currentOrigin, NPC->s.number, NPC->enemy->clipmask );
if ( !trace.allsolid && !trace.startsolid && (trace.fraction == 1.0 || trace.entityNum == NPC->enemy->s.number ) )
{//I can get right to him
//reset fire-timing variables
NPC_ChangeWeapon( WP_MELEE );
if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//NPCInfo->behaviorState == BS_STAND_AND_SHOOT )
{//FIXME: should we be overriding scriptFlags?
NPCInfo->scriptFlags |= SCF_CHASE_ENEMIES;//NPCInfo->behaviorState = BS_HUNT_AND_KILL;
}
}
}
}
else if ( enemyDist > 65536 || (NPC->enemy->client && NPC->enemy->client->ps.weapon == WP_SABER && NPC->enemy->client->ps.saberActive) )//256
{//enemy is far or using saber
if ( NPC->client->ps.weapon == WP_MELEE && (NPC->client->ps.stats[STAT_WEAPONS]&(1<<WP_THERMAL)) )
{//fisticuffs, make switch to thermal if have it
//reset fire-timing variables
NPC_ChangeWeapon( WP_THERMAL );
}
}
//can we see our target?
if ( NPC_ClearLOS( NPC->enemy ) )
{
NPCInfo->enemyLastSeenTime = level.time;
enemyLOS = qtrue;
if ( NPC->client->ps.weapon == WP_MELEE )
{
if ( enemyDist <= 4096 && InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 90, 45 ) )//within 64 & infront
{
VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
enemyCS = qtrue;
}
}
else if ( InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 45, 90 ) )
{//in front of me
//can we shoot our target?
//FIXME: how accurate/necessary is this check?
int hit = NPC_ShotEntity( NPC->enemy );
gentity_t *hitEnt = &g_entities[hit];
if ( hit == NPC->enemy->s.number
|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam ) )
{
VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
float enemyHorzDist = DistanceHorizontalSquared( NPC->enemy->currentOrigin, NPC->currentOrigin );
if ( enemyHorzDist < 1048576 )
{//within 1024
enemyCS = qtrue;
NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
}
else
{
NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
}
}
}
}
else
{
NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
}
/*
else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
{
NPCInfo->enemyLastSeenTime = level.time;
faceEnemy = qtrue;
}
*/
if ( enemyLOS )
{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
faceEnemy = qtrue;
}
if ( enemyCS )
{
shoot = qtrue;
if ( NPC->client->ps.weapon == WP_THERMAL )
{//don't chase and throw
move = qfalse;
}
else if ( NPC->client->ps.weapon == WP_MELEE && enemyDist < (NPC->maxs[0]+NPC->enemy->maxs[0]+16)*(NPC->maxs[0]+NPC->enemy->maxs[0]+16) )
{//close enough
move = qfalse;
}
}//this should make him chase enemy when out of range...?
//Check for movement to take care of
Grenadier_CheckMoveState();
//See if we should override shooting decision with any special considerations
Grenadier_CheckFireState();
if ( move )
{//move toward goal
if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist > 10000 ) )//100 squared
{
move = Grenadier_Move();
}
else
{
move = qfalse;
}
}
if ( !move )
{
if ( !TIMER_Done( NPC, "duck" ) )
{
ucmd.upmove = -127;
}
//FIXME: what about leaning?
}
else
{//stop ducking!
TIMER_Set( NPC, "duck", -1 );
}
if ( !faceEnemy )
{//we want to face in the dir we're running
if ( move )
{//don't run away and shoot
NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
NPCInfo->desiredPitch = 0;
shoot = qfalse;
}
NPC_UpdateAngles( qtrue, qtrue );
}
else// if ( faceEnemy )
{//face the enemy
NPC_FaceEnemy();
}
if ( NPCInfo->scriptFlags&SCF_DONT_FIRE )
{
shoot = qfalse;
}
//FIXME: don't shoot right away!
if ( shoot )
{//try to shoot if it's time
if ( TIMER_Done( NPC, "attackDelay" ) )
{
if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
{
WeaponThink( qtrue );
TIMER_Set( NPC, "attackDelay", NPCInfo->shotTime-level.time );
}
}
}
}
void NPC_BSSandCreature_Default( void )
{
qboolean visible = qfalse;
//clear it every frame, will be set if we actually move this frame...
NPC->s.loopSound = 0;
if ( NPC->health > 0 && TIMER_Done( NPC, "breaching" ) )
{//go back to non-solid mode
if ( NPC->contents )
{
NPC->contents = 0;
}
if ( NPC->clipmask == MASK_NPCSOLID )
{
NPC->clipmask = CONTENTS_SOLID|CONTENTS_MONSTERCLIP;
}
if ( TIMER_Done( NPC, "speaking" ) )
{
G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/sand_creature/voice%d.mp3", Q_irand( 1, 3 ) ) );
TIMER_Set( NPC, "speaking", Q_irand( 3000, 10000 ) );
}
}
else
{//still in breaching anim
visible = qtrue;
//FIXME: maybe push things up/away and maybe knock people down when doing this?
//FIXME: don't turn while breaching?
//FIXME: move faster while breaching?
//NOTE: shaking now done whenever he moves
}
//FIXME: when in start and end of attack/pain anims, need ground disturbance effect around him
// NOTENOTE: someone stubbed this code in, so I figured I'd use it. The timers are all weird, ie, magic numbers that sort of work,
// but maybe I'll try and figure out real values later if I have time.
if ( NPC->client->ps.legsAnim == BOTH_ATTACK1
|| NPC->client->ps.legsAnim == BOTH_ATTACK2 )
{//FIXME: get start and end frame numbers for this effect for each of these anims
vec3_t up={0,0,1};
vec3_t org;
VectorCopy( NPC->currentOrigin, org );
org[2] -= 40;
if ( NPC->client->ps.legsAnimTimer > 3700 )
{
// G_PlayEffect( G_EffectIndex( "env/sand_dive" ), NPC->currentOrigin, up );
G_PlayEffect( G_EffectIndex( "env/sand_spray" ), org, up );
}
else if ( NPC->client->ps.legsAnimTimer > 1600 && NPC->client->ps.legsAnimTimer < 1900 )
{
G_PlayEffect( G_EffectIndex( "env/sand_spray" ), org, up );
}
//G_PlayEffect( G_EffectIndex( "env/sand_attack_breach" ), org, up );
}
if ( !TIMER_Done( NPC, "pain" ) )
{
visible = qtrue;
}
else if ( !TIMER_Done( NPC, "attacking" ) )
{
visible = qtrue;
}
else
{
if ( NPC->activator )
{//kill and remove the guy we ate
//FIXME: want to play ...? What was I going to say?
NPC->activator->health = 0;
GEntity_DieFunc( NPC->activator, NPC, NPC, 1000, MOD_MELEE, 0, HL_NONE );
if ( NPC->activator->s.number )
{
G_FreeEntity( NPC->activator );
}
else
{//can't remove the player, just make him invisible
NPC->client->ps.eFlags |= EF_NODRAW;
}
NPC->activator = NPC->enemy = NPCInfo->goalEntity = NULL;
}
if ( NPC->enemy )
{
SandCreature_Chase();
}
else if ( (level.time - NPCInfo->enemyLastSeenTime) < 5000 )//FIXME: should make this able to be variable
{//we were alerted recently, move towards there and look for footsteps, etc.
SandCreature_Hunt();
}
else
{//no alerts, sleep and wake up only by alerts
//FIXME: keeps chasing goalEntity even when it's already reached it!
SandCreature_Sleep();
}
}
NPC_UpdateAngles( qtrue, qtrue );
if ( !visible )
{
NPC->client->ps.eFlags |= EF_NODRAW;
NPC->s.eFlags |= EF_NODRAW;
}
else
{
NPC->client->ps.eFlags &= ~EF_NODRAW;
NPC->s.eFlags &= ~EF_NODRAW;
SandCreature_PushEnts();
}
}
//------------------------------------
void Seeker_MaintainHeight( void )
{
float dif;
// Update our angles regardless
NPC_UpdateAngles( qtrue, qtrue );
// If we have an enemy, we should try to hover at or a little below enemy eye level
if ( NPC->enemy )
{
if (TIMER_Done( NPC, "heightChange" ))
{
TIMER_Set( NPC,"heightChange",Q_irand( 1000, 3000 ));
// Find the height difference
dif = (NPC->enemy->currentOrigin[2] + Q_flrand( NPC->enemy->maxs[2]/2, NPC->enemy->maxs[2]+8 )) - NPC->currentOrigin[2];
// cap to prevent dramatic height shifts
if ( fabs( dif ) > 2 )
{
if ( fabs( dif ) > 24 )
{
dif = ( dif < 0 ? -24 : 24 );
}
NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
}
}
}
else
{
gentity_t *goal = NULL;
if ( NPCInfo->goalEntity ) // Is there a goal?
{
goal = NPCInfo->goalEntity;
}
else
{
goal = NPCInfo->lastGoalEntity;
}
if ( goal )
{
dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
if ( fabs( dif ) > 24 )
{
ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
}
else
{
if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
{
NPC->client->ps.velocity[2] = 0;
}
}
}
}
}
// Apply friction
if ( NPC->client->ps.velocity[0] )
{
NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
{
NPC->client->ps.velocity[0] = 0;
}
}
if ( NPC->client->ps.velocity[1] )
{
NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
{
NPC->client->ps.velocity[1] = 0;
}
}
}
void NPC_BSHuntAndKill( void )
{
qboolean turned = qfalse;
vec3_t vec;
float enemyDist;
visibility_t oEVis;
int curAnim;
NPC_CheckEnemy( NPCInfo->tempBehavior != BS_HUNT_AND_KILL, qfalse, qtrue );//don't find new enemy if this is tempbehav
if ( NPC->enemy )
{
oEVis = enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV|CHECK_SHOOT );//CHECK_360|//CHECK_PVS|
if(enemyVisibility > VIS_PVS)
{
if ( !NPC_EnemyTooFar( NPC->enemy, 0, qtrue ) )
{//Enemy is close enough to shoot - FIXME: this next func does this also, but need to know here for info on whether ot not to turn later
NPC_CheckCanAttack( 1.0, qfalse );
turned = qtrue;
}
}
curAnim = NPC->client->ps.legsAnim;
if(curAnim != BOTH_ATTACK1 && curAnim != BOTH_ATTACK2 && curAnim != BOTH_ATTACK3 && curAnim != BOTH_MELEE1 && curAnim != BOTH_MELEE2 )
{//Don't move toward enemy if we're in a full-body attack anim
//FIXME, use IdealDistance to determin if we need to close distance
VectorSubtract(NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec);
enemyDist = VectorLength(vec);
if( enemyDist > 48 && ((enemyDist*1.5)*(enemyDist*1.5) >= NPC_MaxDistSquaredForWeapon() ||
oEVis != VIS_SHOOT ||
//!(ucmd.buttons & BUTTON_ATTACK) ||
enemyDist > IdealDistance(NPC)*3 ) )
{//We should close in?
NPCInfo->goalEntity = NPC->enemy;
NPC_MoveToGoal( qtrue );
}
else if(enemyDist < IdealDistance(NPC))
{//We should back off?
//if(ucmd.buttons & BUTTON_ATTACK)
{
NPCInfo->goalEntity = NPC->enemy;
NPCInfo->goalRadius = 12;
NPC_MoveToGoal( qtrue );
ucmd.forwardmove *= -1;
ucmd.rightmove *= -1;
VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
ucmd.buttons |= BUTTON_WALKING;
}
}//otherwise, stay where we are
}
}
else
{//ok, stand guard until we find an enemy
if( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
{
NPCInfo->tempBehavior = BS_DEFAULT;
}
else
{
NPCInfo->tempBehavior = BS_STAND_GUARD;
NPC_BSStandGuard();
}
return;
}
if(!turned)
{
NPC_UpdateAngles(qtrue, qtrue);
}
}
//----------------------------------
void Rancor_Combat( void )
{
if ( NPC->count )
{//holding my enemy
if ( TIMER_Done2( NPC, "takingPain", qtrue ))
{
NPCInfo->localState = LSTATE_CLEAR;
}
else
{
Rancor_Attack( 0, qfalse );
}
NPC_UpdateAngles( qtrue, qtrue );
return;
}
// If we cannot see our target or we have somewhere to go, then do that
if ( !NPC_ClearLOS4( NPC->enemy ) )//|| UpdateGoal( ))
{
NPCInfo->combatMove = qtrue;
NPCInfo->goalEntity = NPC->enemy;
NPCInfo->goalRadius = MIN_DISTANCE;//MAX_DISTANCE; // just get us within combat range
if ( !NPC_MoveToGoal( qtrue ) )
{//couldn't go after him? Look for a new one
TIMER_Set( NPC, "lookForNewEnemy", 0 );
NPCInfo->consecutiveBlockedMoves++;
}
else
{
NPCInfo->consecutiveBlockedMoves = 0;
}
return;
}
// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
NPC_FaceEnemy( qtrue );
{
float distance;
qboolean advance;
qboolean doCharge;
distance = Distance( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
advance = (qboolean)( distance > (NPC->r.maxs[0]+MIN_DISTANCE) ? qtrue : qfalse );
doCharge = qfalse;
if ( advance )
{//have to get closer
vec3_t yawOnlyAngles;
VectorSet( yawOnlyAngles, 0, NPC->r.currentAngles[YAW], 0 );
if ( NPC->enemy->health > 0
&& fabs(distance-250) <= 80
&& InFOV3( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, yawOnlyAngles, 30, 30 ) )
{
if ( !Q_irand( 0, 9 ) )
{//go for the charge
doCharge = qtrue;
advance = qfalse;
}
}
}
if (( advance /*|| NPCInfo->localState == LSTATE_WAITING*/ ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
{
if ( TIMER_Done2( NPC, "takingPain", qtrue ))
{
NPCInfo->localState = LSTATE_CLEAR;
}
else
{
Rancor_Move( 1 );
}
}
else
{
Rancor_Attack( distance, doCharge );
}
}
}
/*
-------------------------
NPC_BSRancor_Default
-------------------------
*/
void NPC_BSRancor_Default( void )
{
AddSightEvent( NPC, NPC->r.currentOrigin, 1024, AEL_DANGER_GREAT, 50 );
Rancor_Crush();
NPC->client->ps.eFlags2 &= ~(EF2_USE_ALT_ANIM|EF2_GENERIC_NPC_FLAG);
if ( NPC->count )
{//holding someone
NPC->client->ps.eFlags2 |= EF2_USE_ALT_ANIM;
if ( NPC->count == 2 )
{//in my mouth
NPC->client->ps.eFlags2 |= EF2_GENERIC_NPC_FLAG;
}
}
else
{
NPC->client->ps.eFlags2 &= ~(EF2_USE_ALT_ANIM|EF2_GENERIC_NPC_FLAG);
}
if ( TIMER_Done2( NPC, "clearGrabbed", qtrue ) )
{
Rancor_DropVictim( NPC );
}
else if ( NPC->client->ps.legsAnim == BOTH_PAIN2
&& NPC->count == 1
&& NPC->activator )
{
if ( !Q_irand( 0, 3 ) )
{
Rancor_CheckDropVictim();
}
}
if ( !TIMER_Done( NPC, "rageTime" ) )
{//do nothing but roar first time we see an enemy
AddSoundEvent( NPC, NPC->r.currentOrigin, 1024, AEL_DANGER_GREAT, qfalse );//, qfalse );
NPC_FaceEnemy( qtrue );
return;
}
if ( NPC->enemy )
{
/*
if ( NPC->enemy->client //enemy is a client
&& (NPC->enemy->client->NPC_class == CLASS_UGNAUGHT || NPC->enemy->client->NPC_class == CLASS_JAWA )//enemy is a lowly jawa or ugnaught
&& NPC->enemy->enemy != NPC//enemy's enemy is not me
&& (!NPC->enemy->enemy || !NPC->enemy->enemy->client || NPC->enemy->enemy->client->NPC_class!=CLASS_RANCOR) )//enemy's enemy is not a client or is not a rancor (which is as scary as me anyway)
{//they should be scared of ME and no-one else
G_SetEnemy( NPC->enemy, NPC );
}
*/
if ( TIMER_Done(NPC,"angrynoise") )
{
G_Sound( NPC, CHAN_AUTO, G_SoundIndex( va("sound/chars/rancor/misc/anger%d.wav", Q_irand(1, 3))) );
TIMER_Set( NPC, "angrynoise", Q_irand( 5000, 10000 ) );
}
else
{
AddSoundEvent( NPC, NPC->r.currentOrigin, 512, AEL_DANGER_GREAT, qfalse );//, qfalse );
}
if ( NPC->count == 2 && NPC->client->ps.legsAnim == BOTH_ATTACK3 )
{//we're still chewing our enemy up
NPC_UpdateAngles( qtrue, qtrue );
return;
}
//else, if he's in our hand, we eat, else if he's on the ground, we keep attacking his dead body for a while
if( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_RANCOR )
{//got mad at another Rancor, look for a valid enemy
if ( TIMER_Done( NPC, "rancorInfight" ) )
{
NPC_CheckEnemyExt( qtrue );
}
}
else if ( !NPC->count )
{
if ( ValidEnemy( NPC->enemy ) == qfalse )
{
TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
if ( !NPC->enemy->inuse || level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) )
{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
NPC->enemy = NULL;
Rancor_Patrol();
NPC_UpdateAngles( qtrue, qtrue );
return;
}
}
if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
{
gentity_t *newEnemy, *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
NPC->enemy = NULL;
newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
NPC->enemy = sav_enemy;
if ( newEnemy && newEnemy != sav_enemy )
{//picked up a new enemy!
NPC->lastEnemy = NPC->enemy;
G_SetEnemy( NPC, newEnemy );
//hold this one for at least 5-15 seconds
TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
}
else
{//look again in 2-5 secs
TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
}
}
}
Rancor_Combat();
}
else
{
if ( TIMER_Done(NPC,"idlenoise") )
{
G_Sound( NPC, CHAN_AUTO, G_SoundIndex( va("sound/chars/rancor/snort_%d.wav", Q_irand(1, 2))) );
TIMER_Set( NPC, "idlenoise", Q_irand( 2000, 4000 ) );
AddSoundEvent( NPC, NPC->r.currentOrigin, 384, AEL_DANGER, qfalse );//, qfalse );
}
if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
{
Rancor_Patrol();
}
else
{
Rancor_Idle();
}
}
NPC_UpdateAngles( qtrue, qtrue );
}
/*
-------------------------
Sentry_MaintainHeight
-------------------------
*/
void Sentry_MaintainHeight( void )
{
float dif;
NPC->s.loopSound = G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_1_lp" );
// Update our angles regardless
NPC_UpdateAngles( qtrue, qtrue );
// If we have an enemy, we should try to hover at about enemy eye level
if ( NPC->enemy )
{
// Find the height difference
dif = (NPC->enemy->currentOrigin[2]+NPC->enemy->maxs[2]) - NPC->currentOrigin[2];
// cap to prevent dramatic height shifts
if ( fabs( dif ) > 8 )
{
if ( fabs( dif ) > SENTRY_HOVER_HEIGHT )
{
dif = ( dif < 0 ? -24 : 24 );
}
NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
}
}
else
{
gentity_t *goal = NULL;
if ( NPCInfo->goalEntity ) // Is there a goal?
{
goal = NPCInfo->goalEntity;
}
else
{
goal = NPCInfo->lastGoalEntity;
}
if (goal)
{
dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
if ( fabs( dif ) > SENTRY_HOVER_HEIGHT )
{
ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
}
else
{
if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= SENTRY_VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
{
NPC->client->ps.velocity[2] = 0;
}
}
}
}
// Apply friction to Z
else if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= SENTRY_VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
{
NPC->client->ps.velocity[2] = 0;
}
}
}
// Apply friction
if ( NPC->client->ps.velocity[0] )
{
NPC->client->ps.velocity[0] *= SENTRY_VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
{
NPC->client->ps.velocity[0] = 0;
}
}
if ( NPC->client->ps.velocity[1] )
{
NPC->client->ps.velocity[1] *= SENTRY_VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
{
NPC->client->ps.velocity[1] = 0;
}
}
NPC_FaceEnemy( qtrue );
}
/*
-------------------------
NPC_BSWampa_Default
-------------------------
*/
void NPC_BSWampa_Default( void )
{
NPC->client->ps.eFlags2 &= ~EF2_USE_ALT_ANIM;
//NORMAL ANIMS
// stand1 = normal stand
// walk1 = normal, non-angry walk
// walk2 = injured
// run1 = far away run
// run2 = close run
//VICTIM ANIMS
// grabswipe = melee1 - sweep out and grab
// stand2 attack = attack4 - while holding victim, swipe at him
// walk3_drag = walk5 - walk with drag
// stand2 = hold victim
// stand2to1 = drop victim
if ( !TIMER_Done( NPC, "rageTime" ) )
{//do nothing but roar first time we see an enemy
NPC_FaceEnemy( qtrue );
return;
}
if ( NPC->enemy )
{
if ( !TIMER_Done(NPC,"attacking") )
{//in middle of attack
//face enemy
NPC_FaceEnemy( qtrue );
//continue attack logic
enemyDist = Distance( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
Wampa_Attack( enemyDist, qfalse );
return;
}
else
{
if ( TIMER_Done(NPC,"angrynoise") )
{
G_Sound( NPC, CHAN_VOICE, G_SoundIndex( va("sound/chars/wampa/misc/anger%d.wav", Q_irand(1, 2)) ) );
TIMER_Set( NPC, "angrynoise", Q_irand( 5000, 10000 ) );
}
//else, if he's in our hand, we eat, else if he's on the ground, we keep attacking his dead body for a while
if( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_WAMPA )
{//got mad at another Wampa, look for a valid enemy
if ( TIMER_Done( NPC, "wampaInfight" ) )
{
NPC_CheckEnemyExt( qtrue );
}
}
else
{
if ( ValidEnemy( NPC->enemy ) == qfalse )
{
TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
if ( !NPC->enemy->inuse || level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) )
{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
NPC->enemy = NULL;
Wampa_Patrol();
NPC_UpdateAngles( qtrue, qtrue );
//just lost my enemy
if ( (NPC->spawnflags&2) )
{//search around me if I don't have an enemy
NPC_BSSearchStart( NPC->waypoint, BS_SEARCH );
NPCInfo->tempBehavior = BS_DEFAULT;
}
else if ( (NPC->spawnflags&1) )
{//wander if I don't have an enemy
NPC_BSSearchStart( NPC->waypoint, BS_WANDER );
NPCInfo->tempBehavior = BS_DEFAULT;
}
return;
}
}
if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
{
gentity_t *newEnemy, *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
NPC->enemy = NULL;
newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
NPC->enemy = sav_enemy;
if ( newEnemy && newEnemy != sav_enemy )
{//picked up a new enemy!
NPC->lastEnemy = NPC->enemy;
G_SetEnemy( NPC, newEnemy );
//hold this one for at least 5-15 seconds
TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
}
else
{//look again in 2-5 secs
TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
}
}
}
Wampa_Combat();
return;
}
}
else
{
if ( TIMER_Done(NPC,"idlenoise") )
{
G_Sound( NPC, CHAN_AUTO, G_SoundIndex( "sound/chars/wampa/misc/anger3.wav" ) );
TIMER_Set( NPC, "idlenoise", Q_irand( 2000, 4000 ) );
}
if ( (NPC->spawnflags&2) )
{//search around me if I don't have an enemy
if ( NPCInfo->homeWp == WAYPOINT_NONE )
{//no homewap, initialize the search behavior
NPC_BSSearchStart( WAYPOINT_NONE, BS_SEARCH );
NPCInfo->tempBehavior = BS_DEFAULT;
}
ucmd.buttons |= BUTTON_WALKING;
NPC_BSSearch();//this automatically looks for enemies
}
else if ( (NPC->spawnflags&1) )
{//wander if I don't have an enemy
if ( NPCInfo->homeWp == WAYPOINT_NONE )
{//no homewap, initialize the wander behavior
NPC_BSSearchStart( WAYPOINT_NONE, BS_WANDER );
NPCInfo->tempBehavior = BS_DEFAULT;
}
ucmd.buttons |= BUTTON_WALKING;
NPC_BSWander();
if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
{
if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
{
Wampa_Idle();
}
else
{
Wampa_CheckRoar( NPC );
TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
}
}
}
else
{
if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
{
Wampa_Patrol();
}
else
{
Wampa_Idle();
}
}
}
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_BSGM_Attack( void )
{
//Don't do anything if we're hurt
if ( NPC->painDebounceTime > level.time )
{
NPC_UpdateAngles( qtrue, qtrue );
return;
}
//FIXME: if killed enemy, use victory anim
if ( NPC->enemy && NPC->enemy->health <= 0
&& !NPC->enemy->s.number )
{//my enemy is dead
if ( NPC->client->ps.torsoAnim == BOTH_STAND2TO1 )
{
if ( NPC->client->ps.torsoAnimTimer <= 500 )
{
G_AddVoiceEvent( NPC, Q_irand( EV_VICTORY1, EV_VICTORY3 ), 3000 );
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsAnimTimer += 500;
NPC->client->ps.torsoAnimTimer += 500;
}
}
else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1START )
{
if ( NPC->client->ps.torsoAnimTimer <= 500 )
{
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1STARTGESTURE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsAnimTimer += 500;
NPC->client->ps.torsoAnimTimer += 500;
}
}
else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1STARTGESTURE )
{
if ( NPC->client->ps.torsoAnimTimer <= 500 )
{
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsAnimTimer += 500;
NPC->client->ps.torsoAnimTimer += 500;
}
}
else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1STOP )
{
if ( NPC->client->ps.torsoAnimTimer <= 500 )
{
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
NPC->client->ps.legsAnimTimer = -1;
NPC->client->ps.torsoAnimTimer = -1;
}
}
else if ( NPC->wait )
{
if ( TIMER_Done( NPC, "gloatTime" ) )
{
GM_StartGloat();
}
else if ( DistanceHorizontalSquared( NPC->client->renderInfo.eyePoint, NPC->enemy->currentOrigin ) > 4096 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//64 squared
{
NPCInfo->goalEntity = NPC->enemy;
GM_Move();
}
else
{//got there
GM_StartGloat();
}
}
NPC_FaceEnemy( qtrue );
NPC_UpdateAngles( qtrue, qtrue );
return;
}
//If we don't have an enemy, just idle
if ( NPC_CheckEnemyExt() == qfalse || !NPC->enemy )
{
NPC->enemy = NULL;
NPC_BSGM_Patrol();
return;
}
enemyLOS = enemyCS = qfalse;
bMove = qtrue;
faceEnemy = qfalse;
shoot = qfalse;
hitAlly = qfalse;
VectorClear( impactPos );
enemyDist = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
if ( NPC->client->ps.torsoAnim == BOTH_ATTACK4 ||
NPC->client->ps.torsoAnim == BOTH_ATTACK5 )
{
shoot = qfalse;
if ( TIMER_Done( NPC, "smackTime" ) && !NPCInfo->blockedDebounceTime )
{//time to smack
//recheck enemyDist and InFront
if ( enemyDist < MELEE_DIST_SQUARED && InFront( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 0.3f ) )
{
vec3_t smackDir;
VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, smackDir );
smackDir[2] += 30;
VectorNormalize( smackDir );
//hurt them
G_Sound( NPC->enemy, G_SoundIndex( "sound/weapons/galak/skewerhit.wav" ) );
G_Damage( NPC->enemy, NPC, NPC, smackDir, NPC->currentOrigin, (g_spskill->integer+1)*Q_irand( 5, 10), DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_CRUSH );
if ( NPC->client->ps.torsoAnim == BOTH_ATTACK4 )
{//smackdown
int knockAnim = BOTH_KNOCKDOWN1;
if ( PM_CrouchAnim( NPC->enemy->client->ps.legsAnim ) )
{//knockdown from crouch
knockAnim = BOTH_KNOCKDOWN4;
}
//throw them
smackDir[2] = 1;
VectorNormalize( smackDir );
G_Throw( NPC->enemy, smackDir, 50 );
NPC_SetAnim( NPC->enemy, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
else
{//uppercut
//throw them
G_Throw( NPC->enemy, smackDir, 100 );
//make them backflip
NPC_SetAnim( NPC->enemy, SETANIM_BOTH, BOTH_KNOCKDOWN5, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
//done with the damage
NPCInfo->blockedDebounceTime = 1;
}
}
}
else if ( NPC->lockCount ) //already shooting laser
{//sometimes use the laser beam attack, but only after he's taken down our generator
shoot = qfalse;
if ( NPC->lockCount == 1 )
{//charging up
if ( TIMER_Done( NPC, "beamDelay" ) )
{//time to start the beam
int laserAnim;
if ( Q_irand( 0, 1 ) )
{
laserAnim = BOTH_ATTACK2;
}
else
{
laserAnim = BOTH_ATTACK7;
}
NPC_SetAnim( NPC, SETANIM_BOTH, laserAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoAnimTimer + Q_irand( 1000, 3000 ) );
//turn on beam effect
NPC->lockCount = 2;
G_PlayEffect( "galak/trace_beam", NPC->s.number );
NPC->s.loopSound = G_SoundIndex( "sound/weapons/galak/lasercutting.wav" );
if ( !NPCInfo->coverTarg )
{//for moving looping sound at end of trace
NPCInfo->coverTarg = G_Spawn();
if ( NPCInfo->coverTarg )
{
G_SetOrigin( NPCInfo->coverTarg, NPC->client->renderInfo.muzzlePoint );
NPCInfo->coverTarg->svFlags |= SVF_BROADCAST;
NPCInfo->coverTarg->s.loopSound = G_SoundIndex( "sound/weapons/galak/lasercutting.wav" );
}
}
}
}
else
{//in the actual attack now
if ( !NPC->client->ps.torsoAnimTimer )
{//attack done!
NPC->lockCount = 0;
G_FreeEntity( NPCInfo->coverTarg );
NPC->s.loopSound = 0;
NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_DROPWEAP2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoAnimTimer );
}
else
{//attack still going
//do the trace and damage
trace_t trace;
vec3_t end, mins={-3,-3,-3}, maxs={3,3,3};
VectorMA( NPC->client->renderInfo.muzzlePoint, 1024, NPC->client->renderInfo.muzzleDir, end );
gi.trace( &trace, NPC->client->renderInfo.muzzlePoint, mins, maxs, end, NPC->s.number, MASK_SHOT );
if ( trace.allsolid || trace.startsolid )
{//oops, in a wall
if ( NPCInfo->coverTarg )
{
G_SetOrigin( NPCInfo->coverTarg, NPC->client->renderInfo.muzzlePoint );
}
}
else
{//clear
if ( trace.fraction < 1.0f )
{//hit something
gentity_t *traceEnt = &g_entities[trace.entityNum];
if ( traceEnt && traceEnt->takedamage )
{//damage it
G_SoundAtSpot( trace.endpos, G_SoundIndex( "sound/weapons/galak/laserdamage.wav" ) );
G_Damage( traceEnt, NPC, NPC, NPC->client->renderInfo.muzzleDir, trace.endpos, 10, 0, MOD_ENERGY );
}
}
if ( NPCInfo->coverTarg )
{
G_SetOrigin( NPCInfo->coverTarg, trace.endpos );
}
if ( !Q_irand( 0, 5 ) )
{
G_SoundAtSpot( trace.endpos, G_SoundIndex( "sound/weapons/galak/laserdamage.wav" ) );
}
}
}
}
}
else
{//Okay, we're not in a special attack, see if we should switch weapons or start a special attack
/*
if ( NPC->s.weapon == WP_REPEATER
&& !(NPCInfo->scriptFlags & SCF_ALT_FIRE)//using rapid-fire
&& NPC->enemy->s.weapon == WP_SABER //enemy using saber
&& NPC->client && (NPC->client->ps.saberEventFlags&SEF_DEFLECTED)
&& !Q_irand( 0, 50 ) )
{//he's deflecting my shots, switch to the laser or the lob fire for a while
TIMER_Set( NPC, "noRapid", Q_irand( 2000, 6000 ) );
NPCInfo->scriptFlags |= SCF_ALT_FIRE;
NPC->alt_fire = qtrue;
if ( NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH && (Q_irand( 0, 1 )||enemyDist < MAX_LOB_DIST_SQUARED) )
{//shield down, use laser
NPC_GM_StartLaser();
}
}
else*/
if ( !NPC->client->ps.powerups[PW_GALAK_SHIELD]
&& enemyDist < MELEE_DIST_SQUARED
&& InFront( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 0.3f )
&& G_StandardHumanoid( NPC->enemy->NPC_type ) )//within 80 and in front
{//our shield is down, and enemy within 80, if very close, use melee attack to slap away
if ( TIMER_Done( NPC, "attackDelay" ) )
{
//animate me
int swingAnim;
if ( NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH )
{//generator down, use random melee
swingAnim = Q_irand( BOTH_ATTACK4, BOTH_ATTACK5 );//smackdown or uppercut
}
else
{//always knock-away
swingAnim = BOTH_ATTACK5;//uppercut
}
//FIXME: swing sound
NPC_SetAnim( NPC, SETANIM_BOTH, swingAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoAnimTimer + Q_irand( 1000, 3000 ) );
//delay the hurt until the proper point in the anim
TIMER_Set( NPC, "smackTime", 600 );
NPCInfo->blockedDebounceTime = 0;
//FIXME: say something?
}
}
else if ( !NPC->lockCount && NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH
&& TIMER_Done( NPC, "attackDelay" )
&& InFront( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 0.3f )
&& ((!Q_irand( 0, 10*(2-g_spskill->integer))&& enemyDist > MIN_LOB_DIST_SQUARED&& enemyDist < MAX_LOB_DIST_SQUARED)
||(!TIMER_Done( NPC, "noLob" )&&!TIMER_Done( NPC, "noRapid" )))
&& NPC->enemy->s.weapon != WP_TURRET )
{//sometimes use the laser beam attack, but only after he's taken down our generator
shoot = qfalse;
NPC_GM_StartLaser();
}
else if ( enemyDist < MIN_LOB_DIST_SQUARED
&& (NPC->enemy->s.weapon != WP_TURRET || Q_stricmp( "PAS", NPC->enemy->classname ))
&& TIMER_Done( NPC, "noRapid" ) )//256
{//enemy within 256
if ( (NPC->client->ps.weapon == WP_REPEATER) && (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
{//shooting an explosive, but enemy too close, switch to primary fire
NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
NPC->alt_fire = qfalse;
//FIXME: use weap raise & lower anims
NPC_ChangeWeapon( WP_REPEATER );
}
}
else if ( (enemyDist > MAX_LOB_DIST_SQUARED || (NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname )))
&& TIMER_Done( NPC, "noLob" ) )//448
{//enemy more than 448 away and we are ready to try lob fire again
if ( (NPC->client->ps.weapon == WP_REPEATER) && !(NPCInfo->scriptFlags & SCF_ALT_FIRE) )
{//enemy far enough away to use lobby explosives
NPCInfo->scriptFlags |= SCF_ALT_FIRE;
NPC->alt_fire = qtrue;
//FIXME: use weap raise & lower anims
NPC_ChangeWeapon( WP_REPEATER );
}
}
}
//can we see our target?
if ( NPC_ClearLOS( NPC->enemy ) )
{
NPCInfo->enemyLastSeenTime = level.time;//used here for aim debouncing, not always a clear LOS
enemyLOS = qtrue;
if ( NPC->client->ps.weapon == WP_NONE )
{
enemyCS = qfalse;//not true, but should stop us from firing
NPC_AimAdjust( -1 );//adjust aim worse longer we have no weapon
}
else
{//can we shoot our target?
if ( ((NPC->client->ps.weapon == WP_REPEATER && (NPCInfo->scriptFlags&SCF_ALT_FIRE))) && enemyDist < MIN_LOB_DIST_SQUARED )//256
{
enemyCS = qfalse;//not true, but should stop us from firing
hitAlly = qtrue;//us!
//FIXME: if too close, run away!
}
else
{
int hit = NPC_ShotEntity( NPC->enemy, impactPos );
gentity_t *hitEnt = &g_entities[hit];
if ( hit == NPC->enemy->s.number
|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
|| ( hitEnt && hitEnt->takedamage ) )
{//can hit enemy or will hit glass or other breakable, so shoot anyway
enemyCS = qtrue;
NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
}
else
{//Hmm, have to get around this bastard
NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
{//would hit an ally, don't fire!!!
hitAlly = qtrue;
}
else
{//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
}
}
}
}
}
else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
{
if ( TIMER_Done( NPC, "talkDebounce" ) && !Q_irand( 0, 10 ) )
{
if ( NPCInfo->enemyCheckDebounceTime < 8 )
{
int speech = -1;
switch( NPCInfo->enemyCheckDebounceTime )
{
case 0:
case 1:
case 2:
speech = EV_CHASE1 + NPCInfo->enemyCheckDebounceTime;
break;
case 3:
case 4:
case 5:
speech = EV_COVER1 + NPCInfo->enemyCheckDebounceTime-3;
break;
case 6:
case 7:
speech = EV_ESCAPING1 + NPCInfo->enemyCheckDebounceTime-6;
break;
}
NPCInfo->enemyCheckDebounceTime++;
if ( speech != -1 )
{
G_AddVoiceEvent( NPC, speech, Q_irand( 3000, 5000 ) );
TIMER_Set( NPC, "talkDebounce", Q_irand( 5000, 7000 ) );
}
}
}
NPCInfo->enemyLastSeenTime = level.time;
int hit = NPC_ShotEntity( NPC->enemy, impactPos );
gentity_t *hitEnt = &g_entities[hit];
if ( hit == NPC->enemy->s.number
|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
|| ( hitEnt && hitEnt->takedamage ) )
{//can hit enemy or will hit glass or other breakable, so shoot anyway
enemyCS = qtrue;
}
else
{
faceEnemy = qtrue;
NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
}
}
if ( enemyLOS )
{
faceEnemy = qtrue;
}
else
{
if ( !NPCInfo->goalEntity )
{
NPCInfo->goalEntity = NPC->enemy;
}
if ( NPCInfo->goalEntity == NPC->enemy )
{//for now, always chase the enemy
bMove = qtrue;
}
}
if ( enemyCS )
{
shoot = qtrue;
//NPCInfo->enemyCheckDebounceTime = level.time;//actually used here as a last actual LOS
}
else
{
if ( !NPCInfo->goalEntity )
{
NPCInfo->goalEntity = NPC->enemy;
}
if ( NPCInfo->goalEntity == NPC->enemy )
{//for now, always chase the enemy
bMove = qtrue;
}
}
//Check for movement to take care of
GM_CheckMoveState();
//See if we should override shooting decision with any special considerations
GM_CheckFireState();
if ( NPC->client->ps.weapon == WP_REPEATER && (NPCInfo->scriptFlags&SCF_ALT_FIRE) && shoot && TIMER_Done( NPC, "attackDelay" ) )
{
vec3_t muzzle;
vec3_t angles;
vec3_t target;
vec3_t velocity = {0,0,0};
vec3_t mins = {-REPEATER_ALT_SIZE,-REPEATER_ALT_SIZE,-REPEATER_ALT_SIZE}, maxs = {REPEATER_ALT_SIZE,REPEATER_ALT_SIZE,REPEATER_ALT_SIZE};
CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
VectorCopy( NPC->enemy->currentOrigin, target );
target[0] += Q_flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
target[1] += Q_flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
target[2] += Q_flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
//Find the desired angles
qboolean clearshot = WP_LobFire( NPC, muzzle, target, mins, maxs, MASK_SHOT|CONTENTS_LIGHTSABER,
velocity, qtrue, NPC->s.number, NPC->enemy->s.number,
300, 1100, 1500, qtrue );
if ( VectorCompare( vec3_origin, velocity ) || (!clearshot&&enemyLOS&&enemyCS) )
{//no clear lob shot and no lob shot that will hit something breakable
if ( enemyLOS && enemyCS && TIMER_Done( NPC, "noRapid" ) )
{//have a clear straight shot, so switch to primary
NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
NPC->alt_fire = qfalse;
NPC_ChangeWeapon( WP_REPEATER );
//keep this weap for a bit
TIMER_Set( NPC, "noLob", Q_irand( 500, 1000 ) );
}
else
{
shoot = qfalse;
}
}
else
{
vectoangles( velocity, angles );
NPCInfo->desiredYaw = AngleNormalize360( angles[YAW] );
NPCInfo->desiredPitch = AngleNormalize360( angles[PITCH] );
VectorCopy( velocity, NPC->client->hiddenDir );
NPC->client->hiddenDist = VectorNormalize ( NPC->client->hiddenDir );
}
}
else if ( faceEnemy )
{//face the enemy
NPC_FaceEnemy( qtrue );
}
if ( !TIMER_Done( NPC, "standTime" ) )
{
bMove = qfalse;
}
if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
{//not supposed to chase my enemies
if ( NPCInfo->goalEntity == NPC->enemy )
{//goal is my entity, so don't bMove
bMove = qfalse;
}
}
if ( bMove && !NPC->lockCount )
{//bMove toward goal
if ( NPCInfo->goalEntity
&& NPC->client->ps.legsAnim != BOTH_ALERT1
&& NPC->client->ps.legsAnim != BOTH_ATTACK2
&& NPC->client->ps.legsAnim != BOTH_ATTACK4
&& NPC->client->ps.legsAnim != BOTH_ATTACK5
&& NPC->client->ps.legsAnim != BOTH_ATTACK7 )
{
bMove = GM_Move();
}
else
{
bMove = qfalse;
}
}
if ( !TIMER_Done( NPC, "flee" ) )
{//running away
faceEnemy = qfalse;
}
//FIXME: check scf_face_move_dir here?
if ( !faceEnemy )
{//we want to face in the dir we're running
if ( !bMove )
{//if we haven't moved, we should look in the direction we last looked?
VectorCopy( NPC->client->ps.viewangles, NPCInfo->lastPathAngles );
}
if ( bMove )
{//don't run away and shoot
NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
NPCInfo->desiredPitch = 0;
shoot = qfalse;
}
}
NPC_UpdateAngles( qtrue, qtrue );
if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
{
shoot = qfalse;
}
if ( NPC->enemy && NPC->enemy->enemy )
{
if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
shoot = qfalse;
}
}
//FIXME: don't shoot right away!
if ( shoot )
{//try to shoot if it's time
if ( TIMER_Done( NPC, "attackDelay" ) )
{
if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
{
WeaponThink( qtrue );
}
}
}
//also:
if ( NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname ) )
{//crush turrets
if ( G_BoundsOverlap( NPC->absmin, NPC->absmax, NPC->enemy->absmin, NPC->enemy->absmax ) )
{//have to do this test because placed turrets are not solid to NPCs (so they don't obstruct navigation)
if ( NPC->client->ps.powerups[PW_GALAK_SHIELD] > 0 )
{
NPC->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
G_Damage( NPC->enemy, NPC, NPC, NULL, NPC->currentOrigin, 100, DAMAGE_NO_KNOCKBACK, MOD_ELECTROCUTE );
}
else
{
G_Damage( NPC->enemy, NPC, NPC, NULL, NPC->currentOrigin, 100, DAMAGE_NO_KNOCKBACK, MOD_CRUSH );
}
}
}
else if ( NPCInfo->touchedByPlayer != NULL && NPCInfo->touchedByPlayer == NPC->enemy )
{//touched enemy
if ( NPC->client->ps.powerups[PW_GALAK_SHIELD] > 0 )
{//zap him!
//animate me
NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK6, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoAnimTimer );
TIMER_Set( NPC, "standTime", NPC->client->ps.legsAnimTimer );
//FIXME: debounce this?
NPCInfo->touchedByPlayer = NULL;
//FIXME: some shield effect?
NPC->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
vec3_t smackDir;
VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, smackDir );
smackDir[2] += 30;
VectorNormalize( smackDir );
G_Damage( NPC->enemy, NPC, NPC, smackDir, NPC->currentOrigin, (g_spskill->integer+1)*Q_irand( 5, 10), DAMAGE_NO_KNOCKBACK, MOD_ELECTROCUTE );
//throw them
G_Throw( NPC->enemy, smackDir, 100 );
NPC->enemy->s.powerups |= ( 1 << PW_SHOCKED );
if ( NPC->enemy->client )
{
NPC->enemy->client->ps.powerups[PW_SHOCKED] = level.time + 1000;
}
//stop any attacks
ucmd.buttons = 0;
}
}
if ( NPCInfo->movementSpeech < 3 && NPCInfo->blockedSpeechDebounceTime <= level.time )
{
if ( NPC->enemy && NPC->enemy->health > 0 && NPC->enemy->painDebounceTime > level.time )
{
if ( NPC->enemy->health < 50 && NPCInfo->movementSpeech == 2 )
{
G_AddVoiceEvent( NPC, EV_ANGER2, Q_irand( 2000, 4000 ) );
NPCInfo->movementSpeech = 3;
}
else if ( NPC->enemy->health < 75 && NPCInfo->movementSpeech == 1 )
{
G_AddVoiceEvent( NPC, EV_ANGER1, Q_irand( 2000, 4000 ) );
NPCInfo->movementSpeech = 2;
}
else if ( NPC->enemy->health < 100 && NPCInfo->movementSpeech == 0 )
{
G_AddVoiceEvent( NPC, EV_ANGER3, Q_irand( 2000, 4000 ) );
NPCInfo->movementSpeech = 1;
}
}
}
}
/*
-------------------------
Droid_Patrol
-------------------------
*/
void Droid_Patrol( void )
{
NPC->pos1[1] = AngleNormalize360( NPC->pos1[1]);
if ( NPC->client && NPC->client->NPC_class != CLASS_GONK )
{
if (NPC->client->NPC_class != CLASS_R5D2)
{ //he doesn't have an eye.
R2D2_PartsMove(); // Get his eye moving.
}
R2D2_TurnAnims();
}
//If we have somewhere to go, then do that
if ( UpdateGoal() )
{
ucmd.buttons |= BUTTON_WALKING;
NPC_MoveToGoal( qtrue );
if( NPC->client && NPC->client->NPC_class == CLASS_MOUSE )
{
NPCInfo->desiredYaw += sin(level.time*.5) * 25; // Weaves side to side a little
if (TIMER_Done(NPC,"patrolNoise"))
{
G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/mouse/misc/mousego%d.wav", Q_irand(1, 3)) );
TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
}
}
else if( NPC->client && NPC->client->NPC_class == CLASS_R2D2 )
{
if (TIMER_Done(NPC,"patrolNoise"))
{
G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/r2d2/misc/r2d2talk0%d.wav", Q_irand(1, 3)) );
TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
}
}
else if( NPC->client && NPC->client->NPC_class == CLASS_R5D2 )
{
if (TIMER_Done(NPC,"patrolNoise"))
{
G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/r5d2/misc/r5talk%d.wav", Q_irand(1, 4)) );
TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
}
}
if( NPC->client && NPC->client->NPC_class == CLASS_GONK )
{
if (TIMER_Done(NPC,"patrolNoise"))
{
G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/gonk/misc/gonktalk%d.wav", Q_irand(1, 2)) );
TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
}
}
// else
// {
// R5D2_LookAround();
// }
}
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_BSStandAndShoot (void)
{
//FIXME:
//When our numbers outnumber enemies 3 to 1, or only one of them,
//go into hunt and kill mode
//FIXME:
//When they're all dead, go to some script or wander off to sickbay?
if(NPC->client->playerTeam && NPC->client->enemyTeam)
{
//FIXME: don't realize this right away- or else enemies show up and we're standing around
/*
if( teamNumbers[NPC->enemyTeam] == 0 )
{//ok, stand guard until we find another enemy
//reset our rush counter
teamCounter[NPC->playerTeam] = 0;
NPCInfo->tempBehavior = BS_STAND_GUARD;
NPC_BSStandGuard();
return;
}*/
/*
//FIXME: whether to do this or not should be settable
else if( NPC->playerTeam != TEAM_BORG )//Borg don't rush
{
//FIXME: In case reinforcements show up, we should wait a few seconds
//and keep checking before rushing!
//Also: what if not everyone on our team is going after playerTeam?
//Also: our team count includes medics!
if(NPC->health > 25)
{//Can we rush the enemy?
if(teamNumbers[NPC->enemyTeam] == 1 ||
teamNumbers[NPC->playerTeam] >= teamNumbers[NPC->enemyTeam]*3)
{//Only one of them or we outnumber 3 to 1
if(teamStrength[NPC->playerTeam] >= 75 ||
(teamStrength[NPC->playerTeam] >= 50 && teamStrength[NPC->playerTeam] > teamStrength[NPC->enemyTeam]))
{//Our team is strong enough to rush
teamCounter[NPC->playerTeam]++;
if(teamNumbers[NPC->playerTeam] * 17 <= teamCounter[NPC->playerTeam])
{//ok, we waited 1.7 think cycles on average and everyone is go, let's do it!
//FIXME: Should we do this to everyone on our team?
NPCInfo->behaviorState = BS_HUNT_AND_KILL;
//FIXME: if the tide changes, we should retreat!
//FIXME: when do we reset the counter?
NPC_BSHuntAndKill ();
return;
}
}
else//Oops! Something's wrong, reset the counter to rush
teamCounter[NPC->playerTeam] = 0;
}
else//Oops! Something's wrong, reset the counter to rush
teamCounter[NPC->playerTeam] = 0;
}
}
*/
}
NPC_CheckEnemy(qtrue, qfalse, qtrue);
if(NPCInfo->duckDebounceTime > level.time && NPC->client->ps.weapon != WP_SABER )
{
ucmd.upmove = -127;
if(NPC->enemy)
{
NPC_CheckCanAttack(1.0, qtrue);
}
return;
}
if(NPC->enemy)
{
if(!NPC_StandTrackAndShoot( NPC, qtrue ))
{//That func didn't update our angles
NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
NPC_UpdateAngles(qtrue, qtrue);
}
}
else
{
NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
NPC_UpdateAngles(qtrue, qtrue);
// NPC_BSIdle();//only moves if we have a goal
}
}
void NPC_BSGrenadier_Patrol( void )
{//FIXME: pick up on bodies of dead buddies?
if ( NPCInfo->confusionTime < level.time )
{
//Look for any enemies
if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
{
if ( NPC_CheckPlayerTeamStealth() )
{
//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be automatic now
//NPC_AngerSound();
NPC_UpdateAngles( qtrue, qtrue );
return;
}
}
if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
{
//Is there danger nearby
int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_SUSPICIOUS );
if ( NPC_CheckForDanger( alertEvent ) )
{
NPC_UpdateAngles( qtrue, qtrue );
return;
}
else
{//check for other alert events
//There is an event to look at
if ( alertEvent >= 0 && level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
{
NPCInfo->lastAlertID = level.alertEvents[alertEvent].ID;
if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED )
{
if ( level.alertEvents[alertEvent].owner &&
level.alertEvents[alertEvent].owner->client &&
level.alertEvents[alertEvent].owner->health >= 0 &&
level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
{//an enemy
G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
//NPCInfo->enemyLastSeenTime = level.time;
TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
}
}
else
{//FIXME: get more suspicious over time?
//Save the position for movement (if necessary)
VectorCopy( level.alertEvents[alertEvent].position, NPCInfo->investigateGoal );
NPCInfo->investigateDebounceTime = level.time + Q_irand( 500, 1000 );
if ( level.alertEvents[alertEvent].level == AEL_SUSPICIOUS )
{//suspicious looks longer
NPCInfo->investigateDebounceTime += Q_irand( 500, 2500 );
}
}
}
}
if ( NPCInfo->investigateDebounceTime > level.time )
{//FIXME: walk over to it, maybe? Not if not chase enemies
//NOTE: stops walking or doing anything else below
vec3_t dir, angles;
float o_yaw, o_pitch;
VectorSubtract( NPCInfo->investigateGoal, NPC->client->renderInfo.eyePoint, dir );
vectoangles( dir, angles );
o_yaw = NPCInfo->desiredYaw;
o_pitch = NPCInfo->desiredPitch;
NPCInfo->desiredYaw = angles[YAW];
NPCInfo->desiredPitch = angles[PITCH];
NPC_UpdateAngles( qtrue, qtrue );
NPCInfo->desiredYaw = o_yaw;
NPCInfo->desiredPitch = o_pitch;
return;
}
}
}
//If we have somewhere to go, then do that
if ( UpdateGoal() )
{
ucmd.buttons |= BUTTON_WALKING;
NPC_MoveToGoal( qtrue );
}
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_BSRunAndShoot (void)
{
/*if(NPC->playerTeam && NPC->enemyTeam)
{
//FIXME: don't realize this right away- or else enemies show up and we're standing around
if( teamNumbers[NPC->enemyTeam] == 0 )
{//ok, stand guard until we find another enemy
//reset our rush counter
teamCounter[NPC->playerTeam] = 0;
NPCInfo->tempBehavior = BS_STAND_GUARD;
NPC_BSStandGuard();
return;
}
}*/
//NOTE: are we sure we want ALL run and shoot people to move this way?
//Shouldn't it check to see if we have an enemy and our enemy is our goal?!
//Moved that check into NPC_MoveToGoal
//NPCInfo->combatMove = qtrue;
NPC_CheckEnemy( qtrue, qfalse, qtrue );
if ( NPCInfo->duckDebounceTime > level.time ) // && NPCInfo->hidingGoal )
{
ucmd.upmove = -127;
if ( NPC->enemy )
{
NPC_CheckCanAttack( 1.0, qfalse );
}
return;
}
if ( NPC->enemy )
{
int monitor = NPC->cantHitEnemyCounter;
NPC_StandTrackAndShoot( NPC, qfalse );//(NPCInfo->hidingGoal != NULL) );
if ( !(ucmd.buttons & BUTTON_ATTACK) && ucmd.upmove >= 0 && NPC->cantHitEnemyCounter > monitor )
{//not crouching and not firing
vec3_t vec;
VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec );
vec[2] = 0;
if ( VectorLength( vec ) > 128 || NPC->cantHitEnemyCounter >= 10 )
{//run at enemy if too far away
//The cantHitEnemyCounter getting high has other repercussions
//100 (10 seconds) will make you try to pick a new enemy...
//But we're chasing, so we clamp it at 50 here
if ( NPC->cantHitEnemyCounter > 60 )
{
NPC->cantHitEnemyCounter = 60;
}
if ( NPC->cantHitEnemyCounter >= (NPCInfo->stats.aggression+1) * 10 )
{
NPC_LostEnemyDecideChase();
}
//chase and face
ucmd.angles[YAW] = 0;
ucmd.angles[PITCH] = 0;
NPCInfo->goalEntity = NPC->enemy;
NPCInfo->goalRadius = 12;
//NAV_ClearLastRoute(NPC);
NPC_MoveToGoal( qtrue );
NPC_UpdateAngles(qtrue, qtrue);
}
else
{
//FIXME: this could happen if they're just on the other side
//of a thin wall or something else blocking out shot. That
//would make us just stand there and not go around it...
//but maybe it's okay- might look like we're waiting for
//him to come out...?
//Current solution: runs around if cantHitEnemyCounter gets
//to 10 (1 second).
}
}
else
{//Clear the can't hit enemy counter here
NPC->cantHitEnemyCounter = 0;
}
}
else
{
if ( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
{//lost him, go back to what we were doing before
NPCInfo->tempBehavior = BS_DEFAULT;
return;
}
// NPC_BSRun();//only moves if we have a goal
}
}
void Pilot_Steer_Vehicle()
{
if (!NPC->enemy || !NPC->enemy->client)
{
return;
}
// SETUP
//=======
// Setup Actor Data
//------------------
CVec3 ActorPos(NPC->currentOrigin);
CVec3 ActorAngles(NPC->currentAngles);
ActorAngles[2] = 0;
Vehicle_t* ActorVeh = NPCInfo->greetEnt->m_pVehicle;
bool ActorInTurbo = (ActorVeh->m_iTurboTime>level.time);
float ActorSpeed = (ActorVeh)?(VectorLength(ActorVeh->m_pParentEntity->client->ps.velocity)):(NPC->client->ps.speed);
// If my vehicle is spinning out of control, just hold on, we're going to die!!!!!
//---------------------------------------------------------------------------------
if (ActorVeh && (ActorVeh->m_ulFlags & VEH_OUTOFCONTROL))
{
if (NPC->client->ps.weapon!=WP_NONE)
{
NPC_ChangeWeapon(WP_NONE);
}
ucmd.buttons &=~BUTTON_ATTACK;
ucmd.buttons &=~BUTTON_ALT_ATTACK;
return;
}
CVec3 ActorDirection;
AngleVectors(ActorAngles.v, ActorDirection.v, 0, 0);
CVec3 ActorFuturePos(ActorPos);
ActorFuturePos.ScaleAdd(ActorDirection, FUTURE_PRED_DIST);
bool ActorDoTurbo = false;
bool ActorAccelerate = false;
bool ActorAimAtTarget= true;
float ActorYawOffset = 0.0f;
// Setup Enemy Data
//------------------
CVec3 EnemyPos(NPC->enemy->currentOrigin);
CVec3 EnemyAngles(NPC->enemy->currentAngles);
EnemyAngles[2] = 0;
Vehicle_t* EnemyVeh = (NPC->enemy->s.m_iVehicleNum)?(g_entities[NPC->enemy->s.m_iVehicleNum].m_pVehicle):(0);
bool EnemyInTurbo = (EnemyVeh && EnemyVeh->m_iTurboTime>level.time);
float EnemySpeed = (EnemyVeh)?(EnemyVeh->m_pParentEntity->client->ps.speed):(NPC->enemy->resultspeed);
bool EnemySlideBreak = (EnemyVeh && (EnemyVeh->m_ulFlags&VEH_SLIDEBREAKING || EnemyVeh->m_ulFlags&VEH_STRAFERAM));
bool EnemyDead = (NPC->enemy->health<=0);
bool ActorFlank = (NPCInfo->lastAvoidSteerSideDebouncer>level.time && EnemyVeh && EnemySpeed>10.0f);
CVec3 EnemyDirection;
CVec3 EnemyRight;
AngleVectors(EnemyAngles.v, EnemyDirection.v, EnemyRight.v, 0);
CVec3 EnemyFuturePos(EnemyPos);
EnemyFuturePos.ScaleAdd(EnemyDirection, FUTURE_PRED_DIST);
ESide EnemySide = ActorPos.LRTest(EnemyPos, EnemyFuturePos);
CVec3 EnemyFlankPos(EnemyFuturePos);
EnemyFlankPos.ScaleAdd(EnemyRight, (EnemySide==Side_Right)?(FUTURE_SIDE_DIST):(-FUTURE_SIDE_DIST));
// Debug Draw Enemy Data
//-----------------------
if (false)
{
CG_DrawEdge(EnemyPos.v, EnemyFuturePos.v, EDGE_IMPACT_SAFE);
CG_DrawEdge(EnemyFuturePos.v, EnemyFlankPos.v, EDGE_IMPACT_SAFE);
}
// Setup Move And Aim Directions
//-------------------------------
CVec3 MoveDirection((ActorFlank)?(EnemyFlankPos):(EnemyFuturePos));
MoveDirection -= ActorPos;
float MoveDistance = MoveDirection.SafeNorm();
float MoveAccuracy = MoveDirection.Dot(ActorDirection);
CVec3 AimDirection(EnemyPos);
AimDirection -= ActorPos;
float AimDistance = AimDirection.SafeNorm();
float AimAccuracy = AimDirection.Dot(ActorDirection);
if (!ActorFlank && TIMER_Done(NPC, "FlankAttackCheck"))
{
TIMER_Set(NPC, "FlankAttackCheck", Q_irand(1000, 3000));
if (MoveDistance<4000 && Q_irand(0, 1)==0)
{
NPCInfo->lastAvoidSteerSideDebouncer = level.time + Q_irand(8000, 14000);
}
}
// Fly By Sounds
//---------------
if ((ActorVeh->m_pVehicleInfo->soundFlyBy || ActorVeh->m_pVehicleInfo->soundFlyBy2) &&
EnemyVeh &&
MoveDistance<800 &&
ActorSpeed>500.0f &&
TIMER_Done(NPC, "FlybySoundDebouncer")
)
{
if (EnemySpeed<100.0f || (ActorDirection.Dot(EnemyDirection)*(MoveDistance/800.0f))<-0.5f)
{
TIMER_Set(NPC, "FlybySoundDebouncer", 2000);
int soundFlyBy = ActorVeh->m_pVehicleInfo->soundFlyBy;
if (ActorVeh->m_pVehicleInfo->soundFlyBy2 && (!soundFlyBy || !Q_irand(0,1)))
{
soundFlyBy = ActorVeh->m_pVehicleInfo->soundFlyBy2;
}
G_Sound(ActorVeh->m_pParentEntity, soundFlyBy);
}
}
// FLY PAST BEHAVIOR
//===================
if (EnemySlideBreak || !TIMER_Done(NPC, "MinHoldDirectionTime"))
{
if (TIMER_Done(NPC, "MinHoldDirectionTime"))
{
TIMER_Set(NPC, "MinHoldDirectionTime", 500); // Hold For At Least 500 ms
}
ActorAccelerate = true; // Go
ActorAimAtTarget = false; // Don't Alter Our Aim Direction
ucmd.buttons &=~BUTTON_VEH_SPEED; // Let Normal Vehicle Controls Go
}
// FLANKING BEHAVIOR
//===================
else if (ActorFlank)
{
ActorAccelerate = true;
ActorDoTurbo = (MoveDistance>2500 || EnemyInTurbo);
ucmd.buttons |= BUTTON_VEH_SPEED; // Tells PMove to use the ps.speed we calculate here, not the one from g_vehicles.c
// For Flanking, We Calculate The Speed By Hand, Rather Than Using Pure Accelerate / No Accelerate Functionality
//---------------------------------------------------------------------------------------------------------------
NPC->client->ps.speed = ActorVeh->m_pVehicleInfo->speedMax * ((ActorInTurbo)?(1.35f):(1.15f));
// If In Slowing Distance, Scale Down The Speed As We Approach Our Move Target
//-----------------------------------------------------------------------------
if (MoveDistance<ATTACK_FLANK_SLOWING)
{
NPC->client->ps.speed *= (MoveDistance/ATTACK_FLANK_SLOWING);
NPC->client->ps.speed += EnemySpeed;
// Match Enemy Speed
//-------------------
if (NPC->client->ps.speed<5.0f && EnemySpeed<5.0f)
{
NPC->client->ps.speed = EnemySpeed;
}
// Extra Slow Down When Out In Front
//-----------------------------------
if (MoveAccuracy<0.0f)
{
NPC->client->ps.speed *= (MoveAccuracy + 1.0f);
}
MoveDirection *= (MoveDistance/ATTACK_FLANK_SLOWING);
EnemyDirection *= 1.0f - (MoveDistance/ATTACK_FLANK_SLOWING);
MoveDirection += EnemyDirection;
if (TIMER_Done(NPC, "RamCheck"))
{
TIMER_Set(NPC, "RamCheck", Q_irand(1000, 3000));
if (MoveDistance<RAM_DIST && Q_irand(0, 2)==0)
{
VEH_StartStrafeRam(ActorVeh, (EnemySide==Side_Left));
}
}
}
}
// NORMAL CHASE BEHAVIOR
//=======================
else
{
if (!EnemyVeh && AimAccuracy>0.99f && MoveDistance<500 && !EnemyDead)
{
ActorAccelerate = true;
ActorDoTurbo = false;
}
else
{
ActorAccelerate = ((MoveDistance>500 && EnemySpeed>20.0f) || MoveDistance>1000);
ActorDoTurbo = (MoveDistance>3000 && EnemySpeed>20.0f);
}
ucmd.buttons &=~BUTTON_VEH_SPEED;
}
// APPLY RESULTS
//=======================
// Decide Turbo
//--------------
if (ActorDoTurbo || ActorInTurbo)
{
ucmd.buttons |= BUTTON_ALT_ATTACK;
}
else
{
ucmd.buttons &=~BUTTON_ALT_ATTACK;
}
// Decide Acceleration
//---------------------
ucmd.forwardmove = (ActorAccelerate)?(127):(0);
// Decide To Shoot
//-----------------
ucmd.buttons &=~BUTTON_ATTACK;
ucmd.rightmove = 0;
if (AimDistance<2000 && !EnemyDead)
{
// If Doing A Ram Attack
//-----------------------
if (ActorYawOffset!=0)
{
if (NPC->client->ps.weapon!=WP_NONE)
{
NPC_ChangeWeapon(WP_NONE);
}
ucmd.buttons &=~BUTTON_ATTACK;
}
else if (AimAccuracy>ATTACK_FWD)
{
if (NPC->client->ps.weapon!=WP_NONE)
{
NPC_ChangeWeapon(WP_NONE);
}
ucmd.buttons |= BUTTON_ATTACK;
}
else if (AimAccuracy<AIM_SIDE && AimAccuracy>-AIM_SIDE)
{
if (NPC->client->ps.weapon!=WP_BLASTER)
{
NPC_ChangeWeapon(WP_BLASTER);
}
if (AimAccuracy<ATTACK_SIDE && AimAccuracy>-ATTACK_SIDE)
{
//if (!TIMER_Done(NPC, "RiderAltAttack"))
//{
// ucmd.buttons |= BUTTON_ALT_ATTACK;
//}
//else
//{
ucmd.buttons |= BUTTON_ATTACK;
/* if (TIMER_Done(NPC, "RiderAltAttackCheck"))
{
TIMER_Set(NPC, "RiderAltAttackCheck", Q_irand(1000, 3000));
if (Q_irand(0, 2)==0)
{
TIMER_Set(NPC, "RiderAltAttack", 300);
}
}*/
//}
WeaponThink(true);
}
ucmd.rightmove = (EnemySide==Side_Left)?( 127):(-127);
}
else
{
if (NPC->client->ps.weapon!=WP_NONE)
{
NPC_ChangeWeapon(WP_NONE);
}
}
}
else
{
if (NPC->client->ps.weapon!=WP_NONE)
{
NPC_ChangeWeapon(WP_NONE);
}
}
// Aim At Target
//---------------
if (ActorAimAtTarget)
{
MoveDirection.VecToAng();
NPCInfo->desiredPitch = AngleNormalize360(MoveDirection[PITCH]);
NPCInfo->desiredYaw = AngleNormalize360(MoveDirection[YAW] + ActorYawOffset);
}
NPC_UpdateAngles(qtrue, qtrue);
}
void NPC_BSPointShoot (qboolean shoot)
{//FIXME: doesn't check for clear shot...
vec3_t muzzle, dir, angles, org;
if ( !NPC->enemy || !NPC->enemy->inuse || (NPC->enemy->NPC && NPC->enemy->health <= 0) )
{//FIXME: should still keep shooting for a second or two after they actually die...
trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
goto finished;
return;
}
CalcEntitySpot(NPC, SPOT_WEAPON, muzzle);
CalcEntitySpot(NPC->enemy, SPOT_HEAD, org);//Was spot_org
//Head is a little high, so let's aim for the chest:
if ( NPC->enemy->client )
{
org[2] -= 12;//NOTE: is this enough?
}
VectorSubtract(org, muzzle, dir);
vectoangles(dir, angles);
switch( NPC->client->ps.weapon )
{
case WP_NONE:
// case WP_TRICORDER:
case WP_STUN_BATON:
case WP_SABER:
//don't do any pitch change if not holding a firing weapon
break;
default:
NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]);
break;
}
NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]);
if ( NPC_UpdateAngles ( qtrue, qtrue ) )
{//FIXME: if angles clamped, this may never work!
//NPCInfo->shotTime = NPC->attackDebounceTime = 0;
if ( shoot )
{//FIXME: needs to hold this down if using a weapon that requires it, like phaser...
ucmd.buttons |= BUTTON_ATTACK;
}
//if ( !shoot || !(NPC->svFlags & SVF_LOCKEDENEMY) )
if (1)
{//If locked_enemy is on, dont complete until it is destroyed...
trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
goto finished;
}
}
//else if ( shoot && (NPC->svFlags & SVF_LOCKEDENEMY) )
if (0)
{//shooting them till their dead, not aiming right at them yet...
/*
qboolean movingTarget = qfalse;
if ( NPC->enemy->client )
{
if ( VectorLengthSquared( NPC->enemy->client->ps.velocity ) )
{
movingTarget = qtrue;
}
}
else if ( VectorLengthSquared( NPC->enemy->s.pos.trDelta ) )
{
movingTarget = qtrue;
}
if (movingTarget )
*/
{
float dist = VectorLength( dir );
float yawMiss, yawMissAllow = NPC->enemy->r.maxs[0];
float pitchMiss, pitchMissAllow = (NPC->enemy->r.maxs[2] - NPC->enemy->r.mins[2])/2;
if ( yawMissAllow < 8.0f )
{
yawMissAllow = 8.0f;
}
if ( pitchMissAllow < 8.0f )
{
pitchMissAllow = 8.0f;
}
yawMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw ))) * dist;
pitchMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[PITCH], NPCInfo->desiredPitch))) * dist;
if ( yawMissAllow >= yawMiss && pitchMissAllow > pitchMiss )
{
ucmd.buttons |= BUTTON_ATTACK;
}
}
}
return;
finished:
NPCInfo->desiredYaw = client->ps.viewangles[YAW];
NPCInfo->desiredPitch = client->ps.viewangles[PITCH];
NPCInfo->aimTime = 0;//ok to turn normally now
}
//----------------------------------
//replaced with SP version.
static void Howler_Combat( void )
{
qboolean faced = qfalse;
float distance;
qboolean advance = qfalse;
if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
{//not on the ground
if ( NPC->client->ps.legsAnim == BOTH_JUMP1
|| NPC->client->ps.legsAnim == BOTH_INAIR1 )
{//flying through the air with the greatest of ease, etc
Howler_TryDamage( 10, qfalse, qfalse );
}
}
else
{//not in air, see if we should attack or advance
// If we cannot see our target or we have somewhere to go, then do that
if ( !NPC_ClearLOS4( NPC->enemy ) )//|| UpdateGoal( ))
{
NPCInfo->goalEntity = NPC->enemy;
NPCInfo->goalRadius = MAX_DISTANCE; // just get us within combat range
if ( NPCInfo->localState == LSTATE_BERZERK )
{
NPC_Howler_Move( 3 );
}
else
{
NPC_Howler_Move( 10 );
}
NPC_UpdateAngles( qfalse, qtrue );
return;
}
distance = DistanceHorizontal( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
if ( NPC->enemy && NPC->enemy->client && PM_InKnockDown( &NPC->enemy->client->ps ) )
{//get really close to knocked down enemies
advance = (qboolean)( distance > MIN_DISTANCE ? qtrue : qfalse );
}
else
{
advance = (qboolean)( distance > MAX_DISTANCE ? qtrue : qfalse );//MIN_DISTANCE
}
if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
{
if ( TIMER_Done2( NPC, "takingPain", qtrue ))
{
NPCInfo->localState = LSTATE_CLEAR;
}
else if ( TIMER_Done( NPC, "standing" ) )
{
faced = Howler_Move( qtrue );
}
}
else
{
Howler_Attack( distance, qfalse );
}
}
if ( !faced )
{
if ( //TIMER_Done( NPC, "standing" ) //not just standing there
//!advance //not moving
TIMER_Done( NPC, "attacking" ) )// not attacking
{//not standing around
// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
NPC_FaceEnemy( qtrue );
}
else
{
NPC_UpdateAngles( qfalse, qtrue );
}
}
}
void NPC_BSDefault( void )
{
// vec3_t enemyDir;
// float enemyDist;
// float shootDist;
// qboolean enemyFOV = qfalse;
// qboolean enemyShotFOV = qfalse;
// qboolean enemyPVS = qfalse;
// vec3_t enemyHead;
// vec3_t muzzle;
// qboolean enemyLOS = qfalse;
// qboolean enemyCS = qfalse;
qboolean move = qtrue;
// qboolean shoot = qfalse;
if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
{
WeaponThink( qtrue );
}
if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
{//being forced to walk
if( NPC->client->ps.torsoAnim != TORSO_SURRENDER_START )
{
NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_SURRENDER_START, SETANIM_FLAG_HOLD );
}
}
//look for a new enemy if don't have one and are allowed to look, validate current enemy if have one
NPC_CheckEnemy( (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES), qfalse, qtrue );
if ( !NPC->enemy )
{//still don't have an enemy
if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
{//check for alert events
//FIXME: Check Alert events, see if we should investigate or just look at it
int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qtrue, AEL_DISCOVERED );
//There is an event to look at
if ( alertEvent >= 0 && level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
{//heard/saw something
if ( level.alertEvents[alertEvent].level >= AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
{//was a big event
if ( level.alertEvents[alertEvent].owner && level.alertEvents[alertEvent].owner->client && level.alertEvents[alertEvent].owner->health >= 0 && level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
{//an enemy
G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
}
}
else
{//FIXME: investigate lesser events
}
}
//FIXME: also check our allies' condition?
}
}
if ( NPC->enemy && !(NPCInfo->scriptFlags&SCF_FORCED_MARCH) )
{
// just use the stormtrooper attack AI...
NPC_CheckGetNewWeapon();
if ( NPC->client->leader
&& NPCInfo->goalEntity == NPC->client->leader
&& !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
{
NPC_ClearGoal();
}
NPC_BSST_Attack();
return;
/*
//have an enemy
//FIXME: if one of these fails, meaning we can't shoot, do we really need to do the rest?
VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, enemyDir );
enemyDist = VectorNormalize( enemyDir );
enemyDist *= enemyDist;
shootDist = NPC_MaxDistSquaredForWeapon();
enemyFOV = InFOV( NPC->enemy, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov );
enemyShotFOV = InFOV( NPC->enemy, NPC, 20, 20 );
enemyPVS = gi.inPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin );
if ( enemyPVS )
{//in the pvs
trace_t tr;
CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemyHead );
enemyHead[2] -= Q_flrand( 0.0f, NPC->enemy->maxs[2]*0.5f );
CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
enemyLOS = NPC_ClearLOS( muzzle, enemyHead );
gi.trace ( &tr, muzzle, vec3_origin, vec3_origin, enemyHead, NPC->s.number, MASK_SHOT );
enemyCS = NPC_EvaluateShot( tr.entityNum, qtrue );
}
else
{//skip thr 2 traces since they would have to fail
enemyLOS = qfalse;
enemyCS = qfalse;
}
if ( enemyCS && enemyShotFOV )
{//can hit enemy if we want
NPC->cantHitEnemyCounter = 0;
}
else
{//can't hit
NPC->cantHitEnemyCounter++;
}
if ( enemyCS && enemyShotFOV && enemyDist < shootDist )
{//can shoot
shoot = qtrue;
if ( NPCInfo->goalEntity == NPC->enemy )
{//my goal is my enemy and I have a clear shot, no need to chase right now
move = qfalse;
}
}
else
{//don't shoot yet, keep chasing
shoot = qfalse;
move = qtrue;
}
//shoot decision
if ( !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
{//try to shoot
if ( NPC->enemy )
{
if ( shoot )
{
if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
{
WeaponThink( qtrue );
}
}
}
}
//chase decision
if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
{//go after him
NPCInfo->goalEntity = NPC->enemy;
//FIXME: don't need to chase when have a clear shot and in range?
if ( !enemyCS && NPC->cantHitEnemyCounter > 60 )
{//haven't been able to shoot enemy for about 6 seconds, need to do something
//FIXME: combat points? Just chase?
if ( enemyPVS )
{//in my PVS, just pick a combat point
//FIXME: implement
}
else
{//just chase him
}
}
//FIXME: in normal behavior, should we use combat Points? Do we care? Is anyone actually going to ever use this AI?
}
else if ( NPC->cantHitEnemyCounter > 60 )
{//pick a new one
NPC_CheckEnemy( qtrue, qfalse, qtrue );
}
if ( enemyPVS && enemyLOS )//&& !enemyShotFOV )
{//have a clear LOS to him//, but not looking at him
//Find the desired angles
vec3_t angles;
GetAnglesForDirection( muzzle, enemyHead, angles );
NPCInfo->desiredYaw = AngleNormalize180( angles[YAW] );
NPCInfo->desiredPitch = AngleNormalize180( angles[PITCH] );
}
*/
}
if ( UpdateGoal() )
{//have a goal
if ( !NPC->enemy
&& NPC->client->leader
&& NPCInfo->goalEntity == NPC->client->leader
&& !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
{
NPC_BSFollowLeader();
}
else
{
//set angles
if ( (NPCInfo->scriptFlags & SCF_FACE_MOVE_DIR) || NPCInfo->goalEntity != NPC->enemy )
{//face direction of movement, NOTE: default behavior when not chasing enemy
NPCInfo->combatMove = qfalse;
}
else
{//face goal.. FIXME: what if have a navgoal but want to face enemy while moving? Will this do that?
vec3_t dir, angles;
NPCInfo->combatMove = qfalse;
VectorSubtract( NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir );
vectoangles( dir, angles );
NPCInfo->desiredYaw = angles[YAW];
if ( NPCInfo->goalEntity == NPC->enemy )
{
NPCInfo->desiredPitch = angles[PITCH];
}
}
//set movement
//override default walk/run behavior
//NOTE: redundant, done in NPC_ApplyScriptFlags
if ( NPCInfo->scriptFlags & SCF_RUNNING )
{
ucmd.buttons &= ~BUTTON_WALKING;
}
else if ( NPCInfo->scriptFlags & SCF_WALKING )
{
ucmd.buttons |= BUTTON_WALKING;
}
else if ( NPCInfo->goalEntity == NPC->enemy )
{
ucmd.buttons &= ~BUTTON_WALKING;
}
else
{
ucmd.buttons |= BUTTON_WALKING;
}
if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
{//being forced to walk
//if ( g_crosshairEntNum != NPC->s.number )
if (!NPC_SomeoneLookingAtMe(NPC))
{//don't walk if player isn't aiming at me
move = qfalse;
}
}
if ( move )
{
//move toward goal
NPC_MoveToGoal( qtrue );
}
}
}
else if ( !NPC->enemy && NPC->client->leader )
{
NPC_BSFollowLeader();
}
//update angles
NPC_UpdateAngles( qtrue, qtrue );
}
//replaced with SP version.
void NPC_BSHowler_Default( void )
{
if ( NPC->client->ps.legsAnim != BOTH_GESTURE1 )
{
NPC->count = 0;
}
//FIXME: if in jump, do damage in front and maybe knock them down?
if ( !TIMER_Done( NPC, "attacking" ) )
{
if ( NPC->enemy )
{
//NPC_FaceEnemy( qfalse );
Howler_Attack( Distance( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ), qfalse );
}
else
{
//NPC_UpdateAngles( qfalse, qtrue );
Howler_Attack( 0.0f, qfalse );
}
NPC_UpdateAngles( qfalse, qtrue );
return;
}
if ( NPC->enemy )
{
if ( NPCInfo->stats.aggression > 0 )
{
if ( TIMER_Done( NPC, "aggressionDecay" ) )
{
NPCInfo->stats.aggression--;
TIMER_Set( NPC, "aggressionDecay", 500 );
}
}
//RAFIXME - No fleeing, need to fix this at some point.
/*
if ( !TIMER_Done( NPC, "flee" )
&& NPC_BSFlee() ) //this can clear ENEMY
{//successfully trying to run away
return;
}
*/
if ( NPC->enemy == NULL)
{
NPC_UpdateAngles( qfalse, qtrue );
return;
}
if ( NPCInfo->localState == LSTATE_FLEE )
{//we were fleeing, now done (either timer ran out or we cannot flee anymore
if ( NPC_ClearLOS4( NPC->enemy ) )
{//if enemy is still around, go berzerk
NPCInfo->localState = LSTATE_BERZERK;
}
else
{//otherwise, lick our wounds?
NPCInfo->localState = LSTATE_CLEAR;
TIMER_Set( NPC, "standing", Q_irand( 3000, 10000 ) );
}
}
else if ( NPCInfo->localState == LSTATE_BERZERK )
{//go nuts!
}
else if ( NPCInfo->stats.aggression >= Q_irand( 75, 125 ) )
{//that's it, go nuts!
NPCInfo->localState = LSTATE_BERZERK;
}
else if ( !TIMER_Done( NPC, "retreating" ) )
{//trying to back off
NPC_FaceEnemy( qtrue );
if ( NPC->client->ps.speed > NPCInfo->stats.walkSpeed )
{
NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
}
ucmd.buttons |= BUTTON_WALKING;
if ( Distance( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) < HOWLER_RETREAT_DIST )
{//enemy is close
vec3_t moveDir;
AngleVectors( NPC->r.currentAngles, moveDir, NULL, NULL );
VectorScale( moveDir, -1, moveDir );
if ( !NAV_DirSafe( NPC, moveDir, 8 ) )
{//enemy is backing me up against a wall or ledge! Start to get really mad!
NPCInfo->stats.aggression += 2;
}
else
{//back off
ucmd.forwardmove = -127;
}
//enemy won't leave me alone, get mad...
NPCInfo->stats.aggression++;
}
return;
}
else if ( TIMER_Done( NPC, "standing" ) )
{//not standing around
if ( !(NPCInfo->last_ucmd.forwardmove)
&& !(NPCInfo->last_ucmd.rightmove) )
{//stood last frame
if ( TIMER_Done( NPC, "walking" )
&& TIMER_Done( NPC, "running" ) )
{//not walking or running
if ( Q_irand( 0, 2 ) )
{//run for a while
TIMER_Set( NPC, "walking", Q_irand( 4000, 8000 ) );
}
else
{//walk for a bit
TIMER_Set( NPC, "running", Q_irand( 2500, 5000 ) );
}
}
}
else if ( (NPCInfo->last_ucmd.buttons&BUTTON_WALKING) )
{//walked last frame
if ( TIMER_Done( NPC, "walking" ) )
{//just finished walking
if ( Q_irand( 0, 5 ) || DistanceSquared( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) < MAX_DISTANCE_SQR )
{//run for a while
TIMER_Set( NPC, "running", Q_irand( 4000, 20000 ) );
}
else
{//stand for a bit
TIMER_Set( NPC, "standing", Q_irand( 2000, 6000 ) );
}
}
}
else
{//ran last frame
if ( TIMER_Done( NPC, "running" ) )
{//just finished running
if ( Q_irand( 0, 8 ) || DistanceSquared( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) < MAX_DISTANCE_SQR )
{//walk for a while
TIMER_Set( NPC, "walking", Q_irand( 3000, 10000 ) );
}
else
{//stand for a bit
TIMER_Set( NPC, "standing", Q_irand( 2000, 6000 ) );
}
}
}
}
if ( NPC_ValidEnemy( NPC->enemy ) == qfalse )
{
TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
if ( !NPC->enemy->inuse || level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) )
{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
NPC->enemy = NULL;
Howler_Patrol();
NPC_UpdateAngles( qtrue, qtrue );
return;
}
}
if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
{
gentity_t *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
gentity_t *newEnemy;
NPC->enemy = NULL;
newEnemy = NPC_CheckEnemy( (qboolean)(NPCInfo->confusionTime < level.time), qfalse, qfalse );
NPC->enemy = sav_enemy;
if ( newEnemy && newEnemy != sav_enemy )
{//picked up a new enemy!
NPC->lastEnemy = NPC->enemy;
G_SetEnemy( NPC, newEnemy );
if ( NPC->enemy != NPC->lastEnemy )
{//clear this so that we only sniff the player the first time we pick them up
//RACC - this doesn't appear to get used for Howlers
//NPC->useDebounceTime = 0;
}
//hold this one for at least 5-15 seconds
TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
}
else
{//look again in 2-5 secs
TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
}
}
Howler_Combat();
if ( TIMER_Done( NPC, "speaking" ) )
{
if ( !TIMER_Done( NPC, "standing" )
|| !TIMER_Done( NPC, "retreating" ))
{
G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/idle_hiss%d.mp3", Q_irand( 1, 2 ) ) );
}
else if ( !TIMER_Done( NPC, "walking" )
|| NPCInfo->localState == LSTATE_FLEE )
{
G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/howl_talk%d.mp3", Q_irand( 1, 5 ) ) );
}
else
{
G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/howl_yell%d.mp3", Q_irand( 1, 5 ) ) );
}
if ( NPCInfo->localState == LSTATE_BERZERK
|| NPCInfo->localState == LSTATE_FLEE )
{
TIMER_Set( NPC, "speaking", Q_irand( 1000, 4000 ) );
}
else
{
TIMER_Set( NPC, "speaking", Q_irand( 3000, 8000 ) );
}
}
return;
}
else
{
if ( TIMER_Done( NPC, "speaking" ) )
{
if ( !Q_irand( 0, 3 ) )
{
G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/idle_hiss%d.mp3", Q_irand( 1, 2 ) ) );
}
else
{
G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/howl_talk%d.mp3", Q_irand( 1, 5 ) ) );
}
TIMER_Set( NPC, "speaking", Q_irand( 4000, 12000 ) );
}
if ( NPCInfo->stats.aggression > 0 )
{
if ( TIMER_Done( NPC, "aggressionDecay" ) )
{
NPCInfo->stats.aggression--;
TIMER_Set( NPC, "aggressionDecay", 200 );
}
}
if ( TIMER_Done( NPC, "standing" ) )
{//not standing around
if ( !(NPCInfo->last_ucmd.forwardmove)
&& !(NPCInfo->last_ucmd.rightmove) )
{//stood last frame
if ( TIMER_Done( NPC, "walking" )
&& TIMER_Done( NPC, "running" ) )
{//not walking or running
if ( NPCInfo->goalEntity )
{//have somewhere to go
if ( Q_irand( 0, 2 ) )
{//walk for a while
TIMER_Set( NPC, "walking", Q_irand( 3000, 10000 ) );
}
else
{//run for a bit
TIMER_Set( NPC, "running", Q_irand( 2500, 5000 ) );
}
}
}
}
else if ( (NPCInfo->last_ucmd.buttons&BUTTON_WALKING) )
{//walked last frame
if ( TIMER_Done( NPC, "walking" ) )
{//just finished walking
if ( Q_irand( 0, 3 ) )
{//run for a while
TIMER_Set( NPC, "running", Q_irand( 3000, 6000 ) );
}
else
{//stand for a bit
TIMER_Set( NPC, "standing", Q_irand( 2500, 5000 ) );
}
}
}
else
{//ran last frame
if ( TIMER_Done( NPC, "running" ) )
{//just finished running
if ( Q_irand( 0, 2 ) )
{//walk for a while
TIMER_Set( NPC, "walking", Q_irand( 6000, 15000 ) );
}
else
{//stand for a bit
TIMER_Set( NPC, "standing", Q_irand( 4000, 6000 ) );
}
}
}
}
if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
{
Howler_Patrol();
}
else
{
Howler_Idle();
}
}
NPC_UpdateAngles( qfalse, qtrue );
}
void Sniper_FaceEnemy( void )
{
//FIXME: the ones behind kill holes are facing some arbitrary direction and not firing
//FIXME: If actually trying to hit enemy, don't fire unless enemy is at least in front of me?
//FIXME: need to give designers option to make them not miss first few shots
if ( NPC->enemy )
{
vec3_t muzzle, target, angles, forward, right, up;
//Get the positions
AngleVectors( NPC->client->ps.viewangles, forward, right, up );
CalcMuzzlePoint( NPC, forward, right, up, muzzle, 0 );
//CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
CalcEntitySpot( NPC->enemy, SPOT_ORIGIN, target );
if ( enemyDist > 65536 && NPCInfo->stats.aim < 5 )//is 256 squared, was 16384 (128*128)
{
if ( NPC->count < (5-NPCInfo->stats.aim) )
{//miss a few times first
if ( shoot && TIMER_Done( NPC, "attackDelay" ) && level.time >= NPCInfo->shotTime )
{//ready to fire again
qboolean aimError = qfalse;
qboolean hit = qtrue;
int tryMissCount = 0;
trace_t trace;
GetAnglesForDirection( muzzle, target, angles );
AngleVectors( angles, forward, right, up );
while ( hit && tryMissCount < 10 )
{
tryMissCount++;
if ( !Q_irand( 0, 1 ) )
{
aimError = qtrue;
if ( !Q_irand( 0, 1 ) )
{
VectorMA( target, NPC->enemy->maxs[2]*Q_flrand(1.5, 4), right, target );
}
else
{
VectorMA( target, NPC->enemy->mins[2]*Q_flrand(1.5, 4), right, target );
}
}
if ( !aimError || !Q_irand( 0, 1 ) )
{
if ( !Q_irand( 0, 1 ) )
{
VectorMA( target, NPC->enemy->maxs[2]*Q_flrand(1.5, 4), up, target );
}
else
{
VectorMA( target, NPC->enemy->mins[2]*Q_flrand(1.5, 4), up, target );
}
}
gi.trace( &trace, muzzle, vec3_origin, vec3_origin, target, NPC->s.number, MASK_SHOT, (EG2_Collision)0, 0 );
hit = Sniper_EvaluateShot( trace.entityNum );
}
NPC->count++;
}
else
{
if ( !enemyLOS )
{
NPC_UpdateAngles( qtrue, qtrue );
return;
}
}
}
else
{//based on distance, aim value, difficulty and enemy movement, miss
//FIXME: incorporate distance as a factor?
int missFactor = 8-(NPCInfo->stats.aim+g_spskill->integer) * 3;
if ( missFactor > ENEMY_POS_LAG_STEPS )
{
missFactor = ENEMY_POS_LAG_STEPS;
}
else if ( missFactor < 0 )
{//???
missFactor = 0 ;
}
VectorCopy( NPCInfo->enemyLaggedPos[missFactor], target );
}
GetAnglesForDirection( muzzle, target, angles );
}
else
{
target[2] += Q_flrand( 0, NPC->enemy->maxs[2] );
//CalcEntitySpot( NPC->enemy, SPOT_HEAD_LEAN, target );
GetAnglesForDirection( muzzle, target, angles );
}
NPCInfo->desiredYaw = AngleNormalize360( angles[YAW] );
NPCInfo->desiredPitch = AngleNormalize360( angles[PITCH] );
}
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_RunBehavior( int team, int bState )
{
qboolean dontSetAim = qfalse;
if (NPC->s.NPC_class == CLASS_VEHICLE &&
NPC->m_pVehicle)
{ //vehicles don't do AI!
return;
}
if ( bState == BS_CINEMATIC )
{
NPC_BSCinematic();
}
else if ( NPC->client->ps.weapon == WP_EMPLACED_GUN )
{
NPC_BSEmplaced();
NPC_CheckCharmed();
return;
}
else if ( NPC->client->ps.weapon == WP_SABER )
{//jedi
NPC_BehaviorSet_Jedi( bState );
dontSetAim = qtrue;
}
else if ( NPC->client->NPC_class == CLASS_WAMPA )
{//wampa
NPC_BSWampa_Default();
}
else if ( NPC->client->NPC_class == CLASS_RANCOR )
{//rancor
NPC_BehaviorSet_Rancor( bState );
}
else if ( NPC->client->NPC_class == CLASS_REMOTE )
{
NPC_BehaviorSet_Remote( bState );
}
else if ( NPC->client->NPC_class == CLASS_SEEKER )
{
NPC_BehaviorSet_Seeker( bState );
}
else if ( NPC->client->NPC_class == CLASS_BOBAFETT )
{//bounty hunter
if ( Boba_Flying( NPC ) )
{
NPC_BehaviorSet_Seeker(bState);
}
else
{
NPC_BehaviorSet_Jedi( bState );
}
dontSetAim = qtrue;
}
else if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
{//being forced to march
NPC_BSDefault();
}
else
{
switch( team )
{
// case NPCTEAM_SCAVENGERS:
// case NPCTEAM_IMPERIAL:
// case NPCTEAM_KLINGON:
// case NPCTEAM_HIROGEN:
// case NPCTEAM_MALON:
// not sure if TEAM_ENEMY is appropriate here, I think I should be using NPC_class to check for behavior - dmv
case NPCTEAM_ENEMY:
// special cases for enemy droids
switch( NPC->client->NPC_class)
{
case CLASS_ATST:
NPC_BehaviorSet_ATST( bState );
return;
case CLASS_PROBE:
NPC_BehaviorSet_ImperialProbe(bState);
return;
case CLASS_REMOTE:
NPC_BehaviorSet_Remote( bState );
return;
case CLASS_SENTRY:
NPC_BehaviorSet_Sentry(bState);
return;
case CLASS_INTERROGATOR:
NPC_BehaviorSet_Interrogator( bState );
return;
case CLASS_MINEMONSTER:
NPC_BehaviorSet_MineMonster( bState );
return;
case CLASS_HOWLER:
NPC_BehaviorSet_Howler( bState );
return;
case CLASS_MARK1:
NPC_BehaviorSet_Mark1( bState );
return;
case CLASS_MARK2:
NPC_BehaviorSet_Mark2( bState );
return;
case CLASS_GALAKMECH:
NPC_BSGM_Default();
return;
default:
break;
}
if ( NPC->enemy && NPC->s.weapon == WP_NONE && bState != BS_HUNT_AND_KILL && !trap->ICARUS_TaskIDPending( (sharedEntity_t *)NPC, TID_MOVE_NAV ) )
{//if in battle and have no weapon, run away, fixme: when in BS_HUNT_AND_KILL, they just stand there
if ( bState != BS_FLEE )
{
NPC_StartFlee( NPC->enemy, &NPC->enemy->r.currentOrigin, AEL_DANGER_GREAT, 5000, 10000 );
}
else
{
NPC_BSFlee();
}
return;
}
if ( NPC->client->ps.weapon == WP_SABER )
{//special melee exception
NPC_BehaviorSet_Default( bState );
return;
}
if ( NPC->client->ps.weapon == WP_DISRUPTOR && (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
{//a sniper
NPC_BehaviorSet_Sniper( bState );
return;
}
if ( NPC->client->ps.weapon == WP_THERMAL || NPC->client->ps.weapon == WP_STUN_BATON )//FIXME: separate AI for melee fighters
{//a grenadier
NPC_BehaviorSet_Grenadier( bState );
return;
}
if ( NPC_CheckSurrender() )
{
return;
}
NPC_BehaviorSet_Stormtrooper( bState );
break;
case NPCTEAM_NEUTRAL:
// special cases for enemy droids
if ( NPC->client->NPC_class == CLASS_PROTOCOL || NPC->client->NPC_class == CLASS_UGNAUGHT ||
NPC->client->NPC_class == CLASS_JAWA)
{
NPC_BehaviorSet_Default(bState);
}
else if ( NPC->client->NPC_class == CLASS_VEHICLE )
{
// TODO: Add vehicle behaviors here.
NPC_UpdateAngles( qtrue, qtrue );//just face our spawn angles for now
}
else
{
// Just one of the average droids
NPC_BehaviorSet_Droid( bState );
}
break;
default:
if ( NPC->client->NPC_class == CLASS_SEEKER )
{
NPC_BehaviorSet_Seeker(bState);
}
else
{
if ( NPCInfo->charmedTime > level.time )
{
NPC_BehaviorSet_Charmed( bState );
}
else
{
NPC_BehaviorSet_Default( bState );
}
NPC_CheckCharmed();
dontSetAim = qtrue;
}
break;
}
}
}
void NPC_BSSniper_Attack( void )
{
//Don't do anything if we're hurt
if ( NPC->painDebounceTime > level.time )
{
NPC_UpdateAngles( qtrue, qtrue );
return;
}
//NPC_CheckEnemy( qtrue, qfalse );
//If we don't have an enemy, just idle
if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//
{
NPC_BSSniper_Patrol();//FIXME: or patrol?
return;
}
if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
{//going to run
NPC_UpdateAngles( qtrue, qtrue );
return;
}
if ( !NPC->enemy )
{//WTF? somehow we lost our enemy?
NPC_BSSniper_Patrol();//FIXME: or patrol?
return;
}
enemyLOS = enemyCS = qfalse;
doMove = qtrue;
faceEnemy = qfalse;
shoot = qfalse;
enemyDist = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
if ( enemyDist < 16384 )//128 squared
{//too close, so switch to primary fire
if ( NPC->client->ps.weapon == WP_DISRUPTOR
|| NPC->client->ps.weapon == WP_TUSKEN_RIFLE )
{//sniping... should be assumed
if ( NPCInfo->scriptFlags & SCF_ALT_FIRE )
{//use primary fire
trace_t trace;
gi.trace ( &trace, NPC->enemy->currentOrigin, NPC->enemy->mins, NPC->enemy->maxs, NPC->currentOrigin, NPC->enemy->s.number, NPC->enemy->clipmask, (EG2_Collision)0, 0 );
if ( !trace.allsolid && !trace.startsolid && (trace.fraction == 1.0 || trace.entityNum == NPC->s.number ) )
{//he can get right to me
NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
//reset fire-timing variables
NPC_ChangeWeapon( NPC->client->ps.weapon );
NPC_UpdateAngles( qtrue, qtrue );
return;
}
}
//FIXME: switch back if he gets far away again?
}
}
else if ( enemyDist > 65536 )//256 squared
{
if ( NPC->client->ps.weapon == WP_DISRUPTOR
|| NPC->client->ps.weapon == WP_TUSKEN_RIFLE )
{//sniping... should be assumed
if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
{//use primary fire
NPCInfo->scriptFlags |= SCF_ALT_FIRE;
//reset fire-timing variables
NPC_ChangeWeapon( NPC->client->ps.weapon );
NPC_UpdateAngles( qtrue, qtrue );
return;
}
}
}
Sniper_UpdateEnemyPos();
//can we see our target?
if ( NPC_ClearLOS( NPC->enemy ) )//|| (NPCInfo->stats.aim >= 5 && gi.inPVS( NPC->client->renderInfo.eyePoint, NPC->enemy->currentOrigin )) )
{
NPCInfo->enemyLastSeenTime = level.time;
VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
enemyLOS = qtrue;
float maxShootDist = NPC_MaxDistSquaredForWeapon();
if ( enemyDist < maxShootDist )
{
vec3_t fwd, right, up, muzzle, end;
trace_t tr;
AngleVectors( NPC->client->ps.viewangles, fwd, right, up );
CalcMuzzlePoint( NPC, fwd, right, up, muzzle, 0 );
VectorMA( muzzle, 8192, fwd, end );
gi.trace ( &tr, muzzle, NULL, NULL, end, NPC->s.number, MASK_SHOT, G2_RETURNONHIT, 0 );
int hit = tr.entityNum;
//can we shoot our target?
if ( Sniper_EvaluateShot( hit ) )
{
enemyCS = qtrue;
}
}
}
/*
else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
{
NPCInfo->enemyLastSeenTime = level.time;
faceEnemy = qtrue;
}
*/
if ( enemyLOS )
{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
faceEnemy = qtrue;
}
if ( !TIMER_Done( NPC, "taunting" ) )
{
doMove = qfalse;
shoot = qfalse;
}
else if ( enemyCS )
{
shoot = qtrue;
}
else if ( level.time - NPCInfo->enemyLastSeenTime > 3000 )
{//Hmm, have to get around this bastard... FIXME: this NPCInfo->enemyLastSeenTime builds up when ducked seems to make them want to run when they uncrouch
Sniper_ResolveBlockedShot();
}
else if ( NPC->client->ps.weapon == WP_TUSKEN_RIFLE && !Q_irand( 0, 100 ) )
{//start a taunt
NPC_Tusken_Taunt();
TIMER_Set( NPC, "duck", -1 );
doMove = qfalse;
}
//Check for movement to take care of
Sniper_CheckMoveState();
//See if we should override shooting decision with any special considerations
Sniper_CheckFireState();
if ( doMove )
{//doMove toward goal
if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist > 10000 ) )//100 squared
{
doMove = Sniper_Move();
}
else
{
doMove = qfalse;
}
}
if ( !doMove )
{
if ( !TIMER_Done( NPC, "duck" ) )
{
if ( TIMER_Done( NPC, "watch" ) )
{//not while watching
ucmd.upmove = -127;
if ( NPC->client->NPC_class == CLASS_SABOTEUR )
{
Saboteur_Cloak( NPC );
}
}
}
//FIXME: what about leaning?
//FIXME: also, when stop ducking, start looking, if enemy can see me, chance of ducking back down again
}
else
{//stop ducking!
TIMER_Set( NPC, "duck", -1 );
if ( NPC->client->NPC_class == CLASS_SABOTEUR )
{
Saboteur_Decloak( NPC );
}
}
if ( TIMER_Done( NPC, "duck" )
&& TIMER_Done( NPC, "watch" )
&& (TIMER_Get( NPC, "attackDelay" )-level.time) > 1000
&& NPC->attackDebounceTime < level.time )
{
if ( enemyLOS && (NPCInfo->scriptFlags&SCF_ALT_FIRE) )
{
if ( NPC->fly_sound_debounce_time < level.time )
{
NPC->fly_sound_debounce_time = level.time + 2000;
}
}
}
if ( !faceEnemy )
{//we want to face in the dir we're running
if ( doMove )
{//don't run away and shoot
NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
NPCInfo->desiredPitch = 0;
shoot = qfalse;
}
NPC_UpdateAngles( qtrue, qtrue );
}
else// if ( faceEnemy )
{//face the enemy
Sniper_FaceEnemy();
}
if ( NPCInfo->scriptFlags&SCF_DONT_FIRE )
{
shoot = qfalse;
}
//FIXME: don't shoot right away!
if ( shoot )
{//try to shoot if it's time
if ( TIMER_Done( NPC, "attackDelay" ) )
{
WeaponThink( qtrue );
if ( ucmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK) )
{
G_SoundOnEnt( NPC, CHAN_WEAPON, "sound/null.wav" );
}
//took a shot, now hide
if ( !(NPC->spawnflags&SPF_NO_HIDE) && !Q_irand( 0, 1 ) )
{
//FIXME: do this if in combat point and combat point has duck-type cover... also handle lean-type cover
Sniper_StartHide();
}
else
{
TIMER_Set( NPC, "attackDelay", NPCInfo->shotTime-level.time );
}
}
}
}
void ImperialProbe_MaintainHeight( void )
{
float dif;
// vec3_t endPos;
// trace_t trace;
// Update our angles regardless
NPC_UpdateAngles( qtrue, qtrue );
// If we have an enemy, we should try to hover at about enemy eye level
if ( NPC->enemy )
{
// Find the height difference
dif = NPC->enemy->currentOrigin[2] - NPC->currentOrigin[2];
// cap to prevent dramatic height shifts
if ( fabs( dif ) > 8 )
{
if ( fabs( dif ) > 16 )
{
dif = ( dif < 0 ? -16 : 16 );
}
NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
}
}
else
{
gentity_t *goal = NULL;
if ( NPCInfo->goalEntity ) // Is there a goal?
{
goal = NPCInfo->goalEntity;
}
else
{
goal = NPCInfo->lastGoalEntity;
}
if ( goal )
{
dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
if ( fabs( dif ) > 24 )
{
ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
}
else
{
if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
{
NPC->client->ps.velocity[2] = 0;
}
}
}
}
// Apply friction
else if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
{
NPC->client->ps.velocity[2] = 0;
}
}
// Stay at a given height until we take on an enemy
/* VectorSet( endPos, NPC->currentOrigin[0], NPC->currentOrigin[1], NPC->currentOrigin[2] - 512 );
gi.trace( &trace, NPC->currentOrigin, NULL, NULL, endPos, NPC->s.number, MASK_SOLID );
if ( trace.fraction != 1.0f )
{
float length = ( trace.fraction * 512 );
if ( length < 80 )
{
ucmd.upmove = 32;
}
else if ( length > 120 )
{
ucmd.upmove = -32;
}
else
{
if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
{
NPC->client->ps.velocity[2] = 0;
}
}
}
} */
}
// Apply friction
if ( NPC->client->ps.velocity[0] )
{
NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
{
NPC->client->ps.velocity[0] = 0;
}
}
if ( NPC->client->ps.velocity[1] )
{
NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
{
NPC->client->ps.velocity[1] = 0;
}
}
}
/*
-------------------------
Remote_MaintainHeight
-------------------------
*/
void Remote_MaintainHeight( void )
{
float dif;
// Update our angles regardless
NPC_UpdateAngles( qtrue, qtrue );
if ( NPC->client->ps.velocity[2] )
{
NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
{
NPC->client->ps.velocity[2] = 0;
}
}
// If we have an enemy, we should try to hover at or a little below enemy eye level
if ( NPC->enemy )
{
if (TIMER_Done( NPC, "heightChange"))
{
TIMER_Set( NPC,"heightChange",Q_irand( 1000, 3000 ));
// Find the height difference
dif = (NPC->enemy->r.currentOrigin[2] + Q_irand( 0, NPC->enemy->r.maxs[2]+8 )) - NPC->r.currentOrigin[2];
// cap to prevent dramatic height shifts
if ( fabs( dif ) > 2 )
{
if ( fabs( dif ) > 24 )
{
dif = ( dif < 0 ? -24 : 24 );
}
dif *= 10;
NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
// NPC->fx_time = level.time;
G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/remote/misc/hiss.wav"));
}
}
}
else
{
gentity_t *goal = NULL;
if ( NPCInfo->goalEntity ) // Is there a goal?
{
goal = NPCInfo->goalEntity;
}
else
{
goal = NPCInfo->lastGoalEntity;
}
if ( goal )
{
dif = goal->r.currentOrigin[2] - NPC->r.currentOrigin[2];
if ( fabs( dif ) > 24 )
{
dif = ( dif < 0 ? -24 : 24 );
NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
}
}
}
// Apply friction
if ( NPC->client->ps.velocity[0] )
{
NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
{
NPC->client->ps.velocity[0] = 0;
}
}
if ( NPC->client->ps.velocity[1] )
{
NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
{
NPC->client->ps.velocity[1] = 0;
}
}
}
qboolean NPC_CheckSurrender( void )
{
if ( !g_AIsurrender->integer )
{//not enabled
return qfalse;
}
if ( !Q3_TaskIDPending( NPC, TID_MOVE_NAV )
&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE
&& !NPC->client->ps.weaponTime && !PM_InKnockDown( &NPC->client->ps )
&& NPC->enemy && NPC->enemy->client && NPC->enemy->enemy == NPC && NPC->enemy->s.weapon != WP_NONE && NPC->enemy->s.weapon != WP_MELEE
&& NPC->enemy->health > 20 && NPC->enemy->painDebounceTime < level.time - 3000 && NPC->enemy->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] < level.time - 1000 )
{//don't surrender if scripted to run somewhere or if we're in the air or if we're busy or if we don't have an enemy or if the enemy is not mad at me or is hurt or not a threat or busy being attacked
//FIXME: even if not in a group, don't surrender if there are other enemies in the PVS and within a certain range?
if ( NPC->s.weapon != WP_ROCKET_LAUNCHER
&& NPC->s.weapon != WP_REPEATER
&& NPC->s.weapon != WP_FLECHETTE
&& NPC->s.weapon != WP_SABER )
{//jedi and heavy weapons guys never surrender
//FIXME: rework all this logic into some orderly fashion!!!
if ( NPC->s.weapon != WP_NONE )
{//they have a weapon so they'd have to drop it to surrender
//don't give up unless low on health
if ( NPC->health > 25 || NPC->health >= NPC->max_health )
{
return qfalse;
}
if ( g_crosshairEntNum == NPC->s.number && NPC->painDebounceTime > level.time )
{//if he just shot me, always give up
//fall through
}
else
{//don't give up unless facing enemy and he's very close
if ( !InFOV( player, NPC, 60, 30 ) )
{//I'm not looking at them
return qfalse;
}
else if ( DistanceSquared( NPC->currentOrigin, player->currentOrigin ) < 65536/*256*256*/ )
{//they're not close
return qfalse;
}
else if ( !gi.inPVS( NPC->currentOrigin, player->currentOrigin ) )
{//they're not in the same room
return qfalse;
}
}
}
if ( NPCInfo->group && NPCInfo->group->numGroup <= 1 )
{//I'm alone but I was in a group//FIXME: surrender anyway if just melee or no weap?
if ( NPC->s.weapon == WP_NONE
//NPC has a weapon
|| NPC->enemy == player
|| (NPC->enemy->s.weapon == WP_SABER&&NPC->enemy->client&&NPC->enemy->client->ps.saberActive)
|| (NPC->enemy->NPC && NPC->enemy->NPC->group && NPC->enemy->NPC->group->numGroup > 2) )
{//surrender only if have no weapon or fighting a player or jedi or if we are outnumbered at least 3 to 1
if ( NPC->enemy == player )
{//player is the guy I'm running from
if ( g_crosshairEntNum == NPC->s.number )
{//give up if player is aiming at me
NPC_Surrender();
NPC_UpdateAngles( qtrue, qtrue );
return qtrue;
}
else if ( player->s.weapon == WP_SABER )
{//player is using saber
if ( InFOV( NPC, player, 60, 30 ) )
{//they're looking at me
if ( DistanceSquared( NPC->currentOrigin, player->currentOrigin ) < 16384/*128*128*/ )
{//they're close
if ( gi.inPVS( NPC->currentOrigin, player->currentOrigin ) )
{//they're in the same room
NPC_Surrender();
NPC_UpdateAngles( qtrue, qtrue );
return qtrue;
}
}
}
}
}
else if ( NPC->enemy )
{//???
//should NPC's surrender to others?
if ( InFOV( NPC, NPC->enemy, 30, 30 ) )
{//they're looking at me
if ( DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin ) < 4096 )
{//they're close
if ( gi.inPVS( NPC->currentOrigin, NPC->enemy->currentOrigin ) )
{//they're in the same room
//FIXME: should player-team NPCs not fire on surrendered NPCs?
NPC_Surrender();
NPC_UpdateAngles( qtrue, qtrue );
return qtrue;
}
}
}
}
}
}
}
}
return qfalse;
}
qboolean NPC_FacePosition( vec3_t position, qboolean doPitch )
{
vec3_t muzzle;
qboolean facing = qtrue;
//Get the positions
if ( NPC->client && (NPC->client->NPC_class == CLASS_RANCOR || NPC->client->NPC_class == CLASS_WAMPA || NPC->client->NPC_class == CLASS_SAND_CREATURE) )
{
CalcEntitySpot( NPC, SPOT_ORIGIN, muzzle );
muzzle[2] += NPC->maxs[2] * 0.75f;
}
else if ( NPC->client && NPC->client->NPC_class == CLASS_GALAKMECH )
{
CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
}
else
{
CalcEntitySpot( NPC, SPOT_HEAD_LEAN, muzzle );//SPOT_HEAD
if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER )
{//*sigh*, look down more
position[2] -= 32;
}
}
//Find the desired angles
vec3_t angles;
GetAnglesForDirection( muzzle, position, angles );
NPCInfo->desiredYaw = AngleNormalize360( angles[YAW] );
NPCInfo->desiredPitch = AngleNormalize360( angles[PITCH] );
if ( NPC->enemy && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_ATST )
{
// FIXME: this is kind of dumb, but it was the easiest way to get it to look sort of ok
NPCInfo->desiredYaw += Q_flrand( -5, 5 ) + sin( level.time * 0.004f ) * 7;
NPCInfo->desiredPitch += Q_flrand( -2, 2 );
}
//Face that yaw
NPC_UpdateAngles( qtrue, qtrue );
//Find the delta between our goal and our current facing
float yawDelta = AngleNormalize360( NPCInfo->desiredYaw - ( SHORT2ANGLE( ucmd.angles[YAW] + client->ps.delta_angles[YAW] ) ) );
//See if we are facing properly
if ( fabs( yawDelta ) > VALID_ATTACK_CONE )
facing = qfalse;
if ( doPitch )
{
//Find the delta between our goal and our current facing
float currentAngles = ( SHORT2ANGLE( ucmd.angles[PITCH] + client->ps.delta_angles[PITCH] ) );
float pitchDelta = NPCInfo->desiredPitch - currentAngles;
//See if we are facing properly
if ( fabs( pitchDelta ) > VALID_ATTACK_CONE )
facing = qfalse;
}
return facing;
}
