переделка пулемета М2 (двухрежимный)

#include <amxmodx>
#include <fun>
#include <fakemeta>
#include <hamsandwich>
#include <engine>

new g_mod, g_weapon, g_duck, g_reload, g_connect, g_reload_mod, g_block
#define get_weapon(%0)   (entity_get_int(%0, EV_INT_impulse) == 20140)
#define set_weapon(%0)   entity_set_int(%0, EV_INT_impulse, 20140)
#define get_bit(%1,%2)   ((%1 & (1 << (%2 & 31))) ? true : false)
#define set_bit(%1,%2)	 %1 |= (1 << (%2 & 31))
#define reset_bit(%1,%2) %1 &= ~(1 << (%2 & 31))
#define VectorAdd(%1,%2,%3)   (%3[0] = %1[0] + %2[0], %3[1] = %1 [1] + %2[1], %3[2] = %1[2] + %2[2])

const PRIMARY_WEAPONS_BIT_SUM = 
(1<<CSW_SCOUT)|(1<<CSW_XM1014)|(1<<CSW_MAC10)|(1<<CSW_AUG)|(1<<CSW_UMP45)|(1<<CSW_SG550)|(1<<CSW_GALIL)|(1<<CSW_FAMAS)|(1<<CSW_AWP)|(1<<
CSW_MP5NAVY)|(1<<CSW_M249)|(1<<CSW_M3)|(1<<CSW_M4A1)|(1<<CSW_TMP)|(1<<CSW_G3SG1)|(1<<CSW_SG552)|(1<<CSW_AK47)|(1<<CSW_P90)

new const weapon_block[][]=
{
    "weapon_p228", "weapon_shield", "weapon_scout", "weapon_hegrenade", "weapon_xm1014", "weapon_c4", "weapon_mac10", "weapon_aug",
    "weapon_smokegrenade", "weapon_elite", "weapon_fiveseven", "weapon_ump45", "weapon_sg550", "weapon_galil", "weapon_famas",
    "weapon_usp", "weapon_glock18", "weapon_awp", "weapon_mp5navy", "weapon_m249", "weapon_m3", "weapon_m4a1", "weapon_tmp",
    "weapon_g3sg1", "weapon_flashbang", "weapon_deagle", "weapon_sg552", "weapon_ak47", "weapon_knife", "weapon_p90", "lastinv"
}

enum 
{
    IDLE_A = 0,
    IDLE_B,
    DRAW_A,
    DRAW_A_,
    CHANGE_A,
    CHANGE_A_,  
    CHANGE_B, 
    CHANGE_B_, 
    RELOAD_A,
    RELOAD_B,
    SHOOT_A,
    SHOOT_B
}

new const trace_attack[][] = 
{
    "func_breakable", 
    "func_wall", 
    "func_door",
    "func_plat", 
    "func_rotating", 
    "worldspawn" 
}

new const damage_entity[][] =
{
    "player",
    "func_breakable",
    "hostage_entity"
}

new const gunshot_decal[] = {41, 42, 43, 44, 45}

new const sound_shoot[] = "weapons/m2-1.wav"
new const smoke_sprite[] = "sprites/smoke_cheytaclrrs.spr"
new const shell_model[] = "models/cso/shell762.mdl"
new const models_weapon[][] =
{
    "models/cso/v_m2.mdl",
    "models/cso/p_m2_1.mdl",
    "models/cso/p_m2_2.mdl",
    "models/cso/w_m2.mdl"
}

const AMMO_CLIP = 250
const AMMO_MAX = 250
const Float:DAMAGE_A = 2.0
const Float:DAMAGE_B = 2.5
const Float:SPEED_A = 0.1
const Float:SPEED_B = 0.15
const Float:RECOIL_A = 2.0
const Float:RECOIL_B = 0.0

new Float:time_mod[33] = 0.0
new g_origin_event_weapon, g_smoke_index, g_shell_index, g_item

new const item_name[] = "M2 (Dual Mod)"
const item_cost = 100

public plugin_init()
{
       register_plugin("[Z] Weapon: M2", "0.6 beta", "batcon")

       RegisterHam(Ham_Item_Deploy, "weapon_m249", "Ham_Item_Deploy_Post", true)
       RegisterHam(Ham_Weapon_Reload, "weapon_m249", "Ham_Weapon_Reload_Pre", false)
       RegisterHam(Ham_Item_PostFrame, "weapon_m249", "Ham_Item_PostFrame_Pre", false)
       RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_m249", "Ham_Weapon_PrimaryAttack_Pre", false)
       RegisterHam(Ham_Weapon_WeaponIdle, "weapon_m249", "Ham_Weapon_WeaponIdle_Pre", false)
       RegisterHam(Ham_Item_AddToPlayer, "weapon_m249", "Ham_Item_AddToPlayer_Post", true)
       
       static i

       for(i = 0 ;i < sizeof trace_attack; i++)
       {
                   RegisterHam(Ham_TraceAttack, trace_attack[i], "Ham_TraceAttack_Post", true)
       }

       for(i = 0 ;i < sizeof damage_entity; i++)
       {
                   RegisterHam(Ham_TraceAttack, damage_entity[i], "Ham_TraceAttack_Pre", false)	
       }

       register_forward(FM_PlaybackEvent, "FM_PlaybackEvent_Pre", false)
       register_forward(FM_UpdateClientData, "FM_UpdateClientData_Post", true)
       register_forward(FM_SetModel, "FM_SetModel_Pre", false)
       register_forward(FM_CmdStart, "FM_CmdStart_Pre", false)
       register_forward(FM_PlayerPreThink, "FM_PlayerPreThink_Pre", false)

       for(i = 0; i < sizeof(weapon_block); i++) 
       {
             register_clcmd(weapon_block[i], "block_weapon")
       }
       register_clcmd("give_m2", "give_m2")
       register_clcmd("weapon_m2", "weapon_hook")
}

public plugin_precache()
{
       static i

       for(i = 0; i < sizeof models_weapon; i++)
       {
		precache_model(models_weapon[i])
       }

       precache_sound(sound_shoot)
       g_smoke_index = precache_model(smoke_sprite)
       g_shell_index = precache_model(shell_model)

       register_forward(FM_PrecacheEvent, "FM_PrecacheEvent_Post", true)
}


//public zp_user_infected_post(id)
//{
//       reset_bit(g_mod, id)
//       reset_bit(g_duck, id)
//       reset_bit(g_reload_mod, id)
//       reset_bit(g_block, id)
//       remove_task(id)
//}

public weapon_hook(id) 
{
       engclient_cmd(id, "weapon_m249")
       return PLUGIN_HANDLED
}

public block_weapon(id)
{
       static item; item = get_player_item(id)

       if(get_bit(g_mod, id) || get_bit(g_reload_mod, id))
       {
              set_mod(id, item)
              set_bit(g_block, id)      
              return PLUGIN_HANDLED
       }

       return PLUGIN_CONTINUE
}

public client_putinserver(id)
{
       set_bit(g_connect, id)
}

public client_disconnect(id)
{
       reset_bit(g_connect, id)
       reset_bit(g_mod, id)
       reset_bit(g_weapon, id)
       reset_bit(g_reload, id)
       reset_bit(g_reload_mod, id)
       reset_bit(g_duck, id)
       remove_task(id)
}

public FM_PrecacheEvent_Post(type, name[])
{
       if(equal("events/m249.sc", name))
       {
                g_origin_event_weapon = get_orig_retval()
                return FMRES_HANDLED
       }

       return FMRES_IGNORED
}

public FM_PlaybackEvent_Pre(flags, invoker, eventid, Float:delay, Float:origin[3], Float:angles[3], Float:fparam1, Float:fparam2, iParam1, iParam2, bParam1, bParam2)
{
       if(eventid != g_origin_event_weapon)
       return FMRES_IGNORED

       if(!(1 < invoker <= get_maxplayers()))
       return FMRES_IGNORED

       playback_event(flags | FEV_HOSTONLY, invoker, eventid, delay, origin, angles, fparam1, fparam2, iParam1, iParam2, bParam1, bParam2)
       return FMRES_SUPERCEDE
}

public FM_UpdateClientData_Post(id, SendWeapons, CD_Handle)
{
       if(!is_user_alive(id))
       return FMRES_IGNORED

       static item; item = get_player_item(id)
	
       if(!get_weapon(item))
       return FMRES_IGNORED

       set_cd(CD_Handle, CD_flNextAttack, get_gametime () + 0.001)
       return FMRES_HANDLED
}

public give_m2(id)
{
       drop_weapons(id, 1)

       if(get_bit(g_mod, id))
       {
             reset_bit(g_mod, id)
             set_user_maxspeed(id, 220.0)
       }

       set_bit(g_weapon, id)
       static weapon; weapon = give_item(id, "weapon_m249")
       set_weapon(weapon)
       set_ammo_clip(weapon, AMMO_CLIP)
       set_ammo(id, AMMO_MAX)
       entity_set_string(id, EV_SZ_viewmodel, models_weapon[0])
       entity_set_string(id, EV_SZ_weaponmodel, models_weapon[1]) 
       UTIL_PlayWeaponAnimation(id, DRAW_A)
       set_next_attack(id, 1.0)

       message_begin(MSG_ONE, get_user_msgid("WeaponList"), _, id)
       write_string("weapon_m2") 
       write_byte(3)
       write_byte(200)
       write_byte(-1)
       write_byte(-1)
       write_byte(0)
       write_byte(4)
       write_byte(CSW_M249)
       write_byte(0)
       message_end()
}

public Ham_Item_Deploy_Post(weapon_ent)
{
       static id; id = get_player(weapon_ent)

       if(!get_weapon(weapon_ent))
       return HAM_IGNORED
       
       entity_set_string(id, EV_SZ_viewmodel, models_weapon[0]) 
       UTIL_PlayWeaponAnimation(id, DRAW_A)
       set_next_attack(id, 1.0) 

       switch(get_bit(g_mod, id))
       {
             case false: entity_set_string(id, EV_SZ_weaponmodel, models_weapon[1]) 
             case true:  entity_set_string(id, EV_SZ_weaponmodel, models_weapon[2]) 
       }

       return HAM_IGNORED
}

public Ham_Weapon_Reload_Pre(weapon_ent)
{
       static id, anim, clip, Float:time
       id = get_player(weapon_ent)

       if(!get_weapon(weapon_ent))
       return HAM_IGNORED

       if(get_ammo(id) <= 0 || get_ammo_clip(weapon_ent) >= AMMO_CLIP || get_bit(g_reload_mod, id))
       return HAM_SUPERCEDE

       clip = get_ammo_clip(weapon_ent)

       set_ammo_clip(weapon_ent, 0)
       ExecuteHam(Ham_Weapon_Reload, weapon_ent)
       set_ammo_clip(weapon_ent, clip)

       switch(get_bit(g_mod, id))
       {
             case false:
             {
                  anim = RELOAD_A 
                  time = 6.06
             }
             case true:
             {  
                  anim = RELOAD_B 
                  time = 5.7
             }
       }

       UTIL_PlayWeaponAnimation(id, anim) 
       set_next_attack(id, time)
       set_next_idle(weapon_ent, time)
       set_bit(g_reload, id)

       return HAM_SUPERCEDE
}

public Ham_Item_PostFrame_Pre(weapon_ent)
{
       static id; id = get_player(weapon_ent) 
       static ammo; ammo = get_ammo(id)
       static clip; clip = get_ammo_clip(weapon_ent)     
       static Float:NextAttack, Reload 

       if(!get_weapon(weapon_ent))
       return HAM_IGNORED 

       NextAttack = get_pdata_float(id, 83, 5) 
       Reload = get_pdata_int(weapon_ent, 54, 4)

       if(Reload && NextAttack <= 0.0)
       {
             static old; old = min(AMMO_CLIP - clip, ammo)  

             set_ammo_clip(weapon_ent, clip + old) 
             set_ammo(id, ammo - old)

             set_pdata_int(weapon_ent, 54, 0, 4)
             Reload = 0
       }

       reset_bit(g_reload, id)

       return HAM_IGNORED
}

public Ham_Weapon_PrimaryAttack_Pre(weapon_ent)
{
       static id, anim, Float:time, Float:type_recoil
       id = get_player(weapon_ent)

       if(!get_weapon(weapon_ent))
       return HAM_IGNORED

       if(get_ammo_clip(weapon_ent) == 0)
       return HAM_IGNORED
       ExecuteHam(Ham_Weapon_PrimaryAttack, weapon_ent)

       switch(get_bit(g_mod, id))
       {
             case false:
             {
                  anim = SHOOT_A
                  time = SPEED_A
                  type_recoil = RECOIL_A
                  EjectBrass(id, g_shell_index, -9.0, 17.0, 9.0, 10.0, 50.0)
             }
             case true:
             {
                  anim = SHOOT_B
                  time = SPEED_B
                  type_recoil = RECOIL_B
                  EjectBrass(id, g_shell_index, -9.0, 17.0, 0.2, 80.0, 100.0)
             }
       }

       emit_sound(id, CHAN_WEAPON, sound_shoot, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
       set_weapon_reloil(weapon_ent, type_recoil)
       UTIL_PlayWeaponAnimation(id, anim)
       set_next_attack(id, time) 
       set_next_idle(weapon_ent, 1.3)

       return HAM_SUPERCEDE
}

public Ham_Weapon_WeaponIdle_Pre(weapon_ent)
{
       static id, anim, Float:time_idle, Float:time
       id = get_player(weapon_ent)

       if(!get_weapon(weapon_ent))
       return HAM_IGNORED

       if(get_bit(g_reload_mod, id))
       {
             reset_bit(g_reload_mod, id)
       }

       if(get_bit(g_block, id))
       {
             reset_bit(g_block, id)
       }

       time_idle = get_pdata_float(weapon_ent, 48, 4)    

       if(time_idle > 0.0)
       return HAM_IGNORED

       switch(get_bit(g_mod, id))
       {
             case false: 
             {
                  anim = IDLE_A
                  time = 2.6
             }
             case true:  
             {
                  anim = IDLE_B
                  time = 1.6
             }
       } 

       UTIL_PlayWeaponAnimation(id, anim)
       set_next_idle(weapon_ent, time)

       return HAM_SUPERCEDE
}

public Ham_Item_AddToPlayer_Post(weapon_ent, id)
{
       if(is_valid_ent(weapon_ent))
       {
             if(get_weapon(weapon_ent))
             {
                    set_bit(g_weapon, id)
                    
                    if(get_bit(g_mod, id))
                    {
                          reset_bit(g_mod, id)
                    }

                    if(get_bit(g_duck, id))
                    {
                          delete_duck_player(id)
                    }

                    message_begin(MSG_ONE, get_user_msgid("WeaponList"), _, id)
                    write_string("weapon_m2") 
                    write_byte(3)
                    write_byte(200)
                    write_byte(-1)
                    write_byte(-1)
                    write_byte(0)
                    write_byte(4)
                    write_byte(CSW_M249)
                    write_byte(0)
                    message_end()

                    return HAM_HANDLED
             }
                    message_begin(MSG_ONE, get_user_msgid("WeaponList"), _, id)
                    write_string("weapon_m249") 
                    write_byte(3)
                    write_byte(200)
                    write_byte(-1)
                    write_byte(-1)
                    write_byte(0)
                    write_byte(4)
                    write_byte(CSW_M249)
                    write_byte(0)
                    message_end()
       }

       return HAM_IGNORED
}

public Ham_TraceAttack_Post(entity, attacker, Float:damage, Float:fDir[3], ptr, damagetype)
{
       static item; item = get_player_item(attacker)
       static FLAG

       if(!get_weapon(item))
       return HAM_HANDLED
	
       new decal = gunshot_decal[random_num(0, sizeof(gunshot_decal) - 1)]
       new Float:vecEnd[3]
   
       get_tr2(ptr, TR_vecEndPos, vecEnd);

       message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
       write_byte(TE_GUNSHOTDECAL)
       engfunc(EngFunc_WriteCoord, vecEnd[0])
       engfunc(EngFunc_WriteCoord, vecEnd[1])
       engfunc(EngFunc_WriteCoord, vecEnd[2])
       write_short(entity)
       write_byte(decal)
       message_end()

       FLAG |= TE_EXPLFLAG_NODLIGHTS
       FLAG |= TE_EXPLFLAG_NOSOUND
       FLAG |= TE_EXPLFLAG_NOPARTICLES

       engfunc(EngFunc_MessageBegin, MSG_PAS, SVC_TEMPENTITY, vecEnd, 0)
       write_byte(TE_EXPLOSION)
       engfunc(EngFunc_WriteCoord, vecEnd[0])
       engfunc(EngFunc_WriteCoord, vecEnd[1])
       engfunc(EngFunc_WriteCoord, vecEnd[2] - 10.0)
       write_short(g_smoke_index)
       write_byte(2)
       write_byte(12)
       write_byte(FLAG)
       message_end()

       return HAM_IGNORED
}

public Ham_TraceAttack_Pre(entity, attacker, Float:damage)
{
       static Float:damage_x

       if(get_bit(g_connect, attacker))
       {
                if(get_user_weapon(attacker) == CSW_M249 && get_bit(g_weapon, attacker))
                {
                         switch(get_bit(g_mod, attacker))
                         {
                                case false: damage_x = DAMAGE_A
                                case true:  damage_x = DAMAGE_B
                         }

                         SetHamParamFloat(3, damage * damage_x)
                         return HAM_IGNORED
                } 
       }
       return HAM_IGNORED
}

public FM_SetModel_Pre(entity, model[])
{
       if(!is_valid_ent(entity))
       return FMRES_IGNORED
	
       static szClassName[33]
       entity_get_string(entity, EV_SZ_classname, szClassName, charsmax(szClassName))
		
       if(!equal(szClassName, "weaponbox"))
       return FMRES_IGNORED
	
       static id; id = entity_get_edict(entity, EV_ENT_owner)
	
       if(equal(model, "models/w_m249.mdl"))
       {
		static iStoredAugID; iStoredAugID = find_ent_by_owner(-1, "weapon_m249", entity)
	
		if(!is_valid_ent(iStoredAugID))
		return FMRES_IGNORED
	
		if(get_bit(g_weapon, id))
		{			
			entity_set_model(entity, models_weapon[3])
                        reset_bit(g_weapon, id)

                        if(get_bit(g_mod, id))
                        {
                              delete_duck_player(id)
                        }

			return FMRES_SUPERCEDE
		}
       }

       return FMRES_IGNORED
}

public FM_PlayerPreThink_Pre(id)
{
       if(!(is_user_alive(id) && (get_user_weapon(id) == CSW_M249) && get_bit(g_weapon, id) && get_bit(g_duck, id)))
       return FMRES_IGNORED

       entity_set_int(id, EV_INT_bInDuck, 1)

       client_cmd(id, "+duck")

       return FMRES_IGNORED
}

public FM_CmdStart_Pre(id, uc_handle, seed)
{
       if(!is_user_alive(id)) 
       return PLUGIN_HANDLED

       static item; item = get_player_item(id)
       static Float:world_time; world_time = get_gametime()

       if((get_uc(uc_handle, UC_Buttons) & IN_JUMP) && !(entity_get_int(id, EV_INT_oldbuttons) & IN_JUMP) && get_bit(g_duck, id))
       {
                entity_set_int(id, EV_INT_oldbuttons, entity_get_int(id, EV_INT_oldbuttons) | IN_JUMP)
       }

       if((get_uc(uc_handle, UC_Buttons) & IN_ATTACK2) && !(entity_get_int(id, EV_INT_oldbuttons) & IN_ATTACK2))
       {
                if(!get_weapon(item))
                return PLUGIN_HANDLED

                if((time_mod[id] > world_time) || get_bit(g_reload, id))
                return PLUGIN_HANDLED

                set_mod(id, item)
       }

       return PLUGIN_HANDLED
}

public set_mod(id, weapon)
{
       if(get_bit(g_block, id))
       return

       static anim, Float:time, Float:world_time
       world_time = get_gametime()

       switch(get_bit(g_mod, id))
       {
             case false:
             {
                  set_bit(g_mod, id)
                  set_bit(g_duck, id)
                  anim = CHANGE_A
                  time = 4.6
                  entity_set_string(id, EV_SZ_weaponmodel, models_weapon[2])
             }
             case true:  
             {
                  reset_bit(g_mod, id)
                  anim = CHANGE_B
                  time = 4.06
                  set_task(time, "set_speed_duck", id)
                  entity_set_string(id, EV_SZ_weaponmodel, models_weapon[1])
             }
       }  

       UTIL_PlayWeaponAnimation(id, anim)
       set_next_attack(id, time)
       set_next_idle(weapon, time) 
       set_user_maxspeed(id, 1.0)
       time_mod[id] = world_time + time
       set_bit(g_reload_mod, id)

       message_begin(MSG_ONE, get_user_msgid("BarTime"), _, id)
       write_short(floatround(time, floatround_round))
       message_end()
}

public set_speed_duck(id)
{
       set_user_maxspeed(id, 220.0)
       delete_duck_player(id)
}

public delete_duck_player(id)
{
       reset_bit(g_duck, id)
       entity_set_int(id, EV_INT_bInDuck, 0)
       client_cmd(id, "-duck")
}

public EjectBrass(id, iShellModelIndex, Float:upScale, Float:fwScale, Float:rgScale, Float:rgKoord1, Float:rgKoord2)
{
	UTIL_MakeVectors(id, 3)
	
	static Float:vVel[3], Float:vAngle[3], Float:vOrigin[3], Float:vViewOfs[3],
	i, Float:vShellOrigin[3], Float:vShellVelocity[3], Float:vRight[3], 
	Float:vUp[3], Float:vForward[3]
        entity_get_vector(id, EV_VEC_velocity, vVel)
        entity_get_vector(id, EV_VEC_view_ofs, vViewOfs)
        entity_get_vector(id, EV_VEC_angles, vAngle)
        entity_get_vector(id, EV_VEC_origin, vOrigin)
	global_get(glb_v_right, vRight)
	global_get(glb_v_up, vUp)
	global_get(glb_v_forward, vForward)
	
	for( i = 0; i < 3; i++ )
	{
		vShellOrigin[i] = vOrigin[i] + vViewOfs[i] + vUp[i] * upScale + vForward[i] * fwScale + vRight[i] * rgScale
		vShellVelocity[i] = vVel[i] + vRight[i] * random_float(rgKoord1, rgKoord2) + vUp[i] * random_float(100.0, 150.0) + vForward[i] * 25.0;
	}
	
	engfunc(EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, vShellOrigin, 0)
	write_byte(TE_MODEL)
	engfunc(EngFunc_WriteCoord, vShellOrigin[0])
	engfunc(EngFunc_WriteCoord, vShellOrigin[1])
	engfunc(EngFunc_WriteCoord, vShellOrigin[2])	
	engfunc(EngFunc_WriteCoord, vShellVelocity[0])
	engfunc(EngFunc_WriteCoord, vShellVelocity[1])
	engfunc(EngFunc_WriteCoord, vShellVelocity[2])
	engfunc(EngFunc_WriteAngle, vAngle[1])
	write_short(iShellModelIndex)
	write_byte(1)
	write_byte(15)
	message_end()
	
}

stock UTIL_MakeVectors(id, angletype)
{
	static Float:vPunchAngle[3], Float:vAngle[3]
	
	if(angletype& 1)    
                entity_get_vector(id, EV_VEC_v_angle, vAngle)
	if(angletype& 2) 
                entity_get_vector(id, EV_VEC_punchangle, vPunchAngle)
	
	VectorAdd(vAngle, vPunchAngle, vAngle)
	engfunc(EngFunc_MakeVectors, vAngle)
}

set_ammo_clip(weapon, amount)
{
	set_pdata_int(weapon, 51, amount, 4)
}

set_ammo(player, amount)
{
	set_pdata_int(player, 379, amount, 5)
}

get_ammo(player)
{
        return get_pdata_int(player, 379, 5)
}

get_ammo_clip(weapon)
{
        return get_pdata_int(weapon, 51, 4)
}

get_player(weapon)
{
        return get_pdata_cbase(weapon, 41, 4)
}

get_player_item(player)
{
        return get_pdata_cbase(player, 373, 5)
}

set_next_attack(player, Float:time)
{
        set_pdata_float(player, 83, time, 5)
}

set_next_idle(weapon, Float:time)
{
        set_pdata_float(weapon, 48, time, 4)
}

set_weapon_reloil(weapon, Float:recoil)
{
        set_pdata_float(weapon, 62, recoil, 4)
}

stock UTIL_PlayWeaponAnimation(const Player, const Sequence)
{
        entity_set_int(Player, EV_INT_weaponanim, Sequence)
	
	message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, .player = Player)
	write_byte(Sequence)
	write_byte(0)
	message_end()
}

stock drop_weapons(player, dropwhat)
{
     static weapons[32], num, i, weaponid
     num = 0
     get_user_weapons(player, weapons, num)
     
     for (i = 0; i < num; i++)
     {
          weaponid = weapons[i]
          
          if (dropwhat == 1 && ((1<<weaponid) & PRIMARY_WEAPONS_BIT_SUM))
          {
               static wname[32]
               get_weaponname(weaponid, wname, sizeof wname - 1)
               engclient_cmd(player, "drop", wname)
          }
     }
}