codemp/game/NPC_AI_Jedi.c

Go to the documentation of this file.

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

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

extern void CG_DrawAlert( vec3_t origin, float rating );
extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
extern void ForceJump( gentity_t *self, usercmd_t *ucmd );
extern vmCvar_t g_saberRealisticCombat;
extern vmCvar_t d_slowmodeath;

void G_StartMatrixEffect( gentity_t *ent )
{ //perhaps write this at some point?

}

#define MAX_VIEW_DIST           2048
#define MAX_VIEW_SPEED          100
#define JEDI_MAX_LIGHT_INTENSITY 64
#define JEDI_MIN_LIGHT_THRESHOLD 10
#define JEDI_MAX_LIGHT_THRESHOLD 50

#define DISTANCE_SCALE          0.25f
//#define       DISTANCE_THRESHOLD      0.075f
#define SPEED_SCALE                     0.25f
#define FOV_SCALE                       0.5f
#define LIGHT_SCALE                     0.25f

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

#define MAX_CHECK_THRESHOLD     1

extern void NPC_ClearLookTarget( gentity_t *self );
extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
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 qboolean NPC_CheckEnemyStealth( void );
extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );

#include "../namespace_begin.h"
extern gitem_t  *BG_FindItemForAmmo( ammo_t ammo );
#include "../namespace_end.h"

extern void ForceThrow( gentity_t *self, qboolean pull );
extern void ForceLightning( gentity_t *self );
extern void ForceHeal( gentity_t *self );
extern void ForceRage( gentity_t *self );
extern void ForceProtect( gentity_t *self );
extern void ForceAbsorb( gentity_t *self );
extern int WP_MissileBlockForBlock( int saberBlock );
extern qboolean G_GetHitLocFromSurfName( gentity_t *ent, const char *surfName, int *hitLoc, vec3_t point, vec3_t dir, vec3_t bladeDir, int mod );
extern qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
extern qboolean WP_ForcePowerAvailable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
extern void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
extern void WP_DeactivateSaber( gentity_t *self, qboolean clearLength ); //clearLength = qfalse
extern void WP_ActivateSaber( gentity_t *self );
//extern void WP_SaberBlock(gentity_t *saber, vec3_t hitloc);

#include "../namespace_begin.h"
extern qboolean PM_SaberInStart( int move );
extern qboolean BG_SaberInSpecialAttack( int anim );
extern qboolean BG_SaberInAttack( int move );
extern qboolean PM_SaberInBounce( int move );
extern qboolean PM_SaberInParry( int move );
extern qboolean PM_SaberInKnockaway( int move );
extern qboolean PM_SaberInBrokenParry( int move );
extern qboolean PM_SaberInDeflect( int move );
extern qboolean BG_SpinningSaberAnim( int anim );
extern qboolean BG_FlippingAnim( int anim );
extern qboolean PM_RollingAnim( int anim );
extern qboolean PM_InKnockDown( playerState_t *ps );
extern qboolean BG_InRoll( playerState_t *ps, int anim );
extern qboolean BG_CrouchAnim( int anim );
#include "../namespace_end.h"

extern qboolean NPC_SomeoneLookingAtMe(gentity_t *ent);

extern int WP_GetVelocityForForceJump( gentity_t *self, vec3_t jumpVel, usercmd_t *ucmd );

extern void G_TestLine(vec3_t start, vec3_t end, int color, int time);

static void Jedi_Aggression( gentity_t *self, int change );
qboolean Jedi_WaitingAmbush( gentity_t *self );

#include "../namespace_begin.h"
extern int bg_parryDebounce[];
#include "../namespace_end.h"

static int      jediSpeechDebounceTime[TEAM_NUM_TEAMS];//used to stop several jedi from speaking all at once
//Local state enums
enum
{
        LSTATE_NONE = 0,
        LSTATE_UNDERFIRE,
        LSTATE_INVESTIGATE,
};

void NPC_ShadowTrooper_Precache( void )
{
        RegisterItem( BG_FindItemForAmmo( AMMO_FORCE ) );
        G_SoundIndex( "sound/chars/shadowtrooper/cloak.wav" );
        G_SoundIndex( "sound/chars/shadowtrooper/decloak.wav" );
}

void Jedi_ClearTimers( gentity_t *ent )
{
        TIMER_Set( ent, "roamTime", 0 );
        TIMER_Set( ent, "chatter", 0 );
        TIMER_Set( ent, "strafeLeft", 0 );
        TIMER_Set( ent, "strafeRight", 0 );
        TIMER_Set( ent, "noStrafe", 0 );
        TIMER_Set( ent, "walking", 0 );
        TIMER_Set( ent, "taunting", 0 );
        TIMER_Set( ent, "parryTime", 0 );
        TIMER_Set( ent, "parryReCalcTime", 0 );
        TIMER_Set( ent, "forceJumpChasing", 0 );
        TIMER_Set( ent, "jumpChaseDebounce", 0 );
        TIMER_Set( ent, "moveforward", 0 );
        TIMER_Set( ent, "moveback", 0 );
        TIMER_Set( ent, "movenone", 0 );
        TIMER_Set( ent, "moveright", 0 );
        TIMER_Set( ent, "moveleft", 0 );
        TIMER_Set( ent, "movecenter", 0 );
        TIMER_Set( ent, "saberLevelDebounce", 0 );
        TIMER_Set( ent, "noRetreat", 0 );
        TIMER_Set( ent, "holdLightning", 0 );
        TIMER_Set( ent, "gripping", 0 );
        TIMER_Set( ent, "draining", 0 );
        TIMER_Set( ent, "noturn", 0 );
}

void Jedi_PlayBlockedPushSound( gentity_t *self )
{
        if ( !self->s.number )
        {
                G_AddVoiceEvent( self, EV_PUSHFAIL, 3000 );
        }
        else if ( self->health > 0 && self->NPC && self->NPC->blockedSpeechDebounceTime < level.time )
        {
                G_AddVoiceEvent( self, EV_PUSHFAIL, 3000 );
                self->NPC->blockedSpeechDebounceTime = level.time + 3000;
        }
}

void Jedi_PlayDeflectSound( gentity_t *self )
{
        if ( !self->s.number )
        {
                G_AddVoiceEvent( self, Q_irand( EV_DEFLECT1, EV_DEFLECT3 ), 3000 );
        }
        else if ( self->health > 0 && self->NPC && self->NPC->blockedSpeechDebounceTime < level.time )
        {
                G_AddVoiceEvent( self, Q_irand( EV_DEFLECT1, EV_DEFLECT3 ), 3000 );
                self->NPC->blockedSpeechDebounceTime = level.time + 3000;
        }
}

void NPC_Jedi_PlayConfusionSound( gentity_t *self )
{
        if ( self->health > 0 )
        {
                if ( self->client && ( self->client->NPC_class == CLASS_TAVION || self->client->NPC_class == CLASS_DESANN ) )
                {
                        G_AddVoiceEvent( self, Q_irand( EV_CONFUSE1, EV_CONFUSE3 ), 2000 );
                }
                else if ( Q_irand( 0, 1 ) )
                {
                        G_AddVoiceEvent( self, Q_irand( EV_TAUNT1, EV_TAUNT3 ), 2000 );
                }
                else
                {
                        G_AddVoiceEvent( self, Q_irand( EV_GLOAT1, EV_GLOAT3 ), 2000 );
                }
        }
}

void Boba_Precache( void )
{
        G_SoundIndex( "sound/boba/jeton.wav" );
        G_SoundIndex( "sound/boba/jethover.wav" );
        G_SoundIndex( "sound/effects/combustfire.mp3" );
        G_EffectIndex( "boba/jet" );
        G_EffectIndex( "boba/fthrw" );
}

extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
extern void ChangeWeapon( gentity_t *ent, int newWeapon );
void Boba_ChangeWeapon( int wp )
{
        if ( NPC->s.weapon == wp )
        {
                return;
        }
        NPC_ChangeWeapon( wp );
        G_AddEvent( NPC, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
}

void WP_ResistForcePush( gentity_t *self, gentity_t *pusher, qboolean noPenalty )
{
        int parts;
        qboolean runningResist = qfalse;

        if ( !self || self->health <= 0 || !self->client || !pusher || !pusher->client ) 
        {
                return;
        }
        if ( (!self->s.number || self->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",self->NPC_type) || self->client->NPC_class == CLASS_LUKE)
                && (VectorLengthSquared( self->client->ps.velocity ) > 10000 || self->client->ps.fd.forcePowerLevel[FP_PUSH] >= FORCE_LEVEL_3 || self->client->ps.fd.forcePowerLevel[FP_PULL] >= FORCE_LEVEL_3 ) )
        {
                runningResist = qtrue;
        }
        if ( !runningResist
                && self->client->ps.groundEntityNum != ENTITYNUM_NONE 
                && !BG_SpinningSaberAnim( self->client->ps.legsAnim ) 
                && !BG_FlippingAnim( self->client->ps.legsAnim ) 
                && !PM_RollingAnim( self->client->ps.legsAnim ) 
                && !PM_InKnockDown( &self->client->ps ) 
                && !BG_CrouchAnim( self->client->ps.legsAnim ))
        {//if on a surface and not in a spin or flip, play full body resist
                parts = SETANIM_BOTH;
        }
        else
        {//play resist just in torso
                parts = SETANIM_TORSO;
        }
        NPC_SetAnim( self, parts, BOTH_RESISTPUSH, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
        if ( !noPenalty )
        {
                char buf[128];
                float tFVal = 0;

                trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf));

                tFVal = atof(buf);

                if ( !runningResist )
                {
                        VectorClear( self->client->ps.velocity );
                        //still stop them from attacking or moving for a bit, though
                        //FIXME: maybe push just a little (like, slide)?
                        self->client->ps.weaponTime = 1000;
                        if ( self->client->ps.fd.forcePowersActive&(1<<FP_SPEED) )
                        {
                                self->client->ps.weaponTime = floor( self->client->ps.weaponTime * tFVal );
                        }
                        self->client->ps.pm_time = self->client->ps.weaponTime;
                        self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
                        //play the full body push effect on me
                        //self->forcePushTime = level.time + 600; // let the push effect last for 600 ms
                        //rwwFIXMEFIXME: Do this?
                }
                else
                {
                        self->client->ps.weaponTime = 600;
                        if ( self->client->ps.fd.forcePowersActive&(1<<FP_SPEED) )
                        {
                                self->client->ps.weaponTime = floor( self->client->ps.weaponTime * tFVal );
                        }
                }
        }
        //play my force push effect on my hand
        self->client->ps.powerups[PW_DISINT_4] = level.time + self->client->ps.torsoTimer + 500;
        self->client->ps.powerups[PW_PULL] = 0;
        Jedi_PlayBlockedPushSound( self );
}

qboolean Boba_StopKnockdown( gentity_t *self, gentity_t *pusher, vec3_t pushDir, qboolean forceKnockdown ) //forceKnockdown = qfalse
{
        vec3_t  pDir, fwd, right, ang;
        float   fDot, rDot;
        int             strafeTime;

        if ( self->client->NPC_class != CLASS_BOBAFETT )
        {
                return qfalse;
        }

        if ( (self->client->ps.eFlags2&EF2_FLYING) )//moveType == MT_FLYSWIM )
        {//can't knock me down when I'm flying
                return qtrue;
        }

        VectorSet(ang, 0, self->r.currentAngles[YAW], 0);
        strafeTime = Q_irand( 1000, 2000 );

        AngleVectors( ang, fwd, right, NULL );
        VectorNormalize2( pushDir, pDir );
        fDot = DotProduct( pDir, fwd );
        rDot = DotProduct( pDir, right );

        if ( Q_irand( 0, 2 ) )
        {//flip or roll with it
                usercmd_t       tempCmd;
                if ( fDot >= 0.4f )
                {
                        tempCmd.forwardmove = 127;
                        TIMER_Set( self, "moveforward", strafeTime );
                }
                else if ( fDot <= -0.4f )
                {
                        tempCmd.forwardmove = -127;
                        TIMER_Set( self, "moveback", strafeTime );
                }
                else if ( rDot > 0 )
                {
                        tempCmd.rightmove = 127;
                        TIMER_Set( self, "strafeRight", strafeTime );
                        TIMER_Set( self, "strafeLeft", -1 );
                }
                else
                {
                        tempCmd.rightmove = -127;
                        TIMER_Set( self, "strafeLeft", strafeTime );
                        TIMER_Set( self, "strafeRight", -1 );
                }
                G_AddEvent( self, EV_JUMP, 0 );
                if ( !Q_irand( 0, 1 ) )
                {//flip
                        self->client->ps.fd.forceJumpCharge = 280;//FIXME: calc this intelligently?
                        ForceJump( self, &tempCmd );
                }
                else
                {//roll
                        TIMER_Set( self, "duck", strafeTime );
                }
                self->painDebounceTime = 0;//so we do something
        }
        else if ( !Q_irand( 0, 1 ) && forceKnockdown )
        {//resist
                WP_ResistForcePush( self, pusher, qtrue );
        }
        else
        {//fall down
                return qfalse;
        }

        return qtrue;
}

void Boba_FlyStart( gentity_t *self )
{//switch to seeker AI for a while
        if ( TIMER_Done( self, "jetRecharge" ) )
        {
                self->client->ps.gravity = 0;
                if ( self->NPC )
                {
                        self->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
                }
                self->client->ps.eFlags2 |= EF2_FLYING;//moveType = MT_FLYSWIM;
                self->client->jetPackTime = level.time + Q_irand( 3000, 10000 );
                //take-off sound
                G_SoundOnEnt( self, CHAN_ITEM, "sound/boba/jeton.wav" );
                //jet loop sound
                self->s.loopSound = G_SoundIndex( "sound/boba/jethover.wav" );
                if ( self->NPC )
                {
                        self->count = Q3_INFINITE; // SEEKER shot ammo count
                }
        }
}

void Boba_FlyStop( gentity_t *self )
{
        self->client->ps.gravity = g_gravity.value;
        if ( self->NPC )
        {
                self->NPC->aiFlags &= ~NPCAI_CUSTOM_GRAVITY;
        }
        self->client->ps.eFlags2 &= ~EF2_FLYING;
        self->client->jetPackTime = 0;
        //stop jet loop sound
        self->s.loopSound = 0;
        if ( self->NPC )
        {
                self->count = 0; // SEEKER shot ammo count
                TIMER_Set( self, "jetRecharge", Q_irand( 1000, 5000 ) );
                TIMER_Set( self, "jumpChaseDebounce", Q_irand( 500, 2000 ) );
        }
}

qboolean Boba_Flying( gentity_t *self )
{
        return ((qboolean)(self->client->ps.eFlags2&EF2_FLYING));//moveType==MT_FLYSWIM));
}

void Boba_FireFlameThrower( gentity_t *self )
{
        int             damage  = Q_irand( 20, 30 );
        trace_t         tr;
        gentity_t       *traceEnt = NULL;
        mdxaBone_t      boltMatrix;
        vec3_t          start, end, dir, traceMins = {-4, -4, -4}, traceMaxs = {4, 4, 4};

        trap_G2API_GetBoltMatrix( self->ghoul2, 0, self->client->renderInfo.handLBolt,
                        &boltMatrix, self->r.currentAngles, self->r.currentOrigin, level.time,
                        NULL, self->modelScale );

        BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, start );
        BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
        //G_PlayEffect( "boba/fthrw", start, dir );
        VectorMA( start, 128, dir, end );

        trap_Trace( &tr, start, traceMins, traceMaxs, end, self->s.number, MASK_SHOT );

        traceEnt = &g_entities[tr.entityNum];
        if ( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage )
        {
                G_Damage( traceEnt, self, self, dir, tr.endpos, damage, DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|/*DAMAGE_NO_HIT_LOC|*/DAMAGE_IGNORE_TEAM, MOD_LAVA );
                //rwwFIXMEFIXME: add DAMAGE_NO_HIT_LOC?
        }
}

//extern void SP_fx_explosion_trail( gentity_t *ent );
void Boba_StartFlameThrower( gentity_t *self )
{
        int     flameTime = 4000;//Q_irand( 1000, 3000 );
        mdxaBone_t      boltMatrix;
        vec3_t          org, dir;

        self->client->ps.torsoTimer = flameTime;//+1000;
        if ( self->NPC )
        {
                TIMER_Set( self, "nextAttackDelay", flameTime );
                TIMER_Set( self, "walking", 0 );
        }
        TIMER_Set( self, "flameTime", flameTime );
        /*
        gentity_t *fire = G_Spawn();
        if ( fire != NULL )
        {
                mdxaBone_t      boltMatrix;
                vec3_t          org, dir, ang;
                gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, NPC->handRBolt,
                                &boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, (cg.time?cg.time:level.time),
                                NULL, NPC->s.modelScale );

                gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
                gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, dir );
                vectoangles( dir, ang );

                VectorCopy( org, fire->s.origin );
                VectorCopy( ang, fire->s.angles );

                fire->targetname = "bobafire";
                SP_fx_explosion_trail( fire );
                fire->damage = 1;
                fire->radius = 10;
                fire->speed = 200;
                fire->fxID = G_EffectIndex( "boba/fthrw" );//"env/exp_fire_trail" );//"env/small_fire"
                fx_explosion_trail_link( fire );
                fx_explosion_trail_use( fire, NPC, NPC );

        }
        */
        G_SoundOnEnt( self, CHAN_WEAPON, "sound/effects/combustfire.mp3" );

        trap_G2API_GetBoltMatrix(NPC->ghoul2, 0, NPC->client->renderInfo.handRBolt, &boltMatrix, NPC->r.currentAngles,
                NPC->r.currentOrigin, level.time, NULL, NPC->modelScale);

        BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org );
        BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );

        G_PlayEffectID( G_EffectIndex("boba/fthrw"), org, dir);
}

void Boba_DoFlameThrower( gentity_t *self )
{
        NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCELIGHTNING_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
        if ( TIMER_Done( self, "nextAttackDelay" ) && TIMER_Done( self, "flameTime" ) )
        {
                Boba_StartFlameThrower( self );
        }
        Boba_FireFlameThrower( self );
}

void Boba_FireDecide( void )
{
        qboolean enemyLOS = qfalse;
        qboolean enemyCS = qfalse;
        qboolean enemyInFOV = qfalse;
        //qboolean move = qtrue;
        qboolean faceEnemy = qfalse;
        qboolean shoot = qfalse;
        qboolean hitAlly = qfalse;
        vec3_t  impactPos;
        float   enemyDist;
        float   dot;
        vec3_t  enemyDir, shootDir;

        if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE 
                && NPC->client->ps.fd.forceJumpZStart
                && !BG_FlippingAnim( NPC->client->ps.legsAnim )
                && !Q_irand( 0, 10 ) )
        {//take off
                Boba_FlyStart( NPC );
        }

        if ( !NPC->enemy )
        {
                return;
        }

        /*
        if ( NPC->enemy->enemy != NPC && NPC->health == NPC->client->pers.maxHealth )
        {
                NPCInfo->scriptFlags |= SCF_ALT_FIRE;
                Boba_ChangeWeapon( WP_DISRUPTOR );
        }
        else */if ( NPC->enemy->s.weapon == WP_SABER )
        {
                NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
                Boba_ChangeWeapon( WP_ROCKET_LAUNCHER );
        }
        else
        {
                if ( NPC->health < NPC->client->pers.maxHealth*0.5f )
                {
                        NPCInfo->scriptFlags |= SCF_ALT_FIRE;
                        Boba_ChangeWeapon( WP_BLASTER );
                        NPCInfo->burstMin = 3;
                        NPCInfo->burstMean = 12;
                        NPCInfo->burstMax = 20;
                        NPCInfo->burstSpacing = Q_irand( 300, 750 );//attack debounce
                }
                else
                {
                        NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
                        Boba_ChangeWeapon( WP_BLASTER );
                }
        }

        VectorClear( impactPos );
        enemyDist = DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );

        VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, enemyDir );
        VectorNormalize( enemyDir );
        AngleVectors( NPC->client->ps.viewangles, shootDir, NULL, NULL );
        dot = DotProduct( enemyDir, shootDir );
        if ( dot > 0.5f ||( enemyDist * (1.0f-dot)) < 10000 )
        {//enemy is in front of me or they're very close and not behind me
                enemyInFOV = qtrue;
        }

        if ( (enemyDist < (128*128)&&enemyInFOV) || !TIMER_Done( NPC, "flameTime" ) )
        {//flamethrower
                Boba_DoFlameThrower( NPC );
                enemyCS = qfalse;
                shoot = qfalse;
                NPCInfo->enemyLastSeenTime = level.time;
                faceEnemy = qtrue;
                ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);
        }
        else if ( enemyDist < MIN_ROCKET_DIST_SQUARED )//128
        {//enemy within 128
                if ( (NPC->client->ps.weapon == WP_FLECHETTE || NPC->client->ps.weapon == WP_REPEATER) && 
                        (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
                {//shooting an explosive, but enemy too close, switch to primary fire
                        NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
                        //FIXME: we can never go back to alt-fire this way since, after this, we don't know if we were initially supposed to use alt-fire or not...
                }
        }
        else if ( enemyDist > 65536 )//256 squared
        {
                if ( NPC->client->ps.weapon == WP_DISRUPTOR )
                {//sniping... should be assumed
                        if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
                        {//use primary fire
                                NPCInfo->scriptFlags |= SCF_ALT_FIRE;
                                //reset fire-timing variables
                                NPC_ChangeWeapon( WP_DISRUPTOR );
                                NPC_UpdateAngles( qtrue, qtrue );
                                return;
                        }
                }
        }

        //can we see our target?
        if ( TIMER_Done( NPC, "nextAttackDelay" ) && TIMER_Done( NPC, "flameTime" ) )
        {
                if ( NPC_ClearLOS4( NPC->enemy ) )
                {
                        NPCInfo->enemyLastSeenTime = level.time;
                        enemyLOS = qtrue;

                        if ( NPC->client->ps.weapon == WP_NONE )
                        {
                                enemyCS = qfalse;//not true, but should stop us from firing
                        }
                        else
                        {//can we shoot our target?
                                if ( (NPC->client->ps.weapon == WP_ROCKET_LAUNCHER || (NPC->client->ps.weapon == WP_FLECHETTE && (NPCInfo->scriptFlags&SCF_ALT_FIRE))) && enemyDist < MIN_ROCKET_DIST_SQUARED )//128*128
                                {
                                        enemyCS = qfalse;//not true, but should stop us from firing
                                        hitAlly = qtrue;//us!
                                        //FIXME: if too close, run away!
                                }
                                else if ( enemyInFOV )
                                {//if enemy is FOV, go ahead and check for shooting
                                        int hit = NPC_ShotEntity( NPC->enemy, impactPos );
                                        gentity_t *hitEnt = &g_entities[hit];

                                        if ( hit == NPC->enemy->s.number 
                                                || ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
                                                || ( hitEnt && hitEnt->takedamage && ((hitEnt->r.svFlags&SVF_GLASS_BRUSH)||hitEnt->health < 40||NPC->s.weapon == WP_EMPLACED_GUN) ) )
                                        {//can hit enemy or enemy ally or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
                                                enemyCS = qtrue;
                                                //NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
                                                VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
                                        }
                                        else
                                        {//Hmm, have to get around this bastard
                                                //NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
                                                if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
                                                {//would hit an ally, don't fire!!!
                                                        hitAlly = qtrue;
                                                }
                                                else
                                                {//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
                                                }
                                        }
                                }
                                else
                                {
                                        enemyCS = qfalse;//not true, but should stop us from firing
                                }
                        }
                }
                else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
                {
                        NPCInfo->enemyLastSeenTime = level.time;
                        faceEnemy = qtrue;
                        //NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
                }

                if ( NPC->client->ps.weapon == WP_NONE )
                {
                        faceEnemy = qfalse;
                        shoot = qfalse;
                }
                else
                {
                        if ( enemyLOS )
                        {//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
                                faceEnemy = qtrue;
                        }
                        if ( enemyCS )
                        {
                                shoot = qtrue;
                        }
                }

                if ( !enemyCS )
                {//if have a clear shot, always try
                        //See if we should continue to fire on their last position
                        if ( !hitAlly //we're not going to hit an ally
                                && enemyInFOV //enemy is in our FOV //FIXME: or we don't have a clear LOS?
                                && NPCInfo->enemyLastSeenTime > 0 )//we've seen the enemy
                        {
                                if ( level.time - NPCInfo->enemyLastSeenTime < 10000 )//we have seem the enemy in the last 10 seconds
                                {
                                        if ( !Q_irand( 0, 10 ) )
                                        {
                                                //Fire on the last known position
                                                vec3_t  muzzle, dir, angles;
                                                qboolean tooClose = qfalse;
                                                qboolean tooFar = qfalse;
                                                float distThreshold;
                                                float dist;

                                                CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
                                                if ( VectorCompare( impactPos, vec3_origin ) )
                                                {//never checked ShotEntity this frame, so must do a trace...
                                                        trace_t tr;
                                                        //vec3_t        mins = {-2,-2,-2}, maxs = {2,2,2};
                                                        vec3_t  forward, end;
                                                        AngleVectors( NPC->client->ps.viewangles, forward, NULL, NULL );
                                                        VectorMA( muzzle, 8192, forward, end );
                                                        trap_Trace( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
                                                        VectorCopy( tr.endpos, impactPos );
                                                }

                                                //see if impact would be too close to me
                                                distThreshold = 16384/*128*128*/;//default
                                                switch ( NPC->s.weapon )
                                                {
                                                case WP_ROCKET_LAUNCHER:
                                                case WP_FLECHETTE:
                                                case WP_THERMAL:
                                                case WP_TRIP_MINE:
                                                case WP_DET_PACK:
                                                        distThreshold = 65536/*256*256*/;
                                                        break;
                                                case WP_REPEATER:
                                                        if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
                                                        {
                                                                distThreshold = 65536/*256*256*/;
                                                        }
                                                        break;
                                                default:
                                                        break;
                                                }

                                                dist = DistanceSquared( impactPos, muzzle );

                                                if ( dist < distThreshold )
                                                {//impact would be too close to me
                                                        tooClose = qtrue;
                                                }
                                                else if ( level.time - NPCInfo->enemyLastSeenTime > 5000 ||
                                                        (NPCInfo->group && level.time - NPCInfo->group->lastSeenEnemyTime > 5000 ))
                                                {//we've haven't seen them in the last 5 seconds
                                                        //see if it's too far from where he is
                                                        distThreshold = 65536/*256*256*/;//default
                                                        switch ( NPC->s.weapon )
                                                        {
                                                        case WP_ROCKET_LAUNCHER:
                                                        case WP_FLECHETTE:
                                                        case WP_THERMAL:
                                                        case WP_TRIP_MINE:
                                                        case WP_DET_PACK:
                                                                distThreshold = 262144/*512*512*/;
                                                                break;
                                                        case WP_REPEATER:
                                                                if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
                                                                {
                                                                        distThreshold = 262144/*512*512*/;
                                                                }
                                                                break;
                                                        default:
                                                                break;
                                                        }
                                                        dist = DistanceSquared( impactPos, NPCInfo->enemyLastSeenLocation );
                                                        if ( dist > distThreshold )
                                                        {//impact would be too far from enemy
                                                                tooFar = qtrue;
                                                        }
                                                }

                                                if ( !tooClose && !tooFar )
                                                {//okay too shoot at last pos
                                                        VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
                                                        VectorNormalize( dir );
                                                        vectoangles( dir, angles );

                                                        NPCInfo->desiredYaw             = angles[YAW];
                                                        NPCInfo->desiredPitch   = angles[PITCH];

                                                        shoot = qtrue;
                                                        faceEnemy = qfalse;
                                                }
                                        }
                                }
                        }
                }

                //FIXME: don't shoot right away!
                if ( NPC->client->ps.weaponTime > 0 )
                {
                        if ( NPC->s.weapon == WP_ROCKET_LAUNCHER )
                        {
                                if ( !enemyLOS || !enemyCS )
                                {//cancel it
                                        NPC->client->ps.weaponTime = 0;
                                }
                                else
                                {//delay our next attempt
                                        TIMER_Set( NPC, "nextAttackDelay", Q_irand( 500, 1000 ) );
                                }
                        }
                }
                else if ( shoot )
                {//try to shoot if it's time
                        if ( TIMER_Done( NPC, "nextAttackDelay" ) )
                        {
                                if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
                                {
                                        WeaponThink( qtrue );
                                }
                                //NASTY
                                if ( NPC->s.weapon == WP_ROCKET_LAUNCHER 
                                        && (ucmd.buttons&BUTTON_ATTACK) 
                                        && !Q_irand( 0, 3 ) )
                                {//every now and then, shoot a homing rocket
                                        ucmd.buttons &= ~BUTTON_ATTACK;
                                        ucmd.buttons |= BUTTON_ALT_ATTACK;
                                        NPC->client->ps.weaponTime = Q_irand( 500, 1500 );
                                }
                        }
                }
        }
}

void Jedi_Cloak( gentity_t *self )
{
        if ( self )
        {
                self->flags |= FL_NOTARGET;
                if ( self->client )
                {
                        if ( !self->client->ps.powerups[PW_CLOAKED] )
                        {//cloak
                                self->client->ps.powerups[PW_CLOAKED] = Q3_INFINITE;

                                //FIXME: debounce attacks?
                                //FIXME: temp sound
                                G_Sound( self, CHAN_ITEM, G_SoundIndex("sound/chars/shadowtrooper/cloak.wav") );
                        }
                }
        }
}

void Jedi_Decloak( gentity_t *self )
{
        if ( self )
        {
                self->flags &= ~FL_NOTARGET;
                if ( self->client )
                {
                        if ( self->client->ps.powerups[PW_CLOAKED] )
                        {//Uncloak
                                self->client->ps.powerups[PW_CLOAKED] = 0;

                                G_Sound( self, CHAN_ITEM, G_SoundIndex("sound/chars/shadowtrooper/decloak.wav") );
                        }
                }
        }
}

void Jedi_CheckCloak( void )
{
        if ( NPC && NPC->client && NPC->client->NPC_class == CLASS_SHADOWTROOPER )
        {
                if ( !NPC->client->ps.saberHolstered ||
                        NPC->health <= 0 || 
                        NPC->client->ps.saberInFlight ||
                //      (NPC->client->ps.eFlags&EF_FORCE_GRIPPED) ||
                //      (NPC->client->ps.eFlags&EF_FORCE_DRAINED) ||
                        NPC->painDebounceTime > level.time )
                {//can't be cloaked if saber is on, or dead or saber in flight or taking pain or being gripped
                        Jedi_Decloak( NPC );
                }
                else if ( NPC->health > 0 
                        && !NPC->client->ps.saberInFlight 
                //      && !(NPC->client->ps.eFlags&EF_FORCE_GRIPPED) 
                //      && !(NPC->client->ps.eFlags&EF_FORCE_DRAINED) 
                        && NPC->painDebounceTime < level.time )
                {//still alive, have saber in hand, not taking pain and not being gripped
                        Jedi_Cloak( NPC );
                }
        }
}
/*
==========================================================================================
AGGRESSION
==========================================================================================
*/
static void Jedi_Aggression( 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
                if ( self->client->NPC_class == CLASS_DESANN )
                {
                        upper_threshold = 20;
                        lower_threshold = 5;
                }
                else
                {
                        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;
        }
        //Com_Printf( "(%d) %s agg %d change: %d\n", level.time, self->NPC_type, self->NPC->stats.aggression, change );
}

static void Jedi_AggressionErosion( int amt )
{
        if ( TIMER_Done( NPC, "roamTime" ) )
        {//the longer we're not alerted and have no enemy, the more our aggression goes down
                TIMER_Set( NPC, "roamTime", Q_irand( 2000, 5000 ) );
                Jedi_Aggression( NPC, amt );
        }
        
        if ( NPCInfo->stats.aggression < 4 || (NPCInfo->stats.aggression < 6&&NPC->client->NPC_class == CLASS_DESANN))
        {//turn off the saber
                WP_DeactivateSaber( NPC, qfalse );
        }
}

void NPC_Jedi_RateNewEnemy( gentity_t *self, gentity_t *enemy )
{
        float healthAggression;
        float weaponAggression;
        int newAggression;

        switch( enemy->s.weapon )
        {
        case WP_SABER:
                healthAggression = (float)self->health/200.0f*6.0f;
                weaponAggression = 7;//go after him
                break;
        case WP_BLASTER:
                if ( DistanceSquared( self->r.currentOrigin, enemy->r.currentOrigin ) < 65536 )//256 squared
                {
                        healthAggression = (float)self->health/200.0f*8.0f;
                        weaponAggression = 8;//go after him
                }
                else
                {
                        healthAggression = 8.0f - ((float)self->health/200.0f*8.0f);
                        weaponAggression = 2;//hang back for a second
                }
                break;
        default:
                healthAggression = (float)self->health/200.0f*8.0f;
                weaponAggression = 6;//approach
                break;
        }
        //Average these with current aggression
        newAggression = ceil( (healthAggression + weaponAggression + (float)self->NPC->stats.aggression )/3.0f);
        //Com_Printf( "(%d) new agg %d - new enemy\n", level.time, newAggression );
        Jedi_Aggression( self, newAggression - self->NPC->stats.aggression );

        //don't taunt right away
        TIMER_Set( self, "chatter", Q_irand( 4000, 7000 ) );
}

static void Jedi_Rage( void )
{
        Jedi_Aggression( NPC, 10 - NPCInfo->stats.aggression + Q_irand( -2, 2 ) );
        TIMER_Set( NPC, "roamTime", 0 );
        TIMER_Set( NPC, "chatter", 0 );
        TIMER_Set( NPC, "walking", 0 );
        TIMER_Set( NPC, "taunting", 0 );
        TIMER_Set( NPC, "jumpChaseDebounce", 0 );
        TIMER_Set( NPC, "movenone", 0 );
        TIMER_Set( NPC, "movecenter", 0 );
        TIMER_Set( NPC, "noturn", 0 );
        ForceRage( NPC );
}

void Jedi_RageStop( gentity_t *self )
{
        if ( self->NPC )
        {//calm down and back off
                TIMER_Set( self, "roamTime", 0 );
                Jedi_Aggression( self, Q_irand( -5, 0 ) );
        }
}
/*
==========================================================================================
SPEAKING
==========================================================================================
*/

static qboolean Jedi_BattleTaunt( void )
{
        if ( TIMER_Done( NPC, "chatter" ) 
                && !Q_irand( 0, 3 ) 
                && NPCInfo->blockedSpeechDebounceTime < level.time 
                && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time )
        {
                int event = -1;
                if ( NPC->client->playerTeam == NPCTEAM_PLAYER 
                        && NPC->enemy && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_JEDI )
                {//a jedi fighting a jedi - training
                        if ( NPC->client->NPC_class ==