codemp/game/NPC_AI_Stormtrooper.c

Go to the documentation of this file.

#include "b_local.h"
#include "g_nav.h"
#include "anims.h"

extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
extern void AI_GroupUpdateSquadstates( AIGroupInfo_t *group, gentity_t *member, int newSquadState );
extern qboolean AI_GroupContainsEntNum( AIGroupInfo_t *group, int entNum );
extern void AI_GroupUpdateEnemyLastSeen( AIGroupInfo_t *group, vec3_t spot );
extern void AI_GroupUpdateClearShotTime( AIGroupInfo_t *group );
extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
extern void ChangeWeapon( gentity_t *ent, int newWeapon );
extern void NPC_CheckGetNewWeapon( void );
extern int GetTime ( int lastTime );
extern void NPC_AimAdjust( int change );
extern qboolean FlyingCreature( gentity_t *ent );

extern  vmCvar_t                d_asynchronousGroupAI;

#define MAX_VIEW_DIST           1024
#define MAX_VIEW_SPEED          250
#define MAX_LIGHT_INTENSITY 255
#define MIN_LIGHT_THRESHOLD     0.1
#define ST_MIN_LIGHT_THRESHOLD 30
#define ST_MAX_LIGHT_THRESHOLD 180
#define DISTANCE_THRESHOLD      0.075f

#define DISTANCE_SCALE          0.35f   //These first three get your base detection rating, ideally add up to 1
#define FOV_SCALE                       0.40f   //
#define LIGHT_SCALE                     0.25f   //

#define SPEED_SCALE                     0.25f   //These next two are bonuses
#define TURNING_SCALE           0.25f   //

#define REALIZE_THRESHOLD       0.6f
#define CAUTIOUS_THRESHOLD      ( REALIZE_THRESHOLD * 0.75 )

qboolean NPC_CheckPlayerTeamStealth( void );

static qboolean enemyLOS;
static qboolean enemyCS;
static qboolean enemyInFOV;
static qboolean hitAlly;
static qboolean faceEnemy;
static qboolean move;
static qboolean shoot;
static float    enemyDist;
static vec3_t   impactPos;

int groupSpeechDebounceTime[TEAM_NUM_TEAMS];//used to stop several group AI from speaking all at once

//Local state enums
enum
{
        LSTATE_NONE = 0,
        LSTATE_UNDERFIRE,
        LSTATE_INVESTIGATE,
};

void ST_AggressionAdjust( gentity_t *self, int change )
{
        int     upper_threshold, lower_threshold;

        self->NPC->stats.aggression += change;
        
        //FIXME: base this on initial NPC stats
        if ( self->client->playerTeam == NPCTEAM_PLAYER )
        {//good guys are less aggressive
                upper_threshold = 7;
                lower_threshold = 1;
        }
        else
        {//bad guys are more aggressive
                upper_threshold = 10;
                lower_threshold = 3;
        }

        if ( self->NPC->stats.aggression > upper_threshold )
        {
                self->NPC->stats.aggression = upper_threshold;
        }
        else if ( self->NPC->stats.aggression < lower_threshold )
        {
                self->NPC->stats.aggression = lower_threshold;
        }
}

void ST_ClearTimers( gentity_t *ent )
{
        TIMER_Set( ent, "chatter", 0 );
        TIMER_Set( ent, "duck", 0 );
        TIMER_Set( ent, "stand", 0 );
        TIMER_Set( ent, "shuffleTime", 0 );
        TIMER_Set( ent, "sleepTime", 0 );
        TIMER_Set( ent, "enemyLastVisible", 0 );
        TIMER_Set( ent, "roamTime", 0 );
        TIMER_Set( ent, "hideTime", 0 );
        TIMER_Set( ent, "attackDelay", 0 );     //FIXME: Slant for difficulty levels
        TIMER_Set( ent, "stick", 0 );
        TIMER_Set( ent, "scoutTime", 0 );
        TIMER_Set( ent, "flee", 0 );
        TIMER_Set( ent, "interrogating", 0 );
        TIMER_Set( ent, "verifyCP", 0 );
}

enum
{
        SPEECH_CHASE,
        SPEECH_CONFUSED,
        SPEECH_COVER,
        SPEECH_DETECTED,
        SPEECH_GIVEUP,
        SPEECH_LOOK,
        SPEECH_LOST,
        SPEECH_OUTFLANK,
        SPEECH_ESCAPING,
        SPEECH_SIGHT,
        SPEECH_SOUND,
        SPEECH_SUSPICIOUS,
        SPEECH_YELL,
        SPEECH_PUSHED
};

static void ST_Speech( gentity_t *self, int speechType, float failChance )
{
        if ( random() < failChance )
        {
                return;
        }

        if ( failChance >= 0 )
        {//a negative failChance makes it always talk
                if ( self->NPC->group )
                {//group AI speech debounce timer
                        if ( self->NPC->group->speechDebounceTime > level.time )
                        {
                                return;
                        }
                        /*
                        else if ( !self->NPC->group->enemy )
                        {
                                if ( groupSpeechDebounceTime[self->client->playerTeam] > level.time )
                                {
                                        return;
                                }
                        }
                        */
                }
                else if ( !TIMER_Done( self, "chatter" ) )
                {//personal timer
                        return;
                }
                else if ( groupSpeechDebounceTime[self->client->playerTeam] > level.time )
                {//for those not in group AI
                        //FIXME: let certain speech types interrupt others?  Let closer NPCs interrupt farther away ones?
                        return;
                }
        }

        if ( self->NPC->group )
        {//So they don't all speak at once...
                //FIXME: if they're not yet mad, they have no group, so distracting a group of them makes them all speak!
                self->NPC->group->speechDebounceTime = level.time + Q_irand( 2000, 4000 );
        }
        else
        {
                TIMER_Set( self, "chatter", Q_irand( 2000, 4000 ) );
        }
        groupSpeechDebounceTime[self->client->playerTeam] = level.time + Q_irand( 2000, 4000 );

        if ( self->NPC->blockedSpeechDebounceTime > level.time )
        {
                return;
        }

        switch( speechType )
        {
        case SPEECH_CHASE:
                G_AddVoiceEvent( self, Q_irand(EV_CHASE1, EV_CHASE3), 2000 );
                break;
        case SPEECH_CONFUSED:
                G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
                break;
        case SPEECH_COVER:
                G_AddVoiceEvent( self, Q_irand(EV_COVER1, EV_COVER5), 2000 );
                break;
        case SPEECH_DETECTED:
                G_AddVoiceEvent( self, Q_irand(EV_DETECTED1, EV_DETECTED5), 2000 );
                break;
        case SPEECH_GIVEUP:
                G_AddVoiceEvent( self, Q_irand(EV_GIVEUP1, EV_GIVEUP4), 2000 );
                break;
        case SPEECH_LOOK:
                G_AddVoiceEvent( self, Q_irand(EV_LOOK1, EV_LOOK2), 2000 );
                break;
        case SPEECH_LOST:
                G_AddVoiceEvent( self, EV_LOST1, 2000 );
                break;
        case SPEECH_OUTFLANK:
                G_AddVoiceEvent( self, Q_irand(EV_OUTFLANK1, EV_OUTFLANK2), 2000 );
                break;
        case SPEECH_ESCAPING:
                G_AddVoiceEvent( self, Q_irand(EV_ESCAPING1, EV_ESCAPING3), 2000 );
                break;
        case SPEECH_SIGHT:
                G_AddVoiceEvent( self, Q_irand(EV_SIGHT1, EV_SIGHT3), 2000 );
                break;
        case SPEECH_SOUND:
                G_AddVoiceEvent( self, Q_irand(EV_SOUND1, EV_SOUND3), 2000 );
                break;
        case SPEECH_SUSPICIOUS:
                G_AddVoiceEvent( self, Q_irand(EV_SUSPICIOUS1, EV_SUSPICIOUS5), 2000 );
                break;
        case SPEECH_YELL:
                G_AddVoiceEvent( self, Q_irand( EV_ANGER1, EV_ANGER3 ), 2000 );
                break;
        case SPEECH_PUSHED:
                G_AddVoiceEvent( self, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 2000 );
                break;
        default:
                break;
        }

        self->NPC->blockedSpeechDebounceTime = level.time + 2000;
}

void ST_MarkToCover( gentity_t *self )
{
        if ( !self || !self->NPC )
        {
                return;
        }
        self->NPC->localState = LSTATE_UNDERFIRE;
        TIMER_Set( self, "attackDelay", Q_irand( 500, 2500 ) );
        ST_AggressionAdjust( self, -3 );
        if ( self->NPC->group && self->NPC->group->numGroup > 1 )
        {
                ST_Speech( self, SPEECH_COVER, 0 );//FIXME: flee sound?
        }
}

void ST_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int minTime, int maxTime )
{
        if ( !self || !self->NPC )
        {
                return;
        }
        G_StartFlee( self, enemy, dangerPoint, dangerLevel, minTime, maxTime );
        if ( self->NPC->group && self->NPC->group->numGroup > 1 )
        {
                ST_Speech( self, SPEECH_COVER, 0 );//FIXME: flee sound?
        }
}
/*
-------------------------
NPC_ST_Pain
-------------------------
*/

void NPC_ST_Pain(gentity_t *self, gentity_t *attacker, int damage)
{
        self->NPC->localState = LSTATE_UNDERFIRE;

        TIMER_Set( self, "duck", -1 );
        TIMER_Set( self, "hideTime", -1 );
        TIMER_Set( self, "stand", 2000 );

        NPC_Pain( self, attacker, damage );

        if ( !damage && self->health > 0 )
        {//FIXME: better way to know I was pushed
                G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
        }
}

/*
-------------------------
ST_HoldPosition
-------------------------
*/

static void ST_HoldPosition( void )
{
        if ( NPCInfo->squadState == SQUAD_RETREAT )
        {
                TIMER_Set( NPC, "flee", -level.time );
        }
        TIMER_Set( NPC, "verifyCP", Q_irand( 1000, 3000 ) );//don't look for another one for a few seconds
        NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
        //NPCInfo->combatPoint = -1;//???
        if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
        {//don't have a script waiting for me to get to my point, okay to stop trying and stand
                AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
                NPCInfo->goalEntity = NULL;
        }
        
        /*if ( TIMER_Done( NPC, "stand" ) )
        {//FIXME: what if can't shoot from this pos?
                TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
        }
        */
}

void NPC_ST_SayMovementSpeech( void )
{
        if ( !NPCInfo->movementSpeech )
        {
                return;
        }
        if ( NPCInfo->group && 
                NPCInfo->group->commander && 
                NPCInfo->group->commander->client && 
                NPCInfo->group->commander->client->NPC_class == CLASS_IMPERIAL && 
                !Q_irand( 0, 3 ) )
        {//imperial (commander) gives the order
                ST_Speech( NPCInfo->group->commander, NPCInfo->movementSpeech, NPCInfo->movementSpeechChance );
        }
        else
        {//really don't want to say this unless we can actually get there...
                ST_Speech( NPC, NPCInfo->movementSpeech, NPCInfo->movementSpeechChance );
        }

        NPCInfo->movementSpeech = 0;
        NPCInfo->movementSpeechChance = 0.0f;
}

void NPC_ST_StoreMovementSpeech( int speech, float chance )
{
        NPCInfo->movementSpeech = speech;
        NPCInfo->movementSpeechChance = chance;
}
/*
-------------------------
ST_Move
-------------------------
*/
void ST_TransferMoveGoal( gentity_t *self, gentity_t *other );
static qboolean ST_Move( void )
{
        qboolean        moved;
        navInfo_t       info;

        NPCInfo->combatMove = qtrue;//always move straight toward our goal

        moved = NPC_MoveToGoal( qtrue );
        
        //Get the move info
        NAV_GetLastMove( &info );

        //FIXME: if we bump into another one of our guys and can't get around him, just stop!
        //If we hit our target, then stop and fire!
        if ( info.flags & NIF_COLLISION ) 
        {
                if ( info.blocker == NPC->enemy )
                {
                        ST_HoldPosition();
                }
        }

        //If our move failed, then reset
        if ( moved == qfalse )
        {//FIXME: if we're going to a combat point, need to pick a different one
                if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
                {//can't transfer movegoal or stop when a script we're running is waiting to complete
                        if ( info.blocker && info.blocker->NPC && NPCInfo->group != NULL && info.blocker->NPC->group == NPCInfo->group )//(NPCInfo->aiFlags&NPCAI_BLOCKED) && NPCInfo->group != NULL )
                        {//dammit, something is in our way
                                //see if it's one of ours
                                int j;

                                for ( j = 0; j < NPCInfo->group->numGroup; j++ )
                                {
                                        if ( NPCInfo->group->member[j].number == NPCInfo->blockingEntNum )
                                        {//we're being blocked by one of our own, pass our goal onto them and I'll stand still
                                                ST_TransferMoveGoal( NPC, &g_entities[NPCInfo->group->member[j].number] );
                                                break;
                                        }
                                }
                        }
                        
                        ST_HoldPosition();
                }
        }
        else
        {
                //First time you successfully move, say what it is you're doing
                NPC_ST_SayMovementSpeech();
        }

        return moved;
}


/*
-------------------------
NPC_ST_SleepShuffle
-------------------------
*/

static void NPC_ST_SleepShuffle( void )
{
        //Play an awake script if we have one
        if ( G_ActivateBehavior( NPC, BSET_AWAKE) )
        {
                return;
        }

        //Automate some movement and noise
        if ( TIMER_Done( NPC, "shuffleTime" ) )
        {
                
                //TODO: Play sleeping shuffle animation

                //int   soundIndex = Q_irand( 0, 1 );

                /*
                switch ( soundIndex )
                {
                case 0:
                        G_Sound( NPC, G_SoundIndex("sound/chars/imperialsleeper1/scav4/hunh.mp3") );
                        break;

                case 1:
                        G_Sound( NPC, G_SoundIndex("sound/chars/imperialsleeper3/scav4/tryingtosleep.wav") );
                        break;
                }
                */

                TIMER_Set( NPC, "shuffleTime", 4000 );
                TIMER_Set( NPC, "sleepTime", 2000 );
                return;
        }

        //They made another noise while we were stirring, see if we can see them
        if ( TIMER_Done( NPC, "sleepTime" ) )
        {
                NPC_CheckPlayerTeamStealth();
                TIMER_Set( NPC, "sleepTime", 2000 );
        }
}

/*
-------------------------
NPC_ST_Sleep
-------------------------
*/

void NPC_BSST_Sleep( void )
{
        int alertEvent = NPC_CheckAlertEvents( qfalse, qtrue, -1, qfalse, AEL_MINOR );//only check sounds since we're alseep!

        //There is an event we heard
        if ( alertEvent >= 0 )
        {
                //See if it was enough to wake us up
                if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
                { //rwwFIXMEFIXME: Care about all clients not just 0
                        if ( &g_entities[0] && g_entities[0].health > 0 )
                        {
                                G_SetEnemy( NPC, &g_entities[0] );
                                return;
                        }
                }

                //Otherwise just stir a bit
                NPC_ST_SleepShuffle();
                return;
        }
}

/*
-------------------------
NPC_CheckEnemyStealth
-------------------------
*/

qboolean NPC_CheckEnemyStealth( gentity_t *target )
{
        float           target_dist, minDist = 40;//any closer than 40 and we definitely notice
        float           maxViewDist;
        qboolean        clearLOS;

        //In case we aquired one some other way
        if ( NPC->enemy != NULL )
                return qtrue;

        //Ignore notarget
        if ( target->flags & FL_NOTARGET )
                return qfalse;

        if ( target->health <= 0 )
        {
                return qfalse;
        }

        if ( target->client->ps.weapon == WP_SABER && !target->client->ps.saberHolstered && !target->client->ps.saberInFlight )
        {//if target has saber in hand and activated, we wake up even sooner even if not facing him
                minDist = 100;
        }

        target_dist = DistanceSquared( target->r.currentOrigin, NPC->r.currentOrigin );

        //If the target is this close, then wake up regardless
        if ( !(target->client->ps.pm_flags&PMF_DUCKED)
                && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES)
                && (target_dist) < (minDist*minDist) )
        {
                G_SetEnemy( NPC, target );
                NPCInfo->enemyLastSeenTime = level.time;
                TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
                return qtrue;
        }

        maxViewDist                     = MAX_VIEW_DIST;

        if ( NPCInfo->stats.visrange > maxViewDist )
        {//FIXME: should we always just set maxViewDist to this?
                maxViewDist = NPCInfo->stats.visrange;
        }

        if ( target_dist > (maxViewDist*maxViewDist) )
        {//out of possible visRange
                return qfalse;
        }

        //Check FOV first
        if ( InFOV( target, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) == qfalse )
                return qfalse;

        //clearLOS = ( target->client->ps.leanofs ) ? NPC_ClearLOS5( target->client->renderInfo.eyePoint ) : NPC_ClearLOS4( target );
        clearLOS = NPC_ClearLOS4( target );

        //Now check for clear line of vision
        if ( clearLOS )
        {
                vec3_t  targ_org;
                float   hAngle_perc;
                float   vAngle_perc;
                float   target_speed;
                int             target_crouching;
                float   dist_rating;
                float   speed_rating;
                float   turning_rating;
                float   light_level;
                float   FOV_perc;
                float   vis_rating;
                float   dist_influence;
                float   fov_influence;
                float   light_influence;
                float   target_rating;
                int             contents;
                float   realize, cautious;

                if ( target->client->NPC_class == CLASS_ATST )
                {//can't miss 'em!
                        G_SetEnemy( NPC, target );
                        TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
                        return qtrue;
                }
                VectorSet(targ_org, target->r.currentOrigin[0],target->r.currentOrigin[1],target->r.currentOrigin[2]+target->r.maxs[2]-4);
                hAngle_perc                     = NPC_GetHFOVPercentage( targ_org, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, NPCInfo->stats.hfov );
                vAngle_perc                     = NPC_GetVFOVPercentage( targ_org, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, NPCInfo->stats.vfov );

                //Scale them vertically some, and horizontally pretty harshly
                vAngle_perc *= vAngle_perc;//( vAngle_perc * vAngle_perc );
                hAngle_perc *= ( hAngle_perc * hAngle_perc );

                //Cap our vertical vision severely
                //if ( vAngle_perc <= 0.3f ) // was 0.5f
                //      return qfalse;

                //Assess the player's current status
                target_dist                     = Distance( target->r.currentOrigin, NPC->r.currentOrigin );

                target_speed            = VectorLength( target->client->ps.velocity );
                target_crouching        = ( target->client->pers.cmd.upmove < 0 );
                dist_rating                     = ( target_dist / maxViewDist );
                speed_rating            = ( target_speed / MAX_VIEW_SPEED );
                turning_rating          = 5.0f;//AngleDelta( target->client->ps.viewangles[PITCH], target->lastAngles[PITCH] )/180.0f + AngleDelta( target->client->ps.viewangles[YAW], target->lastAngles[YAW] )/180.0f;
                light_level                     = (255/MAX_LIGHT_INTENSITY); //( target->lightLevel / MAX_LIGHT_INTENSITY );
                FOV_perc                        = 1.0f - ( hAngle_perc + vAngle_perc ) * 0.5f;  //FIXME: Dunno about the average...
                vis_rating                      = 0.0f;
                
                //Too dark
                if ( light_level < MIN_LIGHT_THRESHOLD )
                        return qfalse;

                //Too close?
                if ( dist_rating < DISTANCE_THRESHOLD )
                {
                        G_SetEnemy( NPC, target );
                        TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
                        return qtrue;
                }

                //Out of range
                if ( dist_rating > 1.0f )
                        return qfalse;
                
                //Cap our speed checks
                if ( speed_rating > 1.0f )
                        speed_rating = 1.0f;
                

                //Calculate the distance, fov and light influences
                //...Visibilty linearly wanes over distance
                dist_influence  = DISTANCE_SCALE * ( ( 1.0f - dist_rating ) );
                //...As the percentage out of the FOV increases, straight perception suffers on an exponential scale
                fov_influence           = FOV_SCALE * ( 1.0f - FOV_perc );
                //...Lack of light hides, abundance of light exposes
                light_influence = ( light_level - 0.5f ) * LIGHT_SCALE;
                
                //Calculate our base rating
                target_rating           = dist_influence + fov_influence + light_influence;
                
                //Now award any final bonuses to this number
                contents = trap_PointContents( targ_org, target->s.number );
                if ( contents&CONTENTS_WATER )
                {
                        int myContents = trap_PointContents( NPC->client->renderInfo.eyePoint, NPC->s.number );
                        if ( !(myContents&CONTENTS_WATER) )
                        {//I'm not in water
                                if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
                                {//these guys can see in in/through water pretty well
                                        vis_rating = 0.10f;//10% bonus
                                }
                                else
                                {
                                        vis_rating = 0.35f;//35% bonus
                                }
                        }
                        else
                        {//else, if we're both in water
                                if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
                                {//I can see him just fine
                                }
                                else
                                {
                                        vis_rating = 0.15f;//15% bonus
                                }
                        }
                }
                else 
                {//not in water
                        if ( contents&CONTENTS_FOG )
                        {
                                vis_rating = 0.15f;//15% bonus
                        }
                }

                target_rating *= (1.0f - vis_rating);

                //...Motion draws the eye quickly
                target_rating += speed_rating * SPEED_SCALE;
                target_rating += turning_rating * TURNING_SCALE;
                //FIXME: check to see if they're animating, too?  But can we do something as simple as frame != oldframe?

                //...Smaller targets are harder to indentify
                if ( target_crouching )
                {
                        target_rating *= 0.9f;  //10% bonus
                }       
        
                //If he's violated the threshold, then realize him
                //float difficulty_scale = 1.0f + (2.0f-g_spskill.value);//if playing on easy, 20% harder to be seen...?
                if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
                {//swamptroopers can see much better
                        realize = (float)CAUTIOUS_THRESHOLD;
                        cautious = (float)CAUTIOUS_THRESHOLD * 0.75f;
                }
                else
                {
                        realize = (float)REALIZE_THRESHOLD;
                        cautious = (float)CAUTIOUS_THRESHOLD * 0.75f;
                }

                if ( target_rating > realize && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
                {
                        G_SetEnemy( NPC, target );
                        NPCInfo->enemyLastSeenTime = level.time;
                        TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
                        return qtrue;
                }

                //If he's above the caution threshold, then realize him in a few seconds unless he moves to cover
                if ( target_rating > cautious && !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
                {//FIXME: ambushing guys should never talk
                        if ( TIMER_Done( NPC, "enemyLastVisible" ) )
                        {//If we haven't already, start the counter
                                int     lookTime = Q_irand( 4500, 8500 );
                                //NPCInfo->timeEnemyLastVisible = level.time + 2000;
                                TIMER_Set( NPC, "enemyLastVisible", lookTime );
                                //TODO: Play a sound along the lines of, "Huh?  What was that?"
                                ST_Speech( NPC, SPEECH_SIGHT, 0 );
                                NPC_TempLookTarget( NPC, target->s.number, lookTime, lookTime );
                                //FIXME: set desired yaw and pitch towards this guy?
                        }
                        else if ( TIMER_Get( NPC, "enemyLastVisible" ) <= level.time + 500 && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )     //FIXME: Is this reliable?
                        {
                                if ( NPCInfo->rank < RANK_LT && !Q_irand( 0, 2 ) )
                                {
                                        int     interrogateTime = Q_irand( 2000, 4000 );
                                        ST_Speech( NPC, SPEECH_SUSPICIOUS, 0 );
                                        TIMER_Set( NPC, "interrogating", interrogateTime );
                                        G_SetEnemy( NPC, target );
                                        NPCInfo->enemyLastSeenTime = level.time;
                                        TIMER_Set( NPC, "attackDelay", interrogateTime );
                                        TIMER_Set( NPC, "stand", interrogateTime );
                                }
                                else
                                {
                                        G_SetEnemy( NPC, target );
                                        NPCInfo->enemyLastSeenTime = level.time;
                                        //FIXME: ambush guys (like those popping out of water) shouldn't delay...
                                        TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
                                        TIMER_Set( NPC, "stand", Q_irand( 500, 2500 ) );
                                }
                                return qtrue;
                        }

                        return qfalse;
                }
        }

        return qfalse;
}

qboolean NPC_CheckPlayerTeamStealth( void )
{
        /*
        //NOTENOTE: For now, all stealh checks go against the player, since
        //                      he is the main focus.  Squad members and rivals do not
        //                      fall into this category and will be ignored.

        NPC_CheckEnemyStealth( &g_entities[0] );        //Change this pointer to assess other entities
        */
        gentity_t *enemy;
        int i;

        for ( i = 0; i < ENTITYNUM_WORLD; i++ )
        {
                enemy = &g_entities[i];

                if (!enemy->inuse)
                {
                        continue;
                }

                if ( enemy && enemy->client && NPC_ValidEnemy( enemy ) && enemy->client->playerTeam == NPC->client->enemyTeam )
                {
                        if ( NPC_CheckEnemyStealth( enemy ) )   //Change this pointer to assess other entities
                        {
                                return qtrue;
                        }
                }
        }
        return qfalse;
}
/*
-------------------------
NPC_ST_InvestigateEvent
-------------------------
*/

#define MAX_CHECK_THRESHOLD     1

static qboolean NPC_ST_InvestigateEvent( int eventID, qboolean extraSuspicious )
{
        //If they've given themselves away, just take them as an enemy
        if ( NPCInfo->confusionTime < level.time )
        {
                if ( level.alertEvents[eventID].level == AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
                {
                        NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
                        if ( !level.alertEvents[eventID].owner || 
                                !level.alertEvents[eventID].owner->client || 
                                level.alertEvents[eventID].owner->health <= 0 ||
                                level.alertEvents[eventID].owner->client->playerTeam != NPC->client->enemyTeam )
                        {//not an enemy
                                return qfalse;
                        }
                        //FIXME: what if can't actually see enemy, don't know where he is... should we make them just become very alert and start looking for him?  Or just let combat AI handle this... (act as if you lost him)
                        //ST_Speech( NPC, SPEECH_CHARGE, 0 );
                        G_SetEnemy( NPC, level.alertEvents[eventID].owner );
                        NPCInfo->enemyLastSeenTime = level.time;
                        TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
                        if ( level.alertEvents[eventID].type == AET_SOUND )
                        {//heard him, didn't see him, stick for a bit
                                TIMER_Set( NPC, "roamTime", Q_irand( 500, 2500 ) );
                        }
                        return qtrue;
                }
        }

        //don't look at the same alert twice
        if ( level.alertEvents[eventID].ID == NPCInfo->lastAlertID )
        {
                return qfalse;
        }
        NPCInfo->lastAlertID = level.alertEvents[eventID].ID;

        //Must be ready to take another sound event
        /*
        if ( NPCInfo->investigateSoundDebounceTime > level.time )
        {
                return qfalse;
        }
        */

        if ( level.alertEvents[eventID].type == AET_SIGHT )
        {//sight alert, check the light level
                if ( level.alertEvents[eventID].light < Q_irand( ST_MIN_LIGHT_THRESHOLD, ST_MAX_LIGHT_THRESHOLD ) )
                {//below my threshhold of potentially seeing
                        return qfalse;
                }
        }

        //Save the position for movement (if necessary)
        VectorCopy( level.alertEvents[eventID].position, NPCInfo->investigateGoal );

        //First awareness of it
        NPCInfo->investigateCount += ( extraSuspicious ) ? 2 : 1;

        //Clamp the value
        if ( NPCInfo->investigateCount > 4 )
                NPCInfo->investigateCount = 4;

        //See if we should walk over and investigate
        if ( level.alertEvents[eventID].level > AEL_MINOR && NPCInfo->investigateCount > 1 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
        {
                //make it so they can walk right to this point and look at it rather than having to use combatPoints
                if ( G_ExpandPointToBBox( NPCInfo->investigateGoal, NPC->r.mins, NPC->r.maxs, NPC->s.number, ((NPC->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP) ) )
                {//we were able to move the investigateGoal to a point in which our bbox would fit
                        //drop the goal to the ground so we can get at it
                        vec3_t  end;
                        trace_t trace;
                        VectorCopy( NPCInfo->investigateGoal, end );
                        end[2] -= 512;//FIXME: not always right?  What if it's even higher, somehow?
                        trap_Trace( &trace, NPCInfo->investigateGoal, NPC->r.mins, NPC->r.maxs, end, ENTITYNUM_NONE, ((NPC->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP) );
                        if ( trace.fraction >= 1.0f )
                        {//too high to even bother
                                //FIXME: look at them???
                        }
                        else
                        {
                                VectorCopy( trace.endpos, NPCInfo->investigateGoal );
                                NPC_SetMoveGoal( NPC, NPCInfo->investigateGoal, 16, qtrue, -1, NULL );
                                NPCInfo->localState = LSTATE_INVESTIGATE;
                        }
                }
                else
                {
                        int id = NPC_FindCombatPoint( NPCInfo->investigateGoal, NPCInfo->investigateGoal, NPCInfo->investigateGoal, CP_INVESTIGATE|CP_HAS_ROUTE, 0, -1 );

                        if ( id != -1 )
                        {
                                NPC_SetMoveGoal( NPC, level.combatPoints[id].origin, 16, qtrue, id, NULL );
                                NPCInfo->localState = LSTATE_INVESTIGATE;
                        }
                }
                //Say something
                //FIXME: only if have others in group... these should be responses?
                if ( NPCInfo->investigateDebounceTime+NPCInfo->pauseTime > level.time )
                {//was already investigating
                        if ( NPCInfo->group && 
                                NPCInfo->group->commander && 
                                NPCInfo->group->commander->client && 
                                NPCInfo->group->commander->client->NPC_class == CLASS_IMPERIAL && 
                                !Q_irand( 0, 3 ) )
                        {
                                ST_Speech( NPCInfo->group->commander, SPEECH_LOOK, 0 );//FIXME: "I'll go check it out" type sounds
                        }
                        else
                        {
                                ST_Speech( NPC, SPEECH_LOOK, 0 );//FIXME: "I'll go check it out" type sounds
                        }
                }
                else
                {
                        if ( level.alertEvents[eventID].type == AET_SIGHT )
                        {
                                ST_Speech( NPC, SPEECH_SIGHT, 0 );
                        }
                        else if ( level.alertEvents[eventID].type == AET_SOUND )
                        {
                                ST_Speech( NPC, SPEECH_SOUND, 0 );
                        }
                }
                //Setup the debounce info
                NPCInfo->investigateDebounceTime                = NPCInfo->investigateCount * 5000;
                NPCInfo->investigateSoundDebounceTime   = level.time + 2000;
                NPCInfo->pauseTime                                              = level.time;
        }
        else
        {//just look?
                //Say something
                if ( level.alertEvents[eventID].type == AET_SIGHT )
                {
                        ST_Speech( NPC, SPEECH_SIGHT, 0 );
                }
                else if ( level.alertEvents[eventID].type == AET_SOUND )
                {
                        ST_Speech( NPC, SPEECH_SOUND, 0 );
                }
                //Setup the debounce info
                NPCInfo->investigateDebounceTime                = NPCInfo->investigateCount * 1000;
                NPCInfo->investigateSoundDebounceTime   = level.time + 1000;
                NPCInfo->pauseTime                                              = level.time;
                VectorCopy( level.alertEvents[eventID].position, NPCInfo->investigateGoal );
        }

        if ( level.alertEvents[eventID].level >= AEL_DANGER )
        {
                NPCInfo->investigateDebounceTime = Q_irand( 500, 2500 );
        }

        //Start investigating
        NPCInfo->tempBehavior = BS_INVESTIGATE;
        return qtrue;
}

/*
-------------------------
ST_OffsetLook
-------------------------
*/

static void ST_OffsetLook( float offset, vec3_t out )
{
        vec3_t  angles, forward, temp;

        GetAnglesForDirection( NPC->r.currentOrigin, NPCInfo->investigateGoal, angles );
        angles[YAW] += offset;
        AngleVectors( angles, forward, NULL, NULL );
        VectorMA( NPC->r.currentOrigin, 64, forward, out );
        
        CalcEntitySpot( NPC, SPOT_HEAD, temp );
        out[2] = temp[2];
}

/*
-------------------------
ST_LookAround
-------------------------
*/

static void ST_LookAround( void )
{
        vec3_t  lookPos;
        float   perc = (float) ( level.time - NPCInfo->pauseTime ) / (float) NPCInfo->investigateDebounceTime;

        //Keep looking at the spot
        if ( perc < 0.25 )
        {
                VectorCopy( NPCInfo->investigateGoal, lookPos );
        }
        else if ( perc < 0.5f )         //Look up but straight ahead
        {
                ST_OffsetLook( 0.0f, lookPos );
        }
        else if ( perc < 0.75f )        //Look right
        {
                ST_OffsetLook( 45.0f, lookPos );
        }
        else    //Look left
        {
                ST_OffsetLook( -45.0f, lookPos );
        }

        NPC_FacePosition( lookPos, qtrue );
}

/*
-------------------------
NPC_BSST_Investigate
-------------------------
*/

void NPC_BSST_Investigate( void )
{
        //get group- mainly for group speech debouncing, but may use for group scouting/investigating AI, too
        AI_GetGroup( NPC );

        if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
        {
                WeaponThink( qtrue );
        }

        if ( NPCInfo->confusionTime < level.time )
        {
                if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
                {
                        //Look for an enemy
                        if ( NPC_CheckPlayerTeamStealth() )
                        {
                                //NPCInfo->behaviorState        = BS_HUNT_AND_KILL;//should be auto now
                                ST_Speech( NPC, SPEECH_DETECTED, 0 );
                                NPCInfo->tempBehavior   = BS_DEFAULT;
                                NPC_UpdateAngles( qtrue, qtrue );
                                return;
                        }
                }
        }

        if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
        {
                int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, NPCInfo->lastAlertID, qfalse, AEL_MINOR );

                //There is an event to look at
                if ( alertEvent >= 0 )
                {
                        if ( NPCInfo->confusionTime < level.time )
                        {
                                if ( NPC_CheckForDanger( alertEvent ) )
                                {//running like hell
                                        ST_Speech( NPC, SPEECH_COVER, 0 );//FIXME: flee sound?
                                        return;
                                }
                        }

                        if ( level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
                        {
                                NPC_ST_InvestigateEvent( alertEvent, qtrue );
                        }
                }
        }

        //If we're done looking, then just return to what we were doing
        if ( ( NPCInfo->investigateDebounceTime + NPCInfo->pauseTime ) < level.time )
        {
                NPCInfo->tempBehavior = BS_DEFAULT;
                NPCInfo->goalEntity = UpdateGoal();
                
                NPC_UpdateAngles( qtrue, qtrue );
                //Say something
                ST_Speech( NPC, SPEECH_GIVEUP, 0 );
                return;
        }

        //FIXME: else, look for new alerts

        //See if we're searching for the noise's origin
        if ( NPCInfo->localState == LSTATE_INVESTIGATE && (NPCInfo->goalEntity!=NULL) )
        {
                //See if we're there
                if ( NAV_HitNavGoal( NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPCInfo->goalEntity->r.currentOrigin, 32, FlyingCreature( NPC ) ) == qfalse )
                {
                        ucmd.buttons |= BUTTON_WALKING;

                        //Try and move there
                        if ( NPC_MoveToGoal( qtrue )  )
                        {
                                //Bump our times
                                NPCInfo->investigateDebounceTime        = NPCInfo->investigateCount * 5000;
                                NPCInfo->pauseTime                                      = level.time;

                                NPC_UpdateAngles( qtrue, qtrue );
                                return;
                        }
                }

                //Otherwise we're done or have given up
                //Say something
                //ST_Speech( NPC, SPEECH_LOOK, 0.33f );
                NPCInfo->localState = LSTATE_NONE;
        }

        //Look around
        ST_LookAround();
}

/*
-------------------------
NPC_BSST_Patrol
-------------------------
*/

void NPC_BSST_Patrol( void )
{//FIXME: pick up on bodies of dead buddies?
        
        //get group- mainly for group speech debouncing, but may use for group scouting/investigating AI, too
        AI_GetGroup( NPC );

        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 auto now
                                //NPC_AngerSound();
                                NPC_UpdateAngles( qtrue, qtrue );
                                return;
                        }
                }
        }

        if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
        {
                int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_MINOR );

                //There is an event to look at
                if ( alertEvent >= 0 )
                {
                        if ( NPC_ST_InvestigateEvent( alertEvent, qfalse ) )
                        {//actually going to investigate it
                                NPC_UpdateAngles( qtrue, qtrue );
                                return;
                        }
                }
        }

        //If we have somewhere to go, then do that
        if ( UpdateGoal() )
        {
                ucmd.buttons |= BUTTON_WALKING;
                //ST_Move( NPCInfo->goalEntity );
                NPC_MoveToGoal( qtrue );
        }
        else// if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
        {
                if ( NPC->client->NPC_class != CLASS_IMPERIAL && NPC->client->NPC_class != CLASS_IMPWORKER )
                {//imperials do not look around
                        if ( TIMER_Done( NPC, "enemyLastVisible" ) )
                        {//nothing suspicious, look around
                                if ( !Q_irand( 0, 30 ) )
                                {
                                        NPCInfo->desiredYaw = NPC->s.angles[1] + Q_irand( -90, 90 );
                                }
                                if ( !Q_irand( 0, 30 ) )
                                {
                                        NPCInfo->desiredPitch = Q_irand( -20, 20 );
                                }