codemp/game/NPC_behavior.c

Go to the documentation of this file.

//NPC_behavior.cpp
/*
FIXME - MCG:
These all need to make use of the snapshots.  Write something that can look for only specific
things in a snapshot or just go through the snapshot every frame and save the info in case
we need it...
*/

#include "b_local.h"
#include "g_nav.h"
#include "../icarus/Q3_Interface.h"

extern  qboolean        showBBoxes;
extern vec3_t NPCDEBUG_BLUE;
extern void G_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
extern void NPC_CheckGetNewWeapon( void );

#include "../namespace_begin.h"
extern qboolean PM_InKnockDown( playerState_t *ps );
#include "../namespace_end.h"

extern void NPC_AimAdjust( int change );
extern qboolean NPC_SomeoneLookingAtMe(gentity_t *ent);
/*
 void NPC_BSAdvanceFight (void)

Advance towards your captureGoal and shoot anyone you can along the way.
*/
void NPC_BSAdvanceFight (void)
{//FIXME: IMPLEMENT
//Head to Goal if I can

        //Make sure we're still headed where we want to capture
        if ( NPCInfo->captureGoal )
        {//FIXME: if no captureGoal, what do we do?
                //VectorCopy( NPCInfo->captureGoal->r.currentOrigin, NPCInfo->tempGoal->r.currentOrigin );
                //NPCInfo->goalEntity = NPCInfo->tempGoal;

                NPC_SetMoveGoal( NPC, NPCInfo->captureGoal->r.currentOrigin, 16, qtrue, -1, NULL );

//              NAV_ClearLastRoute(NPC);
                NPCInfo->goalTime = level.time + 100000;
        }

//      NPC_BSRun();

        NPC_CheckEnemy(qtrue, qfalse, qtrue);

        //FIXME: Need melee code
        if( NPC->enemy )
        {//See if we can shoot him
                vec3_t          delta, forward;
                vec3_t          angleToEnemy;
                vec3_t          hitspot, muzzle, diff, enemy_org, enemy_head;
                float           distanceToEnemy;
                qboolean        attack_ok = qfalse;
                qboolean        dead_on = qfalse;
                float           attack_scale = 1.0;
                float           aim_off;
                float           max_aim_off = 64;

                //Yaw to enemy
                VectorMA(NPC->enemy->r.absmin, 0.5, NPC->enemy->r.maxs, enemy_org);
                CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
                
                VectorSubtract (enemy_org, muzzle, delta);
                vectoangles ( delta, angleToEnemy );
                distanceToEnemy = VectorNormalize(delta);

                if(!NPC_EnemyTooFar(NPC->enemy, distanceToEnemy*distanceToEnemy, qtrue))
                {
                        attack_ok = qtrue;
                }

                if(attack_ok)
                {
                        NPC_UpdateShootAngles(angleToEnemy, qfalse, qtrue);

                        NPCInfo->enemyLastVisibility = enemyVisibility;
                        enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV);//CHECK_360|//CHECK_PVS|

                        if(enemyVisibility == VIS_FOV)
                        {//He's in our FOV
                                
                                attack_ok = qtrue;
                                CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_head);

                                if(attack_ok)
                                {
                                        trace_t         tr;
                                        gentity_t       *traceEnt;
                                        //are we gonna hit him if we shoot at his center?
                                        trap_Trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
                                        traceEnt = &g_entities[tr.entityNum];
                                        if( traceEnt != NPC->enemy &&
                                                (!traceEnt || !traceEnt->client || !NPC->client->enemyTeam || NPC->client->enemyTeam != traceEnt->client->playerTeam) )
                                        {//no, so shoot for the head
                                                attack_scale *= 0.75;
                                                trap_Trace ( &tr, muzzle, NULL, NULL, enemy_head, NPC->s.number, MASK_SHOT );
                                                traceEnt = &g_entities[tr.entityNum];
                                        }

                                        VectorCopy( tr.endpos, hitspot );

                                        if( traceEnt == NPC->enemy || (traceEnt->client && NPC->client->enemyTeam && NPC->client->enemyTeam == traceEnt->client->playerTeam) )
                                        {
                                                dead_on = qtrue;
                                        }
                                        else
                                        {
                                                attack_scale *= 0.5;
                                                if(NPC->client->playerTeam)
                                                {
                                                        if(traceEnt && traceEnt->client && traceEnt->client->playerTeam)
                                                        {
                                                                if(NPC->client->playerTeam == traceEnt->client->playerTeam)
                                                                {//Don't shoot our own team
                                                                        attack_ok = qfalse;
                                                                }
                                                        }
                                                }
                                        }
                                }

                                if( attack_ok )
                                {
                                        //ok, now adjust pitch aim
                                        VectorSubtract (hitspot, muzzle, delta);
                                        vectoangles ( delta, angleToEnemy );
                                        NPC->NPC->desiredPitch = angleToEnemy[PITCH];
                                        NPC_UpdateShootAngles(angleToEnemy, qtrue, qfalse);

                                        if( !dead_on )
                                        {//We're not going to hit him directly, try a suppressing fire
                                                //see if where we're going to shoot is too far from his origin
                                                AngleVectors (NPCInfo->shootAngles, forward, NULL, NULL);
                                                VectorMA ( muzzle, distanceToEnemy, forward, hitspot);
                                                VectorSubtract(hitspot, enemy_org, diff);
                                                aim_off = VectorLength(diff);
                                                if(aim_off > random() * max_aim_off)//FIXME: use aim value to allow poor aim?
                                                {
                                                        attack_scale *= 0.75;
                                                        //see if where we're going to shoot is too far from his head
                                                        VectorSubtract(hitspot, enemy_head, diff);
                                                        aim_off = VectorLength(diff);
                                                        if(aim_off > random() * max_aim_off)
                                                        {
                                                                attack_ok = qfalse;
                                                        }
                                                }
                                                attack_scale *= (max_aim_off - aim_off + 1)/max_aim_off;
                                        }
                                }
                        }
                }

                if( attack_ok )
                {
                        if( NPC_CheckAttack( attack_scale ))
                        {//check aggression to decide if we should shoot
                                enemyVisibility = VIS_SHOOT;
                                WeaponThink(qtrue);
                        }
                        else
                                attack_ok = qfalse;
                }
//Don't do this- only for when stationary and trying to shoot an enemy
//              else
//                      NPC->cantHitEnemyCounter++;
        }
        else
        {//FIXME: 
                NPC_UpdateShootAngles(NPC->client->ps.viewangles, qtrue, qtrue);
        }

        if(!ucmd.forwardmove && !ucmd.rightmove)
        {//We reached our captureGoal
                if(trap_ICARUS_IsInitialized(NPC->s.number))
                {
                        trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
                }
        }
}

void Disappear(gentity_t *self)
{
//      ClientDisconnect(self);
        self->s.eFlags |= EF_NODRAW;
        self->think = 0;
        self->nextthink = -1;
}

void MakeOwnerInvis (gentity_t *self);
void BeamOut (gentity_t *self)
{
//      gentity_t *tent = G_Spawn();
        
/*
        tent->owner = self;
        tent->think = MakeOwnerInvis;
        tent->nextthink = level.time + 1800;
        //G_AddEvent( ent, EV_PLAYER_TELEPORT, 0 );
        tent = G_TempEntity( self->client->pcurrentOrigin, EV_PLAYER_TELEPORT );
*/
        //fixme: doesn't actually go away!
        self->nextthink = level.time + 1500;
        self->think = Disappear;
        self->client->squadname = NULL;
        self->client->playerTeam = self->s.teamowner = TEAM_FREE;
        //self->r.svFlags |= SVF_BEAMING; //this appears unused in SP as well
}

void NPC_BSCinematic( void ) 
{

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

        if ( UpdateGoal() )
        {//have a goalEntity
                //move toward goal, should also face that goal
                NPC_MoveToGoal( qtrue );
        }

        if ( NPCInfo->watchTarget )
        {//have an entity which we want to keep facing
                //NOTE: this will override any angles set by NPC_MoveToGoal
                vec3_t eyes, viewSpot, viewvec, viewangles;

                CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
                CalcEntitySpot( NPCInfo->watchTarget, SPOT_HEAD_LEAN, viewSpot );

                VectorSubtract( viewSpot, eyes, viewvec );
                
                vectoangles( viewvec, viewangles );

                NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = viewangles[YAW];
                NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch = viewangles[PITCH];
        }

        NPC_UpdateAngles( qtrue, qtrue );
}

void NPC_BSWait( void ) 
{
        NPC_UpdateAngles( qtrue, qtrue );
}


void NPC_BSInvestigate (void)
{
/*
        //FIXME: maybe allow this to be set as a tempBState in a script?  Just specify the
        //investigateGoal, investigateDebounceTime and investigateCount? (Needs a macro)
        vec3_t          invDir, invAngles, spot;
        gentity_t       *saveGoal;
        //BS_INVESTIGATE would turn toward goal, maybe take a couple steps towards it,
        //look for enemies, then turn away after your investigate counter was down-
        //investigate counter goes up every time you set it...

        if(level.time > NPCInfo->enemyCheckDebounceTime)
        {
                NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 1000);
                NPC_CheckEnemy(qtrue, qfalse);
                if(NPC->enemy)
                {//FIXME: do anger script
                        NPCInfo->goalEntity = NPC->enemy;
//                      NAV_ClearLastRoute(NPC);
                        NPCInfo->behaviorState = BS_RUN_AND_SHOOT;
                        NPCInfo->tempBehavior = BS_DEFAULT;
                        NPC_AngerSound();
                        return;
                }
        }

        NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );

        if(NPCInfo->stats.vigilance <= 1.0 && NPCInfo->eventOwner)
        {
                VectorCopy(NPCInfo->eventOwner->r.currentOrigin, NPCInfo->investigateGoal);
        }

        saveGoal = NPCInfo->goalEntity;
        if(     level.time > NPCInfo->walkDebounceTime )
        {
                vec3_t  vec;

                VectorSubtract(NPCInfo->investigateGoal, NPC->r.currentOrigin, vec);
                vec[2] = 0;
                if(VectorLength(vec) > 64)
                {
                        if(Q_irand(0, 100) < NPCInfo->investigateCount)
                        {//take a full step
                                //NPCInfo->walkDebounceTime = level.time + 1400;
                                //actually finds length of my BOTH_WALK anim
                                NPCInfo->walkDebounceTime = PM_AnimLength( NPC->client->clientInfo.animFileIndex, BOTH_WALK1 );
                        }
                }
        }

        if(     level.time < NPCInfo->walkDebounceTime )
        {//walk toward investigateGoal
                
                /*
                NPCInfo->goalEntity = NPCInfo->tempGoal;
//              NAV_ClearLastRoute(NPC);
                VectorCopy(NPCInfo->investigateGoal, NPCInfo->tempGoal->r.currentOrigin);
                */

/*              NPC_SetMoveGoal( NPC, NPCInfo->investigateGoal, 16, qtrue );

                NPC_MoveToGoal( qtrue );

                //FIXME: walk2?
                NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_WALK1,SETANIM_FLAG_NORMAL);

                ucmd.buttons |= BUTTON_WALKING;
        }
        else
        {

                NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);

                if(NPCInfo->hlookCount > 30)
                {
                        if(Q_irand(0, 10) > 7) 
                        {
                                NPCInfo->hlookCount = 0;
                        }
                }
                else if(NPCInfo->hlookCount < -30)
                {
                        if(Q_irand(0, 10) > 7) 
                        {
                                NPCInfo->hlookCount = 0;
                        }
                }
                else if(NPCInfo->hlookCount == 0)
                {
                        NPCInfo->hlookCount = Q_irand(-1, 1);
                }
                else if(Q_irand(0, 10) > 7) 
                {
                        if(NPCInfo->hlookCount > 0)
                        {
                                NPCInfo->hlookCount++;
                        }
                        else//lookCount < 0
                        {
                                NPCInfo->hlookCount--;
                        }
                }

                if(NPCInfo->vlookCount >= 15)
                {
                        if(Q_irand(0, 10) > 7) 
                        {
                                NPCInfo->vlookCount = 0;
                        }
                }
                else if(NPCInfo->vlookCount <= -15)
                {
                        if(Q_irand(0, 10) > 7) 
                        {
                                NPCInfo->vlookCount = 0;
                        }
                }
                else if(NPCInfo->vlookCount == 0)
                {
                        NPCInfo->vlookCount = Q_irand(-1, 1);
                }
                else if(Q_irand(0, 10) > 8) 
                {
                        if(NPCInfo->vlookCount > 0)
                        {
                                NPCInfo->vlookCount++;
                        }
                        else//lookCount < 0
                        {
                                NPCInfo->vlookCount--;
                        }
                }

                //turn toward investigateGoal
                CalcEntitySpot( NPC, SPOT_HEAD, spot );
                VectorSubtract(NPCInfo->investigateGoal, spot, invDir);
                VectorNormalize(invDir);
                vectoangles(invDir, invAngles);
                NPCInfo->desiredYaw = AngleNormalize360(invAngles[YAW] + NPCInfo->hlookCount);
                NPCInfo->desiredPitch = AngleNormalize360(invAngles[PITCH] + NPCInfo->hlookCount);
        }

        NPC_UpdateAngles(qtrue, qtrue);

        NPCInfo->goalEntity = saveGoal;
//      NAV_ClearLastRoute(NPC);

        if(level.time > NPCInfo->investigateDebounceTime)
        {
                NPCInfo->tempBehavior = BS_DEFAULT;
        }

        NPC_CheckSoundEvents();
        */
}

qboolean NPC_CheckInvestigate( int alertEventNum )
{
        gentity_t       *owner = level.alertEvents[alertEventNum].owner;
        int             invAdd = level.alertEvents[alertEventNum].level;
        vec3_t  soundPos;
        float   soundRad = level.alertEvents[alertEventNum].radius;
        float   earshot = NPCInfo->stats.earshot;

        VectorCopy( level.alertEvents[alertEventNum].position, soundPos );

        //NOTE: Trying to preserve previous investigation behavior
        if ( !owner )
        {
                return qfalse;
        }

        if ( owner->s.eType != ET_PLAYER && owner->s.eType != ET_NPC && owner == NPCInfo->goalEntity ) 
        {
                return qfalse;
        }

        if ( owner->s.eFlags & EF_NODRAW ) 
        {
                return qfalse;
        }

        if ( owner->flags & FL_NOTARGET ) 
        {
                return qfalse;
        }

        if ( soundRad < earshot )
        {
                return qfalse;
        }

        //if(!trap_InPVSIgnorePortals(ent->r.currentOrigin, NPC->r.currentOrigin))//should we be able to hear through areaportals?
        if ( !trap_InPVS( soundPos, NPC->r.currentOrigin ) )
        {//can hear through doors?
                return qfalse;
        }

        if ( owner->client && owner->client->playerTeam && NPC->client->playerTeam && owner->client->playerTeam != NPC->client->playerTeam )
        {
                if( (float)NPCInfo->investigateCount >= (NPCInfo->stats.vigilance*200) && owner )
                {//If investigateCount == 10, just take it as enemy and go
                        if ( ValidEnemy( owner ) )
                        {//FIXME: run angerscript
                                G_SetEnemy( NPC, owner );
                                NPCInfo->goalEntity = NPC->enemy;
                                NPCInfo->goalRadius = 12;
                                NPCInfo->behaviorState = BS_HUNT_AND_KILL;
                                return qtrue;
                        }
                }
                else
                {
                        NPCInfo->investigateCount += invAdd;
                }
                //run awakescript
                G_ActivateBehavior(NPC, BSET_AWAKE);

                /*
                if ( Q_irand(0, 10) > 7 )
                {
                        NPC_AngerSound();
                }
                */

                //NPCInfo->hlookCount = NPCInfo->vlookCount = 0;
                NPCInfo->eventOwner = owner;
                VectorCopy( soundPos, NPCInfo->investigateGoal );
                if ( NPCInfo->investigateCount > 20 )
                {
                        NPCInfo->investigateDebounceTime = level.time + 10000;
                }
                else
                {
                        NPCInfo->investigateDebounceTime = level.time + (NPCInfo->investigateCount*500);
                }
                NPCInfo->tempBehavior = BS_INVESTIGATE;
                return qtrue;
        }

        return qfalse;
}


/*
void NPC_BSSleep( void ) 
*/
void NPC_BSSleep( void ) 
{
        int alertEvent = NPC_CheckAlertEvents( qtrue, qfalse, -1, qfalse, AEL_MINOR );

        //There is an event to look at
        if ( alertEvent >= 0 )
        {
                G_ActivateBehavior(NPC, BSET_AWAKE);
                return;
        }

        /*
        if ( level.time > NPCInfo->enemyCheckDebounceTime )
        {
                if ( NPC_CheckSoundEvents() != -1 )
                {//only 1 alert per second per 0.1 of vigilance
                        NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 10000);
                        G_ActivateBehavior(NPC, BSET_AWAKE);
                }
        }
        */
}

extern qboolean NPC_MoveDirClear( int forwardmove, int rightmove, qboolean reset );
void NPC_BSFollowLeader (void)
{
        vec3_t          vec;
        float           leaderDist;
        visibility_t    leaderVis;
        int                     curAnim;

        if ( !NPC->client->leader )
        {//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 ( !NPC->enemy  )
        {//no enemy, find one
                NPC_CheckEnemy( NPCInfo->confusionTime<level.time, qfalse, qtrue );//don't find new enemy if this is tempbehav
                if ( NPC->enemy )
                {//just found one
                        NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
                }
                else
                {
                        if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
                        {
                                int eventID = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_MINOR );
                                if ( level.alertEvents[eventID].level >= AEL_SUSPICIOUS && (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
                                        }
                                        else
                                        {
                                                //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)
                                                G_SetEnemy( NPC, level.alertEvents[eventID].owner );
                                                NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
                                                NPCInfo->enemyLastSeenTime = level.time;
                                                TIMER_Set( NPC, "attackDelay", Q_irand( 500, 1000 ) );
                                        }
                                }

                        }
                }
                if ( !NPC->enemy )
                {
                        if ( NPC->client->leader 
                                && NPC->client->leader->enemy 
                                && NPC->client->leader->enemy != NPC
                                && ( (NPC->client->leader->enemy->client&&NPC->client->leader->enemy->client->playerTeam==NPC->client->enemyTeam)
                                        ||(/*NPC->client->leader->enemy->r.svFlags&SVF_NONNPC_ENEMY*/0&&NPC->client->leader->enemy->alliedTeam==NPC->client->enemyTeam) )
                                && NPC->client->leader->enemy->health > 0 )
                        { //rwwFIXMEFIXME: use SVF_NONNPC_ENEMY?
                                G_SetEnemy( NPC, NPC->client->leader->enemy );
                                NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
                                NPCInfo->enemyLastSeenTime = level.time;
                        }
                }
        }
        else 
        {
                if ( NPC->enemy->health <= 0 || (NPC->enemy->flags&FL_NOTARGET) )
                {
                        G_ClearEnemy( NPC );
                        if ( NPCInfo->enemyCheckDebounceTime > level.time + 1000 )
                        {
                                NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 1000, 2000 );
                        }
                }
                else if ( NPC->client->ps.weapon && NPCInfo->enemyCheckDebounceTime < level.time )
                {
                        NPC_CheckEnemy( (NPCInfo->confusionTime<level.time||NPCInfo->tempBehavior!=BS_FOLLOW_LEADER), qfalse, qtrue );//don't find new enemy if this is tempbehav
                }
        }
        
        if ( NPC->enemy && NPC->client->ps.weapon )
        {//If have an enemy, face him and fire
                if ( NPC->client->ps.weapon == WP_SABER )//|| NPCInfo->confusionTime>level.time )
                {//lightsaber user or charmed enemy
                        if ( NPCInfo->tempBehavior != BS_FOLLOW_LEADER )
                        {//not already in a temp bState
                                //go after the guy
                                NPCInfo->tempBehavior = BS_HUNT_AND_KILL;
                                NPC_UpdateAngles(qtrue, qtrue);
                                return;
                        }
                }

                enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV|CHECK_SHOOT );//CHECK_360|CHECK_PVS|
                if ( enemyVisibility > VIS_PVS )
                {//face
                        vec3_t  enemy_org, muzzle, delta, angleToEnemy;
                        float   distanceToEnemy;

                        CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
                        NPC_AimWiggle( enemy_org );

                        CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
                        
                        VectorSubtract( enemy_org, muzzle, delta);
                        vectoangles( delta, angleToEnemy );
                        distanceToEnemy = VectorNormalize( delta );

                        NPCInfo->desiredYaw = angleToEnemy[YAW];
                        NPCInfo->desiredPitch = angleToEnemy[PITCH];
                        NPC_UpdateFiringAngles( qtrue, qtrue );

                        if ( enemyVisibility >= VIS_SHOOT )
                        {//shoot
                                NPC_AimAdjust( 2 );
                                if ( NPC_GetHFOVPercentage( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.hfov ) > 0.6f 
                                        && NPC_GetHFOVPercentage( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.vfov ) > 0.5f )
                                {//actually withing our front cone
                                        WeaponThink( qtrue );
                                }
                        }
                        else
                        {
                                NPC_AimAdjust( 1 );
                        }
                        
                        //NPC_CheckCanAttack(1.0, qfalse);
                }
                else
                {
                        NPC_AimAdjust( -1 );
                }
        }
        else
        {//FIXME: combine with vector calc below
                vec3_t  head, leaderHead, delta, angleToLeader;

                CalcEntitySpot( NPC->client->leader, SPOT_HEAD, leaderHead );
                CalcEntitySpot( NPC, SPOT_HEAD, head );
                VectorSubtract (leaderHead, head, delta);
                vectoangles ( delta, angleToLeader );
                VectorNormalize(delta);
                NPC->NPC->desiredYaw = angleToLeader[YAW];
                NPC->NPC->desiredPitch = angleToLeader[PITCH];
                
                NPC_UpdateAngles(qtrue, qtrue);
        }

        //leader visible?
        leaderVis = NPC_CheckVisibility( NPC->client->leader, CHECK_PVS|CHECK_360|CHECK_SHOOT );//                      ent->e_UseFunc = useF_NULL;


        //Follow leader, stay within visibility and a certain distance, maintain a distance from.
        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 leader if we're in a full-body attack anim
                //FIXME, use IdealDistance to determine if we need to close distance
                float   followDist = 96.0f;//FIXME:  If there are enmies, make this larger?
                float   backupdist, walkdist, minrundist;
                float   leaderHDist;

                if ( NPCInfo->followDist )
                {
                        followDist = NPCInfo->followDist;
                }
                backupdist = followDist/2.0f;
                walkdist = followDist*0.83;
                minrundist = followDist*1.33;

                VectorSubtract(NPC->client->leader->r.currentOrigin, NPC->r.currentOrigin, vec);
                leaderDist = VectorLength( vec );//FIXME: make this just nav distance?
                //never get within their radius horizontally
                vec[2] = 0;
                leaderHDist = VectorLength( vec );
                if( leaderHDist > backupdist && (leaderVis != VIS_SHOOT || leaderDist > walkdist) )
                {//We should close in?
                        NPCInfo->goalEntity = NPC->client->leader;

                        NPC_SlideMoveToGoal();
                        if ( leaderVis == VIS_SHOOT && leaderDist < minrundist )
                        {
                                ucmd.buttons |= BUTTON_WALKING;
                        }
                }
                else if ( leaderDist < backupdist )
                {//We should back off?
                        NPCInfo->goalEntity = NPC->client->leader;
                        NPC_SlideMoveToGoal();

                        //reversing direction
                        ucmd.forwardmove = -ucmd.forwardmove;
                        ucmd.rightmove   = -ucmd.rightmove;
                        VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
                }//otherwise, stay where we are
                //check for do not enter and stop if there's one there...
                if ( ucmd.forwardmove || ucmd.rightmove || VectorCompare( vec3_origin, NPC->client->ps.moveDir ) )
                {
                        NPC_MoveDirClear( ucmd.forwardmove, ucmd.rightmove, qtrue );
                }
        }
}
#define APEX_HEIGHT             200.0f
#define PARA_WIDTH              (sqrt(APEX_HEIGHT)+sqrt(APEX_HEIGHT))
#define JUMP_SPEED              200.0f
void NPC_BSJump (void)
{
        vec3_t          dir, angles, p1, p2, apex;
        float           time, height, forward, z, xy, dist, yawError, apexHeight;

        if( !NPCInfo->goalEntity )
        {//Should have task completed the navgoal
                return;
        }

        if ( NPCInfo->jumpState != JS_JUMPING && NPCInfo->jumpState != JS_LANDING )
        {
                //Face navgoal
                VectorSubtract(NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir);
                vectoangles(dir, angles);
                NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]);
                NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]);
        }

        NPC_UpdateAngles ( qtrue, qtrue );
        yawError = AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw );
        //We don't really care about pitch here

        switch ( NPCInfo->jumpState )
        {
        case JS_FACING:
                if ( yawError < MIN_ANGLE_ERROR )
                {//Facing it, Start crouching
                        NPC_SetAnim(NPC, SETANIM_LEGS, BOTH_CROUCH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
                        NPCInfo->jumpState = JS_CROUCHING;
                }
                break;
        case JS_CROUCHING:
                if ( NPC->client->ps.legsTimer > 0 )
                {//Still playing crouching anim
                        return;
                }

                //Create a parabola

                if ( NPC->r.currentOrigin[2] > NPCInfo->goalEntity->r.currentOrigin[2] )
                {
                        VectorCopy( NPC->r.currentOrigin, p1 );
                        VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p2 );
                }
                else if ( NPC->r.currentOrigin[2] < NPCInfo->goalEntity->r.currentOrigin[2] )
                {
                        VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p1 );
                        VectorCopy( NPC->r.currentOrigin, p2 );
                }
                else
                {
                        VectorCopy( NPC->r.currentOrigin, p1 );
                        VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p2 );
                }

                //z = xy*xy
                VectorSubtract( p2, p1, dir );
                dir[2] = 0;

                //Get xy and z diffs
                xy = VectorNormalize( dir );
                z = p1[2] - p2[2];

                apexHeight = APEX_HEIGHT/2;
                /*
                //Determine most desirable apex height
                apexHeight = (APEX_HEIGHT * PARA_WIDTH/xy) + (APEX_HEIGHT * z/128);
                if ( apexHeight < APEX_HEIGHT * 0.5 )
                {
                        apexHeight = APEX_HEIGHT*0.5;
                }
                else if ( apexHeight > APEX_HEIGHT * 2 )
                {
                        apexHeight = APEX_HEIGHT*2;
                }
                */

                //FIXME: length of xy will change curve of parabola, need to account for this
                //somewhere... PARA_WIDTH
                
                z = (sqrt(apexHeight + z) - sqrt(apexHeight));

                assert(z >= 0);

//              Com_Printf("apex is %4.2f percent from p1: ", (xy-z)*0.5/xy*100.0f);

                xy -= z;
                xy *= 0.5;
                
                assert(xy > 0);

                VectorMA( p1, xy, dir, apex );
                apex[2] += apexHeight;
        
                VectorCopy(apex, NPC->pos1);
                
                //Now we have the apex, aim for it
                height = apex[2] - NPC->r.currentOrigin[2];
                time = sqrt( height / ( .5 * NPC->client->ps.gravity ) );
                if ( !time ) 
                {
//                      Com_Printf("ERROR no time in jump\n");
                        return;
                }

                // set s.origin2 to the push velocity
                VectorSubtract ( apex, NPC->r.currentOrigin, NPC->client->ps.velocity );
                NPC->client->ps.velocity[2] = 0;
                dist = VectorNormalize( NPC->client->ps.velocity );

                forward = dist / time;
                VectorScale( NPC->client->ps.velocity, forward, NPC->client->ps.velocity );

                NPC->client->ps.velocity[2] = time * NPC->client->ps.gravity;

//              Com_Printf( "%s jumping %s, gravity at %4.0f percent\n", NPC->targetname, vtos(NPC->client->ps.velocity), NPC->client->ps.gravity/8.0f );

                NPC->flags |= FL_NO_KNOCKBACK;
                NPCInfo->jumpState = JS_JUMPING;
                //FIXME: jumpsound?
                break;
        case JS_JUMPING:

                if ( showBBoxes )
                {
                        VectorAdd(NPC->r.mins, NPC->pos1, p1);
                        VectorAdd(NPC->r.maxs, NPC->pos1, p2);
                        G_Cube( p1, p2, NPCDEBUG_BLUE, 0.5 );
                }

                if ( NPC->s.groundEntityNum != ENTITYNUM_NONE)
                {//Landed, start landing anim
                        //FIXME: if the 
                        VectorClear(NPC->client->ps.velocity);
                        NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_LAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
                        NPCInfo->jumpState = JS_LANDING;
                        //FIXME: landsound?
                }
                else if ( NPC->client->ps.legsTimer > 0 )
                {//Still playing jumping anim
                        //FIXME: apply jump velocity here, a couple frames after start, not right away
                        return;
                }
                else
                {//still in air, but done with jump anim, play inair anim
                        NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_INAIR1, SETANIM_FLAG_OVERRIDE);
                }
                break;
        case JS_LANDING:
                if ( NPC->client->ps.legsTimer > 0 )
                {//Still playing landing anim
                        return;
                }
                else
                {
                        NPCInfo->jumpState = JS_WAITING;

                        
                        //task complete no matter what...  
                        NPC_ClearGoal();
                        NPCInfo->goalTime = level.time;
                        NPCInfo->aiFlags &= ~NPCAI_MOVING;
                        ucmd.forwardmove = 0;
                        NPC->flags &= ~FL_NO_KNOCKBACK;
                        //Return that the goal was reached
                        trap_ICARUS_TaskIDComplete( NPC, TID_MOVE_NAV );
                        
                        //Or should we keep jumping until reached goal?
                        
                        /*
                        NPCInfo->goalEntity = UpdateGoal();
                        if ( !NPCInfo->goalEntity )
                        {
                                NPC->flags &= ~FL_NO_KNOCKBACK;
                                Q3_TaskIDComplete( NPC, TID_MOVE_NAV );
                        }
                        */
                        
                }
                break;
        case JS_WAITING:
        default:
                NPCInfo->jumpState = JS_FACING;
                break;
        }
}

void NPC_BSRemove (void)
{
        NPC_UpdateAngles ( qtrue, qtrue );
        if( !trap_InPVS( NPC->r.currentOrigin, g_entities[0].r.currentOrigin ) )//FIXME: use cg.vieworg?
        { //rwwFIXMEFIXME: Care about all clients instead of just 0?
                G_UseTargets2( NPC, NPC, NPC->target3 );
                NPC->s.eFlags |= EF_NODRAW;
                NPC->s.eType = ET_INVISIBLE;
                NPC->r.contents = 0;
                NPC->health = 0;
                NPC->targetname = NULL;

                //Disappear in half a second
                NPC->think = G_FreeEntity;
                NPC->nextthink = level.time + FRAMETIME;
        }//FIXME: else allow for out of FOV???
}

void NPC_BSSearch (void)
{
        NPC_CheckEnemy(qtrue, qfalse, qtrue);
        //Look for enemies, if find one:
        if ( NPC->enemy )
        {
                if( NPCInfo->tempBehavior == BS_SEARCH )
                {//if tempbehavior, set tempbehavior to default
                        NPCInfo->tempBehavior = BS_DEFAULT;
                }
                else
                {//if bState, change to run and shoot
                        NPCInfo->behaviorState = BS_HUNT_AND_KILL;
                        NPC_BSRunAndShoot();
                }
                return;
        }

        //FIXME: what if our goalEntity is not NULL and NOT our tempGoal - they must
        //want us to do something else?  If tempBehavior, just default, else set
        //to run and shoot...?

        //FIXME: Reimplement

        if ( !NPCInfo->investigateDebounceTime )
        {//On our way to a tempGoal
                float   minGoalReachedDistSquared = 32*32;
                vec3_t  vec;

                //Keep moving toward our tempGoal
                NPCInfo->goalEntity = NPCInfo->tempGoal;

                VectorSubtract ( NPCInfo->tempGoal->r.currentOrigin, NPC->r.currentOrigin, vec);
                if ( vec[2] < 24 )
                {
                        vec[2] = 0;
                }

                if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
                {
                        /*
                        //FIXME: can't get the radius...
                        float   wpRadSq = waypoints[NPCInfo->tempGoal->waypoint].radius * waypoints[NPCInfo->tempGoal->waypoint].radius;
                        if ( minGoalReachedDistSquared > wpRadSq )
                        {
                                minGoalReachedDistSquared = wpRadSq;
                        }
                        */

                        minGoalReachedDistSquared = 32*32;//12*12;
                }

                if ( VectorLengthSquared( vec ) < minGoalReachedDistSquared )
                {
                        //Close enough, just got there
                        NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );

                        if ( ( NPCInfo->homeWp == WAYPOINT_NONE ) || ( NPC->waypoint == WAYPOINT_NONE ) )
                        {
                                //Heading for or at an invalid waypoint, get out of this bState
                                if( NPCInfo->tempBehavior == BS_SEARCH )
                                {//if tempbehavior, set tempbehavior to default
                                        NPCInfo->tempBehavior = BS_DEFAULT;
                                }
                                else
                                {//if bState, change to stand guard
                                        NPCInfo->behaviorState = BS_STAND_GUARD;
                                        NPC_BSRunAndShoot();
                                }
                                return;
                        }

                        if ( NPC->waypoint == NPCInfo->homeWp )
                        {
                                //Just Reached our homeWp, if this is the first time, run your lostenemyscript
                                if ( NPCInfo->aiFlags & NPCAI_ENROUTE_TO_HOMEWP )
                                {
                                        NPCInfo->aiFlags &= ~NPCAI_ENROUTE_TO_HOMEWP;
                                        G_ActivateBehavior( NPC, BSET_LOSTENEMY );
                                }

                        }

                        //Com_Printf("Got there.\n");
                        //Com_Printf("Looking...");
                        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);
                        }
                        NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
                }
                else
                {
                        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 = trap_Nav_GetNodeNumEdges( NPCInfo->tempGoal->waypoint );

                                        if ( numEdges != WAYPOINT_NONE )
                                        {
                                                int branchNum = Q_irand( 0, numEdges - 1 );

                                                vec3_t  branchPos, lookDir;

                                                int nextWp = trap_Nav_GetNodeEdge( NPCInfo->tempGoal->waypoint, branchNum );
                                                trap_Nav_GetNodePosition( nextWp, branchPos );

                                                VectorSubtract( branchPos, NPCInfo->tempGoal->r.currentOrigin, lookDir );
                                                NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + flrand( -45, 45 ) );
                                        }

                                        //pick an angle +-45 degrees off of the dir of a random branch
                                        //from NPCInfo->tempGoal->waypoint
                                        //int branch = Q_irand( 0, (waypoints[NPCInfo->tempGoal->waypoint].numNeighbors - 1) );
                                        //int   nextWp = waypoints[NPCInfo->tempGoal->waypoint].nextWaypoint[branch][NPC->client->moveType];
                                        //vec3_t        lookDir;

                                        //VectorSubtract( waypoints[nextWp].origin, NPCInfo->tempGoal->r.currentOrigin, lookDir );
                                        //Look in that direction +- 45 degrees
                                        //NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + Q_flrand( -45, 45 ) );
                                }
                        }
                        //Com_Printf(".");
                }
                else
                {//Just finished waiting
                        NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
                        
                        if ( NPC->waypoint == NPCInfo->homeWp )
                        {
                                int     numEdges = trap_Nav_GetNodeNumEdges( NPCInfo->tem