codemp/cgame/cg_weapons.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// cg_weapons.c -- events and effects dealing with weapons
#include "cg_local.h"
#include "fx_local.h"

extern vec4_t   bluehudtint;
extern vec4_t   redhudtint;
extern float    *hudTintColor;

/*
Ghoul2 Insert Start
*/
// set up the appropriate ghoul2 info to a refent
void CG_SetGhoul2InfoRef( refEntity_t *ent, refEntity_t *s1)
{
        ent->ghoul2 = s1->ghoul2;
        VectorCopy( s1->modelScale, ent->modelScale);
        ent->radius = s1->radius;
        VectorCopy( s1->angles, ent->angles);
}

/*
Ghoul2 Insert End
*/

/*
=================
CG_RegisterItemVisuals

The server says this item is used on this level
=================
*/
void CG_RegisterItemVisuals( int itemNum ) {
        itemInfo_t              *itemInfo;
        gitem_t                 *item;
        int                             handle;

        if ( itemNum < 0 || itemNum >= bg_numItems ) {
                CG_Error( "CG_RegisterItemVisuals: itemNum %d out of range [0-%d]", itemNum, bg_numItems-1 );
        }

        itemInfo = &cg_items[ itemNum ];
        if ( itemInfo->registered ) {
                return;
        }

        item = &bg_itemlist[ itemNum ];

        memset( itemInfo, 0, sizeof( &itemInfo ) );
        itemInfo->registered = qtrue;

        if (item->giType == IT_TEAM &&
                (item->giTag == PW_REDFLAG || item->giTag == PW_BLUEFLAG) &&
                cgs.gametype == GT_CTY)
        { //in CTY the flag model is different
                itemInfo->models[0] = trap_R_RegisterModel( item->world_model[1] );
        }
        else if (item->giType == IT_WEAPON &&
                (item->giTag == WP_THERMAL || item->giTag == WP_TRIP_MINE || item->giTag == WP_DET_PACK))
        {
                itemInfo->models[0] = trap_R_RegisterModel( item->world_model[1] );
        }
        else
        {
                itemInfo->models[0] = trap_R_RegisterModel( item->world_model[0] );
        }
/*
Ghoul2 Insert Start
*/
        if (!Q_stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
        {
                handle = trap_G2API_InitGhoul2Model(&itemInfo->g2Models[0], item->world_model[0], 0 , 0, 0, 0, 0);
                if (handle<0)
                {
                        itemInfo->g2Models[0] = NULL;
                }
                else
                {
                        itemInfo->radius[0] = 60;
                }
        }
/*
Ghoul2 Insert End
*/
        if (item->icon)
        {
                if (item->giType == IT_HEALTH)
                { //medpack gets nomip'd by the ui or something I guess.
                        itemInfo->icon = trap_R_RegisterShaderNoMip( item->icon );
                }
                else
                {
                        itemInfo->icon = trap_R_RegisterShader( item->icon );
                }
        }
        else
        {
                itemInfo->icon = 0;
        }

        if ( item->giType == IT_WEAPON ) {
                CG_RegisterWeapon( item->giTag );
        }

        //
        // powerups have an accompanying ring or sphere
        //
        if ( item->giType == IT_POWERUP || item->giType == IT_HEALTH || 
                item->giType == IT_ARMOR || item->giType == IT_HOLDABLE ) {
                if ( item->world_model[1] ) {
                        itemInfo->models[1] = trap_R_RegisterModel( item->world_model[1] );
                }
        }
}


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

VIEW WEAPON

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

#define WEAPON_FORCE_BUSY_HOLSTER

#ifdef WEAPON_FORCE_BUSY_HOLSTER
//rww - this was done as a last resort. Forgive me.
static int cgWeapFrame = 0;
static int cgWeapFrameTime = 0;
#endif

/*
=================
CG_MapTorsoToWeaponFrame

=================
*/
static int CG_MapTorsoToWeaponFrame( clientInfo_t *ci, int frame, int animNum ) {
        animation_t *animations = bgHumanoidAnimations;
#ifdef WEAPON_FORCE_BUSY_HOLSTER
        if (cg.snap->ps.forceHandExtend != HANDEXTEND_NONE || cgWeapFrameTime > cg.time)
        { //the reason for the after delay is so that it doesn't snap the weapon frame to the "idle" (0) frame
                //for a very quick moment
                if (cgWeapFrame < 6)
                {
                        cgWeapFrame = 6;
                        cgWeapFrameTime = cg.time + 10;
                }

                if (cgWeapFrameTime < cg.time && cgWeapFrame < 10)
                {
                        cgWeapFrame++;
                        cgWeapFrameTime = cg.time + 10;
                }

                if (cg.snap->ps.forceHandExtend != HANDEXTEND_NONE &&
                        cgWeapFrame == 10)
                {
                        cgWeapFrameTime = cg.time + 100;
                }

                return cgWeapFrame;
        }
        else
        {
                cgWeapFrame = 0;
                cgWeapFrameTime = 0;
        }
#endif

        switch( animNum )
        {
        case TORSO_DROPWEAP1:
                if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 5 ) 
                {
                        return frame - animations[animNum].firstFrame + 6;
                }
                break;

        case TORSO_RAISEWEAP1:
                if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 4 ) 
                {
                        return frame - animations[animNum].firstFrame + 6 + 4;
                }
                break;
        case BOTH_ATTACK1:
        case BOTH_ATTACK2:
        case BOTH_ATTACK3:
        case BOTH_ATTACK4:
        case BOTH_ATTACK10:
        case BOTH_THERMAL_THROW:
                if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 6 ) 
                {
                        return 1 + ( frame - animations[animNum].firstFrame );
                }

                break;
        }       
        return -1;
}


/*
==============
CG_CalculateWeaponPosition
==============
*/
static void CG_CalculateWeaponPosition( vec3_t origin, vec3_t angles ) {
        float   scale;
        int             delta;
        float   fracsin;

        VectorCopy( cg.refdef.vieworg, origin );
        VectorCopy( cg.refdef.viewangles, angles );

        // on odd legs, invert some angles
        if ( cg.bobcycle & 1 ) {
                scale = -cg.xyspeed;
        } else {
                scale = cg.xyspeed;
        }

        // gun angles from bobbing
        angles[ROLL] += scale * cg.bobfracsin * 0.005;
        angles[YAW] += scale * cg.bobfracsin * 0.01;
        angles[PITCH] += cg.xyspeed * cg.bobfracsin * 0.005;

        // drop the weapon when landing
        delta = cg.time - cg.landTime;
        if ( delta < LAND_DEFLECT_TIME ) {
                origin[2] += cg.landChange*0.25 * delta / LAND_DEFLECT_TIME;
        } else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
                origin[2] += cg.landChange*0.25 * 
                        (LAND_DEFLECT_TIME + LAND_RETURN_TIME - delta) / LAND_RETURN_TIME;
        }

#if 0
        // drop the weapon when stair climbing
        delta = cg.time - cg.stepTime;
        if ( delta < STEP_TIME/2 ) {
                origin[2] -= cg.stepChange*0.25 * delta / (STEP_TIME/2);
        } else if ( delta < STEP_TIME ) {
                origin[2] -= cg.stepChange*0.25 * (STEP_TIME - delta) / (STEP_TIME/2);
        }
#endif

        // idle drift
        scale = cg.xyspeed + 40;
        fracsin = sin( cg.time * 0.001 );
        angles[ROLL] += scale * fracsin * 0.01;
        angles[YAW] += scale * fracsin * 0.01;
        angles[PITCH] += scale * fracsin * 0.01;
}


/*
===============
CG_LightningBolt

Origin will be the exact tag point, which is slightly
different than the muzzle point used for determining hits.
The cent should be the non-predicted cent if it is from the player,
so the endpoint will reflect the simulated strike (lagging the predicted
angle)
===============
*/
static void CG_LightningBolt( centity_t *cent, vec3_t origin ) {
//      trace_t  trace;
        refEntity_t  beam;
//      vec3_t   forward;
//      vec3_t   muzzlePoint, endPoint;

        //Must be a durational weapon that continuously generates an effect.
        if ( cent->currentState.weapon == WP_DEMP2 && cent->currentState.eFlags & EF_ALT_FIRING ) 
        { /*nothing*/ }
        else
        {
                return;
        }

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

        // NOTENOTE No lightning gun-ish stuff yet.
/*
        // CPMA  "true" lightning
        if ((cent->currentState.number == cg.predictedPlayerState.clientNum) && (cg_trueLightning.value != 0)) {
                vec3_t angle;
                int i;

                for (i = 0; i < 3; i++) {
                        float a = cent->lerpAngles[i] - cg.refdef.viewangles[i];
                        if (a > 180) {
                                a -= 360;
                        }
                        if (a < -180) {
                                a += 360;
                        }

                        angle[i] = cg.refdef.viewangles[i] + a * (1.0 - cg_trueLightning.value);
                        if (angle[i] < 0) {
                                angle[i] += 360;
                        }
                        if (angle[i] > 360) {
                                angle[i] -= 360;
                        }
                }

                AngleVectors(angle, forward, NULL, NULL );
                VectorCopy(cent->lerpOrigin, muzzlePoint );
//              VectorCopy(cg.refdef.vieworg, muzzlePoint );
        } else {
                // !CPMA
                AngleVectors( cent->lerpAngles, forward, NULL, NULL );
                VectorCopy(cent->lerpOrigin, muzzlePoint );
        }

        // FIXME: crouch
        muzzlePoint[2] += DEFAULT_VIEWHEIGHT;

        VectorMA( muzzlePoint, 14, forward, muzzlePoint );

        // project forward by the lightning range
        VectorMA( muzzlePoint, LIGHTNING_RANGE, forward, endPoint );

        // see if it hit a wall
        CG_Trace( &trace, muzzlePoint, vec3_origin, vec3_origin, endPoint, 
                cent->currentState.number, MASK_SHOT );

        // this is the endpoint
        VectorCopy( trace.endpos, beam.oldorigin );

        // use the provided origin, even though it may be slightly
        // different than the muzzle origin
        VectorCopy( origin, beam.origin );

        beam.reType = RT_LIGHTNING;
        beam.customShader = cgs.media.lightningShader;
        trap_R_AddRefEntityToScene( &beam );
*/

        // NOTENOTE No lightning gun-ish stuff yet.
/*
        // add the impact flare if it hit something
        if ( trace.fraction < 1.0 ) {
                vec3_t  angles;
                vec3_t  dir;

                VectorSubtract( beam.oldorigin, beam.origin, dir );
                VectorNormalize( dir );

                memset( &beam, 0, sizeof( beam ) );
                beam.hModel = cgs.media.lightningExplosionModel;

                VectorMA( trace.endpos, -16, dir, beam.origin );

                // make a random orientation
                angles[0] = rand() % 360;
                angles[1] = rand() % 360;
                angles[2] = rand() % 360;
                AnglesToAxis( angles, beam.axis );
                trap_R_AddRefEntityToScene( &beam );
        }
*/
}


/*
========================
CG_AddWeaponWithPowerups
========================
*/
static void CG_AddWeaponWithPowerups( refEntity_t *gun, int powerups ) {
        // add powerup effects
        trap_R_AddRefEntityToScene( gun );

        if (cg.predictedPlayerState.electrifyTime > cg.time)
        { //add electrocution shell
                int preShader = gun->customShader;
                if ( rand() & 1 )
                {
                        gun->customShader = cgs.media.electricBodyShader;       
                }
                else
                {
                        gun->customShader = cgs.media.electricBody2Shader;
                }
                trap_R_AddRefEntityToScene( gun );
                gun->customShader = preShader; //set back just to be safe
        }
}


/*
=============
CG_AddPlayerWeapon

Used for both the view weapon (ps is valid) and the world modelother character models (ps is NULL)
The main player will have this called for BOTH cases, so effects like light and
sound should only be done on the world model case.
=============
*/
void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent, int team, vec3_t newAngles, qboolean thirdPerson ) {
        refEntity_t     gun;
        refEntity_t     barrel;
        vec3_t          angles;
        weapon_t        weaponNum;
        weaponInfo_t    *weapon;
        centity_t       *nonPredictedCent;
        refEntity_t     flash;

        weaponNum = cent->currentState.weapon;

        if (cent->currentState.weapon == WP_EMPLACED_GUN)
        {
                return;
        }

        if (cg.predictedPlayerState.pm_type == PM_SPECTATOR &&
                cent->currentState.number == cg.predictedPlayerState.clientNum)
        { //spectator mode, don't draw it...
                return;
        }

        CG_RegisterWeapon( weaponNum );
        weapon = &cg_weapons[weaponNum];
/*
Ghoul2 Insert Start
*/

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

        // only do this if we are in first person, since world weapons are now handled on the server by Ghoul2
        if (!thirdPerson)
        {

                // add the weapon
                VectorCopy( parent->lightingOrigin, gun.lightingOrigin );
                gun.shadowPlane = parent->shadowPlane;
                gun.renderfx = parent->renderfx;

                if (ps)
                {       // this player, in first person view
                        gun.hModel = weapon->viewModel;
                }
                else
                {
                        gun.hModel = weapon->weaponModel;
                }
                if (!gun.hModel) {
                        return;
                }

                if ( !ps ) {
                        // add weapon ready sound
                        cent->pe.lightningFiring = qfalse;
                        if ( ( cent->currentState.eFlags & EF_FIRING ) && weapon->firingSound ) {
                                // lightning gun and guantlet make a different sound when fire is held down
                                trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->firingSound );
                                cent->pe.lightningFiring = qtrue;
                        } else if ( weapon->readySound ) {
                                trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->readySound );
                        }
                }
        
                CG_PositionEntityOnTag( &gun, parent, parent->hModel, "tag_weapon");

                if (!CG_IsMindTricked(cent->currentState.trickedentindex,
                        cent->currentState.trickedentindex2,
                        cent->currentState.trickedentindex3,
                        cent->currentState.trickedentindex4,
                        cg.snap->ps.clientNum))
                {
                        CG_AddWeaponWithPowerups( &gun, cent->currentState.powerups ); //don't draw the weapon if the player is invisible
                        /*
                        if ( weaponNum == WP_STUN_BATON )
                        {
                                gun.shaderRGBA[0] = gun.shaderRGBA[1] = gun.shaderRGBA[2] = 25;
        
                                gun.customShader = trap_R_RegisterShader( "gfx/effects/stunPass" );
                                gun.renderfx = RF_RGB_TINT | RF_FIRST_PERSON | RF_DEPTHHACK;
                                trap_R_AddRefEntityToScene( &gun );
                        }
                        */
                }

                if (weaponNum == WP_STUN_BATON)
                {
                        int i = 0;

                        while (i < 3)
                        {
                                memset( &barrel, 0, sizeof( barrel ) );
                                VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
                                barrel.shadowPlane = parent->shadowPlane;
                                barrel.renderfx = parent->renderfx;

                                if (i == 0)
                                {
                                        barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel.md3");
                                }
                                else if (i == 1)
                                {
                                        barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel2.md3");
                                }
                                else
                                {
                                        barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel3.md3");
                                }
                                angles[YAW] = 0;
                                angles[PITCH] = 0;
                                angles[ROLL] = 0;

                                AnglesToAxis( angles, barrel.axis );

                                if (i == 0)
                                {
                                        CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" );
                                }
                                else if (i == 1)
                                {
                                        CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel2" );
                                }
                                else
                                {
                                        CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel3" );
                                }
                                CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups );

                                i++;
                        }
                }
                else
                {
                        // add the spinning barrel
                        if ( weapon->barrelModel ) {
                                memset( &barrel, 0, sizeof( barrel ) );
                                VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
                                barrel.shadowPlane = parent->shadowPlane;
                                barrel.renderfx = parent->renderfx;

                                barrel.hModel = weapon->barrelModel;
                                angles[YAW] = 0;
                                angles[PITCH] = 0;
                                angles[ROLL] = 0;

                                AnglesToAxis( angles, barrel.axis );

                                CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" );

                                CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups );
                        }
                }
        }
/*
Ghoul2 Insert End
*/

        memset (&flash, 0, sizeof(flash));
        CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");

        VectorCopy(flash.origin, cg.lastFPFlashPoint);

        // Do special charge bits
        //-----------------------
        if ( (ps || cg.renderingThirdPerson || cg.predictedPlayerState.clientNum != cent->currentState.number) &&
                ( ( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_PISTOL ) ||
                  ( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_OLD ) ||
                  ( cent->currentState.weapon == WP_BOWCASTER && cent->currentState.modelindex2 == WEAPON_CHARGING ) ||
                  ( cent->currentState.weapon == WP_DEMP2 && cent->currentState.modelindex2 == WEAPON_CHARGING_ALT) ) )
        {
                int             shader = 0;
                float   val = 0.0f;
                float   scale = 1.0f;
                addspriteArgStruct_t fxSArgs;
                vec3_t flashorigin, flashdir;

                if (!thirdPerson)
                {
                        VectorCopy(flash.origin, flashorigin);
                        VectorCopy(flash.axis[0], flashdir);
                }
                else
                {
                        mdxaBone_t              boltMatrix;

                        if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
                        { //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case
                                return;
                        }

                        // go away and get me the bolt position for this frame please
                        if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale)))
                        {       // Couldn't find bolt point.
                                return;
                        }
                        
                        BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin);
                        BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir);
                }

                if ( cent->currentState.weapon == WP_BRYAR_PISTOL ||
                        cent->currentState.weapon == WP_BRYAR_OLD)
                {
                        // Hardcoded max charge time of 1 second
                        val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
                        shader = cgs.media.bryarFrontFlash;
                }
                else if ( cent->currentState.weapon == WP_BOWCASTER )
                {
                        // Hardcoded max charge time of 1 second
                        val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
                        shader = cgs.media.greenFrontFlash;
                }
                else if ( cent->currentState.weapon == WP_DEMP2 )
                {
                        val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
                        shader = cgs.media.lightningFlash;
                        scale = 1.75f;
                }

                if ( val < 0.0f )
                {
                        val = 0.0f;
                }
                else if ( val > 1.0f )
                {
                        val = 1.0f;
                        if (ps && cent->currentState.number == ps->clientNum)
                        {
                                CGCam_Shake( /*0.1f*/0.2f, 100 );
                        }
                }
                else
                {
                        if (ps && cent->currentState.number == ps->clientNum)
                        {
                                CGCam_Shake( val * val * /*0.3f*/0.6f, 100 );
                        }
                }

                val += random() * 0.5f;

                VectorCopy(flashorigin, fxSArgs.origin);
                VectorClear(fxSArgs.vel);
                VectorClear(fxSArgs.accel);
                fxSArgs.scale = 3.0f*val*scale;
                fxSArgs.dscale = 0.0f;
                fxSArgs.sAlpha = 0.7f;
                fxSArgs.eAlpha = 0.7f;
                fxSArgs.rotation = random()*360;
                fxSArgs.bounce = 0.0f;
                fxSArgs.life = 1.0f;
                fxSArgs.shader = shader;
                fxSArgs.flags = 0x08000000;

                //FX_AddSprite( flash.origin, NULL, NULL, 3.0f * val, 0.0f, 0.7f, 0.7f, WHITE, WHITE, random() * 360, 0.0f, 1.0f, shader, FX_USE_ALPHA );
                trap_FX_AddSprite(&fxSArgs);
        }

        // make sure we aren't looking at cg.predictedPlayerEntity for LG
        nonPredictedCent = &cg_entities[cent->currentState.clientNum];

        // if the index of the nonPredictedCent is not the same as the clientNum
        // then this is a fake player (like on teh single player podiums), so
        // go ahead and use the cent
        if( ( nonPredictedCent - cg_entities ) != cent->currentState.clientNum ) {
                nonPredictedCent = cent;
        }

        // add the flash
        if ( ( weaponNum == WP_DEMP2)
                && ( nonPredictedCent->currentState.eFlags & EF_FIRING ) ) 
        {
                // continuous flash
        } else {
                // impulse flash
                if ( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME) {
                        return;
                }
        }

        if ( ps || cg.renderingThirdPerson ||
                        cent->currentState.number != cg.predictedPlayerState.clientNum ) 
        {       // Make sure we don't do the thirdperson model effects for the local player if we're in first person
                vec3_t flashorigin, flashdir;
                refEntity_t     flash;

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

                if (!thirdPerson)
                {
                        CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
                        VectorCopy(flash.origin, flashorigin);
                        VectorCopy(flash.axis[0], flashdir);
                }
                else
                {
                        mdxaBone_t              boltMatrix;

                        if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
                        { //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case
                                return;
                        }

                        // go away and get me the bolt position for this frame please
                        if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale)))
                        {       // Couldn't find bolt point.
                                return;
                        }
                        
                        BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin);
                        BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir);
                }

                if ( cg.time - cent->muzzleFlashTime <= MUZZLE_FLASH_TIME + 10 )
                {       // Handle muzzle flashes
                        if ( cent->currentState.eFlags & EF_ALT_FIRING )
                        {       // Check the alt firing first.
                                if (weapon->altMuzzleEffect)
                                {
                                        if (!thirdPerson)
                                        {
                                                trap_FX_PlayEntityEffectID(weapon->altMuzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1  );
                                        }
                                        else
                                        {
                                                trap_FX_PlayEffectID(weapon->altMuzzleEffect, flashorigin, flashdir, -1, -1);
                                        }
                                }
                        }
                        else
                        {       // Regular firing
                                if (weapon->muzzleEffect)
                                {
                                        if (!thirdPerson)
                                        {
                                                trap_FX_PlayEntityEffectID(weapon->muzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1  );
                                        }
                                        else
                                        {
                                                trap_FX_PlayEffectID(weapon->muzzleEffect, flashorigin, flashdir, -1, -1);
                                        }
                                }
                        }
                }

                // add lightning bolt
                CG_LightningBolt( nonPredictedCent, flashorigin );

                if ( weapon->flashDlightColor[0] || weapon->flashDlightColor[1] || weapon->flashDlightColor[2] ) {
                        trap_R_AddLightToScene( flashorigin, 300 + (rand()&31), weapon->flashDlightColor[0],
                                weapon->flashDlightColor[1], weapon->flashDlightColor[2] );
                }
        }
}

/*
==============
CG_AddViewWeapon

Add the weapon, and flash for the player's view
==============
*/
void CG_AddViewWeapon( playerState_t *ps ) {
        refEntity_t     hand;
        centity_t       *cent;
        clientInfo_t    *ci;
        float           fovOffset;
        vec3_t          angles;
        weaponInfo_t    *weapon;
        float   cgFov = cg_fov.value;

        if (cgFov < 1)
        {
                cgFov = 1;
        }
        if (cgFov > 97)
        {
                cgFov = 97;
        }

        if ( ps->persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
                return;
        }

        if ( ps->pm_type == PM_INTERMISSION ) {
                return;
        }

        // no gun if in third person view or a camera is active
        //if ( cg.renderingThirdPerson || cg.cameraMode) {
        if ( cg.renderingThirdPerson ) {
                return;
        }

        // allow the gun to be completely removed
        if ( !cg_drawGun.integer || cg.predictedPlayerState.zoomMode) {
                vec3_t          origin;

                if ( cg.predictedPlayerState.eFlags & EF_FIRING ) {
                        // special hack for lightning gun...
                        VectorCopy( cg.refdef.vieworg, origin );
                        VectorMA( origin, -8, cg.refdef.viewaxis[2], origin );
                        CG_LightningBolt( &cg_entities[ps->clientNum], origin );
                }
                return;
        }

        // don't draw if testing a gun model
        if ( cg.testGun ) {
                return;
        }

        // drop gun lower at higher fov
        if ( cgFov > 90 ) {
                fovOffset = -0.2 * ( cgFov - 90 );
        } else {
                fovOffset = 0;
        }

        cent = &cg_entities[cg.predictedPlayerState.clientNum];
        CG_RegisterWeapon( ps->weapon );
        weapon = &cg_weapons[ ps->weapon ];

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

        // set up gun position
        CG_CalculateWeaponPosition( hand.origin, angles );

        VectorMA( hand.origin, cg_gun_x.value, cg.refdef.viewaxis[0], hand.origin );
        VectorMA( hand.origin, cg_gun_y.value, cg.refdef.viewaxis[1], hand.origin );
        VectorMA( hand.origin, (cg_gun_z.value+fovOffset), cg.refdef.viewaxis[2], hand.origin );

        AnglesToAxis( angles, hand.axis );

        // map torso animations to weapon animations
        if ( cg_gun_frame.integer ) {
                // development tool
                hand.frame = hand.oldframe = cg_gun_frame.integer;
                hand.backlerp = 0;
        } else {
                // get clientinfo for animation map
                if (cent->currentState.eType == ET_NPC)
                {
                        if (!cent->npcClient)
                        {
                                return;
                        }

                        ci = cent->npcClient;
                }
                else
                {
                        ci = &cgs.clientinfo[ cent->currentState.clientNum ];
                }
                hand.frame = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.frame, cent->currentState.torsoAnim );
                hand.oldframe = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.oldFrame, cent->currentState.torsoAnim );
                hand.backlerp = cent->pe.torso.backlerp;

                // Handle the fringe situation where oldframe is invalid
                if ( hand.frame == -1 )
                {
                        hand.frame = 0;
                        hand.oldframe = 0;
                        hand.backlerp = 0;
                }
                else if ( hand.oldframe == -1 )
                {
                        hand.oldframe = hand.frame;
                        hand.backlerp = 0;
                }
        }

        hand.hModel = weapon->handsModel;
        hand.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON;// | RF_MINLIGHT;

        // add everything onto the hand
        CG_AddPlayerWeapon( &hand, ps, &cg_entities[cg.predictedPlayerState.clientNum], ps->persistant[PERS_TEAM], angles, qfalse );
}

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

WEAPON SELECTION

==============================================================================
*/
#define ICON_WEAPONS    0
#define ICON_FORCE              1
#define ICON_INVENTORY  2


void CG_DrawIconBackground(void)
{
        int                             height,xAdd,x2,y2,t;
//      int                             prongLeftX,prongRightX;
        float                   inTime = cg.invenSelectTime+WEAPON_SELECT_TIME;
        float                   wpTime = cg.weaponSelectTime+WEAPON_SELECT_TIME;
        float                   fpTime = cg.forceSelectTime+WEAPON_SELECT_TIME;
//      int                             drawType = cgs.media.weaponIconBackground;
//      int                             yOffset = 0;

#ifdef _XBOX
        //yOffset = -50;
#endif

        // don't display if dead
        if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
        {
                return;
        }

        if (cg_hudFiles.integer)
        { //simple hud
                return;
        }

        x2 = 30;
        y2 = SCREEN_HEIGHT-70;

        //prongLeftX =x2+37; 
        //prongRightX =x2+544; 

        if (inTime > wpTime)
        {
//              drawType = cgs.media.inventoryIconBackground;
                cg.iconSelectTime = cg.invenSelectTime;
        }
        else
        {
//              drawType = cgs.media.weaponIconBackground;
                cg.iconSelectTime = cg.weaponSelectTime;
        }

        if (fpTime > inTime && fpTime > wpTime)
        {
//              drawType = cgs.media.forceIconBackground;
                cg.iconSelectTime = cg.forceSelectTime;
        }

        if ((cg.iconSelectTime+WEAPON_SELECT_TIME)<cg.time)     // Time is up for the HUD to display
        {
                if (cg.iconHUDActive)           // The time is up, but we still need to move the prongs back to their original position
                {
                        t =  cg.time - (cg.iconSelectTime+WEAPON_SELECT_TIME);
                        cg.iconHUDPercent = t/ 130.0f;
                        cg.iconHUDPercent = 1 - cg.iconHUDPercent;

                        if (cg.iconHUDPercent<0)
                        {
                                cg.iconHUDActive = qfalse;
                                cg.iconHUDPercent=0;
                        }

                        xAdd = (int) 8*cg.iconHUDPercent;

                        height = (int) (60.0f*cg.iconHUDPercent);
                        //CG_DrawPic( x2+60, y2+30+yOffset, 460, -height, drawType);    // Top half
                        //CG_DrawPic( x2+60, y2+30-2+yOffset, 460, height, drawType);   // Bottom half

                }
                else
                {
                        xAdd = 0;
                }

                return;
        }
        //prongLeftX =x2+37; 
        //prongRightX =x2+544; 

        if (!cg.iconHUDActive)
        {
                t = cg.time - cg.iconSelectTime;
                cg.iconHUDPercent = t/ 130.0f;

                // Calc how far into opening sequence we are
                if (cg.iconHUDPercent>1)
                {
                        cg.iconHUDActive = qtrue;
                        cg.iconHUDPercent=1;
                }
                else if (cg.iconHUDPercent<0)
                {
                        cg.iconHUDPercent=0;
                }
        }
        else
        {
                cg.iconHUDPercent=1;
        }

        //trap_R_SetColor( colorTable[CT_WHITE] );                                      
        //height = (int) (60.0f*cg.iconHUDPercent);
        //CG_DrawPic( x2+60, y2+30+yOffset, 460, -height, drawType);    // Top half
        //CG_DrawPic( x2+60, y2+30-2+yOffset, 460, height, drawType);   // Bottom half

        // And now for the prongs
/*      if ((cg.inventorySelectTime+WEAPON_SELECT_TIME)>cg.time)        
        {
                cgs.media.currentBackground = ICON_INVENTORY;
                background = &cgs.media.inventoryProngsOn;
        }
        else if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)>cg.time)      
        {
                cgs.media.currentBackground = ICON_WEAPONS;
        }
        else 
        {
                cgs.media.currentBackground = ICON_FORCE;
                background = &cgs.media.forceProngsOn;
        }
*/
        // Side Prongs
//      trap_R_SetColor( colorTable[CT_WHITE]);                                 
//      xAdd = (int) 8*cg.iconHUDPercent;
//      CG_DrawPic( prongLeftX+xAdd, y2-10, 40, 80, background);
//      CG_DrawPic( prongRightX-xAdd, y2-10, -40, 80, background);

}

qboolean CG_WeaponCheck(int weap)
{
        if (cg.snap->ps.ammo[weaponData[weap].ammoIndex] < weaponData[weap].energyPerShot &&
                cg.snap->ps.ammo[weaponData[weap].ammoIndex] < weaponData[weap].altEnergyPerShot)
        {
                return qfalse;
        }

        return qtrue;
}

/*
===============
CG_WeaponSelectable
===============
*/
static qboolean CG_WeaponSelectable( int i ) {
        /*if ( !cg.snap->ps.ammo[weaponData[i].ammoIndex] ) {
                return qfalse;
        }*/
        if (!i)
        {
                return qfalse;
        }

        if (cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < weaponData[i].energyPerShot &&
                cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < weaponData[i].altEnergyPerShot)
        {
                return qfalse;
        }

        if (i == WP_DET_PACK && cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < 1 &&
                !cg.predictedPlayerState.hasDetPackPlanted)
        {
                return qfalse;
        }

        if ( ! (cg.predictedPlayerState.stats[ STAT_WEAPONS ] & ( 1 << i ) ) ) {
                return qfalse;
        }

        return qtrue;
}

/*
===================
CG_DrawWeaponSelect
===================
*/
#ifdef _XBOX
extern bool CL_ExtendSelectTime(void);
#endif
void CG_DrawWeaponSelect( void ) {
        int                             i;
        int                             bits;
        int                             count;
        int                             smallIconSize,bigIconSize;
        int                             holdX,x,y,pad;
        int                             sideLeftIconCnt,sideRightIconCnt;
        int                             sideMax,holdCount,iconCnt;
        int                             height;
        int             yOffset = 0;
        qboolean drewConc = qfalse;

        if (cg.predictedPlayerState.emplacedIndex)
        { //can't cycle when on a weapon
                cg.weaponSelectTime = 0;
        }

        if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)<cg.time)   // Time is up for the HUD to display
        {
                return;
        }

        // don't display if dead
        if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) 
        {
                return;
        }

#ifdef _XBOX
        if(CL_ExtendSelectTime()) {
                cg.weaponSelectTime = cg.time;
        }

        yOffset = -50;
#endif

        // showing weapon select clears pickup item display, but not the blend blob
        cg.itemPickupTime = 0;

        bits = cg.predictedPlayerState.stats[ STAT_WEAPONS ];

        // count the number of weapons owned
        count = 0;

        if ( !CG_WeaponSelectable(cg.weaponSelect) &&
                (cg.weaponSelect == WP_THERMAL || cg.weaponSelect == WP_TRIP_MINE) )
        { //display this weapon that we don't actually "have" as unhighlighted until it's deselected
          //since it's selected we must increase the count to display the proper number of valid selectable weapons
                count++;
        }

        for ( i = 1 ; i < WP_NUM_WEAPONS ; i++ ) 
        {
                if ( bits & ( 1 << i ) ) 
                {
                        if ( CG_WeaponSelectable(i) ||
                                (i != WP_THERMAL && i != WP_TRIP_MINE) )
                        {
                                count++;
                        }
                }
        }

        if (count == 0) // If no weapons, don't display
        {
                return;
        }

        sideMax = 3;    // Max number of icons on the side

        // Calculate how many icons will appear to either side of the center one
        holdCount = count - 1;  // -1 for the center icon
        if (holdCount == 0)                     // No icons to either side
        {
                sideLeftIconCnt = 0;
                sideRightIconCnt = 0;
        }
        else if (count > (2*sideMax))   // Go to the max on each side
        {
                sideLeftIconCnt = sideMax;
                sideRightIconCnt = sideMax;
        }
        else                                                    // Less than max, so do the calc
        {
                sideLeftIconCnt = holdCount/2;
                sideRightIconCnt = holdCount - sideLeftIconCnt;
        }

        if ( cg.weaponSelect == WP_CONCUSSION )
        {
                i = WP_FLECHETTE;
        }
        else
        {
                i = cg.weaponSelect - 1;
        }
        if (i<1)
        {
                i = LAST_USEABLE_WEAPON;
        }

        smallIconSize = 40;
        bigIconSize = 80;
        pad = 12;

        x = 320;
        y = 410;

        // Background
//      memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
//      calcColor[3] = .35f;
//      trap_R_SetColor( calcColor);                                    

        // Left side ICONS
        trap_R_SetColor(colorTable[CT_WHITE]);
        // Work backwards from current icon
        holdX = x - ((bigIconSize/2) + pad + smallIconSize);
        height = smallIconSize * 1;//cg.iconHUDPercent;
        drewConc = qfalse;

        for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
        {
                if ( i == WP_CONCUSSION )
                {
                        i--;
                }
                else if ( i == WP_FLECHETTE && !drewConc && cg.weaponSelect != WP_CONCUSSION )
                {
                        i = WP_CONCUSSION;
                }
                if (i<1)
                {
                        //i = 13;
                        //...don't ever do this.
                        i = LAST_USEABLE_WEAPON;
                }

                if ( !(bits & ( 1 << i )))      // Does he have this weapon?
                {
                        if ( i == WP_CONCUSSION )
                        {
                                drewConc = qtrue;
                                i = WP_ROCKET_LAUNCHER;
                        }
                        continue;
                }

                if ( !CG_WeaponSelectable(i) &&
                        (i == WP_THERMAL || i == WP_TRIP_MINE) )
                { //Don't show thermal and tripmine when out of them
                        continue;
                }

                ++iconCnt;                                      // Good icon

                if (cgs.media.weaponIcons[i])
                {
                        weaponInfo_t    *weaponInfo;
                        CG_RegisterWeapon( i ); 
                        weaponInfo = &cg_weapons[i];

                        trap_R_SetColor(colorTable[CT_WHITE]);
                        if (!CG_WeaponCheck(i))
                        {
                                CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, /*weaponInfo->weaponIconNoAmmo*/cgs.media.weaponIcons_NA[i] );
                        }
                        else
                        {
                                CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, /*weaponInfo->weaponIcon*/cgs.media.weaponIcons[i] );
                        }

                        holdX -= (smallIconSize+pad);
                }
                if ( i == WP_CONCUSSION )
                {
                        drewConc = qtrue;
                        i = WP_ROCKET_LAUNCHER;
                }
        }

        // Current Center Icon
        height = bigIconSize * cg.iconHUDPercent;
        if (cgs.media.weaponIcons[cg.weaponSelect])
        {
                weaponInfo_t    *weaponInfo;
                CG_RegisterWeapon( cg.weaponSelect );   
                weaponInfo = &cg_weapons[cg.weaponSelect];

                trap_R_SetColor( colorTable[CT_WHITE]);
                if (!CG_WeaponCheck(cg.weaponSelect))
                {
                        CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, cgs.media.weaponIcons_NA[cg.weaponSelect] );
                }
                else
                {
                        CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, cgs.media.weaponIcons[cg.weaponSelect] );
                }
        }

        if ( cg.weaponSelect == WP_CONCUSSION )
        {
                i = WP_ROCKET_LAUNCHER;
        }
        else
        {
                i = cg.weaponSelect + 1;
        }
        if (i> LAST_USEABLE_WEAPON)
        {
                i = 1;
        }

        // Right side ICONS
        // Work forwards from current icon
        holdX = x + (bigIconSize/2) + pad;
        height = smallIconSize * cg.iconHUDPercent;
        for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
        {
                if ( i == WP_CONCUSSION )
                {
                        i++;
                }
                else if ( i == WP_ROCKET_LAUNCHER && !drewConc && cg.weaponSelect != WP_CONCUSSION )
                {
                        i = WP_CONCUSSION;
                }
                if (i>LAST_USEABLE_WEAPON)
                {
                        i = 1;
                }

                if ( !(bits & ( 1 << i )))      // Does he have this weapon?
                {
                        if ( i == WP_CONCUSSION )
                        {
                                drewConc = qtrue;
                                i = WP_FLECHETTE;
                        }
                        continue;
                }

                if ( !CG_WeaponSelectable(i) &&
                        (i == WP_THERMAL || i == WP_TRIP_MINE) )
                { //Don't show thermal and tripmine when out of them
                        continue;
                }

                ++iconCnt;                                      // Good icon

                if (/*weaponData[i].weaponIcon[0]*/cgs.media.weaponIcons[i])
                {
                        weaponInfo_t    *weaponInfo;
                        CG_RegisterWeapon( i ); 
                        weaponInfo = &cg_weapons[i];
                        // No ammo for this weapon?
                        trap_R_SetColor( colorTable[CT_WHITE]);
                        if (!CG_WeaponCheck(i))
                        {
                                CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, cgs.media.weaponIcons_NA[i] );
                        }
                        else
                        {
                                CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, cgs.media.weaponIcons[i] );
                        }


                        holdX += (smallIconSize+pad);
                }
                if ( i == WP_CONCUSSION )
                {
                        drewConc = qtrue;
                        i = WP_FLECHETTE;
                }
        }

        // draw the selected name
        if ( cg_weapons[ cg.weaponSelect ].item ) 
        {
                vec4_t                  textColor = { .875f, .718f, .121f, 1.0f };
                char    text[1024];
                char    upperKey[1024];

                strcpy(upperKey, cg_weapons[ cg.weaponSelect ].item->classname);