jediacademypc/code/game/NPC_stats.cpp

//NPC_stats.cpp
// leave this line at the top for all NPC_xxxx.cpp files...
#include "g_headers.h"

#include "b_local.h"
#include "b_public.h"
#include "anims.h"
#include "wp_saber.h"
#include "g_Vehicles.h"
#if !defined(RUFL_HSTRING_INC)
	#include "..\Rufl\hstring.h"
#endif
	#include "..\Ratl\string_vs.h"
	#include "..\Rufl\hstring.h"
	#include "..\Ratl\vector_vs.h"

extern void WP_RemoveSaber( gentity_t *ent, int saberNum );
extern qboolean NPCsPrecached;
extern vec3_t playerMins;
extern vec3_t playerMaxs;
extern stringID_table_t WPTable[];

#define		MAX_MODELS_PER_LEVEL	40

#ifdef _XBOX
using dllNamespace::hstring;
#endif
hstring		modelsAlreadyDone[MAX_MODELS_PER_LEVEL];


stringID_table_t animEventTypeTable[] = 
{
	ENUM2STRING(AEV_SOUND),			//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
	ENUM2STRING(AEV_FOOTSTEP),		//# animID AEV_FOOTSTEP framenum footstepType
	ENUM2STRING(AEV_EFFECT),		//# animID AEV_EFFECT framenum effectpath boltName
	ENUM2STRING(AEV_FIRE),			//# animID AEV_FIRE framenum altfire chancetofire
	ENUM2STRING(AEV_MOVE),			//# animID AEV_MOVE framenum forwardpush rightpush uppush
	ENUM2STRING(AEV_SOUNDCHAN),		//# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay 
	//must be terminated
	NULL,-1
};

stringID_table_t footstepTypeTable[] = 
{
	ENUM2STRING(FOOTSTEP_R),
	ENUM2STRING(FOOTSTEP_L),
	ENUM2STRING(FOOTSTEP_HEAVY_R),
	ENUM2STRING(FOOTSTEP_HEAVY_L),
	//must be terminated
	NULL,-1
};

stringID_table_t FPTable[] =
{
	ENUM2STRING(FP_HEAL),
	ENUM2STRING(FP_LEVITATION),
	ENUM2STRING(FP_SPEED),
	ENUM2STRING(FP_PUSH),
	ENUM2STRING(FP_PULL),
	ENUM2STRING(FP_TELEPATHY),
	ENUM2STRING(FP_GRIP),
	ENUM2STRING(FP_LIGHTNING),
	ENUM2STRING(FP_SABERTHROW),
	ENUM2STRING(FP_SABER_DEFENSE),
	ENUM2STRING(FP_SABER_OFFENSE),
	//new Jedi Academy powers
	ENUM2STRING(FP_RAGE),
	ENUM2STRING(FP_PROTECT),
	ENUM2STRING(FP_ABSORB),
	ENUM2STRING(FP_DRAIN),
	ENUM2STRING(FP_SEE),
	"",	-1
};


stringID_table_t TeamTable[] =
{
	"free", TEAM_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(TEAM_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
	"player", TEAM_PLAYER,
	ENUM2STRING(TEAM_PLAYER),
	"enemy", TEAM_ENEMY,
	ENUM2STRING(TEAM_ENEMY),
	"neutral", TEAM_NEUTRAL,	// most droids are team_neutral, there are some exceptions like Probe,Seeker,Interrogator
	ENUM2STRING(TEAM_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_SAND_CREATURE),
	ENUM2STRING(CLASS_WAMPA),
	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_SABOTEUR),
	ENUM2STRING(CLASS_STORMTROOPER),
	ENUM2STRING(CLASS_SWAMP),
	ENUM2STRING(CLASS_SWAMPTROOPER),
	ENUM2STRING(CLASS_NOGHRI),
	ENUM2STRING(CLASS_TAVION),
	ENUM2STRING(CLASS_ALORA),
	ENUM2STRING(CLASS_TRANDOSHAN),
	ENUM2STRING(CLASS_UGNAUGHT),
	ENUM2STRING(CLASS_JAWA),
	ENUM2STRING(CLASS_WEEQUAY),
	ENUM2STRING(CLASS_TUSKEN),
	ENUM2STRING(CLASS_BOBAFETT),
	ENUM2STRING(CLASS_ROCKETTROOPER),
	ENUM2STRING(CLASS_SABER_DROID),
	ENUM2STRING(CLASS_PLAYER),
	ENUM2STRING(CLASS_ASSASSIN_DROID),
	ENUM2STRING(CLASS_HAZARD_TROOPER),
	ENUM2STRING(CLASS_VEHICLE),
	"",	-1
};

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

//
// parse support routines
//

qboolean G_ParseLiteral( const char **data, const char *string ) 
{
	const char	*token;

	token = COM_ParseExt( data, qtrue );
	if ( token[0] == 0 ) 
	{
		gi.Printf( "unexpected EOF\n" );
		return qtrue;
	}

	if ( Q_stricmp( token, string ) ) 
	{
		gi.Printf( "required string '%s' missing\n", string );
		return qtrue;
	}

	return qfalse;
}

//
// NPC parameters file : ext_data/NPCs/*.npc*
//
#define MAX_NPC_DATA_SIZE 0x20000
char	NPCParms[MAX_NPC_DATA_SIZE];

/*
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;
}

#ifdef _XBOX
extern saber_colors_t TranslateSaberColor( const char *name );
#else
saber_colors_t TranslateSaberColor( const char *name ) 
{
	if ( !Q_stricmp( name, "red" ) ) 
	{
		return SABER_RED;
	}
	if ( !Q_stricmp( name, "orange" ) ) 
	{
		return SABER_ORANGE;
	}
	if ( !Q_stricmp( name, "yellow" ) ) 
	{
		return SABER_YELLOW;
	}
	if ( !Q_stricmp( name, "green" ) ) 
	{
		return SABER_GREEN;
	}
	if ( !Q_stricmp( name, "blue" ) ) 
	{
		return SABER_BLUE;
	}
	if ( !Q_stricmp( name, "purple" ) ) 
	{
		return SABER_PURPLE;
	}
	if ( !Q_stricmp( name, "random" ) ) 
	{
		return ((saber_colors_t)(Q_irand( SABER_ORANGE, SABER_PURPLE )));
	}
	return SABER_BLUE;
}
#endif

/* 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;
}
*/

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;
}

extern void CG_RegisterClientRenderInfo(clientInfo_t *ci, renderInfo_t *ri);
extern void CG_RegisterClientModels (int entityNum);
extern void CG_RegisterNPCCustomSounds( clientInfo_t *ci );
//extern void CG_RegisterNPCEffects( team_t team );

//#define CONVENIENT_ANIMATION_FILE_DEBUG_THING

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

	gi.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, bgGlobalAnimations[i].frameLerp));
		i++;
	}

	gi.FS_Write(BGPAFtext, strlen(BGPAFtext), f);
	gi.FS_FCloseFile(f);
}
#endif

int CG_CheckAnimFrameForEventType( animevent_t *animEvents, int keyFrame, animEventType_t eventType, unsigned short modelIndex )
{
	for ( int i = 0; i < MAX_ANIM_EVENTS; i++ )
	{
		if ( animEvents[i].keyFrame == keyFrame )
		{//there is an animevent on this frame already
			if ( animEvents[i].eventType == eventType )
			{//and it is of the same type
				if ( animEvents[i].modelOnly == modelIndex )
				{//and it is for the same model
					return i;
				}
			}
		}
	}
	//nope
	return -1;
}

/*
======================
ParseAnimationEvtBlock
======================
*/
static void ParseAnimationEvtBlock(int glaIndex, unsigned short modelIndex, const char* aeb_filename, animevent_t *animEvents, animation_t *animations, unsigned char &lastAnimEvent, const char **text_p, bool bIsFrameSkipped)
{
	const char		*token;
	int				num, n, animNum, keyFrame, lowestVal, highestVal, curAnimEvent = 0;
	animEventType_t	eventType;
	char			stringData[MAX_QPATH];

	// get past starting bracket
	while(1) 
	{
		token = COM_Parse( text_p );
		if ( !Q_stricmp( token, "{" ) ) 
		{
			break;
		}
	}

	//NOTE: instead of a blind increment, increase the index
	//			this way if we have an event on an anim that already
	//			has an event of that type, it stomps it

	// read information for each frame
	while ( 1 ) 
	{
		if ( lastAnimEvent >= MAX_ANIM_EVENTS )
		{
			CG_Error( "ParseAnimationEvtBlock: number events in file %s > MAX_ANIM_EVENTS(%i)", aeb_filename, MAX_ANIM_EVENTS );
		}
		// Get base frame of sequence
		token = COM_Parse( text_p );
		if ( !token || !token[0]) 
		{
			break;
		}

		if ( !Q_stricmp( token, "}" ) )		// At end of block 
		{
			break;
		}

		//Compare to same table as animations used 
		//	so we don't have to use actual numbers for animation first frames,
		//	just need offsets.
		//This way when animation numbers change, this table won't have to be updated,
		//	at least not much.
		animNum = GetIDForString(animTable, token);
		if(animNum == -1)
		{//Unrecognized ANIM ENUM name,
			Com_Printf(S_COLOR_YELLOW"WARNING: Unknown ANIM %s in file %s\n", token, aeb_filename );
			//skip this entry
			SkipRestOfLine( text_p );
			continue;
		}

		if ( animations[animNum].numFrames == 0 )
		{//we don't use this anim
#ifndef FINAL_BUILD
			Com_Printf(S_COLOR_YELLOW"WARNING: %s: anim %s not used by this model\n", aeb_filename, token);
#endif
			//skip this entry
			SkipRestOfLine( text_p );
			continue;
		}

		token = COM_Parse( text_p );
		eventType = (animEventType_t)GetIDForString(animEventTypeTable, token);
		if ( eventType == AEV_NONE || eventType == -1 )
		{//Unrecognized ANIM EVENT TYPE
			Com_Printf(S_COLOR_RED"ERROR: Unknown EVENT %s in animEvent file %s\n", token, aeb_filename );
			continue;
		}

		// Get offset to frame within sequence
		token = COM_Parse( text_p );
		if ( !token ) 
		{
			break;
		}

		keyFrame = atoi( token );
		if ( bIsFrameSkipped && 
			(animations[animNum].numFrames>1) // important, else frame 1 gets divided down and becomes frame 0. Carcass & Assimilate also work this way
			)
		{
			keyFrame /= 2;	// if we ever use any other value in frame-skipping we'll have to figure out some way of reading it, since it's not stored anywhere
		}
		if(keyFrame >= animations[animNum].numFrames)
		{
			Com_Printf(S_COLOR_YELLOW"WARNING: Event out of range on %s in %s\n", GetStringForID(animTable,animNum), aeb_filename );
			assert(keyFrame < animations[animNum].numFrames);
			keyFrame = animations[animNum].numFrames-1;	//clamp it
		}

		//set our start frame
		keyFrame += animations[animNum].firstFrame;

		//see if this frame already has an event of this type on it, if so, overwrite it
		curAnimEvent = CG_CheckAnimFrameForEventType( animEvents, keyFrame, eventType, modelIndex );
		if ( curAnimEvent == -1 )
		{//this anim frame doesn't already have an event of this type on it
			curAnimEvent = lastAnimEvent;
		}

		//now that we know which event index we're going to plug the data into, start doing it
		animEvents[curAnimEvent].eventType = eventType;
		assert(keyFrame >= 0 && keyFrame < 65535);	//
		animEvents[curAnimEvent].keyFrame = keyFrame;
		animEvents[curAnimEvent].glaIndex = glaIndex;
		animEvents[curAnimEvent].modelOnly = modelIndex;
		int tempVal;

		//now read out the proper data based on the type
		switch ( animEvents[curAnimEvent].eventType )
		{
		case AEV_SOUNDCHAN:		//# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay
			token = COM_Parse( text_p );
			if ( !token ) 
			{
				break;
			}
			if ( stricmp( token, "CHAN_VOICE_ATTEN" ) == 0 )
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE_ATTEN;
			}
			else if ( stricmp( token, "CHAN_VOICE_GLOBAL" ) == 0 )
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE_GLOBAL;
			}
			else if ( stricmp( token, "CHAN_ANNOUNCER" ) == 0 )
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_ANNOUNCER;
			}
			else if ( stricmp( token, "CHAN_BODY" ) == 0 )
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_BODY;
			}
			else if ( stricmp( token, "CHAN_WEAPON" ) == 0 )
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_WEAPON;
			}
			else if ( stricmp( token, "CHAN_VOICE" ) == 0 )
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE;
			} 
			else
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_AUTO;
			}
			//fall through to normal sound
		case AEV_SOUND:			//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
			//get soundstring
			token = COM_Parse( text_p );
			if ( !token ) 
			{
				break;
			}
			strcpy(stringData, token);
			//get lowest value
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			lowestVal = atoi( token );
			//get highest value
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			highestVal = atoi( token );
			//Now precache all the sounds
			//NOTE: If we can be assured sequential handles, we can store the first sound index and count
			//		unfortunately, if these sounds were previously registered, we cannot be guaranteed sequential indices.  Thus an array
			if(lowestVal && highestVal)
			{
				assert(highestVal - lowestVal < MAX_RANDOM_ANIM_SOUNDS);
				for ( n = lowestVal, num = AED_SOUNDINDEX_START; n <= highestVal && num <= AED_SOUNDINDEX_END; n++, num++ )
				{
					animEvents[curAnimEvent].eventData[num] = G_SoundIndex( va( stringData, n ) );//cgi_S_RegisterSound
				}
				animEvents[curAnimEvent].eventData[AED_SOUND_NUMRANDOMSNDS] = num - 1;
			}
			else
			{
				animEvents[curAnimEvent].eventData[AED_SOUNDINDEX_START] = G_SoundIndex( stringData );//cgi_S_RegisterSound
#if 0 //#ifndef FINAL_BUILD (only meaningfull if using S_RegisterSound
				if ( !animEvents[curAnimEvent].eventData[AED_SOUNDINDEX_START] )
				{//couldn't register it - file not found
					Com_Printf( S_COLOR_RED "ParseAnimationSndBlock: sound %s does not exist (%s)!\n", stringData, *aeb_filename );
				}
#endif
				animEvents[curAnimEvent].eventData[AED_SOUND_NUMRANDOMSNDS] = 0;
			}
			//get probability
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			animEvents[curAnimEvent].eventData[AED_SOUND_PROBABILITY] = atoi( token );
			break;
		case AEV_FOOTSTEP:		//# animID AEV_FOOTSTEP framenum footstepType
			//get footstep type
			token = COM_Parse( text_p );
			if ( !token ) 
			{
				break;
			}		
			animEvents[curAnimEvent].eventData[AED_FOOTSTEP_TYPE] = GetIDForString(footstepTypeTable, token);
			//get probability
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			animEvents[curAnimEvent].eventData[AED_FOOTSTEP_PROBABILITY] = atoi( token );
			break;
		case AEV_EFFECT:		//# animID AEV_EFFECT framenum effectpath boltName
			//get effect index
			token = COM_Parse( text_p );
			if ( !token ) 
			{
				break;
			}
			if ( token[0] && Q_stricmp( "special", token ) == 0 )
			{//special hard-coded effects
				//let cgame know it's not a real effect
				animEvents[curAnimEvent].eventData[AED_EFFECTINDEX] = -1;
				//get the name of it
				token = COM_Parse( text_p );
				animEvents[curAnimEvent].stringData = G_NewString( token );
			}
			else
			{//regular effect
				tempVal = G_EffectIndex(token);
				assert(tempVal > -32767 && tempVal < 32767);
				animEvents[curAnimEvent].eventData[AED_EFFECTINDEX] = tempVal;
				//get bolt index
				token = COM_Parse( text_p );
				if ( !token ) 
				{
					break;
				}		
				if ( Q_stricmp( "none", token ) != 0 && Q_stricmp( "NULL", token ) != 0 )
				{//actually are specifying a bolt to use
					animEvents[curAnimEvent].stringData = G_NewString( token );
				}
			}
			//NOTE: this string will later be used to add a bolt and store the index, as below:
			//animEvent->eventData[AED_BOLTINDEX] = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], animEvent->stringData );
			//get probability
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			animEvents[curAnimEvent].eventData[AED_EFFECT_PROBABILITY] = atoi( token );
			break;
		case AEV_FIRE:			//# animID AEV_FIRE framenum altfire chancetofire
			//get altfire
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			animEvents[curAnimEvent].eventData[AED_FIRE_ALT] = atoi( token );
			//get probability
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			animEvents[curAnimEvent].eventData[AED_FIRE_PROBABILITY] = atoi( token );
			break;
		case AEV_MOVE:			//# animID AEV_MOVE framenum forwardpush rightpush uppush
			//get forward push
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			tempVal = atoi(token);
			assert(tempVal > -32767 && tempVal < 32767);
			animEvents[curAnimEvent].eventData[AED_MOVE_FWD] = tempVal;
			//get right push
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			tempVal = atoi(token);
			assert(tempVal > -32767 && tempVal < 32767);
			animEvents[curAnimEvent].eventData[AED_MOVE_RT] = tempVal;
			//get upwards push
			token = COM_Parse( text_p );
			if ( !token ) 
			{//WARNING!  BAD TABLE!
				break;
			}
			tempVal = atoi(token);
			assert(tempVal > -32767 && tempVal < 32767);
			animEvents[curAnimEvent].eventData[AED_MOVE_UP] = tempVal;
			break;
		default:				//unknown?
			SkipRestOfLine( text_p );
			continue;
			break;
		}

		if ( curAnimEvent == lastAnimEvent )
		{
			lastAnimEvent++;
		}
	}	
}



/*
======================
G_ParseAnimationEvtFile

Read a configuration file containing animation events
models/players/kyle/animevents.cfg, etc

This file's presence is not required

======================
*/
static
void G_ParseAnimationEvtFile(int glaIndex, const char* eventsDirectory, int fileIndex, int iRealGLAIndex = -1, bool modelSpecific = false)
{
	int				len;
	const char*		token;
	char			text[80000];
	const char*		text_p = text;
	fileHandle_t	f;
	char			eventsPath[MAX_QPATH];
	int				modelIndex = 0;

	assert(fileIndex>=0 && fileIndex<MAX_ANIM_FILES);

	const char *psAnimFileInternalName = (iRealGLAIndex == -1 ? NULL : gi.G2API_GetAnimFileInternalNameIndex( iRealGLAIndex ));
//	bool bIsFrameSkipped = (psAnimFileInternalName && strlen(psAnimFileInternalName)>5 && !stricmp(&psAnimFileInternalName[strlen(psAnimFileInternalName)-5],"_skip"));
	bool bIsFrameSkipped = false;
	if( (psAnimFileInternalName && strstr(psAnimFileInternalName, "_humanoid")) ||
		strstr(eventsDirectory, "rancor") )
		bIsFrameSkipped = true;

	// Open The File, Make Sure It Is Safe
	//-------------------------------------
	Com_sprintf(eventsPath, MAX_QPATH, "models/players/%s/animevents.cfg", eventsDirectory);
	len = cgi_FS_FOpenFile(eventsPath, &f, FS_READ);
	if ( len <= 0 ) 
	{//no file
		return;
	}
	if ( len >= sizeof( text ) - 1 ) 
	{
		CG_Printf( "File %s too long\n", eventsPath );
		return;
	}

	// Read It To The Buffer, Close The File
	//---------------------------------------
	cgi_FS_Read( text, len, f );
	text[len] = 0;
	cgi_FS_FCloseFile( f );


	// Get The Pointers To The Anim Event Arrays
	//-------------------------------------------
	animFileSet_t&	afileset		= level.knownAnimFileSets[fileIndex];
	animevent_t	*legsAnimEvents		= afileset.legsAnimEvents;
	animevent_t	*torsoAnimEvents	= afileset.torsoAnimEvents;
	animation_t	*animations			= afileset.animations;


	if (modelSpecific)
	{
		hstring		modelName(eventsDirectory);
		modelIndex = modelName.handle();
	}


	// read information for batches of sounds (UPPER or LOWER)
	while ( 1 ) 
	{
		// Get base frame of sequence
		token = COM_Parse( &text_p );
		if ( !token || !token[0] ) 
		{
			break;
		}

		//these stomp anything set in the include file (if it's an event of the same type on the same frame)!
		if ( !Q_stricmp(token,"UPPEREVENTS") )	// A batch of upper events
		{
			ParseAnimationEvtBlock(glaIndex, modelIndex, eventsPath, torsoAnimEvents, animations, afileset.torsoAnimEventCount, &text_p, bIsFrameSkipped); 
		}

		else if ( !Q_stricmp(token,"LOWEREVENTS") )	// A batch of lower events
		{
			ParseAnimationEvtBlock(glaIndex, modelIndex, eventsPath, legsAnimEvents, animations, afileset.legsAnimEventCount, &text_p, bIsFrameSkipped); 
		}
	}
}

/*
======================
G_ParseAnimationFile

Read a configuration file containing animation coutns and rates
models/players/visor/animation.cfg, etc

======================
*/
qboolean G_ParseAnimationFile(int glaIndex, const char *skeletonName, int fileIndex) 
{
	char			text[80000];
	int				len			= 0;
	const char		*token		= 0;
	float			fps			= 0;
	const char*		text_p		= text;
	int				animNum		= 0;
	animation_t*	animations	= level.knownAnimFileSets[fileIndex].animations;
	char			skeletonPath[MAX_QPATH];


	// Read In The File To The Text Buffer, Make Sure Everything Is Safe To Continue
	//-------------------------------------------------------------------------------
	Com_sprintf(skeletonPath, MAX_QPATH, "models/players/%s/%s.cfg", skeletonName, skeletonName);
	len = gi.RE_GetAnimationCFG(skeletonPath, text, sizeof(text));
	if ( len <= 0 ) 
	{
		Com_sprintf(skeletonPath, MAX_QPATH, "models/players/%s/animation.cfg", skeletonName);
		len = gi.RE_GetAnimationCFG(skeletonPath, text, sizeof(text));
		if ( len <= 0 ) 
		{
			return qfalse;
		}
	}
	if ( len >= sizeof( text ) - 1 ) 
	{
		G_Error( "G_ParseAnimationFile: File %s too long\n (%d > %d)", skeletonName, len, sizeof( text ) - 1);
		return qfalse;
	}



	// Read In Each Token
	//--------------------
	while(1) 
	{
		token = COM_Parse( &text_p );

		// If No Token, We've Reached The End Of The File
		//------------------------------------------------
		if ( !token || !token[0]) 
		{
			break;
		}

		// Get The Anim Number Converted From The First Token
		//----------------------------------------------------
		animNum = GetIDForString(animTable, token);
		if(animNum == -1)
		{
#ifndef FINAL_BUILD
			if (strcmp(token,"ROOT"))
			{
				Com_Printf(S_COLOR_RED"WARNING: Unknown token %s in %s\n", token, skeletonPath);
			}
#endif
			//unrecognized animation so skip to end of line, 
			while (token[0])
			{
				token = COM_ParseExt( &text_p, qfalse );	//returns empty string when next token is EOL
			}
			continue;
		}

		// GLAIndex
		//----------
		animations[animNum].glaIndex = glaIndex;	// Passed Into This Func

		// First Frame
		//-------------
		token = COM_Parse( &text_p );
		if ( !token ) 
		{
			break;
		}
		assert(atoi(token) >= 0 && atoi(token) < 65536);
		animations[animNum].firstFrame = atoi( token );

		// Num Frames
		//------------
		token = COM_Parse( &text_p );
		if ( !token ) 
		{
			break;
		}
		assert(atoi(token) >= 0 && atoi(token) < 65536);
		animations[animNum].numFrames = atoi( token );

		// Loop Frames
		//-------------
		token = COM_Parse( &text_p );
		if ( !token ) 
		{
			break;
		}
		assert(atoi(token) >= -1 && atoi(token) < 128);
		animations[animNum].loopFrames = atoi( token );

		// FPS
		//-----
		token = COM_Parse( &text_p );
		if ( !token ) 
		{
			break;
		}
		fps = atof( token );
		if ( fps == 0 ) 
		{
			fps = 1;//Don't allow divide by zero error
		}

		// Calculate Frame Lerp
		//----------------------
		int lerp;
		if ( fps < 0 )
		{//backwards
			lerp = floor(1000.0f / fps);
			assert(lerp > -32767 && lerp < 32767);
			animations[animNum].frameLerp = lerp;
			assert(animations[animNum].frameLerp <= 1);
		}
		else
		{
			lerp = ceil(1000.0f / fps);
			assert(lerp > -32767 && lerp < 32767);
			animations[animNum].frameLerp = lerp;
			assert(animations[animNum].frameLerp >= 1);
		}

/*		lerp = ceil(1000.0f / Q_fabs(fps));
		assert(lerp > -32767 && lerp < 32767);
		animations[animNum].initialLerp = lerp;
*/
	}




#ifdef CONVENIENT_ANIMATION_FILE_DEBUG_THING
	if (strstr(af_filename, "humanoid"))
	{
		SpewDebugStuffToFile(animations);
	}
#endif

	return qtrue;
}




////////////////////////////////////////////////////////////////////////
// G_ParseAnimFileSet
//
// This function is responsible for building the animation file and 
// the animation event file.
//
////////////////////////////////////////////////////////////////////////
int		G_ParseAnimFileSet(const char *skeletonName, const char *modelName=0)
{
	int			fileIndex=0;


	// Try To Find An Existing Skeleton File For This Animation Set
	//--------------------------------------------------------------
	for (fileIndex=0; fileIndex<level.numKnownAnimFileSets; fileIndex++)
	{
		if (Q_stricmp(level.knownAnimFileSets[fileIndex].filename, skeletonName)==0)
		{
			break;
		}
	}

	// Ok, We Don't Already Have One, So Time To Create A New One And Initialize It
	//------------------------------------------------------------------------------
	if (fileIndex>=level.numKnownAnimFileSets)
	{
		if (level.numKnownAnimFileSets==MAX_ANIM_FILES)
		{
			G_Error( "G_ParseAnimFileSet: MAX_ANIM_FILES" );
			return -1;
		}

		// Allocate A new File Set, And Get Some Shortcut Pointers
		//---------------------------------------------------------
		fileIndex = level.numKnownAnimFileSets;
		level.numKnownAnimFileSets++;
		strcpy(level.knownAnimFileSets[fileIndex].filename, skeletonName);

		level.knownAnimFileSets[fileIndex].torsoAnimEventCount = 0;
		level.knownAnimFileSets[fileIndex].legsAnimEventCount = 0;

		animation_t*	animations		= level.knownAnimFileSets[fileIndex].animations;
		animevent_t*	legsAnimEvents	= level.knownAnimFileSets[fileIndex].legsAnimEvents;
		animevent_t*	torsoAnimEvents	= level.knownAnimFileSets[fileIndex].torsoAnimEvents;

		int i, j;

		// Initialize The Frames Information
		//-----------------------------------
		for(i=0; i<MAX_ANIMATIONS; i++)
		{
			animations[i].firstFrame	= 0;
			animations[i].numFrames		= 0;
			animations[i].loopFrames	= -1;
			animations[i].frameLerp		= 100;
//			animations[i].initialLerp	= 100;
			animations[i].glaIndex		= 0;
		}

		// Initialize Animation Event Array
		//----------------------------------
		for(i=0; i<MAX_ANIM_EVENTS; i++)
		{
			torsoAnimEvents[i].eventType	= AEV_NONE;		//Type of event
			legsAnimEvents[i].eventType		= AEV_NONE;
			torsoAnimEvents[i].keyFrame		= (unsigned short)-1;	//65535 should never be a valid frame... :)
			legsAnimEvents[i].keyFrame		= (unsigned short)-1;	//Frame to play event on
			torsoAnimEvents[i].stringData	= NULL;			//we allow storage of one string, temporarily (in case we have to look up an index later, 
			legsAnimEvents[i].stringData	= NULL;			//then make sure to set stringData to NULL so we only do the look-up once)
			torsoAnimEvents[i].modelOnly	= 0;
			legsAnimEvents[i].modelOnly		= 0;
			torsoAnimEvents[i].glaIndex		= 0;
			legsAnimEvents[i].glaIndex		= 0;

			
			for (j=0; j<AED_ARRAY_SIZE; j++)				//Unique IDs, can be soundIndex of sound file to play OR effect index or footstep type, etc.
			{
				torsoAnimEvents[i].eventData[j] = -1;
				legsAnimEvents[i].eventData[j]	= -1;
			}
		}

		// Get The Cinematic GLA Name
		//----------------------------
		if (stricmp(skeletonName, "_humanoid")==0)
		{
			const char* mapName = strrchr( level.mapname, '/' );
			if (mapName)
			{
				mapName++;
			}
			else
			{
				mapName = level.mapname;
			}
			char  skeletonMapName[MAX_QPATH];
			Com_sprintf(skeletonMapName, MAX_QPATH, "_humanoid_%s", mapName);
			const int normalGLAIndex = gi.G2API_PrecacheGhoul2Model("models/players/_humanoid/_humanoid.gla");//double check this always comes first!

			// Make Sure To Precache The GLAs (both regular and cinematic), And Remember Their Indicies
			//------------------------------------------------------------------------------------------
			G_ParseAnimationFile(0,    skeletonName, fileIndex);
			G_ParseAnimationEvtFile(0, skeletonName, fileIndex, normalGLAIndex, false/*flag for model specific*/);	

			const int cineGLAIndex = gi.G2API_PrecacheGhoul2Model( va("models/players/%s/%s.gla", skeletonMapName, skeletonMapName));
			if (cineGLAIndex)
			{
				assert(cineGLAIndex == normalGLAIndex+1);
				if (cineGLAIndex != normalGLAIndex+1)
				{
					Com_Error(ERR_DROP,"Cinematic GLA was not loaded after the normal GLA.  Cannot continue safely.");
				}
				G_ParseAnimationFile(1,    skeletonMapName, fileIndex);
				G_ParseAnimationEvtFile(1, skeletonMapName, fileIndex, cineGLAIndex, false/*flag for model specific*/);
			}
		}
		else
		{
			// non-humanoid...
			//
			// Make Sure To Precache The GLAs (both regular and cinematic), And Remember Their Indicies
			//------------------------------------------------------------------------------------------
			G_ParseAnimationFile(0,    skeletonName, fileIndex);
			G_ParseAnimationEvtFile(0, skeletonName, fileIndex);
		}
	}

	// Tack Any Additional Per Model Events
	//--------------------------------------
	if (modelName)
	{
		// Quick Search To See If We've Already Loaded This Model
		//--------------------------------------------------------
		int			curModel=0;
		hstring		curModelName(modelName);
		while (curModel<MAX_MODELS_PER_LEVEL && !modelsAlreadyDone[curModel].empty())
		{
			if (modelsAlreadyDone[curModel]==curModelName)
			{
				return fileIndex;
			}
			curModel++;
		}

		if (curModel == MAX_MODELS_PER_LEVEL)
		{
			Com_Error(ERR_DROP, "About to overflow modelsAlreadyDone, increase MAX_MODELS_PER_LEVEL\n");
		}

		// Nope, Ok, Record The Model As Found And Parse It's Event File
		//---------------------------------------------------------------
		modelsAlreadyDone[curModel]=curModelName;

		// Only Do The Event File If The Model Is Not The Same As The Skeleton
		//---------------------------------------------------------------------
		if (stricmp(skeletonName, modelName)!=0)
		{
			const int iGLAIndexToCheckForSkip = (stricmp(skeletonName, "_humanoid")?-1:gi.G2API_PrecacheGhoul2Model("models/players/_humanoid/_humanoid.gla")); // ;-)

			G_ParseAnimationEvtFile(0, modelName, fileIndex, iGLAIndexToCheckForSkip, true);	
		}
	}

	return fileIndex;
}

#ifdef _XBOX
// Utility to wipe the modelsAlreadyDone array, as it is never cleared
void ClearModelsAlreadyDone(void)
{
	memset(modelsAlreadyDone, 0, sizeof(modelsAlreadyDone));
}
#endif

extern cvar_t	*g_char_model;
void G_LoadAnimFileSet( gentity_t *ent, const char *pModelName )
{
//load its animation config
	char	animName[MAX_QPATH];
	char	*GLAName, *modelName;
	char	*slash = NULL;
	char	*strippedName;
	
	if ( ent->playerModel == -1 )
	{
		return;
	}
	if ( Q_stricmp( "player", pModelName ) == 0 )
	{//model is actually stored on console
		modelName = g_char_model->string;
	}
	else
	{
		modelName = (char *)pModelName;
	}
	//get the location of the animation.cfg
	GLAName = gi.G2API_GetGLAName( &ent->ghoul2[ent->playerModel] );
	//now load and parse the animation.cfg, animevents.cfg and set the animFileIndex
	if ( !GLAName) 
	{
		Com_Printf( S_COLOR_RED"Failed find animation file name models/players/%s\n", modelName );
		strippedName="_humanoid";	//take a guess, maybe it's right?
	}
	else
	{
		Q_strncpyz( animName, GLAName, sizeof( animName ), qtrue );
		slash = strrchr( animName, '/' );
		if ( slash )
		{
			*slash = 0;
		}
		strippedName = COM_SkipPath( animName );
	}

	//now load and parse the animation.cfg, animevents.cfg and set the animFileIndex
	ent->client->clientInfo.animFileIndex = G_ParseAnimFileSet(strippedName, modelName);

	if (ent->client->clientInfo.animFileIndex<0) 
	{
		Com_Printf( S_COLOR_RED"Failed to load animation file set models/players/%s/animation.cfg\n", modelName );
#ifndef FINAL_BUILD
		Com_Error(ERR_FATAL, "Failed to load animation file set models/players/%s/animation.cfg\n", modelName);
#endif
	}
}


void NPC_PrecacheAnimationCFG( const char *NPC_type )
{
	char	filename[MAX_QPATH];
	const char	*token;
	const char	*value;
	const char	*p;

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

	p = NPCParms;
	COM_BeginParseSession();

	// 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 ( G_ParseLiteral( &p, "{" ) ) 
	{
		return;
	}

	// parse the NPC info block
	while ( 1 ) 
	{
		token = COM_ParseExt( &p, qtrue );
		if ( !token[0] ) 
		{
			gi.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 ), qtrue );
			G_ParseAnimFileSet( filename );
			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(strippedName, filename);
					return;
				}
			}
		}
	}
}

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 );
	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
		}
	}
}

/*
void NPC_PrecacheByClassName ( char *NPCName )

This runs all the class specific precache functions

*/

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_Rancor_Precache( void );
extern void NPC_MutantRancor_Precache( void );
extern void NPC_Wampa_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_Protocol_Precache( void );
extern void Boba_Precache( void );
extern void RT_Precache( void );
extern void SandCreature_Precache( void );
extern void NPC_TavionScepter_Precache( void );
extern void NPC_TavionSithSword_Precache( void );
extern void NPC_Rosh_Dark_Precache( void );
extern void NPC_Tusken_Precache( void );
extern void NPC_Saboteur_Precache( void );
extern void NPC_CultistDestroyer_Precache( void );
void NPC_Jawa_Precache( void )
{
	for ( int i = 1; i < 7; i++ )
	{
		G_SoundIndex( va( "sound/chars/jawa/misc/chatter%d.wav", i ) );
	}
	G_SoundIndex( "sound/chars/jawa/misc/ooh-tee-nee.wav" );
}

void NPC_PrecacheByClassName( const char* type )
{
	if (!type || !type[0])
	{
		return;
	}

	if ( !Q_stricmp( "gonk", type))
	{
		NPC_Gonk_Precache();
	}
	else if ( !Q_stricmp( "mouse", type))
	{
		NPC_Mouse_Precache();
	}
	else if ( !Q_stricmpn( "r2d2", type, 4))
	{
		NPC_R2D2_Precache();
	}
	else if ( !Q_stricmp( "atst", type))
	{
		NPC_ATST_Precache();
	}
	else if ( !Q_stricmpn( "r5d2", type, 4))
	{
		NPC_R5D2_Precache();
	}
	else if ( !Q_stricmp( "mark1", type))
	{
		NPC_Mark1_Precache();
	}
	else if ( !Q_stricmp( "mark2", type))
	{
		NPC_Mark2_Precache();
	}
	else if ( !Q_stricmp( "interrogator", type))
	{
		NPC_Interrogator_Precache(NULL);
	}
	else if ( !Q_stricmp( "probe", type))
	{
		NPC_Probe_Precache();
	}
	else if ( !Q_stricmp( "seeker", type))
	{
		NPC_Seeker_Precache();
	}
	else if ( !Q_stricmpn( "remote", type, 6))
	{
		NPC_Remote_Precache();
	}
	else if ( !Q_stricmpn( "shadowtrooper", type, 13 ) )
	{
		NPC_ShadowTrooper_Precache();
	}
	else if ( !Q_stricmp( "minemonster", type ))
	{
		NPC_MineMonster_Precache();
	}
	else if ( !Q_stricmp( "howler", type ))
	{
		NPC_Howler_Precache();
	}
	else if ( !Q_stricmp( "rancor", type ))
	{
		NPC_Rancor_Precache();
	}
	else if ( !Q_stricmp( "mutant_rancor", type ))
	{
		NPC_Rancor_Precache();
		NPC_MutantRancor_Precache();
	}
	else if ( !Q_stricmp( "wampa", type ))
	{
		NPC_Wampa_Precache();
	}
	else if ( !Q_stricmp( "sand_creature", type ))
	{
		SandCreature_Precache();
	}
	else if ( !Q_stricmp( "sentry", type ))
	{
		NPC_Sentry_Precache();
	}
	else if ( !Q_stricmp( "protocol", type ))
	{
		NPC_Protocol_Precache();
	}
	else if ( !Q_stricmp( "boba_fett", type ))
	{
		Boba_Precache();
	}
	else if ( !Q_stricmp( "rockettrooper2", type ))
	{
		RT_Precache();
	}
	else if ( !Q_stricmp( "rockettrooper2Officer", type ))
	{
		RT_Precache();
	}
	else if ( !Q_stricmp( "tavion_scepter", type ))
	{
		NPC_TavionScepter_Precache();
	}
	else if ( !Q_stricmp( "tavion_sith_sword", type ))
	{
		NPC_TavionSithSword_Precache();
	}
	else if ( !Q_stricmp( "rosh_dark", type ) )
	{
		NPC_Rosh_Dark_Precache();
	}
	else if ( !Q_stricmpn( "tusken", type, 6 ) )
	{
		NPC_Tusken_Precache();
	}
	else if ( !Q_stricmpn( "saboteur", type, 8 ) )
	{
		NPC_Saboteur_Precache();
	}
	else if ( !Q_stricmp( "cultist_destroyer", type ) )
	{
		NPC_CultistDestroyer_Precache();
	}
	else if ( !Q_stricmpn( "jawa", type, 4 ) )
	{
		NPC_Jawa_Precache();
	}
}



/*
void NPC_Precache ( char *NPCName )

Precaches NPC skins, tgas and md3s.

*/
void NPC_Precache ( gentity_t *spawner )
{
	clientInfo_t	ci={0};
	renderInfo_t	ri={0};
	team_t			playerTeam = TEAM_FREE;
	const char	*token;
	const char	*value;
	const char	*p;
	char	*patch;
	char	sound[MAX_QPATH];
	qboolean	md3Model = qfalse;
	char	playerModel[MAX_QPATH] = { 0 };
	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();

	// 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 ( G_ParseLiteral( &p, "{" ) ) 
	{
		return;
	}

	// parse the NPC info block
	while ( 1 ) 
	{
		token = COM_ParseExt( &p, qtrue );
		if ( !token[0] ) 
		{
			gi.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), qtrue);			
			md3Model = qfalse;
			continue;
		}

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

		// playerTeam
		if ( !Q_stricmp( token, "playerTeam" ) ) 
		{
			if ( COM_ParseString( &p, &value ) ) 
			{
				continue;
			}
			playerTeam = (team_t)GetIDForString( TeamTable, token );
			continue;
		}

	
		// snd
		if ( !Q_stricmp( token, "snd" ) ) {
			if ( COM_ParseString( &p, &value ) ) {
				continue;
			}
			if ( !(spawner->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;
				}
				ci.customBasicSoundDir = G_NewString( sound );
			}
			continue;
		}

		// sndcombat
		if ( !Q_stricmp( token, "sndcombat" ) ) {
			if ( COM_ParseString( &p, &value ) ) {
				continue;
			}
			if ( !(spawner->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;
				}
				ci.customCombatSoundDir = G_NewString( sound );
			}
			continue;
		}
		
		// sndextra
		if ( !Q_stricmp( token, "sndextra" ) ) {
			if ( COM_ParseString( &p, &value ) ) {
				continue;
			}
			if ( !(spawner->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;
				}
				ci.customExtraSoundDir = G_NewString( sound );
			}
			continue;
		}

		// sndjedi
		if ( !Q_stricmp( token, "sndjedi" ) ) {
			if ( COM_ParseString( &p, &value ) ) {
				continue;
			}
			if ( !(spawner->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;
				}
				ci.customJediSoundDir = G_NewString( sound );
			}
			continue;
		}

		//cache weapons
		if ( !Q_stricmp( token, "weapon" ) )
		{
			if ( COM_ParseString( &p, &value ) ) 
			{
				continue;
			}
			int weap = GetIDForString( WPTable, value );
			if ( weap >= WP_NONE && weap < WP_NUM_WEAPONS )
			{
				if ( weap > WP_NONE )
				{
					RegisterItem( FindItemForWeapon( (weapon_t)(weap) ) );	//precache the weapon
				}
			}
			continue;
		}
		//cache sabers
		//saber name
		if ( !Q_stricmp( token, "saber" ) ) 
		{
			if ( COM_ParseString( &p, &value ) ) 
			{
				continue;
			}
			char *saberName = G_NewString( value );
			saberInfo_t saber;
			WP_SaberParseParms( saberName, &saber );
			if ( saber.model && saber.model[0] )
			{
				G_ModelIndex( saber.model );
			}
			if ( saber.skin && saber.skin[0] )
			{
				gi.RE_RegisterSkin( saber.skin );
				G_SkinIndex( saber.skin );
			}
			continue;
		}
		
		//second saber name
		if ( !Q_stricmp( token, "saber2" ) ) 
		{
			if ( COM_ParseString( &p, &value ) ) 
			{
				continue;
			}
			char *saberName = G_NewString( value );
			saberInfo_t saber;
			WP_SaberParseParms( saberName, &saber );
			if ( saber.model && saber.model[0] )
			{
				G_ModelIndex( saber.model );
			}
			if ( saber.skin && saber.skin[0] )
			{
				gi.RE_RegisterSkin( saber.skin );
				G_SkinIndex( saber.skin );
			}
			continue;
		}
	}

	if ( md3Model )
	{
		CG_RegisterClientRenderInfo( &ci, &ri );
	}
	else
	{
		char	skinName[MAX_QPATH];
		//precache ghoul2 model
		gi.G2API_PrecacheGhoul2Model( va( "models/players/%s/model.glm", playerModel ) );
		//precache skin
		if (strchr(customSkin, '|'))
		{//three part skin
			Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/|%s", playerModel, customSkin );
		}
		else
		{//standard skin
			Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/model_%s.skin", playerModel, customSkin );
		}
		// lets see if it's out there
		gi.RE_RegisterSkin( skinName );
	}

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

	// Anything else special about them
	NPC_PrecacheByClassName( spawner->NPC_type );

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

void NPC_BuildRandom( gentity_t *NPC )
{
}

extern void G_MatchPlayerWeapon( gentity_t *ent );
extern void G_InitPlayerFromCvars( gentity_t *ent );
extern void G_SetG2PlayerModel( gentity_t * const ent, const char *modelName, const char *customSkin, const char *surfOff, const char *surfOn );
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];
	clientInfo_t	*ci = &NPC->client->clientInfo;
	renderInfo_t	*ri = &NPC->client->renderInfo;
	gNPCstats_t		*stats = NULL;
	qboolean	md3Model = qtrue;
	char	surfOff[1024]={0};
	char	surfOn[1024]={0};
	qboolean parsingPlayer = qfalse;

	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->sex			= SEX_MALE;
		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;
		if (g_entities[ENTITYNUM_WORLD].max_health && stats->visrange>g_entities[ENTITYNUM_WORLD].max_health)
		{
			stats->visrange	= g_entities[ENTITYNUM_WORLD].max_health;
		}
		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;
	}

	Q_strncpyz( ci->name, NPCName, sizeof( ci->name ) );
	
	NPC->playerModel = -1;
	
	//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);
	ri->headModelName[0] = 0;
	ri->torsoModelName[0]= 0;
	ri->legsModelName[0] =0;

	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->mins);
	VectorCopy(playerMaxs, NPC->maxs);
	NPC->client->crouchheight = CROUCH_MAXS_2;
	NPC->client->standheight = DEFAULT_MAXS_2;

	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;

	*(int*)ri->customRGBA=-1;

	if ( !Q_stricmp( "random", NPCName ) )
	{//Randomly assemble an NPC
		NPC_BuildRandom( NPC );
	}
	else
	{
		p = NPCParms;
		COM_BeginParseSession();

		// 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 ( G_ParseLiteral( &p, "{" ) ) 
		{
			return qfalse;
		}
			
		// parse the NPC info block
		while ( 1 ) 
		{
			token = COM_ParseExt( &p, qtrue );
			if ( !token[0] ) 
			{
				gi.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") )
				{
					ri->customRGBA[0]=Q_irand(0,255);
					ri->customRGBA[1]=Q_irand(0,255);
					ri->customRGBA[2]=Q_irand(0,255);
					ri->customRGBA[3]=255;
				} 
				else if ( !Q_stricmp( value, "random1") )
				{
					ri->customRGBA[3]=255;
					switch (Q_irand(0,5))
					{
					default:
					case 0:
						ri->customRGBA[0]=127;
						ri->customRGBA[1]=153;
						ri->customRGBA[2]=255;
						break;
					case 1:
						ri->customRGBA[0]=177;
						ri->customRGBA[1]=29;
						ri->customRGBA[2]=13;
						break;
					case 2:
						ri->customRGBA[0]=47;
						ri->customRGBA[1]=90;
						ri->customRGBA[2]=40;
						break;
					case 3:
						ri->customRGBA[0]=181;
						ri->customRGBA[1]=207;
						ri->customRGBA[2]=255;
						break;
					case 4:
						ri->customRGBA[0]=138;
						ri->customRGBA[1]=83;
						ri->customRGBA[2]=0;
						break;
					case 5:
						ri->customRGBA[0]=254;
						ri->customRGBA[1]=199;
						ri->customRGBA[2]=14;
						break;
					}
				} 
				else if ( !Q_stricmp( value, "jedi_hf" ) )
				{
					ri->customRGBA[3]=255;
					switch (Q_irand(0,7))
					{
					default:
					case 0://red1
						ri->customRGBA[0]=165;
						ri->customRGBA[1]=48;
						ri->customRGBA[2]=21;
						break;
					case 1://yellow1
						ri->customRGBA[0]=254;
						ri->customRGBA[1]=230;
						ri->customRGBA[2]=132;
						break;
					case 2://bluegray
						ri->customRGBA[0]=181;
						ri->customRGBA[1]=207;
						ri->customRGBA[2]=255;
						break;
					case 3://pink
						ri->customRGBA[0]=233;
						ri->customRGBA[1]=183;
						ri->customRGBA[2]=208;
						break;
					case 4://lt blue
						ri->customRGBA[0]=161;
						ri->customRGBA[1]=226;
						ri->customRGBA[2]=240;
						break;
					case 5://blue
						ri->customRGBA[0]=101;
						ri->customRGBA[1]=159;
						ri->customRGBA[2]=255;
						break;
					case 6://orange
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=157;
						ri->customRGBA[2]=114;
						break;
					case 7://violet
						ri->customRGBA[0]=216;
						ri->customRGBA[1]=160;
						ri->customRGBA[2]=255;
						break;
					}
				}
				else if ( !Q_stricmp( value, "jedi_hm" ) )
				{
					ri->customRGBA[3]=255;
					switch (Q_irand(0,7))
					{
					default:
					case 0://yellow
						ri->customRGBA[0]=252;
						ri->customRGBA[1]=243;
						ri->customRGBA[2]=180;
						break;
					case 1://blue
						ri->customRGBA[0]=69;
						ri->customRGBA[1]=109;
						ri->customRGBA[2]=255;
						break;
					case 2://gold
						ri->customRGBA[0]=254;
						ri->customRGBA[1]=197;
						ri->customRGBA[2]=73;
						break;
					case 3://orange
						ri->customRGBA[0]=178;
						ri->customRGBA[1]=78;
						ri->customRGBA[2]=18;
						break;
					case 4://bluegreen
						ri->customRGBA[0]=112;
						ri->customRGBA[1]=153;
						ri->customRGBA[2]=161;
						break;
					case 5://blue2
						ri->customRGBA[0]=123;
						ri->customRGBA[1]=182;
						ri->customRGBA[2]=255;
						break;
					case 6://green2
						ri->customRGBA[0]=0;
						ri->customRGBA[1]=88;
						ri->customRGBA[2]=105;
						break;
					case 7://violet
						ri->customRGBA[0]=138;
						ri->customRGBA[1]=0;
						ri->customRGBA[2]=0;
						break;
					}
				}
				else if ( !Q_stricmp( value, "jedi_kdm" ) )
				{
					ri->customRGBA[3]=255;
					switch (Q_irand(0,8))
					{
					default:
					case 0://blue
						ri->customRGBA[0]=85;
						ri->customRGBA[1]=120;
						ri->customRGBA[2]=255;
						break;
					case 1://violet
						ri->customRGBA[0]=173;
						ri->customRGBA[1]=142;
						ri->customRGBA[2]=219;
						break;
					case 2://brown1
						ri->customRGBA[0]=254;
						ri->customRGBA[1]=197;
						ri->customRGBA[2]=73;
						break;
					case 3://orange
						ri->customRGBA[0]=138;
						ri->customRGBA[1]=83;
						ri->customRGBA[2]=0;
						break;
					case 4://gold
						ri->customRGBA[0]=254;
						ri->customRGBA[1]=199;
						ri->customRGBA[2]=14;
						break;
					case 5://blue2
						ri->customRGBA[0]=68;
						ri->customRGBA[1]=194;
						ri->customRGBA[2]=217;
						break;
					case 6://red1
						ri->customRGBA[0]=170;
						ri->customRGBA[1]=3;
						ri->customRGBA[2]=30;
						break;
					case 7://yellow1
						ri->customRGBA[0]=225;
						ri->customRGBA[1]=226;
						ri->customRGBA[2]=144;
						break;
					case 8://violet2
						ri->customRGBA[0]=167;
						ri->customRGBA[1]=202;
						ri->customRGBA[2]=255;
						break;
					}
				}
				else if ( !Q_stricmp( value, "jedi_rm" ) )
				{
					ri->customRGBA[3]=255;
					switch (Q_irand(0,8))
					{
					default:
					case 0://blue
						ri->customRGBA[0]=127;
						ri->customRGBA[1]=153;
						ri->customRGBA[2]=255;
						break;
					case 1://green1
						ri->customRGBA[0]=208;
						ri->customRGBA[1]=249;
						ri->customRGBA[2]=85;
						break;
					case 2://blue2
						ri->customRGBA[0]=181;
						ri->customRGBA[1]=207;
						ri->customRGBA[2]=255;
						break;
					case 3://gold
						ri->customRGBA[0]=138;
						ri->customRGBA[1]=83;
						ri->customRGBA[2]=0;
						break;
					case 4://gold
						ri->customRGBA[0]=224;
						ri->customRGBA[1]=171;
						ri->customRGBA[2]=44;
						break;
					case 5://green2
						ri->customRGBA[0]=49;
						ri->customRGBA[1]=155;
						ri->customRGBA[2]=131;
						break;
					case 6://red1
						ri->customRGBA[0]=163;
						ri->customRGBA[1]=79;
						ri->customRGBA[2]=17;
						break;
					case 7://violet2
						ri->customRGBA[0]=148;
						ri->customRGBA[1]=104;
						ri->customRGBA[2]=228;
						break;
					case 8://green3
						ri->customRGBA[0]=138;
						ri->customRGBA[1]=136;
						ri->customRGBA[2]=0;
						break;
					}
				}
				else if ( !Q_stricmp( value, "jedi_tf" ) )
				{
					ri->customRGBA[3]=255;
					switch (Q_irand(0,5))
					{
					default:
					case 0://green1
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=235;
						ri->customRGBA[2]=100;
						break;
					case 1://blue1
						ri->customRGBA[0]=62;
						ri->customRGBA[1]=155;
						ri->customRGBA[2]=255;
						break;
					case 2://red1
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=110;
						ri->customRGBA[2]=120;
						break;
					case 3://purple
						ri->customRGBA[0]=180;
						ri->customRGBA[1]=150;
						ri->customRGBA[2]=255;
						break;
					case 4://flesh
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=200;
						ri->customRGBA[2]=212;
						break;
					case 5://base
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=255;
						ri->customRGBA[2]=255;
						break;
					}
				}
				else if ( !Q_stricmp( value, "jedi_zf" ) )
				{
					ri->customRGBA[3]=255;
					switch (Q_irand(0,7))
					{
					default:
					case 0://red1
						ri->customRGBA[0]=204;
						ri->customRGBA[1]=19;
						ri->customRGBA[2]=21;
						break;
					case 1://orange1
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=107;
						ri->customRGBA[2]=40;
						break;
					case 2://pink1
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=148;
						ri->customRGBA[2]=155;
						break;
					case 3://gold
						ri->customRGBA[0]=255;
						ri->customRGBA[1]=164;
						ri->customRGBA[2]=59;
						break;
					case 4://violet1
						ri->customRGBA[0]=216;
						ri->customRGBA[1]=160;
						ri->customRGBA[2]=255;
						break;
					case 5://blue1
						ri->customRGBA[0]=101;
						ri->customRGBA[1]=159;
						ri->customRGBA[2]=255;
						break;
					case 6://blue2
						ri->customRGBA[0]=161;
						ri->customRGBA[1]=226;
						ri->customRGBA[2]=240;
						break;
					case 7://blue3
						ri->customRGBA[0]=37;
						ri->customRGBA[1]=155;
						ri->customRGBA[2]=181;
						break;
					}
				}
				else 
				{
					ri->customRGBA[0]=atoi(value);
					
					if ( COM_ParseInt( &p, &n ) ) 
					{
						continue;
					}
					ri->customRGBA[1]=n;
					
					if ( COM_ParseInt( &p, &n ) ) 
					{
						continue;
					}
					ri->customRGBA[2]=n;
					
					if ( COM_ParseInt( &p, &n ) ) 
					{
						continue;
					}
					ri->customRGBA[3]=n;
				}
				continue;
			}

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

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

				if(!Q_stricmp("none", value))
				{
					ri->torsoModelName[0] = NULL;
					//Zero the torso clamp range so the legs don't lag behind
					ri->torsoYawRangeLeft = 
					ri->torsoYawRangeRight = 
					ri->torsoPitchRangeUp = 
					ri->torsoPitchRangeDown = 0;
				}
				else
				{
					Q_strncpyz( ri->torsoModelName, value, sizeof(ri->torsoModelName), qtrue);
				}
				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
				ci->animFileIndex = G_ParseAnimFileSet(ri->legsModelName);
				continue;
			}

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

			// surfOff
			if ( !Q_stricmp( token, "surfOff" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				if ( surfOff[0] )
				{
					strncat( (char *)surfOff, ",", sizeof(surfOff) );
					strncat( (char *)surfOff, value, sizeof(surfOff) );
				}
				else
				{
					Q_strncpyz( surfOff, value, sizeof(surfOff), qtrue);
				}
				continue;
			}
			
			// surfOn
			if ( !Q_stricmp( token, "surfOn" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				if ( surfOn[0] )
				{
					strncat( (char *)surfOn, ",", sizeof(surfOn) );
					strncat( (char *)surfOn, value, sizeof(surfOn) );
				}
				else
				{
					Q_strncpyz( surfOn, value, sizeof(surfOn), qtrue);
				}
				continue;
			}
			
			//headYawRangeLeft
			if ( !Q_stricmp( token, "headYawRangeLeft" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.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 ) 
				{
					gi.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 ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				ri->headPitchRangeUp = n;
				continue;
			}
			
			//headPitchRangeDown
			if ( !Q_stricmp( token, "headPitchRangeDown" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				ri->headPitchRangeDown = n;
				continue;
			}

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

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

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

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

			// Uniform XYZ scale
			if ( !Q_stricmp( token, "scale" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if (n != 100)
				{
					NPC->s.modelScale[0] = NPC->s.modelScale[1] = NPC->s.modelScale[2] = n/100.0f;
				}
				continue;
			}

			//X scale
			if ( !Q_stricmp( token, "scaleX" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if (n != 100)
				{
					NPC->s.modelScale[0] = n/100.0f;
				}
				continue;
			}

			//Y scale
			if ( !Q_stricmp( token, "scaleY" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if (n != 100)
				{
					NPC->s.modelScale[1] = n/100.0f;
				}
				continue;
			}

			//Z scale
			if ( !Q_stricmp( token, "scaleZ" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if (n != 100)
				{
					NPC->s.modelScale[2] = n/100.0f;
				}
				continue;
			}

	//===AI STATS=====================================================================
			if ( !parsingPlayer )
			{
				// aggression
				if ( !Q_stricmp( token, "aggression" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 1 || n > 5 ) {
						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->aggression = n;
					}
					continue;
				}

				// aim
				if ( !Q_stricmp( token, "aim" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 1 || n > 5 ) {
						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->aim = n;
					}
					continue;
				}

				// earshot
				if ( !Q_stricmp( token, "earshot" ) ) {
					if ( COM_ParseFloat( &p, &f ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( f < 0.0f ) 
					{
						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->earshot = f;
					}
					continue;
				}

				// evasion
				if ( !Q_stricmp( token, "evasion" ) ) 
				{
					if ( COM_ParseInt( &p, &n ) ) 
					{
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 1 || n > 5 ) 
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->evasion = n;
					}
					continue;
				}

				// hfov
				if ( !Q_stricmp( token, "hfov" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 1 || n > 180 ) {
						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->hfov = n;// / 2;	//FIXME: Why was this being done?!
					}
					continue;
				}

				// intelligence
				if ( !Q_stricmp( token, "intelligence" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 1 || n > 5 ) {
						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->intelligence = n;
					}
					continue;
				}
				
				// move
				if ( !Q_stricmp( token, "move" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 1 || n > 5 ) {
						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->move = n;
					}
					continue;
				}

				// reactions
				if ( !Q_stricmp( token, "reactions" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 1 || n > 5 ) {
						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->reactions = n;
					}
					continue;
				}

				// shootDistance
				if ( !Q_stricmp( token, "shootDistance" ) ) {
					if ( COM_ParseFloat( &p, &f ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( f < 0.0f ) 
					{
						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->shootDistance = f;
					}
					continue;
				}

				// vfov
				if ( !Q_stricmp( token, "vfov" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 2 || n > 360 ) {
						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->vfov = n / 2;
					}
					continue;
				}

				// vigilance
				if ( !Q_stricmp( token, "vigilance" ) ) {
					if ( COM_ParseFloat( &p, &f ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( f < 0.0f ) 
					{
						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->vigilance = f;
					}
					continue;
				}

				// visrange
				if ( !Q_stricmp( token, "visrange" ) ) {
					if ( COM_ParseFloat( &p, &f ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( f < 0.0f ) 
					{
						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->visrange = f;
						if (g_entities[ENTITYNUM_WORLD].max_health && stats->visrange>g_entities[ENTITYNUM_WORLD].max_health)
						{
							stats->visrange	= g_entities[ENTITYNUM_WORLD].max_health;
						}
					}
					continue;
				}

				// race
		//		if ( !Q_stricmp( token, "race" ) ) 
		//		{
		//			if ( COM_ParseString( &p, &value ) ) 
		//			{
		//				continue;
		//			}
		//			NPC->client->race = TranslateRaceName(value);
		//			continue;
		//		}

				// rank
				if ( !Q_stricmp( token, "rank" ) ) 
				{
					if ( COM_ParseString( &p, &value ) ) 
					{
						continue;
					}
					if ( NPC->NPC )
					{
						NPC->NPC->rank = TranslateRankName(value);
					}
					continue;
				}
			}

			// health
			if ( !Q_stricmp( token, "health" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if ( NPC->NPC )
				{
					stats->health = n;
				}
				else if ( parsingPlayer )
				{
					NPC->client->ps.stats[STAT_MAX_HEALTH] = NPC->client->pers.maxHealth = NPC->max_health = n;
				}
				continue;
			}

			// fullName
			if ( !Q_stricmp( token, "fullName" ) ) 
			{
#ifndef FINAL_BUILD
				gi.Printf( S_COLOR_YELLOW"WARNING: fullname ignored in NPC '%s'\n", NPCName );
#endif
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				continue;
			}

			// playerTeam
			if ( !Q_stricmp( token, "playerTeam" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				NPC->client->playerTeam = (team_t)GetIDForString( TeamTable, value );
				continue;
			}

			// enemyTeam
			if ( !Q_stricmp( token, "enemyTeam" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				NPC->client->enemyTeam = (team_t)GetIDForString( TeamTable, value );
				continue;
			}

			// class
			if ( !Q_stricmp( token, "class" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				NPC->client->NPC_class = (class_t)GetIDForString( ClassTable, value );

				// No md3's for vehicles.
				if ( NPC->client->NPC_class == CLASS_VEHICLE )
				{
					if ( !NPC->m_pVehicle )
					{//you didn't spawn this guy right!
						Com_Printf ( S_COLOR_RED "ERROR: Tried to spawn a vehicle NPC (%s) without using NPC_Vehicle or 'NPC spawn vehicle <vehiclename>'!!!  Bad, bad, bad!  Shame on you!\n", NPCName );
						return qfalse;
					}
					md3Model = qfalse;
				}

				continue;
			}

			// dismemberment probability for head
			if ( !Q_stricmp( token, "dismemberProbHead" ) ) {
				if ( COM_ParseInt( &p, &n ) ) {
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if ( NPC->NPC )
				{
					NPC->client->dismemberProbHead = n;
				}
				continue;
			}

			// dismemberment probability for arms
			if ( !Q_stricmp( token, "dismemberProbArms" ) ) {
				if ( COM_ParseInt( &p, &n ) ) {
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if ( NPC->NPC )
				{
					NPC->client->dismemberProbArms = n;
				}
				continue;
			}

			// dismemberment probability for hands
			if ( !Q_stricmp( token, "dismemberProbHands" ) ) {
				if ( COM_ParseInt( &p, &n ) ) {
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if ( NPC->NPC )
				{
					NPC->client->dismemberProbHands = n;
				}
				continue;
			}

			// dismemberment probability for waist
			if ( !Q_stricmp( token, "dismemberProbWaist" ) ) {
				if ( COM_ParseInt( &p, &n ) ) {
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if ( NPC->NPC )
				{
					NPC->client->dismemberProbWaist = n;
				}
				continue;
			}

			// dismemberment probability for legs
			if ( !Q_stricmp( token, "dismemberProbLegs" ) ) {
				if ( COM_ParseInt( &p, &n ) ) {
					SkipRestOfLine( &p );
					continue;
				}
				if ( n < 0 ) 
				{
					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
					continue;
				}
				if ( NPC->NPC )
				{
					NPC->client->dismemberProbLegs = n;
				}
				continue;
			}

	//===MOVEMENT STATS============================================================
			
			if ( !Q_stricmp( token, "width" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					continue;
				}

				NPC->mins[0] = NPC->mins[1] = -n;
				NPC->maxs[0] = NPC->maxs[1] = n;
				continue;
			}

			if ( !Q_stricmp( token, "height" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					continue;
				}

				if ( NPC->client->NPC_class == CLASS_VEHICLE
					&& NPC->m_pVehicle
					&& NPC->m_pVehicle->m_pVehicleInfo
					&& NPC->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
				{//a flying vehicle's origin must be centered in bbox
					NPC->maxs[2] = NPC->client->standheight = (n/2.0f);
					NPC->mins[2] = -NPC->maxs[2];
					NPC->s.origin[2] += (DEFAULT_MINS_2-NPC->mins[2])+0.125f;
					VectorCopy(NPC->s.origin, NPC->client->ps.origin);
					VectorCopy(NPC->s.origin, NPC->currentOrigin);
					G_SetOrigin( NPC, NPC->s.origin );
					gi.linkentity(NPC);
				}
				else
				{
					NPC->mins[2] = DEFAULT_MINS_2;//Cannot change
					NPC->maxs[2] = NPC->client->standheight = n + DEFAULT_MINS_2;
				}
				NPC->s.radius = n;
				continue;
			}

			if ( !Q_stricmp( token, "crouchheight" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					continue;
				}

				NPC->client->crouchheight = n + DEFAULT_MINS_2;
				continue;
			}

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

					NPC->client->moveType = (movetype_t)MoveTypeNameToEnum(value);
					continue;
				}
					
				// yawSpeed
				if ( !Q_stricmp( token, "yawSpeed" ) ) {
					if ( COM_ParseInt( &p, &n ) ) {
						SkipRestOfLine( &p );
						continue;
					}
					if ( n <= 0) {
						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->yawSpeed = ((float)(n));
					}
					continue;
				}

				// walkSpeed
				if ( !Q_stricmp( token, "walkSpeed" ) ) 
				{
					if ( COM_ParseInt( &p, &n ) ) 
					{
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 0 ) 
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->walkSpeed = n;
					}
					continue;
				}
				
				//runSpeed
				if ( !Q_stricmp( token, "runSpeed" ) ) 
				{
					if ( COM_ParseInt( &p, &n ) ) 
					{
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < 0 ) 
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						stats->runSpeed = n;
					}
					continue;
				}

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

				//sex
				if ( !Q_stricmp( token, "sex" ) ) 
				{
					if ( COM_ParseString( &p, &value ) ) 
					{
						SkipRestOfLine( &p );
						continue;
					}
					if ( value[0] == 'm' )
					{//male
						stats->sex = SEX_MALE;
					}
					else if ( value[0] == 'n' )
					{//neutral
						stats->sex = SEX_NEUTRAL;
					}
					else if ( value[0] == 'a' )
					{//asexual?
						stats->sex = SEX_NEUTRAL;
					}
					else if ( value[0] == 'f' )
					{//female
						stats->sex = SEX_FEMALE;
					}
					else if ( value[0] == 's' )
					{//shemale?
						stats->sex = SEX_SHEMALE;
					}
					else if ( value[0] == 'h' )
					{//hermaphrodite?
						stats->sex = SEX_SHEMALE;
					}
					else if ( value[0] == 't' )
					{//transsexual/transvestite?
						stats->sex = SEX_SHEMALE;
					}
					continue;
				}
//===MISC===============================================================================
				// default behavior
				if ( !Q_stricmp( token, "behavior" ) ) 
				{
					if ( COM_ParseInt( &p, &n ) ) 
					{
						SkipRestOfLine( &p );
						continue;
					}
					if ( n < BS_DEFAULT || n >= NUM_BSTATES ) 
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
						continue;
					}
					if ( NPC->NPC )
					{
						NPC->NPC->defaultBehavior = (bState_t)(n);
					}
					continue;
				}
			}

			// snd
			if ( !Q_stricmp( token, "snd" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				if ( !(NPC->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;
					}
					ci->customBasicSoundDir = G_NewString( sound );
				}
				continue;
			}

			// sndcombat
			if ( !Q_stricmp( token, "sndcombat" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				if ( !(NPC->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;
					}
					ci->customCombatSoundDir = G_NewString( sound );
				}
				continue;
			}
			
			// sndextra
			if ( !Q_stricmp( token, "sndextra" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				if ( !(NPC->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;
					}
					ci->customExtraSoundDir = G_NewString( sound );
				}
				continue;
			}

			// sndjedi
			if ( !Q_stricmp( token, "sndjedi" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				if ( !(NPC->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;
					}
					ci->customJediSoundDir = G_NewString( sound );
				}
				continue;
			}

			//New NPC/jedi stats:
			//starting weapon
			if ( !Q_stricmp( token, "weapon" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				//FIXME: need to precache the weapon, too?  (in above func)
				int weap = GetIDForString( WPTable, value );
				if ( weap >= WP_NONE && weap < WP_NUM_WEAPONS )
				{
					NPC->client->ps.weapon = weap;
					NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << weap );
					if ( weap > WP_NONE )
					{
						RegisterItem( FindItemForWeapon( (weapon_t)(weap) ) );	//precache the weapon
						NPC->client->ps.ammo[weaponData[weap].ammoIndex] = ammoData[weaponData[weap].ammoIndex].max;
					}
				}
				continue;
			}
			
			if ( !parsingPlayer )
			{
				//altFire
				if ( !Q_stricmp( token, "altFire" ) ) 
				{
					if ( COM_ParseInt( &p, &n ) ) 
					{
						SkipRestOfLine( &p );
						continue;
					}
					if ( NPC->NPC )
					{
						if ( n != 0 )
						{
							NPC->NPC->scriptFlags |= SCF_ALT_FIRE;
						}
					}
					continue;
				}
				//Other unique behaviors/numbers that are currently hardcoded?
			}

			//force powers
			int fp = GetIDForString( FPTable, token );
			if ( fp >= FP_FIRST && fp < NUM_FORCE_POWERS )
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				//FIXME: need to precache the fx, too?  (in above func)
				//cap
				if ( n > 5 )
				{
					n = 5;
				}
				else if ( n < 0 )
				{
					n = 0;
				}
				if ( n )
				{//set
					NPC->client->ps.forcePowersKnown |= ( 1 << fp );
				}
				else
				{//clear
					NPC->client->ps.forcePowersKnown &= ~( 1 << fp );
				}
				NPC->client->ps.forcePowerLevel[fp] = n;
				continue;
			}

			//max force power
			if ( !Q_stricmp( token, "forcePowerMax" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				NPC->client->ps.forcePowerMax = n;
				continue;
			}

			//force regen rate - default is 100ms
			if ( !Q_stricmp( token, "forceRegenRate" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				NPC->client->ps.forcePowerRegenRate = n;
				continue;
			}

			//force regen amount - default is 1 (points per second)
			if ( !Q_stricmp( token, "forceRegenAmount" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				NPC->client->ps.forcePowerRegenAmount = n;
				continue;
			}

			//have a sabers.cfg and just name your saber in your NPCs.cfg/ICARUS script
			//saber name
			if ( !Q_stricmp( token, "saber" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}
				char *saberName = G_NewString( value );
				WP_SaberParseParms( saberName, &NPC->client->ps.saber[0] );
				//if it requires a specific style, make sure we know how to use it
				if ( NPC->client->ps.saber[0].style )
				{
					NPC->client->ps.saberStylesKnown |= (1<<NPC->client->ps.saber[0].style);
				}
				continue;
			}
			
			//second saber name
			if ( !Q_stricmp( token, "saber2" ) ) 
			{
				if ( COM_ParseString( &p, &value ) ) 
				{
					continue;
				}

				if ( !NPC->client->ps.saber[0].twoHanded )
				{//can't use a second saber if first one is a two-handed saber...?
					char *saberName = G_NewString( value );
					WP_SaberParseParms( saberName, &NPC->client->ps.saber[1] );
					if ( NPC->client->ps.saber[1].style )
					{
						NPC->client->ps.saberStylesKnown |= (1<<NPC->client->ps.saber[1].style);
					}
					if ( NPC->client->ps.saber[1].twoHanded )
					{//tsk tsk, can't use a twoHanded saber as second saber
						WP_RemoveSaber( NPC, 1 );
					}
					else
					{
						NPC->client->ps.dualSabers = qtrue;
					}
				}
				continue;
			}

			// saberColor
			if ( !Q_stricmpn( token, "saberColor", 10) ) 
			{
				if ( !NPC->client )
				{
					continue;
				}

				if (strlen(token)==10)
				{
					if ( COM_ParseString( &p, &value ) ) 
					{
						continue;
					}
					saber_colors_t color = TranslateSaberColor( value );
					for ( n = 0; n < MAX_BLADES; n++ )
					{
						NPC->client->ps.saber[0].blade[n].color = color;
					}
				}
				else if (strlen(token)==11)
				{
					int index = atoi(&token[10])-1;
					if (index > 7 || index < 1 )
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, NPCName );
						continue;
					}
					if ( COM_ParseString( &p, &value ) ) 
					{
						continue;
					}
					NPC->client->ps.saber[0].blade[index].color = TranslateSaberColor( value );
				}
				else
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, NPCName );
				}
				continue;
			}


			if ( !Q_stricmpn( token, "saber2Color", 11 ) ) 
			{
				if ( !NPC->client )
				{
					continue;
				}

				if (strlen(token)==11)
				{
					if ( COM_ParseString( &p, &value ) ) 
					{
						continue;
					}
					saber_colors_t color = TranslateSaberColor( value );
					for ( n = 0; n < MAX_BLADES; n++ )
					{
						NPC->client->ps.saber[1].blade[n].color = color;
					}
				}
				else if (strlen(token)==12)
				{
					n = atoi(&token[11])-1;
					if (n > 7 || n < 1 )
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Color '%s' in %s\n", token, NPCName );
						continue;
					}
					if ( COM_ParseString( &p, &value ) ) 
					{
						continue;
					}
					NPC->client->ps.saber[1].blade[n].color = TranslateSaberColor( value );
				}
				else
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Color '%s' in %s\n", token, NPCName );
				}
				continue;
			}


			//saber length
			if ( !Q_stricmpn( token, "saberLength", 11) ) 
			{
				if (strlen(token)==11)
				{
					n = -1;
				}
				else if (strlen(token)==12)
				{
					n = atoi(&token[11])-1;
					if (n > 7 || n < 1 )
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, NPCName );
						continue;
					}
				}
				else
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, NPCName );
					continue;
				}

				if ( COM_ParseFloat( &p, &f ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				//cap
				if ( f < 4.0f )
				{
					f = 4.0f;
				}

				if (n == -1)//do them all
				{
					for ( n = 0; n < MAX_BLADES; n++ )
					{
						NPC->client->ps.saber[0].blade[n].lengthMax = f;
					}
				} 
				else //just one
				{
					NPC->client->ps.saber[0].blade[n].lengthMax = f;
				}
				continue;
			}

			if ( !Q_stricmpn( token, "saber2Length", 12) ) 
			{
				if (strlen(token)==12)
				{
					n = -1;
				}
				else if (strlen(token)==13)
				{
					n = atoi(&token[12])-1;
					if (n > 7 || n < 1 )
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Length '%s' in %s\n", token, NPCName );
						continue;
					}
				}
				else
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Length '%s' in %s\n", token, NPCName );
					continue;
				}

				if ( COM_ParseFloat( &p, &f ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				//cap
				if ( f < 4.0f )
				{
					f = 4.0f;
				}

				if (n == -1)//do them all
				{
					for ( n = 0; n < MAX_BLADES; n++ )
					{
						NPC->client->ps.saber[1].blade[n].lengthMax = f;
					}
				}
				else //just one
				{
					NPC->client->ps.saber[1].blade[n].lengthMax = f;
				}
				continue;
			}


			//saber radius
			if ( !Q_stricmpn( token, "saberRadius", 11 ) ) 
			{
				if (strlen(token)==11)
				{
					n = -1;
				}
				else if (strlen(token)==12)
				{
					n = atoi(&token[11])-1;
					if (n > 7 || n < 1 )
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, NPCName );
						continue;
					}
				}
				else
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, NPCName );
					continue;
				}
				
				if ( COM_ParseFloat( &p, &f ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				//cap
				if ( f < 0.25f )
				{
					f = 0.25f;
				}

				if (n==-1)
				{//NOTE: this fills in the rest of the blades with the same length by default
					for ( n = 0; n < MAX_BLADES; n++ )
					{
						NPC->client->ps.saber[0].blade[n].radius = f;
					}
				}
				else 
				{
					NPC->client->ps.saber[0].blade[n].radius = f;
				}
				continue;
			}


			if ( !Q_stricmpn( token, "saber2Radius", 12 ) ) 
			{
				if (strlen(token)==12)
				{
					n = -1;
				}
				else if (strlen(token)==13)
				{
					n = atoi(&token[12])-1;
					if (n > 7 || n < 1 )
					{
						gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Radius '%s' in %s\n", token, NPCName );
						continue;
					}
				}
				else
				{
					gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Radius '%s' in %s\n", token, NPCName );
					continue;
				}

				if ( COM_ParseFloat( &p, &f ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				//cap
				if ( f < 0.25f )
				{
					f = 0.25f;
				}

				if (n==-1)
				{//NOTE: this fills in the rest of the blades with the same length by default
					for ( n = 0; n < MAX_BLADES; n++ )
					{
						NPC->client->ps.saber[1].blade[n].radius = f;
					}
				}
				else
				{
					NPC->client->ps.saber[1].blade[n].radius = f;
				}
				continue;
			}

			//ADD:
			//saber sounds (on, off, loop)
			//loop sound (like Vader's breathing or droid bleeps, etc.)

			//starting saber style
			if ( !Q_stricmp( token, "saberStyle" ) ) 
			{
				if ( COM_ParseInt( &p, &n ) ) 
				{
					SkipRestOfLine( &p );
					continue;
				}
				//cap
				if ( n > SS_STAFF )
				{
					n = SS_STAFF;
				}
				else if ( n < SS_FAST )
				{
					n = SS_FAST;
				}
				if ( n )
				{//set
					NPC->client->ps.saberStylesKnown |= ( 1 << n );
				}
				else
				{//clear
					NPC->client->ps.saberStylesKnown &= ~( 1 << n );
				}
				NPC->client->ps.saberAnimLevel = n;
				if ( parsingPlayer )
				{
					cg.saberAnimLevelPending = n;
				}
				continue;
			}

			if ( !parsingPlayer )
			{
				gi.Printf( "WARNING: unknown keyword '%s' while parsing '%s'\n", token, NPCName );
			}
			SkipRestOfLine( &p );
		}
	}

	ci->infoValid = qfalse;

/*
Ghoul2 Insert Start
*/
	if ( !md3Model )
	{
		NPC->weaponModel[0] = -1;
		if ( Q_stricmp( "player", playerModel ) == 0 )
		{//set the model from the console cvars
			G_InitPlayerFromCvars( NPC );
			//now set the weapon, etc.
			G_MatchPlayerWeapon( NPC );
			//NPC->NPC->aiFlags |= NPCAI_MATCHPLAYERWEAPON;//FIXME: may not always want this
		}
		else
		{//do a normal model load

			// If this is a vehicle, set the model name from the vehicle type array.
			if ( NPC->client->NPC_class == CLASS_VEHICLE )
			{
				int iVehIndex = BG_VehicleGetIndex( NPC->NPC_type );
				strcpy(customSkin, "default");	// Ignore any custom skin that may have come from the NPC File
				Q_strncpyz( playerModel, g_vehicleInfo[iVehIndex].model, sizeof(playerModel), qtrue);
				if ( g_vehicleInfo[iVehIndex].skin && g_vehicleInfo[iVehIndex].skin[0] )
				{
					bool	forceSkin = false;

					// Iterate Over All Possible Skins
					//---------------------------------
					ratl::vector_vs<hstring, 15>	skinarray;
					ratl::string_vs<256>			skins(g_vehicleInfo[iVehIndex].skin);
					for (ratl::string_vs<256>::tokenizer i = skins.begin("|"); i!=skins.end(); i++)
					{
						if (NPC->soundSet && NPC->soundSet[0] && Q_stricmp(*i, NPC->soundSet)==0)
						{
							forceSkin = true;
						}
						skinarray.push_back(*i);
					}

					// Soundset Is The Designer Set Way To Supply A Skin
					//---------------------------------------------------
					if (forceSkin)
					{
						Q_strncpyz( customSkin, NPC->soundSet, sizeof(customSkin), qtrue);
					}

					// Otherwise Choose A Random Skin
					//--------------------------------
					else
					{
						if (NPC->soundSet && NPC->soundSet[0])
						{
							gi.Printf(S_COLOR_RED"WARNING: Unable to use skin (%s)", NPC->soundSet);
						}
						Q_strncpyz( customSkin, *skinarray[Q_irand(0, skinarray.size()-1)], sizeof(customSkin), qtrue);			
					}
					if (NPC->soundSet && gi.bIsFromZone(NPC->soundSet, TAG_G_ALLOC)) {
						gi.Free(NPC->soundSet);	
					}
					NPC->soundSet = 0; // clear the pointer
				}
			}

			G_SetG2PlayerModel( NPC, playerModel, customSkin, surfOff, surfOn );
		}
	}
/*
Ghoul2 Insert End
*/
	if(	NPCsPrecached )
	{//Spawning in after initial precache, our models are precached, we just need to set our clientInfo
		CG_RegisterClientModels( NPC->s.number );
		CG_RegisterNPCCustomSounds( ci );
		//CG_RegisterNPCEffects( NPC->client->playerTeam );
	}

	return qtrue;
}

void NPC_LoadParms( void ) 
{
	int			len, totallen, npcExtFNLen, fileCnt, i;
	char		*buffer, *holdChar, *marker;
	char		npcExtensionListBuf[2048];			//	The list of file names read in

	//gi.Printf( "Parsing ext_data/npcs/*.npc definitions\n" );

	//set where to store the first one
	totallen = 0;
	marker = NPCParms;
	marker[0] = '\0';

	//now load in the .npc definitions
	fileCnt = gi.FS_GetFileList("ext_data/npcs", ".npc", npcExtensionListBuf, sizeof(npcExtensionListBuf) );

	holdChar = npcExtensionListBuf;
	for ( i = 0; i < fileCnt; i++, holdChar += npcExtFNLen + 1 ) 
	{
		npcExtFNLen = strlen( holdChar );

		//gi.Printf( "Parsing %s\n", holdChar );

		len = gi.FS_ReadFile( va( "ext_data/npcs/%s", holdChar), (void **) &buffer );

		if ( len == -1 ) 
		{
			gi.Printf( "NPC_LoadParms: error reading file %s\n", holdChar );
		}
		else
		{
			if ( totallen && *(marker-1) == '}' )
			{//don't let previous file end on a } because that must be a stand-alone token
				strcat( marker, " " );
				totallen++;
				marker++; 
			}
			len = COM_Compress( buffer );

			if ( totallen + len >= MAX_NPC_DATA_SIZE ) {
				G_Error( "NPC_LoadParms: ran out of space before reading %s\n(you must make the .npc files smaller)", holdChar );
			}
			strcat( marker, buffer );
			gi.FS_FreeFile( buffer );

			totallen += len;
			marker += len;
		}
	}
}