codemp/game/NPC.c

Go to the documentation of this file.

//
// NPC.cpp - generic functions
//
#include "b_local.h"
#include "anims.h"
#include "say.h"
#include "../icarus/Q3_Interface.h"

extern vec3_t playerMins;
extern vec3_t playerMaxs;
//extern void PM_SetAnimFinal(int *torsoAnim,int *legsAnim,int type,int anim,int priority,int *torsoAnimTimer,int *legsAnimTimer,gentity_t *gent);
extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
extern void NPC_BSNoClip ( void );
extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
extern void NPC_ApplyRoff (void);
extern void NPC_TempLookTarget ( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
extern void NPC_CheckPlayerAim ( void );
extern void NPC_CheckAllClear ( void );
extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
extern qboolean NPC_CheckLookTarget( gentity_t *self );
extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
extern void Mark1_dying( gentity_t *self );
extern void NPC_BSCinematic( void );
extern int GetTime ( int lastTime );
extern void NPC_BSGM_Default( void );
extern void NPC_CheckCharmed( void );
extern qboolean Boba_Flying( gentity_t *self );

extern vmCvar_t         g_saberRealisticCombat;

//Local Variables
gentity_t               *NPC;
gNPC_t                  *NPCInfo;
gclient_t               *client;
usercmd_t               ucmd;
visibility_t    enemyVisibility;

void NPC_SetAnim(gentity_t      *ent,int type,int anim,int priority);
void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope );
extern void GM_Dying( gentity_t *self );

extern int eventClearTime;

void CorpsePhysics( gentity_t *self )
{
        // run the bot through the server like it was a real client
        memset( &ucmd, 0, sizeof( ucmd ) );
        ClientThink( self->s.number, &ucmd );
        //VectorCopy( self->s.origin, self->s.origin2 );
        //rww - don't get why this is happening.
        
        if ( self->client->NPC_class == CLASS_GALAKMECH )
        {
                GM_Dying( self );
        }
        //FIXME: match my pitch and roll for the slope of my groundPlane
        if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE && !(self->s.eFlags&EF_DISINTEGRATION) )
        {//on the ground
                //FIXME: check 4 corners
                pitch_roll_for_slope( self, NULL );
        }

        if ( eventClearTime == level.time + ALERT_CLEAR_TIME )
        {//events were just cleared out so add me again
                if ( !(self->client->ps.eFlags&EF_NODRAW) )
                {
                        AddSightEvent( self->enemy, self->r.currentOrigin, 384, AEL_DISCOVERED, 0.0f );
                }
        }

        if ( level.time - self->s.time > 3000 )
        {//been dead for 3 seconds
                if ( g_dismember.integer < 11381138 && !g_saberRealisticCombat.integer )
                {//can't be dismembered once dead
                        if ( self->client->NPC_class != CLASS_PROTOCOL )
                        {
                        //      self->client->dismembered = qtrue;
                        }
                }
        }

        //if ( level.time - self->s.time > 500 )
        if (self->client->respawnTime < (level.time+500))
        {//don't turn "nonsolid" until about 1 second after actual death

                if (self->client->ps.eFlags & EF_DISINTEGRATION)
                {
                        self->r.contents = 0;
                }
                else if ((self->client->NPC_class != CLASS_MARK1) && (self->client->NPC_class != CLASS_INTERROGATOR))   // The Mark1 & Interrogator stays solid.
                {
                        self->r.contents = CONTENTS_CORPSE;
                        //self->r.maxs[2] = -8;
                }

                if ( self->message )
                {
                        self->r.contents |= CONTENTS_TRIGGER;
                }
        }
}

/*
----------------------------------------
NPC_RemoveBody

Determines when it's ok to ditch the corpse
----------------------------------------
*/
#define REMOVE_DISTANCE         128
#define REMOVE_DISTANCE_SQR (REMOVE_DISTANCE * REMOVE_DISTANCE)

void NPC_RemoveBody( gentity_t *self )
{
        CorpsePhysics( self );

        self->nextthink = level.time + FRAMETIME;

        if ( self->NPC->nextBStateThink <= level.time )
        {
                trap_ICARUS_MaintainTaskManager(self->s.number);
        }
        self->NPC->nextBStateThink = level.time + FRAMETIME;

        if ( self->message )
        {//I still have a key
                return;
        }

        // I don't consider this a hack, it's creative coding . . . 
        // I agree, very creative... need something like this for ATST and GALAKMECH too!
        if (self->client->NPC_class == CLASS_MARK1)
        {
                Mark1_dying( self );
        }

        // Since these blow up, remove the bounding box.
        if ( self->client->NPC_class == CLASS_REMOTE 
                || self->client->NPC_class == CLASS_SENTRY
                || self->client->NPC_class == CLASS_PROBE
                || self->client->NPC_class == CLASS_INTERROGATOR
                || self->client->NPC_class == CLASS_PROBE
                || self->client->NPC_class == CLASS_MARK2 )
        {
                //if ( !self->taskManager || !self->taskManager->IsRunning() )
                if (!trap_ICARUS_IsRunning(self->s.number))
                {
                        if ( !self->activator || !self->activator->client || !(self->activator->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
                        {//not being held by a Rancor
                                G_FreeEntity( self );
                        }
                }
                return;
        }

        //FIXME: don't ever inflate back up?
        self->r.maxs[2] = self->client->renderInfo.eyePoint[2] - self->r.currentOrigin[2] + 4;
        if ( self->r.maxs[2] < -8 )
        {
                self->r.maxs[2] = -8;
        }

        if ( self->client->NPC_class == CLASS_GALAKMECH )
        {//never disappears
                return;
        }
        if ( self->NPC && self->NPC->timeOfDeath <= level.time )
        {
                self->NPC->timeOfDeath = level.time + 1000;
                // Only do all of this nonsense for Scav boys ( and girls )
        //              || self->client->playerTeam == NPCTEAM_HIROGEN || self->client->playerTeam == NPCTEAM_MALON )
                // should I check NPC_class here instead of TEAM ? - dmv
                if( self->client->playerTeam == NPCTEAM_ENEMY || self->client->NPC_class == CLASS_PROTOCOL )
                {
                        self->nextthink = level.time + FRAMETIME; // try back in a second

                        /*
                        if ( DistanceSquared( g_entities[0].r.currentOrigin, self->r.currentOrigin ) <= REMOVE_DISTANCE_SQR )
                        {
                                return;
                        }

                        if ( (InFOV( self, &g_entities[0], 110, 90 )) ) // generous FOV check
                        {
                                if ( (NPC_ClearLOS2( &g_entities[0], self->r.currentOrigin )) )
                                {
                                        return;
                                }
                        }
                        */
                        //Don't care about this for MP I guess.
                }

                //FIXME: there are some conditions - such as heavy combat - in which we want
                //                      to remove the bodies... but in other cases it's just weird, like
                //                      when they're right behind you in a closed room and when they've been
                //                      placed as dead NPCs by a designer...
                //                      For now we just assume that a corpse with no enemy was 
                //                      placed in the map as a corpse
                if ( self->enemy )
                {
                        //if ( !self->taskManager || !self->taskManager->IsRunning() )
                        if (!trap_ICARUS_IsRunning(self->s.number))
                        {
                                if ( !self->activator || !self->activator->client || !(self->activator->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
                                {//not being held by a Rancor
                                        if ( self->client && self->client->ps.saberEntityNum > 0 && self->client->ps.saberEntityNum < ENTITYNUM_WORLD )
                                        {
                                                gentity_t *saberent = &g_entities[self->client->ps.saberEntityNum];
                                                if ( saberent )
                                                {
                                                        G_FreeEntity( saberent );
                                                }
                                        }
                                        G_FreeEntity( self );
                                }
                        }
                }
        }
}

/*
----------------------------------------
NPC_RemoveBody

Determines when it's ok to ditch the corpse
----------------------------------------
*/

int BodyRemovalPadTime( gentity_t *ent )
{
        int     time;

        if ( !ent || !ent->client )
                return 0;
/*
        switch ( ent->client->playerTeam )
        {
        case NPCTEAM_KLINGON:   // no effect, we just remove them when the player isn't looking
        case NPCTEAM_SCAVENGERS:
        case NPCTEAM_HIROGEN:
        case NPCTEAM_MALON:
        case NPCTEAM_IMPERIAL:
        case NPCTEAM_STARFLEET:
                time = 10000; // 15 secs.
                break;

        case NPCTEAM_BORG:
                time = 2000;
                break;

        case NPCTEAM_STASIS:
                return qtrue;
                break;

        case NPCTEAM_FORGE:
                time = 1000;
                break;

        case NPCTEAM_BOTS:
//              if (!Q_stricmp( ent->NPC_type, "mouse" ))
//              {
                        time = 0;
//              }
//              else
//              {
//                      time = 10000;
//              }
                break;

        case NPCTEAM_8472:
                time = 2000;
                break;

        default:
                // never go away
                time = Q3_INFINITE;
                break;
        }
*/
        // team no longer indicates species/race, so in this case we'd use NPC_class, but
        switch( ent->client->NPC_class )
        {
        case CLASS_MOUSE:
        case CLASS_GONK:
        case CLASS_R2D2:
        case CLASS_R5D2:
        //case CLASS_PROTOCOL:
        case CLASS_MARK1:
        case CLASS_MARK2:
        case CLASS_PROBE:
        case CLASS_SEEKER:
        case CLASS_REMOTE:
        case CLASS_SENTRY:
        case CLASS_INTERROGATOR:
                time = 0;
                break;
        default:
                // never go away
        //      time = Q3_INFINITE;
                // for now I'm making default 10000
                time = 10000;
                break;

        }
        

        return time;
}


/*
----------------------------------------
NPC_RemoveBodyEffect

Effect to be applied when ditching the corpse
----------------------------------------
*/

static void NPC_RemoveBodyEffect(void)
{
//      vec3_t          org;
//      gentity_t       *tent;

        if ( !NPC || !NPC->client || (NPC->s.eFlags & EF_NODRAW) )
                return;
/*
        switch(NPC->client->playerTeam)
        {
        case NPCTEAM_STARFLEET:
                //FIXME: Starfleet beam out
                break;

        case NPCTEAM_BOTS:
//              VectorCopy( NPC->r.currentOrigin, org );
//              org[2] -= 16;
//              tent = G_TempEntity( org, EV_BOT_EXPLODE );
//              tent->owner = NPC;

                break;

        default:
                break;
        }
*/


        // team no longer indicates species/race, so in this case we'd use NPC_class, but
        
        // stub code
        switch(NPC->client->NPC_class)
        {
        case CLASS_PROBE:
        case CLASS_SEEKER:
        case CLASS_REMOTE:
        case CLASS_SENTRY:
        case CLASS_GONK:
        case CLASS_R2D2:
        case CLASS_R5D2:
        //case CLASS_PROTOCOL:
        case CLASS_MARK1:
        case CLASS_MARK2:
        case CLASS_INTERROGATOR:
        case CLASS_ATST: // yeah, this is a little weird, but for now I'm listing all droids
        //      VectorCopy( NPC->r.currentOrigin, org );
        //      org[2] -= 16;
        //      tent = G_TempEntity( org, EV_BOT_EXPLODE );
        //      tent->owner = NPC;
                break;
        default:
                break;
        }


}


/*
====================================================================
void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope )

MG

This will adjust the pitch and roll of a monster to match
a given slope - if a non-'0 0 0' slope is passed, it will
use that value, otherwise it will use the ground underneath
the monster.  If it doesn't find a surface, it does nothinh\g
and returns.
====================================================================
*/

void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope )
{
        vec3_t  slope;
        vec3_t  nvf, ovf, ovr, startspot, endspot, new_angles = { 0, 0, 0 };
        float   pitch, mod, dot;

        //if we don't have a slope, get one
        if( !pass_slope || VectorCompare( vec3_origin, pass_slope ) )
        {
                trace_t trace;

                VectorCopy( forwhom->r.currentOrigin, startspot );
                startspot[2] += forwhom->r.mins[2] + 4;
                VectorCopy( startspot, endspot );
                endspot[2] -= 300;
                trap_Trace( &trace, forwhom->r.currentOrigin, vec3_origin, vec3_origin, endspot, forwhom->s.number, MASK_SOLID );
//              if(trace_fraction>0.05&&forwhom.movetype==MOVETYPE_STEP)
//                      forwhom.flags(-)FL_ONGROUND;

                if ( trace.fraction >= 1.0 )
                        return;

                if( !( &trace.plane ) )
                        return;

                if ( VectorCompare( vec3_origin, trace.plane.normal ) )
                        return;

                VectorCopy( trace.plane.normal, slope );
        }
        else
        {
                VectorCopy( pass_slope, slope );
        }


        AngleVectors( forwhom->r.currentAngles, ovf, ovr, NULL );

        vectoangles( slope, new_angles );
        pitch = new_angles[PITCH] + 90;
        new_angles[ROLL] = new_angles[PITCH] = 0;

        AngleVectors( new_angles, nvf, NULL, NULL );

        mod = DotProduct( nvf, ovr );

        if ( mod<0 )
                mod = -1;
        else
                mod = 1;

        dot = DotProduct( nvf, ovf );

        if ( forwhom->client )
        {
                float oldmins2;

                forwhom->client->ps.viewangles[PITCH] = dot * pitch;
                forwhom->client->ps.viewangles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
                oldmins2 = forwhom->r.mins[2];
                forwhom->r.mins[2] = -24 + 12 * fabs(forwhom->client->ps.viewangles[PITCH])/180.0f;
                //FIXME: if it gets bigger, move up
                if ( oldmins2 > forwhom->r.mins[2] )
                {//our mins is now lower, need to move up
                        //FIXME: trace?
                        forwhom->client->ps.origin[2] += (oldmins2 - forwhom->r.mins[2]);
                        forwhom->r.currentOrigin[2] = forwhom->client->ps.origin[2];
                        trap_LinkEntity( forwhom );
                }
        }
        else
        {
                forwhom->r.currentAngles[PITCH] = dot * pitch;
                forwhom->r.currentAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
        }
}


/*
----------------------------------------
DeadThink
----------------------------------------
*/
static void DeadThink ( void ) 
{
        trace_t trace;

        //HACKHACKHACKHACKHACK
        //We should really have a seperate G2 bounding box (seperate from the physics bbox) for G2 collisions only
        //FIXME: don't ever inflate back up?
        NPC->r.maxs[2] = NPC->client->renderInfo.eyePoint[2] - NPC->r.currentOrigin[2] + 4;
        if ( NPC->r.maxs[2] < -8 )
        {
                NPC->r.maxs[2] = -8;
        }
        if ( VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
        {//not flying through the air
                if ( NPC->r.mins[0] > -32 )
                {
                        NPC->r.mins[0] -= 1;
                        trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
                        if ( trace.allsolid )
                        {
                                NPC->r.mins[0] += 1;
                        }
                }
                if ( NPC->r.maxs[0] < 32 )
                {
                        NPC->r.maxs[0] += 1;
                        trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
                        if ( trace.allsolid )
                        {
                                NPC->r.maxs[0] -= 1;
                        }
                }
                if ( NPC->r.mins[1] > -32 )
                {
                        NPC->r.mins[1] -= 1;
                        trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
                        if ( trace.allsolid )
                        {
                                NPC->r.mins[1] += 1;
                        }
                }
                if ( NPC->r.maxs[1] < 32 )
                {
                        NPC->r.maxs[1] += 1;
                        trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
                        if ( trace.allsolid )
                        {
                                NPC->r.maxs[1] -= 1;
                        }
                }
        }
        //HACKHACKHACKHACKHACK

        //FIXME: tilt and fall off of ledges?
        //NPC_PostDeathThink();

        /*
        if ( !NPCInfo->timeOfDeath && NPC->client != NULL && NPCInfo != NULL ) 
        {
                //haven't finished death anim yet and were NOT given a specific amount of time to wait before removal
                int                             legsAnim        = NPC->client->ps.legsAnim;
                animation_t             *animations     = knownAnimFileSets[NPC->client->clientInfo.animFileIndex].animations;

                NPC->bounceCount = -1; // This is a cheap hack for optimizing the pointcontents check below

                //ghoul doesn't tell us this anymore
                //if ( NPC->client->renderInfo.legsFrame == animations[legsAnim].firstFrame + (animations[legsAnim].numFrames - 1) )
                {
                        //reached the end of the death anim
                        NPCInfo->timeOfDeath = level.time + BodyRemovalPadTime( NPC );
                }
        }
        else
        */
        {
                //death anim done (or were given a specific amount of time to wait before removal), wait the requisite amount of time them remove
                if ( level.time >= NPCInfo->timeOfDeath + BodyRemovalPadTime( NPC ) )
                {
                        if ( NPC->client->ps.eFlags & EF_NODRAW )
                        {
                                if (!trap_ICARUS_IsRunning(NPC->s.number))
                                //if ( !NPC->taskManager || !NPC->taskManager->IsRunning() )
                                {
                                        NPC->think = G_FreeEntity;
                                        NPC->nextthink = level.time + FRAMETIME;
                                }
                        }
                        else
                        {
                                class_t npc_class;

                                // Start the body effect first, then delay 400ms before ditching the corpse
                                NPC_RemoveBodyEffect();

                                //FIXME: keep it running through physics somehow?
                                NPC->think = NPC_RemoveBody;
                                NPC->nextthink = level.time + FRAMETIME;
                        //      if ( NPC->client->playerTeam == NPCTEAM_FORGE )
                        //              NPCInfo->timeOfDeath = level.time + FRAMETIME * 8;
                        //      else if ( NPC->client->playerTeam == NPCTEAM_BOTS )
                                npc_class = NPC->client->NPC_class;
                                // check for droids
                                if ( npc_class == CLASS_SEEKER || npc_class == CLASS_REMOTE || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
                                         npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 ||
                                         npc_class == CLASS_MARK2 || npc_class == CLASS_SENTRY )//npc_class == CLASS_PROTOCOL ||
                                {
                                        NPC->client->ps.eFlags |= EF_NODRAW;
                                        NPCInfo->timeOfDeath = level.time + FRAMETIME * 8;
                                }
                                else
                                        NPCInfo->timeOfDeath = level.time + FRAMETIME * 4;
                        }
                        return;
                }
        }

        // If the player is on the ground and the resting position contents haven't been set yet...(BounceCount tracks the contents)
        if ( NPC->bounceCount < 0 && NPC->s.groundEntityNum >= 0 )
        {
                // if client is in a nodrop area, make him/her nodraw
                int contents = NPC->bounceCount = trap_PointContents( NPC->r.currentOrigin, -1 );

                if ( ( contents & CONTENTS_NODROP ) ) 
                {
                        NPC->client->ps.eFlags |= EF_NODRAW;
                }
        }

        CorpsePhysics( NPC );
}


/*
===============
SetNPCGlobals

local function to set globals used throughout the AI code
===============
*/
void SetNPCGlobals( gentity_t *ent ) 
{
        NPC = ent;
        NPCInfo = ent->NPC;
        client = ent->client;
        memset( &ucmd, 0, sizeof( usercmd_t ) );
}

gentity_t       *_saved_NPC;
gNPC_t          *_saved_NPCInfo;
gclient_t       *_saved_client;
usercmd_t       _saved_ucmd;

void SaveNPCGlobals(void) 
{
        _saved_NPC = NPC;
        _saved_NPCInfo = NPCInfo;
        _saved_client = client;
        memcpy( &_saved_ucmd, &ucmd, sizeof( usercmd_t ) );
}

void RestoreNPCGlobals(void) 
{
        NPC = _saved_NPC;
        NPCInfo = _saved_NPCInfo;
        client = _saved_client;
        memcpy( &ucmd, &_saved_ucmd, sizeof( usercmd_t ) );
}

//We MUST do this, other funcs were using NPC illegally when "self" wasn't the global NPC
void ClearNPCGlobals( void ) 
{
        NPC = NULL;
        NPCInfo = NULL;
        client = NULL;
}
//===============

extern  qboolean        showBBoxes;
vec3_t NPCDEBUG_RED = {1.0, 0.0, 0.0};
vec3_t NPCDEBUG_GREEN = {0.0, 1.0, 0.0};
vec3_t NPCDEBUG_BLUE = {0.0, 0.0, 1.0};
vec3_t NPCDEBUG_LIGHT_BLUE = {0.3f, 0.7f, 1.0};
extern void G_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
extern void G_Line( vec3_t start, vec3_t end, vec3_t color, float alpha );
extern void G_Cylinder( vec3_t start, vec3_t end, float radius, vec3_t color );

void NPC_ShowDebugInfo (void)
{
        if ( showBBoxes )
        {
                gentity_t       *found = NULL;
                vec3_t          mins, maxs;

                while( (found = G_Find( found, FOFS(classname), "NPC" ) ) != NULL )
                {
                        if ( trap_InPVS( found->r.currentOrigin, g_entities[0].r.currentOrigin ) )
                        {
                                VectorAdd( found->r.currentOrigin, found->r.mins, mins );
                                VectorAdd( found->r.currentOrigin, found->r.maxs, maxs );
                                G_Cube( mins, maxs, NPCDEBUG_RED, 0.25 );
                        }
                }
        }
}

void NPC_ApplyScriptFlags (void)
{
        if ( NPCInfo->scriptFlags & SCF_CROUCHED )
        {
                if ( NPCInfo->charmedTime > level.time && (ucmd.forwardmove || ucmd.rightmove) )
                {//ugh, if charmed and moving, ignore the crouched command
                }
                else
                {
                        ucmd.upmove = -127;
                }
        }

        if(NPCInfo->scriptFlags & SCF_RUNNING)
        {
                ucmd.buttons &= ~BUTTON_WALKING;
        }
        else if(NPCInfo->scriptFlags & SCF_WALKING)
        {
                if ( NPCInfo->charmedTime > level.time && (ucmd.forwardmove || ucmd.rightmove) )
                {//ugh, if charmed and moving, ignore the walking command
                }
                else
                {
                        ucmd.buttons |= BUTTON_WALKING;
                }
        }
/*
        if(NPCInfo->scriptFlags & SCF_CAREFUL)
        {
                ucmd.buttons |= BUTTON_CAREFUL;
        }
*/
        if(NPCInfo->scriptFlags & SCF_LEAN_RIGHT)
        {
                ucmd.buttons |= BUTTON_USE;
                ucmd.rightmove = 127;
                ucmd.forwardmove = 0;
                ucmd.upmove = 0;
        }
        else if(NPCInfo->scriptFlags & SCF_LEAN_LEFT)
        {
                ucmd.buttons |= BUTTON_USE;
                ucmd.rightmove = -127;
                ucmd.forwardmove = 0;
                ucmd.upmove = 0;
        }

        if ( (NPCInfo->scriptFlags & SCF_ALT_FIRE) && (ucmd.buttons & BUTTON_ATTACK) )
        {//Use altfire instead
                ucmd.buttons |= BUTTON_ALT_ATTACK;
        }
}

void Q3_DebugPrint( int level, const char *format, ... );
void NPC_HandleAIFlags (void)
{
        //FIXME: make these flags checks a function call like NPC_CheckAIFlagsAndTimers
        if ( NPCInfo->aiFlags & NPCAI_LOST )
        {//Print that you need help!
                //FIXME: shouldn't remove this just yet if cg_draw needs it
                NPCInfo->aiFlags &= ~NPCAI_LOST;
                
                /*
                if ( showWaypoints )
                {
                        Q3_DebugPrint(WL_WARNING, "%s can't navigate to target %s (my wp: %d, goal wp: %d)\n", NPC->targetname, NPCInfo->goalEntity->targetname, NPC->waypoint, NPCInfo->goalEntity->waypoint );
                }
                */

                if ( NPCInfo->goalEntity && NPCInfo->goalEntity == NPC->enemy )
                {//We can't nav to our enemy
                        //Drop enemy and see if we should search for him
                        NPC_LostEnemyDecideChase();
                }
        }

        //MRJ Request:
        /*
        if ( NPCInfo->aiFlags & NPCAI_GREET_ALLIES && !NPC->enemy )//what if "enemy" is the greetEnt?
        {//If no enemy, look for teammates to greet
                //FIXME: don't say hi to the same guy over and over again.
                if ( NPCInfo->greetingDebounceTime < level.time )
                {//Has been at least 2 seconds since we greeted last
                        if ( !NPCInfo->greetEnt )
                        {//Find a teammate whom I'm facing and who is facing me and within 128
                                NPCInfo->greetEnt = NPC_PickAlly( qtrue, 128, qtrue, qtrue );
                        }

                        if ( NPCInfo->greetEnt && !Q_irand(0, 5) )
                        {//Start greeting someone
                                qboolean        greeted = qfalse;

                                //TODO:  If have a greetscript, run that instead?

                                //FIXME: make them greet back?
                                if( !Q_irand( 0, 2 ) )
                                {//Play gesture anim (press gesture button?)
                                        greeted = qtrue;
                                        NPC_SetAnim( NPC, SETANIM_TORSO, Q_irand( BOTH_GESTURE1, BOTH_GESTURE3 ), SETANIM_FLAG_NORMAL|SETANIM_FLAG_HOLD );
                                        //NOTE: play full-body gesture if not moving?
                                }

                                if( !Q_irand( 0, 2 ) )
                                {//Play random voice greeting sound
                                        greeted = qtrue;
                                        //FIXME: need NPC sound sets

                                        //G_AddVoiceEvent( NPC, Q_irand(EV_GREET1, EV_GREET3), 2000 );
                                }

                                if( !Q_irand( 0, 1 ) )
                                {//set looktarget to them for a second or two
                                        greeted = qtrue;
                                        NPC_TempLookTarget( NPC, NPCInfo->greetEnt->s.number, 1000, 3000 );
                                }

                                if ( greeted )
                                {//Did at least one of the things above
                                        //Don't greet again for 2 - 4 seconds
                                        NPCInfo->greetingDebounceTime = level.time + Q_irand( 2000, 4000 );
                                        NPCInfo->greetEnt = NULL;
                                }
                        }
                }
        }
        */
        //been told to play a victory sound after a delay
        if ( NPCInfo->greetingDebounceTime && NPCInfo->greetingDebounceTime < level.time )
        {
                G_AddVoiceEvent( NPC, Q_irand(EV_VICTORY1, EV_VICTORY3), Q_irand( 2000, 4000 ) );
                NPCInfo->greetingDebounceTime = 0;
        }

        if ( NPCInfo->ffireCount > 0 )
        {
                if ( NPCInfo->ffireFadeDebounce < level.time )
                {
                        NPCInfo->ffireCount--;
                        //Com_Printf( "drop: %d < %d\n", NPCInfo->ffireCount, 3+((2-g_spskill.integer)*2) );
                        NPCInfo->ffireFadeDebounce = level.time + 3000;
                }
        }
        if ( d_patched.integer )
        {//use patch-style navigation
                if ( NPCInfo->consecutiveBlockedMoves > 20 )
                {//been stuck for a while, try again?
                        NPCInfo->consecutiveBlockedMoves = 0;
                }
        }
}

void NPC_AvoidWallsAndCliffs (void)
{
        //...
}

void NPC_CheckAttackScript(void)
{
        if(!(ucmd.buttons & BUTTON_ATTACK))
        {
                return;
        }

        G_ActivateBehavior(NPC, BSET_ATTACK);
}

float NPC_MaxDistSquaredForWeapon (void);
void NPC_CheckAttackHold(void)
{
        vec3_t          vec;

        // If they don't have an enemy they shouldn't hold their attack anim.
        if ( !NPC->enemy )
        {
                NPCInfo->attackHoldTime = 0;
                return;
        }

/*      if ( ( NPC->client->ps.weapon == WP_BORG_ASSIMILATOR ) || ( NPC->client->ps.weapon == WP_BORG_DRILL ) )
        {//FIXME: don't keep holding this if can't hit enemy?

                // If they don't have shields ( been disabled) they shouldn't hold their attack anim.
                if ( !(NPC->NPC->aiFlags & NPCAI_SHIELDS) )
                {
                        NPCInfo->attackHoldTime = 0;
                        return;
                }

                VectorSubtract(NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec);
                if( VectorLengthSquared(vec) > NPC_MaxDistSquaredForWeapon() )
                {
                        NPCInfo->attackHoldTime = 0;
                        PM_SetTorsoAnimTimer(NPC, &NPC->client->ps.torsoAnimTimer, 0);
                }
                else if( NPCInfo->attackHoldTime && NPCInfo->attackHoldTime > level.time )
                {
                        ucmd.buttons |= BUTTON_ATTACK;
                }
                else if ( ( NPCInfo->attackHold ) && ( ucmd.buttons & BUTTON_ATTACK ) )
                {
                        NPCInfo->attackHoldTime = level.time + NPCInfo->attackHold;
                        PM_SetTorsoAnimTimer(NPC, &NPC->client->ps.torsoAnimTimer, NPCInfo->attackHold);
                }
                else
                {
                        NPCInfo->attackHoldTime = 0;
                        PM_SetTorsoAnimTimer(NPC, &NPC->client->ps.torsoAnimTimer, 0);
                }
        }
        else*/
        {//everyone else...?  FIXME: need to tie this into AI somehow?
                VectorSubtract(NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec);
                if( VectorLengthSquared(vec) > NPC_MaxDistSquaredForWeapon() )
                {
                        NPCInfo->attackHoldTime = 0;
                }
                else if( NPCInfo->attackHoldTime && NPCInfo->attackHoldTime > level.time )
                {
                        ucmd.buttons |= BUTTON_ATTACK;
                }
                else if ( ( NPCInfo->attackHold ) && ( ucmd.buttons & BUTTON_ATTACK ) )
                {
                        NPCInfo->attackHoldTime = level.time + NPCInfo->attackHold;
                }
                else
                {
                        NPCInfo->attackHoldTime = 0;
                }
        }
}

/*
void NPC_KeepCurrentFacing(void)

Fills in a default ucmd to keep current angles facing
*/
void NPC_KeepCurrentFacing(void)
{
        if(!ucmd.angles[YAW])
        {
                ucmd.angles[YAW] = ANGLE2SHORT( client->ps.viewangles[YAW] ) - client->ps.delta_angles[YAW];
        }

        if(!ucmd.angles[PITCH])
        {
                ucmd.angles[PITCH] = ANGLE2SHORT( client->ps.viewangles[PITCH] ) - client->ps.delta_angles[PITCH];
        }
}

/*
-------------------------
NPC_BehaviorSet_Charmed
-------------------------
*/

void NPC_BehaviorSet_Charmed( int bState )
{
        switch( bState )
        {
        case BS_FOLLOW_LEADER://# 40: Follow your leader and shoot any enemies you come across
                NPC_BSFollowLeader();
                break;
        case BS_REMOVE:
                NPC_BSRemove();
                break;
        case BS_SEARCH:                 //# 43: Using current waypoint as a base, search the immediate branches of waypoints for enemies
                NPC_BSSearch();
                break;
        case BS_WANDER:                 //# 46: Wander down random waypoint paths
                NPC_BSWander();
                break;
        case BS_FLEE:
                NPC_BSFlee();
                break;
        default:
        case BS_DEFAULT://whatever
                NPC_BSDefault();
                break;
        }
}
/*
-------------------------
NPC_BehaviorSet_Default
-------------------------
*/

void NPC_BehaviorSet_Default( int bState )
{
        switch( bState )
        {
        case BS_ADVANCE_FIGHT://head toward captureGoal, shoot anything that gets in the way
                NPC_BSAdvanceFight ();
                break;
        case BS_SLEEP://Follow a path, looking for enemies
                NPC_BSSleep ();
                break;
        case BS_FOLLOW_LEADER://# 40: Follow your leader and shoot any enemies you come across
                NPC_BSFollowLeader();
                break;
        case BS_JUMP:                   //41: Face navgoal and jump to it.
                NPC_BSJump();
                break;
        case BS_REMOVE:
                NPC_BSRemove();
                break;
        case BS_SEARCH:                 //# 43: Using current waypoint as a base, search the immediate branches of waypoints for enemies
                NPC_BSSearch();
                break;
        case BS_NOCLIP:
                NPC_BSNoClip();
                break;
        case BS_WANDER:                 //# 46: Wander down random waypoint paths
                NPC_BSWander();
                break;
        case BS_FLEE:
                NPC_BSFlee();
                break;
        case BS_WAIT:
                NPC_BSWait();
                break;
        case BS_CINEMATIC:
                NPC_BSCinematic();
                break;
        default:
        case BS_DEFAULT://whatever
                NPC_BSDefault();
                break;
        }
}

/*
-------------------------
NPC_BehaviorSet_Interrogator
-------------------------
*/
void NPC_BehaviorSet_Interrogator( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSInterrogator_Default();
                break;
        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}

void NPC_BSImperialProbe_Attack( void );
void NPC_BSImperialProbe_Patrol( void );
void NPC_BSImperialProbe_Wait(void);

/*
-------------------------
NPC_BehaviorSet_ImperialProbe
-------------------------
*/
void NPC_BehaviorSet_ImperialProbe( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSImperialProbe_Default();
                break;
        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}


void NPC_BSSeeker_Default( void );

/*
-------------------------
NPC_BehaviorSet_Seeker
-------------------------
*/
void NPC_BehaviorSet_Seeker( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSSeeker_Default();
                break; 
        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}

void NPC_BSRemote_Default( void );

/*
-------------------------
NPC_BehaviorSet_Remote
-------------------------
*/
void NPC_BehaviorSet_Remote( int bState )
{
        NPC_BSRemote_Default();
}

void NPC_BSSentry_Default( void );

/*
-------------------------
NPC_BehaviorSet_Sentry
-------------------------
*/
void NPC_BehaviorSet_Sentry( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSSentry_Default();
                break; 
        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}

/*
-------------------------
NPC_BehaviorSet_Grenadier
-------------------------
*/
void NPC_BehaviorSet_Grenadier( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSGrenadier_Default();
                break;

        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}
/*
-------------------------
NPC_BehaviorSet_Sniper
-------------------------
*/
void NPC_BehaviorSet_Sniper( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSSniper_Default();
                break;

        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}
/*
-------------------------
NPC_BehaviorSet_Stormtrooper
-------------------------
*/

void NPC_BehaviorSet_Stormtrooper( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSST_Default();
                break;

        case BS_INVESTIGATE:
                NPC_BSST_Investigate();
                break;

        case BS_SLEEP:
                NPC_BSST_Sleep();
                break;

        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}

/*
-------------------------
NPC_BehaviorSet_Jedi
-------------------------
*/

void NPC_BehaviorSet_Jedi( int bState )
{
        switch( bState )
        {
        case BS_STAND_GUARD:
        case BS_PATROL:
        case BS_STAND_AND_SHOOT:
        case BS_HUNT_AND_KILL:
        case BS_DEFAULT:
                NPC_BSJedi_Default();
                break;

        case BS_FOLLOW_LEADER:
                NPC_BSJedi_FollowLeader();
                break;

        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}

/*
-------------------------
NPC_BehaviorSet_Droid
-------------------------
*/
void NPC_BehaviorSet_Droid( int bState )
{
        switch( bState )
        {
        case BS_DEFAULT:
        case BS_STAND_GUARD:
        case BS_PATROL:
                NPC_BSDroid_Default();
                break;
        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}

/*
-------------------------
NPC_BehaviorSet_Mark1
-------------------------
*/
void NPC_BehaviorSet_Mark1( int bState )
{
        switch( bState )
        {
        case BS_DEFAULT:
        case BS_STAND_GUARD:
        case BS_PATROL:
                NPC_BSMark1_Default();
                break;
        default:
                NPC_BehaviorSet_Default( bState );
                break;
        }
}

<