Half-Life и Adrenaline Gamer форум

// Don't touch this line, lol.
//#define _DEBUG

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

#if defined _DEBUG
   #define _DEBUG_CMD ""
#else
   #include <zombieplague>
#endif

#include <xs>

#define PLUGIN "[ZP] Extra: Balrog1"
#define VERSION "1.0"
#define AUTHOR "KORD_12.7"

#pragma ctrlchar '\'

//**********************************************
//* Weapon Settings.                           *
//**********************************************

// Main
#define WEAPON_REFERANCE      "weapon_usp"
#define WEAPON_NAME          "wpn_list_balrog1"

#define WEAPON_MAX_CLIP         10
#define WEAPON_DEFAULT_AMMO      50

#define WEAPON_MULTIPLIER_DAMAGE    2.2
#define WEAPON_EXPLODE_DAMAGE      500.0
#define WEAPON_EXPLDOE_RADIUS      100.0

#define WEAPON_TIME_NEXT_IDLE       2.00
#define WEAPON_TIME_NEXT_ATTACK    0.55
#define WEAPON_TIME_DELAY_DEPLOY    1.00
#define WEAPON_TIME_DELAY_RELOAD    2.70

// Extra
#define ZP_ITEM_NAME         "Balrog-I" 
#define ZP_ITEM_COST         15

// Models
#define MODEL_WORLD      "models/wpn/w_balrog1.mdl"
#define MODEL_VIEW      "models/wpn/v_balrog1.mdl"
#define MODEL_PLAYER   "models/wpn/p_balrog1.mdl"
#define MODEL_SHELL      "models/rshell.mdl"

// Sounds
#define SOUND_FIRE         "wpn/balrog1-1.wav" 
#define SOUND_FIRE_S      "wpn/balrog1-2.wav" 

// Sprites
#define WEAPON_HUD_TXT      "sprites/wpn_list_balrog1.txt"
#define WEAPON_HUD_SPR_1   "sprites/wpn/wpn_balrog1.spr"

#define SPRITE_EXPLODE      "sprites/wpn/ef_balrog1.spr"

enum _:Anim
{
   idleA = 0 , 
   idleB,
   shootA,
   shootB,
   reloadA,
   draw,
   changeA,
   changeB ,
   reloadB
}

//**********************************************
//* Some macroses.                             *
//**********************************************

#define SET_MODEL(%0,%1)      engfunc(EngFunc_SetModel, %0, %1)
#define SET_ORIGIN(%0,%1)      engfunc(EngFunc_SetOrigin, %0, %1)

#define PRECACHE_MODEL(%0)      engfunc(EngFunc_PrecacheModel, %0)
#define PRECACHE_SOUND(%0)      engfunc(EngFunc_PrecacheSound, %0)
#define PRECACHE_GENERIC(%0)      engfunc(EngFunc_PrecacheGeneric, %0)

#define PRECACHE_MODEL2(%0)      PrecacheSoundsFromModel(%0)

//**********************************************
//* PvData Offsets.                            *
//**********************************************

// Linux extra offsets
#define extra_offset_weapon      4
#define extra_offset_player      5

// CWeaponBox
#define m_rgpPlayerItems_CWeaponBox   34

// CBasePlayerItem
#define m_pPlayer         41
#define m_pNext            42

// CBasePlayerWeapon
#define m_flNextPrimaryAttack      46
#define m_flNextSecondaryAttack      47
#define m_flTimeWeaponIdle      48
#define m_iPrimaryAmmoType      49
#define m_iClip            51
#define m_fInSpecialReload      55
#define m_fInReload         54
#define m_iDirection         60
#define m_iShotsFired         64
#define m_fWeaponState         74

// CBaseMonster
#define m_flNextAttack         83

// CBasePlayer
#define m_iFOV            363
#define m_rgpPlayerItems_CBasePlayer   367
#define m_pActiveItem         373
#define m_rgAmmo_CBasePlayer      376
#define m_szAnimExtention      492

#define m_iCurrentMode         m_fInSpecialReload

//**********************************************
//* Let's code our weapon.                     *
//**********************************************

Weapon_OnPrecache()
{
   PRECACHE_MODEL(MODEL_VIEW);
   PRECACHE_MODEL2(MODEL_VIEW);
   
   PRECACHE_MODEL(MODEL_WORLD);
   PRECACHE_MODEL(MODEL_PLAYER);
   PRECACHE_MODEL(MODEL_SHELL);
   
   PRECACHE_SOUND(SOUND_FIRE);
   PRECACHE_SOUND(SOUND_FIRE_S);
   
   PRECACHE_GENERIC(WEAPON_HUD_TXT);
   PRECACHE_GENERIC(WEAPON_HUD_SPR_1);
   PRECACHE_MODEL(SPRITE_EXPLODE);
}

Weapon_OnSpawn(const iItem)
{
   // Setting world model.
   SET_MODEL(iItem, MODEL_WORLD);
}

Weapon_OnDeploy(const iItem, const iPlayer, const iClip, const iAmmoPrimary)
{
   #pragma unused iClip, iAmmoPrimary
   
   static iszViewModel;
   if (iszViewModel || (iszViewModel = engfunc(EngFunc_AllocString, MODEL_VIEW)))
   {
      set_pev_string(iPlayer, pev_viewmodel2, iszViewModel);
   }
   
   static iszPlayerModel;
   if (iszPlayerModel || (iszPlayerModel = engfunc(EngFunc_AllocString, MODEL_PLAYER)))
   {
      set_pev_string(iPlayer, pev_weaponmodel2, iszPlayerModel);
   }
   
   set_pdata_float(iItem, m_flTimeWeaponIdle, WEAPON_TIME_DELAY_DEPLOY, extra_offset_weapon);
   set_pdata_float(iPlayer, m_flNextAttack, WEAPON_TIME_DELAY_DEPLOY, extra_offset_player);
   set_pdata_int(iItem, m_iCurrentMode , 0 , extra_offset_weapon);
   
   Weapon_SendAnim( iPlayer,  draw  );
}

Weapon_OnHolster(const iItem, const iPlayer, const iClip, const iAmmoPrimary)
{
   #pragma unused iPlayer, iClip, iAmmoPrimary
   
   // Cancel any reload in progress.
   set_pdata_int(iItem, m_fInReload, 0, extra_offset_weapon);
}

Weapon_OnIdle(const iItem, const iPlayer, const iClip, const iAmmoPrimary)
{
   #pragma unused iClip, iAmmoPrimary
   
   ExecuteHamB(Ham_Weapon_ResetEmptySound, iItem);

   if (get_pdata_int(iItem, m_flTimeWeaponIdle, extra_offset_weapon) > 0.0)
   {
      return;
   }
   
   switch( get_pdata_int( iItem , m_iCurrentMode , extra_offset_weapon ) )
   {
      case 0:Weapon_SendAnim(iPlayer, idleA );
      case 1:Weapon_SendAnim(iPlayer, idleB );
   }
   
   set_pdata_float(iItem, m_flTimeWeaponIdle, WEAPON_TIME_NEXT_IDLE, extra_offset_weapon);
}

Weapon_OnReload(const iItem, const iPlayer, const iClip, const iAmmoPrimary)
{
   if (min(WEAPON_MAX_CLIP - iClip, iAmmoPrimary) <= 0)
   {
      return;
   }
   
   set_pdata_int(iItem, m_iClip, 0, extra_offset_weapon);
   
   ExecuteHam(Ham_Weapon_Reload, iItem);
   
   set_pdata_int(iItem, m_iClip, iClip, extra_offset_weapon);
   
   set_pdata_float(iPlayer, m_flNextAttack, WEAPON_TIME_DELAY_RELOAD, extra_offset_player);
   set_pdata_float(iItem, m_flTimeWeaponIdle, WEAPON_TIME_DELAY_RELOAD, extra_offset_weapon);
   
   switch( get_pdata_int( iItem , m_iCurrentMode , extra_offset_weapon ) )
   {
      case 0:Weapon_SendAnim(iPlayer, reloadA );
      case 1:
      {
         set_pdata_int(iItem, m_iCurrentMode , 0 , extra_offset_weapon);
         Weapon_SendAnim(iPlayer, reloadB );
      }
   }
}

Weapon_OnPrimaryAttack(const iItem, const iPlayer, const iClip, const iAmmoPrimary)
{
   #pragma unused iAmmoPrimary
   
   if (iClip <= 0)
   {
      return;
   }
   
   if(get_pdata_int(iItem, m_iShotsFired, extra_offset_weapon)) 
   {
      return;
   }
   
   static iShellModelIndex; 
   
   if (!iShellModelIndex)
   {
      iShellModelIndex = PRECACHE_MODEL(MODEL_SHELL);
   }
   
   cmdBrass( iPlayer , iShellModelIndex , iItem );
   
   switch( get_pdata_int( iItem , m_iCurrentMode , extra_offset_weapon ) )
   {
      case 0:
      {
         CallOrigFireBullets3(iItem, iPlayer);
         
         set_pdata_float(iItem, m_flTimeWeaponIdle, WEAPON_TIME_NEXT_IDLE, extra_offset_weapon);
         set_pdata_float(iItem, m_flNextPrimaryAttack, WEAPON_TIME_NEXT_ATTACK, extra_offset_weapon);
         set_pdata_float(iItem, m_flNextSecondaryAttack, WEAPON_TIME_NEXT_ATTACK, extra_offset_weapon);
         
         Weapon_SendAnim(iPlayer, shootA );
         emit_sound(iPlayer, CHAN_WEAPON, SOUND_FIRE, 0.9, ATTN_NORM, 0, PITCH_NORM);
      }
      case 1:
      {
         if(CWeapon_MakeExplode(iPlayer, iItem))
         {
            set_pdata_int(iItem, m_iClip, iClip - 1, extra_offset_weapon);
            
            set_pdata_float(iItem, m_flTimeWeaponIdle, 3.0, extra_offset_weapon);
            set_pdata_float(iItem, m_flNextPrimaryAttack, 3.0, extra_offset_weapon);
            set_pdata_float(iItem, m_flNextSecondaryAttack, 3.0, extra_offset_weapon);
            
            Weapon_SendAnim(iPlayer, shootB );
            emit_sound(iPlayer, CHAN_WEAPON, SOUND_FIRE_S, 0.9, ATTN_NORM, 0, PITCH_NORM);
            set_pdata_int(iItem, m_iCurrentMode , 0 , extra_offset_weapon);
         }
      }
   }
   
   set_pev( iPlayer, pev_punchangle, Float:{ 1.6 , 1.8 , 0.0 }  );
}

Weapon_OnSecondaryAttack(const iItem, const iPlayer, const iClip, const iAmmoPrimary)
{
   #pragma unused iAmmoPrimary, iClip
   
   switch( get_pdata_int( iItem , m_iCurrentMode , extra_offset_weapon ) )
   {
      case 0:
      {
         set_pdata_int(iItem, m_iCurrentMode , 1 , extra_offset_weapon);
         Weapon_SendAnim(iPlayer, changeA );
      }
      case 1:
      {
         set_pdata_int(iItem, m_iCurrentMode , 0 , extra_offset_weapon);
         Weapon_SendAnim(iPlayer, changeB );
      }
   }
   
   set_pdata_float(iItem, m_flTimeWeaponIdle, 2.0, extra_offset_weapon);
   set_pdata_float(iItem, m_flNextPrimaryAttack, 2.0, extra_offset_weapon);
   set_pdata_float(iItem, m_flNextSecondaryAttack, 2.0, extra_offset_weapon);
}

public CWeapon_MakeExplode(iPlayer, iItem)
{
   #define OFFSET_CSTEAMS      114
   
   new Float: vecSrc[3], Float: vecEnd[3], iTrace = create_tr2(); 
       
   wpn_get_gun_position(iPlayer, vecSrc); 
   global_get(glb_v_forward, vecEnd); 
       
   xs_vec_mul_scalar(vecEnd, 8192.0, vecEnd); 
   xs_vec_add(vecSrc, vecEnd, vecEnd); 

   engfunc(EngFunc_TraceLine, vecSrc, vecEnd, DONT_IGNORE_MONSTERS, iPlayer, iTrace); 
       
   get_tr2(iTrace, TR_vecEndPos, vecSrc); 
   get_tr2(iTrace, TR_vecPlaneNormal, vecEnd); 
   free_tr2(iTrace); 
       
   xs_vec_mul_scalar(vecEnd, 60.0, vecEnd); 
   xs_vec_add(vecSrc, vecEnd, vecEnd); 
       
   static iSpriteIndex; 
   if (iSpriteIndex|| (iSpriteIndex  = engfunc(EngFunc_ModelIndex, SPRITE_EXPLODE))) 
   { 
      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]); 
      write_short(iSpriteIndex); 
      write_byte(20); 
      write_byte(8);  
      write_byte(TE_EXPLFLAG_NONE); 
      message_end(); 
   }  
   
   static pevVictim   
   pevVictim  = -1;
   while( ( pevVictim = engfunc( EngFunc_FindEntityInSphere, pevVictim, vecEnd, WEAPON_EXPLDOE_RADIUS) ) != 0 )
   {
      if( !is_user_alive( pevVictim ) )
            continue;
            
      #if defined _DEBUG
      
      if(get_pdata_int(iPlayer, OFFSET_CSTEAMS, extra_offset_player) == get_pdata_int(pevVictim, OFFSET_CSTEAMS, extra_offset_player))
         continue;
         
      #else
      
      if( !zp_get_user_zombie( pevVictim ) )
         continue;
         
      #endif
      
      ExecuteHamB(Ham_TakeDamage,pevVictim, CSW_HEGRENADE , iPlayer, WEAPON_EXPLODE_DAMAGE, DMG_SONIC);
   }
   
   return 1;
}

//*********************************************************************
//*           Don't modify the code below this line unless            *
//*              you know _exactly_ what you are doing!!!             *
//*********************************************************************

#define MSG_WEAPONLIST 78

#define _CALLFUNC(%0,%1,%2) \
                           \
   Weapon_On%0                     \
   (                        \
      %1,                      \
      %2,                     \
                           \
      get_pdata_int(%1, m_iClip, extra_offset_weapon),   \
      GetAmmoInventory(%2, PrimaryAmmoIndex(%1))      \
   ) 

#define STATEMENT_FALLBACK(%0,%1,%2)   public %0()<>{return %1;} public %0()<%2>{return %1;}

#define MESSAGE_BEGIN(%0,%1,%2,%3)   engfunc(EngFunc_MessageBegin, %0, %1, %2, %3)
#define MESSAGE_END()         message_end()

#define WRITE_ANGLE(%0)         engfunc(EngFunc_WriteAngle, %0)
#define WRITE_BYTE(%0)         write_byte(%0)
#define WRITE_COORD(%0)         engfunc(EngFunc_WriteCoord, %0)
#define WRITE_STRING(%0)      write_string(%0)
#define WRITE_SHORT(%0)         write_short(%0)

#define MDLL_Spawn(%0)         dllfunc(DLLFunc_Spawn, %0)
#define MDLL_Touch(%0,%1)      dllfunc(DLLFunc_Touch, %0, %1)

//**********************************************
//* Motor!.                                    *
//**********************************************

new g_iszWeaponKey;
new g_iForwardDecalIndex;

#define IsValidPev(%0) (pev_valid(%0) == 2)
#define IsCustomItem(%0) (pev(%0, pev_impulse) == g_iszWeaponKey)

public plugin_precache()
{
   Weapon_OnPrecache();
   
   g_iszWeaponKey = engfunc(EngFunc_AllocString, WEAPON_NAME);
   g_iForwardDecalIndex = register_forward(FM_DecalIndex, "FakeMeta_DecalIndex_Post", true);
   
   register_message(MSG_WEAPONLIST, "MsgHook_WeaponList");
   register_message(get_user_msgid("DeathMsg"), "MsgHook_Death");
   
   register_clcmd(WEAPON_NAME, "Cmd_WeaponSelect");
}

public plugin_init()
{
   register_plugin(PLUGIN, VERSION, AUTHOR);
   
   RegisterHam(Ham_Spawn,       "weaponbox",       "HamHook_Weaponbox_Spawn_Post", true);

   RegisterHam(Ham_TraceAttack,   "func_breakable",   "HamHook_Entity_TraceAttack",    false);
   RegisterHam(Ham_TraceAttack,   "hostage_entity",   "HamHook_Entity_TraceAttack",    false);
   RegisterHam(Ham_TraceAttack,   "info_target",       "HamHook_Entity_TraceAttack",   false);
   RegisterHam(Ham_TraceAttack,   "player",       "HamHook_Entity_TraceAttack",   false);
   
   RegisterHam(Ham_Item_Deploy,      WEAPON_REFERANCE,    "HamHook_Item_Deploy_Post",   true);
   RegisterHam(Ham_Item_Holster,      WEAPON_REFERANCE,   "HamHook_Item_Holster",      false);
   RegisterHam(Ham_Item_PostFrame,      WEAPON_REFERANCE,    "HamHook_Item_PostFrame",   false);
   RegisterHam(Ham_Item_AttachToPlayer,   WEAPON_REFERANCE,    "HamHook_Item_AttachToPlayer",   false);

   RegisterHam(Ham_Weapon_Reload,      WEAPON_REFERANCE,    "HamHook_Item_Reload",      false);
   RegisterHam(Ham_Weapon_WeaponIdle,   WEAPON_REFERANCE,    "HamHook_Item_WeaponIdle",   false);
   RegisterHam(Ham_Weapon_PrimaryAttack,   WEAPON_REFERANCE,    "HamHook_Item_PrimaryAttack",   false);
   RegisterHam(Ham_Weapon_SecondaryAttack,   WEAPON_REFERANCE,    "HamHook_Item_SecondaryAttack",   false);
   
   RegisterHam(Ham_RemovePlayerItem,   "player",       "HamHook_RemovePlayerItem",   false);
   
   register_forward(FM_SetModel,      "FakeMeta_SetModel",         false);
   register_forward(FM_TraceLine,      "FakeMeta_TraceLine_Post",      true);
   register_forward(FM_UpdateClientData,   "FakeMeta_UpdateClientData_Post",   true);
   
   unregister_forward(FM_DecalIndex, g_iForwardDecalIndex, true);
        ExtraItem_Register()
}

#if defined _DEBUG
   
   ExtraItem_Register()
   {
      register_clcmd(_DEBUG_CMD, "Cmd_WeaponGive");
   }
   
   public Cmd_WeaponGive(const iPlayer)
   {
      Weapon_Give(iPlayer);
   }

#else

   new g_iItemID;

   ExtraItem_Register()
   {
      g_iItemID = zp_register_extra_item(ZP_ITEM_NAME, ZP_ITEM_COST, ZP_TEAM_HUMAN);
   }

   public zp_extra_item_selected(id, itemid)
   {
      if (itemid == g_iItemID)
      {
         Weapon_Give(id);
      }
   }
   
#endif

//**********************************************
//* Block client weapon.                       *
//**********************************************

public FakeMeta_UpdateClientData_Post(const iPlayer, const iSendWeapons, const CD_Handle)
{
   static iActiveItem;
   
   if (!IsValidPev(iPlayer))
   {
      return FMRES_IGNORED;
   }
   
   iActiveItem = get_pdata_cbase(iPlayer, m_pActiveItem, extra_offset_player);
   
   if (!IsValidPev(iActiveItem) || !IsCustomItem(iActiveItem))
   {
      return FMRES_IGNORED;
   }
   
   set_cd(CD_Handle, CD_flNextAttack, get_gametime() + 0.001);
   return FMRES_IGNORED;
}

//**********************************************
//* Item (weapon) hooks.                       *
//**********************************************


public HamHook_Item_Deploy_Post(const iItem)
{
   new iPlayer; 
   
   if (!CheckItem(iItem, iPlayer))
   {
      return HAM_IGNORED;
   }
   
   _CALLFUNC(Deploy, iItem, iPlayer);
   return HAM_IGNORED;
}

public HamHook_Item_Holster(const iItem)
{
   new iPlayer; 
   
   if (!CheckItem(iItem, iPlayer))
   {
      return HAM_IGNORED;
   }
   
   set_pev(iPlayer, pev_viewmodel, 0);
   set_pev(iPlayer, pev_weaponmodel, 0);
   
   _CALLFUNC(Holster, iItem, iPlayer);
   return HAM_SUPERCEDE;
}

public HamHook_Item_WeaponIdle(const iItem)
{
   static iPlayer; 
   
   if (!CheckItem(iItem, iPlayer))
   {
      return HAM_IGNORED;
   }

   _CALLFUNC(Idle, iItem, iPlayer);
   return HAM_SUPERCEDE;
}

public HamHook_Item_Reload(const iItem)
{
   static iPlayer; 
   
   if (!CheckItem(iItem, iPlayer))
   {
      return HAM_IGNORED;
   }
   
   _CALLFUNC(Reload, iItem, iPlayer);
   return HAM_SUPERCEDE;
}

public HamHook_Item_PrimaryAttack(const iItem)
{
   static iPlayer; 
   
   if (!CheckItem(iItem, iPlayer))
   {
      return HAM_IGNORED;
   }
   
   _CALLFUNC(PrimaryAttack, iItem, iPlayer);
   return HAM_SUPERCEDE;
}

public HamHook_Item_SecondaryAttack(const iItem)
{
   static iPlayer; 
   
   if (!CheckItem(iItem, iPlayer))
   {
      return HAM_IGNORED;
   }
   
   _CALLFUNC(SecondaryAttack, iItem, iPlayer);
   return HAM_SUPERCEDE;
}

public HamHook_Item_PostFrame(const iItem)
{
   static  iPlayer; 
   
   if (!CheckItem(iItem, iPlayer))
   {
      return HAM_IGNORED;
   }
   
   // Complete reload
   if (get_pdata_int(iItem, m_fInReload, extra_offset_weapon))
   {
      new iClip      = get_pdata_int(iItem, m_iClip, extra_offset_weapon); 
      new iPrimaryAmmoIndex   = PrimaryAmmoIndex(iItem);
      new iAmmoPrimary   = GetAmmoInventory(iPlayer, iPrimaryAmmoIndex);
      new iAmount      = min(WEAPON_MAX_CLIP - iClip, iAmmoPrimary);
      
      set_pdata_int(iItem, m_iClip, iClip + iAmount, extra_offset_weapon);
      set_pdata_int(iItem, m_fInReload, false, extra_offset_weapon);

      SetAmmoInventory(iPlayer, iPrimaryAmmoIndex, iAmmoPrimary - iAmount);
   }
   
   return HAM_IGNORED;
}

//**********************************************
//* Weapon list update.                        *
//**********************************************

new g_aWeaponListData[8];

public Cmd_WeaponSelect(const iPlayer)
{
   engclient_cmd(iPlayer, WEAPON_REFERANCE);
   return PLUGIN_HANDLED;
}

public MsgHook_WeaponList(const iMsgID, const iMsgDest, const iMsgEntity)
{
   new szWeaponName[32];
   get_msg_arg_string(1, szWeaponName, charsmax(szWeaponName));
      
   if (!strcmp(szWeaponName, WEAPON_REFERANCE))
   {
      for (new i, a = sizeof g_aWeaponListData; i < a; i++)
      {
         g_aWeaponListData[i] = get_msg_arg_int(i + 2);
      }
   }
}

public HamHook_Item_AttachToPlayer(const iItem, const iPlayer)
{
   if (!IsValidPev(iItem) || !IsValidPev(iPlayer))
   {
      return HAM_IGNORED;
   }
   
   if (IsCustomItem(iItem))
   {
      SendWeaponListUpdate(iPlayer, WEAPON_NAME);
   }
   
   return HAM_IGNORED;
}

public HamHook_RemovePlayerItem(const iPlayer, const iItem)
{
   if (!IsValidPev(iItem) || !IsValidPev(iPlayer))
   {
      return HAM_IGNORED;
   }
   
   if (IsCustomItem(iItem))
   {
      SendWeaponListUpdate(iPlayer, WEAPON_REFERANCE);
   }
   
   return HAM_IGNORED;
}

SendWeaponListUpdate(const iPlayer, const szWeaponName[32])
{
   MESSAGE_BEGIN(MSG_ONE, MSG_WEAPONLIST, {0.0, 0.0, 0.0}, iPlayer);
   WRITE_STRING(szWeaponName);
      
   for (new i, a = sizeof g_aWeaponListData; i < a; i++)
   {
      WRITE_BYTE(g_aWeaponListData[i]);
   }
   
   MESSAGE_END();
}

//**********************************************
//* Fire Bullets.                              *
//**********************************************

CallOrigFireBullets3(const iItem, const iPlayer)
{
   static Float: vecPuncheAngle[3];

   state stFireBullets: Enabled;
   
   pev(iPlayer, pev_punchangle, vecPuncheAngle);
   ExecuteHam(Ham_Weapon_PrimaryAttack, iItem);
   set_pev(iPlayer, pev_punchangle, vecPuncheAngle);
   
   state stFireBullets: Disabled;
}

public FakeMeta_TraceLine_Post(const Float: vecTraceStart[3], const Float: vecTraceEnd[3], const fNoMonsters, const iEntToSkip, const iTrace) <stFireBullets: Enabled>
{
   static Float: vecEndPos[3];
   
   get_tr2(iTrace, TR_vecEndPos, vecEndPos);
   engfunc(EngFunc_TraceLine, vecEndPos, vecTraceStart, fNoMonsters, iEntToSkip, 0);
   
   UTIL_GunshotDecalTrace(0);
   UTIL_GunshotDecalTrace(iTrace, true);
   
   return FMRES_IGNORED;
}
STATEMENT_FALLBACK(FakeMeta_TraceLine_Post, FMRES_IGNORED, stFireBullets: Disabled)

public HamHook_Entity_TraceAttack(const iEntity, const iAttacker, const Float: flDamage) <stFireBullets: Enabled>
{
   SetHamParamFloat(3, flDamage * WEAPON_MULTIPLIER_DAMAGE);
   return HAM_IGNORED;
}
STATEMENT_FALLBACK(HamHook_Entity_TraceAttack, HAM_IGNORED, stFireBullets: Disabled)

public MsgHook_Death() <stFireBullets: Enabled>
{
   static szTruncatedWeaponName[32];
   
   if (szTruncatedWeaponName[0] == EOS)
   {
      copy(szTruncatedWeaponName, charsmax(szTruncatedWeaponName), WEAPON_NAME);
      replace(szTruncatedWeaponName, charsmax(szTruncatedWeaponName), "weapon_", "");
   }
   
   set_msg_arg_string(4, szTruncatedWeaponName);
   return PLUGIN_CONTINUE;
}
STATEMENT_FALLBACK(MsgHook_Death, PLUGIN_CONTINUE, stFireBullets: Disabled)

//**********************************************
//* Weaponbox world model.                     *
//**********************************************

public HamHook_Weaponbox_Spawn_Post(const iWeaponBox)
{
   if (IsValidPev(iWeaponBox))
   {
      state (IsValidPev(pev(iWeaponBox, pev_owner))) stWeaponBox: Enabled;
   }
   
   return HAM_IGNORED;
}

public FakeMeta_SetModel(const iEntity) <stWeaponBox: Enabled>
{
   state stWeaponBox: Disabled;
   
   if (!IsValidPev(iEntity))
   {
      return FMRES_IGNORED;
   }
   
   #define MAX_ITEM_TYPES   6
   
   for (new i, iItem; i < MAX_ITEM_TYPES; i++)
   {
      iItem = get_pdata_cbase(iEntity, m_rgpPlayerItems_CWeaponBox + i, extra_offset_weapon);
      
      if (IsValidPev(iItem) && IsCustomItem(iItem))
      {
         SET_MODEL(iEntity, MODEL_WORLD);
         set_pev( iEntity , pev_body , 18 );
         return FMRES_SUPERCEDE;
      }
   }
   
   return FMRES_IGNORED;
}
STATEMENT_FALLBACK(FakeMeta_SetModel, FMRES_IGNORED, stWeaponBox: Disabled)

//**********************************************
//* Brass ejection.                            *
//**********************************************

public cmdBrass(const iPlayer , const ModelIndex , const iEnt )
{
   set_pdata_int(iEnt, 57, ModelIndex, extra_offset_weapon);
   set_pdata_float(iPlayer, 111, get_gametime()  );
}

//**********************************************
//* Create and check our custom weapon.        *
//**********************************************

Weapon_Create(const Float: vecOrigin[3] = {0.0, 0.0, 0.0}, const Float: vecAngles[3] = {0.0, 0.0, 0.0})
{
   new iWeapon;

   static iszAllocStringCached;
   if (iszAllocStringCached || (iszAllocStringCached = engfunc(EngFunc_AllocString, WEAPON_REFERANCE)))
   {
      iWeapon = engfunc(EngFunc_CreateNamedEntity, iszAllocStringCached);
   }
   
   if (!IsValidPev(iWeapon))
   {
      return FM_NULLENT;
   }
   
   MDLL_Spawn(iWeapon);
   SET_ORIGIN(iWeapon, vecOrigin);
   
   set_pdata_int(iWeapon, m_iClip, WEAPON_MAX_CLIP, extra_offset_weapon);

   set_pev(iWeapon, pev_impulse, g_iszWeaponKey);
   set_pev(iWeapon, pev_angles, vecAngles);
   
   Weapon_OnSpawn(iWeapon);
   
   return iWeapon;
}

Weapon_Give(const iPlayer)
{
   if (!IsValidPev(iPlayer))
   {
      return FM_NULLENT;
   }
   
   new iWeapon, Float: vecOrigin[3];
   pev(iPlayer, pev_origin, vecOrigin);
   
   if ((iWeapon = Weapon_Create(vecOrigin)) != FM_NULLENT)
   {
      Player_DropWeapons(iPlayer, ExecuteHamB(Ham_Item_ItemSlot, iWeapon));
      
      set_pev(iWeapon, pev_spawnflags, pev(iWeapon, pev_spawnflags) | SF_NORESPAWN);
      MDLL_Touch(iWeapon, iPlayer);
      
      set_pdata_int(iWeapon, m_iCurrentMode , 0 , extra_offset_weapon);
      SetAmmoInventory(iPlayer, PrimaryAmmoIndex(iWeapon), WEAPON_DEFAULT_AMMO);
      
      return iWeapon;
   }
   
   return FM_NULLENT;
}

Player_DropWeapons(const iPlayer, const iSlot)
{
   new szWeaponName[32], iItem = get_pdata_cbase(iPlayer, m_rgpPlayerItems_CBasePlayer + iSlot, extra_offset_player);

   while (IsValidPev(iItem))
   {
      pev(iItem, pev_classname, szWeaponName, charsmax(szWeaponName));
      engclient_cmd(iPlayer, "drop", szWeaponName);

      iItem = get_pdata_cbase(iItem, m_pNext, extra_offset_weapon);
   }
}

Weapon_SendAnim(const iPlayer, const iAnim)
{
   set_pev(iPlayer, pev_weaponanim, iAnim);

   MESSAGE_BEGIN(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, {0.0, 0.0, 0.0}, iPlayer);
   WRITE_BYTE(iAnim);
   WRITE_BYTE(0);
   MESSAGE_END();
}

bool: CheckItem(const iItem, &iPlayer)
{
   if (!IsValidPev(iItem) || !IsCustomItem(iItem))
   {
      return false;
   }
   
   iPlayer = get_pdata_cbase(iItem, m_pPlayer, extra_offset_weapon);
   
   if (!IsValidPev(iPlayer))
   {
      return false;
   }
   
   return true;
}

//**********************************************
//* Decals.                                    *
//**********************************************

#define INSTANCE(%0) ((%0 == -1) ? 0 : %0)

new Array: g_hDecals;

public FakeMeta_DecalIndex_Post()
{
   if (!g_hDecals)
   {
      g_hDecals = ArrayCreate(1, 1);
   }
   
   ArrayPushCell(g_hDecals, get_orig_retval());
}

UTIL_GunshotDecalTrace(const iTrace, const bool: bIsGunshot = false)
{
   static iHit;
   static iMessage;
   static iDecalIndex;
   
   static Float: flFraction; 
   static Float: vecEndPos[3];
   
   iHit = INSTANCE(get_tr2(iTrace, TR_pHit));
   
   if (iHit  && !IsValidPev(iHit) || (pev(iHit, pev_flags) & FL_KILLME))
   {
      return;
   }
   
   if (pev(iHit, pev_solid) != SOLID_BSP && pev(iHit, pev_movetype) != MOVETYPE_PUSHSTEP)
   {
      return;
   }
   
   iDecalIndex = ExecuteHamB(Ham_DamageDecal, iHit, 0);
   
   if (iDecalIndex < 0 || iDecalIndex >=  ArraySize(g_hDecals))
   {
      return;
   }
   
   iDecalIndex = ArrayGetCell(g_hDecals, iDecalIndex);
   
   get_tr2(iTrace, TR_flFraction, flFraction);
   get_tr2(iTrace, TR_vecEndPos, vecEndPos);
   
   if (iDecalIndex < 0 || flFraction >= 1.0)
   {
      return;
   }
   
   if (bIsGunshot)
   {
      iMessage = TE_GUNSHOTDECAL;
   }
   else
   {
      iMessage = TE_DECAL;
      
      if (iHit != 0)
      {
         if (iDecalIndex > 255)
         {
            iMessage = TE_DECALHIGH;
            iDecalIndex -= 256;
         }
      }
      else
      {
         iMessage = TE_WORLDDECAL;
         
         if (iDecalIndex > 255)
         {
            iMessage = TE_WORLDDECALHIGH;
            iDecalIndex -= 256;
         }
      }
   }
   
   MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, vecEndPos, 0);
   WRITE_BYTE(iMessage);
   WRITE_COORD(vecEndPos[0]);
   WRITE_COORD(vecEndPos[1]);
   WRITE_COORD(vecEndPos[2]);
   
   if (bIsGunshot)
   {
      WRITE_SHORT(iHit);
      WRITE_BYTE(iDecalIndex);
   }
   else 
   {
      WRITE_BYTE(iDecalIndex);
      
      if (iHit)
      {
         WRITE_SHORT(iHit);
      }
   }
    
   MESSAGE_END();
}

//**********************************************
//* Get and precache sounds from weapon model. *
//**********************************************

PrecacheSoundsFromModel(const szModelPath[])
{
   new iFile;
   
   if ((iFile = fopen(szModelPath, "rt")))
   {
      new szSoundPath[64];
      
      new iNumSeq, iSeqIndex;
      new iEvent, iNumEvents, iEventIndex;
      
      fseek(iFile, 164, SEEK_SET);
      fread(iFile, iNumSeq, BLOCK_INT);
      fread(iFile, iSeqIndex, BLOCK_INT);
      
      for (new k, i = 0; i < iNumSeq; i++)
      {
         fseek(iFile, iSeqIndex + 48 + 176 * i, SEEK_SET);
         fread(iFile, iNumEvents, BLOCK_INT);
         fread(iFile, iEventIndex, BLOCK_INT);
         fseek(iFile, iEventIndex + 176 * i, SEEK_SET);

         for (k = 0; k < iNumEvents; k++)
         {
            fseek(iFile, iEventIndex + 4 + 76 * k, SEEK_SET);
            fread(iFile, iEvent, BLOCK_INT);
            fseek(iFile, 4, SEEK_CUR);
            
            if (iEvent != 5004)
            {
               continue;
            }

            fread_blocks(iFile, szSoundPath, 64, BLOCK_CHAR);
            
            if (strlen(szSoundPath))
            {
               strtolower(szSoundPath);
               PRECACHE_SOUND(szSoundPath);
            }
            
            // server_print(" * Sound: %s", szSoundPath);
         }
      }
   }
   
   fclose(iFile);
}

//**********************************************
//* Ammo Inventory.                            *
//**********************************************

PrimaryAmmoIndex(const iItem)
{
   return get_pdata_int(iItem, m_iPrimaryAmmoType, extra_offset_weapon);
}

GetAmmoInventory(const iPlayer, const iAmmoIndex)
{
   if (iAmmoIndex == -1)
   {
      return -1;
   }

   return get_pdata_int(iPlayer, m_rgAmmo_CBasePlayer + iAmmoIndex, extra_offset_player);
}

SetAmmoInventory(const iPlayer, const iAmmoIndex, const iAmount)
{
   if (iAmmoIndex == -1)
   {
      return 0;
   }

   set_pdata_int(iPlayer, m_rgAmmo_CBasePlayer + iAmmoIndex, iAmount, extra_offset_player);
   return 1;
}

stock wpn_get_gun_position(id, Float:fOrigin[ ], Float:add_forward=0.0, Float:add_right=0.0, Float:add_up=0.0)
{
   static Float:Angles[3],Float:ViewOfs[3], Float:vAngles[3]
   static Float:Forward[3], Float:Right[3], Float:Up[3]
   
   pev(id, pev_v_angle, vAngles)
   pev(id, pev_origin, fOrigin)
   pev(id, pev_view_ofs, ViewOfs)
   xs_vec_add(fOrigin, ViewOfs, fOrigin)
   
   pev(id, pev_angles, Angles)
   
   Angles[0]=vAngles[0]
   
   engfunc(EngFunc_MakeVectors, Angles)
   
   global_get(glb_v_forward, Forward)
   global_get(glb_v_right, Right)
   global_get(glb_v_up,  Up)
   
   xs_vec_mul_scalar(Forward, add_forward, Forward)
   xs_vec_mul_scalar(Right, add_right, Right)
   xs_vec_mul_scalar(Up, add_up, Up)
   
   fOrigin[0]=fOrigin[0]+Forward[0]+Right[0]+Up[0]
   fOrigin[1]=fOrigin[1]+Forward[1]+Right[1]+Up[1]
   fOrigin[2]=fOrigin[2]+Forward[2]+Right[2]+Up[2]
}