codemp/game/NPC_combat.c

Go to the documentation of this file.

//NPC_combat.cpp
#include "b_local.h"
#include "g_nav.h"

extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
extern qboolean NPC_CheckLookTarget( gentity_t *self );
extern void NPC_ClearLookTarget( gentity_t *self );
extern void NPC_Jedi_RateNewEnemy( gentity_t *self, gentity_t *enemy );
extern int NAV_FindClosestWaypointForPoint2( vec3_t point );
extern int NAV_GetNearestNode( gentity_t *self, int lastNode );
extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
extern qboolean PM_DroidMelee( int npc_class );

void ChangeWeapon( gentity_t *ent, int newWeapon );

void G_ClearEnemy (gentity_t *self)
{
        NPC_CheckLookTarget( self );

        if ( self->enemy )
        {
                if(     self->client && self->client->renderInfo.lookTarget == self->enemy->s.number )
                {
                        NPC_ClearLookTarget( self );
                }

                if ( self->NPC && self->enemy == self->NPC->goalEntity )
                {
                        self->NPC->goalEntity = NULL;
                }
                //FIXME: set last enemy?
        }

        self->enemy = NULL;
}

/*
-------------------------
NPC_AngerAlert
-------------------------
*/

#define ANGER_ALERT_RADIUS                      512
#define ANGER_ALERT_SOUND_RADIUS        256

void G_AngerAlert( gentity_t *self )
{
        if ( self && self->NPC && (self->NPC->scriptFlags&SCF_NO_GROUPS) )
        {//I'm not a team playa...
                return;
        }
        if ( !TIMER_Done( self, "interrogating" ) )
        {//I'm interrogating, don't wake everyone else up yet... FIXME: this may never wake everyone else up, though!
                return;
        }
        //FIXME: hmm.... with all the other new alerts now, is this still neccesary or even a good idea...?
        G_AlertTeam( self, self->enemy, ANGER_ALERT_RADIUS, ANGER_ALERT_SOUND_RADIUS ); 
}

/*
-------------------------
G_TeamEnemy
-------------------------
*/

qboolean G_TeamEnemy( gentity_t *self )
{//FIXME: Probably a better way to do this, is a linked list of your teammates already available?
        int     i;
        gentity_t       *ent;

        if ( !self->client || self->client->playerTeam == TEAM_FREE )
        {
                return qfalse;
        }
        if ( self && self->NPC && (self->NPC->scriptFlags&SCF_NO_GROUPS) )
        {//I'm not a team playa...
                return qfalse;
        }

        for( i = 1; i < level.num_entities; i++ )
        {
                ent = &g_entities[i];

                if ( ent == self )
                {
                        continue;
                }

                if ( ent->health <= 0 )
                {
                        continue;
                }

                if ( !ent->client )
                {
                        continue;
                }

                if ( ent->client->playerTeam != self->client->playerTeam )
                {//ent is not on my team
                        continue;
                }

                if ( ent->enemy )
                {//they have an enemy
                        if ( !ent->enemy->client || ent->enemy->client->playerTeam != self->client->playerTeam )
                        {//the ent's enemy is either a normal ent or is a player/NPC that is not on my team
                                return qtrue;
                        }
                }
        }

        return qfalse;
}

void G_AttackDelay( gentity_t *self, gentity_t *enemy )
{
        if ( enemy && self->client && self->NPC )
        {//delay their attack based on how far away they're facing from enemy
                vec3_t          fwd, dir;
                int                     attDelay;

                VectorSubtract( self->client->renderInfo.eyePoint, enemy->r.currentOrigin, dir );//purposely backwards
                VectorNormalize( dir );
                AngleVectors( self->client->renderInfo.eyeAngles, fwd, NULL, NULL );
                //dir[2] = fwd[2] = 0;//ignore z diff?
                
                attDelay = (4-g_spskill.integer)*500;//initial: from 1000ms delay on hard to 2000ms delay on easy
                if ( self->client->playerTeam == NPCTEAM_PLAYER )
                {//invert
                        attDelay = 2000-attDelay;
                }
                attDelay += floor( (DotProduct( fwd, dir )+1.0f) * 2000.0f );//add up to 4000ms delay if they're facing away

                //FIXME: should distance matter, too?

                //Now modify the delay based on NPC_class, weapon, and team
                //NOTE: attDelay should be somewhere between 1000 to 6000 milliseconds
                switch ( self->client->NPC_class )
                {
                case CLASS_IMPERIAL://they give orders and hang back
                        attDelay += Q_irand( 500, 1500 );
                        break;
                case CLASS_STORMTROOPER://stormtroopers shoot sooner
                        if ( self->NPC->rank >= RANK_LT )
                        {//officers shoot even sooner
                                attDelay -= Q_irand( 500, 1500 );
                        }
                        else
                        {//normal stormtroopers don't have as fast reflexes as officers
                                attDelay -= Q_irand( 0, 1000 );
                        }
                        break;
                case CLASS_SWAMPTROOPER://shoot very quickly?  What about guys in water?
                        attDelay -= Q_irand( 1000, 2000 );
                        break;
                case CLASS_IMPWORKER://they panic, don't fire right away
                        attDelay += Q_irand( 1000, 2500 );
                        break;
                case CLASS_TRANDOSHAN:
                        attDelay -= Q_irand( 500, 1500 );
                        break;
                case CLASS_JAN:                         
                case CLASS_LANDO:                       
                case CLASS_PRISONER:
                case CLASS_REBEL:
                        attDelay -= Q_irand( 500, 1500 );
                        break;
                case CLASS_GALAKMECH:   
                case CLASS_ATST:                
                        attDelay -= Q_irand( 1000, 2000 );
                        break;
                case CLASS_REELO:
                case CLASS_UGNAUGHT:
                case CLASS_JAWA:
                        return;
                        break;
                case CLASS_MINEMONSTER:
                case CLASS_MURJJ:
                        return;
                        break;
                case CLASS_INTERROGATOR:
                case CLASS_PROBE:               
                case CLASS_MARK1:               
                case CLASS_MARK2:               
                case CLASS_SENTRY:              
                        return;
                        break;
                case CLASS_REMOTE:
                case CLASS_SEEKER:
                        return;
                        break;
                /*
                case CLASS_GRAN:
                case CLASS_RODIAN:
                case CLASS_WEEQUAY:
                        break;
                case CLASS_JEDI:                                
                case CLASS_SHADOWTROOPER:
                case CLASS_TAVION:
                case CLASS_REBORN:
                case CLASS_LUKE:                                
                case CLASS_DESANN:                      
                        break;
                */
                }

                switch ( self->s.weapon )
                {
                case WP_NONE:
                case WP_SABER:
                        return;
                        break;
                case WP_BRYAR_PISTOL:
                        break;
                case WP_BLASTER:
                        if ( self->NPC->scriptFlags & SCF_ALT_FIRE )
                        {//rapid-fire blasters
                                attDelay += Q_irand( 0, 500 );
                        }
                        else
                        {//regular blaster
                                attDelay -= Q_irand( 0, 500 );
                        }
                        break;
                case WP_BOWCASTER:
                        attDelay += Q_irand( 0, 500 );
                        break;
                case WP_REPEATER:
                        if ( !(self->NPC->scriptFlags&SCF_ALT_FIRE) )
                        {//rapid-fire blasters
                                attDelay += Q_irand( 0, 500 );
                        }
                        break;
                case WP_FLECHETTE:
                        attDelay += Q_irand( 500, 1500 );
                        break;
                case WP_ROCKET_LAUNCHER:
                        attDelay += Q_irand( 500, 1500 );
                        break;
//              case WP_BLASTER_PISTOL: // apparently some enemy only version of the blaster
//                      attDelay -= Q_irand( 500, 1500 );
//                      break;
                        //rwwFIXMEFIXME: Have this weapon for NPCs?
                case WP_DISRUPTOR://sniper's don't delay?
                        return;
                        break;
                case WP_THERMAL://grenade-throwing has a built-in delay
                        return;
                        break;
                case WP_STUN_BATON:                     // Any ol' melee attack
                        return;
                        break;
                case WP_EMPLACED_GUN:
                        return;
                        break;
                case WP_TURRET:                 // turret guns 
                        return;
                        break;
//              case WP_BOT_LASER:              // Probe droid  - Laser blast
//                      return; //rwwFIXMEFIXME: Have this weapon for NPCs?
                        break;
                /*
                case WP_DEMP2:
                        break;
                case WP_TRIP_MINE:
                        break;
                case WP_DET_PACK:
                        break;
                case WP_STUN_BATON:
                        break;
                case WP_ATST_MAIN:
                        break;
                case WP_ATST_SIDE:
                        break;
                case WP_TIE_FIGHTER:
                        break;
                case WP_RAPID_FIRE_CONC:
                        break;
                */
                }

                if ( self->client->playerTeam == NPCTEAM_PLAYER )
                {//clamp it
                        if ( attDelay > 2000 )
                        {
                                attDelay = 2000;
                        }
                }

                //don't shoot right away
                if ( attDelay > 4000+((2-g_spskill.integer)*3000) )
                {
                        attDelay = 4000+((2-g_spskill.integer)*3000);
                }
                TIMER_Set( self, "attackDelay", attDelay );//Q_irand( 1500, 4500 ) );
                //don't move right away either
                if ( attDelay > 4000 )
                {
                        attDelay = 4000 - Q_irand(500, 1500);
                }
                else
                {
                        attDelay -= Q_irand(500, 1500);
                }

                TIMER_Set( self, "roamTime", attDelay );//was Q_irand( 1000, 3500 );
        }
}

void G_ForceSaberOn(gentity_t *ent)
{
        if (ent->client->ps.saberInFlight)
        { //alright, can't turn it on now in any case, so forget it.
                return;
        }

        if (!ent->client->ps.saberHolstered)
        { //it's already on!
                return;
        }

        if (ent->client->ps.weapon != WP_SABER)
        { //This probably should never happen. But if it does we'll just return without complaining.
                return;
        }

        //Well then, turn it on.
        ent->client->ps.saberHolstered = 0;

        if (ent->client->saber[0].soundOn)
        {
                G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOn);
        }
        if (ent->client->saber[1].soundOn)
        {
                G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOn);
        }
}


/*
-------------------------
G_SetEnemy
-------------------------
*/
void G_AimSet( gentity_t *self, int aim );
void G_SetEnemy( gentity_t *self, gentity_t *enemy )
{
        int     event = 0;
        
        //Must be valid
        if ( enemy == NULL )
                return;

        //Must be valid
        if ( enemy->inuse == 0 )
        {
                return;
        }

        //Don't take the enemy if in notarget
        if ( enemy->flags & FL_NOTARGET )
                return;

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

        if ( self->NPC->confusionTime > level.time )
        {//can't pick up enemies if confused
                return;
        }

#ifdef _DEBUG
        if ( self->s.number )
        {
                assert( enemy != self );
        }
#endif// _DEBUG
        
//      if ( enemy->client && enemy->client->playerTeam == TEAM_DISGUISE )
//      {//unmask the player
//              enemy->client->playerTeam = TEAM_PLAYER;
//      }
        
        if ( self->client && self->NPC && enemy->client && enemy->client->playerTeam == self->client->playerTeam )
        {//Probably a damn script!
                if ( self->NPC->charmedTime > level.time )
                {//Probably a damn script!
                        return;
                }
        }

        if ( self->NPC && self->client && self->client->ps.weapon == WP_SABER )
        {
                //when get new enemy, set a base aggression based on what that enemy is using, how far they are, etc.
                NPC_Jedi_RateNewEnemy( self, enemy );
        }

        //NOTE: this is not necessarily true!
        //self->NPC->enemyLastSeenTime = level.time;

        if ( self->enemy == NULL )
        {
                //TEMP HACK: turn on our saber
                if ( self->health > 0 )
                {
                        G_ForceSaberOn(self);
                }

                //FIXME: Have to do this to prevent alert cascading
                G_ClearEnemy( self );
                self->enemy = enemy;

                //Special case- if player is being hunted by his own people, set their enemy team correctly
                if ( self->client->playerTeam == NPCTEAM_PLAYER && enemy->s.number == 0 )
                {
                        self->client->enemyTeam = NPCTEAM_PLAYER;
                }

                //If have an anger script, run that instead of yelling
                if( G_ActivateBehavior( self, BSET_ANGER ) )
                {
                }
                else if ( self->client && enemy->client && self->client->playerTeam != enemy->client->playerTeam )
                {
                        //FIXME: Use anger when entire team has no enemy.
                        //               Basically, you're first one to notice enemies
                        //if ( self->forcePushTime < level.time ) // not currently being pushed
                        if (1) //rwwFIXMEFIXME: Set forcePushTime
                        {
                                if ( !G_TeamEnemy( self ) )
                                {//team did not have an enemy previously
                                        event = Q_irand(EV_ANGER1, EV_ANGER3);
                                }
                        }
                        
                        if ( event )
                        {//yell
                                G_AddVoiceEvent( self, event, 2000 );
                        }
                }
                
                if ( self->s.weapon == WP_BLASTER || self->s.weapon == WP_REPEATER ||
                        self->s.weapon == WP_THERMAL /*|| self->s.weapon == WP_BLASTER_PISTOL */ //rwwFIXMEFIXME: Blaster pistol useable by npcs?
                        || self->s.weapon == WP_BOWCASTER )
                {//Hmm, how about sniper and bowcaster?
                        //When first get mad, aim is bad
                        //Hmm, base on game difficulty, too?  Rank?
                        if ( self->client->playerTeam == NPCTEAM_PLAYER )
                        {
                                G_AimSet( self, Q_irand( self->NPC->stats.aim - (5*(g_spskill.integer)), self->NPC->stats.aim - g_spskill.integer ) );
                        }
                        else
                        {
                                int minErr = 3;
                                int maxErr = 12;
                                if ( self->client->NPC_class == CLASS_IMPWORKER )
                                {
                                        minErr = 15;
                                        maxErr = 30;
                                }
                                else if ( self->client->NPC_class == CLASS_STORMTROOPER && self->NPC && self->NPC->rank <= RANK_CREWMAN )
                                {
                                        minErr = 5;
                                        maxErr = 15;
                                }

                                G_AimSet( self, Q_irand( self->NPC->stats.aim - (maxErr*(3-g_spskill.integer)), self->NPC->stats.aim - (minErr*(3-g_spskill.integer)) ) );
                        }
                }
                
                //Alert anyone else in the area
                if ( Q_stricmp( "desperado", self->NPC_type ) != 0 && Q_stricmp( "paladin", self->NPC_type ) != 0 )
                {//special holodeck enemies exception
                        if ( self->client->ps.fd.forceGripBeingGripped < level.time )
                        {//gripped people can't call for help
                                G_AngerAlert( self );
                        }
                }

                //Stormtroopers don't fire right away!
                G_AttackDelay( self, enemy );

                //rwwFIXMEFIXME: Deal with this some other way.
                /*
                //FIXME: this is a disgusting hack that is supposed to make the Imperials start with their weapon holstered- need a better way
                if ( self->client->ps.weapon == WP_NONE && !Q_strncmp( self->NPC_type, "imp", 3 ) && !(self->NPC->scriptFlags & SCF_FORCED_MARCH)  )
                {
                        if ( self->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER ) )
                        {
                                ChangeWeapon( self, WP_BLASTER );
                                self->client->ps.weapon = WP_BLASTER;
                                self->client->ps.weaponstate = WEAPON_READY;
                                G_CreateG2AttachedWeaponModel( self, weaponData[WP_BLASTER].weaponMdl, self->handRBolt, 0 );
                        }
                        else if ( self->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER_PISTOL ) )
                        {
                                ChangeWeapon( self, WP_BLASTER_PISTOL );
                                self->client->ps.weapon = WP_BLASTER_PISTOL;
                                self->client->ps.weaponstate = WEAPON_READY;
                                G_CreateG2AttachedWeaponModel( self, weaponData[WP_BLASTER_PISTOL].weaponMdl, self->handRBolt, 0 );
                        }
                }
                */
                return;
        }
        
        //Otherwise, just picking up another enemy

        if ( event )
        {
                G_AddVoiceEvent( self, event, 2000 );
        }

        //Take the enemy
        G_ClearEnemy(self);
        self->enemy = enemy;
}

/*
int ChooseBestWeapon( void ) 
{
        int             n;
        int             weapon;

        // check weapons in the NPC's weapon preference order
        for ( n = 0; n < MAX_WEAPONS; n++ ) 
        {
                weapon = NPCInfo->weaponOrder[n];

                if ( weapon == WP_NONE ) 
                {
                        break;
                }

                if ( !HaveWeapon( weapon ) ) 
                {
                        continue;
                }

                if ( client->ps.ammo[weaponData[weapon].ammoIndex] ) 
                {
                        return weapon;
                }
        }

        // check weapons serially (mainly in case a weapon is not on the NPC's list)
        for ( weapon = 1; weapon < WP_NUM_WEAPONS; weapon++ ) 
        {
                if ( !HaveWeapon( weapon ) ) 
                {
                        continue;
                }

                if ( client->ps.ammo[weaponData[weapon].ammoIndex] ) 
                {
                        return weapon;
                }
        }

        return client->ps.weapon;
}
*/

void ChangeWeapon( gentity_t *ent, int newWeapon ) 
{
        if ( !ent || !ent->client || !ent->NPC )
        {
                return;
        }

        ent->client->ps.weapon = newWeapon;
        ent->client->pers.cmd.weapon = newWeapon;
        ent->NPC->shotTime = 0;
        ent->NPC->burstCount = 0;
        ent->NPC->attackHold = 0;
        ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[newWeapon].ammoIndex];

        switch ( newWeapon ) 
        {
        case WP_BRYAR_PISTOL://prifle
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                ent->NPC->burstSpacing = 1000;//attackdebounce
                break;

                /*
        case WP_BLASTER_PISTOL:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
        //      ent->NPC->burstSpacing = 1000;//attackdebounce
                if ( g_spskill.integer == 0 )
                        ent->NPC->burstSpacing = 1000;//attack debounce
                else if ( g_spskill.integer == 1 )
                        ent->NPC->burstSpacing = 750;//attack debounce
                else 
                        ent->NPC->burstSpacing = 500;//attack debounce
                break;
                */
                //rwwFIXMEFIXME: support WP_BLASTER_PISTOL and WP_BOT_LASER

                /*
        case WP_BOT_LASER://probe attack
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
        //      ent->NPC->burstSpacing = 600;//attackdebounce
                if ( g_spskill.integer == 0 )
                        ent->NPC->burstSpacing = 600;//attack debounce
                else if ( g_spskill.integer == 1 )
                        ent->NPC->burstSpacing = 400;//attack debounce
                else 
                        ent->NPC->burstSpacing = 200;//attack debounce
                break;
                */

        case WP_SABER:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                ent->NPC->burstSpacing = 0;//attackdebounce
                break;

        case WP_DISRUPTOR:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
                {
                        switch( g_spskill.integer )
                        {
                        case 0:
                                ent->NPC->burstSpacing = 2500;//attackdebounce
                                break;
                        case 1:
                                ent->NPC->burstSpacing = 2000;//attackdebounce
                                break;
                        case 2:
                                ent->NPC->burstSpacing = 1500;//attackdebounce
                                break;
                        }
                }
                else
                {
                        ent->NPC->burstSpacing = 1000;//attackdebounce
                }
                break;

        case WP_BOWCASTER:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
        //      ent->NPC->burstSpacing = 1000;//attackdebounce
                if ( g_spskill.integer == 0 )
                        ent->NPC->burstSpacing = 1000;//attack debounce
                else if ( g_spskill.integer == 1 )
                        ent->NPC->burstSpacing = 750;//attack debounce
                else 
                        ent->NPC->burstSpacing = 500;//attack debounce
                break;

        case WP_REPEATER:
                if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
                {
                        ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                        ent->NPC->burstSpacing = 2000;//attackdebounce
                }
                else
                {
                        ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
                        ent->NPC->burstMin = 3;
                        ent->NPC->burstMean = 6;
                        ent->NPC->burstMax = 10;
                        if ( g_spskill.integer == 0 )
                                ent->NPC->burstSpacing = 1500;//attack debounce
                        else if ( g_spskill.integer == 1 )
                                ent->NPC->burstSpacing = 1000;//attack debounce
                        else 
                                ent->NPC->burstSpacing = 500;//attack debounce
                }
                break;

        case WP_DEMP2:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                ent->NPC->burstSpacing = 1000;//attackdebounce
                break;

        case WP_FLECHETTE:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
                {
                        ent->NPC->burstSpacing = 2000;//attackdebounce
                }
                else
                {
                        ent->NPC->burstSpacing = 1000;//attackdebounce
                }
                break;

        case WP_ROCKET_LAUNCHER:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
        //      ent->NPC->burstSpacing = 2500;//attackdebounce
                if ( g_spskill.integer == 0 )
                        ent->NPC->burstSpacing = 2500;//attack debounce
                else if ( g_spskill.integer == 1 )
                        ent->NPC->burstSpacing = 2000;//attack debounce
                else 
                        ent->NPC->burstSpacing = 1500;//attack debounce
                break;

        case WP_THERMAL:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
        //      ent->NPC->burstSpacing = 3000;//attackdebounce
                if ( g_spskill.integer == 0 )
                        ent->NPC->burstSpacing = 3000;//attack debounce
                else if ( g_spskill.integer == 1 )
                        ent->NPC->burstSpacing = 2500;//attack debounce
                else 
                        ent->NPC->burstSpacing = 2000;//attack debounce
                break;

        /*
        case WP_SABER:
                ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
                ent->NPC->burstMin = 5;//0.5 sec
                ent->NPC->burstMean = 10;//1 second
                ent->NPC->burstMax = 20;//3 seconds
                ent->NPC->burstSpacing = 2000;//2 seconds
                ent->NPC->attackHold = 1000;//Hold attack button for a 1-second burst
                break;
        
        case WP_TRICORDER:
                ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
                ent->NPC->burstMin = 5;
                ent->NPC->burstMean = 10;
                ent->NPC->burstMax = 30;
                ent->NPC->burstSpacing = 1000;
                break;
        */

        case WP_BLASTER:
                if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
                {
                        ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
                        ent->NPC->burstMin = 3;
                        ent->NPC->burstMean = 3;
                        ent->NPC->burstMax = 3;
                        if ( g_spskill.integer == 0 )
                                ent->NPC->burstSpacing = 1500;//attack debounce
                        else if ( g_spskill.integer == 1 )
                                ent->NPC->burstSpacing = 1000;//attack debounce
                        else 
                                ent->NPC->burstSpacing = 500;//attack debounce
                }
                else
                {
                        ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                        if ( g_spskill.integer == 0 )
                                ent->NPC->burstSpacing = 1000;//attack debounce
                        else if ( g_spskill.integer == 1 )
                                ent->NPC->burstSpacing = 750;//attack debounce
                        else 
                                ent->NPC->burstSpacing = 500;//attack debounce
                //      ent->NPC->burstSpacing = 1000;//attackdebounce
                }
                break;

        case WP_STUN_BATON:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                ent->NPC->burstSpacing = 1000;//attackdebounce
                break;

                /*
        case WP_ATST_MAIN:
        case WP_ATST_SIDE:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
        //      ent->NPC->burstSpacing = 1000;//attackdebounce
                        if ( g_spskill.integer == 0 )
                                ent->NPC->burstSpacing = 1000;//attack debounce
                        else if ( g_spskill.integer == 1 )
                                ent->NPC->burstSpacing = 750;//attack debounce
                        else 
                                ent->NPC->burstSpacing = 500;//attack debounce
                break;
                */
                //rwwFIXMEFIXME: support for atst weaps

        case WP_EMPLACED_GUN:
                //FIXME: give some designer-control over this?
                if ( ent->client && ent->client->NPC_class == CLASS_REELO )
                {
                        ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                        ent->NPC->burstSpacing = 1000;//attack debounce
        //              if ( g_spskill.integer == 0 )
        //                      ent->NPC->burstSpacing = 300;//attack debounce
        //              else if ( g_spskill.integer == 1 )
        //                      ent->NPC->burstSpacing = 200;//attack debounce
        //              else 
        //                      ent->NPC->burstSpacing = 100;//attack debounce
                }
                else
                {
                        ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
                        ent->NPC->burstMin = 2; // 3 shots, really
                        ent->NPC->burstMean = 2;
                        ent->NPC->burstMax = 2;

                        if ( ent->parent ) // if we have an owner, it should be the chair at this point...so query the chair for its shot debounce times, etc.
                        {
                                if ( g_spskill.integer == 0 )
                                {
                                        ent->NPC->burstSpacing = ent->parent->wait + 400;//attack debounce
                                        ent->NPC->burstMin = ent->NPC->burstMax = 1; // two shots
                                }
                                else if ( g_spskill.integer == 1 )
                                {
                                        ent->NPC->burstSpacing = ent->parent->wait + 200;//attack debounce
                                }
                                else 
                                {
                                        ent->NPC->burstSpacing = ent->parent->wait;//attack debounce
                                }
                        }
                        else
                        {
                                if ( g_spskill.integer == 0 )
                                {
                                        ent->NPC->burstSpacing = 1200;//attack debounce
                                        ent->NPC->burstMin = ent->NPC->burstMax = 1; // two shots
                                }
                                else if ( g_spskill.integer == 1 )
                                {
                                        ent->NPC->burstSpacing = 1000;//attack debounce
                                }
                                else 
                                {
                                        ent->NPC->burstSpacing = 800;//attack debounce
                                }
                        }
                }
                break;

        default:
                ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
                break;
        }
}

void NPC_ChangeWeapon( int newWeapon ) 
{
        /*
        qboolean        changing = qfalse;
        if ( newWeapon != NPC->client->ps.weapon )
        {
                changing = qtrue;
        }
        if ( changing && NPC->weaponModel[0] > 9 )
        {
                trap_G2API_RemoveGhoul2Model( NPC->ghoul2, NPC->weaponModel[0] );
        }
        ChangeWeapon( NPC, newWeapon );
        if ( changing && NPC->client->ps.weapon != WP_NONE )
        {
                if ( NPC->client->ps.weapon == WP_SABER )
                {
                        G_CreateG2AttachedWeaponModel( NPC, NPC->client->ps.saber[0].model, NPC->handRBolt, 0 );
                        if ( NPC->client->ps.dualSabers )
                        {
                                G_CreateG2AttachedWeaponModel( NPC, NPC->client->ps.saber[1].model, NPC->handLBolt, 0 );
                        }
                }
                else
                {
                        G_CreateG2AttachedWeaponModel( NPC, weaponData[NPC->client->ps.weapon].weaponMdl, NPC->handRBolt, 0 );
                }
        }*/
        //rwwFIXMEFIXME: Change the same way as players, all this stuff is just crazy.
}
/*
void NPC_ApplyWeaponFireDelay(void)
How long, if at all, in msec the actual fire should delay from the time the attack was started
*/
void NPC_ApplyWeaponFireDelay(void)
{       
        if ( NPC->attackDebounceTime > level.time )
        {//Just fired, if attacking again, must be a burst fire, so don't add delay
                //NOTE: Borg AI uses attackDebounceTime "incorrectly", so this will always return for them!
                return;
        }
        
        switch(client->ps.weapon)
        {
                /*
        case WP_BOT_LASER:
                NPCInfo->burstCount = 0;
                client->ps.weaponTime = 500;
                break;
                */ //rwwFIXMEFIXME: support for this

        case WP_THERMAL:
                if ( client->ps.clientNum )
                {//NPCs delay... 
                        //FIXME: player should, too, but would feel weird in 1st person, even though it
                        //                      would look right in 3rd person.  Really should have a wind-up anim
                        //                      for player as he holds down the fire button to throw, then play
                        //                      the actual throw when he lets go...
                        client->ps.weaponTime = 700;
                }
                break;

        case WP_STUN_BATON:
                //if ( !PM_DroidMelee( client->NPC_class ) )
                if (1) //rwwFIXMEFIXME: ...
                {//FIXME: should be unique per melee anim
                        client->ps.weaponTime = 300;
                }
                break;

        default:
                client->ps.weaponTime = 0;
                break;
        }
}

/*
-------------------------
ShootThink
-------------------------
*/
void ShootThink( void ) 
{
        int                     delay;

        ucmd.buttons &= ~BUTTON_ATTACK;
/*
        if ( enemyVisibility != VIS_SHOOT) 
                return;
*/

        if ( client->ps.weapon == WP_NONE )
                return;

        if ( client->ps.weaponstate != WEAPON_READY && client->ps.weaponstate != WEAPON_FIRING && client->ps.weaponstate != WEAPON_IDLE) 
                return;

        if ( level.time < NPCInfo->shotTime ) 
        {
                return;
        }

        ucmd.buttons |= BUTTON_ATTACK;

        NPCInfo->currentAmmo = client->ps.ammo[weaponData[client->ps.weapon].ammoIndex];        // checkme

        NPC_ApplyWeaponFireDelay();

        if ( NPCInfo->aiFlags & NPCAI_BURST_WEAPON ) 
        {
                if ( !NPCInfo->burstCount ) 
                {
                        NPCInfo->burstCount = Q_irand( NPCInfo->burstMin, NPCInfo->burstMax );
                        /*
                        NPCInfo->burstCount = erandom( NPCInfo->burstMean );
                        if ( NPCInfo->burstCount < NPCInfo->burstMin ) 
                        {
                                NPCInfo->burstCount = NPCInfo->burstMin;
                        }
                        else if ( NPCInfo->burstCount > NPCInfo->burstMax ) 
                        {
                                NPCInfo->burstCount = NPCInfo->burstMax;
                        }
                        */
                        delay = 0;
                }
                else 
                {
                        NPCInfo->burstCount--;
                        if ( NPCInfo->burstCount == 0 ) 
                        {
                                delay = NPCInfo->burstSpacing;
                        }
                        else 
                        {
                                delay = 0;
                        }
                }

                if ( !delay )
                {
                        // HACK: dirty little emplaced bits, but is done because it would otherwise require some sort of new variable...
                        if ( client->ps.weapon == WP_EMPLACED_GUN )
                        {
                                if ( NPC->parent ) // try and get the debounce values from the chair if we can
                                {
                                        if ( g_spskill.integer == 0 )
                                        {
                                                delay = NPC->parent->random + 150;
                                        }
                                        else if ( g_spskill.integer == 1 )
                                        {
                                                delay = NPC->parent->random + 100;
                                        }
                                        else 
                                        {
                                                delay = NPC->parent->random;
                                        }
                                }
                                else
                                {
                                        if ( g_spskill.integer == 0 )
                                        {
                                                delay = 350;
                                        }
                                        else if ( g_spskill.integer == 1 )
                                        {
                                                delay = 300;
                                        }
                                        else 
                                        {
                                                delay = 200;
                                        }
                                }
                        }
                }
        }
        else 
        {
                delay = NPCInfo->burstSpacing;
        }

        NPCInfo->shotTime = level.time + delay;
        NPC->attackDebounceTime = level.time + NPC_AttackDebounceForWeapon();
}

/*
static void WeaponThink( qboolean inCombat ) 
FIXME makes this so there's a delay from event that caused us to check to actually doing it

Added: hacks for Borg
*/
void WeaponThink( qboolean inCombat ) 
{
        if ( client->ps.weaponstate == WEAPON_RAISING || client->ps.weaponstate == WEAPON_DROPPING ) 
        {
                ucmd.weapon = client->ps.weapon;
                ucmd.buttons &= ~BUTTON_ATTACK;
                return;
        }

//MCG - Begin
        //For now, no-one runs out of ammo      
        if(NPC->client->ps.ammo[ weaponData[client->ps.weapon].ammoIndex ] < 10)        // checkme      
//      if(NPC->client->ps.ammo[ client->ps.weapon ] < 10)
        {
                Add_Ammo (NPC, client->ps.weapon, 100);
        }

        /*if ( NPC->playerTeam == TEAM_BORG )
        {//HACK!!!
                if(!(NPC->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BORG_WEAPON )))
                        NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BORG_WEAPON );

                if ( client->ps.weapon != WP_BORG_WEAPON ) 
                {
                        NPC_ChangeWeapon( WP_BORG_WEAPON );
                        Add_Ammo (NPC, client->ps.weapon, 10);
                        NPCInfo->currentAmmo = client->ps.ammo[client->ps.weapon];
                }
        }
        else */
        
        /*if ( NPC->client->playerTeam == TEAM_SCAVENGERS )
        {//HACK!!!
                if(!(NPC->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER )))
                        NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BLASTER );

                if ( client->ps.weapon != WP_BLASTER )
                         
                {
                        NPC_ChangeWeapon( WP_BLASTER );
                        Add_Ammo (NPC, client->ps.weapon, 10);
//                      NPCInfo->currentAmmo = client->ps.ammo[client->ps.weapon];
                        NPCInfo->currentAmmo = client->ps.ammo[weaponData[client->ps.weapon].ammoIndex];        // checkme
                }
        }
        else*/
//MCG - End
        {
                // if the gun in our hands is out of ammo, we need to change
                /*if ( client->ps.ammo[client->ps.weapon] == 0 ) 
                {
                        NPCInfo->aiFlags |= NPCAI_CHECK_WEAPON;
                }

                if ( NPCInfo->aiFlags & NPCAI_CHECK_WEAPON ) 
                {
                        NPCInfo->aiFlags &= ~NPCAI_CHECK_WEAPON;
                        bestWeapon = ChooseBestWeapon();
                        if ( bestWeapon != client->ps.weapon ) 
                        {
                                NPC_ChangeWeapon( bestWeapon );
                        }
                }*/
        }

        ucmd.weapon = client->ps.weapon;
        ShootThink();
}

/*
HaveWeapon
*/

qboolean HaveWeapon( int weapon ) 
{
        return ( client->ps.stats[STAT_WEAPONS] & ( 1 << weapon ) );
}

qboolean EntIsGlass (gentity_t *check)
{
        if(check->classname &&
                !Q_stricmp("func_breakable", check->classname) &&
                check->count == 1 && check->health <= 100)
        {
                return qtrue;
        }

        return qfalse;
}

qboolean ShotThroughGlass (trace_t *tr, gentity_t *target, vec3_t spot, int mask)
{
        gentity_t       *hit = &g_entities[ tr->entityNum ];
        if(hit != target && EntIsGlass(hit))
        {//ok to shoot through breakable glass
                int                     skip = hit->s.number;
                vec3_t          muzzle;

                VectorCopy(tr->endpos, muzzle);
                trap_Trace (tr, muzzle, NULL, NULL, spot, skip, mask );
                return qtrue;
        }

        return qfalse;
}

/*
CanShoot
determine if NPC can directly target enemy

this function does not check teams, invulnerability, notarget, etc....

Added: If can't shoot center, try head, if not, see if it's close enough to try anyway.
*/
qboolean CanShoot ( gentity_t *ent, gentity_t *shooter ) 
{
        trace_t         tr;
        vec3_t          muzzle;
        vec3_t          spot, diff;
        gentity_t       *traceEnt;

        CalcEntitySpot( shooter, SPOT_WEAPON, muzzle );
        CalcEntitySpot( ent, SPOT_ORIGIN, spot );               //FIXME preferred target locations for some weapons (feet for R/L)

        trap_Trace ( &tr, muzzle, NULL, NULL, spot, shooter->s.number, MASK_SHOT );
        traceEnt = &g_entities[ tr.entityNum ];

        // point blank, baby!
        if (tr.startsolid && (shooter->NPC) && (shooter->NPC->touchedByPlayer) ) 
        {
                traceEnt = shooter->NPC->touchedByPlayer;
        }
        
        if ( ShotThroughGlass( &tr, ent, spot, MASK_SHOT ) )
        {
                traceEnt = &g_entities[ tr.entityNum ];
        }

        // shot is dead on
        if ( traceEnt == ent ) 
        {
                return qtrue;
        }
//MCG - Begin
        else
        {//ok, can't hit them in center, try their head
                CalcEntitySpot( ent, SPOT_HEAD, spot );
                trap_Trace ( &tr, muzzle, NULL, NULL, spot, shooter->s.number, MASK_SHOT );
                traceEnt = &g_entities[ tr.entityNum ];
                if ( traceEnt == ent) 
                {
                        return qtrue;
                }
        }

        //Actually, we should just check to fire in dir we're facing and if it's close enough,
        //and we didn't hit someone on our own team, shoot
        VectorSubtract(spot, tr.endpos, diff);
        if(VectorLength(diff) < random() * 32)
        {
                return qtrue;
        }
//MCG - End
        // shot would hit a non-client
        if ( !traceEnt->client ) 
        {
                return qfalse;
        }

        // shot is blocked by another player

        // he's already dead, so go ahead
        if ( traceEnt->health <= 0 ) 
        {
                return qtrue;
        }

        // don't deliberately shoot a teammate
        if ( traceEnt->client && ( traceEnt->client->playerTeam == shooter->client->playerTeam ) ) 
        {
                return qfalse;
        }

        // he's just in the wrong place, go ahead
        return qtrue;
}


/*
void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis ) 

Added: hacks for scripted NPCs
*/
void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis ) 
{
        // is he is already our enemy?
        if ( other == NPC->enemy ) 
                return;

        if ( other->flags & FL_NOTARGET ) 
                return;

        // we already have an enemy and this guy is in our FOV, see if this guy would be better
        if ( NPC->enemy && vis == VIS_FOV ) 
        {
                if ( NPCInfo->enemyLastSeenTime - level.time < 2000 ) 
                {
                        return;
                }
                if ( enemyVisibility == VIS_UNKNOWN ) 
                {
                        enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_360|CHECK_FOV );
                }
                if ( enemyVisibility == VIS_FOV ) 
                {
                        return;
                }
        }

        if ( !NPC->enemy )
        {//only take an enemy if you don't have one yet
                G_SetEnemy( NPC, other );
        }

        if ( vis == VIS_FOV ) 
        {
                NPCInfo->enemyLastSeenTime = level.time;
                VectorCopy( other->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
                NPCInfo->enemyLastHeardTime = 0;
                VectorClear( NPCInfo->enemyLastHeardLocation );
        } 
        else 
        {
                NPCInfo->enemyLastSeenTime = 0;
                VectorClear( NPCInfo->enemyLastSeenLocation );
                NPCInfo->enemyLastHeardTime = level.time;
                VectorCopy( other->r.currentOrigin, NPCInfo->enemyLastHeardLocation );
        }
}


//==========================================
//MCG Added functions:
//==========================================

/*
int NPC_AttackDebounceForWeap