// g_weapon.c

#include "g_local.h"
#include "m_player.h"


static qboolean is_quad;
static byte             is_silenced;


void weapon_grenade_fire (edict_t *ent, qboolean held);


void P_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
{
        vec3_t  _distance;

        VectorCopy (distance, _distance);
/*        if (client->pers.hand == LEFT_HANDED)
                _distance[1] = -1;
        else if (client->pers.hand == CENTER_HANDED)
                _distance[1] = 0;
                                */
                _distance[1] = 0; // fire at the crosshair always
        G_ProjectSource (point, _distance, forward, right, result);
}

// used for setting up the positions of the guns in shell ejection
void Old_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
{
        vec3_t  _distance;

        VectorCopy (distance, _distance);
        if (client->pers.hand == LEFT_HANDED)
                _distance[1] = -1;
        else if (client->pers.hand == CENTER_HANDED)
                _distance[1] = 0;
        G_ProjectSource (point, _distance, forward, right, result);
}



/*
===============
PlayerNoise

Each player can have two noise objects associated with it:
a personal noise (jumping, pain, weapon firing), and a weapon
target noise (bullet wall impacts)

Monsters that don't directly see the player can move
to a noise in hopes of seeing the player from there.
===============
*/
void PlayerNoise(edict_t *who, vec3_t where, int type)
{
        edict_t         *noise;

        if (type == PNOISE_WEAPON)
        {
                if (who->client->silencer_shots)
                {
                        who->client->silencer_shots--;
                        return;
                }
        }

        if (deathmatch->value)
                return;

        if (who->flags & FL_NOTARGET)
                return;


        if (!who->mynoise)
        {
                noise = G_Spawn();
                noise->classname = "player_noise";
                VectorSet (noise->mins, -8, -8, -8);
                VectorSet (noise->maxs, 8, 8, 8);
                noise->owner = who;
                noise->svflags = SVF_NOCLIENT;
                who->mynoise = noise;

                noise = G_Spawn();
                noise->classname = "player_noise";
                VectorSet (noise->mins, -8, -8, -8);
                VectorSet (noise->maxs, 8, 8, 8);
                noise->owner = who;
                noise->svflags = SVF_NOCLIENT;
                who->mynoise2 = noise;
        }

        if (type == PNOISE_SELF || type == PNOISE_WEAPON)
        {
                noise = who->mynoise;
                level.sound_entity = noise;
                level.sound_entity_framenum = level.framenum;
        }
        else // type == PNOISE_IMPACT
        {
                noise = who->mynoise2;
                level.sound2_entity = noise;
                level.sound2_entity_framenum = level.framenum;
        }

        VectorCopy (where, noise->s.origin);
        VectorSubtract (where, noise->maxs, noise->absmin);
        VectorAdd (where, noise->maxs, noise->absmax);
        noise->teleport_time = level.time;
        gi.linkentity (noise);
}


void PlaceHolder( edict_t *ent )
{
        ent->nextthink = level.time + 1000;
}

// keep the entity around so we can find it later if we need to respawn the weapon there
void SetSpecWeapHolder (edict_t *ent )
{
        ent->flags |= FL_RESPAWN;
        ent->svflags |= SVF_NOCLIENT;
        ent->solid = SOLID_NOT;
        ent->think = PlaceHolder;
        gi.linkentity (ent);
}

qboolean Pickup_Weapon (edict_t *ent, edict_t *other)
{
        int                     index, index2;
        gitem_t         *ammo;
                gitem_t         *item;

        int                     special = 0;
                int band = 0;

        index = ITEM_INDEX(ent->item);

        if ( ( ((int)(dmflags->value) & DF_WEAPONS_STAY) || coop->value) 
                && other->client->pers.inventory[index])
        {
                if (!(ent->spawnflags & (DROPPED_ITEM | DROPPED_PLAYER_ITEM) ) )
                        return false;   // leave the weapon for others to pickup
        }

                // find out if they have a bandolier
                item = FindItem(BAND_NAME);
                if ( other->client->pers.inventory[ITEM_INDEX(item)] )
                        band = 1;
                else
                        band = 0;
        


        // zucc special cases for picking up weapons
        // the mk23 should never be dropped, probably
        
        if ( stricmp(ent->item->pickup_name, MK23_NAME) == 0 )
        {
                if ( other->client->pers.inventory[index] ) // already has one
                {
                        if ( !(ent->spawnflags & DROPPED_ITEM) )
                        {
                                ammo = FindItem (ent->item->ammo);
                                return ( Add_Ammo(other, ammo, ammo->quantity) );
                        }
                }
                other->client->pers.inventory[index]++;
                if ( !(ent->spawnflags & DROPPED_ITEM) )
                        other->client->mk23_rds = other->client->mk23_max;
        }
        else if ( stricmp(ent->item->pickup_name, MP5_NAME) == 0 )
        {
                        if ( other->client->unique_weapon_total < unique_weapons->value + band ) 
                        {
                                other->client->pers.inventory[index]++;
                                other->client->unique_weapon_total++;
                                if ( !(ent->spawnflags & DROPPED_ITEM) )
                                        other->client->mp5_rds = other->client->mp5_max;
                                special = 1;
                                gi.cprintf(other, PRINT_HIGH, "%s - Unique Weapon\n", ent->item->pickup_name);
                        }
                        else
                                return false; // we can't get it        
        }
        else if ( stricmp(ent->item->pickup_name, M4_NAME) == 0 )
        {
                if ( other->client->unique_weapon_total < unique_weapons->value + band ) 
                {
                        other->client->pers.inventory[index]++;
                        other->client->unique_weapon_total++;
                        if ( !(ent->spawnflags & DROPPED_ITEM) )
                                other->client->m4_rds = other->client->m4_max;  
                        special = 1;
                                                gi.cprintf(other, PRINT_HIGH, "%s - Unique Weapon\n", ent->item->pickup_name);
                }
                else
                        return false; // we can't get it        
                
        }
        else if ( stricmp(ent->item->pickup_name, M3_NAME) == 0 )
        {
                if ( other->client->unique_weapon_total < unique_weapons->value + band ) 
                {
                        other->client->pers.inventory[index]++;                 
                        other->client->unique_weapon_total++;
                        if ( !(ent->spawnflags & DROPPED_ITEM) )
                                                {
                                                        // any weapon that doesn't completely fill up each reload can 
                                                        //end up in a state where it has a full weapon and pending reload(s)
                                                        if ( other->client->weaponstate == WEAPON_RELOADING ) 
                                                        {
                                                                if ( other->client->fast_reload )
                                                                {
                                                                        other->client->shot_rds = other->client->shot_max - 2;
                                                                }
                                                                else
                                                                        other->client->shot_rds = other->client->shot_max - 1;
                                                        }
                                                        else
                                                        {
                                other->client->shot_rds = other->client->shot_max;      
                                                        }
                                                }
                        special = 1;
                                                gi.cprintf(other, PRINT_HIGH, "%s - Unique Weapon\n", ent->item->pickup_name);
                }
                else
                        return false; // we can't get it        
                
        }
        else if ( stricmp(ent->item->pickup_name, HC_NAME) == 0 )
        {
                        if ( other->client->unique_weapon_total < unique_weapons->value + band ) 
                        {
                                other->client->pers.inventory[index]++;
                                other->client->unique_weapon_total++;
                                if ( !(ent->spawnflags & DROPPED_ITEM) )
                                {
                                        other->client->cannon_rds = other->client->cannon_max;  
                                        index2 = ITEM_INDEX(FindItem(ent->item->ammo));
                                        if ( other->client->pers.inventory[index2] + 5 > other->client->pers.max_shells )
                                                other->client->pers.inventory[index2] = other->client->pers.max_shells;
                                        else
                                                other->client->pers.inventory[index2] += 5;
                                        
                                }
                                gi.cprintf(other, PRINT_HIGH, "%s - Unique Weapon\n", ent->item->pickup_name);
                                special = 1;
                        }
                        else
                                return false; // we can't get it        
                        
        }
        else if ( stricmp(ent->item->pickup_name, SNIPER_NAME) == 0 )
        {
                if ( other->client->unique_weapon_total < unique_weapons->value + band ) 
                {
                        other->client->pers.inventory[index]++;
                        other->client->unique_weapon_total++;
                        if ( !(ent->spawnflags & DROPPED_ITEM) )
                                                {
                                                        if ( other->client->weaponstate == WEAPON_RELOADING ) 
                                                        {
                                                                if ( other->client->fast_reload )
                                                                {
                                                                        other->client->sniper_rds = other->client->sniper_max - 2;
                                                                }
                                                                else
                                                                        other->client->sniper_rds = other->client->sniper_max - 1;
                                                        }
                                                        else
                                                        {
                                other->client->sniper_rds = other->client->sniper_max;      
                                                        } 
                                                }         
                        special = 1;
                                                gi.cprintf(other, PRINT_HIGH, "%s - Unique Weapon\n", ent->item->pickup_name);
                }
                else
                        return false; // we can't get it        
                
        }
        else if ( stricmp(ent->item->pickup_name, DUAL_NAME) == 0 )
        {
                
                if ( other->client->pers.inventory[index] ) // already has one
                {
                        if ( !(ent->spawnflags & DROPPED_ITEM) )
                        {
                                ammo = FindItem (ent->item->ammo);
                                return (Add_Ammo(other, ammo, ammo->quantity) );
                        }
                }
                other->client->pers.inventory[index]++;
                if ( !(ent->spawnflags & DROPPED_ITEM) )
                {
                        other->client->dual_rds += other->client->mk23_max;
                        // assume the player uses the new (full) pistol
                        other->client->mk23_rds = other->client->mk23_max; 
                }
        }
        else if ( stricmp(ent->item->pickup_name, KNIFE_NAME) == 0 )
        {
                
                if ( other->client->pers.inventory[index] < other->client->knife_max )
                {
                        other->client->pers.inventory[index]++;
                        return true;
                }
                else
                {
                        return false;
                }
        }
        else if ( stricmp(ent->item->pickup_name, GRENADE_NAME) == 0 )
        {
                
                if ( other->client->pers.inventory[index] < other->client->grenade_max )
                {
                        other->client->pers.inventory[index]++;
                        if (! (ent->spawnflags & DROPPED_PLAYER_ITEM) )
                        {
                                if (deathmatch->value)
                                {
                                        if ((int)(dmflags->value) & DF_WEAPONS_STAY)
                                                ent->flags |= FL_RESPAWN;
                                        else
                                                SetRespawn (ent, 30);
                                }
                                if (coop->value)
                                        ent->flags |= FL_RESPAWN;
                        }

                        return true;
                }
                else
                {
                        return false;
                }
        }
        else 
        {
                
                other->client->pers.inventory[index]++;
                
                
                if (!(ent->spawnflags & DROPPED_ITEM) )
                {
                        // give them some ammo with it
                        ammo = FindItem (ent->item->ammo);              
                        
                        if ( (int)dmflags->value & DF_INFINITE_AMMO )
                                Add_Ammo (other, ammo, 1000);
                        else
                                Add_Ammo (other, ammo, ammo->quantity);
                        
                        if (! (ent->spawnflags & DROPPED_PLAYER_ITEM) )
                        {
                                if (deathmatch->value)
                                {
                                        if ((int)(dmflags->value) & DF_WEAPONS_STAY)
                                                ent->flags |= FL_RESPAWN;
                                        else
                                                SetRespawn (ent, 30);
                                }
                                if (coop->value)
                                        ent->flags |= FL_RESPAWN;
                        }
                }
        }
/* zucc - don't want auto switching
        if (other->client->pers.weapon != ent->item && 
                (other->client->pers.inventory[index] == 1) &&
                ( !deathmatch->value || other->client->pers.weapon == FindItem("blaster") ) )
                other->client->newweapon = ent->item;
*/
        if ( !(ent->spawnflags & DROPPED_ITEM) 
                && !(ent->spawnflags & DROPPED_PLAYER_ITEM)
                && (SPEC_WEAPON_RESPAWN) )
        {
                SetSpecWeapHolder( ent );
        }


        return true;
}


// zucc vwep 3.17(?) vwep support
void ShowGun(edict_t *ent)
{
        
        int nIndex;
        char *pszIcon;
        
        // No weapon?
        if ( !ent->client->pers.weapon)
        {
                ent->s.modelindex2 = 0;
                return;
        }
        
        // Determine the weapon's precache index.
        
        nIndex = 0;
        pszIcon = ent->client->pers.weapon->icon;
        
        if ( strcmp( pszIcon, "w_mk23") == 0)
                nIndex = 1;
        else if ( strcmp( pszIcon, "w_mp5") == 0)
                nIndex = 2;
        else if ( strcmp( pszIcon, "w_m4") == 0)
                nIndex = 3;
        else if ( strcmp( pszIcon, "w_cannon") == 0)
                nIndex = 4;
        else if ( strcmp( pszIcon, "w_super90") == 0)
                nIndex = 5;
        else if ( strcmp( pszIcon, "w_sniper") == 0)
                nIndex = 6;
        else if ( strcmp( pszIcon, "w_akimbo") == 0)
                nIndex = 7;
        else if ( strcmp( pszIcon, "w_knife") == 0)
                nIndex = 8;
        else if ( strcmp( pszIcon, "a_m61frag") == 0)
                nIndex = 9;
        
        // Clear previous weapon model.
        ent->s.skinnum &= 255;
        
        // Set new weapon model.
        ent->s.skinnum |= (nIndex << 8);
        ent->s.modelindex2 = 255;
        /*
        char heldmodel[128];
        int len;

        if(!ent->client->pers.weapon)
        {
                ent->s.modelindex2 = 0;
                return;
        }

        strcpy(heldmodel, "players/");
        strcat(heldmodel, Info_ValueForKey (ent->client->pers.userinfo, "skin"));
        for(len = 8; heldmodel[len]; len++)
        {
                if(heldmodel[len] == '/')
                        heldmodel[++len] = '\0';
        }
        strcat(heldmodel, ent->client->pers.weapon->icon);      
        strcat(heldmodel, ".md2");
        //gi.dprintf ("%s\n", heldmodel);
        ent->s.modelindex2 = gi.modelindex(heldmodel);  
*/
}









//#define GRENADE_IDLE_FIRST 40
//#define GRENADE_IDLE_LAST 69


/*
===============
ChangeWeapon

The old weapon has been dropped all the way, so make the new one
current
===============
*/
void ChangeWeapon (edict_t *ent)
{
        gitem_t *item;
        if (ent->client->grenade_time)
        {
                ent->client->grenade_time = level.time;
                ent->client->weapon_sound = 0;
                weapon_grenade_fire (ent, false);
                ent->client->grenade_time = 0;
        }

        ent->client->pers.lastweapon = ent->client->pers.weapon;
        ent->client->pers.weapon = ent->client->newweapon;
        ent->client->newweapon = NULL;
        ent->client->machinegun_shots = 0;

        if (ent->client->pers.weapon && ent->client->pers.weapon->ammo)
                ent->client->ammo_index = ITEM_INDEX(FindItem(ent->client->pers.weapon->ammo));
        else
                ent->client->ammo_index = 0;

        if (!ent->client->pers.weapon || ent->s.modelindex != 255) // zucc vwep
        {       // dead 
                ent->client->ps.gunindex = 0;
                return;
        }

        ent->client->weaponstate = WEAPON_ACTIVATING;
        ent->client->ps.gunframe = 0;
        
//FIREBLADE
        if (ent->solid == SOLID_NOT && ent->deadflag != DEAD_DEAD)
                return;
//FIREBLADE

        ent->client->ps.gunindex = gi.modelindex(ent->client->pers.weapon->view_model);
        
        // zucc hentai's animation for vwep
        ent->client->anim_priority = ANIM_PAIN;
        if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
        {
                        ent->s.frame = FRAME_crpain1;
                        ent->client->anim_end = FRAME_crpain4;
        }
        else
        {
                        ent->s.frame = FRAME_pain301;
                        ent->client->anim_end = FRAME_pain304;
                        
        }
        
        ShowGun(ent);   
        // zucc done
        
        
        
        
        if(stricmp(ent->client->pers.weapon->pickup_name, MK23_NAME) == 0)
        {
                ent->client->curr_weap = MK23_NUM;
        }
        else if(stricmp(ent->client->pers.weapon->pickup_name, MP5_NAME) == 0)
        {
                ent->client->curr_weap = MP5_NUM;
        }
        else if(stricmp(ent->client->pers.weapon->pickup_name, M4_NAME) == 0)
        {
                ent->client->curr_weap = M4_NUM;
        }
        else if(stricmp(ent->client->pers.weapon->pickup_name, M3_NAME) == 0)
        {
                ent->client->curr_weap = M3_NUM;
        }
        else if(stricmp(ent->client->pers.weapon->pickup_name, HC_NAME) == 0)
        {
                ent->client->curr_weap = HC_NUM;
        }

        else if(stricmp(ent->client->pers.weapon->pickup_name, SNIPER_NAME) == 0)
        {
                ent->client->curr_weap = SNIPER_NUM;
        }
        else if(stricmp(ent->client->pers.weapon->pickup_name, DUAL_NAME) == 0)
        {
                ent->client->curr_weap = DUAL_NUM;
        }
        else if(stricmp(ent->client->pers.weapon->pickup_name, KNIFE_NAME) == 0)
        {
                ent->client->curr_weap = KNIFE_NUM;
        }
        else if(stricmp(ent->client->pers.weapon->pickup_name, GRENADE_NAME) == 0)
        {
                ent->client->curr_weap = GRENADE_NUM;
        }

        item = FindItem(LASER_NAME);
        if ( ent->client->pers.inventory[ITEM_INDEX(item)] )
                        SP_LaserSight(ent, item);//item->use(ent, item);
}

/*
=================
NoAmmoWeaponChange
=================
*/
void NoAmmoWeaponChange (edict_t *ent)
{
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("slugs"))]
                &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("railgun"))] )
        {
                ent->client->newweapon = FindItem ("railgun");
                return;
        }
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("cells"))]
                &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("hyperblaster"))] )
        {
                ent->client->newweapon = FindItem ("hyperblaster");
                return;
        }
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("bullets"))]
                &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("chaingun"))] )
        {
                ent->client->newweapon = FindItem ("chaingun");
                return;
        }
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("bullets"))]
                &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("machinegun"))] )
        {
                ent->client->newweapon = FindItem ("machinegun");
                return;
        }
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("shells"))] > 1
                &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("super shotgun"))] )
        {
                ent->client->newweapon = FindItem ("super shotgun");
                return;
        }
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("shells"))]
                &&  ent->client->pers.inventory[ITEM_INDEX(FindItem("shotgun"))] )
        {
                ent->client->newweapon = FindItem ("shotgun");
                return;
        }
        ent->client->newweapon = FindItem ("blaster");
}

/*
=================
Think_Weapon

Called by ClientBeginServerFrame and ClientThink
=================
*/
void Think_Weapon (edict_t *ent)
{
        // if just died, put the weapon away
        if (ent->health < 1)
        {
                ent->client->newweapon = NULL;
                ChangeWeapon (ent);
        }

        // call active weapon think routine
        if (ent->client->pers.weapon && ent->client->pers.weapon->weaponthink)
        {
                is_quad = (ent->client->quad_framenum > level.framenum);
                if (ent->client->silencer_shots)
                        is_silenced = MZ_SILENCED;
                else
                        is_silenced = 0;
                ent->client->pers.weapon->weaponthink (ent);
        }
}


/*
================
Use_Weapon

Make the weapon ready if there is ammo
================
*/
void Use_Weapon (edict_t *ent, gitem_t *item)
{
        //int                   ammo_index;
        //gitem_t               *ammo_item;


        if(ent->client->weaponstate == WEAPON_BANDAGING || ent->client->bandaging == 1 )
                        return;
        
        
        
        
                // see if we're already using it
        if (item == ent->client->pers.weapon)
                return;

        // zucc - let them change if they want
                /*if (item->ammo && !g_select_empty->value && !(item->flags & IT_AMMO))
        {
                ammo_item = FindItem(item->ammo);
                ammo_index = ITEM_INDEX(ammo_item);

                if (!ent->client->pers.inventory[ammo_index])
                {
                        gi.cprintf (ent, PRINT_HIGH, "No %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
                        return;
                }

                if (ent->client->pers.inventory[ammo_index] < item->quantity)
                {
                        gi.cprintf (ent, PRINT_HIGH, "Not enough %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
                        return;
                }
        }*/

        // change to this weapon when down
        ent->client->newweapon = item;
}




edict_t *FindSpecWeapSpawn( edict_t* ent )
{
        edict_t *spot = NULL;
        
                //gi.bprintf (PRINT_HIGH, "Calling the FindSpecWeapSpawn\n");
                spot = G_Find (spot, FOFS(classname), ent->classname);
                //gi.bprintf (PRINT_HIGH, "spot = %p and spot->think = %p and playerholder = %p, spot, (spot ? spot->think : 0), PlaceHolder\n");
        while ( spot && spot->think != PlaceHolder )//(spot->spawnflags & DROPPED_ITEM ) && spot->think != PlaceHolder )//spot->solid == SOLID_NOT )        
        {
                //              gi.bprintf (PRINT_HIGH, "Calling inside the loop FindSpecWeapSpawn\n");
                spot = G_Find (spot, FOFS(classname), ent->classname);
        }
/*      if (!spot)
        {
                gi.bprintf(PRINT_HIGH, "Failed to find a spawn spot for %s\n", ent->classname);
        }
        else
                gi.bprintf(PRINT_HIGH, "Found a spawn spot for %s\n", ent->classname);
*/
        return spot;
}

void ThinkSpecWeap( edict_t* ent );


static void SpawnSpecWeap(gitem_t *item, edict_t *spot)
{
/*        edict_t *ent;
        vec3_t  forward, right;
        vec3_t  angles;

        ent = G_Spawn();

        ent->classname = item->classname;
        ent->item = item;
        ent->spawnflags = DROPPED_PLAYER_ITEM;//DROPPED_ITEM;
        ent->s.effects = item->world_model_flags;
        ent->s.renderfx = RF_GLOW;
        VectorSet (ent->mins, -15, -15, -15);
        VectorSet (ent->maxs, 15, 15, 15);
        gi.setmodel (ent, ent->item->world_model);
        ent->solid = SOLID_TRIGGER;
        ent->movetype = MOVETYPE_TOSS;  
        ent->touch = Touch_Item;
        ent->owner = ent;

        angles[0] = 0;
        angles[1] = rand() % 360;
        angles[2] = 0;

        AngleVectors (angles, forward, right, NULL);
        VectorCopy (spot->s.origin, ent->s.origin);
        ent->s.origin[2] += 16;
        VectorScale (forward, 100, ent->velocity);
        ent->velocity[2] = 300;

        ent->think = NULL;

        gi.linkentity (ent);
                */
                SetRespawn(spot, 1);
                gi.linkentity(spot);
}

void temp_think_specweap( edict_t* ent )
{
        ent->touch = Touch_Item;
        if (deathmatch->value && !teamplay->value && !allweapon->value )
        {
                ent->nextthink = level.time + 74;
                ent->think = ThinkSpecWeap;
        }
                else if ( teamplay->value && !allweapon->value)
                {
                        ent->nextthink = level.time + 1000;
                        ent->think = PlaceHolder;
                }
                else // allweapon set
                {
                        ent->nextthink = level.time + 1;
                        ent->think = G_FreeEdict;
                }
}



// zucc make dropped weapons respawn elsewhere
void ThinkSpecWeap( edict_t* ent )
{
        edict_t *spot;

        if ((spot = FindSpecWeapSpawn(ent)) != NULL) {
                SpawnSpecWeap(ent->item, spot);         
                G_FreeEdict(ent);
        } else {
                ent->nextthink = level.time + 1;
                ent->think = G_FreeEdict;
        }
}





/*
================
Drop_Weapon
================
*/
void Drop_Weapon (edict_t *ent, gitem_t *item)
{
        int             index;
        gitem_t *replacement;
        edict_t *temp = NULL;
        
        if ((int)(dmflags->value) & DF_WEAPONS_STAY)
                return;

        
        if ( ent->client->weaponstate == WEAPON_BANDAGING ||
                ent->client->bandaging == 1 || ent->client->bandage_stopped == 1 )
        {
                gi.cprintf(ent, PRINT_HIGH, "You are too busy bandaging right now...\n");
                return;
        }
                // don't let them drop this, causes duplication
                if ( ent->client->newweapon == item )
                {
                        return;
                }


        index = ITEM_INDEX(item);
        // see if we're already using it
        //zucc special cases for dropping       
        if ( stricmp(item->pickup_name, MK23_NAME) == 0 )
        {
                gi.cprintf(ent, PRINT_HIGH, "Can't drop the %s.\n", MK23_NAME);
                return;
        }
        else if ( stricmp(item->pickup_name, MP5_NAME) == 0 && (ent->client->pers.inventory[index] == 1))
        {
                
                if ( ent->client->pers.weapon == item  )
                {
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = 51;
                        
                        //ChangeWeapon( ent );
                }
                ent->client->unique_weapon_total--; // dropping 1 unique weapon
                temp = Drop_Item (ent, item);
                temp->think = temp_think_specweap;
                ent->client->pers.inventory[index]--;
        }
        else if ( stricmp(item->pickup_name, M4_NAME) == 0 && (ent->client->pers.inventory[index] == 1))
        {
                   
                        
                        if ( ent->client->pers.weapon == item  )
                {
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = 44;
                        
                        //ChangeWeapon( ent );
                }
                ent->client->unique_weapon_total--; // dropping 1 unique weapon
                temp = Drop_Item (ent, item);
                temp->think = temp_think_specweap;
                ent->client->pers.inventory[index]--;
        }
        else if ( stricmp(item->pickup_name, M3_NAME) == 0 && (ent->client->pers.inventory[index] == 1))
        {
                
                        if ( ent->client->pers.weapon == item  )
                {
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = 41;
                        //ChangeWeapon( ent );
                }
                ent->client->unique_weapon_total--; // dropping 1 unique weapon
                temp = Drop_Item (ent, item);
                temp->think = temp_think_specweap;
                ent->client->pers.inventory[index]--;
        }
        else if ( stricmp(item->pickup_name, HC_NAME) == 0 && (ent->client->pers.inventory[index] == 1))
        {
                    if ( ent->client->pers.weapon == item )
                {
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = 61;
                        //ChangeWeapon( ent );
                }
                ent->client->unique_weapon_total--; // dropping 1 unique weapon
                temp = Drop_Item (ent, item);
                temp->think = temp_think_specweap;
                ent->client->pers.inventory[index]--;
        }
        else if ( stricmp(item->pickup_name, SNIPER_NAME) == 0 )
        {
                if ( ent->client->pers.weapon == item && (ent->client->pers.inventory[index] == 1) )
                {
                        // in case they are zoomed in
                        ent->client->ps.fov = 90;
                        ent->client->desired_fov = 90;
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = 50;
                        //ChangeWeapon( ent );
                }
                ent->client->unique_weapon_total--; // dropping 1 unique weapon
                temp = Drop_Item (ent, item);
                temp->think = temp_think_specweap;
                ent->client->pers.inventory[index]--;
        }
        else if ( stricmp(item->pickup_name, DUAL_NAME) == 0 )
        {
                    if ( ent->client->pers.weapon == item )
                {
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = 40;
                        //ChangeWeapon( ent );
                }
                ent->client->dual_rds = ent->client->mk23_rds;
        }
        else if ( stricmp(item->pickup_name, KNIFE_NAME) == 0 )
        {
                //gi.cprintf(ent, PRINT_HIGH, "Before checking knife inven frames = %d\n", ent->client->ps.gunframe);
                    
                        if ( ((ent->client->pers.weapon == item) ) && (ent->client->pers.inventory[index] == 1) )
                {
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        if ( ent->client->resp.knife_mode ) // hack to avoid an error
                        {
                                ent->client->weaponstate = WEAPON_DROPPING;
                                ent->client->ps.gunframe = 111;
                        }
                        else
                                ChangeWeapon( ent );
                        //      gi.cprintf(ent, PRINT_HIGH, "After change weap from knife drop frames = %d\n", ent->client->ps.gunframe);
                }
        }
        else if ( stricmp(item->pickup_name, GRENADE_NAME) == 0 )
        {
                    if ( (ent->client->pers.weapon == item  ) && (ent->client->pers.inventory[index] == 1) )
                {
                        replacement = FindItem (MK23_NAME); // back to the pistol then
                        ent->client->newweapon = replacement;
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = 0;
                        //ChangeWeapon( ent );
                }
        }
        
        
        else if ( ((item == ent->client->pers.weapon) || (item == ent->client->newweapon))&& (ent->client->pers.inventory[index] == 1) )
        {
                gi.cprintf (ent, PRINT_HIGH, "Can't drop current weapon\n");
                return;
        }
        
        if ( !temp )    
        {
                temp = Drop_Item (ent, item);
                ent->client->pers.inventory[index]--;
        }

}





//zucc drop special weapon (only 1 of them)
void DropSpecialWeapon ( edict_t* ent )
{

        // first check if their current weapon is a special weapon, if so, drop it.
        if ( (ent->client->pers.weapon == FindItem(MP5_NAME))
                || (ent->client->pers.weapon == FindItem(M4_NAME))
                || (ent->client->pers.weapon == FindItem(M3_NAME))
                || (ent->client->pers.weapon == FindItem(HC_NAME))
                || (ent->client->pers.weapon == FindItem(SNIPER_NAME)) )
                Drop_Weapon (ent, ent->client->pers.weapon);
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(SNIPER_NAME))] > 0 )
                Drop_Weapon (ent, FindItem(SNIPER_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(HC_NAME))] > 0 )
                Drop_Weapon (ent, FindItem(HC_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(M3_NAME))] > 0 )
                Drop_Weapon (ent, FindItem(M3_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(MP5_NAME))] > 0 )
                Drop_Weapon (ent, FindItem(MP5_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(M4_NAME))] > 0 )
                Drop_Weapon (ent, FindItem(M4_NAME));
        // special case, aq does this, guess I can support it
        else if (ent->client->pers.weapon == FindItem(DUAL_NAME))
                ent->client->newweapon = FindItem(MK23_NAME);
        
}

// used for when we want to force a player to drop an extra special weapon
// for when they drop the bandolier and they are over the weapon limit
void DropExtraSpecial( edict_t* ent )
{
        gitem_t *item;
    
        if ( (ent->client->pers.weapon == FindItem(MP5_NAME))
                || (ent->client->pers.weapon == FindItem(M4_NAME))
                || (ent->client->pers.weapon == FindItem(M3_NAME))
                || (ent->client->pers.weapon == FindItem(HC_NAME))
                || (ent->client->pers.weapon == FindItem(SNIPER_NAME)) )
        {
                item = ent->client->pers.weapon;
                // if they have more than 1 then they are willing to drop one           
                if ( ent->client->pers.inventory[ITEM_INDEX(item)] > 1 )
                {
                        Drop_Weapon(ent, ent->client->pers.weapon );
                        return;
                }
        }
        // otherwise drop some weapon they aren't using
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(SNIPER_NAME))] > 0 
                && FindItem(SNIPER_NAME) != ent->client->pers.weapon )
                Drop_Weapon (ent, FindItem(SNIPER_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(HC_NAME))] > 0 
                && FindItem(HC_NAME) != ent->client->pers.weapon )
                Drop_Weapon (ent, FindItem(HC_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(M3_NAME))] > 0 
                && FindItem(M3_NAME) != ent->client->pers.weapon )
                Drop_Weapon (ent, FindItem(M3_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(MP5_NAME))] > 0 
                && FindItem(MP5_NAME) != ent->client->pers.weapon )
                Drop_Weapon (ent, FindItem(MP5_NAME));
        else if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(M4_NAME))] > 0 
                && FindItem(M4_NAME) != ent->client->pers.weapon )
                Drop_Weapon (ent, FindItem(M4_NAME));
        else
                gi.dprintf("Couldn't find the appropriate weapon to drop.\n");
        

}

//zucc ready special weapon
void ReadySpecialWeapon ( edict_t* ent )
{
        int weapons[5] = {MP5_NUM, M4_NUM, M3_NUM, HC_NUM, SNIPER_NUM};
        char *strings[5] = {MP5_NAME, M4_NAME, M3_NAME, HC_NAME, SNIPER_NAME};
        int curr, i;
        int last;
        
        
        if(ent->client->weaponstate == WEAPON_BANDAGING || ent->client->bandaging == 1 )
                return;
        
        
        for ( curr = 0; curr < 5; curr++ )
        {
                if ( ent->client->curr_weap == weapons[curr] )
                        break;
        }
        if ( curr >= 5 )
        {
                curr = -1;
                last = 5;
        }
        else
        {
                last = curr + 5;
        }
        
        for ( i = (curr + 1); i != last; i = (i + 1))
        {
                if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(strings[i % 5]))] )        
                {
                        ent->client->newweapon = FindItem(strings[i % 5]);
                        return;
                }
        }
        
        
}

/*
================
Weapon_Generic

A generic function to handle the basics of weapon thinking
================
*/

//zucc - copied in BD's code, modified for use with other weapons

#define FRAME_FIRE_FIRST                (FRAME_ACTIVATE_LAST + 1)
#define FRAME_IDLE_FIRST                (FRAME_FIRE_LAST + 1)
#define FRAME_DEACTIVATE_FIRST  (FRAME_IDLE_LAST + 1)

#define FRAME_RELOAD_FIRST              (FRAME_DEACTIVATE_LAST +1)
#define FRAME_LASTRD_FIRST   (FRAME_RELOAD_LAST +1)

#define MK23MAG 12
#define MP5MAG  30
#define M4MAG   24
#define DUALMAG 24

void Weapon_Generic (edict_t *ent, int FRAME_ACTIVATE_LAST, int FRAME_FIRE_LAST, 
                                         int FRAME_IDLE_LAST, int FRAME_DEACTIVATE_LAST, 
                                         int FRAME_RELOAD_LAST, int FRAME_LASTRD_LAST,
                                         int *pause_frames, int *fire_frames, void (*fire)(edict_t *ent))
{
        int             n;
        int                     bFire = 0;
        int                     bOut = 0;
/*        int                     bBursting = 0;*/


        // zucc vwep
        if(ent->s.modelindex != 255)  
                return; // not on client, so VWep animations could do wacky things

//FIREBLADE
        if (ent->client->weaponstate == WEAPON_FIRING &&
                ((ent->solid == SOLID_NOT && ent->deadflag != DEAD_DEAD) || 
                 lights_camera_action))
        {
                ent->client->weaponstate = WEAPON_READY;
        }
//FIREBLADE
        
        //+BD - Added Reloading weapon, done manually via a cmd
        if( ent->client->weaponstate == WEAPON_RELOADING)
        {
                if(ent->client->ps.gunframe < FRAME_RELOAD_FIRST || ent->client->ps.gunframe > FRAME_RELOAD_LAST)
                        ent->client->ps.gunframe = FRAME_RELOAD_FIRST;
                else if(ent->client->ps.gunframe < FRAME_RELOAD_LAST)
                {
                        ent->client->ps.gunframe++;             
                        switch ( ent->client->curr_weap )
                        {
                                //+BD - Check weapon to find out when to play reload sounds
                        case MK23_NUM:
                                {
                                        if(ent->client->ps.gunframe == 46)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23out.wav"), 1, ATTN_NORM, 0);
                                        else if(ent->client->ps.gunframe == 53)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23in.wav"), 1, ATTN_NORM, 0);                               
                                        else if(ent->client->ps.gunframe == 59) // 3
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23slap.wav"), 1, ATTN_NORM, 0);
                                        break;
                                }
                        case MP5_NUM:
                                {
                                        if(ent->client->ps.gunframe == 55)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mp5out.wav"), 1, ATTN_NORM, 0);
                                        else if(ent->client->ps.gunframe == 59)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mp5in.wav"), 1, ATTN_NORM, 0);                               
                                        else if(ent->client->ps.gunframe == 63) //61
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mp5slap.wav"), 1, ATTN_NORM, 0);                               
                                        break;
                                }
                        case M4_NUM:
                                {
                                        if(ent->client->ps.gunframe == 52)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/m4a1out.wav"), 1, ATTN_NORM, 0);
                                        else if(ent->client->ps.gunframe == 58)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/m4a1in.wav"), 1, ATTN_NORM, 0);                               
                                        break;
                                }
                        case M3_NUM:
                                {
                                                                        if ( ent->client->shot_rds >= ent->client->shot_max)
                                                                        {
                                                                                ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                                                                                ent->client->weaponstate = WEAPON_READY;
                                                                                return;
                                                                        }
                                                                        
                                                                        if(ent->client->ps.gunframe == 48)
                                                                        {
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/m3in.wav"), 1, ATTN_NORM, 0); 
                                        }
                                        if(ent->client->ps.gunframe == 49 )
                                        {
                                                if ( ent->client->fast_reload == 1 )
                                                {
                                                        ent->client->fast_reload = 0;
                                                        ent->client->shot_rds++;
                                                        ent->client->ps.gunframe = 44;
                                                }
                                        }
                                        break;
                                }
                        case HC_NUM:
                                {
                                        if(ent->client->ps.gunframe == 64)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/copen.wav"), 1, ATTN_NORM, 0);
                                        else if(ent->client->ps.gunframe == 67)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/cout.wav"), 1, ATTN_NORM, 0);                               
                                        else if(ent->client->ps.gunframe == 76) //61
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/cin.wav"), 1, ATTN_NORM, 0);                               
                                        else if (ent->client->ps.gunframe == 80) // 3
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/cclose.wav"), 1, ATTN_NORM, 0);
                                        break;
                                }
                        case SNIPER_NUM:
                                {
                                    
                                                                        if ( ent->client->sniper_rds >= ent->client->sniper_max)
                                                                        {
                                                                                ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                                                                                ent->client->weaponstate = WEAPON_READY;
                                                                                return;
                                                                        }
                                                                        
                                                                        if(ent->client->ps.gunframe == 59)
                                        {
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/ssgbolt.wav"), 1, ATTN_NORM, 0);      
                                        }
                                        else if(ent->client->ps.gunframe == 71)
                                        {
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/ssgin.wav"), 1, ATTN_NORM, 0);        
                                        }
                                        else if(ent->client->ps.gunframe == 73 )
                                        {
                                                if ( ent->client->fast_reload == 1 )
                                                {
                                                        ent->client->fast_reload = 0;
                                                        ent->client->sniper_rds++;
                                                        ent->client->ps.gunframe = 67;
                                                }
                                        }
                                        else if(ent->client->ps.gunframe == 76)
                                        {
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/ssgbolt.wav"), 1, ATTN_NORM, 0);      
                                        }
                                        break;
                                }
                        case DUAL_NUM:
                                {
                                        if(ent->client->ps.gunframe == 45)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23out.wav"), 1, ATTN_NORM, 0);
                                        else if(ent->client->ps.gunframe == 53)
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23slap.wav"), 1, ATTN_NORM, 0);                               
                                        else if(ent->client->ps.gunframe == 60) // 3
                                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23slap.wav"), 1, ATTN_NORM, 0);
                                        break;
                                }
                        default:
                                gi.dprintf("No weapon choice for reloading (sounds).\n");
                                break;
                                
                        }               
                }
                else
                {
                        ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                        ent->client->weaponstate = WEAPON_READY;
                        switch ( ent->client->curr_weap )
                        {
                        case MK23_NUM:
                                {
                                        ent->client->dual_rds -= ent->client->mk23_rds;
                                        ent->client->mk23_rds = ent->client->mk23_max;
                                        ent->client->dual_rds += ent->client->mk23_max;
                                        (ent->client->pers.inventory[ent->client->ammo_index])--;
                                        if ( ent->client->pers.inventory[ent->client->ammo_index] < 0) 
                                        {
                                                ent->client->pers.inventory[ent->client->ammo_index] = 0;
                                        }
                                        ent->client->fired = 0; // reset any firing delays
                                        break;
                                        //else
                                        //      ent->client->mk23_rds = ent->client->pers.inventory[ent->client->ammo_index];
                                }
                        case MP5_NUM:
                                {
                                        
                                        ent->client->mp5_rds = ent->client->mp5_max;
                                        (ent->client->pers.inventory[ent->client->ammo_index])--;
                                        if ( ent->client->pers.inventory[ent->client->ammo_index] < 0) 
                                        {
                                                ent->client->pers.inventory[ent->client->ammo_index] = 0;
                                        }
                                        ent->client->fired = 0; // reset any firing delays
                                        ent->client->burst = 0; // reset any bursting
                                        break;
                                }
                        case M4_NUM:
                                {
                                        
                                        ent->client->m4_rds = ent->client->m4_max;
                                        (ent->client->pers.inventory[ent->client->ammo_index])--;
                                        if ( ent->client->pers.inventory[ent->client->ammo_index] < 0) 
                                        {
                                                ent->client->pers.inventory[ent->client->ammo_index] = 0;
                                        }
                                        ent->client->fired = 0; // reset any firing delays
                                        ent->client->burst = 0; // reset any bursting                           
                                        ent->client->machinegun_shots = 0;
                                        break;
                                }
                        case M3_NUM:
                                {
                                        ent->client->shot_rds++;
                                        (ent->client->pers.inventory[ent->client->ammo_index])--;
                                        if ( ent->client->pers.inventory[ent->client->ammo_index] < 0) 
                                        {
                                                ent->client->pers.inventory[ent->client->ammo_index] = 0;
                                        }       
                                        break;
                                }
                        case HC_NUM:
                                {
                                        ent->client->cannon_rds = ent->client->cannon_max;
                                        (ent->client->pers.inventory[ent->client->ammo_index]) -= 2;
                                        if ( ent->client->pers.inventory[ent->client->ammo_index] < 0) 
                                        {
                                                ent->client->pers.inventory[ent->client->ammo_index] = 0;
                                        }
                                        break;
                                }
                        case SNIPER_NUM:
                                {
                                        ent->client->sniper_rds++;
                                        (ent->client->pers.inventory[ent->client->ammo_index])--;
                                        if ( ent->client->pers.inventory[ent->client->ammo_index] < 0) 
                                        {
                                                ent->client->pers.inventory[ent->client->ammo_index] = 0;
                                        }       
                                        break;
                                }
                        case DUAL_NUM:
                                {
                                        ent->client->dual_rds = ent->client->dual_max;
                                        ent->client->mk23_rds = ent->client->mk23_max;
                                        (ent->client->pers.inventory[ent->client->ammo_index]) -= 2;
                                        if ( ent->client->pers.inventory[ent->client->ammo_index] < 0) 
                                        {
                                                ent->client->pers.inventory[ent->client->ammo_index] = 0;
                                        }                       
                                        break;
                                }
                        default:
                                gi.dprintf("No weapon choice for reloading.\n");
                                break;
                        }

                        
                }
        }

        if( ent->client->weaponstate == WEAPON_END_MAG)
        {
                if(ent->client->ps.gunframe < FRAME_LASTRD_LAST)
                        ent->client->ps.gunframe++;
                else
                        ent->client->ps.gunframe = FRAME_LASTRD_LAST;
                // see if our weapon has ammo (from something other than reloading)
                if ( (( ent->client->curr_weap == MK23_NUM ) && ( ent->client->mk23_rds > 0 ))
                        || (( ent->client->curr_weap == MP5_NUM ) && ( ent->client->mp5_rds > 0 ))
                        || (( ent->client->curr_weap == M4_NUM ) && ( ent->client->m4_rds > 0 ))
                        || (( ent->client->curr_weap == M3_NUM ) && ( ent->client->shot_rds > 0 ))
                        || (( ent->client->curr_weap == HC_NUM ) && ( ent->client->cannon_rds > 0 ))
                        || (( ent->client->curr_weap == SNIPER_NUM ) && ( ent->client->sniper_rds > 0 ))
                        || (( ent->client->curr_weap == DUAL_NUM ) && ( ent->client->dual_rds > 0 )) )
                {
                        ent->client->weaponstate = WEAPON_READY;
                        ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                }
                
        }
        
        if (ent->client->weaponstate == WEAPON_DROPPING)
        {
                if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST)
                {
                        
                        ChangeWeapon (ent);
                        return;
                }
                // zucc for vwep
                else if((FRAME_DEACTIVATE_LAST - ent->client->ps.gunframe) == 4)
                {
                        ent->client->anim_priority = ANIM_REVERSE;
                        if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                        {
                                ent->s.frame = FRAME_crpain4+1;
                                ent->client->anim_end = FRAME_crpain1;
                        }
                        else
                        {
                                ent->s.frame = FRAME_pain304+1;
                                ent->client->anim_end = FRAME_pain301;
                                
                        }
                }


                ent->client->ps.gunframe++;
                return;
        }
        
        if ( ent->client->weaponstate == WEAPON_BANDAGING )
        {
                if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST )
                {
                        ent->client->weaponstate = WEAPON_BUSY;
                        ent->client->idle_weapon = BANDAGE_TIME;
                        return;
                }
                ent->client->ps.gunframe++;
                return;
        }


        if (ent->client->weaponstate == WEAPON_ACTIVATING)
        {
                if (ent->client->ps.gunframe == FRAME_ACTIVATE_LAST)
                {
                        ent->client->weaponstate = WEAPON_READY;
                        ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                        return;
                }
                
                // sounds for activation?
                switch( ent->client->curr_weap )
                {
                case MK23_NUM:
                        {
                                if (ent->client->dual_rds >= ent->client->mk23_max )
                                        ent->client->mk23_rds = ent->client->mk23_max;
                                else
                                        ent->client->mk23_rds = ent->client->dual_rds;
                                if(ent->client->ps.gunframe == 3) // 3
                                        gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23slide.wav"), 1, ATTN_NORM, 0);
                                ent->client->fired = 0;                                 //reset any firing delays
                                break;
                        }
                case MP5_NUM:
                        {
                                if(ent->client->ps.gunframe == 3) // 3
                                        gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mp5slide.wav"), 1, ATTN_NORM, 0);
                                ent->client->fired = 0;                                 //reset any firing delays
                                ent->client->burst = 0;
                                break;
                        }
                case M4_NUM:
                        {
                                if(ent->client->ps.gunframe == 3) // 3
                                        gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/m4a1slide.wav"), 1, ATTN_NORM, 0);
                                ent->client->fired = 0;                                 //reset any firing delays
                                ent->client->burst = 0;
                                ent->client->machinegun_shots = 0;
                                break;
                        }
                case M3_NUM:
                        {
                                ent->client->fired = 0;                                 //reset any firing delays
                                ent->client->burst = 0;
                                ent->client->fast_reload = 0;
                                break;
                        }
                case HC_NUM:
                        {
                                ent->client->fired = 0;                                 //reset any firing delays
                                ent->client->burst = 0;
                                break;
                        }
                case SNIPER_NUM:
                        {
                                ent->client->fired = 0;                                 //reset any firing delays
                                ent->client->burst = 0;
                                ent->client->fast_reload = 0;
                                break;
                        }
                case DUAL_NUM:
                        {
                                ent->client->fired = 0;                                 //reset any firing delays
                                ent->client->burst = 0;
                                break;
                        }
                        
                default:
                        gi.dprintf("Activated unknown weapon.\n");
                        break;
                }

                ent->client->resp.sniper_mode = 0;
                // has to be here for dropping the sniper rifle, in the drop command didn't work...
                ent->client->desired_fov = 90;
                ent->client->ps.fov = 90;
                ent->client->ps.gunframe++;
                return;
        }
                
                if (ent->client->weaponstate == WEAPON_BUSY)
        {
                        if ( ent->client->bandaging == 1 )
                        {
                                if ( !(ent->client->idle_weapon) )
                                {
                                        Bandage( ent );
                                        return;
                                }
                                else
                                {
                                        (ent->client->idle_weapon)--;
                                        return;
                                }
                        }
                        
                        // for after bandaging delay
                        if ( !(ent->client->idle_weapon) && ent->client->bandage_stopped )
                        {
                                ent->client->weaponstate = WEAPON_ACTIVATING;
                                ent->client->ps.gunframe = 0;
                                ent->client->bandage_stopped = 0;
                                return;
                        }
                        else if ( ent->client->bandage_stopped )
                        {
                                (ent->client->idle_weapon)--;
                                return;
                        }
                        
                        if( ent->client->curr_weap == SNIPER_NUM )
                        {
                                if ( ent->client->desired_fov == 90 )
                                        ent->client->ps.fov = 90;
                                if ( !(ent->client->idle_weapon) )
                                {
                                        ent->client->ps.fov = ent->client->desired_fov;
                                        ent->client->weaponstate = WEAPON_READY;
                                        ent->client->ps.gunindex = 0;
                                }
                                else                                                    
                                        (ent->client->idle_weapon)--;
                                                                                                
                        }
        }


        if ((ent->client->newweapon) && (ent->client->weaponstate != WEAPON_FIRING)
                        && (ent->client->weaponstate != WEAPON_BURSTING )
                        && (ent->client->bandage_stopped == 0) )
        {
                        ent->client->weaponstate = WEAPON_DROPPING;
                        ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
                        ent->client->desired_fov = 90;
                        ent->client->ps.fov = 90;
                        ent->client->resp.sniper_mode = 0;
                        if ( ent->client->pers.weapon )
                                ent->client->ps.gunindex = gi.modelindex( ent->client->pers.weapon->view_model );
                        
                        // zucc more vwep stuff
                        if((FRAME_DEACTIVATE_LAST - FRAME_DEACTIVATE_FIRST) < 4)
                        {
                                ent->client->anim_priority = ANIM_REVERSE;
                                if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                {
                                        ent->s.frame = FRAME_crpain4+1;
                                        ent->client->anim_end = FRAME_crpain1;
                                }
                                else
                                {
                                        ent->s.frame = FRAME_pain304+1;
                                        ent->client->anim_end = FRAME_pain301;
                                        
                                }
                        }
                        return;
        }

        // bandaging case
        if ( (ent->client->bandaging)
                && (ent->client->weaponstate != WEAPON_FIRING) 
                && (ent->client->weaponstate != WEAPON_BURSTING)
                && (ent->client->weaponstate != WEAPON_BUSY)
                && (ent->client->weaponstate != WEAPON_BANDAGING) )
        {
                ent->client->weaponstate = WEAPON_BANDAGING;
                ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
                return;
        }
        
        if (ent->client->weaponstate == WEAPON_READY)
        {
                if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) 
//FIREBLADE
                        && (ent->solid != SOLID_NOT || ent->deadflag == DEAD_DEAD) && !lights_camera_action)
//FIREBLADE
                {
                        ent->client->latched_buttons &= ~BUTTON_ATTACK;
                        switch ( ent->client->curr_weap )
                        {
                        case MK23_NUM:
                                {
                                        //      gi.cprintf (ent, PRINT_HIGH, "Calling ammo check %d\n", ent->client->mk23_rds);
                                        if ( ent->client->mk23_rds > 0 )
                                        {
                                                //              gi.cprintf(ent, PRINT_HIGH, "Entered fire selection\n");
                                                if ( ent->client->resp.mk23_mode != 0 && ent->client->fired == 0 )
                                                {
                                                        ent->client->fired = 1;
                                                        bFire = 1;
                                                }
                                                else if ( ent->client->resp.mk23_mode == 0 )
                                                {
                                                        bFire = 1;
                                                }
                                        }
                                        else
                                                bOut = 1;
                                        break;
                                        
                                }
                        case MP5_NUM:
                                {
                                        if ( ent->client->mp5_rds > 0 )
                                        {
                                                if ( ent->client->resp.mp5_mode != 0 && ent->client->fired == 0 && ent->client->burst == 0 )
                                                {
                                                        ent->client->fired = 1;
                                                        ent->client->ps.gunframe = 70;
                                                        ent->client->burst = 1;
                                                        ent->client->weaponstate = WEAPON_BURSTING;
                                                        
                                                        // start the animation
                                                        ent->client->anim_priority = ANIM_ATTACK;
                                                        if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                                        {
                                                                ent->s.frame = FRAME_crattak1-1;
                                                                ent->client->anim_end = FRAME_crattak9;
                                                        }
                                                        else
                                                        {
                                                                ent->s.frame = FRAME_attack1-1;
                                                                ent->client->anim_end = FRAME_attack8;
                                                        }
                                                }
                                                else if ( ent->client->resp.mp5_mode == 0 && ent->client->fired == 0 )
                                                {
                                                        bFire = 1;
                                                }
                                        }
                                        else
                                                bOut = 1;
                                        break;
                                }
                        case M4_NUM:
                                {
                                        if ( ent->client->m4_rds > 0 )
                                        {
                                                if ( ent->client->resp.m4_mode != 0 && ent->client->fired == 0 && ent->client->burst == 0 )
                                                {
                                                        ent->client->fired = 1;
                                                        ent->client->ps.gunframe = 64;
                                                        ent->client->burst = 1;
                                                        ent->client->weaponstate = WEAPON_BURSTING;
                                                        
                                                        // start the animation
                                                        ent->client->anim_priority = ANIM_ATTACK;
                                                        if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                                        {
                                                                ent->s.frame = FRAME_crattak1-1;
                                                                ent->client->anim_end = FRAME_crattak9;
                                                        }
                                                        else
                                                        {
                                                                ent->s.frame = FRAME_attack1-1;
                                                                ent->client->anim_end = FRAME_attack8;
                                                        }
                                                }
                                                else if ( ent->client->resp.m4_mode == 0 && ent->client->fired == 0 )
                                                {
                                                        bFire = 1;
                                                }
                                        }
                                        else
                                                bOut = 1;
                                        break;
                                }
                        case M3_NUM:
                                {
                                        if ( ent->client->shot_rds > 0 )
                                        {
                                                bFire = 1;
                                        }
                                        else
                                                bOut = 1;
                                        break;
                                }
                        case HC_NUM:
                                {
                                        if ( ent->client->cannon_rds == 2 )
                                        {
                                                bFire = 1;
                                        }
                                        else
                                                bOut = 1;
                                        break;
                                }
                        case SNIPER_NUM:
                                {
                                        if ( ent->client->ps.fov != ent->client->desired_fov)
                                                ent->client->ps.fov = ent->client->desired_fov;
                                        // if they aren't at 90 then they must be zoomed, so remove their weapon from view
                                        if ( ent->client->ps.fov != 90 )
                                        {
                                                ent->client->ps.gunindex = 0;
                                                ent->client->no_sniper_display = 0;
                                        }
                                        
                                        if ( ent->client->sniper_rds > 0 )
                                        {
                                                bFire = 1;
                                        }
                                        else
                                                bOut = 1;
                                        break;
                                }
                        case DUAL_NUM:
                                {
                                        if ( ent->client->dual_rds > 0 )
                                        {
                                                bFire = 1;
                                        }
                                        else
                                                bOut = 1;
                                        break;
                                }
                                
                                
                        default:
                                {
                                        gi.cprintf (ent, PRINT_HIGH, "Calling non specific ammo code\n");
                                        if ((!ent->client->ammo_index) || ( ent->client->pers.inventory[ent->client->ammo_index] >= ent->client->pers.weapon->quantity))        
                                        {               
                                                bFire = 1;
                                        }
                                        else
                                        {
                                                bFire = 0;
                                                bOut = 1;
                                        }
                                }
                                
                        }
                        if ( bFire )
                        {
                                ent->client->ps.gunframe = FRAME_FIRE_FIRST;
                                ent->client->weaponstate = WEAPON_FIRING;
                                
                                // start the animation
                                ent->client->anim_priority = ANIM_ATTACK;
                                if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                {
                                        ent->s.frame = FRAME_crattak1-1;
                                        ent->client->anim_end = FRAME_crattak9;
                                }
                                else
                                {
                                        ent->s.frame = FRAME_attack1-1;
                                        ent->client->anim_end = FRAME_attack8;
                                }
                        }
                        else if ( bOut ) // out of ammo
                        {
                                if (level.time >= ent->pain_debounce_time)
                                {
                                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                                        ent->pain_debounce_time = level.time + 1;
                                }
                                //+BD - Disabled for manual weapon change
                                //NoAmmoWeaponChange (ent);
                        }
                }
                else
                {
                        
                        if ( ent->client->ps.fov != ent->client->desired_fov)
                                ent->client->ps.fov = ent->client->desired_fov;
                        // if they aren't at 90 then they must be zoomed, so remove their weapon from view
                        if ( ent->client->ps.fov != 90 )
                        {
                                ent->client->ps.gunindex = 0;
                                ent->client->no_sniper_display = 0;
                        }
                        
                        if (ent->client->ps.gunframe == FRAME_IDLE_LAST)
                        {
                                ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                                return;
                        }
                        
                 /*       if (pause_frames)
                        {
                                for (n = 0; pause_frames[n]; n++)
                                {
                                        if (ent->client->ps.gunframe == pause_frames[n])
                                        {
                                                if (rand()&15)
                                                        return;
                                        }
                                }
                        }
                   */     
                        ent->client->ps.gunframe++;
                        ent->client->fired = 0; // weapon ready and button not down, now they can fire again
                        ent->client->burst = 0;
                        ent->client->machinegun_shots = 0;
                        return;
                }
        }
        
        if (ent->client->weaponstate == WEAPON_FIRING  )
        {
                for (n = 0; fire_frames[n]; n++)
                {
                        if (ent->client->ps.gunframe == fire_frames[n])
                        {
                                if (ent->client->quad_framenum > level.framenum)                                                                gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
                                
                                fire (ent);
                                break;
                        }
                }
                
                if (!fire_frames[n])
                        ent->client->ps.gunframe++;
                
                if (ent->client->ps.gunframe == FRAME_IDLE_FIRST+1)
                        ent->client->weaponstate = WEAPON_READY;
        }
        // player switched into 
        if ( ent->client->weaponstate == WEAPON_BURSTING )
        {
                for (n = 0; fire_frames[n]; n++)
                {
                        if (ent->client->ps.gunframe == fire_frames[n])
                        {
                                if (ent->client->quad_framenum > level.framenum)                                                                gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
                                {
                //                      gi.cprintf (ent, PRINT_HIGH, "Calling fire code, frame = %d.\n", ent->client->ps.gunframe);
                                        fire (ent);
                                }
                                break;
                        }
                }
                
                if (!fire_frames[n])
                        ent->client->ps.gunframe++;
                
                //gi.cprintf (ent, PRINT_HIGH, "Calling stricmp, frame = %d.\n", ent->client->ps.gunframe);
                
                
                if (ent->client->ps.gunframe == FRAME_IDLE_FIRST+1)
                        ent->client->weaponstate = WEAPON_READY;

                if ( ent->client->curr_weap == MP5_NUM )
                {
                        if (ent->client->ps.gunframe >= 76)
                        {
                                ent->client->weaponstate = WEAPON_READY;
                                ent->client->ps.gunframe = FRAME_IDLE_FIRST+1;
                        }
                //      gi.cprintf (ent, PRINT_HIGH, "Succes stricmp now: frame = %d.\n", ent->client->ps.gunframe);

                }
                if ( ent->client->curr_weap == M4_NUM ) 
                {
                        if (ent->client->ps.gunframe >= 69)
                        {
                                ent->client->weaponstate = WEAPON_READY;
                                ent->client->ps.gunframe = FRAME_IDLE_FIRST+1;
                        }
                //      gi.cprintf (ent, PRINT_HIGH, "Succes stricmp now: frame = %d.\n", ent->client->ps.gunframe);

                }

        }
}




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

GRENADE

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

#define GRENADE_TIMER           3.0
#define GRENADE_MINSPEED        400
#define GRENADE_MAXSPEED        800

void weapon_grenade_fire (edict_t *ent, qboolean held)
{
        vec3_t  offset;
        vec3_t  forward, right;
        vec3_t  start;
        int             damage = 125;
        float   timer;
        int             speed;
        float   radius;

        radius = damage+40;
        if (is_quad)
                damage *= 4;

        VectorSet(offset, 8, 8, ent->viewheight-8);
        AngleVectors (ent->client->v_angle, forward, right, NULL);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        timer = ent->client->grenade_time - level.time;
        speed = GRENADE_MINSPEED + (GRENADE_TIMER - timer) * ((GRENADE_MAXSPEED - GRENADE_MINSPEED) / GRENADE_TIMER);
        fire_grenade2 (ent, start, forward, damage, speed, timer, radius, held);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index]--;

        ent->client->grenade_time = level.time + 1.0;
}

void Weapon_Grenade (edict_t *ent)
{
        if ((ent->client->newweapon) && (ent->client->weaponstate == WEAPON_READY))
        {
                ChangeWeapon (ent);
                return;
        }

        if (ent->client->weaponstate == WEAPON_ACTIVATING)
        {
                ent->client->weaponstate = WEAPON_READY;
                ent->client->ps.gunframe = 16;
                return;
        }

        if (ent->client->weaponstate == WEAPON_READY)
        {
                if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) )
                {
                        ent->client->latched_buttons &= ~BUTTON_ATTACK;
                        if (ent->client->pers.inventory[ent->client->ammo_index])
                        {
                                ent->client->ps.gunframe = 1;
                                ent->client->weaponstate = WEAPON_FIRING;
                                ent->client->grenade_time = 0;
                        }
                        else
                        {
                                if (level.time >= ent->pain_debounce_time)
                                {
                                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                                        ent->pain_debounce_time = level.time + 1;
                                }
                                NoAmmoWeaponChange (ent);
                        }
                        return;
                }

                if ((ent->client->ps.gunframe == 29) || (ent->client->ps.gunframe == 34) || (ent->client->ps.gunframe == 39) || (ent->client->ps.gunframe == 48))
                {
                        if (rand()&15)
                                return;
                }

                if (++ent->client->ps.gunframe > 48)
                        ent->client->ps.gunframe = 16;
                return;
        }

        if (ent->client->weaponstate == WEAPON_FIRING)
        {
                if (ent->client->ps.gunframe == 5)
                        gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/hgrena1b.wav"), 1, ATTN_NORM, 0);

                if (ent->client->ps.gunframe == 11)
                {
                        if (!ent->client->grenade_time)
                        {
                                ent->client->grenade_time = level.time + GRENADE_TIMER + 0.2;
                                ent->client->weapon_sound = gi.soundindex("weapons/hgrenc1b.wav");
                                                                //ent->client->weapon_sound = gi.soundindex("weapons/grenlb1b.wav");
                        }

                        // they waited too long, detonate it in their hand
                        if (!ent->client->grenade_blew_up && level.time >= ent->client->grenade_time)
                        {
                                ent->client->weapon_sound = 0;
                                weapon_grenade_fire (ent, true);
                                ent->client->grenade_blew_up = true;
                        }

                        if (ent->client->buttons & BUTTON_ATTACK)
                                return;

                        if (ent->client->grenade_blew_up)
                        {
                                if (level.time >= ent->client->grenade_time)
                                {
                                        ent->client->ps.gunframe = 15;
                                        ent->client->grenade_blew_up = false;
                                }
                                else
                                {
                                        return;
                                }
                        }
                }

                if (ent->client->ps.gunframe == 12)
                {
                        ent->client->weapon_sound = 0;
                        weapon_grenade_fire (ent, false);
                }

                if ((ent->client->ps.gunframe == 15) && (level.time < ent->client->grenade_time))
                        return;

                ent->client->ps.gunframe++;

                if (ent->client->ps.gunframe == 16)
                {
                        ent->client->grenade_time = 0;
                        ent->client->weaponstate = WEAPON_READY;
                }
        }
}



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

GRENADE LAUNCHER

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

void weapon_grenadelauncher_fire (edict_t *ent)
{
        vec3_t  offset;
        vec3_t  forward, right;
        vec3_t  start;
        int             damage = 120;
        float   radius;

        radius = damage+40;
        if (is_quad)
                damage *= 4;

        VectorSet(offset, 8, 8, ent->viewheight-8);
        AngleVectors (ent->client->v_angle, forward, right, NULL);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -1;

        fire_grenade (ent, start, forward, damage, 600, 2.5, radius);

        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_GRENADE | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        ent->client->ps.gunframe++;

        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index]--;
}

void Weapon_GrenadeLauncher (edict_t *ent)
{
        static int      pause_frames[]  = {34, 51, 59, 0};
        static int      fire_frames[]   = {6, 0};

        Weapon_Generic (ent, 5, 16, 59, 64, 0, 0, pause_frames, fire_frames, weapon_grenadelauncher_fire);
}

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

ROCKET

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

void Weapon_RocketLauncher_Fire (edict_t *ent)
{
        vec3_t  offset, start;
        vec3_t  forward, right;
        int             damage;
        float   damage_radius;
        int             radius_damage;

        damage = 100 + (int)(random() * 20.0);
        radius_damage = 120;
        damage_radius = 120;
        if (is_quad)
        {
                damage *= 4;
                radius_damage *= 4;
        }

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -1;

        VectorSet(offset, 8, 8, ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
        fire_rocket (ent, start, forward, damage, 650, damage_radius, radius_damage);

        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_ROCKET | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        ent->client->ps.gunframe++;

        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index]--;
}

void Weapon_RocketLauncher (edict_t *ent)
{
        static int      pause_frames[]  = {25, 33, 42, 50, 0};
        static int      fire_frames[]   = {5, 0};

        Weapon_Generic (ent, 4, 12, 50, 54, 0,0, pause_frames, fire_frames, Weapon_RocketLauncher_Fire);
}


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

BLASTER / HYPERBLASTER

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

void Blaster_Fire (edict_t *ent, vec3_t g_offset, int damage, qboolean hyper, int effect)
{
        vec3_t  forward, right;
        vec3_t  start;
        vec3_t  offset;

        if (is_quad)
                damage *= 4;
        AngleVectors (ent->client->v_angle, forward, right, NULL);
        VectorSet(offset, 24, 8, ent->viewheight-8);
        VectorAdd (offset, g_offset, offset);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -1;

        fire_blaster (ent, start, forward, damage, 1000, effect, hyper);

        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        if (hyper)
                gi.WriteByte (MZ_HYPERBLASTER | is_silenced);
        else
                gi.WriteByte (MZ_BLASTER | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        PlayerNoise(ent, start, PNOISE_WEAPON);
}


void Weapon_Blaster_Fire (edict_t *ent)
{
        int             damage;

        if (deathmatch->value)
                damage = 15;
        else
                damage = 10;
        Blaster_Fire (ent, vec3_origin, damage, false, EF_BLASTER);
        ent->client->ps.gunframe++;
}

void Weapon_Blaster (edict_t *ent)
{
        static int      pause_frames[]  = {19, 32, 0};
        static int      fire_frames[]   = {5, 0};

        Weapon_Generic (ent, 4, 8, 52, 55, 0, 0, pause_frames, fire_frames, Weapon_Blaster_Fire);
}


void Weapon_HyperBlaster_Fire (edict_t *ent)
{
        float   rotation;
        vec3_t  offset;
        int             effect;
        int             damage;

        ent->client->weapon_sound = gi.soundindex("weapons/hyprbl1a.wav");

        if (!(ent->client->buttons & BUTTON_ATTACK))
        {
                ent->client->ps.gunframe++;
        }
        else
        {
                if (! ent->client->pers.inventory[ent->client->ammo_index] )
                {
                        if (level.time >= ent->pain_debounce_time)
                        {
                                gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                                ent->pain_debounce_time = level.time + 1;
                        }
                        NoAmmoWeaponChange (ent);
                }
                else
                {
                        rotation = (ent->client->ps.gunframe - 5) * 2*M_PI/6;
                        offset[0] = -4 * sin(rotation);
                        offset[1] = 0;
                        offset[2] = 4 * cos(rotation);

                        if ((ent->client->ps.gunframe == 6) || (ent->client->ps.gunframe == 9))
                                effect = EF_HYPERBLASTER;
                        else
                                effect = 0;
                        if (deathmatch->value)
                                damage = 15;
                        else
                                damage = 20;
                        Blaster_Fire (ent, offset, damage, true, effect);
                        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                                ent->client->pers.inventory[ent->client->ammo_index]--;
                }

                ent->client->ps.gunframe++;
                if (ent->client->ps.gunframe == 12 && ent->client->pers.inventory[ent->client->ammo_index])
                        ent->client->ps.gunframe = 6;
        }

        if (ent->client->ps.gunframe == 12)
        {
                gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/hyprbd1a.wav"), 1, ATTN_NORM, 0);
                ent->client->weapon_sound = 0;
        }

}

void Weapon_HyperBlaster (edict_t *ent)
{
        static int      pause_frames[]  = {0};
        static int      fire_frames[]   = {6, 7, 8, 9, 10, 11, 0};

        Weapon_Generic (ent, 5, 20, 49, 53, 0, 0, pause_frames, fire_frames, Weapon_HyperBlaster_Fire);
}

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

MACHINEGUN / CHAINGUN

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

void Machinegun_Fire (edict_t *ent)
{
        int     i;
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          angles;
        int                     damage = 8;
        int                     kick = 2;
        vec3_t          offset;

        if (!(ent->client->buttons & BUTTON_ATTACK))
        {
                ent->client->machinegun_shots = 0;
                ent->client->ps.gunframe++;
                return;
        }

        if (ent->client->ps.gunframe == 5)
                ent->client->ps.gunframe = 4;
        else
                ent->client->ps.gunframe = 5;

        if (ent->client->pers.inventory[ent->client->ammo_index] < 1)
        {
                ent->client->ps.gunframe = 6;
                if (level.time >= ent->pain_debounce_time)
                {
                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                        ent->pain_debounce_time = level.time + 1;
                }
                NoAmmoWeaponChange (ent);
                return;
        }

        if (is_quad)
        {
                damage *= 4;
                kick *= 4;
        }

        for (i=1 ; i<3 ; i++)
        {
                ent->client->kick_origin[i] = crandom() * 0.35;
                ent->client->kick_angles[i] = crandom() * 0.7;
        }
        ent->client->kick_origin[0] = crandom() * 0.35;
        ent->client->kick_angles[0] = ent->client->machinegun_shots * -1.5;

        // raise the gun as it is firing
        if (!deathmatch->value)
        {
                ent->client->machinegun_shots++;
                if (ent->client->machinegun_shots > 9)
                        ent->client->machinegun_shots = 9;
        }

        // get start / end positions
        VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
        AngleVectors (angles, forward, right, NULL);
        VectorSet(offset, 0, 8, ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
        fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN);

        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_MACHINEGUN | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index]--;
}

void Weapon_Machinegun (edict_t *ent)
{
        static int      pause_frames[]  = {23, 45, 0};
        static int      fire_frames[]   = {4, 5, 0};

        Weapon_Generic (ent, 3, 5, 45, 49, 0, 0, pause_frames, fire_frames, Machinegun_Fire);
}

void Chaingun_Fire (edict_t *ent)
{
        int                     i;
        int                     shots;
        vec3_t          start;
        vec3_t          forward, right, up;
        float           r, u;
        vec3_t          offset;
        int                     damage;
        int                     kick = 2;

        if (deathmatch->value)
                damage = 6;
        else
                damage = 8;

        if (ent->client->ps.gunframe == 5)
                gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnu1a.wav"), 1, ATTN_IDLE, 0);

        if ((ent->client->ps.gunframe == 14) && !(ent->client->buttons & BUTTON_ATTACK))
        {
                ent->client->ps.gunframe = 32;
                ent->client->weapon_sound = 0;
                return;
        }
        else if ((ent->client->ps.gunframe == 21) && (ent->client->buttons & BUTTON_ATTACK)
                && ent->client->pers.inventory[ent->client->ammo_index])
        {
                ent->client->ps.gunframe = 15;
        }
        else
        {
                ent->client->ps.gunframe++;
        }

        if (ent->client->ps.gunframe == 22)
        {
                ent->client->weapon_sound = 0;
                gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnd1a.wav"), 1, ATTN_IDLE, 0);
        }
        else
        {
                ent->client->weapon_sound = gi.soundindex("weapons/chngnl1a.wav");
        }

        if (ent->client->ps.gunframe <= 9)
                shots = 1;
        else if (ent->client->ps.gunframe <= 14)
        {
                if (ent->client->buttons & BUTTON_ATTACK)
                        shots = 2;
                else
                        shots = 1;
        }
        else
                shots = 3;

        if (ent->client->pers.inventory[ent->client->ammo_index] < shots)
                shots = ent->client->pers.inventory[ent->client->ammo_index];

        if (!shots)
        {
                if (level.time >= ent->pain_debounce_time)
                {
                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
                        ent->pain_debounce_time = level.time + 1;
                }
                NoAmmoWeaponChange (ent);
                return;
        }

        if (is_quad)
        {
                damage *= 4;
                kick *= 4;
        }

        for (i=0 ; i<3 ; i++)
        {
                ent->client->kick_origin[i] = crandom() * 0.35;
                ent->client->kick_angles[i] = crandom() * 0.7;
        }

        for (i=0 ; i<shots ; i++)
        {
                // get start / end positions
                AngleVectors (ent->client->v_angle, forward, right, up);
                r = 7 + crandom()*4;
                u = crandom()*4;
                VectorSet(offset, 0, r, u + ent->viewheight-8);
                P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

                fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_CHAINGUN);
        }

        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte ((MZ_CHAINGUN1 + shots - 1) | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index] -= shots;
}


void Weapon_Chaingun (edict_t *ent)
{
        static int      pause_frames[]  = {38, 43, 51, 61, 0};
        static int      fire_frames[]   = {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 0};

        Weapon_Generic (ent, 4, 31, 61, 64, 0, 0, pause_frames, fire_frames, Chaingun_Fire);
}


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

SHOTGUN / SUPERSHOTGUN

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

void weapon_shotgun_fire (edict_t *ent)
{
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          offset;
        int                     damage = 4;
        int                     kick = 8;

        if (ent->client->ps.gunframe == 9)
        {
                ent->client->ps.gunframe++;
                return;
        }

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -2;

        VectorSet(offset, 0, 8,  ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        if (is_quad)
        {
                damage *= 4;
                kick *= 4;
        }

        if (deathmatch->value)
                fire_shotgun (ent, start, forward, damage, kick, 500, 500, DEFAULT_DEATHMATCH_SHOTGUN_COUNT, MOD_SHOTGUN);
        else
                fire_shotgun (ent, start, forward, damage, kick, 500, 500, DEFAULT_SHOTGUN_COUNT, MOD_SHOTGUN);

        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_SHOTGUN | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        ent->client->ps.gunframe++;
        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index]--;
}

void Weapon_Shotgun (edict_t *ent)
{
        static int      pause_frames[]  = {22, 28, 34, 0};
        static int      fire_frames[]   = {8, 9, 0};

        Weapon_Generic (ent, 7, 18, 36, 39, 0, 0, pause_frames, fire_frames, weapon_shotgun_fire);
}


void weapon_supershotgun_fire (edict_t *ent)
{
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          offset;
        vec3_t          v;
        int                     damage = 6;
        int                     kick = 12;

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -2;

        VectorSet(offset, 0, 8,  ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        if (is_quad)
        {
                damage *= 4;
                kick *= 4;
        }

        v[PITCH] = ent->client->v_angle[PITCH];
        v[YAW]   = ent->client->v_angle[YAW] - 5;
        v[ROLL]  = ent->client->v_angle[ROLL];
        AngleVectors (v, forward, NULL, NULL);
        fire_shotgun (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT/2, MOD_SSHOTGUN);
        v[YAW]   = ent->client->v_angle[YAW] + 5;
        AngleVectors (v, forward, NULL, NULL);
        fire_shotgun (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT/2, MOD_SSHOTGUN);

        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_SSHOTGUN | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        ent->client->ps.gunframe++;
        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index] -= 2;
}

void Weapon_SuperShotgun (edict_t *ent)
{
        static int      pause_frames[]  = {29, 42, 57, 0};
        static int      fire_frames[]   = {7, 0};

        Weapon_Generic (ent, 6, 17, 57, 61, 0, 0, pause_frames, fire_frames, weapon_supershotgun_fire);
}



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

RAILGUN

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

void weapon_railgun_fire (edict_t *ent)
{
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          offset;
        int                     damage;
        int                     kick;

        if (deathmatch->value)
        {       // normal damage is too extreme in dm
                damage = 100;
                kick = 200;
        }
        else
        {
                damage = 150;
                kick = 250;
        }

        if (is_quad)
        {
                damage *= 4;
                kick *= 4;
        }

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -3, ent->client->kick_origin);
        ent->client->kick_angles[0] = -3;

        VectorSet(offset, 0, 7,  ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
        fire_rail (ent, start, forward, damage, kick);

        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_RAILGUN | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        ent->client->ps.gunframe++;
        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index]--;
}


void Weapon_Railgun (edict_t *ent)
{
        static int      pause_frames[]  = {56, 0};
        static int      fire_frames[]   = {4, 0};

        Weapon_Generic (ent, 3, 18, 56, 61, 0, 0, pause_frames, fire_frames, weapon_railgun_fire);
}


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

BFG10K

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

void weapon_bfg_fire (edict_t *ent)
{
        vec3_t  offset, start;
        vec3_t  forward, right;
        int             damage;
        float   damage_radius = 1000;

        if (deathmatch->value)
                damage = 200;
        else
                damage = 500;

        if (ent->client->ps.gunframe == 9)
        {
                // send muzzle flash
                gi.WriteByte (svc_muzzleflash);
                gi.WriteShort (ent-g_edicts);
                gi.WriteByte (MZ_BFG | is_silenced);
                gi.multicast (ent->s.origin, MULTICAST_PVS);

                ent->client->ps.gunframe++;

                PlayerNoise(ent, start, PNOISE_WEAPON);
                return;
        }

        // cells can go down during windup (from power armor hits), so
        // check again and abort firing if we don't have enough now
        if (ent->client->pers.inventory[ent->client->ammo_index] < 50)
        {
                ent->client->ps.gunframe++;
                return;
        }

        if (is_quad)
                damage *= 4;

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -2, ent->client->kick_origin);

        // make a big pitch kick with an inverse fall
        ent->client->v_dmg_pitch = -40;
        ent->client->v_dmg_roll = crandom()*8;
        ent->client->v_dmg_time = level.time + DAMAGE_TIME;

        VectorSet(offset, 8, 8, ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
        fire_bfg (ent, start, forward, damage, 400, damage_radius);

        ent->client->ps.gunframe++;

        PlayerNoise(ent, start, PNOISE_WEAPON);

        if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
                ent->client->pers.inventory[ent->client->ammo_index] -= 50;
}

void Weapon_BFG (edict_t *ent)
{
        static int      pause_frames[]  = {39, 45, 50, 55, 0};
        static int      fire_frames[]   = {9, 17, 0};

        Weapon_Generic (ent, 8, 32, 55, 58, 0, 0, pause_frames, fire_frames, weapon_bfg_fire);
}




#define MK23_SPREAD     140
#define MP5_SPREAD 250
#define M4_SPREAD 300
#define SNIPER_SPREAD 425
#define DUAL_SPREAD     300

int AdjustSpread( edict_t * ent, int spread )
{
        
        int running = 225; // minimum speed for running
        int walking = 10; // minimum speed for walking
        int laser = 0;
        float factor[] = {.7, 1, 2, 6};
        int stage = 0;

        // 225 is running
        // < 10 will be standing
        float xyspeed = (ent->velocity[0]*ent->velocity[0] + ent->velocity[1]*ent->velocity[1]);
        
        if (ent->client->ps.pmove.pm_flags & PMF_DUCKED) // crouching
                return( spread * .65);

        if ( (ent->client->pers.inventory[ITEM_INDEX(FindItem(LASER_NAME))]) 
                        && (ent->client->curr_weap == MK23_NUM
                        || ent->client->curr_weap == MP5_NUM
                        || ent->client->curr_weap == M4_NUM ) )
                laser = 1;


        // running
        if ( xyspeed > running*running )
                stage = 3;
        // walking
        else if ( xyspeed >= walking*walking )
                stage = 2;
        // standing
        else
                stage = 1;
        
        // laser advantage
        if (laser)
        {
                        if (stage == 1)
                                stage = 0;
                        else
                                stage = 1;
        }
                
        return (int)(spread * factor[stage]);
}



//======================================================================


//======================================================================
// mk23 derived from tutorial by GreyBear

void Pistol_Fire(edict_t *ent)
{
        int     i;
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          angles;
        int             damage = 90;
        int             kick = 150;
        vec3_t          offset; 
        int                             spread = MK23_SPREAD;
        
        
        //If the user isn't pressing the attack button, advance the frame and go away....
        if (!(ent->client->buttons & BUTTON_ATTACK))
        {
                ent->client->ps.gunframe++;
                return;
        }
        ent->client->ps.gunframe++;     
        
        //Oops! Out of ammo!
        if (ent->client->mk23_rds < 1)
        {
                ent->client->ps.gunframe = 13;
                if (level.time >= ent->pain_debounce_time)
                {
                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"),1, ATTN_NORM, 0);
                        ent->pain_debounce_time = level.time + 1;
                }
                //NoAmmoWeaponChange (ent);
                return;
        }
        
        
        //Calculate the kick angles
        for (i=1 ; i<3 ; i++)
        {
                ent->client->kick_origin[i] = crandom() * 0.35;
                ent->client->kick_angles[i] = crandom() * 0.7;
        }
        ent->client->kick_origin[0] = crandom() * 0.35;
        ent->client->kick_angles[0] = ent->client->machinegun_shots * -1.5;
        
        // get start / end positions
        VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
        AngleVectors (angles, forward, right, NULL);
        VectorSet(offset, 0, 8, ent->viewheight-0);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);    
                if (!sv_shelloff->value)
        {
                        vec3_t result;
                        Old_ProjectSource (ent->client, ent->s.origin, offset, forward, right, result);    
                        EjectShell(ent, result, 0);
                }

        spread = AdjustSpread( ent, spread );
        
        if ( ent->client->resp.mk23_mode )
                spread *= .7;

//      gi.cprintf(ent, PRINT_HIGH, "Spread is %d\n", spread);

/*        if ((ent->client->mk23_rds == 1))
        {
                //Hard coded for reload only.
                ent->client->ps.gunframe=62;
                ent->client->weaponstate = WEAPON_END_MAG;
                fire_bullet (ent, start, forward, damage, kick, spread, spread,MOD_MK23);
                ent->client->mk23_rds--;
                ent->client->dual_rds--;
        }
        else
                */
        {
                //If no reload, fire normally.
                fire_bullet (ent, start, forward, damage, kick, spread, spread,MOD_MK23);
                ent->client->mk23_rds--;
                ent->client->dual_rds--;
        }
        
        // silencer suppresses both sound and muzzle flash 
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(SIL_NAME))] )
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/silencer.wav"), 1, ATTN_NORM, 0);        
        }
        else
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_NORM, 0);
                
                
                //Display the yellow muzzleflash light effect
                gi.WriteByte (svc_muzzleflash);
                gi.WriteShort (ent-g_edicts);
                //If not silenced, play a shot sound for everyone else
                gi.WriteByte (MZ_MACHINEGUN | is_silenced);
                gi.multicast (ent->s.origin, MULTICAST_PVS);
                PlayerNoise(ent, start, PNOISE_WEAPON);
        }       
}

void Weapon_MK23 (edict_t *ent)
{
        //Idle animation entry points - These make the fidgeting look more random
        static int      pause_frames[]  = {13, 22, 40};
        //The frames at which the weapon will fire
        static int      fire_frames[]   = {10, 0};
        
        //The call is made...
        Weapon_Generic (ent, 9, 12, 37, 40, 61, 65, pause_frames, fire_frames, Pistol_Fire);
}


void MP5_Fire(edict_t *ent)
{
        int     i;
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          angles;
        int             damage = 55;
        int             kick = 90;
        vec3_t          offset; 
        int                             spread = MP5_SPREAD;    
        
        //If the user isn't pressing the attack button, advance the frame and go away....
        if (!(ent->client->buttons & BUTTON_ATTACK) && !(ent->client->burst) )
        {
                ent->client->ps.gunframe++;
                return;
        }

        if ( ent->client->burst == 0 && !(ent->client->resp.mp5_mode) )
        {
                if (ent->client->ps.gunframe == 12)
                        ent->client->ps.gunframe = 11;
                else
                        ent->client->ps.gunframe = 12;
        }
        //burst mode
        else if ( ent->client->burst == 0 && ent->client->resp.mp5_mode )
        {
                ent->client->ps.gunframe = 72;
                ent->client->weaponstate = WEAPON_BURSTING;
                ent->client->burst = 1;
                ent->client->fired = 1;
        }

        else if ( ent->client->ps.gunframe >= 70 && ent->client->ps.gunframe <= 75 )
        {
                ent->client->ps.gunframe++;     
                
        }


        //Oops! Out of ammo!
        if (ent->client->mp5_rds < 1)
        {
                ent->client->ps.gunframe = 13;
                if (level.time >= ent->pain_debounce_time)
                {
                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"),1, ATTN_NORM, 0);
                        ent->pain_debounce_time = level.time + 1;
                }
                //NoAmmoWeaponChange (ent);
                return;
        }
        

        spread = AdjustSpread( ent, spread );
        if ( ent->client->burst )
                spread *= .7;


        //Calculate the kick angles
        for (i=1 ; i<3 ; i++)
        {
                ent->client->kick_origin[i] = crandom() * 0.25;
                ent->client->kick_angles[i] = crandom() * 0.5;
        }
        ent->client->kick_origin[0] = crandom() * 0.35;
        ent->client->kick_angles[0] = ent->client->machinegun_shots * -1.5;
        
        // get start / end positions
        VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
        AngleVectors (angles, forward, right, NULL);
        VectorSet(offset, 0, 8, ent->viewheight);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);    
        
                fire_bullet (ent, start, forward, damage, kick, spread, spread,MOD_MP5);
        ent->client->mp5_rds--;
        
                if (!sv_shelloff->value)
        {
                        vec3_t result;
                        Old_ProjectSource (ent->client, ent->s.origin, offset, forward, right, result);    
                        EjectShell(ent, result, 0);
                }



        // zucc vwep

        ent->client->anim_priority = ANIM_ATTACK;
        if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
        {
                ent->s.frame = FRAME_crattak1 - (int) (random()+0.25);
                ent->client->anim_end = FRAME_crattak9;
        }
        else
        {
                ent->s.frame = FRAME_attack1 - (int) (random()+0.25);
                ent->client->anim_end = FRAME_attack8;
        }

        // zucc vwep done

        // silencer suppresses both sound and muzzle flash 
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(SIL_NAME))] )
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/silencer.wav"), 1, ATTN_NORM, 0);        
        }
        else
        {       
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mp5fire1.wav"), 1, ATTN_NORM, 0);
                
                
                //Display the yellow muzzleflash light effect
                gi.WriteByte (svc_muzzleflash);
                gi.WriteShort (ent-g_edicts);
                //If not silenced, play a shot sound for everyone else
                gi.WriteByte (MZ_MACHINEGUN | is_silenced);
                gi.multicast (ent->s.origin, MULTICAST_PVS);
                PlayerNoise(ent, start, PNOISE_WEAPON);
        }               
}

void Weapon_MP5 (edict_t *ent)
{
        //Idle animation entry points - These make the fidgeting look more random
        static int      pause_frames[]  = {13, 30, 47};
        //The frames at which the weapon will fire
        static int      fire_frames[]   = {11, 12, 71, 72, 73, 0};
        
        //The call is made...
        Weapon_Generic (ent, 10, 12, 47, 51, 69, 77, pause_frames, fire_frames, MP5_Fire);
}

void M4_Fire(edict_t *ent)
{
        int                         i;
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          angles;
        int             damage = 90;
        int             kick = 90;
        vec3_t          offset; 
        int             spread = M4_SPREAD;     
        
        //If the user isn't pressing the attack button, advance the frame and go away....
        if (!(ent->client->buttons & BUTTON_ATTACK) && !(ent->client->burst) )
        {
                ent->client->ps.gunframe++;
                ent->client->machinegun_shots = 0;
                return;
        }
        
        if ( ent->client->burst == 0 && !(ent->client->resp.m4_mode) )
        {
                if (ent->client->ps.gunframe == 12)
                        ent->client->ps.gunframe = 11;
                else
                        ent->client->ps.gunframe = 12;
        }
        //burst mode
        else if ( ent->client->burst == 0 && ent->client->resp.m4_mode )
        {
                ent->client->ps.gunframe = 66;
                ent->client->weaponstate = WEAPON_BURSTING;
                ent->client->burst = 1;
                ent->client->fired = 1;
        }
        
        else if ( ent->client->ps.gunframe >= 64 && ent->client->ps.gunframe <= 69 )
        {
                ent->client->ps.gunframe++;     
                
        }
        
        
        //Oops! Out of ammo!
        if (ent->client->m4_rds < 1)
        {
                ent->client->ps.gunframe = 13;
                if (level.time >= ent->pain_debounce_time)
                {
                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"),1, ATTN_NORM, 0);
                        ent->pain_debounce_time = level.time + 1;
                }
                //NoAmmoWeaponChange (ent);
                return;
        }
        
        // causes the ride up
        if ( ent->client->weaponstate != WEAPON_BURSTING )
        {
                ent->client->machinegun_shots++;
                if (ent->client->machinegun_shots > 23)
                        ent->client->machinegun_shots = 23;
        }
        else // no kick when in burst mode
        {
                ent->client->machinegun_shots = 0;
        }
        
        
        spread = AdjustSpread( ent, spread );
        if ( ent->client->burst )
                spread *= .7;
        
        
        //      gi.cprintf(ent, PRINT_HIGH, "Spread is %d\n", spread);
        
        
        //Calculate the kick angles
        for (i=1 ; i<3 ; i++)
        {
                ent->client->kick_origin[i] = crandom() * 0.25;
                ent->client->kick_angles[i] = crandom() * 0.5;
        }
        ent->client->kick_origin[0] = crandom() * 0.35;
        ent->client->kick_angles[0] = ent->client->machinegun_shots * -.7;
        
        // get start / end positions
        VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
        AngleVectors (angles, forward, right, NULL);
        VectorSet(offset, 0, 8, ent->viewheight-0);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);    
        
                fire_bullet_sparks (ent, start, forward, damage, kick, spread, spread,MOD_M4);
                ent->client->m4_rds--;
        
        if (!sv_shelloff->value)
        {
                        vec3_t result;
                        Old_ProjectSource (ent->client, ent->s.origin, offset, forward, right, result);    
                        EjectShell(ent, result, 0);
                }

        
        // zucc vwep
        
        ent->client->anim_priority = ANIM_ATTACK;
        if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
        {
                ent->s.frame = FRAME_crattak1 - (int) (random()+0.25);
                ent->client->anim_end = FRAME_crattak9;
        }
        else
        {
                ent->s.frame = FRAME_attack1 - (int) (random()+0.25);
                ent->client->anim_end = FRAME_attack8;
        }
        
        // zucc vwep done
        
        // silencer suppresses both sound and muzzle flash 
        /*      if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(SIL_NAME))] )
        {
        gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/silencer.wav"), 1, ATTN_NORM, 0);        
        }
        else
        */
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/m4a1fire.wav"), 1, ATTN_NORM, 0);
                
                
                //Display the yellow muzzleflash light effect
                gi.WriteByte (svc_muzzleflash);
                gi.WriteShort (ent-g_edicts);
                //If not silenced, play a shot sound for everyone else
                gi.WriteByte (MZ_MACHINEGUN | is_silenced);
                gi.multicast (ent->s.origin, MULTICAST_PVS);
                PlayerNoise(ent, start, PNOISE_WEAPON);
        }       
}

void Weapon_M4 (edict_t *ent)
{
        //Idle animation entry points - These make the fidgeting look more random
        static int      pause_frames[]  = {13, 24, 39};
        //The frames at which the weapon will fire
        static int      fire_frames[]   = {11, 12, 65, 66, 67, 0};
        
        //The call is made...
        Weapon_Generic (ent, 10, 12, 39, 44, 63, 71, pause_frames, fire_frames, M4_Fire);
}

void M3_Fire (edict_t *ent)
{
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          offset;
        int                     damage = 17; //actionquake is 15 standard
        int                     kick = 20;

        if (ent->client->ps.gunframe == 9)
        {
                ent->client->ps.gunframe++;
                return;
        }

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -2;

        VectorSet(offset, 0, 8,  ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

/*      if (is_quad)
        {
                damage *= 4;
                kick *= 4;
        }*/

        if (deathmatch->value)
                fire_shotgun (ent, start, forward, damage, kick, 800, 800, 12/*DEFAULT_DEATHMATCH_SHOTGUN_COUNT*/, MOD_M3);
        else
                fire_shotgun (ent, start, forward, damage, kick, 800, 800, 12/*DEFAULT_SHOTGUN_COUNT*/, MOD_M3);

        if (!sv_shelloff->value)
        {
                        vec3_t result;
                        Old_ProjectSource (ent->client, ent->s.origin, offset, forward, right, result);    
                        EjectShell(ent, result, 0);
                }


        
                
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/shotgf1b.wav"), 1, ATTN_NORM, 0);

        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_SHOTGUN | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        ent->client->ps.gunframe++;
        PlayerNoise(ent, start, PNOISE_WEAPON);

        //if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
        //      ent->client->pers.inventory[ent->client->ammo_index]--;
        ent->client->shot_rds--;

}

void Weapon_M3 (edict_t *ent)
{
        static int      pause_frames[]  = {22, 28, 0};
        static int      fire_frames[]   = {8, 9, 0};

        Weapon_Generic (ent, 7, 15, 35, 41, 52, 60, pause_frames, fire_frames, M3_Fire);
}


void HC_Fire (edict_t *ent)
{
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          offset;
        vec3_t          v;
        int                     damage = 20;
        int                     kick = 40;

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -2;

        VectorSet(offset, 0, 8,  ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        /*if (is_quad)
        {
                damage *= 4;
                kick *= 4;
        }*/

        v[PITCH] = ent->client->v_angle[PITCH];
        v[YAW]   = ent->client->v_angle[YAW] - 5;
        v[ROLL]  = ent->client->v_angle[ROLL];
        AngleVectors (v, forward, NULL, NULL);
        // default hspread is 1k and default vspread is 500
                fire_shotgun (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD*4, DEFAULT_SHOTGUN_VSPREAD*4, 34/2, MOD_HC);
        v[YAW]   = ent->client->v_angle[YAW] + 5;
        AngleVectors (v, forward, NULL, NULL);
        fire_shotgun (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD*4, DEFAULT_SHOTGUN_VSPREAD*5, 34/2, MOD_HC);

        gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/cannon_fire.wav"), 1, ATTN_NORM, 0);
        
        // send muzzle flash
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        gi.WriteByte (MZ_SSHOTGUN | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);

        ent->client->ps.gunframe++;
        PlayerNoise(ent, start, PNOISE_WEAPON);

//      if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
//              ent->client->pers.inventory[ent->client->ammo_index] -= 2;

        ent->client->cannon_rds -= 2;
}

void Weapon_HC (edict_t *ent)
{
        static int      pause_frames[]  = {29, 42, 57, 0};
        static int      fire_frames[]   = {7, 0};

        Weapon_Generic (ent, 6, 17, 57, 61, 82, 83, pause_frames, fire_frames, HC_Fire);
}

void Sniper_Fire(edict_t *ent)
{
        int     i;
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          angles;
        int             damage = 250;
        int             kick = 200;
        vec3_t          offset; 
        int                             spread = SNIPER_SPREAD;
        
        
        if ( ent->client->ps.gunframe == 13 )
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/ssgbolt.wav"), 1, ATTN_NORM, 0);
                ent->client->ps.gunframe++;
                                
                                
                                AngleVectors (ent->client->v_angle, forward, right, NULL);
                                VectorSet(offset, 0, 0, ent->viewheight-0);
        
                P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);    
        
                                EjectShell(ent, start, 0);
                return;
        }
        
        if ( ent->client->ps.gunframe == 21 )
        {
                if ( ent->client->ps.fov != ent->client->desired_fov)
                        ent->client->ps.fov = ent->client->desired_fov;
                // if they aren't at 90 then they must be zoomed, so remove their weapon from view
                if ( ent->client->ps.fov != 90 )
                {
                        ent->client->ps.gunindex = 0;
                        ent->client->no_sniper_display = 0;
                }
                ent->client->ps.gunframe++;

                return;
        }
        
        
        //If the user isn't pressing the attack button, advance the frame and go away....
        if (!(ent->client->buttons & BUTTON_ATTACK))
        {
                ent->client->ps.gunframe++;
                return;
        }
        ent->client->ps.gunframe++;     
        
        //Oops! Out of ammo!
        if (ent->client->sniper_rds < 1)
        {
                ent->client->ps.gunframe = 22;
                if (level.time >= ent->pain_debounce_time)
                {
                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"),1, ATTN_NORM, 0);
                        ent->pain_debounce_time = level.time + 1;
                }
                //NoAmmoWeaponChange (ent);
                return;
        }

        spread = AdjustSpread( ent, spread );
        if ( ent->client->resp.sniper_mode == SNIPER_2X )
                spread = 0;
        else if ( ent->client->resp.sniper_mode == SNIPER_4X )
                spread = 0;
        else if ( ent->client->resp.sniper_mode == SNIPER_6X )
                spread = 0; 


        
        //Calculate the kick angles
        for (i=1 ; i<3 ; i++)
        {
                ent->client->kick_origin[i] = crandom() * 0;
                ent->client->kick_angles[i] = crandom() * 0;
        }
        ent->client->kick_origin[0] = crandom() * 0;
        ent->client->kick_angles[0] = ent->client->machinegun_shots * 0;
        
        // get start / end positions
        VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
        AngleVectors (ent->client->v_angle, forward, right, NULL);
        VectorSet(offset, 0, 0, ent->viewheight-0);
        
                P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);    
        
        
        {
                //If no reload, fire normally.
                fire_bullet_sniper (ent, start, forward, damage, kick, spread, spread,MOD_SNIPER);
                ent->client->sniper_rds--;
                ent->client->ps.fov = 90; // so we can watch the next round get chambered
                ent->client->ps.gunindex = gi.modelindex( ent->client->pers.weapon->view_model );
                ent->client->no_sniper_display = 1;
        }
                
        
        
        // silencer suppresses both sound and muzzle flash 
        if ( ent->client->pers.inventory[ITEM_INDEX(FindItem(SIL_NAME))] )
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/silencer.wav"), 1, ATTN_NORM, 0);        
        }
        else
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/ssgfire.wav"), 1, ATTN_NORM, 0);
                //Display the yellow muzzleflash light effect
                gi.WriteByte (svc_muzzleflash);
                gi.WriteShort (ent-g_edicts);
                //If not silenced, play a shot sound for everyone else
                gi.WriteByte (MZ_MACHINEGUN | is_silenced);
                gi.multicast (ent->s.origin, MULTICAST_PVS);
                PlayerNoise(ent, start, PNOISE_WEAPON);
        }       
}

void Weapon_Sniper (edict_t *ent)
{
        //Idle animation entry points - These make the fidgeting look more random
        static int      pause_frames[]  = {21, 40};
        //The frames at which the weapon will fire
        static int      fire_frames[]   = {9, 13, 21, 0};
        
        //The call is made...
        Weapon_Generic (ent, 8, 21, 41, 50, 81, 95, pause_frames, fire_frames, Sniper_Fire);
}

void Dual_Fire(edict_t *ent)
{
        int     i;
        vec3_t          start;
        vec3_t          forward, right;
        vec3_t          angles;
        int             damage = 90;
        int             kick = 90;
        vec3_t          offset; 
        int                             spread = DUAL_SPREAD;
        
        //If the user isn't pressing the attack button, advance the frame and go away....
        if ( ent->client->ps.gunframe == 8 )
        {
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_NORM, 0);
                ent->client->ps.gunframe++;
                return;
        }

        if ( ent->client->ps.gunframe == 9 )
        {
                ent->client->ps.gunframe += 2;
                return;
        }

        /*if (!(ent->client->buttons & BUTTON_ATTACK))
        {
                ent->client->ps.gunframe++;
                return;
        }*/
        ent->client->ps.gunframe++;     
        
        //Oops! Out of ammo!
        if (ent->client->dual_rds < 1)
        {
                ent->client->ps.gunframe = 12;
                if (level.time >= ent->pain_debounce_time)
                {
                        gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"),1, ATTN_NORM, 0);
                        ent->pain_debounce_time = level.time + 1;
                }
                //NoAmmoWeaponChange (ent);
                return;
        }
        
        
        //Calculate the kick angles
        for (i=1 ; i<3 ; i++)
        {
                ent->client->kick_origin[i] = crandom() * 0.25;
                ent->client->kick_angles[i] = crandom() * 0.5;
        }
        ent->client->kick_origin[0] = crandom() * 0.35;
        
        // get start / end positions
        VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
        AngleVectors (angles, forward, right, NULL);
        // first set up for left firing
        VectorSet(offset, 0, -8, ent->viewheight);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);    
        
                if (!sv_shelloff->value)
        {
                        vec3_t result;
                        Old_ProjectSource (ent->client, ent->s.origin, offset, forward, right, result);    
                        EjectShell(ent, result, 1);
                }


        
        spread = AdjustSpread( ent, spread );
                
        
                //If no reload, fire normally.
                fire_bullet (ent, start, forward, damage, kick, spread, spread,MOD_DUAL);
                //now set it up for firing the right gun
                VectorSet(offset, 0, 8, ent->viewheight);
                P_ProjectSource(ent->client, ent->s.origin, offset, forward, right, start);    
                if ( ent->client->dual_rds > 1 )
                {
                        fire_bullet (ent, start, forward, damage, kick, spread, spread,MOD_DUAL);
                        
                        if (!sv_shelloff->value)
                        {
                                vec3_t result;
                                Old_ProjectSource (ent->client, ent->s.origin, offset, forward, right, result);    
                                EjectShell(ent, result, 2);
                        }
                        
                        if ( ent->client->dual_rds > ent->client->mk23_max + 1 )
                        {
                                ent->client->dual_rds -= 2;
                        }
                        else if ( ent->client->dual_rds > ent->client->mk23_max ) // 13 rounds left
                        {
                                ent->client->dual_rds -= 2;
                                ent->client->mk23_rds--;
                        }
                        else
                        {
                                ent->client->dual_rds -= 2;
                                ent->client->mk23_rds -= 2;
                        }
                        gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_NORM, 0);
                }
                else
                {
                        ent->client->dual_rds = 0;
                        ent->client->mk23_rds = 0;
            gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/noammo.wav"),1, ATTN_NORM, 0);
            //ent->pain_debounce_time = level.time + 1;
                }
        
        
        //gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_NORM, 0);
        //Display the yellow muzzleflash light effect
        gi.WriteByte (svc_muzzleflash);
        gi.WriteShort (ent-g_edicts);
        //If not silenced, play a shot sound for everyone else
        gi.WriteByte (MZ_MACHINEGUN | is_silenced);
        gi.multicast (ent->s.origin, MULTICAST_PVS);
        PlayerNoise(ent, start, PNOISE_WEAPON);
        
        
}

void Weapon_Dual (edict_t *ent)
{
        //Idle animation entry points - These make the fidgeting look more random
        static int      pause_frames[]  = {13, 22, 32};
        //The frames at which the weapon will fire
        static int      fire_frames[]   = {7,8,9, 0};
        
        //The call is made...
        Weapon_Generic (ent, 6, 10, 32, 40, 65, 68, pause_frames, fire_frames, Dual_Fire);
}



//zucc 

#define FRAME_PREPARETHROW_FIRST        (FRAME_DEACTIVATE_LAST +1)
#define FRAME_IDLE2_FIRST                       (FRAME_PREPARETHROW_LAST +1)
#define FRAME_THROW_FIRST                       (FRAME_IDLE2_LAST +1)
#define FRAME_STOPTHROW_FIRST           (FRAME_THROW_LAST +1)
#define FRAME_NEWKNIFE_FIRST            (FRAME_STOPTHROW_LAST +1)

void Weapon_Generic_Knife(edict_t *ent, int FRAME_ACTIVATE_LAST, int FRAME_FIRE_LAST, 
                                         int FRAME_IDLE_LAST, int FRAME_DEACTIVATE_LAST, 
                                         int FRAME_PREPARETHROW_LAST, int FRAME_IDLE2_LAST,
                                         int FRAME_THROW_LAST, int FRAME_STOPTHROW_LAST,
                                         int FRAME_NEWKNIFE_LAST,
                                         int *pause_frames, int *fire_frames, int (*fire)(edict_t *ent))
{
                
        if(ent->s.modelindex != 255) // zucc vwep
                return; // not on client, so VWep animations could do wacky things

//FIREBLADE
        if (ent->client->weaponstate == WEAPON_FIRING &&
                ((ent->solid == SOLID_NOT && ent->deadflag != DEAD_DEAD) || lights_camera_action))
        {
                ent->client->weaponstate = WEAPON_READY;
        }
//FIREBLADE
        
        if( ent->client->weaponstate == WEAPON_RELOADING)
        {
                if(ent->client->ps.gunframe < FRAME_NEWKNIFE_LAST)
                {
                        ent->client->ps.gunframe++;             
                }
                else
                {
                        ent->client->ps.gunframe = FRAME_IDLE2_FIRST;
                        ent->client->weaponstate = WEAPON_READY;
                }
        }
        
        if (ent->client->weaponstate == WEAPON_DROPPING)
        {
                if (ent->client->resp.knife_mode == 1)
                {
                        if (ent->client->ps.gunframe == FRAME_NEWKNIFE_FIRST)
                        {
                                ChangeWeapon (ent);
                                return;
                        }
                        else
                        {
                                // zucc going to have to do this a bit different because
                                // of the way I roll gunframes backwards for the thrownknife position
                                if((ent->client->ps.gunframe - FRAME_NEWKNIFE_FIRST) == 4)
                                {
                                        ent->client->anim_priority = ANIM_REVERSE;
                                        if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                        {
                                                ent->s.frame = FRAME_crpain4+1;
                                                ent->client->anim_end = FRAME_crpain1;
                                        }
                                        else
                                        {
                                                ent->s.frame = FRAME_pain304+1;
                                                ent->client->anim_end = FRAME_pain301;
                                                
                                        }
                                }
                                ent->client->ps.gunframe--;
                        }                               
                                
                }
                else
                {
                        if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST)
                        {
                                ChangeWeapon (ent);
                                return;
                        }
                        else if((FRAME_DEACTIVATE_LAST - ent->client->ps.gunframe) == 4)
                        {
                                ent->client->anim_priority = ANIM_REVERSE;
                                if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                {
                                        ent->s.frame = FRAME_crpain4+1;
                                        ent->client->anim_end = FRAME_crpain1;
                                }
                                else
                                {
                                        ent->s.frame = FRAME_pain304+1;
                                        ent->client->anim_end = FRAME_pain301;
                                        
                                }
                        }

                        

                        ent->client->ps.gunframe++;
                }
                return;
        }
        if (ent->client->weaponstate == WEAPON_ACTIVATING)
        {
                
                if ( ent->client->resp.knife_mode == 1 && ent->client->ps.gunframe == 0 )
                {
//                      gi.cprintf(ent, PRINT_HIGH, "NewKnifeFirst\n");
                        ent->client->ps.gunframe = FRAME_PREPARETHROW_FIRST;
                        return;
                }
                if (ent->client->ps.gunframe == FRAME_ACTIVATE_LAST 
                        || ent->client->ps.gunframe == FRAME_STOPTHROW_LAST )   
                {
                        ent->client->weaponstate = WEAPON_READY;
                        ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                        return;
                }
                if (ent->client->ps.gunframe == FRAME_PREPARETHROW_LAST)
                {
                        ent->client->weaponstate = WEAPON_READY;
                        ent->client->ps.gunframe = FRAME_IDLE2_FIRST;
                        return;
                }
                
                ent->client->resp.sniper_mode = 0;
                // has to be here for dropping the sniper rifle, in the drop command didn't work...
                ent->client->desired_fov = 90;
                ent->client->ps.fov = 90;
                
                ent->client->ps.gunframe++;
//              gi.cprintf(ent, PRINT_HIGH, "After increment frames = %d\n", ent->client->ps.gunframe);
                return;
        }

        

        // bandaging case
        if ( (ent->client->bandaging)
                && (ent->client->weaponstate != WEAPON_FIRING) 
                && (ent->client->weaponstate != WEAPON_BURSTING)
                && (ent->client->weaponstate != WEAPON_BUSY)
                && (ent->client->weaponstate != WEAPON_BANDAGING) )
        {
                ent->client->weaponstate = WEAPON_BANDAGING;
                ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
                return;
        }





        if ( ent->client->weaponstate == WEAPON_BUSY )
        {
                
                
                if ( ent->client->bandaging == 1 )
                {
                        if ( !(ent->client->idle_weapon) )
                        {
                                Bandage( ent );
                                //ent->client->weaponstate = WEAPON_ACTIVATING;
                //                ent->client->ps.gunframe = 0;
                        }
                        else
                                (ent->client->idle_weapon)--;
                        return;
                }

                // for after bandaging delay
                                if ( !(ent->client->idle_weapon) && ent->client->bandage_stopped )
                                {
                                        ent->client->weaponstate = WEAPON_ACTIVATING;
                    ent->client->ps.gunframe = 0;
                                        ent->client->bandage_stopped = 0;
                                        return;
                                }
                                else if ( ent->client->bandage_stopped == 1 )
                                {
                                        (ent->client->idle_weapon)--;
                                        return;
                                }

                
                if (ent->client->ps.gunframe == 98 )
                {
                        ent->client->weaponstate = WEAPON_READY;
                        return;
                }
                else
                        ent->client->ps.gunframe++;
        }

        if ( ent->client->weaponstate == WEAPON_BANDAGING )
        {
                if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST )
                {
                        ent->client->weaponstate = WEAPON_BUSY;
                        ent->client->idle_weapon = BANDAGE_TIME;
                        return;
                }
                ent->client->ps.gunframe++;
                return;
        }

        
        if ((ent->client->newweapon) && (ent->client->weaponstate != WEAPON_FIRING)
                && (ent->client->weaponstate != WEAPON_BUSY ) )
        {
                
                if ( ent->client->resp.knife_mode == 1 ) // throwing mode
                {
                        ent->client->ps.gunframe = FRAME_NEWKNIFE_LAST;
                        // zucc more vwep stuff
                        if((FRAME_NEWKNIFE_LAST - FRAME_NEWKNIFE_FIRST) < 4)
                        {
                                ent->client->anim_priority = ANIM_REVERSE;
                                if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                {
                                        ent->s.frame = FRAME_crpain4+1;
                                        ent->client->anim_end = FRAME_crpain1;
                                }
                                else
                                {
                                        ent->s.frame = FRAME_pain304+1;
                                        ent->client->anim_end = FRAME_pain301;
                                        
                                }
                        }               
                }
                else // not in throwing mode
                {
                        ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
                        // zucc more vwep stuff
                        if((FRAME_DEACTIVATE_LAST - FRAME_DEACTIVATE_FIRST) < 4)
                        {
                                ent->client->anim_priority = ANIM_REVERSE;
                                if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                {
                                        ent->s.frame = FRAME_crpain4+1;
                                        ent->client->anim_end = FRAME_crpain1;
                                }
                                else
                                {
                                        ent->s.frame = FRAME_pain304+1;
                                        ent->client->anim_end = FRAME_pain301;
                                        
                                }
                        }               
                }
                ent->client->weaponstate = WEAPON_DROPPING;
                return;
        }
        
        if (ent->client->weaponstate == WEAPON_READY)
        {
            if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) 
//FIREBLADE
                        && (ent->solid != SOLID_NOT || ent->deadflag == DEAD_DEAD) && !lights_camera_action)
//FIREBLADE
                {
                        ent->client->latched_buttons &= ~BUTTON_ATTACK;
                        
                        
                        if ( ent->client->resp.knife_mode == 1 )
                        {
                                ent->client->ps.gunframe = FRAME_THROW_FIRST;
                        }
                        else
                        {
                                ent->client->ps.gunframe = FRAME_FIRE_FIRST;
                        }       
                        ent->client->weaponstate = WEAPON_FIRING;
                        
                        // start the animation
                        ent->client->anim_priority = ANIM_ATTACK;
                        if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                        {
                                ent->s.frame = FRAME_crattak1-1;
                                ent->client->anim_end = FRAME_crattak9;
                        }
                        else
                        {
                                ent->s.frame = FRAME_attack1-1;
                                ent->client->anim_end = FRAME_attack8;
                        }
                        return;
                }
                if (ent->client->ps.gunframe == FRAME_IDLE_LAST)
                {
                        ent->client->ps.gunframe = FRAME_IDLE_FIRST;
                        return;
                }
                
                if ( ent->client->ps.gunframe == FRAME_IDLE2_LAST)
                {
                        ent->client->ps.gunframe = FRAME_IDLE2_FIRST;
                        return;
                }
/* // zucc this causes you to not be able to throw a knife while it is flipping
                if ( ent->client->ps.gunframe == 93 )
                {
                        ent->client->weaponstate = WEAPON_BUSY;
                        return;
                }
                                */
                //gi.cprintf(ent, PRINT_HIGH, "Before a gunframe additon frames = %d\n", ent->client->ps.gunframe);
                ent->client->ps.gunframe++;
                return;
        }
        if (ent->client->weaponstate == WEAPON_FIRING  )
        {
                int n;
                for (n = 0; fire_frames[n]; n++)
                {
                        if (ent->client->ps.gunframe == fire_frames[n])
                        {
                                if (ent->client->quad_framenum > level.framenum)                                                                gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
                                
                                if ( fire(ent) )
                                        break;
                                else // we ran out of knives and switched weapons
                                        return;
                        }
                }
                
                
                
                if (!fire_frames[n])
                        ent->client->ps.gunframe++;

                /*if ( ent->client->ps.gunframe == FRAME_STOPTHROW_FIRST + 1 )
                {
                        ent->client->ps.gunframe = FRAME_NEWKNIFE_FIRST;
                        ent->client->weaponstate = WEAPON_RELOADING;
                }*/
                
                if (ent->client->ps.gunframe == FRAME_IDLE_FIRST+1 ||
                        ent->client->ps.gunframe == FRAME_IDLE2_FIRST+1 )
                        ent->client->weaponstate = WEAPON_READY;
        }
        
}


int Knife_Fire (edict_t *ent)
{
        vec3_t          start, v;
        vec3_t          forward, right;

        vec3_t          offset;
        int             damage = 50;
        int             throwndamage = 250;
        int             kick = 50; // doesn't throw them back much..
        int             knife_return = 3;
        gitem_t*        item;

        AngleVectors (ent->client->v_angle, forward, right, NULL);

        VectorScale (forward, -2, ent->client->kick_origin);
        ent->client->kick_angles[0] = -2;

        VectorSet(offset, 0, 8,  ent->viewheight-8);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        
        
        v[PITCH] = ent->client->v_angle[PITCH];
        v[ROLL]  = ent->client->v_angle[ROLL];
        
        
        if ( ent->client->ps.gunframe == 6 ) 
        {
                v[YAW]   = ent->client->v_angle[YAW] + 5;
                AngleVectors (v, forward, NULL, NULL);
        }
        else if ( ent->client->ps.gunframe == 7 )
        {
                v[YAW]  = ent->client->v_angle[YAW] + 2;
                AngleVectors (v, forward, NULL, NULL);
        }
        else if ( ent->client->ps.gunframe == 8 )
        {
                v[YAW]   = ent->client->v_angle[YAW] ;
                AngleVectors (v, forward, NULL, NULL);
        }
        else if ( ent->client->ps.gunframe == 9 )
        {
                v[YAW]  = ent->client->v_angle[YAW] - 2;
                AngleVectors (v, forward, NULL, NULL);
        }
        else if ( ent->client->ps.gunframe == 10 )
        {
                v[YAW]   = ent->client->v_angle[YAW] -5;
                AngleVectors (v, forward, NULL, NULL);
        }
                
        
        if ( ent->client->resp.knife_mode == 0 )
        {
                knife_return = knife_attack (ent, start, forward, damage, kick  );
                
                if (knife_return < ent->client->knife_sound)
                        ent->client->knife_sound = knife_return;
                
                if ( ent->client->ps.gunframe == 8) // last slicing frame, time for some sound
                {
                        if ( ent->client->knife_sound == -2 ) 
                        {
                                // we hit a player
                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/stab.wav"), 1, ATTN_NORM, 0);
                        }
                        else if ( ent->client->knife_sound == -1 )
                        {
                                // we hit a wall
                                
                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/clank.wav"), 1, ATTN_NORM, 0);
                        }
                        else // we missed
                        {
                                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/swish.wav"), 1, ATTN_NORM, 0);
                        }
                        ent->client->knife_sound = 0;
                }
        }
        
        else
        {
                // do throwing stuff here
                
                damage = throwndamage;
                
                // throwing sound
                gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/throw.wav"), 1, ATTN_NORM, 0);

                                
                                // below is exact code from action for how it sets the knife up
                                AngleVectors (ent->client->v_angle, forward, right, NULL);
                                VectorSet(offset, 24, 8, ent->viewheight-8);
                                VectorAdd (offset, vec3_origin, offset);
                                forward[2] += .17;

                                // zucc using old style because the knife coming straight out looks
                                // pretty stupid
                                
                                
                                Old_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

                item = FindItem(KNIFE_NAME);
                ent->client->pers.inventory[ITEM_INDEX(item)]--;
                if ( ent->client->pers.inventory[ITEM_INDEX(item)] <= 0 )
                {
                        ent->client->newweapon = FindItem( MK23_NAME );
                        ChangeWeapon( ent );
                                                // zucc was at 1250, dropping speed to 1200
                        knife_throw (ent, start, forward, damage, 1200 ); 
                        return 0;
                }
                else
                {
                        ent->client->weaponstate = WEAPON_RELOADING;
                        ent->client->ps.gunframe = 111;
                }
                
                

                /*AngleVectors (ent->client->v_angle, forward, right, NULL);
                
                  VectorScale (forward, -2, ent->client->kick_origin);
                  ent->client->kick_angles[0] = -1;
                  
                        VectorSet(offset, 8, 8, ent->viewheight-8);
                        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
                */
                //      fire_rocket (ent, start, forward, damage, 650, 200, 200);
                
                knife_throw (ent, start, forward, damage, 1200 ); 
                
                
                // 
        }
        
        ent->client->ps.gunframe++;
        if ( ent->client->ps.gunframe == 106 ) // over the throwing frame limit
                ent->client->ps.gunframe = 64;  // the idle animation frame for throwing
                                                                                // not sure why the frames weren't ordered
                                                                                // with throwing first, unwise.
        PlayerNoise(ent, start, PNOISE_WEAPON);
        return 1;

}

void Weapon_Knife (edict_t *ent)
{
        static int      pause_frames[]  = {22, 28, 0};
        static int      fire_frames[]   = {6, 7, 8, 9, 10, 105, 0};
        // I think we need a special version of the generic function for this...
        Weapon_Generic_Knife (ent, 5, 12, 52, 59, 63, 102, 105, 110, 117, pause_frames, fire_frames, Knife_Fire);
}


// zucc - I thought about doing a gas grenade and even experimented with it some.  It
// didn't work out that great though, so I just changed this code to be the standard
// action grenade.  So the function name is just misleading...

void gas_fire (edict_t *ent )
{
        vec3_t  offset;
        vec3_t  forward, right;
        vec3_t  start;
        int             damage = 300;//GRENADE_DAMRAD;
        float   timer;
        int             speed;
        float   radius;
/*        int held = false;*/
        gitem_t* item;
        
        radius = damage + 40;

        VectorSet(offset, 8, 8, ent->viewheight-8);
        AngleVectors (ent->client->v_angle, forward, right, NULL);
        P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);

        timer = 2.0;
        
        if ( ent->client->resp.grenade_mode == 0 )
                speed = 400;
        else if ( ent->client->resp.grenade_mode == 1 )
                speed = 720;
        else
                speed = 920;
        
        fire_grenade2 (ent, start, forward, damage, speed, timer, radius, false);


        
        item = FindItem(GRENADE_NAME);
        ent->client->pers.inventory[ITEM_INDEX(item)]--;
        if ( ent->client->pers.inventory[ITEM_INDEX(item)] <= 0 )
        {
                ent->client->newweapon = FindItem( MK23_NAME );
                ChangeWeapon( ent );
                return;
        }
        else
        {
                ent->client->weaponstate = WEAPON_RELOADING;
                ent->client->ps.gunframe = 0;
        }


//      ent->client->grenade_time = level.time + 1.0;
        ent->client->ps.gunframe++;
}


#define GRENADE_ACTIVATE_LAST 3
#define GRENADE_PULL_FIRST 72
#define GRENADE_PULL_LAST 79
#define GRENADE_THROW_FIRST 4
#define GRENADE_THROW_LAST 9 // throw it on frame 8?
#define GRENADE_PINIDLE_FIRST 10
#define GRENADE_PINIDLE_LAST 39
// moved these up in the file (actually now in g_local.h)
//#define GRENADE_IDLE_FIRST 40
//#define GRENADE_IDLE_LAST 69
                                         
// the 2 deactivation frames are a joke, they look like shit, probably best to roll
// the activation frames backwards.  Aren't really enough of them either.

void Weapon_Gas (edict_t *ent)
{
        gitem_t* item;
        if(ent->s.modelindex != 255) // zucc vwep
                return; // not on client, so VWep animations could do wacky things

//FIREBLADE
        if (ent->client->weaponstate == WEAPON_FIRING &&
                ((ent->solid == SOLID_NOT && ent->deadflag != DEAD_DEAD) || 
                        lights_camera_action))
        {
                        ent->client->weaponstate = WEAPON_READY;
        }
//FIREBLADE
                
        if( ent->client->weaponstate == WEAPON_RELOADING)
        {
                if(ent->client->ps.gunframe < GRENADE_ACTIVATE_LAST)
                {
                        ent->client->ps.gunframe++;             
                }
                else
                {
                        ent->client->ps.gunframe = GRENADE_PINIDLE_FIRST;
                        ent->client->weaponstate = WEAPON_READY;
                }
        }
        
        if (ent->client->weaponstate == WEAPON_DROPPING)
        {
                if (ent->client->ps.gunframe == 0)
                {
                        ChangeWeapon (ent);
                        return;
                }
                else
                {
                        // zucc going to have to do this a bit different because
                        // of the way I roll gunframes backwards for the thrownknife position
                        if((ent->client->ps.gunframe) == 3)
                        {
                                ent->client->anim_priority = ANIM_REVERSE;
                                if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                {
                                        ent->s.frame = FRAME_crpain4+1;
                                        ent->client->anim_end = FRAME_crpain1;
                                }
                                else
                                {
                                        ent->s.frame = FRAME_pain304+1;
                                        ent->client->anim_end = FRAME_pain301;
                                        
                                }
                        }
                        ent->client->ps.gunframe--;
                        return;
                }                               
                
        }
        if (ent->client->weaponstate == WEAPON_ACTIVATING)
        {
                
                if (ent->client->ps.gunframe == GRENADE_ACTIVATE_LAST )
                {
                        ent->client->ps.gunframe = GRENADE_PINIDLE_FIRST;
                        ent->client->weaponstate = WEAPON_READY;
                        return;
                }
                
                if ( ent->client->ps.gunframe == GRENADE_PULL_LAST )
                {
                        ent->client->ps.gunframe = GRENADE_IDLE_FIRST;
                        ent->client->weaponstate = WEAPON_READY;
                        gi.cprintf(ent, PRINT_HIGH, "Pin pulled, ready for %s range throw\n", ent->client->resp.grenade_mode == 0 ? "short" : (ent->client->resp.grenade_mode == 1 ? "medium" : "long" ) );
                                                return;
                }
                
                if ( ent->client->ps.gunframe == 75 )
                {
                        gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/grenade.wav"), 1, ATTN_NORM, 0);
                }
                
                ent->client->resp.sniper_mode = 0;
                // has to be here for dropping the sniper rifle, in the drop command didn't work...
                ent->client->desired_fov = 90;
                ent->client->ps.fov = 90;
                
                ent->client->ps.gunframe++;
//              gi.cprintf(ent, PRINT_HIGH, "After increment frames = %d\n", ent->client->ps.gunframe);
                return;
        }


        // bandaging case
        if ( (ent->client->bandaging)
                && (ent->client->weaponstate != WEAPON_FIRING) 
                && (ent->client->weaponstate != WEAPON_BURSTING)
                && (ent->client->weaponstate != WEAPON_BUSY)
                && (ent->client->weaponstate != WEAPON_BANDAGING) )
        {
                ent->client->weaponstate = WEAPON_BANDAGING;
                ent->client->ps.gunframe = GRENADE_ACTIVATE_LAST;
                return;
        }


        if ( ent->client->weaponstate == WEAPON_BUSY )
        {
                
                
                        if ( ent->client->bandaging == 1 )
                        {
                                if ( !(ent->client->idle_weapon) )
                                {
                                        Bandage( ent );
                                }
                                else
                                        (ent->client->idle_weapon)--;
                                return;
                        }
                        // for after bandaging delay
                        if ( !(ent->client->idle_weapon) && ent->client->bandage_stopped )
                        {
                                gitem_t *item;
                                item = FindItem(GRENADE_NAME);
                                if ( ent->client->pers.inventory[ITEM_INDEX(item)] <= 0 )
                                {
                                        ent->client->newweapon = FindItem( MK23_NAME );
                                        ent->client->bandage_stopped = 0;
                                        ChangeWeapon( ent );
                                        return;
                                }
                                
                                ent->client->weaponstate = WEAPON_ACTIVATING;
                                ent->client->ps.gunframe = 0;
                                ent->client->bandage_stopped = 0;
                        }
                        else if ( ent->client->bandage_stopped )
                                (ent->client->idle_weapon)--;

                                        
        }

        if ( ent->client->weaponstate == WEAPON_BANDAGING )
        {
                if (ent->client->ps.gunframe == 0 )
                {
                        ent->client->weaponstate = WEAPON_BUSY;
                        ent->client->idle_weapon = BANDAGE_TIME;
                        return;
                }
                ent->client->ps.gunframe--;
                return;
        }

        
        if ((ent->client->newweapon) && (ent->client->weaponstate != WEAPON_FIRING)
                && (ent->client->weaponstate != WEAPON_BUSY ) )
        {
                
                        // zucc - check if they have a primed grenade
                        
                        if ( ent->client->curr_weap == GRENADE_NUM
                                && ( ent->client->ps.gunframe >= GRENADE_IDLE_FIRST
                                && ent->client->ps.gunframe <= GRENADE_IDLE_LAST ) )
                        {
                                fire_grenade2 (ent, ent->s.origin, tv(0,0,0), GRENADE_DAMRAD, 0, 2, GRENADE_DAMRAD*2, false);
                                item = FindItem(GRENADE_NAME);
                                ent->client->pers.inventory[ITEM_INDEX(item)]--;
                                if ( ent->client->pers.inventory[ITEM_INDEX(item)] <= 0 )
                                {
                                        ent->client->newweapon = FindItem( MK23_NAME );
                                        ChangeWeapon( ent );
                                        return;
                                }

                        }
    
                                        
                        ent->client->ps.gunframe = GRENADE_ACTIVATE_LAST;
                // zucc more vwep stuff
                if((GRENADE_ACTIVATE_LAST) < 4)
                {
                        ent->client->anim_priority = ANIM_REVERSE;
                        if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                        {
                                ent->s.frame = FRAME_crpain4+1;
                                ent->client->anim_end = FRAME_crpain1;
                        }
                        else
                        {
                                ent->s.frame = FRAME_pain304+1;
                                ent->client->anim_end = FRAME_pain301;
                                
                        }
                }               
                
                ent->client->weaponstate = WEAPON_DROPPING;
                return;
        }
        
        if (ent->client->weaponstate == WEAPON_READY)
        {
                        if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) 
//FIREBLADE
                                && (ent->solid != SOLID_NOT || ent->deadflag == DEAD_DEAD) && 
                                !lights_camera_action)
//FIREBLADE
                                
                        {
                                
                                
                                if ( ent->client->ps.gunframe <= GRENADE_PINIDLE_LAST &&
                                        ent->client->ps.gunframe >= GRENADE_PINIDLE_FIRST )
                                {
                                        ent->client->ps.gunframe = GRENADE_PULL_FIRST;
                                        ent->client->weaponstate = WEAPON_ACTIVATING;                                     
                                                                                ent->client->latched_buttons &= ~BUTTON_ATTACK;
                                }
                                else
                                {
                                        if (ent->client->ps.gunframe == GRENADE_IDLE_LAST)
                                        {
                                                ent->client->ps.gunframe = GRENADE_IDLE_FIRST;
                                                return;
                                        }
                                        ent->client->ps.gunframe++;
                                        return;
                                }       
                        }
                        
                        if ( ent->client->ps.gunframe >= GRENADE_IDLE_FIRST &&
                                ent->client->ps.gunframe <= GRENADE_IDLE_LAST )
                        {
                                ent->client->ps.gunframe = GRENADE_THROW_FIRST;
                                ent->client->anim_priority = ANIM_ATTACK;
                                if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
                                {
                                        ent->s.frame = FRAME_crattak1-1;
                                        ent->client->anim_end = FRAME_crattak9;
                                }
                                else
                                {
                                        ent->s.frame = FRAME_attack1-1;
                                        ent->client->anim_end = FRAME_attack8;
                                }
                                ent->client->weaponstate = WEAPON_FIRING;
                                return;
                                
                                
                                
                        }
                        
                        if ( ent->client->ps.gunframe == GRENADE_PINIDLE_LAST)
                        {
                                ent->client->ps.gunframe = GRENADE_PINIDLE_FIRST;
                                return;
                        }
                        
                        ent->client->ps.gunframe++;
                        return;
        }
        if (ent->client->weaponstate == WEAPON_FIRING  )
        {


                if ( ent->client->ps.gunframe == 8 )
                {
                        gas_fire(ent);
                        return;
                }



                ent->client->ps.gunframe++;

                if (ent->client->ps.gunframe == GRENADE_IDLE_FIRST+1 ||
                        ent->client->ps.gunframe == GRENADE_PINIDLE_FIRST+1 )
                        ent->client->weaponstate = WEAPON_READY;
        }
}
