codemp/cgame/cg_players.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// cg_players.c -- handle the media and animation for player entities
#include "cg_local.h"
#include "..\ghoul2\g2.h"
#include "bg_saga.h"

extern vmCvar_t cg_thirdPersonAlpha;

extern int                      cgSiegeTeam1PlShader;
extern int                      cgSiegeTeam2PlShader;

extern void CG_AddRadarEnt(centity_t *cent);    //cg_ents.c
extern void CG_AddBracketedEnt(centity_t *cent);        //cg_ents.c
extern qboolean CG_InFighter( void );
extern qboolean WP_SaberBladeUseSecondBladeStyle( saberInfo_t *saber, int bladeNum );


//for g2 surface routines
#define TURN_ON                         0x00000000
#define TURN_OFF                        0x00000100

extern stringID_table_t animTable [MAX_ANIMATIONS+1];

char    *cg_customSoundNames[MAX_CUSTOM_SOUNDS] = {
        "*death1",
        "*death2",
        "*death3",
        "*jump1",
        "*pain25",
        "*pain50",
        "*pain75",
        "*pain100",
        "*falling1",
        "*choke1",
        "*choke2",
        "*choke3",
        "*gasp",
        "*land1",
        "*taunt",
        NULL
};

//NPC sounds:
//Used as a supplement to the basic set for enemies and hazard team
// (keep numbers in ascending order in order for variant-capping to work)
const char      *cg_customCombatSoundNames[MAX_CUSTOM_COMBAT_SOUNDS] = 
{
        "*anger1",      //Say when acquire an enemy when didn't have one before
        "*anger2",
        "*anger3",
        "*victory1",    //Say when killed an enemy
        "*victory2",
        "*victory3",
        "*confuse1",    //Say when confused
        "*confuse2",
        "*confuse3",
        "*pushed1",     //Say when force-pushed
        "*pushed2",
        "*pushed3",
        "*choke1",
        "*choke2",
        "*choke3",
        "*ffwarn",
        "*ffturn",
        NULL
};

//Used as a supplement to the basic set for stormtroopers
// (keep numbers in ascending order in order for variant-capping to work)
const char      *cg_customExtraSoundNames[MAX_CUSTOM_EXTRA_SOUNDS] = 
{
        "*chase1",
        "*chase2",
        "*chase3",
        "*cover1",
        "*cover2",
        "*cover3",
        "*cover4",
        "*cover5",
        "*detected1",
        "*detected2",
        "*detected3",
        "*detected4",
        "*detected5",
        "*lost1",
        "*outflank1",
        "*outflank2",
        "*escaping1",
        "*escaping2",
        "*escaping3",
        "*giveup1",
        "*giveup2",
        "*giveup3",
        "*giveup4",
        "*look1",
        "*look2",
        "*sight1",
        "*sight2",
        "*sight3",
        "*sound1",
        "*sound2",
        "*sound3",
        "*suspicious1",
        "*suspicious2",
        "*suspicious3",
        "*suspicious4",
        "*suspicious5",
        NULL
};

//Used as a supplement to the basic set for jedi
// (keep numbers in ascending order in order for variant-capping to work)
const char      *cg_customJediSoundNames[MAX_CUSTOM_JEDI_SOUNDS] = 
{
        "*combat1",
        "*combat2",
        "*combat3",
        "*jdetected1",
        "*jdetected2",
        "*jdetected3",
        "*taunt1",
        "*taunt2",
        "*taunt3",
        "*jchase1",
        "*jchase2",
        "*jchase3",
        "*jlost1",
        "*jlost2",
        "*jlost3",
        "*deflect1",
        "*deflect2",
        "*deflect3",
        "*gloat1",
        "*gloat2",
        "*gloat3",
        "*pushfail",
        NULL
};

//Used for DUEL taunts
const char      *cg_customDuelSoundNames[MAX_CUSTOM_DUEL_SOUNDS] = 
{
        "*anger1",      //Say when acquire an enemy when didn't have one before
        "*anger2",
        "*anger3",
        "*victory1",    //Say when killed an enemy
        "*victory2",
        "*victory3",
        "*taunt1",
        "*taunt2",
        "*taunt3",
        "*deflect1",
        "*deflect2",
        "*deflect3",
        "*gloat1",
        "*gloat2",
        "*gloat3",
        NULL
};

void CG_Disintegration(centity_t *cent, refEntity_t *ent);

/*
================
CG_CustomSound

================
*/
sfxHandle_t     CG_CustomSound( int clientNum, const char *soundName ) {
        clientInfo_t *ci;
        int                     i;
        int                     numCSounds = 0;
        int                     numCComSounds = 0;
        int                     numCExSounds = 0;
        int                     numCJediSounds = 0;
        int                     numCSiegeSounds = 0;
        int                     numCDuelSounds = 0;
        char            lSoundName[MAX_QPATH];

        if ( soundName[0] != '*' ) {
                return trap_S_RegisterSound( soundName );
        }

        COM_StripExtension(soundName, lSoundName);

        if ( clientNum < 0 )
        {
                clientNum = 0;
        }

        if (clientNum >= MAX_CLIENTS)
        {
                ci = cg_entities[clientNum].npcClient;
        }
        else
        {
                ci = &cgs.clientinfo[ clientNum ];
        }

        if (!ci)
        {
                return 0;
        }

        for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
        {
                if (!cg_customSoundNames[i])
                {
                        numCSounds = i;
                        break;
                }
        }

        if (clientNum >= MAX_CLIENTS)
        { //these are only for npc's
                for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
                {
                        if (!cg_customCombatSoundNames[i])
                        {
                                numCComSounds = i;
                                break;
                        }
                }

                for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
                {
                        if (!cg_customExtraSoundNames[i])
                        {
                                numCExSounds = i;
                                break;
                        }
                }

                for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
                {
                        if (!cg_customJediSoundNames[i])
                        {
                                numCJediSounds = i;
                                break;
                        }
                }
        }

    if (cgs.gametype >= GT_TEAM || cg_buildScript.integer)
        { //siege only
                for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
                {
                        if (!bg_customSiegeSoundNames[i])
                        {
                                numCSiegeSounds = i;
                                break;
                        }
                }
        }

    if (cgs.gametype == GT_DUEL
                || cgs.gametype == GT_POWERDUEL
                || cg_buildScript.integer)
        { //Duel only
                for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
                {
                        if (!cg_customDuelSoundNames[i])
                        {
                                numCDuelSounds = i;
                                break;
                        }
                }
        }

        for ( i = 0 ; i < MAX_CUSTOM_SOUNDS ; i++ )
        {
                if ( i < numCSounds && !strcmp( lSoundName, cg_customSoundNames[i] ) )
                {
                        return ci->sounds[i];
                }
                else if ( (cgs.gametype >= GT_TEAM || cg_buildScript.integer) && i < numCSiegeSounds && !strcmp( lSoundName, bg_customSiegeSoundNames[i] ) )
                { //siege only
                        return ci->siegeSounds[i];
                }
                else if ( (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL || cg_buildScript.integer) && i < numCDuelSounds && !strcmp( lSoundName, cg_customDuelSoundNames[i] ) )
                { //siege only
                        return ci->duelSounds[i];
                }
                else if ( clientNum >= MAX_CLIENTS && i < numCComSounds && !strcmp( lSoundName, cg_customCombatSoundNames[i] ) )
                { //npc only
                        return ci->combatSounds[i];
                }
                else if ( clientNum >= MAX_CLIENTS && i < numCExSounds && !strcmp( lSoundName, cg_customExtraSoundNames[i] ) )
                { //npc only
                        return ci->extraSounds[i];
                }
                else if ( clientNum >= MAX_CLIENTS && i < numCJediSounds && !strcmp( lSoundName, cg_customJediSoundNames[i] ) )
                { //npc only
                        return ci->jediSounds[i];
                }
        }

        //CG_Error( "Unknown custom sound: %s", lSoundName );
#ifndef FINAL_BUILD
        Com_Printf( "Unknown custom sound: %s", lSoundName );
#endif
        return 0;
}

/*
=============================================================================

CLIENT INFO

=============================================================================
*/
#define MAX_SURF_LIST_SIZE      1024
qboolean CG_ParseSurfsFile( const char *modelName, const char *skinName, char *surfOff, char *surfOn ) 
{
        const char      *text_p;
        int                     len;
        const char      *token;
        const char      *value;
        char            text[20000];
        char            sfilename[MAX_QPATH];
        fileHandle_t    f;
        int                     i = 0;

        while (skinName && skinName[i])
        {
                if (skinName[i] == '|')
                { //this is a multi-part skin, said skins do not support .surf files
                        return qfalse;
                }

                i++;
        }


        // Load and parse .surf file
        Com_sprintf( sfilename, sizeof( sfilename ), "models/players/%s/model_%s.surf", modelName, skinName );

        // load the file
        len = trap_FS_FOpenFile( sfilename, &f, FS_READ );
        if ( len <= 0 ) 
        {//no file
                return qfalse;
        }
        if ( len >= sizeof( text ) - 1 ) 
        {
                Com_Printf( "File %s too long\n", sfilename );
                return qfalse;
        }

        trap_FS_Read( text, len, f );
        text[len] = 0;
        trap_FS_FCloseFile( f );

        // parse the text
        text_p = text;

        memset( (char *)surfOff, 0, sizeof(surfOff) );
        memset( (char *)surfOn, 0, sizeof(surfOn) );

        // read information for surfOff and surfOn
        while ( 1 ) 
        {
                token = COM_ParseExt( &text_p, qtrue );
                if ( !token || !token[0] ) 
                {
                        break;
                }

                // surfOff
                if ( !Q_stricmp( token, "surfOff" ) ) 
                {
                        if ( COM_ParseString( &text_p, &value ) ) 
                        {
                                continue;
                        }
                        if ( surfOff && surfOff[0] )
                        {
                                Q_strcat( surfOff, MAX_SURF_LIST_SIZE, "," );
                                Q_strcat( surfOff, MAX_SURF_LIST_SIZE, value );
                        }
                        else
                        {
                                Q_strncpyz( surfOff, value, MAX_SURF_LIST_SIZE );
                        }
                        continue;
                }
                
                // surfOn
                if ( !Q_stricmp( token, "surfOn" ) ) 
                {
                        if ( COM_ParseString( &text_p, &value ) ) 
                        {
                                continue;
                        }
                        if ( surfOn && surfOn[0] )
                        {
                                Q_strcat( surfOn, MAX_SURF_LIST_SIZE, ",");
                                Q_strcat( surfOn, MAX_SURF_LIST_SIZE, value );
                        }
                        else
                        {
                                Q_strncpyz( surfOn, value, MAX_SURF_LIST_SIZE );
                        }
                        continue;
                }
        }
        return qtrue;
}

/*
==========================
CG_RegisterClientModelname
==========================
*/
#include "../namespace_begin.h"
qboolean BG_IsValidCharacterModel(const char *modelName, const char *skinName);
qboolean BG_ValidateSkinForTeam( const char *modelName, char *skinName, int team, float *colors );
#include "../namespace_end.h"

static qboolean CG_RegisterClientModelname( clientInfo_t *ci, const char *modelName, const char *skinName, const char *teamName, int clientNum ) {
        int handle;
        char            afilename[MAX_QPATH];
        char             *slash;
        char            GLAName[MAX_QPATH];
        vec3_t  tempVec = {0,0,0};
        qboolean badModel = qfalse;
        char    surfOff[MAX_SURF_LIST_SIZE];
        char    surfOn[MAX_SURF_LIST_SIZE];
        int             checkSkin;
        char    *useSkinName;

retryModel:
        if (badModel)
        {
                if (modelName && modelName[0])
                {
                        Com_Printf("WARNING: Attempted to load an unsupported multiplayer model %s! (bad or missing bone, or missing animation sequence)\n", modelName);
                }

                modelName = "kyle";
                skinName = "default";

                badModel = qfalse;
        }

        // First things first.  If this is a ghoul2 model, then let's make sure we demolish this first.
        if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
        {
                trap_G2API_CleanGhoul2Models(&(ci->ghoul2Model));
        }

        if (!BG_IsValidCharacterModel(modelName, skinName))
        {
                modelName = "kyle";
                skinName = "default";
        }

        if ( cgs.gametype >= GT_TEAM && !cgs.jediVmerc && cgs.gametype != GT_SIEGE )
        { //We won't force colors for siege.
                BG_ValidateSkinForTeam( ci->modelName, ci->skinName, ci->team, ci->colorOverride );
                skinName = ci->skinName;
        }
        else
        {
                ci->colorOverride[0] = ci->colorOverride[1] = ci->colorOverride[2] = 0.0f;
        }

        if (strchr(skinName, '|'))
        {//three part skin
                useSkinName = va("models/players/%s/|%s", modelName, skinName);
        }
        else
        {
                useSkinName = va("models/players/%s/model_%s.skin", modelName, skinName);
        }

        checkSkin = trap_R_RegisterSkin(useSkinName);

        if (checkSkin)
        {
                ci->torsoSkin = checkSkin;
        }
        else
        { //fallback to the default skin
                ci->torsoSkin = trap_R_RegisterSkin(va("models/players/%s/model_default.skin", modelName, skinName));
        }
        Com_sprintf( afilename, sizeof( afilename ), "models/players/%s/model.glm", modelName );
        handle = trap_G2API_InitGhoul2Model(&ci->ghoul2Model, afilename, 0, ci->torsoSkin, 0, 0, 0);

        if (handle<0)
        {
                return qfalse;
        }

        // The model is now loaded.

        trap_G2API_SetSkin(ci->ghoul2Model, 0, ci->torsoSkin, ci->torsoSkin);

        GLAName[0] = 0;

        trap_G2API_GetGLAName( ci->ghoul2Model, 0, GLAName);
        if (GLAName[0] != 0)
        {
                if (!strstr(GLAName, "players/_humanoid/") /*&&
                        (!strstr(GLAName, "players/rockettrooper/") || cgs.gametype != GT_SIEGE)*/) //only allow rockettrooper in siege
                { //Bad!
                        badModel = qtrue;
                        goto retryModel;
                }
        }

        if (!BGPAFtextLoaded)
        {
                if (GLAName[0] == 0/*GLAName == NULL*/)
                {
                        badModel = qtrue;
                        goto retryModel;
                }
                Q_strncpyz( afilename, GLAName, sizeof( afilename ));
                slash = Q_strrchr( afilename, '/' );
                if ( slash )
                {
                        strcpy(slash, "/animation.cfg");
                }       // Now afilename holds just the path to the animation.cfg
                else 
                {       // Didn't find any slashes, this is a raw filename right in base (whish isn't a good thing)
                        return qfalse;
                }

                //rww - All player models must use humanoid, no matter what.
                if (Q_stricmp(afilename, "models/players/_humanoid/animation.cfg") /*&&
                        Q_stricmp(afilename, "models/players/rockettrooper/animation.cfg")*/)
                {
                        Com_Printf( "Model does not use supported animation config.\n");
                        return qfalse;
                }
                else if (BG_ParseAnimationFile("models/players/_humanoid/animation.cfg", bgHumanoidAnimations, qtrue) == -1)
                {
                        Com_Printf( "Failed to load animation file models/players/_humanoid/animation.cfg\n" );
                        return qfalse;
                }

                BG_ParseAnimationEvtFile( "models/players/_humanoid/", 0, -1 ); //get the sounds for the humanoid anims
//              if (cgs.gametype == GT_SIEGE)
//              {
//                      BG_ParseAnimationEvtFile( "models/players/rockettrooper/", 1, 1 ); //parse rockettrooper too
//              }
                //For the time being, we're going to have all real players use the generic humanoid soundset and that's it.
                //Only npc's will use model-specific soundsets.

        //      BG_ParseAnimationSndFile(va("models/players/%s/", modelName), 0, -1);
        }
        else if (!bgAllEvents[0].eventsParsed)
        { //make sure the player anim sounds are loaded even if the anims already are
                BG_ParseAnimationEvtFile( "models/players/_humanoid/", 0, -1 );
//              if (cgs.gametype == GT_SIEGE)
//              {
//                      BG_ParseAnimationEvtFile( "models/players/rockettrooper/", 1, 1 );
//              }
        }

        if ( CG_ParseSurfsFile( modelName, skinName, surfOff, surfOn ) )
        {//turn on/off any surfs
                const char      *token;
                const char      *p;

                //Now turn on/off any surfaces
                if ( surfOff && surfOff[0] )
                {
                        p = surfOff;
                        while ( 1 ) 
                        {
                                token = COM_ParseExt( &p, qtrue );
                                if ( !token[0] ) 
                                {//reached end of list
                                        break;
                                }
                                //turn off this surf
                                trap_G2API_SetSurfaceOnOff( ci->ghoul2Model, token, 0x00000002/*G2SURFACEFLAG_OFF*/ );
                        }
                }
                if ( surfOn && surfOn[0] )
                {
                        p = surfOn;
                        while ( 1 )
                        {
                                token = COM_ParseExt( &p, qtrue );
                                if ( !token[0] ) 
                                {//reached end of list
                                        break;
                                }
                                //turn on this surf
                                trap_G2API_SetSurfaceOnOff( ci->ghoul2Model, token, 0 );
                        }
                }
        }


        ci->bolt_rhand = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*r_hand");
        
        if (!trap_G2API_SetBoneAnim(ci->ghoul2Model, 0, "model_root", 0, 12, BONE_ANIM_OVERRIDE_LOOP, 1.0f, cg.time, -1, -1))
        {
                badModel = qtrue;
        }
        
        if (!trap_G2API_SetBoneAngles(ci->ghoul2Model, 0, "upper_lumbar", tempVec, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, cg.time))
        {
                badModel = qtrue;
        }

        if (!trap_G2API_SetBoneAngles(ci->ghoul2Model, 0, "cranium", tempVec, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, POSITIVE_X, NULL, 0, cg.time))
        {
                badModel = qtrue;
        }

        ci->bolt_lhand = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*l_hand");

        //rhand must always be first bolt. lhand always second. Whichever you want the
        //jetpack bolted to must always be third.
        trap_G2API_AddBolt(ci->ghoul2Model, 0, "*chestg");

        //claw bolts
        trap_G2API_AddBolt(ci->ghoul2Model, 0, "*r_hand_cap_r_arm");
        trap_G2API_AddBolt(ci->ghoul2Model, 0, "*l_hand_cap_l_arm");

        ci->bolt_head = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*head_top");
        if (ci->bolt_head == -1)
        {
                ci->bolt_head = trap_G2API_AddBolt(ci->ghoul2Model, 0, "ceyebrow");
        }

        ci->bolt_motion = trap_G2API_AddBolt(ci->ghoul2Model, 0, "Motion");

        //We need a lower lumbar bolt for footsteps
        ci->bolt_llumbar = trap_G2API_AddBolt(ci->ghoul2Model, 0, "lower_lumbar");

        if (ci->bolt_rhand == -1 || ci->bolt_lhand == -1 || ci->bolt_head == -1 || ci->bolt_motion == -1 || ci->bolt_llumbar == -1)
        {
                badModel = qtrue;
        }

        if (badModel)
        {
                goto retryModel;
        }

        if (!Q_stricmp(modelName, "boba_fett"))
        { //special case, turn off the jetpack surfs
                trap_G2API_SetSurfaceOnOff(ci->ghoul2Model, "torso_rjet", TURN_OFF);
                trap_G2API_SetSurfaceOnOff(ci->ghoul2Model, "torso_cjet", TURN_OFF);
                trap_G2API_SetSurfaceOnOff(ci->ghoul2Model, "torso_ljet", TURN_OFF);
        }

//      ent->s.radius = 90;

        if (clientNum != -1)
        {
                /*
                if (cg_entities[clientNum].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[clientNum].ghoul2))
                {
                        trap_G2API_CleanGhoul2Models(&(cg_entities[clientNum].ghoul2));
                }
                trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cg_entities[clientNum].ghoul2);    
                */

                cg_entities[clientNum].ghoul2weapon = NULL;
        }

        Q_strncpyz (ci->teamName, teamName, sizeof(ci->teamName));

        // Model icon for drawing the portrait on screen
        ci->modelIcon = trap_R_RegisterShaderNoMip ( va ( "models/players/%s/icon_%s", modelName, skinName ) );
        if (!ci->modelIcon)
        {
        int i = 0;
                int j;
                char iconName[1024];
                strcpy(iconName, "icon_");
                j = strlen(iconName);
                while (skinName[i] && skinName[i] != '|' && j < 1024)
                {
            iconName[j] = skinName[i];
                        j++;
                        i++;
                }
                iconName[j] = 0;
                if (skinName[i] == '|')
                { //looks like it actually may be a custom model skin, let's try getting the icon...
                        ci->modelIcon = trap_R_RegisterShaderNoMip ( va ( "models/players/%s/%s", modelName, iconName ) );
                }
        }
        return qtrue;
}

/*
====================
CG_ColorFromString
====================
*/
static void CG_ColorFromString( const char *v, vec3_t color ) {
        int val;

        VectorClear( color );

        val = atoi( v );

        if ( val < 1 || val > 7 ) {
                VectorSet( color, 1, 1, 1 );
                return;
        }

        if ( val & 1 ) {
                color[2] = 1.0f;
        }
        if ( val & 2 ) {
                color[1] = 1.0f;
        }
        if ( val & 4 ) {
                color[0] = 1.0f;
        }
}

/*
====================
CG_ColorFromInt
====================
*/
static void CG_ColorFromInt( int val, vec3_t color ) {
        VectorClear( color );

        if ( val < 1 || val > 7 ) {
                VectorSet( color, 1, 1, 1 );
                return;
        }

        if ( val & 1 ) {
                color[2] = 1.0f;
        }
        if ( val & 2 ) {
                color[1] = 1.0f;
        }
        if ( val & 4 ) {
                color[0] = 1.0f;
        }
}

//load anim info
int CG_G2SkelForModel(void *g2)
{
        int animIndex = -1;
        char GLAName[MAX_QPATH];
        char *slash;

        GLAName[0] = 0;
        trap_G2API_GetGLAName(g2, 0, GLAName);

        slash = Q_strrchr( GLAName, '/' );
        if ( slash )
        {
                strcpy(slash, "/animation.cfg");

                animIndex = BG_ParseAnimationFile(GLAName, NULL, qfalse);
        }

        return animIndex;
}

//get the appropriate anim events file index
int CG_G2EvIndexForModel(void *g2, int animIndex)
{
        int evtIndex = -1;
        char GLAName[MAX_QPATH];
        char *slash;

        if (animIndex == -1)
        {
                assert(!"shouldn't happen, bad animIndex");
                return -1;
        }

        GLAName[0] = 0;
        trap_G2API_GetGLAName(g2, 0, GLAName);

        slash = Q_strrchr( GLAName, '/' );
        if ( slash )
        {
                slash++;
                *slash = 0;

                evtIndex = BG_ParseAnimationEvtFile(GLAName, animIndex, bgNumAnimEvents);
        }

        return evtIndex;
}

#define DEFAULT_FEMALE_SOUNDPATH "chars/mp_generic_female/misc"//"chars/tavion/misc"
#define DEFAULT_MALE_SOUNDPATH "chars/mp_generic_male/misc"//"chars/kyle/misc"
void CG_LoadCISounds(clientInfo_t *ci, qboolean modelloaded)
{
        fileHandle_t f;
        qboolean        isFemale = qfalse;
        int                     i = 0;
        int                     fLen = 0;
        const char      *dir;
        char            soundpath[MAX_QPATH];
        char            soundName[1024];
        const char      *s;

        dir = ci->modelName;

        if ( !ci->skinName || !Q_stricmp( "default", ci->skinName ) )
        {//try default sounds.cfg first
                fLen = trap_FS_FOpenFile(va("models/players/%s/sounds.cfg", dir), &f, FS_READ);
                if ( !f ) 
                {//no?  Look for _default sounds.cfg
                        fLen = trap_FS_FOpenFile(va("models/players/%s/sounds_default.cfg", dir), &f, FS_READ);
                }
        }
        else
        {//use the .skin associated with this skin
                fLen = trap_FS_FOpenFile(va("models/players/%s/sounds_%s.cfg", dir, ci->skinName), &f, FS_READ);
                if ( !f ) 
                {//fall back to default sounds
                        fLen = trap_FS_FOpenFile(va("models/players/%s/sounds.cfg", dir), &f, FS_READ);
                }
        }

        soundpath[0] = 0;

        if (f)
        {
                trap_FS_Read(soundpath, fLen, f);
                soundpath[fLen] = 0;

                i = fLen;

                while (i >= 0 && soundpath[i] != '\n')
                {
                        if (soundpath[i] == 'f')
                        {
                                isFemale = qtrue;
                                soundpath[i] = 0;
                        }

                        i--;
                }

                i = 0;

                while (soundpath[i] && soundpath[i] != '\r' && soundpath[i] != '\n')
                {
                        i++;
                }
                soundpath[i] = 0;

                trap_FS_FCloseFile(f);
        }

        if (isFemale)
        {
                ci->gender = GENDER_FEMALE;
        }
        else
        {
                ci->gender = GENDER_MALE;
        }

        trap_S_ShutUp(qtrue);

        for ( i = 0 ; i < MAX_CUSTOM_SOUNDS ; i++ )
        {
                s = cg_customSoundNames[i];
                if ( !s ) {
                        break;
                }

                Com_sprintf(soundName, sizeof(soundName), "%s", s+1);
                COM_StripExtension(soundName, soundName);
                //strip the extension because we might want .mp3's

                ci->sounds[i] = 0;
                // if the model didn't load use the sounds of the default model
                if (soundpath[0])
                {
                        ci->sounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", soundpath, soundName) );
                }
                else
                {
                        if (modelloaded)
                        {
                                ci->sounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", dir, soundName) );
                        }
                }

                if (!ci->sounds[i])
                { //failed the load, try one out of the generic path
                        if (isFemale)
                        {
                                ci->sounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_FEMALE_SOUNDPATH, soundName) );
                        }
                        else
                        {
                                ci->sounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_MALE_SOUNDPATH, soundName) );
                        }
                }
        }

        if (cgs.gametype >= GT_TEAM || cg_buildScript.integer)
        { //load the siege sounds then
                for ( i = 0 ; i < MAX_CUSTOM_SIEGE_SOUNDS; i++ )
                {
                        s = bg_customSiegeSoundNames[i];
                        if ( !s )
                        {
                                break;
                        }

                        Com_sprintf(soundName, sizeof(soundName), "%s", s+1);
                        COM_StripExtension(soundName, soundName);
                        //strip the extension because we might want .mp3's

                        ci->siegeSounds[i] = 0;
                        // if the model didn't load use the sounds of the default model
                        if (soundpath[0])
                        {
                                ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", soundpath, soundName) );
                        }
                        else
                        {
                                if (modelloaded)
                                {
                                        ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", dir, soundName) );
                                }
                        }

                        if (!ci->siegeSounds[i])
                        { //failed the load, try one out of the generic path
                                if (isFemale)
                                {
                                        ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_FEMALE_SOUNDPATH, soundName) );
                                }
                                else
                                {
                                        ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_MALE_SOUNDPATH, soundName) );
                                }
                        }
                }
        }

        if (cgs.gametype == GT_DUEL
                ||cgs.gametype == GT_POWERDUEL
                || cg_buildScript.integer)
        { //load the Duel sounds then
                for ( i = 0 ; i < MAX_CUSTOM_DUEL_SOUNDS; i++ )
                {
                        s = cg_customDuelSoundNames[i];
                        if ( !s )
                        {
                                break;
                        }

                        Com_sprintf(soundName, sizeof(soundName), "%s", s+1);
                        COM_StripExtension(soundName, soundName);
                        //strip the extension because we might want .mp3's

                        ci->duelSounds[i] = 0;
                        // if the model didn't load use the sounds of the default model
                        if (soundpath[0])
                        {
                                ci->duelSounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", soundpath, soundName) );
                        }
                        else
                        {
                                if (modelloaded)
                                {
                                        ci->duelSounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", dir, soundName) );
                                }
                        }

                        if (!ci->duelSounds[i])
                        { //failed the load, try one out of the generic path
                                if (isFemale)
                                {
                                        ci->duelSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_FEMALE_SOUNDPATH, soundName) );
                                }
                                else
                                {
                                        ci->duelSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_MALE_SOUNDPATH, soundName) );
                                }
                        }
                }
        }

        trap_S_ShutUp(qfalse);
}

/*
===================
CG_LoadClientInfo

Load it now, taking the disk hits.
This will usually be deferred to a safe time
===================
*/
void CG_LoadClientInfo( clientInfo_t *ci ) {
        qboolean        modelloaded;
        int                     clientNum;
        int                     i;
        char            teamname[MAX_QPATH];

        clientNum = ci - cgs.clientinfo;

        if (clientNum < 0 || clientNum >= MAX_CLIENTS)
        {
                clientNum = -1;
        }

        ci->deferred = qfalse;

        /*
        if (ci->team == TEAM_SPECTATOR)
        {
                // reset any existing players and bodies, because they might be in bad
                // frames for this new model
                clientNum = ci - cgs.clientinfo;
                for ( i = 0 ; i < MAX_GENTITIES ; i++ ) {
                        if ( cg_entities[i].currentState.clientNum == clientNum
                                && cg_entities[i].currentState.eType == ET_PLAYER ) {
                                CG_ResetPlayerEntity( &cg_entities[i] );
                        }
                }

                if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
                {
                        trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
                }

                return;
        }
        */

        teamname[0] = 0;
        if( cgs.gametype >= GT_TEAM) {
                if( ci->team == TEAM_BLUE ) {
                        Q_strncpyz(teamname, DEFAULT_BLUETEAM_NAME/*cg_blueTeamName.string*/, sizeof(teamname) );
                } else {
                        Q_strncpyz(teamname, DEFAULT_REDTEAM_NAME/*cg_redTeamName.string*/, sizeof(teamname) );
                }
        }
        if( teamname[0] ) {
                strcat( teamname, "/" );
        }
        modelloaded = qtrue;
        if (cgs.gametype == GT_SIEGE &&
                (ci->team == TEAM_SPECTATOR || ci->siegeIndex == -1))
        { //yeah.. kind of a hack I guess. Don't care until they are actually ingame with a valid class.
                if ( !CG_RegisterClientModelname( ci, DEFAULT_MODEL, "default", teamname, -1 ) )
                {
                        CG_Error( "DEFAULT_MODEL (%s) failed to register", DEFAULT_MODEL );
                }
        }
        else
        {
                if ( !CG_RegisterClientModelname( ci, ci->modelName, ci->skinName, teamname, clientNum ) ) {
                        //CG_Error( "CG_RegisterClientModelname( %s, %s, %s, %s %s ) failed", ci->modelName, ci->skinName, ci->headModelName, ci->headSkinName, teamname );
                        //rww - DO NOT error out here! Someone could just type in a nonsense model name and crash everyone's client.
                        //Give it a chance to load default model for this client instead.

                        // fall back to default team name
                        if( cgs.gametype >= GT_TEAM) {
                                // keep skin name
                                if( ci->team == TEAM_BLUE ) {
                                        Q_strncpyz(teamname, DEFAULT_BLUETEAM_NAME, sizeof(teamname) );
                                } else {
                                        Q_strncpyz(teamname, DEFAULT_REDTEAM_NAME, sizeof(teamname) );
                                }
                                if ( !CG_RegisterClientModelname( ci, DEFAULT_MODEL, ci->skinName, teamname, -1 ) ) {
                                        CG_Error( "DEFAULT_MODEL / skin (%s/%s) failed to register", DEFAULT_MODEL, ci->skinName );
                                }
                        } else {
                                if ( !CG_RegisterClientModelname( ci, DEFAULT_MODEL, "default", teamname, -1 ) ) {
                                        CG_Error( "DEFAULT_MODEL (%s) failed to register", DEFAULT_MODEL );
                                }
                        }
                        modelloaded = qfalse;
                }
        }

        if (clientNum != -1)
        {
                trap_G2API_ClearAttachedInstance(clientNum);
        }

        if (clientNum != -1 && ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
        {
                if (cg_entities[clientNum].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[clientNum].ghoul2))
                {
                        trap_G2API_CleanGhoul2Models(&cg_entities[clientNum].ghoul2);
                }
                trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cg_entities[clientNum].ghoul2);

                //Attach the instance to this entity num so we can make use of client-server
                //shared operations if possible.
                trap_G2API_AttachInstanceToEntNum(cg_entities[clientNum].ghoul2, clientNum, qfalse);


                if (trap_G2API_AddBolt(cg_entities[clientNum].ghoul2, 0, "face") == -1)
                { //check now to see if we have this bone for setting anims and such
                        cg_entities[clientNum].noFace = qtrue;
                }

                cg_entities[clientNum].localAnimIndex = CG_G2SkelForModel(cg_entities[clientNum].ghoul2);
                cg_entities[clientNum].eventAnimIndex = CG_G2EvIndexForModel(cg_entities[clientNum].ghoul2, cg_entities[clientNum].localAnimIndex);
        }

        ci->newAnims = qfalse;
        if ( ci->torsoModel ) {
                orientation_t tag;
                // if the torso model has the "tag_flag"
                if ( trap_R_LerpTag( &tag, ci->torsoModel, 0, 0, 1, "tag_flag" ) ) {
                        ci->newAnims = qtrue;
                }
        }

        // sounds
        if (cgs.gametype == GT_SIEGE &&
                (ci->team == TEAM_SPECTATOR || ci->siegeIndex == -1))
        { //don't need to load sounds
        }
        else
        {
                CG_LoadCISounds(ci, modelloaded);
        }

        ci->deferred = qfalse;

        // reset any existing players and bodies, because they might be in bad
        // frames for this new model
        clientNum = ci - cgs.clientinfo;
        for ( i = 0 ; i < MAX_GENTITIES ; i++ ) {
                if ( cg_entities[i].currentState.clientNum == clientNum
                        && cg_entities[i].currentState.eType == ET_PLAYER ) {
                        CG_ResetPlayerEntity( &cg_entities[i] );
                }
        }
}


//Take care of initializing all the ghoul2 saber stuff based on clientinfo data. -rww
static void CG_InitG2SaberData(int saberNum, clientInfo_t *ci)
{
        trap_G2API_InitGhoul2Model(&ci->ghoul2Weapons[saberNum], ci->saber[saberNum].model, 0, ci->saber[saberNum].skin, 0, 0, 0);

        if (ci->ghoul2Weapons[saberNum])
        {
                int k = 0;
                int tagBolt;
                char *tagName;

                if (ci->saber[saberNum].skin)
                {
                        trap_G2API_SetSkin(ci->ghoul2Weapons[saberNum], 0, ci->saber[saberNum].skin, ci->saber[saberNum].skin);
                }

                if (ci->saber[saberNum].saberFlags & SFL_BOLT_TO_WRIST)
                {
                        trap_G2API_SetBoltInfo(ci->ghoul2Weapons[saberNum], 0, 3+saberNum);
                }
                else
                {
                        trap_G2API_SetBoltInfo(ci->ghoul2Weapons[saberNum], 0, saberNum);
                }

                while (k < ci->saber[saberNum].numBlades)
                {
                        tagName = va("*blade%i", k+1);
                        tagBolt = trap_G2API_AddBolt(ci->ghoul2Weapons[saberNum], 0, tagName);

                        if (tagBolt == -1)
                        {
                                if (k == 0)
                                { //guess this is an 0ldsk3wl saber
                                        tagBolt = trap_G2API_AddBolt(ci->ghoul2Weapons[saberNum], 0, "*flash");

                                        if (tagBolt == -1)
                                        {
                                                assert(0);
                                        }
                                        break;
                                }

                                if (tagBolt == -1)
                                {
                                        assert(0);
                                        break;
                                }
                        }

                        k++;
                }
        }
}


/*
======================
CG_CopyClientInfoModel
======================
*/
static void CG_CopyClientInfoModel( clientInfo_t *from, clientInfo_t *to )
{
        VectorCopy( from->headOffset, to->headOffset );
//      to->footsteps = from->footsteps;
        to->gender = from->gender;

        to->legsModel = from->legsModel;
        to->legsSkin = from->legsSkin;
        to->torsoModel = from->torsoModel;
        to->torsoSkin = from->torsoSkin;
        //to->headModel = from->headModel;
        //to->headSkin = from->headSkin;
        to->modelIcon = from->modelIcon;

        to->newAnims = from->newAnims;

        //to->ghoul2Model = from->ghoul2Model;
        //rww - Trying to use the same ghoul2 pointer for two seperate clients == DISASTER
        assert(to->ghoul2Model != from->ghoul2Model);

        if (to->ghoul2Model && trap_G2_HaveWeGhoul2Models(to->ghoul2Model))
        {
                trap_G2API_CleanGhoul2Models(&to->ghoul2Model);
        }
        if (from->ghoul2Model && trap_G2_HaveWeGhoul2Models(from->ghoul2Model))
        {
                trap_G2API_DuplicateGhoul2Instance(from->ghoul2Model, &to->ghoul2Model);
        }

        //Don't do this, I guess. Just leave the saber info in the original, so it will be
        //properly initialized.
        /*
        strcpy(to->saberName, from->saberName);
        strcpy(to->saber2Name, from->saber2Name);

        while (i < MAX_SABERS)
        {
                if (to->ghoul2Weapons[i] && trap_G2_HaveWeGhoul2Models(to->ghoul2Weapons[i]))
                {
                        trap_G2API_CleanGhoul2Models(&to->ghoul2Weapons[i]);
                }

                WP_SetSaber(to->saber, 0, to->saberName);
                WP_SetSaber(to->saber, 1, to->saber2Name);

                j = 0;

                while (j < MAX_SABERS)
                {
                        if (to->saber[j].model[0])
                        {
                                CG_InitG2SaberData(j, to);
                        }
                        j++;
                }
                i++;
        }
        */

        to->bolt_head = from->bolt_head;
        to->bolt_lhand = from->bolt_lhand;
        to->bolt_rhand = from->bolt_rhand;
        to->bolt_motion = from->bolt_motion;
        to->bolt_llumbar = from->bolt_llumbar;

        to->siegeIndex = from->siegeIndex;

        memcpy( to->sounds, from->sounds, sizeof( to->sounds ) );
        memcpy( to->siegeSounds, from->siegeSounds, sizeof( to->siegeSounds ) );
        memcpy( to->duelSounds, from->duelSounds, sizeof( to->duelSounds ) );
}

/*
======================
CG_ScanForExistingClientInfo
======================
*/
static qboolean CG_ScanForExistingClientInfo( clientInfo_t *ci, int clientNum ) {
        int             i;
        clientInfo_t    *match;

        for ( i = 0 ; i < cgs.maxclients ; i++ ) {
                match = &cgs.clientinfo[ i ];
                if ( !match->infoValid ) {
                        continue;
                }
                if ( match->deferred ) {
                        continue;
                }
                if ( !Q_stricmp( ci->modelName, match->modelName )
                        && !Q_stricmp( ci->skinName, match->skinName )
                        && !Q_stricmp( ci->saberName, match->saberName)
                        && !Q_stricmp( ci->saber2Name, match->saber2Name)
//                      && !Q_stricmp( ci->headModelName, match->headModelName )
//                      && !Q_stricmp( ci->headSkinName, match->headSkinName ) 
//                      && !Q_stricmp( ci->blueTeam, match->blueTeam ) 
//                      && !Q_stricmp( ci->redTeam, match->redTeam )
                        && (cgs.gametype < GT_TEAM || ci->team == match->team) 
                        && ci->siegeIndex == match->siegeIndex
                        && match->ghoul2Model
                        && match->bolt_head) //if the bolts haven't been initialized, this "match" is useless to us
                {
                        // this clientinfo is identical, so use it's handles

                        ci->deferred = qfalse;

                        //rww - Filthy hack. If this is actually the info already belonging to us, just reassign the pointer.
                        //Switching instances when not necessary produces small animation glitches.
                        //Actually, before, were we even freeing the instance attached to the old clientinfo before copying
                        //this new clientinfo over it? Could be a nasty leak possibility. (though this should remedy it in theory)
                        if (clientNum == i)
                        {
                                if (match->ghoul2Model && trap_G2_HaveWeGhoul2Models(match->ghoul2Model))
                                { //The match has a valid instance (if it didn't, we'd probably already be fudged (^_^) at this state)
                                        if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
                                        { //First kill the copy we have if we have one. (but it should be null)
                                                trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
                                        }

                                        VectorCopy( match->headOffset, ci->headOffset );
//                                      ci->footsteps = match->footsteps;
                                        ci->gender = match->gender;

                                        ci->legsModel = match->legsModel;
                                        ci->legsSkin = match->legsSkin;
                                        ci->torsoModel = match->torsoModel;
                                        ci->torsoSkin = match->torsoSkin;
                                        ci->modelIcon = match->modelIcon;

                                        ci->newAnims = match->newAnims;

                                        ci->bolt_head = match->bolt_head;
                                        ci->bolt_lhand = match->bolt_lhand;
                                        ci->bolt_rhand = match->bolt_rhand;
                                        ci->bolt_motion = match->bolt_motion;
                                        ci->bolt_llumbar = match->bolt_llumbar;
                                        ci->siegeIndex = match->siegeIndex;

                                        memcpy( ci->sounds, match->sounds, sizeof( ci->sounds ) );
                                        memcpy( ci->siegeSounds, match->siegeSounds, sizeof( ci->siegeSounds ) );
                                        memcpy( ci->duelSounds, match->duelSounds, sizeof( ci->duelSounds ) );

                                        //We can share this pointer, because it already belongs to this client.
                                        //The pointer itself and the ghoul2 instance is never actually changed, just passed between
                                        //clientinfo structures.
                                        ci->ghoul2Model = match->ghoul2Model;

                                        //Don't need to do this I guess, whenever this function is called the saber stuff should
                                        //already be taken care of in the new info.
                                        /*
                                        while (k < MAX_SABERS)
                                        {
                                                if (match->ghoul2Weapons[k] && match->ghoul2Weapons[k] != ci->ghoul2Weapons[k])
                                                {
                                                        if (ci->ghoul2Weapons[k])
                                                        {
                                                                trap_G2API_CleanGhoul2Models(&ci->ghoul2Weapons[k]);
                                                        }
                            ci->ghoul2Weapons[k] = match->ghoul2Weapons[k];
                                                }
                                                k++;
                                        }
                                        */
                                }
                        }
                        else
                        {
                                CG_CopyClientInfoModel( match, ci );
                        }

                        return qtrue;
                }
        }

        // nothing matches, so defer the load
        return qfalse;
}

/*
======================
CG_SetDeferredClientInfo

We aren't going to load it now, so grab some other
client's info to use until we have some spare time.
======================
*/
static void CG_SetDeferredClientInfo( clientInfo_t *ci ) {
        int             i;
        clientInfo_t    *match;

        // if someone else is already the same models and skins we
        // can just load the client info
        for ( i = 0 ; i < cgs.maxclients ; i++ ) {
                match = &cgs.clientinfo[ i ];
                if ( !match->infoValid || match->deferred ) {
                        continue;
                }
                if ( Q_stricmp( ci->skinName, match->skinName ) ||
                         Q_stricmp( ci->modelName, match->modelName ) ||
//                       Q_stricmp( ci->headModelName, match->headModelName ) ||
//                       Q_stricmp( ci->headSkinName, match->headSkinName ) ||
                         (cgs.gametype >= GT_TEAM && ci->team != match->team && ci->team != TEAM_SPECTATOR) ) {
                        continue;
                }

                 /*
                if (Q_stricmp(ci->saberName, match->saberName) ||
                        Q_stricmp(ci->saber2Name, match->saber2Name))
                {
                        continue;
                }
                */

                // just load the real info cause it uses the same models and skins
                CG_LoadClientInfo( ci );
                return;
        }

        // if we are in teamplay, only grab a model if the skin is correct
        if ( cgs.gametype >= GT_TEAM ) {
                for ( i = 0 ; i < cgs.maxclients ; i++ ) {
                        match = &cgs.clientinfo[ i ];
                        if ( !match->infoValid || match->deferred ) {
                                continue;
                        }
                        if ( ci->