codemp/game/NPC_spawn.c

Go to the documentation of this file.

//b_spawn.cpp
//added by MCG
#include "b_local.h"
#include "anims.h"
#include "w_saber.h"
#include "bg_saga.h"
#include "bg_vehicles.h"
#include "g_nav.h"

extern void G_DebugPrint( int level, const char *format, ... );

extern qboolean G_CheckInSolid (gentity_t *self, qboolean fix);
extern void ClientUserinfoChanged( int clientNum );
extern qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest );
extern void Jedi_Cloak( gentity_t *self );

//extern void FX_BorgTeleport( vec3_t org );

extern void Q3_SetParm (int entID, int parmNum, const char *parmValue);
extern team_t TranslateTeamName( const char *name );
extern char     *TeamNames[TEAM_NUM_TEAMS];

//extern void CG_ShimmeryThing_Spawner( vec3_t start, vec3_t end, float radius, qboolean taper, int duration );

//extern void NPC_StasisSpawnEffect( gentity_t *ent );

extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );

extern void ST_ClearTimers( gentity_t *ent );
extern void Jedi_ClearTimers( gentity_t *ent );
extern void NPC_ShadowTrooper_Precache( void );
extern void NPC_Gonk_Precache( void );
extern void NPC_Mouse_Precache( void );
extern void NPC_Seeker_Precache( void );
extern void NPC_Remote_Precache( void );
extern void     NPC_R2D2_Precache(void);
extern void     NPC_R5D2_Precache(void);
extern void NPC_Probe_Precache(void);
extern void NPC_Interrogator_Precache(gentity_t *self);
extern void NPC_MineMonster_Precache( void );
extern void NPC_Howler_Precache( void );
extern void NPC_ATST_Precache(void);
extern void NPC_Sentry_Precache(void);
extern void NPC_Mark1_Precache(void);
extern void NPC_Mark2_Precache(void);
extern void NPC_GalakMech_Precache( void );
extern void NPC_GalakMech_Init( gentity_t *ent );
extern void NPC_Protocol_Precache( void );
extern void Boba_Precache( void );
extern void NPC_Wampa_Precache( void );
gentity_t *NPC_SpawnType( gentity_t *ent, char *npc_type, char *targetname, qboolean isVehicle );

extern void Rancor_SetBolts( gentity_t *self );
extern void Wampa_SetBolts( gentity_t *self );

#define NSF_DROP_TO_FLOOR       16

// PAIN functions...
//
extern void funcBBrushPain                              (gentity_t *self, gentity_t *attacker, int damage);
extern void misc_model_breakable_pain   (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Pain                                    (gentity_t *self, gentity_t *attacker, int damage);
extern void station_pain                                (gentity_t *self, gentity_t *attacker, int damage);
extern void func_usable_pain                    (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_ATST_Pain                               (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_ST_Pain                                 (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Jedi_Pain                               (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Droid_Pain                              (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Probe_Pain                              (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_MineMonster_Pain                (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Howler_Pain                             (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Seeker_Pain                             (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Remote_Pain                             (gentity_t *self, gentity_t *attacker, int damage);
extern void emplaced_gun_pain                   (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Mark1_Pain                              (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_GM_Pain                         (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Sentry_Pain                             (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Mark2_Pain                              (gentity_t *self, gentity_t *attacker, int damage);
extern void PlayerPain                                  (gentity_t *self, gentity_t *attacker, int damage);
extern void GasBurst                                    (gentity_t *self, gentity_t *attacker, int damage);
extern void CrystalCratePain                    (gentity_t *self, gentity_t *attacker, int damage);
extern void TurretPain                                  (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Wampa_Pain                              (gentity_t *self, gentity_t *attacker, int damage);
extern void NPC_Rancor_Pain                             (gentity_t *self, gentity_t *attacker, int damage);


//void HirogenAlpha_Precache( void );

int WP_SetSaberModel( gclient_t *client, class_t npcClass )
{
        //rwwFIXMEFIXME: Do something here, need to let the client know.
        return 1;
}

/*
-------------------------
NPC_PainFunc
-------------------------
*/
typedef void (PAIN_FUNC) (gentity_t *self, gentity_t *attacker, int damage);

PAIN_FUNC *NPC_PainFunc( gentity_t *ent )
{
        void (*func)(gentity_t *self, gentity_t *attacker, int damage);

        if ( ent->client->ps.weapon == WP_SABER )
        {
                func = NPC_Jedi_Pain;
        }
        else
        {
                // team no longer indicates race/species, use NPC_class to determine different npc types
                /*
                switch ( ent->client->playerTeam )
                {
                default:
                        func = painF_NPC_Pain;
                        break;
                }
                */
                switch( ent->client->NPC_class )
                {
                // troopers get special pain
                case CLASS_STORMTROOPER:
                case CLASS_SWAMPTROOPER:
                        func = NPC_ST_Pain;
                        break;

                case CLASS_SEEKER:
                        func = NPC_Seeker_Pain;
                        break;

                case CLASS_REMOTE:
                        func = NPC_Remote_Pain;
                        break;

                case CLASS_MINEMONSTER:
                        func = NPC_MineMonster_Pain;
                        break;

                case CLASS_HOWLER:
                        func = NPC_Howler_Pain;
                        break;

                // all other droids, did I miss any?
                case CLASS_GONK:
                case CLASS_R2D2:
                case CLASS_R5D2:
                case CLASS_MOUSE:
                case CLASS_PROTOCOL:
                case CLASS_INTERROGATOR:
                        func = NPC_Droid_Pain;
                        break;
                case CLASS_PROBE:
                        func = NPC_Probe_Pain;
                        break;

                case CLASS_SENTRY:
                        func = NPC_Sentry_Pain;
                        break;
                case CLASS_MARK1:
                        func = NPC_Mark1_Pain;
                        break;
                case CLASS_MARK2:
                        func = NPC_Mark2_Pain;
                        break;
                case CLASS_ATST:  
                        func = NPC_ATST_Pain;
                        break;
                case CLASS_GALAKMECH:
                        func = NPC_GM_Pain;
                        break;
                case CLASS_RANCOR:
                        func = NPC_Rancor_Pain;
                        break;
                case CLASS_WAMPA:
                        func = NPC_Wampa_Pain;
                        break;
                // everyone else gets the normal pain func
                default:
                        func = NPC_Pain;
                        break;
                }

        }

        return func;
}


/*
-------------------------
NPC_TouchFunc
-------------------------
*/
typedef void (TOUCH_FUNC) (gentity_t *self, gentity_t *other, trace_t *trace);

TOUCH_FUNC *NPC_TouchFunc( gentity_t *ent )
{
        void (*func)(gentity_t *self, gentity_t *other, trace_t *trace);

        func = NPC_Touch;

        return func;
}

/*
-------------------------
NPC_SetMiscDefaultData
-------------------------
*/

extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
void NPC_SetMiscDefaultData( gentity_t *ent )
{
        if ( ent->spawnflags & SFB_CINEMATIC )
        {//if a cinematic guy, default us to wait bState
                ent->NPC->behaviorState = BS_CINEMATIC;
        }
        if ( ent->client->NPC_class == CLASS_BOBAFETT )
        {//set some stuff, precache
                Boba_Precache();
                ent->client->ps.fd.forcePowersKnown |= ( 1 << FP_LEVITATION );
                ent->client->ps.fd.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_3;
                ent->client->ps.fd.forcePower = 100;
                ent->NPC->scriptFlags |= (SCF_ALT_FIRE|SCF_NO_GROUPS);
        }
        //if ( !Q_stricmp( "atst_vehicle", ent->NPC_type ) )//FIXME: has to be a better, easier way to tell this, no?
        if (ent->s.NPC_class == CLASS_VEHICLE && ent->m_pVehicle)
        {
                ent->s.g2radius = 255;//MAX for this value, was (ent->r.maxs[2]-ent->r.mins[2]), which is 272 or something

                if (ent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)
                {
                        ent->mass = 2000;//???
                        ent->flags |= (FL_SHIELDED|FL_NO_KNOCKBACK);
                        ent->pain = NPC_ATST_Pain;
                }
                //turn the damn hatch cover on and LEAVE it on
                trap_G2API_SetSurfaceOnOff( ent->ghoul2, "head_hatchcover", 0/*TURN_ON*/ );
        }
        if ( !Q_stricmp( "wampa", ent->NPC_type ) )
        {//FIXME: extern this into NPC.cfg?
                Wampa_SetBolts( ent );
                ent->s.g2radius = 80;//???
                ent->mass = 300;//???
                ent->flags |= FL_NO_KNOCKBACK;
                ent->pain = NPC_Wampa_Pain;
        }
        if ( ent->client->NPC_class == CLASS_RANCOR )
        {
                Rancor_SetBolts( ent );
                ent->s.g2radius = 255;//MAX for this value, was (ent->r.maxs[2]-ent->r.mins[2]), which is 272 or something
                ent->mass = 1000;//???
                ent->flags |= FL_NO_KNOCKBACK;
                ent->pain = NPC_Rancor_Pain;
                ent->health *= 4;
        }
        if ( !Q_stricmp( "Yoda", ent->NPC_type ) )
        {//FIXME: extern this into NPC.cfg?
                ent->NPC->scriptFlags |= SCF_NO_FORCE;//force powers don't work on him
        }
        if ( !Q_stricmp( "emperor", ent->NPC_type ) )
        {//FIXME: extern this into NPC.cfg?
                ent->NPC->scriptFlags |= SCF_DONT_FIRE;//so he uses only force powers
        }
        //==================
//      if ( ent->client->ps.saber[0].type != SABER_NONE )
        if (ent->client->ps.weapon == WP_SABER) //rwwFIXMEFIXME: is this going to work?
        {//if I'm equipped with a saber, initialize it (them)
        //      ent->client->ps.SaberDeactivate();
        //      ent->client->ps.SetSaberLength( 0 );
                WP_SaberInitBladeData( ent );
                ent->client->ps.saberHolstered = 2;
        //      G_CreateG2AttachedWeaponModel( ent, ent->client->ps.saber[0].model, ent->handRBolt, 0 );
        //      if ( ent->client->ps.dualSabers )
        //      {
        //              G_CreateG2AttachedWeaponModel( ent, ent->client->ps.saber[1].model, ent->handLBolt, 1 );
        //      }
                Jedi_ClearTimers( ent );
        }
        if ( ent->client->ps.fd.forcePowersKnown != 0 )
        {
                WP_InitForcePowers( ent );
                WP_SpawnInitForcePowers(ent); //rww
        }
        if ( ent->client->NPC_class == CLASS_SEEKER )
        {               
                ent->NPC->defaultBehavior = BS_DEFAULT;
                ent->client->ps.gravity = 0;
                ent->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
                ent->client->ps.eFlags2 |= EF2_FLYING;
                ent->count = 30; // SEEKER shot ammo count
        }
        //***I'm not sure whether I should leave this as a TEAM_ switch, I think NPC_class may be more appropriate - dmv
        switch(ent->client->playerTeam)
        {
        case NPCTEAM_PLAYER:
                //ent->flags |= FL_NO_KNOCKBACK;
                if ( ent->client->NPC_class == CLASS_JEDI || ent->client->NPC_class == CLASS_LUKE )
                {//good jedi
                        ent->client->enemyTeam = NPCTEAM_ENEMY;
                        if ( ent->spawnflags & JSF_AMBUSH )
                        {//ambusher
                                ent->NPC->scriptFlags |= SCF_IGNORE_ALERTS;
                                ent->client->noclip = qtrue;//hang
                        }
                }
                else
                {
                        /*
                        if (ent->client->ps.weapon != WP_NONE)
                        {
                                G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
                        }
                        */
                        switch ( ent->client->ps.weapon )
                        {
                        case WP_BRYAR_PISTOL://FIXME: new weapon: imp blaster pistol
        //              case WP_BLASTER_PISTOL:
                        case WP_DISRUPTOR:
                        case WP_BOWCASTER:
                        case WP_REPEATER:
                        case WP_DEMP2:
                        case WP_FLECHETTE:
                        case WP_ROCKET_LAUNCHER:
                        default:
                                break;
                        case WP_THERMAL:
                        case WP_BLASTER:
                                //FIXME: health in NPCs.cfg, and not all blaster users are stormtroopers
                                //ent->health = 25;
                                //FIXME: not necc. a ST
                                ST_ClearTimers( ent );
                                if ( ent->NPC->rank >= RANK_LT || ent->client->ps.weapon == WP_THERMAL )
                                {//officers, grenade-throwers use alt-fire
                                        //ent->health = 50;
                                        //ent->NPC->scriptFlags |= SCF_ALT_FIRE;
                                }
                                break;
                        }
                }
                if ( ent->client->NPC_class == CLASS_KYLE || ent->client->NPC_class == CLASS_VEHICLE || (ent->spawnflags & SFB_CINEMATIC) )
                {
                        ent->NPC->defaultBehavior = BS_CINEMATIC;
                }
                else
                {
                        /*
                        ent->NPC->defaultBehavior = BS_FOLLOW_LEADER;
                        ent->client->leader = &g_entities[0];
                        */
                }
                break;

        case NPCTEAM_NEUTRAL: 

                if ( Q_stricmp( ent->NPC_type, "gonk" ) == 0 ) 
                {
                        // I guess we generically make them player usable
                        ent->r.svFlags |= SVF_PLAYER_USABLE;

                        // Not even sure if we want to give different levels of batteries?  ...Or even that these are the values we'd want to use.
                        /*
                        switch ( g_spskill.integer )
                        {
                        case 0: //      EASY
                                ent->client->ps.batteryCharge = MAX_BATTERIES * 0.8f; 
                                break;
                        case 1: //      MEDIUM
                                ent->client->ps.batteryCharge = MAX_BATTERIES * 0.75f; 
                                break;
                        default :
                        case 2: //      HARD
                                ent->client->ps.batteryCharge = MAX_BATTERIES * 0.5f; 
                                break;
                        }*/
                        //rwwFIXMEFIXME: Make use of this.
                }
                break;

        case NPCTEAM_ENEMY:
                {
                        ent->NPC->defaultBehavior = BS_DEFAULT;
                        if ( ent->client->NPC_class == CLASS_SHADOWTROOPER )
                        {//FIXME: a spawnflag?
                                Jedi_Cloak( ent );
                        }
                        if( ent->client->NPC_class == CLASS_TAVION ||
                                ent->client->NPC_class == CLASS_REBORN ||
                                ent->client->NPC_class == CLASS_DESANN ||
                                ent->client->NPC_class == CLASS_SHADOWTROOPER )
                        {
                                ent->client->enemyTeam = NPCTEAM_PLAYER;
                                if ( ent->spawnflags & JSF_AMBUSH )
                                {//ambusher
                                        ent->NPC->scriptFlags |= SCF_IGNORE_ALERTS;
                                        ent->client->noclip = qtrue;//hang
                                }
                        }
                        else if( ent->client->NPC_class == CLASS_PROBE || ent->client->NPC_class == CLASS_REMOTE ||
                                                ent->client->NPC_class == CLASS_INTERROGATOR || ent->client->NPC_class == CLASS_SENTRY)
                        {               
                                ent->NPC->defaultBehavior = BS_DEFAULT;
                                ent->client->ps.gravity = 0;
                                ent->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
                                ent->client->ps.eFlags2 |= EF2_FLYING;
                        }
                        else 
                        {
                //              G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
                                switch ( ent->client->ps.weapon )
                                {
                                case WP_BRYAR_PISTOL:
                                        break;
                //              case WP_BLASTER_PISTOL:
                //                      break;
                                case WP_DISRUPTOR:
                                        //Sniper
                                        //ent->NPC->scriptFlags |= SCF_ALT_FIRE;//FIXME: use primary fire sometimes?  Up close?  Different class of NPC?
                                        break;
                                case WP_BOWCASTER:
                                        break;
                                case WP_REPEATER:
                                        //machine-gunner
                                        break;
                                case WP_DEMP2:
                                        break;
                                case WP_FLECHETTE:
                                        //shotgunner
                                        if ( !Q_stricmp( "stofficeralt", ent->NPC_type ) )
                                        {
                                                //ent->NPC->scriptFlags |= SCF_ALT_FIRE;
                                        }
                                        break;
                                case WP_ROCKET_LAUNCHER:
                                        break;
                                case WP_THERMAL:
                                        //Gran, use main, bouncy fire
//                                      ent->NPC->scriptFlags |= SCF_ALT_FIRE;
                                        break;
                                case WP_STUN_BATON:
                                        break;
                                default:
                                case WP_BLASTER:
                                        //FIXME: health in NPCs.cfg, and not all blaster users are stormtroopers
                                        //FIXME: not necc. a ST
                                        ST_ClearTimers( ent );
                                        if ( ent->NPC->rank >= RANK_COMMANDER )
                                        {//commanders use alt-fire
                                                //ent->NPC->scriptFlags |= SCF_ALT_FIRE;
                                        }
                                        if ( !Q_stricmp( "rodian2", ent->NPC_type ) )
                                        {
                                                //ent->NPC->scriptFlags |= SCF_ALT_FIRE;
                                        }
                                        break;
                                }
                                if ( !Q_stricmp( "galak_mech", ent->NPC_type ) )
                                {//starts with armor
                                        NPC_GalakMech_Init( ent );
                                }
                        }
                }
                break;

        default:
                break;
        }


        if ( ent->client->NPC_class == CLASS_SEEKER
                && ent->activator )
        {//assume my teams are already set correctly
        }
        else
        {
                //for siege, want "bad" npc's allied with the "bad" team
                if (g_gametype.integer == GT_SIEGE && ent->s.NPC_class != CLASS_VEHICLE)
                {
                        if (ent->client->enemyTeam == NPCTEAM_PLAYER)
                        {
                                ent->client->sess.sessionTeam = SIEGETEAM_TEAM1;
                        }
                        else if (ent->client->enemyTeam == NPCTEAM_ENEMY)
                        {
                                ent->client->sess.sessionTeam = SIEGETEAM_TEAM2;
                        }
                        else
                        {
                                ent->client->sess.sessionTeam = TEAM_FREE;
                        }
                }
        }

        if ( ent->client->NPC_class == CLASS_ATST || ent->client->NPC_class == CLASS_MARK1 ) // chris/steve/kevin requested that the mark1 be shielded also
        {
                ent->flags |= (FL_SHIELDED|FL_NO_KNOCKBACK);
        }
}

/*
-------------------------
NPC_WeaponsForTeam
-------------------------
*/

int NPC_WeaponsForTeam( team_t team, int spawnflags, const char *NPC_type )
{
        //*** not sure how to handle this, should I pass in class instead of team and go from there? - dmv
        switch(team)
        {
        // no longer exists
//      case TEAM_BORG:
//              break;

//      case TEAM_HIROGEN:
//              if( Q_stricmp( "hirogenalpha", NPC_type ) == 0 )
//                      return ( 1 << WP_BLASTER);
                //Falls through

//      case TEAM_KLINGON:

                //NOTENOTE: Falls through

//      case TEAM_IMPERIAL:
        case NPCTEAM_ENEMY:
                if ( Q_stricmp( "tavion", NPC_type ) == 0 || 
                        Q_strncmp( "reborn", NPC_type, 6 ) == 0 || 
                        Q_stricmp( "desann", NPC_type ) == 0 || 
                        Q_strncmp( "shadowtrooper", NPC_type, 13 ) == 0 )
                        return ( 1 << WP_SABER);
//                      return ( 1 << WP_IMPERIAL_BLADE);
                //NOTENOTE: Falls through if not a knife user

//      case TEAM_SCAVENGERS:
//      case TEAM_MALON:
                //FIXME: default weapon in npc config?
                if ( Q_strncmp( "stofficer", NPC_type, 9 ) == 0 )
                {
                        return ( 1 << WP_FLECHETTE);
                }
                if ( Q_stricmp( "stcommander", NPC_type ) == 0 )
                {
                        return ( 1 << WP_REPEATER);
                }
                if ( Q_stricmp( "swamptrooper", NPC_type ) == 0 )
                {
                        return ( 1 << WP_FLECHETTE);
                }
                if ( Q_stricmp( "swamptrooper2", NPC_type ) == 0 )
                {
                        return ( 1 << WP_REPEATER);
                }
                if ( Q_stricmp( "rockettrooper", NPC_type ) == 0 )
                {
                        return ( 1 << WP_ROCKET_LAUNCHER);
                }
                if ( Q_strncmp( "shadowtrooper", NPC_type, 13 ) == 0 )
                {
                        return ( 1 << WP_SABER);//|( 1 << WP_RAPID_CONCUSSION)?
                }
                if ( Q_stricmp( "imperial", NPC_type ) == 0 )
                {
                        //return ( 1 << WP_BLASTER_PISTOL);
                        return ( 1 << WP_BLASTER);
                }
                if ( Q_strncmp( "impworker", NPC_type, 9 ) == 0 )
                {
                        //return ( 1 << WP_BLASTER_PISTOL);
                        return ( 1 << WP_BLASTER);
                }
                if ( Q_stricmp( "stormpilot", NPC_type ) == 0 )
                {
                        //return ( 1 << WP_BLASTER_PISTOL);
                        return ( 1 << WP_BLASTER);
                }
                if ( Q_stricmp( "galak", NPC_type ) == 0 )
                {
                        return ( 1 << WP_BLASTER);
                }
                if ( Q_stricmp( "galak_mech", NPC_type ) == 0 )
                {
                        return ( 1 << WP_REPEATER);
                }
                if ( Q_strncmp( "ugnaught", NPC_type, 8 ) == 0 )
                {
                        return WP_NONE;
                }
                if ( Q_stricmp( "granshooter", NPC_type ) == 0 )
                {
                        return ( 1 << WP_BLASTER);
                }
                if ( Q_stricmp( "granboxer", NPC_type ) == 0 )
                {
                        return ( 1 << WP_STUN_BATON);
                }
                if ( Q_strncmp( "gran", NPC_type, 4 ) == 0 )
                {
                        return (( 1 << WP_THERMAL)|( 1 << WP_STUN_BATON));
                }
                if ( Q_stricmp( "rodian", NPC_type ) == 0 )
                {
                        return ( 1 << WP_DISRUPTOR);
                }
                if ( Q_stricmp( "rodian2", NPC_type ) == 0 )
                {
                        return ( 1 << WP_BLASTER);
                }

                if (( Q_stricmp( "interrogator",NPC_type) == 0) || ( Q_stricmp( "sentry",NPC_type) == 0) || (Q_strncmp( "protocol",NPC_type,8) == 0) )
                {
                        return WP_NONE;
                }

                if ( Q_strncmp( "weequay", NPC_type, 7 ) == 0 )
                {
                        return ( 1 << WP_BOWCASTER);//|( 1 << WP_STAFF )(FIXME: new weap?)
                }
                if ( Q_stricmp( "impofficer", NPC_type ) == 0 )
                {
                        return ( 1 << WP_BLASTER);
                }
                if ( Q_stricmp( "impcommander", NPC_type ) == 0 )
                {
                        return ( 1 << WP_BLASTER);
                }
                if (( Q_stricmp( "probe", NPC_type ) == 0 ) || ( Q_stricmp( "seeker", NPC_type ) == 0 ))
                {
                        //return ( 1 << WP_BOT_LASER);
                        return 0;
                }       
                if ( Q_stricmp( "remote", NPC_type ) == 0 )
                {
                        //return ( 1 << WP_BOT_LASER );
                        return 0;
                }       
                if ( Q_stricmp( "trandoshan", NPC_type ) == 0 )
                {
                        return (1<<WP_REPEATER);
                }
                if ( Q_stricmp( "atst", NPC_type ) == 0 )
                {
                        //return (( 1 << WP_ATST_MAIN)|( 1 << WP_ATST_SIDE));
                        return 0;
                }
                if ( Q_stricmp( "mark1", NPC_type ) == 0 )
                {
                        //return ( 1 << WP_BOT_LASER);
                        return 0;
                }
                if ( Q_stricmp( "mark2", NPC_type ) == 0 )
                {
                        //return ( 1 << WP_BOT_LASER);
                        return 0;
                }
                if ( Q_stricmp( "minemonster", NPC_type ) == 0 )
                {
                        return (( 1 << WP_STUN_BATON));
                }
                if ( Q_stricmp( "howler", NPC_type ) == 0 )
                {
                        return (( 1 << WP_STUN_BATON));
                }
                //Stormtroopers, etc.
                return ( 1 << WP_BLASTER);
                break;

        case NPCTEAM_PLAYER:
                
//              if(spawnflags & SFB_TRICORDER)
//                      return ( 1 << WP_TRICORDER);
                
                if(spawnflags & SFB_RIFLEMAN)
                        return ( 1 << WP_REPEATER);
                
                if(spawnflags & SFB_PHASER)
                        //return ( 1 << WP_BLASTER_PISTOL);
                        return ( 1 << WP_BLASTER);

                if ( Q_strncmp( "jedi", NPC_type, 4 ) == 0 || Q_stricmp( "luke", NPC_type ) == 0 )
                        return ( 1 << WP_SABER);

                if ( Q_strncmp( "prisoner", NPC_type, 8 ) == 0 )
                {
                        return WP_NONE;
                }
                if ( Q_strncmp( "bespincop", NPC_type, 9 ) == 0 )
                {
                        //return ( 1 << WP_BLASTER_PISTOL);
                        return ( 1 << WP_BLASTER);
                }

                if ( Q_stricmp( "MonMothma", NPC_type ) == 0 )
                {
                        return WP_NONE;
                }

                //rebel
                return ( 1 << WP_BLASTER);
                break;

        case NPCTEAM_NEUTRAL:

                if ( Q_stricmp( "mark1", NPC_type ) == 0 )
                {
                        return WP_NONE;
                }       
                if ( Q_stricmp( "mark2", NPC_type ) == 0 )
                {
                        return WP_NONE;
                }       
                if ( Q_strncmp( "ugnaught", NPC_type, 8 ) == 0 )
                {
                        return WP_NONE;
                }       
                if ( Q_stricmp( "bartender", NPC_type ) == 0 )
                {
                        return WP_NONE;
                }
                if ( Q_stricmp( "morgankatarn", NPC_type ) == 0 )
                {
                        return WP_NONE;
                }
        
                break;

        // these no longer exist
//      case TEAM_FORGE:
//              return ( 1 << WP_STUN_BATON);
//              break;

//      case TEAM_STASIS:
//              return ( 1 << WP_STUN_BATON);
//              break;

//      case TEAM_PARASITE:
//              break;

//      case TEAM_8472:
//              break;

        default:
                break;
        }

        return WP_NONE;
}

extern void ChangeWeapon( gentity_t *ent, int newWeapon );

/*
-------------------------
NPC_SetWeapons
-------------------------
*/

void NPC_SetWeapons( gentity_t *ent )
{
        int                     bestWeap = WP_NONE;
        int                     curWeap;
        int                     weapons = NPC_WeaponsForTeam( ent->client->playerTeam, ent->spawnflags, ent->NPC_type );

        ent->client->ps.stats[STAT_WEAPONS] = 0;
        for ( curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
        {
                if ( (weapons & ( 1 << curWeap )) )
                {
                        ent->client->ps.stats[STAT_WEAPONS] |= ( 1 << curWeap );
//                      RegisterItem( FindItemForWeapon( (weapon_t)(curWeap) ) );       //precache the weapon
                        //rwwFIXMEFIXME: Precache
                        ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[curWeap].ammoIndex] = 100;//FIXME: max ammo

                        if ( bestWeap == WP_SABER )
                        {
                                // still want to register other weapons -- force saber to be best weap
                                continue;
                        }

                        if ( curWeap == WP_STUN_BATON )
                        {
                                if ( bestWeap == WP_NONE )
                                {// We'll only consider giving Melee since we haven't found anything better yet.
                                        bestWeap = curWeap;
                                }
                        }
                        else if ( curWeap > bestWeap || bestWeap == WP_STUN_BATON )
                        {
                                // This will never override saber as best weap.  Also will override WP_STUN_BATON if something better comes later in the list
                                bestWeap = curWeap;
                        }
                }
        }

        ent->client->ps.weapon = bestWeap;
}

/*
-------------------------
NPC_SpawnEffect

  NOTE:  Make sure any effects called here have their models, tga's and sounds precached in
                        CG_RegisterNPCEffects in cg_player.cpp
-------------------------
*/

void NPC_SpawnEffect (gentity_t *ent)
{
}

//--------------------------------------------------------------
// NPC_SetFX_SpawnStates
//
// Set up any special parms for spawn effects
//--------------------------------------------------------------
void NPC_SetFX_SpawnStates( gentity_t *ent )
{
        if ( !(ent->NPC->aiFlags&NPCAI_CUSTOM_GRAVITY) )
        {
                ent->client->ps.gravity = g_gravity.value;
        }
}

/*
================
NPC_SpotWouldTelefrag

================
*/
qboolean NPC_SpotWouldTelefrag( gentity_t *npc )
{
        int                     i, num;
        int                     touch[MAX_GENTITIES];
        gentity_t       *hit;
        vec3_t          mins, maxs;

        VectorAdd( npc->r.currentOrigin, npc->r.mins, mins );
        VectorAdd( npc->r.currentOrigin, npc->r.maxs, maxs );
        num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );

        for (i=0 ; i<num ; i++)
        {
                hit = &g_entities[touch[i]];
                //if ( hit->client && hit->client->ps.stats[STAT_HEALTH] > 0 ) {
                if (hit->inuse 
                        && hit->client 
                        && hit->s.number != npc->s.number 
                        && (hit->r.contents&MASK_NPCSOLID)
                        && hit->s.number != npc->r.ownerNum
                        && hit->r.ownerNum != npc->s.number)
                {
                        return qtrue;
                }

        }

        return qfalse;
}

//--------------------------------------------------------------
void NPC_Begin (gentity_t *ent)
{
        vec3_t  spawn_origin, spawn_angles;
        gclient_t       *client;
        usercmd_t       ucmd;
        gentity_t       *spawnPoint = NULL;

        memset( &ucmd, 0, sizeof( ucmd ) );

        if ( !(ent->spawnflags & SFB_NOTSOLID) )
        {//No NPCs should telefrag
                if (NPC_SpotWouldTelefrag(ent))
                {
                        if ( ent->wait < 0 )
                        {//remove yourself
                                G_DebugPrint( WL_DEBUG, "NPC %s could not spawn, firing target3 (%s) and removing self\n", ent->targetname, ent->target3 );
                                //Fire off our target3
                                G_UseTargets2( ent, ent, ent->target3 );

                                //Kill us
                                ent->think = G_FreeEntity;
                                ent->nextthink = level.time + 100;
                        }
                        else
                        {
                                G_DebugPrint( WL_DEBUG, "NPC %s could not spawn, waiting %4.2 secs to try again\n", ent->targetname, ent->wait/1000.0f );
                                ent->think = NPC_Begin;
                                ent->nextthink = level.time + ent->wait;//try again in half a second
                        }
                        return;
                }
        }
        //Spawn effect
        NPC_SpawnEffect( ent );

        VectorCopy( ent->client->ps.origin, spawn_origin);
        VectorCopy( ent->s.angles, spawn_angles);
        spawn_angles[YAW] = ent->NPC->desiredYaw;

        client = ent->client;

        // increment the spawncount so the client will detect the respawn
        client->ps.persistant[PERS_SPAWN_COUNT]++;

        client->airOutTime = level.time + 12000;

        client->ps.clientNum = ent->s.number;
        // clear entity values

        if ( ent->health )      // Was health supplied in map
        {
                client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = ent->health;
        }
        else if ( ent->NPC->stats.health )      // Was health supplied in NPC.cfg?
        {
                
                if ( ent->client->NPC_class != CLASS_REBORN
                        && ent->client->NPC_class != CLASS_SHADOWTROOPER 
                        //&& ent->client->NPC_class != CLASS_TAVION
                        //&& ent->client->NPC_class != CLASS_DESANN 
                        && ent->client->NPC_class != CLASS_JEDI )
                {// up everyone except jedi
                        ent->NPC->stats.health += ent->NPC->stats.health/4 * g_spskill.integer; // 100% on easy, 125% on medium, 150% on hard
                }
                
                client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = ent->NPC->stats.health;
        }
        else
        {
                client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = 100;
        }

        if ( !Q_stricmp( "rodian", ent->NPC_type ) )
        {//sniper
                //NOTE: this will get overridden by any aim settings in their spawnscripts
                switch ( g_spskill.integer )
                {
                case 0:
                        ent->NPC->stats.aim = 1;
                        break;
                case 1:
                        ent->NPC->stats.aim = Q_irand( 2, 3 );
                        break;
                case 2:
                        ent->NPC->stats.aim = Q_irand( 3, 4 );
                        break;
                }
        }
        else if ( ent->client->NPC_class == CLASS_STORMTROOPER
                || ent->client->NPC_class == CLASS_SWAMPTROOPER
                || ent->client->NPC_class == CLASS_IMPWORKER
                || !Q_stricmp( "rodian2", ent->NPC_type ) )
        {//tweak yawspeed for these NPCs based on difficulty
                switch ( g_spskill.integer )
                {
                case 0:
                        ent->NPC->stats.yawSpeed *= 0.75f;
                        if ( ent->client->NPC_class == CLASS_IMPWORKER )
                        {
                                ent->NPC->stats.aim -= Q_irand( 3, 6 );
                        }
                        break;
                case 1:
                        if ( ent->client->NPC_class == CLASS_IMPWORKER )
                        {
                                ent->NPC->stats.aim -= Q_irand( 2, 4 );
                        }
                        break;
                case 2:
                        ent->NPC->stats.yawSpeed *= 1.5f;
                        if ( ent->client->NPC_class == CLASS_IMPWORKER )
                        {
                                ent->NPC->stats.aim -= Q_irand( 0, 2 );
                        }
                        break;
                }
        }
        else if ( ent->client->NPC_class == CLASS_REBORN
                || ent->client->NPC_class == CLASS_SHADOWTROOPER )
        {
                switch ( g_spskill.integer )
                {
                case 1:
                        ent->NPC->stats.yawSpeed *= 1.25f;
                        break;
                case 2:
                        ent->NPC->stats.yawSpeed *= 1.5f;
                        break;
                }
        }


        ent->s.groundEntityNum = ENTITYNUM_NONE;
        ent->mass = 10;
        ent->takedamage = qtrue;
        ent->inuse = qtrue;
        ent->classname = "NPC";
//      if ( ent->client->race == RACE_HOLOGRAM )
//      {//can shoot through holograms, but not walk through them
//              ent->contents = CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_ITEM;//contents_corspe to make them show up in ID and use traces
//              ent->clipmask = MASK_NPCSOLID;
//      } else
        if(!(ent->spawnflags & SFB_NOTSOLID))
        {
                ent->r.contents = CONTENTS_BODY;
                ent->clipmask = MASK_NPCSOLID;
        }
        else
        {
                ent->r.contents = 0;
                ent->clipmask = MASK_NPCSOLID&~CONTENTS_BODY;
        }
        /*
        if(!ent->client->moveType)//Static?
        {
                ent->client->moveType = MT_RUNJUMP;
        }
        */
        //rwwFIXMEFIXME: movetype support

        ent->die = player_die;
        ent->waterlevel = 0;
        ent->watertype = 0;
        ent->client->ps.rocketLockIndex = ENTITYNUM_NONE;
        ent->client->ps.rocketLockTime = 0;
        
        //visible to player and NPCs
        if ( ent->client->NPC_class != CLASS_R2D2 &&
                ent->client->NPC_class != CLASS_R5D2 &&
                ent->client->NPC_class != CLASS_MOUSE &&
                ent->client->NPC_class != CLASS_GONK &&
                ent->client->NPC_class != CLASS_PROTOCOL )
        {
                ent->flags &= ~FL_NOTARGET;
        }
        ent->s.eFlags &= ~EF_NODRAW;

        NPC_SetFX_SpawnStates( ent );
        
        //client->ps.friction = 6;
        //rwwFIXMEFIXME: per ent friction?

        if ( ent->client->ps.weapon == WP_NONE )
        {//not set by the NPCs.cfg
                NPC_SetWeapons(ent);
        }
        //select the weapon
        ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[ent->client->ps.weapon].ammoIndex];
        ent->client->ps.weaponstate = WEAPON_IDLE;
        ChangeWeapon( ent, ent->client->ps.weapon );

        VectorCopy( spawn_origin, client->ps.origin );

        // the respawned flag will be cleared after the attack and jump keys come up
        client->ps.pm_flags |= PMF_RESPAWNED;

        // clear entity state values
        //ent->s.eType = ET_PLAYER;
        ent->s.eType = ET_NPC;
//      ent->s.skinNum = ent - g_entities - 1;  // used as index to get custom models

        VectorCopy (spawn_origin, ent->s.origin);
//      ent->s.origin[2] += 1;  // make sure off ground

        SetClientViewAngle( ent, spawn_angles );
        client->renderInfo.lookTarget = ENTITYNUM_NONE;

        if(!(ent->spawnflags & 64))
        {
                G_KillBox( ent );
                trap_LinkEntity (ent);
        }

        // don't allow full run speed for a bit
        client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
        client->ps.pm_time = 100;

        client->respawnTime = level.time;
        client->inactivityTime = level.time + g_inactivity.value * 1000;
        client->latched_buttons = 0;
        if ( ent->s.m_iVehicleNum )
        {//I'm an NPC in a vehicle (or a vehicle), I already have owner set
        }
        else if ( client->NPC_class == CLASS_SEEKER && ent->activator != NULL )
        {//somebody else "owns" me
                ent->s.owner = ent->r.ownerNum = ent->activator->s.number;
        }
        else
        {
                ent->s.owner = ENTITYNUM_NONE;
        }

        // set default animations
        if ( ent->client->NPC_class != CLASS_VEHICLE )
        {
                NPC_SetAnim( ent, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_NORMAL );
        }

        if( spawnPoint )
        {
                // fire the targets of the spawn point
                G_UseTargets( spawnPoint, ent );
        }

        //ICARUS include
        trap_ICARUS_InitEnt( ent );

//==NPC initialization
        SetNPCGlobals( ent );

        ent->enemy = NULL;
        NPCInfo->timeOfDeath = 0;
        NPCInfo-