Weapon_Base.c

Go to the documentation of this file.

 
class AbilityRecord
{
  int m_action; 
  int m_actionType; 
  void AbilityRecord(int a, int at) { m_action = a; m_actionType = at; }
};
 
enum WeaponWithAmmoFlags
{
  NONE = 0,
  CHAMBER = 1,
  CHAMBER_RNG = 2,
  CHAMBER_RNG_SPORADIC = 4,
  QUANTITY_RNG = 8,
  AMMO_MAG_RNG = 16,
  AMMO_CHAMBER_RNG = 32,
  MAX_CAPACITY_MAG = 64,
}
 
typedef FSMTransition<WeaponStateBase, WeaponEventBase, WeaponActionBase, WeaponGuardBase> WeaponTransition; 
 
class Weapon_Base extends Weapon
{
  const int SAMF_DEFAULT = WeaponWithAmmoFlags.CHAMBER | WeaponWithAmmoFlags.MAX_CAPACITY_MAG;
  const int SAMF_RNG = WeaponWithAmmoFlags.CHAMBER_RNG | WeaponWithAmmoFlags.QUANTITY_RNG;
 
  protected const float DEFAULT_DAMAGE_ON_SHOT = 0.05;
  protected ref array<ref AbilityRecord> m_abilities = new array<ref AbilityRecord>; 
  protected ref WeaponFSM m_fsm; 
  protected bool m_isJammed = false;
  protected bool m_LiftWeapon = false;
  protected bool m_BayonetAttached;
  protected bool m_ButtstockAttached;
  protected bool m_Charged = false;
  protected bool m_WeaponOpen = false;
  protected int m_BurstCount;
  protected int m_BayonetAttachmentIdx;
  protected int m_ButtstockAttachmentIdx;
  protected int m_weaponAnimState = -1; 
  protected int m_magazineSimpleSelectionIndex = -1;
  protected int m_weaponHideBarrelIdx = -1; //index in simpleHiddenSelections cfg array
  protected float m_DmgPerShot = 0; //default is set to zero, since C++ solution has been implemented. See 'damageBarrel' and 'barrelArmor' in configs.
  protected float m_WeaponLength;
  protected float m_WeaponLiftCheckVerticalOffset;
  protected float m_ShoulderDistance;
  protected vector m_LastLiftPosition;
  ref array<int> m_bulletSelectionIndex = new array<int>;
  ref array<float> m_DOFProperties;
  ref array<float> m_ChanceToJam = new array<float>;
  protected float m_ChanceToJamSync = 0;
  protected ref PropertyModifiers m_PropertyModifierObject;
  protected PhxInteractionLayers hit_mask = PhxInteractionLayers.CHARACTER | PhxInteractionLayers.BUILDING | PhxInteractionLayers.DOOR | PhxInteractionLayers.VEHICLE | PhxInteractionLayers.ROADWAY | PhxInteractionLayers.TERRAIN | PhxInteractionLayers.ITEM_SMALL | PhxInteractionLayers.ITEM_LARGE | PhxInteractionLayers.FENCE | PhxInteractionLayers.AI;
 
  void Weapon_Base()
  {
    //m_DmgPerShot    = ConfigGetFloat("damagePerShot");
    m_BayonetAttached = false;
    m_ButtstockAttached = false;
    m_BayonetAttachmentIdx = -1;
    m_ButtstockAttachmentIdx = -1;
    m_BurstCount = 0;
    m_DOFProperties = new array<float>;
 
    if (ConfigIsExisting("simpleHiddenSelections"))
    {
      TStringArray selectionNames = new TStringArray;
      ConfigGetTextArray("simpleHiddenSelections", selectionNames);
      m_weaponHideBarrelIdx = selectionNames.Find("hide_barrel");
      m_magazineSimpleSelectionIndex = selectionNames.Find("magazine");
 
      int bulletIndex = selectionNames.Find("bullet");
      if (bulletIndex != -1)
      {
        m_bulletSelectionIndex.Insert(bulletIndex);
 
        for (int i = 2; i < 100; i++)
        {
          bulletIndex = selectionNames.Find(string.Format("bullet%1", i));
          if (bulletIndex != -1)
            m_bulletSelectionIndex.Insert(bulletIndex);
          else
            break;
        }
      }
    }
 
    InitWeaponLength();
    InitWeaponLiftCheckVerticalOffset();
    InitShoulderDistance();
    InitDOFProperties(m_DOFProperties);
    if (GetGame().IsServer())
      InitReliability(m_ChanceToJam);
    InitStateMachine();
  }
 
  void InitStateMachine() { }
 
  override void EEInit()
  {
    super.EEInit();
 
    if (GetGame().IsServer())
      GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).Call(AssembleGun);
  }
 
  void SetInitialState(WeaponStableState initState)
  {
    m_fsm.SetInitialState(initState);
    SetCharged(!initState.IsDischarged());
    SetWeaponOpen(!initState.IsWeaponOpen());
    SetGroundAnimFrameIndex(initState.m_animState);
  }
 
  bool IsCharged()
  {
    return m_Charged;
  }
 
  void SetCharged(bool value)
  {
    m_Charged = value;
  }
 
  bool IsWeaponOpen()
  {
    return m_WeaponOpen;
  }
 
  void SetWeaponOpen(bool value)
  {
    m_WeaponOpen = value;
  }
 
  override protected float GetWeightSpecialized(bool forceRecalc = false)
  {
    float baseWeight = GetInventoryAndCargoWeight(forceRecalc);
    float ammoWeight;
    float ammoDamage;
    string bulletTypeName, ammoTypeName;
 
    int muzzleCount = GetMuzzleCount();
#ifdef DEVELOPER
    if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
    {
      WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
      data1.SetCalcDetails("TWPN: " + m_ConfigWeight + "(item weight) + " + baseWeight + "(contents weight)");
    }
#endif
    for (int muzzleIndex = 0; muzzleIndex < muzzleCount; muzzleIndex++)
    {
      //chamber weight
      if (!IsChamberEmpty(muzzleIndex))
      {
        ammoTypeName = GetChamberAmmoTypeName(muzzleIndex);
        ammoWeight += g_Game.ConfigGetFloat(string.Format("CfgMagazines %1 weight", ammoTypeName));
 
#ifdef DEVELOPER
        if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
        {
          WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
          data2.AddCalcDetails(g_Game.ConfigGetFloat("CfgMagazines " + ammoTypeName + " weight").ToString() + "(chamber weight)");
        }
#endif
      }
 
      //correctly calculates internal magazine weight based on the ammo type of each bullet
      if (HasInternalMagazine(muzzleIndex))
      {
#ifdef DEVELOPER
        float debugInternalMagWeight;
#endif
        int cartridgeCount = GetInternalMagazineCartridgeCount(muzzleIndex);
        for (int cartridgeIndex = 0; cartridgeIndex < cartridgeCount; cartridgeIndex++)
        {
          GetInternalMagazineCartridgeInfo(muzzleIndex, cartridgeIndex, ammoDamage, bulletTypeName);
          ammoWeight += Ammunition_Base.GetAmmoWeightByBulletType(bulletTypeName);
#ifdef DEVELOPER
          debugInternalMagWeight += g_Game.ConfigGetFloat("CfgMagazines " + ammoTypeName + " weight");
#endif
        }
#ifdef DEVELOPER
 
        if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
        {
          WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
          data3.AddCalcDetails(debugInternalMagWeight.ToString() + "(internal mag weight)");
        }
#endif
      }
 
    }
    return ammoWeight + baseWeight + GetConfigWeightModified();
  }
  void AssembleGun();
 
  bool CanProcessAction(int action, int actionType)
  {
    return false; // @TODO
  }
  bool HasActionAbility(int action, int actionType)
  {
    int count = GetAbilityCount();
    for (int i = 0; i < count; ++i)
    {
      AbilityRecord rec = GetAbility(i);
      if (rec.m_action == action && rec.m_actionType == actionType)
        return true;
    }
    return false;
  }
  int GetAbilityCount() { return m_abilities.Count(); }
  AbilityRecord GetAbility(int index) { return m_abilities.Get(index); }
 
  bool CanProcessWeaponEvents() { return m_fsm && m_fsm.IsRunning(); }
 
  WeaponStateBase GetCurrentState() { return m_fsm.GetCurrentState(); }
 
  bool IsWaitingForActionFinish()
  {
    return CanProcessWeaponEvents() && GetCurrentState().IsWaitingForActionFinish();
  }
 
  bool IsIdle()
  {
    return CanProcessWeaponEvents() && GetCurrentState().IsIdle();
  }
 
  bool ProcessWeaponEvent(WeaponEventBase e)
  {
    SyncEventToRemote(e);
 
    // @NOTE: synchronous events not handled by fsm
    if (e.GetEventID() == WeaponEventID.SET_NEXT_MUZZLE_MODE)
    {
      SetNextMuzzleMode(GetCurrentMuzzle());
      return true;
    }
 
    if (m_fsm.ProcessEvent(e) == ProcessEventResult.FSM_OK)
      return true;
 
    //if (LogManager.IsWeaponLogEnable()) { wpnDebugPrint("FSM refused to process event (no transition): src=" + GetCurrentState().ToString() + " event=" + e.ToString()); }
    return false;
  }
  bool ProcessWeaponAbortEvent(WeaponEventBase e)
  {
    SyncEventToRemote(e);
 
    ProcessEventResult aa;
    m_fsm.ProcessAbortEvent(e, aa);
    return aa == ProcessEventResult.FSM_OK;
  }
 
  bool CanChamberBullet(int muzzleIndex, Magazine mag)
  {
    return CanChamberFromMag(muzzleIndex, mag) && (!IsChamberFull(muzzleIndex) || IsChamberFiredOut(muzzleIndex) || !IsInternalMagazineFull(muzzleIndex));
  }
 
  void SetWeaponAnimState(int state)
  {
    m_weaponAnimState = state;
    SetGroundAnimFrameIndex(state);
  }
  void ResetWeaponAnimState()
  {
    if (LogManager.IsWeaponLogEnable()) fsmDebugSpam("[wpnfsm] " + Object.GetDebugName(this) + " resetting anim state: " + typename.EnumToString(PistolAnimState, m_weaponAnimState) + " --> " + typename.EnumToString(PistolAnimState, -1));
    m_weaponAnimState = -1;
  }
  int GetWeaponAnimState() { return m_weaponAnimState; }
 
  void EEFired(int muzzleType, int mode, string ammoType)
  {
    if (!GetGame().IsDedicatedServer())
    {
      ItemBase suppressor = GetAttachedSuppressor();
 
      // Muzzle flash & overheating effects
      ItemBase.PlayFireParticles(this, muzzleType, ammoType, this, suppressor, "CfgWeapons");
      IncreaseOverheating(this, ammoType, this, suppressor, "CfgWeapons");
 
      if (suppressor)
      {
        ItemBase.PlayFireParticles(this, muzzleType, ammoType, suppressor, NULL, "CfgVehicles");
        suppressor.IncreaseOverheating(this, ammoType, this, suppressor, "CfgVehicles");
      }
    }
 
    //obsolete, replaced by C++ solution!
    /*
        if (GetGame().IsServer())
        {
          AddHealth("","Health",-m_DmgPerShot); //damages weapon
          if (suppressor)
            suppressor.AddHealth("","Health",-m_DmgPerShot); //damages suppressor; TODO add suppressor damage coeficient/parameter (?) to suppressors/weapons (?)
        }
    */
    //JamCheck(muzzleType);
 
#ifdef DIAG_DEVELOPER
    MiscGameplayFunctions.UnlimitedAmmoDebugCheck(this);
#endif
  }
 
  bool JamCheck(int muzzleIndex)
  {
    PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
    if (player)
    {
      float rnd = player.GetRandomGeneratorSyncManager().GetRandom01(RandomGeneratorSyncUsage.RGSJam);
      //Print("Random Jam - " + rnd);
      if (rnd < GetSyncChanceToJam())
        return true;
    }
    return false;
  }
 
  void ShowBullet(int muzzleIndex)
  {
    if (m_bulletSelectionIndex.Count() > muzzleIndex)
      SetSimpleHiddenSelectionState(m_bulletSelectionIndex[muzzleIndex], 1);
    else
      SelectionBulletShow();
  }
 
  void HideBullet(int muzzleIndex)
  {
    if (m_bulletSelectionIndex.Count() > muzzleIndex)
      SetSimpleHiddenSelectionState(m_bulletSelectionIndex[muzzleIndex], 0);
    else
      SelectionBulletHide();
  }
 
  bool IsJammed() { return m_isJammed; }
  bool CanEjectBullet() {return true;}
  void SetJammed(bool value) { m_isJammed = value; }
  float GetSyncChanceToJam() { return m_ChanceToJamSync; }
  float GetChanceToJam()
  {
    int level = GetHealthLevel();
 
    if (level >= 0 && level < m_ChanceToJam.Count())
      return m_ChanceToJam[level];
    else
      return 0.0;
  }
 
  void SyncSelectionState(bool has_bullet, bool has_mag)
  {
    if (has_bullet)
    {
      string chamberedAmmoTypeName;
      float chamberedAmmoDmg;
 
      if (GetCartridgeInfo(0, chamberedAmmoDmg, chamberedAmmoTypeName))
        EffectBulletShow(0, chamberedAmmoDmg, chamberedAmmoTypeName);
      //ShowBullet(0);
      SelectionBulletShow();
    }
    else
    {
      //HideBullet(0);
      SelectionBulletHide();
      EffectBulletHide(0);
    }
 
    if (has_mag)
      ShowMagazine();
    else
      HideMagazine();
  }
 
  /*override void EEOnAfterLoad()
    {
    super.EEOnAfterLoad();
 
    string chamberedAmmoTypeName;
    float chamberedAmmoDmg;
 
    if ( GetCartridgeInfo(0, chamberedAmmoDmg, chamberedAmmoTypeName) )
    {
      EffectBulletShow(0, chamberedAmmoDmg, chamberedAmmoTypeName);
    }
 
    }*/
 
  void ForceSyncSelectionState()
  {
    int nMuzzles = GetMuzzleCount();
    for (int i = 0; i < nMuzzles; ++i)
    {
      if (IsChamberFull(i))
      {
        ShowBullet(i);
        float damage;
        string ammoTypeName;
        GetCartridgeInfo(i, damage, ammoTypeName);
        EffectBulletShow(i, damage, ammoTypeName);
      }
      else
      {
        HideBullet(i);
        EffectBulletHide(i);
      }
 
      Magazine mag = GetMagazine(i);
      if (mag)
        ShowMagazine();
      else
        HideMagazine();
    }
  }
 
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    if (!super.OnStoreLoad(ctx, version))
      return false;
 
 
    if (version >= 113)
    {
      int current_muzzle = 0;
      if (!ctx.Read(current_muzzle))
      {
        Error("Weapon.OnStoreLoad " + this + " cannot read current muzzle!");
        return false;
      }
 
      if (current_muzzle >= GetMuzzleCount() || current_muzzle < 0)
        Error("Weapon.OnStoreLoad " + this + " trying to set muzzle index " + current_muzzle + " while it only has " + GetMuzzleCount() + " muzzles!");
      else
        SetCurrentMuzzle(current_muzzle);
    }
 
    if (version >= 105)
    {
      int mode_count = 0;
      if (!ctx.Read(mode_count))
      {
        Error("Weapon.OnStoreLoad " + this + " cannot read mode count!");
        return false;
      }
 
      for (int m = 0; m < mode_count; ++m)
      {
        int mode = 0;
        if (!ctx.Read(mode))
        {
          Error("Weapon.OnStoreLoad " + this + " cannot read mode[" + m + "]");
          return false;
        }
 
        if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " OnStoreLoad - loaded muzzle[" + m + "].mode = " + mode);
        SetCurrentMode(m, mode);
      }
    }
 
    if (version >= 106)
    {
      if (!ctx.Read(m_isJammed))
      {
        Error("Weapon.OnStoreLoad cannot load jamming state");
        return false;
      }
    }
 
    if (m_fsm)
    {
      if (!m_fsm.OnStoreLoad(ctx, version))
        return false;
 
      WeaponStableState wss = WeaponStableState.Cast(m_fsm.GetCurrentState());
      if (wss)
        SetGroundAnimFrameIndex(wss.m_animState);
 
    }
    else
    {
      int dummy = 0;
      if (!ctx.Read(dummy))
        return false;
    }
 
    return true;
  }
 
  void SaveCurrentFSMState(ParamsWriteContext ctx)
  {
    if (m_fsm && m_fsm.IsRunning())
    {
      if (m_fsm.SaveCurrentFSMState(ctx))
      {
        if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " state saved.");
      }
      else
        Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " state NOT saved.");
    }
    else
      Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon.SaveCurrentFSMState: trying to save weapon without FSM (or uninitialized weapon) this=" + this + " type=" + GetType());
  }
 
  bool LoadCurrentFSMState(ParamsReadContext ctx, int version)
  {
    if (m_fsm)
    {
      if (m_fsm.LoadCurrentFSMState(ctx, version))
      {
        WeaponStableState state = WeaponStableState.Cast(GetCurrentState());
        if (state)
        {
          SyncSelectionState(state.HasBullet(), state.HasMagazine());
          state.SyncAnimState();
          if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " stable state loaded and synced.");
          return true;
        }
        else
        {
          if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " unstable/error state loaded.");
          return false;
        }
      }
      else
      {
        Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " did not load.");
        return false;
      }
    }
    else
    {
      Error("[wpnfsm] " + Object.GetDebugName(this) + " Weapon.LoadCurrentFSMState: trying to load weapon without FSM (or uninitialized weapon) this=" + this + " type=" + GetType());
      return false;
    }
  }
 
  override void AfterStoreLoad()
  {
    if (m_fsm)
    {
      int mi = GetCurrentMuzzle();
      Magazine mag = GetMagazine(mi);
      bool has_mag = mag != null;
      bool has_bullet = !IsChamberEmpty(mi);
      SyncSelectionState(has_bullet, has_mag);
    }
  }
 
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    // current muzzle added in version 113
    int current_muzzle = GetCurrentMuzzle();
    ctx.Write(current_muzzle);
 
    // fire mode added in version 105
    int mode_count = GetMuzzleCount();
    ctx.Write(mode_count);
    for (int m = 0; m < mode_count; ++m)
      ctx.Write(GetCurrentMode(m));
 
    ctx.Write(m_isJammed);
 
    if (m_fsm)
      m_fsm.OnStoreSave(ctx);
    else
    {
      int dummy = 0;
      ctx.Write(dummy);
    }
  }
 
  int GetInternalStateID()
  {
    if (m_fsm)
      return m_fsm.GetInternalStateID();
    return 0;
  }
 
  int GetCurrentStableStateID()
  {
    if (m_fsm)
      return m_fsm.GetCurrentStableStateID();
    return 0;
  }
 
  void RandomizeFSMState()
  {
    if (m_fsm)
    {
      int mi = GetCurrentMuzzle();
      Magazine mag = GetMagazine(mi);
      bool has_mag = mag != null;
      bool has_bullet = !IsChamberEmpty(mi);
      bool has_jam = IsJammed();
      array<MuzzleState> muzzleStates = GetMuzzleStates();
      m_fsm.RandomizeFSMStateEx(muzzleStates, has_mag, has_jam);
      ForceSyncSelectionState();
    }
  }
 
  protected array<MuzzleState> GetMuzzleStates()
  {
    array<MuzzleState> muzzleStates = new array<MuzzleState>;
 
    int nMuzzles = GetMuzzleCount();
    for (int i = 0; i < nMuzzles; ++i)
    {
      MuzzleState state = MuzzleState.U;
      if (IsChamberFiredOut(i))
        state = MuzzleState.F;
      else if (IsChamberFull(i))
        state = MuzzleState.L;
      else if (IsChamberEmpty(i))
        state = MuzzleState.E;
      else
        ErrorEx(string.Format("Unable to identify chamber state of muzzle %1", i));
 
      muzzleStates.Insert(state);
    }
 
    return muzzleStates;
  }
 
 
  static Weapon_Base CreateWeaponWithAmmo(string weaponType, string magazineType = "", int flags = WeaponWithAmmoFlags.CHAMBER)
  {
    Weapon_Base wpn = Weapon_Base.Cast(GetGame().CreateObjectEx(weaponType, vector.Zero, ECE_PLACE_ON_SURFACE));
 
    if (!wpn)
    {
      ErrorEx(string.Format("%1 does not exist or is not a weapon.", weaponType));
      return null;
    }
 
    wpn.SpawnAmmo(magazineType, flags);
    return wpn;
  }
 
  bool SpawnAmmo(string magazineType = "", int flags = WeaponWithAmmoFlags.CHAMBER)
  {
    // Attempt internal mag
    if (HasInternalMagazine(-1) && FillInnerMagazine(magazineType, flags))
      return true;
 
    // Attempt mag attachment
    if (GetMagazineTypeCount(0) > 0 && SpawnAttachedMagazine(magazineType, flags))
      return true;
 
    // Attempt chamber
    if (FillChamber(magazineType, flags))
      return true;
 
    return false;
  }
 
  Magazine SpawnAttachedMagazine(string magazineType = "", int flags = WeaponWithAmmoFlags.CHAMBER)
  {
    // Check if the gun has any magazines registered in config
    if (GetMagazineTypeCount(0) == 0)
    {
      ErrorEx(string.Format("No 'magazines' config entry for %1.", this));
      return null;
    }
 
    // Randomize when no specific one is given
    if (magazineType == "")
    {
      if (flags & WeaponWithAmmoFlags.MAX_CAPACITY_MAG)
        magazineType = GetMaxMagazineTypeName(0);
      else
        magazineType = GetRandomMagazineTypeName(0);
    }
 
    EntityAI magAI = GetInventory().CreateAttachment(magazineType);
    if (!magAI)
    {
      ErrorEx(string.Format("Failed to create and attach %1 to %2", GetDebugName(magAI), this));
      return null;
    }
 
    Magazine mag;
    if (!CastTo(mag, magAI))
    {
      ErrorEx(string.Format("Expected magazine, created: %1", GetDebugName(magAI)));
      return null;
    }
 
    // Decide random quantity when enabled
    if (flags & WeaponWithAmmoFlags.QUANTITY_RNG)
      mag.ServerSetAmmoCount(Math.RandomIntInclusive(0, mag.GetAmmoMax()));
 
    // Fill chamber when flagged
    bool chamberRng = (flags & WeaponWithAmmoFlags.CHAMBER_RNG);
    bool chamber = (flags & WeaponWithAmmoFlags.CHAMBER) || chamberRng;
    if (chamber || chamberRng)
      FillChamber(magazineType, flags);
 
    // FSM cares about magazine state
    RandomizeFSMState();
    Synchronize();
 
    return mag;
  }
 
  bool FillInnerMagazine(string ammoType = "", int flags = WeaponWithAmmoFlags.CHAMBER)
  {
    // Don't try to fill it when there are none
    if (!HasInternalMagazine(-1))
      return false;
 
    // Make sure the given ammoType is actually useable
    if (ammoType != "")
    {
      if (!AmmoTypesAPI.MagazineTypeToAmmoType(ammoType, ammoType))
        return false;
    }
 
 
    bool didSomething = false;
    int muzzCount = GetMuzzleCount();
 
    bool ammoRng = ammoType == "";
    bool ammoFullRng = ammoRng && (flags & WeaponWithAmmoFlags.AMMO_MAG_RNG);
 
    // No full RNG flag, so pick one random and use only this one
    if (ammoRng && !ammoFullRng)
      ammoType = GetRandomChamberableAmmoTypeName(0);
 
    // Fill the internal magazine
    for (int i = 0; i < muzzCount; ++i)
    {
      int ammoCount = GetInternalMagazineMaxCartridgeCount(i);
 
      // Decide random quantity when enabled
      if (flags & WeaponWithAmmoFlags.QUANTITY_RNG)
        ammoCount = Math.RandomIntInclusive(0, ammoCount);
 
      // Only do the things when there is actually ammo to fill
      if (ammoCount > 0)
      {
        // Push in the cartridges
        for (int j = 0; j < ammoCount; ++j)
        {
          // Full random, decide a new one for every cartridge
          if (ammoFullRng)
            ammoType = GetRandomChamberableAmmoTypeName(i);
 
          PushCartridgeToInternalMagazine(i, 0, ammoType);
          didSomething = true;
        }
      }
    }
 
    // Call the chamber method if asked for
    bool chamber = (flags & WeaponWithAmmoFlags.CHAMBER) || (flags & WeaponWithAmmoFlags.CHAMBER_RNG);
    if (chamber && FillChamber(ammoType, flags))
      didSomething = true;
 
    // Does not need any FSM fixing, FSM does not care about inner magazines
 
    return didSomething;
  }
 
  bool FillChamber(string ammoType = "", int flags = WeaponWithAmmoFlags.CHAMBER)
  {
    // Quickly check if there are any chambers we can fill
    int muzzCount = GetMuzzleCount();
    bool anyEmpty = false;
 
    for (int m = 0; m < muzzCount; ++m)
    {
      if (IsChamberEmpty(m))
      {
        anyEmpty = true;
        break;
      }
    }
 
    if (!anyEmpty)
      return false;
 
    // Make sure the given ammoType is actually useable
    if (ammoType != "")
      if (!AmmoTypesAPI.MagazineTypeToAmmoType(ammoType, ammoType))
        return false;
 
    // Just so we don't '&' wastefully in a loop
    bool didSomething = false;
    bool chamberFullRng = (flags & WeaponWithAmmoFlags.CHAMBER_RNG_SPORADIC);
    bool chamberRng = (flags & WeaponWithAmmoFlags.CHAMBER_RNG);
    bool chamber = (flags & WeaponWithAmmoFlags.CHAMBER);
 
    if (chamber || chamberRng || chamberFullRng)
    {
      int amountToChamber = muzzCount;
 
      // No need to do this for full rng, as that will roll for every muzzle
      if (chamberRng)
        amountToChamber = Math.RandomIntInclusive(0, muzzCount);
 
      bool chamberAmmoRng = (ammoType == "");
      bool chamberAmmoFullRng = chamberAmmoRng && (flags & WeaponWithAmmoFlags.AMMO_CHAMBER_RNG);
 
      // No full RNG flag, so pick one random and use only this one
      if (chamberAmmoRng && !chamberAmmoFullRng)
        ammoType = GetRandomChamberableAmmoTypeName(0);
 
      for (int i = 0; i < muzzCount; ++i)
      {
        // Skip when there's already something in the chamber
        if (!IsChamberEmpty(i))
          continue;
 
        // Roll the rng when enabled
        if (chamberFullRng)
          chamber = Math.RandomIntInclusive(0, 1);
 
        // We chambering
        if (chamber)
        {
          // Full random, decide a new one for every muzzle
          if (chamberAmmoFullRng)
            ammoType = GetRandomChamberableAmmoTypeName(i);
 
          // Push it
          PushCartridgeToChamber(i, 0, ammoType);
          didSomething = true;
 
          // Stop chambering when we hit the desired amount
          --amountToChamber;
          if (amountToChamber <= 0)
            break;
        }
      }
    }
 
    // Only fix the FSM and Synchronize when absolutely needed
    if (!didSomething)
      return false;
 
    // FSM cares about chamber state
    RandomizeFSMState();
    Synchronize();
 
    return true;
  }
 
 
 
  override int GetSlotsCountCorrect()
  {
    int ac = GetInventory().AttachmentCount();
    int sc = GetInventory().GetAttachmentSlotsCount() + GetMuzzleCount();
    if (ac > sc) sc = ac; // fix of some weapons which has 1 attachments but 0 slots...
    return sc;
  };
 
  PropertyModifiers GetPropertyModifierObject()
  {
    if (!m_PropertyModifierObject)
      m_PropertyModifierObject = new PropertyModifiers(this);
    return m_PropertyModifierObject;
  }
 
  void OnFire(int muzzle_index)
  {
    /*
        array<Man> players();
        GetGame().GetPlayers(players);
 
        Man root = GetHierarchyRootPlayer();
 
        if (!root)
        {
          return;
        }
 
        vector safePosition = root.GetPosition() + (root.GetDirection() * "0 1 0" * 3.0);
 
        Man other = null;
        foreach (auto player : players)
        {
          if (player != GetHierarchyRootPlayer())
          {
            player.SetPosition(safePosition);
          }
        }
    */
 
    m_BurstCount++;
  }
 
  void OnFireModeChange(int fireMode)
  {
    if (!GetGame().IsDedicatedServer())
    {
      EffectSound eff;
 
      if (fireMode == 0)
        eff = SEffectManager.PlaySound("Fire_Mode_Switch_Marked_Click_SoundSet", GetPosition());
      else
        eff = SEffectManager.PlaySound("Fire_Mode_Switch_Simple_Click_SoundSet", GetPosition());
 
      eff.SetAutodestroy(true);
    }
 
    ResetBurstCount();
  }
 
  void ValidateAndRepair()
  {
    if (m_fsm)
      m_fsm.ValidateAndRepair();
  }
 
  override void OnInventoryEnter(Man player)
  {
    m_PropertyModifierObject = null;
 
    ValidateAndRepair();
 
    super.OnInventoryEnter(player);
  }
 
  override void OnInventoryExit(Man player)
  {
    m_PropertyModifierObject = null;
    super.OnInventoryExit(player);
  }
 
  override void EEItemAttached(EntityAI item, string slot_name)
  {
    super.EEItemAttached(item, slot_name);
 
    GetPropertyModifierObject().UpdateModifiers();
  }
 
  override void EEItemDetached(EntityAI item, string slot_name)
  {
    super.EEItemDetached(item, slot_name);
 
    GetPropertyModifierObject().UpdateModifiers();
  }
 
  override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
  {
    super.EEItemLocationChanged(oldLoc, newLoc);
 
    if (newLoc.GetType() == InventoryLocationType.HANDS)
    {
      PlayerBase player;
      if (newLoc.GetParent() && PlayerBase.CastTo(player, newLoc.GetParent()))
      {
        HumanCommandMove cm = player.GetCommand_Move();
        if (cm)
          cm.SetMeleeBlock(false);
      }
    }
  }
 
  override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
  {
    super.OnItemLocationChanged(old_owner, new_owner);
 
    // "resets" optics memory on optics
    PlayerBase player;
    if (PlayerBase.CastTo(player, old_owner))
    {
      player.SetReturnToOptics(false);
 
      //optics item state reset
      ItemOptics optics;
      if (Class.CastTo(optics, GetAttachedOptics()))
        player.SwitchOptics(optics, false);
    }
 
    HideWeaponBarrel(false);
  }
 
  override bool CanReleaseAttachment(EntityAI attachment)
  {
    if (!super.CanReleaseAttachment(attachment))
      return false;
    Magazine mag = Magazine.Cast(attachment);
    if (mag)
    {
      PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
      if (player)
      {
        if (player.GetItemInHands() == this)
          return true;
      }
      return false;
    }
 
    return true;
  }
 
  override bool CanRemoveFromHands(EntityAI parent)
  {
    if (IsIdle())
      return true;
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " Weapon=" + this + " not in stable state=" + GetCurrentState().Type());
    return false; // do not allow removal of weapon while weapon is busy
  }
 
  bool IsRemoteWeapon()
  {
    InventoryLocation il = new InventoryLocation;
    if (GetInventory().GetCurrentInventoryLocation(il))
    {
      EntityAI parent = il.GetParent();
      DayZPlayer dayzp = DayZPlayer.Cast(parent);
      if (il.GetType() == InventoryLocationType.HANDS && dayzp)
      {
        bool remote = dayzp.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE;
        return remote;
      }
    }
    return true;
  }
 
  void SyncEventToRemote(WeaponEventBase e)
  {
    DayZPlayer p = DayZPlayer.Cast(GetHierarchyParent());
    if (p && p.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
    {
      ScriptRemoteInputUserData ctx = new ScriptRemoteInputUserData();
 
      ctx.Write(INPUT_UDT_WEAPON_REMOTE_EVENT);
      e.WriteToContext(ctx);
 
      if (LogManager.IsWeaponLogEnable())
        wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(this) + " send 2 remote: sending e=" + e + " id=" + e.GetEventID() + " p=" + e.m_player + "  m=" + e.m_magazine);
 
      p.StoreInputForRemotes(ctx);
    }
  }
 
 
  RecoilBase SpawnRecoilObject()
  {
    return new DefaultRecoil(this);
  }
 
  int GetWeaponSpecificCommand(int weaponAction, int subCommand)
  {
    return subCommand;
  }
 
  bool CanFire()
  {
    if (!IsChamberEmpty(GetCurrentMuzzle()) && !IsChamberFiredOut(GetCurrentMuzzle()) && !IsJammed() && !m_LiftWeapon && !IsDamageDestroyed())
      return true;
    return false;
  }
 
  bool CanEnterIronsights()
  {
    ItemOptics optic = GetAttachedOptics();
    if (!optic)
      return true;
 
    return optic.HasWeaponIronsightsOverride();
  }
 
  bool InitDOFProperties(out array<float> temp_array)
  {
    if (GetGame().ConfigIsExisting("cfgWeapons " + GetType() + " PPDOFProperties"))
    {
      GetGame().ConfigGetFloatArray("cfgWeapons " + GetType() + " PPDOFProperties", temp_array);
      return true;
    }
    return false;
  }
 
  bool InitReliability(out array<float> reliability_array)
  {
    if (GetGame().ConfigIsExisting("cfgWeapons " + GetType() + " Reliability ChanceToJam"))
    {
      GetGame().ConfigGetFloatArray("cfgWeapons " + GetType() + " Reliability ChanceToJam", reliability_array);
      return true;
    }
    return false;
  }
 
  bool InitWeaponLength()
  {
    if (ConfigIsExisting("WeaponLength"))
    {
      m_WeaponLength = ConfigGetFloat("WeaponLength");
      return true;
    }
    m_WeaponLength = 0.8; //default value if not set in config; should not be zero
    return false;
  }
 
  bool InitWeaponLiftCheckVerticalOffset()
  {
    if (ConfigIsExisting("WeaponLiftCheckVerticalOffset"))
    {
      m_WeaponLiftCheckVerticalOffset = ConfigGetFloat("WeaponLiftCheckVerticalOffset");
      return true;
    }
    m_WeaponLiftCheckVerticalOffset = 0.0; //no offset by default
    return false;
  }
 
  protected bool InitShoulderDistance()
  {
    if (ConfigIsExisting("ShoulderDistance"))
    {
      m_ShoulderDistance = ConfigGetFloat("ShoulderDistance");
      return true;
    }
 
    m_ShoulderDistance = 0;
    return false;
  }
 
  ref array<float> GetWeaponDOF()
  {
    return m_DOFProperties;
  }
 
  // lifting weapon on obstcles
  bool LiftWeaponCheck(PlayerBase player)
  {
    int idx;
    float distance;
    float hit_fraction; //junk
    vector start, end;
    vector direction;
    vector usti_hlavne_position;
    vector trigger_axis_position;
    vector hit_pos, hit_normal; //junk
    Object obj;
    ItemBase attachment;
    HumanMovementState movementState = new HumanMovementState();
 
    bool wasLift = m_LiftWeapon;
    vector lastLiftPosition = m_LastLiftPosition;
 
    m_LiftWeapon = false;
    // not a gun, no weap.raise for now
    if (HasSelection("Usti hlavne"))
      return false;
 
    if (!player)
    {
      Print("Error: No weapon owner, returning");
      return false;
    }
 
    // weapon not raised
    player.GetMovementState(movementState);
    if (!movementState.IsRaised())
      return false;
 
    // suppress raising of weapon during melee attack preventing state inconsistency
    if (movementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_MELEE || movementState.m_CommandTypeId == DayZPlayerConstants.COMMANDID_MELEE2)
      return false;
 
    usti_hlavne_position = GetSelectionPositionLS("Usti hlavne"); // Usti hlavne
    trigger_axis_position = GetSelectionPositionLS("trigger_axis");
 
    // If possible use aiming angles instead as these will work consistently
    // and independently of any cameras, etc.
    HumanCommandWeapons hcw = player.GetCommandModifier_Weapons();
    if (hcw)
    {
      vector yawPitchRoll = Vector(
                              hcw.GetBaseAimingAngleLR() + player.GetOrientation()[0],
                              hcw.GetBaseAimingAngleUD(),
                              0.0);
      direction = yawPitchRoll.AnglesToVector();
    }
    else // Fallback to previously implemented logic
    {
      // freelook raycast
      if (player.GetInputController().CameraIsFreeLook())
      {
        if (player.m_DirectionToCursor != vector.Zero)
          direction = player.m_DirectionToCursor;
        // if player raises weapon in freelook
        else
          direction = MiscGameplayFunctions.GetHeadingVector(player);
      }
      else
      {
        direction = GetGame().GetCurrentCameraDirection(); // exception for freelook. Much better this way!
      }
    }
 
    idx = player.GetBoneIndexByName("Neck"); //RightHandIndex1
    if (idx == -1)
      start = player.GetPosition()[1] + 1.5;
    else
      start = player.GetBonePositionWS(idx);
 
 
    // Updated weapon lift detection code prototype
    {
      // 0: construct stable trasformation matrix that
      // approximately aligns with the weapon transform
      // without actually using the weapon as reference
      // (as the weapon can be moved unpredictably by anims)
      vector resTM[4];
      resTM[0] = Vector(direction[0], 0, direction[2]).Normalized();
      resTM[0] = vector.RotateAroundZeroDeg(resTM[0], vector.Up, 90);
      resTM[2] = direction;
      resTM[1] = resTM[2] * resTM[0];
      resTM[3] = start;
 
      // Approximate the roll of leaning
      HumanMovementState hms = new HumanMovementState();
      player.GetMovementState(hms);
      float leanAngle = hms.m_fLeaning * 35;
      vector rotTM[3];
      Math3D.YawPitchRollMatrix(Vector(0, 0, leanAngle), rotTM);
      Math3D.MatrixMultiply3(resTM, rotTM, resTM);
 
      // Draw relative TM diagnostic
#ifdef DIAG_DEVELOPER
      if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG))
      {
        Shape.CreateArrow(resTM[3], resTM[3] + resTM[0], 0.05, COLOR_RED, ShapeFlags.ONCE);
        Shape.CreateArrow(resTM[3], resTM[3] + resTM[1], 0.05, COLOR_GREEN, ShapeFlags.ONCE);
        Shape.CreateArrow(resTM[3], resTM[3] + resTM[2], 0.05, COLOR_BLUE, ShapeFlags.ONCE);
      }
#endif
 
      // 1: pick from predefined offset relative to
      // the previously constructed transform
      float udAngle = Math.Asin(direction[1]) * Math.RAD2DEG;
 
      // offsets are [right, up, forward]
      // values are based on what felt right after iterating
      vector offsets[] = {
        "0.11 0.17 0.0", // offset while aiming down
        "0.12 0.05 0.0", // offset while aiming forward
        "0.112 0.03 0.0" // offset while aiming up
      };
      const int lastIndex = 2; // length of offsets - 1
 
      // <0,1> range of aiming
      float a = Math.Clamp(Math.InverseLerp(DayZPlayerCamera1stPerson.CONST_UD_MIN, DayZPlayerCamera1stPerson.CONST_UD_MAX, udAngle), 0, 0.9999);
      int lo = a * lastIndex;
      int hi = Math.Clamp(lo + 1, 0, lastIndex);
 
      // remap to current lo-hi range
      float t = Math.Clamp(a * lastIndex - lo, 0, 1);
      vector offset = vector.Lerp(offsets[lo], offsets[hi], t);
 
      // offsets are [right, up forward]
      // additional offsets added to previous offsets per stance
      vector stanceOffsets[] = {
        "0 -0.015 0", // erect
        "0 0.03 0", // crouch
        "0 -0.04 0",// prone
      };
 
      // 2. pick from predefined offsets based on stance,
      // allows to even further approximate the alignment
      int stanceOffsetIndex = hms.m_iStanceIdx;
      if (stanceOffsetIndex >= DayZPlayerConstants.STANCEIDX_PRONE)
        stanceOffsetIndex -= DayZPlayerConstants.STANCEIDX_RAISED;
 
      stanceOffsetIndex -= DayZPlayerConstants.STANCEIDX_ERECT;
      offset += stanceOffsets[stanceOffsetIndex];
 
      // if any additional height offset is defined, apply it
      if (m_WeaponLiftCheckVerticalOffset != 0)
        offset[1] = offset[1] + m_WeaponLiftCheckVerticalOffset;
 
      // 3. use the offset as the start position.
      // it will not be perfect, but it should reflect
      // the actual weapon transform more accurately
      start = offset.Multiply4(resTM);
    }
 
    /*usti_hlavne_position = ModelToWorld(usti_hlavne_position);
      distance = vector.Distance(start,usti_hlavne_position);*/
    distance = m_WeaponLength + GetEffectiveAttachmentLength();
 
    vector weaponStart = start + (m_ShoulderDistance * direction);
    vector weaponEnd = weaponStart + (distance * direction);
 
    // Draw diagnostics: Script -> Weapon -> Weapon Lift
#ifdef DIAG_DEVELOPER
    if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG))
    {
      vector diagNoAttachEnd = weaponStart + (m_WeaponLength * direction);
      int diagPtsShpFlgs = ShapeFlags.ONCE | ShapeFlags.NOOUTLINE;
      float diagPtsRadius = 0.025;
      Shape.CreateSphere(COLOR_GREEN, diagPtsShpFlgs, weaponStart, diagPtsRadius);
      Shape.CreateSphere(COLOR_YELLOW, diagPtsShpFlgs, diagNoAttachEnd, diagPtsRadius);
      Shape.CreateSphere(COLOR_BLUE, diagPtsShpFlgs, weaponEnd, diagPtsRadius);
    }
#endif
 
    // For the physical cast, extend the distance by x%
    // to allow for smoother transition handling in some cases
    end = weaponEnd + ((0.1 * distance) * direction);
 
    // Prepare raycast params and perform the cast in fire geo
    RaycastRVParams rayParm = new RaycastRVParams(start, end, player, 0.04);
    rayParm.flags = CollisionFlags.ALLOBJECTS;
    rayParm.type = ObjIntersect.Fire;
 
    DbgUI.BeginCleanupScope();
    array<ref RaycastRVResult> results = {};
    if (!DayZPhysics.RaycastRVProxy(rayParm, results) || results.Count() == 0)
    {
      hit_pos = vector.Zero;
      hit_fraction = 0;
    }
    else
    {
      RaycastRVResult res = results[0];
 
#ifdef DIAG_DEVELOPER // isect diag
      if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG) == 2)
      {
        DbgUI.Begin("Weapon Lift Diag");
        {
          if (res.surface)
          {
            DbgUI.Text("Intersection data:");
            DbgUI.Text("  Name: " + res.surface.GetName());
            DbgUI.Text("  EntryName: " + res.surface.GetEntryName());
            DbgUI.Text("  SurfaceType: " + res.surface.GetSurfaceType());
 
            DbgUI.Text("  IsPassThrough: " + res.surface.IsPassthrough());
            DbgUI.Text("  IsSolid: " + res.surface.IsSolid());
          }
          else
            DbgUI.Text("Intersection with no surface");
        }
        DbgUI.End();
      }
#endif  // !isect diag
 
      if (LiftWeaponRaycastResultCheck(res))
      {
        hit_pos = res.pos;
        float len0 = (hit_pos - start).Length();
        float len1 = (end - start).Length();
        if (len0 <= 0 || len1 <= 0)
          hit_fraction = 1;
        else
          hit_fraction = len0 / len1;
      }
      else
      {
        hit_pos = vector.Zero;
        hit_fraction = 0;
      }
    }
 
    DbgUI.EndCleanupScope();
 
    // Draw diagnostics: Script -> Weapon -> Weapon Lift
#ifdef DIAG_DEVELOPER
    if (DiagMenu.GetValue(DiagMenuIDs.WEAPON_LIFT_DEBUG))
    {
      const vector epsilon = "0 0.0002 0"; // to overcome excessive z-fighting for diag
      if (lastLiftPosition != vector.Zero)
        Shape.CreateArrow(start - epsilon, lastLiftPosition - epsilon, 0.05, COLOR_YELLOW, ShapeFlags.ONCE);
 
      Shape.CreateArrow(start, weaponEnd, 0.05, COLOR_WHITE, ShapeFlags.ONCE | ShapeFlags.NOZBUFFER);
 
      if (hit_fraction != 0)
        Shape.CreateArrow(start + epsilon, hit_pos + epsilon, 0.05, COLOR_RED, ShapeFlags.ONCE);
    }
#endif
 
    // Start by assuming that we want to retain state
    bool wantsLift = wasLift;
 
    // Sq. distance of weapon movement required to trigger lift (in)
    const float inThreshold = 0.002;
    // Sq. distance of weapon movement required to trigger lift (out)
    const float outThreshold = 0.003;
    const float noIsctOutThreshold = 0.01;
 
    // Min angle in degrees change from last lift to stop lifting
    // Base threshold of 0.75 degrees + 0.6 degrees per meter of weapon length
    float angleThreshold = 0.75 + Math.Clamp(m_WeaponLength * 0.6, 0, 1.5);
 
    // Update state when a hit is registered
    if (hit_fraction != 0)
    {
      vector v1 = hit_pos - weaponEnd;
      vector v2 = hit_pos - end;
      float d = vector.Dot(v1, v2);
      // But leave some threshold where previous state is kept
      // to prevent excessive switches from occuring
      if (!wasLift && d > inThreshold)
        wantsLift = true;
      else if (wasLift && d < -outThreshold)
        wantsLift = false;
 
      m_LastLiftPosition = hit_pos;
    }
    else
    {
      // With no hit and no previous lift
      if (lastLiftPosition == vector.Zero)
      {
        wantsLift = false;
        m_LastLiftPosition = vector.Zero;
      }
      // See if previous hit wasn't very close to our current position,
      // in which case simply don't lift the weapon
      else
      {
        vector v3 = (lastLiftPosition - start).Normalized();
        vector v4 = (end - start).Normalized();
        float d2 = vector.Dot(v3, v4);
        // no isect, angle delta check
        if (Math.Acos(d2) > (angleThreshold * Math.DEG2RAD)) // if relative angle is > x degree, stop lifting
        {
          wantsLift = false;
          m_LastLiftPosition = vector.Zero;
        }
        // no isect, distance check
        else
        {
          float d3 = vector.Dot(lastLiftPosition - weaponEnd, (start - end).Normalized());
          if (d3 < -noIsctOutThreshold)
          {
            wantsLift = false;
            m_LastLiftPosition = vector.Zero;
          }
        }
      }
    }
 
    // lift is desired
    if (wantsLift)
    {
      //Print(distance);
      m_LiftWeapon = true;
      return true;
    }
    return false;
  }
 
  bool LiftWeaponRaycastResultCheck(notnull RaycastRVResult res)
  {
    return res.surface.IsSolid();
  }
 
  float GetEffectiveAttachmentLength()
  {
    ItemBase attachment;
    if (HasBayonetAttached())
    {
      int bayonetIndex = GetBayonetAttachmentIdx();
      attachment = ItemBase.Cast(GetInventory().FindAttachment(bayonetIndex));
    }
    else
      attachment = GetAttachedSuppressor();
 
    if (attachment)
      return Math.Max(attachment.m_ItemModelLength + attachment.m_ItemAttachOffset, 0);
    else
      return 0;
  }
 
  void SetSyncJammingChance(float jamming_chance)
  {
    m_ChanceToJamSync = jamming_chance;
  }
 
  bool EjectCartridge(int muzzleIndex, out float ammoDamage, out string ammoTypeName)
  {
    if (IsChamberEjectable(muzzleIndex))
    {
      if (PopCartridgeFromChamber(muzzleIndex, ammoDamage, ammoTypeName))
        return true;
    }
    else if (GetInternalMagazineCartridgeCount(muzzleIndex) > 0)
    {
      if (PopCartridgeFromInternalMagazine(muzzleIndex, ammoDamage, ammoTypeName))
        return true;
    }
    return false;
  }
 
  bool CopyWeaponStateFrom(notnull Weapon_Base src)
  {
    float damage = 0.0;
    string type;
 
    for (int mi = 0; mi < src.GetMuzzleCount(); ++mi)
    {
      if (!src.IsChamberEmpty(mi))
      {
        if (src.GetCartridgeInfo(mi, damage, type))
          PushCartridgeToChamber(mi, damage, type);
      }
 
      for (int ci = 0; ci < src.GetInternalMagazineCartridgeCount(mi); ++ci)
      {
        if (src.GetInternalMagazineCartridgeInfo(mi, ci, damage, type))
          PushCartridgeToInternalMagazine(mi, damage, type);
      }
    }
 
    int dummy_version = int.MAX;
    PlayerBase parentPlayer = PlayerBase.Cast(src.GetHierarchyRootPlayer());
    if (!parentPlayer)
      dummy_version -= 1;
    ScriptReadWriteContext ctx = new ScriptReadWriteContext;
    src.OnStoreSave(ctx.GetWriteContext());
    OnStoreLoad(ctx.GetReadContext(), dummy_version);
    return true;
  }
 
  override void SetBayonetAttached(bool pState, int slot_idx = -1)
  {
    m_BayonetAttached = pState;
    m_BayonetAttachmentIdx = slot_idx;
  }
 
  override bool HasBayonetAttached()
  {
    return m_BayonetAttached;
  }
 
  override int GetBayonetAttachmentIdx()
  {
    return m_BayonetAttachmentIdx;
  }
 
  override void SetButtstockAttached(bool pState, int slot_idx = -1)
  {
    m_ButtstockAttached = pState;
    m_ButtstockAttachmentIdx = slot_idx;
  }
 
  override bool HasButtstockAttached()
  {
    return m_ButtstockAttached;
  }
 
  override int GetButtstockAttachmentIdx()
  {
    return m_ButtstockAttachmentIdx;
  }
 
  void HideWeaponBarrel(bool state)
  {
    if (!GetGame().IsDedicatedServer()) //hidden for client only
    {
      ItemOptics optics = GetAttachedOptics();
      if (optics && !optics.AllowsDOF() && m_weaponHideBarrelIdx != -1)
        SetSimpleHiddenSelectionState(m_weaponHideBarrelIdx, !state);
    }
  }
 
  void ShowMagazine()
  {
    if (m_magazineSimpleSelectionIndex > -1)
      SetSimpleHiddenSelectionState(m_magazineSimpleSelectionIndex, 1);
    else
      SelectionMagazineShow();
  }
 
  void HideMagazine()
  {
    if (m_magazineSimpleSelectionIndex > -1)
      SetSimpleHiddenSelectionState(m_magazineSimpleSelectionIndex, 0);
    else
      SelectionMagazineHide();
  }
 
  override EntityAI ProcessMeleeItemDamage(int mode = 0)
  {
    EntityAI attachment;
 
    switch (mode)
    {
    case 0:
      super.ProcessMeleeItemDamage();
      break;
 
    case 1:
      attachment = GetInventory().FindAttachment(m_ButtstockAttachmentIdx);
      break;
 
    case 2:
      attachment = GetInventory().FindAttachment(m_BayonetAttachmentIdx);
      break;
 
    default:
      super.ProcessMeleeItemDamage();
      break;
    }
 
    if (attachment)
    {
      attachment.ProcessMeleeItemDamage();
      return attachment;
    }
 
    return this;
  }
 
  bool IsShowingChamberedBullet()
  {
    return true;
  }
 
  int GetBurstCount()
  {
    return m_BurstCount;
  }
 
  void ResetBurstCount()
  {
    m_BurstCount = 0;
  }
 
  override void SetActions()
  {
    super.SetActions();
    AddAction(FirearmActionUnjam);
    AddAction(FirearmActionAttachMagazine);
    AddAction(FirearmActionLoadBullet);
    AddAction(FirearmActionMechanicManipulate);
    AddAction(ActionTurnOnWeaponFlashlight);
    AddAction(ActionTurnOffWeaponFlashlight);
 
    AddAction(FirearmActionAttachMagazineQuick); // Easy reload
    AddAction(FirearmActionLoadBulletQuick); // Easy reload
  }
 
  override bool CanBeUsedForSuicide()
  {
    if (!ConfigGetBool("isSuicideWeapon"))
      return false;
 
    return super.CanBeUsedForSuicide();
  }
 
  //Debug menu Spawn Ground Special
  override void OnDebugSpawn()
  {
    SpawnAmmo("", SAMF_DEFAULT);
  }
};