codemp/game/NPC_stats.c

Go to the documentation of this file.

//NPC_stats.cpp
#include "b_local.h"
#include "b_public.h"
#include "anims.h"
#include "../ghoul2/G2.h"

extern qboolean NPCsPrecached;

#include "../namespace_begin.h"
extern qboolean WP_SaberParseParms( const char *SaberName, saberInfo_t *saber );
extern void WP_RemoveSaber( saberInfo_t *sabers, int saberNum );
#include "../namespace_end.h"

stringID_table_t TeamTable[] =
{
        ENUM2STRING(NPCTEAM_FREE),                      // caution, some code checks a team_t via "if (!team_t_varname)" so I guess this should stay as entry 0, great or what? -slc
        ENUM2STRING(NPCTEAM_PLAYER),
        ENUM2STRING(NPCTEAM_ENEMY),
        ENUM2STRING(NPCTEAM_NEUTRAL),   // most droids are team_neutral, there are some exceptions like Probe,Seeker,Interrogator
        "",     -1
};

// this list was made using the model directories, this MUST be in the same order as the CLASS_ enum in teams.h
stringID_table_t ClassTable[] =
{
        ENUM2STRING(CLASS_NONE),                                // hopefully this will never be used by an npc), just covering all bases
        ENUM2STRING(CLASS_ATST),                                // technically droid...
        ENUM2STRING(CLASS_BARTENDER),
        ENUM2STRING(CLASS_BESPIN_COP),          
        ENUM2STRING(CLASS_CLAW),
        ENUM2STRING(CLASS_COMMANDO),
        ENUM2STRING(CLASS_DESANN),                      
        ENUM2STRING(CLASS_FISH),
        ENUM2STRING(CLASS_FLIER2),
        ENUM2STRING(CLASS_GALAK),
        ENUM2STRING(CLASS_GLIDER),
        ENUM2STRING(CLASS_GONK),                                // droid
        ENUM2STRING(CLASS_GRAN),
        ENUM2STRING(CLASS_HOWLER),
//      ENUM2STRING(CLASS_RANCOR),
        ENUM2STRING(CLASS_IMPERIAL),
        ENUM2STRING(CLASS_IMPWORKER),
        ENUM2STRING(CLASS_INTERROGATOR),                // droid 
        ENUM2STRING(CLASS_JAN),                         
        ENUM2STRING(CLASS_JEDI),                                
        ENUM2STRING(CLASS_KYLE),
        ENUM2STRING(CLASS_LANDO),                       
        ENUM2STRING(CLASS_LIZARD),
        ENUM2STRING(CLASS_LUKE),                                
        ENUM2STRING(CLASS_MARK1),                       // droid
        ENUM2STRING(CLASS_MARK2),                       // droid
        ENUM2STRING(CLASS_GALAKMECH),           // droid
        ENUM2STRING(CLASS_MINEMONSTER),
        ENUM2STRING(CLASS_MONMOTHA),                    
        ENUM2STRING(CLASS_MORGANKATARN),
        ENUM2STRING(CLASS_MOUSE),                       // droid
        ENUM2STRING(CLASS_MURJJ),
        ENUM2STRING(CLASS_PRISONER),
        ENUM2STRING(CLASS_PROBE),                       // droid
        ENUM2STRING(CLASS_PROTOCOL),                    // droid
        ENUM2STRING(CLASS_R2D2),                                // droid
        ENUM2STRING(CLASS_R5D2),                                // droid
        ENUM2STRING(CLASS_REBEL),
        ENUM2STRING(CLASS_REBORN),
        ENUM2STRING(CLASS_REELO),
        ENUM2STRING(CLASS_REMOTE),
        ENUM2STRING(CLASS_RODIAN),
        ENUM2STRING(CLASS_SEEKER),                      // droid
        ENUM2STRING(CLASS_SENTRY),
        ENUM2STRING(CLASS_SHADOWTROOPER),
        ENUM2STRING(CLASS_STORMTROOPER),
        ENUM2STRING(CLASS_SWAMP),
        ENUM2STRING(CLASS_SWAMPTROOPER),
        ENUM2STRING(CLASS_TAVION),
        ENUM2STRING(CLASS_TRANDOSHAN),
        ENUM2STRING(CLASS_UGNAUGHT),
        ENUM2STRING(CLASS_JAWA),
        ENUM2STRING(CLASS_WEEQUAY),
        ENUM2STRING(CLASS_BOBAFETT),
        //ENUM2STRING(CLASS_ROCKETTROOPER),
        //ENUM2STRING(CLASS_PLAYER),
        ENUM2STRING(CLASS_VEHICLE),
        ENUM2STRING(CLASS_RANCOR),
        ENUM2STRING(CLASS_WAMPA),
        "",     -1
};

stringID_table_t BSTable[] =
{
        ENUM2STRING(BS_DEFAULT),//# default behavior for that NPC
        ENUM2STRING(BS_ADVANCE_FIGHT),//# Advance to captureGoal and shoot enemies if you can
        ENUM2STRING(BS_SLEEP),//# Play awake script when startled by sound
        ENUM2STRING(BS_FOLLOW_LEADER),//# Follow your leader and shoot any enemies you come across
        ENUM2STRING(BS_JUMP),//# Face navgoal and jump to it.
        ENUM2STRING(BS_SEARCH),//# Using current waypoint as a base), search the immediate branches of waypoints for enemies
        ENUM2STRING(BS_WANDER),//# Wander down random waypoint paths
        ENUM2STRING(BS_NOCLIP),//# Moves through walls), etc.
        ENUM2STRING(BS_REMOVE),//# Waits for player to leave PVS then removes itself
        ENUM2STRING(BS_CINEMATIC),//# Does nothing but face it's angles and move to a goal if it has one
        //the rest are internal only
        "",                             -1,
};

#define stringIDExpand(str, strEnum)    str, strEnum, ENUM2STRING(strEnum)

stringID_table_t BSETTable[] =
{
        ENUM2STRING(BSET_SPAWN),//# script to use when first spawned
        ENUM2STRING(BSET_USE),//# script to use when used
        ENUM2STRING(BSET_AWAKE),//# script to use when awoken/startled
        ENUM2STRING(BSET_ANGER),//# script to use when aquire an enemy
        ENUM2STRING(BSET_ATTACK),//# script to run when you attack
        ENUM2STRING(BSET_VICTORY),//# script to run when you kill someone
        ENUM2STRING(BSET_LOSTENEMY),//# script to run when you can't find your enemy
        ENUM2STRING(BSET_PAIN),//# script to use when take pain
        ENUM2STRING(BSET_FLEE),//# script to use when take pain below 50% of health
        ENUM2STRING(BSET_DEATH),//# script to use when killed
        ENUM2STRING(BSET_DELAYED),//# script to run when self->delayScriptTime is reached
        ENUM2STRING(BSET_BLOCKED),//# script to run when blocked by a friendly NPC or player
        ENUM2STRING(BSET_BUMPED),//# script to run when bumped into a friendly NPC or player (can set bumpRadius)
        ENUM2STRING(BSET_STUCK),//# script to run when blocked by a wall
        ENUM2STRING(BSET_FFIRE),//# script to run when player shoots their own teammates
        ENUM2STRING(BSET_FFDEATH),//# script to run when player kills a teammate
        stringIDExpand("", BSET_INVALID),
        "",                             -1,
};

#include "../namespace_begin.h"
extern stringID_table_t WPTable[];
extern stringID_table_t FPTable[];
#include "../namespace_end.h"

char    *TeamNames[TEAM_NUM_TEAMS] = 
{
        "",
//      "starfleet",
//      "borg",
//      "parasite",
//      "scavengers",
//      "klingon",
//      "malon",
//      "hirogen",
//      "imperial",
//      "stasis",
//      "species8472",
//      "dreadnought",
//      "forge",
//      "disguise",
//      "player (not valid)"
        "player",
        "enemy",
        "neutral"
};

// this list was made using the model directories, this MUST be in the same order as the CLASS_ enum in teams.h
char    *ClassNames[CLASS_NUM_CLASSES] = 
{
        "",                             // class none
        "atst",
        "bartender",
        "bespin_cop",
        "claw",
        "commando",
        "desann",
        "fish",
        "flier2",
        "galak",
        "glider",
        "gonk",                 
        "gran",
        "howler",
        "imperial",
        "impworker",
        "interrogator",
        "jan",
        "jedi",
        "kyle",
        "lando",
        "lizard",
        "luke",
        "mark1",
        "mark2",
        "galak_mech",
        "minemonster",
        "monmotha",
        "morgankatarn",
        "mouse",
        "murjj",
        "prisoner",
        "probe",
        "protocol",
        "r2d2",
        "r5d2",
        "rebel",
        "reborn",
        "reelo",
        "remote",
        "rodian",
        "seeker",
        "sentry",
        "shadowtrooper",
        "stormtrooper",
        "swamp",
        "swamptrooper",
        "tavion",
        "trandoshan",
        "ugnaught",
        "weequay",
        "bobafett",
        "vehicle",
        "rancor",
        "wampa",
};


/*
NPC_ReactionTime
*/
//FIXME use grandom in here
int NPC_ReactionTime ( void ) 
{
        return 200 * ( 6 - NPCInfo->stats.reactions );
}

//
// parse support routines
//

#include "../namespace_begin.h"
extern qboolean BG_ParseLiteral( const char **data, const char *string );
#include "../namespace_end.h"

//
// NPC parameters file : scripts/NPCs.cfg
//
#define MAX_NPC_DATA_SIZE 0x20000
char    NPCParms[MAX_NPC_DATA_SIZE];
char    NPCFile[MAX_QPATH];

/*
team_t TranslateTeamName( const char *name ) 
{
        int n;

        for ( n = (NPCTEAM_FREE + 1); n < NPCTEAM_NUM_TEAMS; n++ )
        {
                if ( Q_stricmp( TeamNames[n], name ) == 0 )
                {
                        return ((team_t) n);
                }
        }
        
        return NPCTEAM_FREE;
}

class_t TranslateClassName( const char *name ) 
{
        int n;

        for ( n = (CLASS_NONE + 1); n < CLASS_NUM_CLASSES; n++ )
        {
                if ( Q_stricmp( ClassNames[n], name ) == 0 )
                {
                        return ((class_t) n);
                }
        }
        
        return CLASS_NONE;  // I hope this never happens, maybe print a warning
}
*/

/*
static race_t TranslateRaceName( const char *name ) 
{
        if ( !Q_stricmp( name, "human" ) ) 
        {
                return RACE_HUMAN;
        }
        return RACE_NONE;
}
*/
/*
static rank_t TranslateRankName( const char *name ) 

  Should be used to determine pip bolt-ons
*/
static rank_t TranslateRankName( const char *name ) 
{
        if ( !Q_stricmp( name, "civilian" ) ) 
        {
                return RANK_CIVILIAN;
        }

        if ( !Q_stricmp( name, "crewman" ) ) 
        {
                return RANK_CREWMAN;
        }
        
        if ( !Q_stricmp( name, "ensign" ) ) 
        {
                return RANK_ENSIGN;
        }
        
        if ( !Q_stricmp( name, "ltjg" ) ) 
        {
                return RANK_LT_JG;
        }
        
        if ( !Q_stricmp( name, "lt" ) ) 
        {
                return RANK_LT;
        }
        
        if ( !Q_stricmp( name, "ltcomm" ) ) 
        {
                return RANK_LT_COMM;
        }
        
        if ( !Q_stricmp( name, "commander" ) ) 
        {
                return RANK_COMMANDER;
        }
        
        if ( !Q_stricmp( name, "captain" ) ) 
        {
                return RANK_CAPTAIN;
        }

        return RANK_CIVILIAN;
}

#include "../namespace_begin.h"
extern saber_colors_t TranslateSaberColor( const char *name );
#include "../namespace_end.h"

/* static int MethodNameToNumber( const char *name ) {
        if ( !Q_stricmp( name, "EXPONENTIAL" ) ) {
                return METHOD_EXPONENTIAL;
        }
        if ( !Q_stricmp( name, "LINEAR" ) ) {
                return METHOD_LINEAR;
        }
        if ( !Q_stricmp( name, "LOGRITHMIC" ) ) {
                return METHOD_LOGRITHMIC;
        }
        if ( !Q_stricmp( name, "ALWAYS" ) ) {
                return METHOD_ALWAYS;
        }
        if ( !Q_stricmp( name, "NEVER" ) ) {
                return METHOD_NEVER;
        }
        return -1;
}

static int ItemNameToNumber( const char *name, int itemType ) {
//      int             n;

        for ( n = 0; n < bg_numItems; n++ ) {
                if ( bg_itemlist[n].type != itemType ) {
                        continue;
                }
                if ( Q_stricmp( bg_itemlist[n].classname, name ) == 0 ) {
                        return bg_itemlist[n].tag;
                }
        }
        return -1;
}
*/

//rwwFIXMEFIXME: movetypes
/*
static int MoveTypeNameToEnum( const char *name ) 
{
        if(!Q_stricmp("runjump", name))
        {
                return MT_RUNJUMP;
        }
        else if(!Q_stricmp("walk", name))
        {
                return MT_WALK;
        }
        else if(!Q_stricmp("flyswim", name))
        {
                return MT_FLYSWIM;
        }
        else if(!Q_stricmp("static", name))
        {
                return MT_STATIC;
        }

        return MT_STATIC;
}
*/

//#define CONVENIENT_ANIMATION_FILE_DEBUG_THING

#ifdef CONVENIENT_ANIMATION_FILE_DEBUG_THING
void SpewDebugStuffToFile(animation_t *anims)
{
        char BGPAFtext[40000];
        fileHandle_t f;
        int i = 0;

        trap_FS_FOpenFile("file_of_debug_stuff_SP.txt", &f, FS_WRITE);

        if (!f)
        {
                return;
        }

        BGPAFtext[0] = 0;

        while (i < MAX_ANIMATIONS)
        {
                strcat(BGPAFtext, va("%i %i\n", i, anims[i].frameLerp));
                i++;
        }

        trap_FS_Write(BGPAFtext, strlen(BGPAFtext), f);
        trap_FS_FCloseFile(f);
}
#endif

qboolean G_ParseAnimFileSet( const char *filename, const char *animCFG, int *animFileIndex )
{
        *animFileIndex = BG_ParseAnimationFile(filename, NULL, qfalse);
        //if it's humanoid we should have it cached and return it, if it is not it will be loaded (unless it's also cached already)

        if (*animFileIndex == -1)
        {
                return qfalse;
        }

        //I guess this isn't really even needed game-side.
        //BG_ParseAnimationSndFile(filename, *animFileIndex);
        return qtrue;
}

void NPC_PrecacheAnimationCFG( const char *NPC_type )
{
#if 0 //rwwFIXMEFIXME: Actually precache stuff here.
        char    filename[MAX_QPATH];
        const char      *token;
        const char      *value;
        const char      *p;
        int             junk;

        if ( !Q_stricmp( "random", NPC_type ) )
        {//sorry, can't precache a random just yet
                return;
        }

        p = NPCParms;
        COM_BeginParseSession(NPCFile);

        // look for the right NPC
        while ( p ) 
        {
                token = COM_ParseExt( &p, qtrue );
                if ( token[0] == 0 )
                        return;

                if ( !Q_stricmp( token, NPC_type ) ) 
                {
                        break;
                }

                SkipBracedSection( &p );
        }

        if ( !p ) 
        {
                return;
        }

        if ( BG_ParseLiteral( &p, "{" ) ) 
        {
                return;
        }

        // parse the NPC info block
        while ( 1 ) 
        {
                token = COM_ParseExt( &p, qtrue );
                if ( !token[0] ) 
                {
                        Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", NPC_type );
                        return;
                }

                if ( !Q_stricmp( token, "}" ) ) 
                {
                        break;
                }

                // legsmodel
                if ( !Q_stricmp( token, "legsmodel" ) ) 
                {
                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }
                        //must copy data out of this pointer into a different part of memory because the funcs we're about to call will call COM_ParseExt
                        Q_strncpyz( filename, value, sizeof( filename ) );
                        G_ParseAnimFileSet( filename, filename, &junk );
                        return;
                }

                // playerModel
                if ( !Q_stricmp( token, "playerModel" ) ) 
                {
                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }
                        /*
                        char    animName[MAX_QPATH];
                        char    *GLAName;
                        char    *slash = NULL;
                        char    *strippedName;
                        
                        int handle = gi.G2API_PrecacheGhoul2Model( va( "models/players/%s/model.glm", value ) );
                        if ( handle > 0 )//FIXME: isn't 0 a valid handle?
                        {
                                GLAName = gi.G2API_GetAnimFileNameIndex( handle );
                                if ( GLAName )
                                {
                                        Q_strncpyz( animName, GLAName, sizeof( animName ), qtrue );
                                        slash = strrchr( animName, '/' );
                                        if ( slash )
                                        {
                                                *slash = 0;
                                        }
                                        strippedName = COM_SkipPath( animName );

                                        //must copy data out of this pointer into a different part of memory because the funcs we're about to call will call COM_ParseExt
                                        Q_strncpyz( filename, value, sizeof( filename ), qtrue );
                                        G_ParseAnimFileSet( value, strippedName, &junk );//qfalse );
                                        //FIXME: still not precaching the animsounds.cfg?
                                        return;
                                }
                        }
                        */
                        //rwwFIXMEFIXME: Do this properly.
                }
        }
#endif
}

extern int NPC_WeaponsForTeam( team_t team, int spawnflags, const char *NPC_type );
void NPC_PrecacheWeapons( team_t playerTeam, int spawnflags, char *NPCtype )
{
        int weapons = NPC_WeaponsForTeam( playerTeam, spawnflags, NPCtype );
        int curWeap;

        for ( curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
        {
                if (weapons & (1 << curWeap))
                {
                        RegisterItem(BG_FindItemForWeapon((weapon_t)curWeap));
                }
        }

#if 0 //rwwFIXMEFIXME: actually precache weapons here
        int weapons = NPC_WeaponsForTeam( playerTeam, spawnflags, NPCtype );
        gitem_t *item;
        for ( int curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
        {
                if ( (weapons & ( 1 << curWeap )) )
                {
                        item = FindItemForWeapon( ((weapon_t)(curWeap)) );      //precache the weapon
                        CG_RegisterItemSounds( (item-bg_itemlist) );
                        CG_RegisterItemVisuals( (item-bg_itemlist) );
                        //precache the in-hand/in-world ghoul2 weapon model

                        char weaponModel[64];
                        
                        strcpy (weaponModel, weaponData[curWeap].weaponMdl);    
                        if (char *spot = strstr(weaponModel, ".md3") ) {
                                *spot = 0;
                                spot = strstr(weaponModel, "_w");//i'm using the in view weapon array instead of scanning the item list, so put the _w back on
                                if (!spot) {
                                        strcat (weaponModel, "_w");
                                }
                                strcat (weaponModel, ".glm");   //and change to ghoul2
                        }
                        gi.G2API_PrecacheGhoul2Model( weaponModel ); // correct way is item->world_model
                }
        }
#endif
}

/*
void NPC_Precache ( char *NPCName )

Precaches NPC skins, tgas and md3s.

*/
void NPC_Precache ( gentity_t *spawner )
{
        npcteam_t                       playerTeam = NPCTEAM_FREE;
        const char      *token;
        const char      *value;
        const char      *p;
        char    *patch;
        char    sound[MAX_QPATH];
        qboolean        md3Model = qfalse;
        char    playerModel[MAX_QPATH];
        char    customSkin[MAX_QPATH];

        if ( !Q_stricmp( "random", spawner->NPC_type ) )
        {//sorry, can't precache a random just yet
                return;
        }
        strcpy(customSkin,"default");

        p = NPCParms;
        COM_BeginParseSession(NPCFile);

        // look for the right NPC
        while ( p ) 
        {
                token = COM_ParseExt( &p, qtrue );
                if ( token[0] == 0 )
                        return;

                if ( !Q_stricmp( token, spawner->NPC_type ) ) 
                {
                        break;
                }

                SkipBracedSection( &p );
        }

        if ( !p ) 
        {
                return;
        }

        if ( BG_ParseLiteral( &p, "{" ) ) 
        {
                return;
        }

        // parse the NPC info block
        while ( 1 ) 
        {
                token = COM_ParseExt( &p, qtrue );
                if ( !token[0] ) 
                {
                        Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", spawner->NPC_type );
                        return;
                }

                if ( !Q_stricmp( token, "}" ) ) 
                {
                        break;
                }

                // headmodel
                if ( !Q_stricmp( token, "headmodel" ) ) 
                {
                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }

                        if(!Q_stricmp("none", value))
                        {
                        }
                        else
                        {
                                //Q_strncpyz( ri.headModelName, value, sizeof(ri.headModelName), qtrue);
                        }
                        md3Model = qtrue;
                        continue;
                }
                
                // torsomodel
                if ( !Q_stricmp( token, "torsomodel" ) ) 
                {
                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }

                        if(!Q_stricmp("none", value))
                        {
                        }
                        else
                        {
                                //Q_strncpyz( ri.torsoModelName, value, sizeof(ri.torsoModelName), qtrue);
                        }
                        md3Model = qtrue;
                        continue;
                }

                // legsmodel
                if ( !Q_stricmp( token, "legsmodel" ) ) 
                {
                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }
                        //Q_strncpyz( ri.legsModelName, value, sizeof(ri.legsModelName), qtrue);                        
                        md3Model = qtrue;
                        continue;
                }

                // playerModel
                if ( !Q_stricmp( token, "playerModel" ) ) 
                {
                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }
                        Q_strncpyz( playerModel, value, sizeof(playerModel));                   
                        md3Model = qfalse;
                        continue;
                }

                // customSkin
                if ( !Q_stricmp( token, "customSkin" ) ) 
                {
                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }
                        Q_strncpyz( customSkin, value, sizeof(customSkin));                     
                        continue;
                }

                // playerTeam
                if ( !Q_stricmp( token, "playerTeam" ) ) 
                {
                        char tk[4096]; //rww - hackilicious!

                        if ( COM_ParseString( &p, &value ) ) 
                        {
                                continue;
                        }
                        //playerTeam = TranslateTeamName(value);
                        Com_sprintf(tk, sizeof(tk), "NPC%s", token);
                        playerTeam = (team_t)GetIDForString( TeamTable, tk );
                        continue;
                }

        
                // snd
                if ( !Q_stricmp( token, "snd" ) ) {
                        if ( COM_ParseString( &p, &value ) ) {
                                continue;
                        }
                        if ( !(spawner->r.svFlags&SVF_NO_BASIC_SOUNDS) )
                        {
                                //FIXME: store this in some sound field or parse in the soundTable like the animTable...
                                Q_strncpyz( sound, value, sizeof( sound ) );
                                patch = strstr( sound, "/" );
                                if ( patch ) 
                                {
                                        *patch = 0;
                                }
                                spawner->s.csSounds_Std = G_SoundIndex( va("*$%s", sound) );
                        }
                        continue;
                }

                // sndcombat
                if ( !Q_stricmp( token, "sndcombat" ) ) {
                        if ( COM_ParseString( &p, &value ) ) {
                                continue;
                        }
                        if ( !(spawner->r.svFlags&SVF_NO_COMBAT_SOUNDS) )
                        {
                                //FIXME: store this in some sound field or parse in the soundTable like the animTable...
                                Q_strncpyz( sound, value, sizeof( sound ) );
                                patch = strstr( sound, "/" );
                                if ( patch ) 
                                {
                                        *patch = 0;
                                }
                                spawner->s.csSounds_Combat = G_SoundIndex( va("*$%s", sound) );
                        }
                        continue;
                }
                
                // sndextra
                if ( !Q_stricmp( token, "sndextra" ) ) {
                        if ( COM_ParseString( &p, &value ) ) {
                                continue;
                        }
                        if ( !(spawner->r.svFlags&SVF_NO_EXTRA_SOUNDS) )
                        {
                                //FIXME: store this in some sound field or parse in the soundTable like the animTable...
                                Q_strncpyz( sound, value, sizeof( sound ) );
                                patch = strstr( sound, "/" );
                                if ( patch ) 
                                {
                                        *patch = 0;
                                }
                                spawner->s.csSounds_Extra = G_SoundIndex( va("*$%s", sound) );
                        }
                        continue;
                }

                // sndjedi
                if ( !Q_stricmp( token, "sndjedi" ) ) {
                        if ( COM_ParseString( &p, &value ) ) {
                                continue;
                        }
                        if ( !(spawner->r.svFlags&SVF_NO_EXTRA_SOUNDS) )
                        {
                                //FIXME: store this in some sound field or parse in the soundTable like the animTable...
                                Q_strncpyz( sound, value, sizeof( sound ) );
                                patch = strstr( sound, "/" );
                                if ( patch ) 
                                {
                                        *patch = 0;
                                }
                                spawner->s.csSounds_Jedi = G_SoundIndex( va("*$%s", sound) );
                        }
                        continue;
                }

                if (!Q_stricmp(token, "weapon"))
                {
                        int curWeap;

                        if (COM_ParseString(&p, &value))
                        {
                                continue;
                        }

                        curWeap = GetIDForString( WPTable, value );

                        if (curWeap > WP_NONE && curWeap < WP_NUM_WEAPONS)
                        {
                                RegisterItem(BG_FindItemForWeapon((weapon_t)curWeap));
                        }
                        continue;
                }
        }

        // If we're not a vehicle, then an error here would be valid...
        if ( !spawner->client || spawner->client->NPC_class != CLASS_VEHICLE )
        {
                if ( md3Model )
                {
                        Com_Printf("MD3 model using NPCs are not supported in MP\n");
                }
                else
                { //if we have a model/skin then index them so they'll be registered immediately
                        //when the client gets a configstring update.
                        char modelName[MAX_QPATH];

                        Com_sprintf(modelName, sizeof(modelName), "models/players/%s/model.glm", playerModel);
                        if (customSkin[0])
                        { //append it after a *
                                strcat( modelName, va("*%s", customSkin) );
                        }

                        G_ModelIndex(modelName);
                }
        }

        //precache this NPC's possible weapons
        NPC_PrecacheWeapons( playerTeam, spawner->spawnflags, spawner->NPC_type );

//      CG_RegisterNPCCustomSounds( &ci );
//      CG_RegisterNPCEffects( playerTeam );
        //rwwFIXMEFIXME: same
        //FIXME: Look for a "sounds" directory and precache death, pain, alert sounds
}

#if 0
void NPC_BuildRandom( gentity_t *NPC )
{
        int     sex, color, head;

        sex = Q_irand(0, 2);
        color = Q_irand(0, 2);
        switch( sex )
        {
        case 0://female
                head = Q_irand(0, 2);
                switch( head )
                {
                default:
                case 0:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "garren", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        break;
                case 1:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "garren/salma", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        break;
                case 2:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "garren/mackey", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        color = Q_irand(3, 5);//torso needs to be afam
                        break;
                }
                switch( color )
                {
                default:
                case 0:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/gold", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                case 1:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                case 2:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/blue", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                case 3:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/aframG", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                case 4:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/aframR", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                case 5:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/aframB", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                }
                Q_strncpyz( NPC->client->renderInfo.legsModelName, "crewfemale", sizeof(NPC->client->renderInfo.legsModelName), qtrue );
                break;
        default:
        case 1://male
        case 2://male
                head = Q_irand(0, 4);
                switch( head )
                {
                default:
                case 0:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "chakotay/nelson", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        break;
                case 1:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "paris/chase", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        break;
                case 2:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "doctor/pasty", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        break;
                case 3:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "kim/durk", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        break;
                case 4:
                        Q_strncpyz( NPC->client->renderInfo.headModelName, "paris/kray", sizeof(NPC->client->renderInfo.headModelName), qtrue );
                        break;
                }
                switch( color )
                {
                default:
                case 0:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewthin/red", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                case 1:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewthin", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                case 2:
                        Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewthin/blue", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
                        break;
                        //NOTE: 3 - 5 should be red, gold & blue, afram hands
                }
                Q_strncpyz( NPC->client->renderInfo.legsModelName, "crewthin", sizeof(NPC->client->renderInfo.legsModelName), qtrue );
                break;
        }

        NPC->s.modelScale[0] = NPC->s.modelScale[1] = NPC->s.modelScale[2] = Q_irand(87, 102)/100.0f;
//      NPC->client->race = RACE_HUMAN;
        NPC->NPC->rank = RANK_CREWMAN;
        NPC->client->playerTeam = NPC->s.teamowner = TEAM_PLAYER;
        NPC->client->clientInfo.customBasicSoundDir = "kyle";//FIXME: generic default?
}
#endif

extern void SetupGameGhoul2Model(gentity_t *ent, char *modelname, char *skinName);
qboolean NPC_ParseParms( const char *NPCName, gentity_t *NPC ) 
{
        const char      *token;
        const char      *value;
        const char      *p;
        int             n;
        float   f;
        char    *patch;
        char    sound[MAX_QPATH];
        char    playerModel[MAX_QPATH];
        char    customSkin[MAX_QPATH];
        renderInfo_t    *ri = &NPC->client->renderInfo;
        gNPCstats_t             *stats = NULL;
        qboolean        md3Model = qtrue;
        char    surfOff[1024];
        char    surfOn[1024];
        qboolean parsingPlayer = qfalse;
        vec3_t playerMins;
        vec3_t playerMaxs;
        int npcSaber1 = 0;
        int npcSaber2 = 0;

        VectorSet(playerMins, -15, -15, DEFAULT_MINS_2);
        VectorSet(playerMaxs, 15, 15, DEFAULT_MAXS_2);

        strcpy(customSkin,"default");
        if ( !NPCName || !NPCName[0]) 
        {
                NPCName = "Player";
        }

        if ( !NPC->s.number && NPC->client != NULL )
        {//player, only want certain data
                parsingPlayer = qtrue;
        }

        if ( NPC->NPC )
        {
                stats = &NPC->NPC->stats;
/*
        NPC->NPC->allWeaponOrder[0]     = WP_BRYAR_PISTOL;
        NPC->NPC->allWeaponOrder[1]     = WP_SABER;
        NPC->NPC->allWeaponOrder[2]     = WP_IMOD;
        NPC->NPC->allWeaponOrder[3]     = WP_SCAVENGER_RIFLE;
        NPC->NPC->allWeaponOrder[4]     = WP_TRICORDER;
        NPC->NPC->allWeaponOrder[6]     = WP_NONE;
        NPC->NPC->allWeaponOrder[6]     = WP_NONE;
        NPC->NPC->allWeaponOrder[7]     = WP_NONE;
*/
                // fill in defaults
                stats->aggression       = 3;
                stats->aim                      = 3;
                stats->earshot          = 1024;
                stats->evasion          = 3;
                stats->hfov                     = 90;
                stats->intelligence     = 3;
                stats->move                     = 3;
                stats->reactions        = 3;
                stats->vfov                     = 60;
                stats->vigilance        = 0.1f;
                stats->visrange         = 1024;

                stats->health           = 0;

                stats->yawSpeed         = 90;
                stats->walkSpeed        = 90;
                stats->runSpeed         = 300;
                stats->acceleration     = 15;//Increase/descrease speed this much per frame (20fps)
        }
        else
        {
                stats = NULL;
        }

        //Set defaults
        //FIXME: should probably put default torso and head models, but what about enemies
        //that don't have any- like Stasis?
        //Q_strncpyz( ri->headModelName,        DEFAULT_HEADMODEL,  sizeof(ri->headModelName),  qtrue);
        //Q_strncpyz( ri->torsoModelName, DEFAULT_TORSOMODEL, sizeof(ri->torsoModelName),       qtrue);
        //Q_strncpyz( ri->legsModelName,        DEFAULT_LEGSMODEL,  sizeof(ri->legsModelName),  qtrue);
        //FIXME: should we have one for weapon too?
        memset( (char *)surfOff, 0, sizeof(surfOff) );
        memset( (char *)surfOn, 0, sizeof(surfOn) );
        
        /*
        ri->headYawRangeLeft = 50;
        ri->headYawRangeRight = 50;
        ri->headPitchRangeUp = 40;
        ri->headPitchRangeDown = 50;
        ri->torsoYawRangeLeft = 60;
        ri->torsoYawRangeRight = 60;
        ri->torsoPitchRangeUp = 30;
        ri->torsoPitchRangeDown = 70;
        */

        ri->headYawRangeLeft = 80;
        ri->headYawRangeRight = 80;
        ri->headPitchRangeUp = 45;
        ri->headPitchRangeDown = 45;
        ri->torsoYawRangeLeft = 60;
        ri->torsoYawRangeRight = 60;
        ri->torsoPitchRangeUp = 30;
        ri->torsoPitchRangeDown = 50;

        VectorCopy(playerMins, NPC->r.mins);
        VectorCopy(playerMaxs, NPC->r.maxs);
        NPC->client->ps.crouchheight = CROUCH_MAXS_2;
        NPC->client->ps.standheight = DEFAULT_MAXS_2;

        //rwwFIXMEFIXME: ...
        /*
        NPC->client->moveType           = MT_RUNJUMP;

        NPC->client->dismemberProbHead = 100;
        NPC->client->dismemberProbArms = 100;
        NPC->client->dismemberProbHands = 100;
        NPC->client->dismemberProbWaist = 100;
        NPC->client->dismemberProbLegs = 100;

        NPC->s.modelScale[0] = NPC->s.modelScale[1] = NPC->s.modelScale[2] = 1.0f;
        */

        NPC->client->ps.customRGBA[0]=255;
        NPC->client->ps.customRGBA[1]=255;
        NPC->client->ps.customRGBA[2]=255;
        NPC->client->ps.customRGBA[3]=255;

        if ( !Q_stricmp( "random", NPCName ) )
        {//Randomly assemble a starfleet guy
                //NPC_BuildRandom( NPC );
                Com_Printf("RANDOM NPC NOT SUPPORTED IN MP\n");
                return qfalse;
        }
        else
        {
                int fp;

                p = NPCParms;
                COM_BeginParseSession(NPCFile);

                // look for the right NPC
                while ( p ) 
                {
                        token = COM_ParseExt( &p, qtrue );
                        if ( token[0] == 0 )
                        {
                                return qfalse;
                        }

                        if ( !Q_stricmp( token, NPCName ) ) 
                        {
                                break;
                        }

                        SkipBracedSection( &p );
                }
                if ( !p ) 
                {
                        return qfalse;
                }

                if ( BG_ParseLiteral( &p, "{" ) ) 
                {
                        return qfalse;
                }
                        
                // parse the NPC info block
                while ( 1 ) 
                {
                        token = COM_ParseExt( &p, qtrue );
                        if ( !token[0] ) 
                        {
                                Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", NPCName );
                                return qfalse;
                        }

                        if ( !Q_stricmp( token, "}" ) ) 
                        {
                                break;
                        }
        //===MODEL PROPERTIES===========================================================
                        // custom color
                        if ( !Q_stricmp( token, "customRGBA" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }
                                if ( !Q_stricmp( value, "random") )
                                {
                                        NPC->client->ps.customRGBA[0]=Q_irand(0,255);
                                        NPC->client->ps.customRGBA[1]=Q_irand(0,255);
                                        NPC->client->ps.customRGBA[2]=Q_irand(0,255);
                                        NPC->client->ps.customRGBA[3]=255;
                                } 
                                else 
                                {
                                        NPC->client->ps.customRGBA[0]=atoi(value);
                                        
                                        if ( COM_ParseInt( &p, &n ) ) 
                                        {
                                                continue;
                                        }
                                        NPC->client->ps.customRGBA[1]=n;
                                        
                                        if ( COM_ParseInt( &p, &n ) ) 
                                        {
                                                continue;
                                        }
                                        NPC->client->ps.customRGBA[2]=n;
                                        
                                        if ( COM_ParseInt( &p, &n ) ) 
                                        {
                                                continue;
                                        }
                                        NPC->client->ps.customRGBA[3]=n;
                                }
                                continue;
                        }

                        // headmodel
                        if ( !Q_stricmp( token, "headmodel" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }

                                if(!Q_stricmp("none", value))
                                {
                                        //Zero the head clamp range so the torso & legs don't lag behind
                                        ri->headYawRangeLeft = 
                                        ri->headYawRangeRight = 
                                        ri->headPitchRangeUp = 
                                        ri->headPitchRangeDown = 0;
                                }
                                continue;
                        }
                        
                        // torsomodel
                        if ( !Q_stricmp( token, "torsomodel" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }

                                if(!Q_stricmp("none", value))
                                {
                                        //Zero the torso clamp range so the legs don't lag behind
                                        ri->torsoYawRangeLeft = 
                                        ri->torsoYawRangeRight = 
                                        ri->torsoPitchRangeUp = 
                                        ri->torsoPitchRangeDown = 0;
                                }
                                continue;
                        }

                        // legsmodel
                        if ( !Q_stricmp( token, "legsmodel" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }
                                /*
                                Q_strncpyz( ri->legsModelName, value, sizeof(ri->legsModelName), qtrue);                        
                                //Need to do this here to get the right index
                                G_ParseAnimFileSet( ri->legsModelName, ri->legsModelName, &ci->animFileIndex );
                                */
                                continue;
                        }

                        // playerModel
                        if ( !Q_stricmp( token, "playerModel" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }
                                Q_strncpyz( playerModel, value, sizeof(playerModel));                   
                                md3Model = qfalse;
                                continue;
                        }
                        
                        // customSkin
                        if ( !Q_stricmp( token, "customSkin" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }
                                Q_strncpyz( customSkin, value, sizeof(customSkin));                     
                                continue;
                        }

                        // surfOff
                        if ( !Q_stricmp( token, "surfOff" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }
                                if ( surfOff[0] )
                                {
                                        Q_strcat( (char *)surfOff, sizeof(surfOff), "," );
                                        Q_strcat( (char *)surfOff, sizeof(surfOff), value );
                                }
                                else
                                {
                                        Q_strncpyz( surfOff, value, sizeof(surfOff));
                                }
                                continue;
                        }
                        
                        // surfOn
                        if ( !Q_stricmp( token, "surfOn" ) ) 
                        {
                                if ( COM_ParseString( &p, &value ) ) 
                                {
                                        continue;
                                }
                                if ( surfOn[0] )
                                {
                                        Q_strcat( (char *)surfOn, sizeof(surfOn), "," );
                                        Q_strcat( (char *)surfOn, sizeof(surfOn), value );
                                }
                                else
                                {
                                        Q_strncpyz( surfOn, value, sizeof(surfOn));
                                }
                                continue;
                        }
                        
                        //headYawRangeLeft
                        if ( !Q_stricmp( token, "headYawRangeLeft" ) ) 
                        {
                                if ( COM_ParseInt( &p, &n ) ) 
                                {
                                        SkipRestOfLine( &p );
                                        continue;
                                }
                                if ( n < 0 ) 
                                {
                                        Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
                                        continue;
                                }
                                ri->headYawRangeLeft = n;
                                continue;
                        }

                        //headYawRangeRight
                        if ( !Q_stricmp( token, "headYawRangeRight" ) ) 
                        {
                                if ( COM_ParseInt( &p, &n ) ) 
                                {
                                        SkipRestOfLine( &p );
                                        continue;
                                }
                                if ( n < 0 ) 
                                {
                                        Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
                                        continue;
                                }
                                ri->headYawRangeRight = n;
                                continue;
                        }

                        //headPitchRangeUp
                        if ( !Q_stricmp( token, "headPitchRangeUp" ) ) 
                        {
                                if ( COM_ParseInt( &p, &n ) ) 
                                {