WeaponManager.c

Go to the documentation of this file.

class WeaponManager
{
  const float MAX_DROP_MAGAZINE_DISTANCE_SQ = 4;
 
  protected PlayerBase m_player;
 
  protected int m_LastAcknowledgmentID;
 
  protected int m_PendingWeaponActionAcknowledgmentID;
  protected Magazine m_PendingTargetMagazine;
  protected ref InventoryLocation m_TargetInventoryLocation;
  protected int m_PendingWeaponAction;
  protected ref InventoryLocation m_PendingInventoryLocation;
 
  protected bool m_canEnd;
  protected bool m_justStart;
  protected bool m_InProgress;
  protected bool m_IsEventSended;
  protected bool m_WantContinue;
  protected bool m_InIronSight;
  protected bool m_InOptic;
  protected bool m_readyToStart;
  protected Weapon_Base m_WeaponInHand;
  protected MagazineStorage m_MagazineInHand;
  protected ActionBase m_ControlAction;
  protected int m_ForceEjectBulletTimestamp;
 
  protected const int FORCE_EJECT_BULLET_TIMEOUT = 2000;
#ifdef DIAG_DEVELOPER
  protected int m_BurstOption;
#endif
  //Reload
  protected ref array<Magazine> m_MagazinePilesInInventory;
  protected ref array<MagazineStorage> m_MagazineStorageInInventory;
  protected ref array<Magazine> m_SuitableMagazines;
  protected Magazine m_PreparedMagazine;
 
  //Jamming
  protected float m_NewJamChance;
  protected bool m_WaitToSyncJamChance;
 
 
  protected int m_AnimationRefreshCooldown;
 
  void WeaponManager(PlayerBase player)
  {
    m_ForceEjectBulletTimestamp = -1;
    m_player = player;
    m_PendingWeaponActionAcknowledgmentID = -1;
    m_PendingTargetMagazine = NULL;
    m_PendingInventoryLocation = NULL;
    m_WeaponInHand = NULL;
    m_MagazineInHand = NULL;
    m_ControlAction = NULL;
    m_PendingWeaponAction = -1;
    m_LastAcknowledgmentID = 1;
    m_InProgress = false;
    m_WantContinue = true;
    m_IsEventSended = false;
    m_canEnd = false;
    m_readyToStart = false;
    m_AnimationRefreshCooldown = 0;
 
    m_NewJamChance = -1;
    m_WaitToSyncJamChance = false;
 
    m_MagazinePilesInInventory = new array<Magazine>;
    m_MagazineStorageInInventory = new array<MagazineStorage>;
    m_SuitableMagazines = new array<Magazine>;
    m_PreparedMagazine = null;
 
#ifdef DEVELOPER
    m_BurstOption = 0;
#endif
  }
  //----------------------------------------------------------------------------
  // Weapon Action conditions
  //----------------------------------------------------------------------------
  bool CanFire(Weapon_Base wpn)
  {
    if (m_player.GetHumanInventory().GetEntityInHands() != wpn)
      return false;
 
    if (m_player.IsLiftWeapon() || !m_player.IsRaised() || wpn.IsDamageDestroyed() || m_player.GetDayZPlayerInventory().IsProcessing() || !m_player.IsWeaponRaiseCompleted() || m_player.IsFighting())
      return false;
 
    return true;
 
  }
 
 
  bool CanAttachMagazine(Weapon_Base wpn, Magazine mag, bool reservationCheck = true)
  {
    if (!wpn || !mag)
      return false;
 
    if (m_player.GetHumanInventory().GetEntityInHands() != wpn)
      return false;
 
    if (wpn.IsDamageDestroyed())
      return false;
 
    //if ( mag.GetHierarchyRootPlayer() && mag.GetHierarchyRootPlayer() != m_player )
    //return false;
 
    if (m_player.IsItemsToDelete())
      return false;
 
    if (reservationCheck && (m_player.GetInventory().HasInventoryReservation(wpn, null) || m_player.GetInventory().HasInventoryReservation(mag, null)))
      return false;
 
    InventoryLocation invLoc;
    invLoc = new InventoryLocation();
 
    mag.GetInventory().GetCurrentInventoryLocation(invLoc);
    Weapon_Base wnp2;
 
 
    //magazine is already in weapon
    if (Class.CastTo(wnp2, invLoc.GetParent()))
      return false;
 
    int muzzleIndex = wpn.GetCurrentMuzzle();
 
    if (wpn.CanAttachMagazine(muzzleIndex, mag))
      return true;
 
    return false;
 
  }
  //---------------------------------------------------------------------------
 
  bool CanSwapMagazine(Weapon_Base wpn, Magazine mag, bool reservationCheck = true)
  {
    if (!wpn || !mag)
      return false;
 
    if (m_player.GetHumanInventory().GetEntityInHands() != wpn)
      return false;
 
    if (mag.IsDamageDestroyed() || wpn.IsDamageDestroyed())
      return false;
 
    //if ( mag.GetHierarchyRootPlayer() && mag.GetHierarchyRootPlayer() != m_player )
    //return false;
 
    if (m_player.IsItemsToDelete())
      return false;
 
    if (reservationCheck && (m_player.GetInventory().HasInventoryReservation(wpn, null) || m_player.GetInventory().HasInventoryReservation(mag, null)))
      return false;
 
 
    InventoryLocation invLoc;
    invLoc = new InventoryLocation();
 
    mag.GetInventory().GetCurrentInventoryLocation(invLoc);
    Weapon_Base wnp2;
 
    //second magazine is already in weapon
    if (Class.CastTo(wnp2, invLoc.GetParent()))
      return false;
 
    int muzzleIndex = wpn.GetCurrentMuzzle();
 
    Magazine mag2;
    if (!Class.CastTo(mag2, wpn.GetMagazine(muzzleIndex)))
      return false;
 
    if (GameInventory.CanSwapEntitiesEx(mag, mag2))
      return true;
 
    InventoryLocation il = new InventoryLocation();
 
    if (GameInventory.CanForceSwapEntitiesEx(mag, null, mag2, il))
      return true;
 
    return false;
  }
  //----------------------------------------------------------------------------
  bool CanDetachMagazine(Weapon_Base wpn, Magazine mag, bool reservationCheck = true)
  {
    if (!wpn || !mag)
      return false;
 
    if (m_player.GetHumanInventory().GetEntityInHands() != wpn)
      return false;
 
    if (mag.GetHierarchyParent() != wpn)
      return false;
 
    if (m_player.IsItemsToDelete())
      return false;
 
    if (reservationCheck && (m_player.GetInventory().HasInventoryReservation(wpn, null) || m_player.GetInventory().HasInventoryReservation(mag, null)))
      return false;
 
    return true;
  }
  //---------------------------------------------------------------------------
  bool CanLoadBullet(Weapon_Base wpn, Magazine mag, bool reservationCheck = true)
  {
    if (!wpn || !mag)
      return false;
 
    if (m_player.GetHumanInventory().GetEntityInHands() != wpn)
      return false;
 
    if (mag.IsDamageDestroyed() || wpn.IsDamageDestroyed())
      return false;
 
    if (wpn.IsJammed())
      return false;
 
    if (m_player.IsItemsToDelete())
      return false;
 
    if (reservationCheck && (m_player.GetInventory().HasInventoryReservation(wpn, null) || m_player.GetInventory().HasInventoryReservation(mag, null)))
      return false;
 
    for (int i = 0; i < wpn.GetMuzzleCount(); i++)
    {
      if (wpn.CanChamberBullet(i, mag))
        return true;
    }
 
    return false;
  }
  //---------------------------------------------------------------------------
  bool CanUnjam(Weapon_Base wpn, bool reservationCheck = true)
  {
    if (!wpn)
      return false;
 
    if (m_player.GetHumanInventory().GetEntityInHands() != wpn)
      return false;
 
    if (wpn.IsDamageDestroyed())
      return false;
 
    if (m_player.IsItemsToDelete())
      return false;
 
    if (reservationCheck && m_player.GetInventory().HasInventoryReservation(wpn, null))
      return false;
 
 
    if (!wpn.IsJammed(/*wpn.GetCurrentMuzzle()*/))
      return false;
 
    return true;
  }
 
  bool CanEjectBullet(Weapon_Base wpn, bool reservationCheck = true)
  {
    if (!wpn)
      return false;
 
    if (m_player.GetHumanInventory().GetEntityInHands() != wpn)
      return false;
 
    if (m_player.IsItemsToDelete())
      return false;
 
    if (reservationCheck && m_player.GetInventory().HasInventoryReservation(wpn, null))
      return false;
 
    if (!wpn.CanEjectBullet())
      return false;
 
    if (wpn.IsJammed(/*wpn.GetCurrentMuzzle()*/))
      return false;
 
    return true;
  }
 
  void SetEjectBulletTryTimestamp()
  {
    m_ForceEjectBulletTimestamp = GetGame().GetTime();
  }
  //----------------------------------------------------------------------------
  bool InventoryReservation(Magazine mag, InventoryLocation invLoc)
  {
    Weapon_Base weapon;
    InventoryLocation ilWeapon = new InventoryLocation();
    if (Weapon_Base.CastTo(weapon, m_player.GetItemInHands()))
    {
      weapon.GetInventory().GetCurrentInventoryLocation(ilWeapon);
      if (m_player.GetInventory().HasInventoryReservation(weapon, ilWeapon))
        return false;
      else
        m_player.GetInventory().AddInventoryReservationEx(weapon, ilWeapon, GameInventory.c_InventoryReservationTimeoutMS);
    }
 
    if (invLoc)
    {
      if (m_player.GetInventory().HasInventoryReservation(invLoc.GetItem(), invLoc))
      {
        m_player.GetInventory().ClearInventoryReservationEx(weapon, ilWeapon);
        return false;
      }
      else
        m_player.GetInventory().AddInventoryReservationEx(invLoc.GetItem(), invLoc, GameInventory.c_InventoryReservationTimeoutMS);
    }
 
    if (mag)
    {
      m_TargetInventoryLocation = new InventoryLocation();
      m_TargetInventoryLocation.SetAttachment(m_WeaponInHand, mag, InventorySlots.MAGAZINE);
 
      if (m_player.GetInventory().HasInventoryReservation(mag, m_TargetInventoryLocation))
        //if ( !m_player.GetInventory().AddInventoryReservationEx( mag, m_TargetInventoryLocation, GameInventory.c_InventoryReservationTimeoutMS) )
      {
        m_player.GetInventory().ClearInventoryReservationEx(weapon, ilWeapon);
        if (invLoc)
          m_player.GetInventory().ClearInventoryReservationEx(invLoc.GetItem(), invLoc);
        return false;
      }
      else
        m_player.GetInventory().AddInventoryReservationEx(mag, m_TargetInventoryLocation, GameInventory.c_InventoryReservationTimeoutMS);
    }
    m_PendingTargetMagazine = mag;
    m_PendingInventoryLocation = invLoc;
 
    return true;
  }
 
  //----------------------------------------------------------------------------
  // Weapon Actions
  //----------------------------------------------------------------------------
  bool AttachMagazine(Magazine mag, ActionBase control_action = NULL)
  {
    return StartAction(AT_WPN_ATTACH_MAGAZINE, mag, NULL, control_action);
  }
 
  bool DetachMagazine(InventoryLocation invLoc, ActionBase control_action = NULL)
  {
    return StartAction(AT_WPN_DETACH_MAGAZINE, NULL, invLoc, control_action);
  }
 
  bool SwapMagazine(Magazine mag, ActionBase control_action = NULL)
  {
    InventoryLocation il = new InventoryLocation();
    if (PrepareInventoryLocationForMagazineSwap(m_WeaponInHand, mag, il))
      return StartAction(AT_WPN_SWAP_MAGAZINE, mag, il, control_action);
    return false;
  }
 
  bool SwapMagazineEx(Magazine mag, InventoryLocation invLoc, ActionBase control_action = NULL)
  {
    return StartAction(AT_WPN_SWAP_MAGAZINE, mag, invLoc, control_action);
  }
 
  bool LoadBullet(Magazine mag, ActionBase control_action = NULL)
  {
    return StartAction(AT_WPN_LOAD_BULLET, mag, NULL, control_action);
  }
 
  bool LoadMultiBullet(Magazine mag, ActionBase control_action = NULL)
  {
    return StartAction(AT_WPN_LOAD_MULTI_BULLETS_START, mag, NULL, control_action);
  }
 
  void LoadMultiBulletStop()
  {
    if (m_InProgress) m_WantContinue = false;
  }
 
  bool Unjam(ActionBase control_action = NULL)
  {
    return StartAction(AT_WPN_UNJAM, NULL, NULL, control_action);
  }
 
  bool EjectBullet(ActionBase control_action = NULL)
  {
    return StartAction(AT_WPN_EJECT_BULLET, NULL, NULL, control_action);
  }
 
  bool CanEjectBulletVerified()
  {
    int mi = m_WeaponInHand.GetCurrentMuzzle();
    if (!m_WeaponInHand.IsChamberFiredOut(mi) && !m_WeaponInHand.IsChamberEmpty(mi))
    {
      int actual_time = GetGame().GetTime();
      if (actual_time - m_ForceEjectBulletTimestamp > FORCE_EJECT_BULLET_TIMEOUT)
        return false;
    }
    return true;
  }
 
  bool EjectBulletVerified(ActionBase control_action = NULL)
  {
    if (m_WeaponInHand)
    {
      int mi = m_WeaponInHand.GetCurrentMuzzle();
      if (!m_WeaponInHand.IsChamberFiredOut(mi) && !m_WeaponInHand.IsChamberEmpty(mi))
      {
        m_ForceEjectBulletTimestamp = GetGame().GetTime();
        return StartAction(AT_WPN_EJECT_BULLET, NULL, NULL, control_action);
      }
      else
        return StartAction(AT_WPN_EJECT_BULLET, NULL, NULL, control_action);
    }
    return false;
  }
 
  bool SetNextMuzzleMode()
  {
    return StartAction(AT_WPN_SET_NEXT_MUZZLE_MODE, NULL, NULL, NULL);
  }
 
  void Fire(Weapon_Base wpn)
  {
    int mi = wpn.GetCurrentMuzzle();
    if (wpn.IsChamberFiredOut(mi) || wpn.IsJammed() || wpn.IsChamberEmpty(mi))
    {
      wpn.ProcessWeaponEvent(new WeaponEventTrigger(m_player));
      return;
    }
 
    if (wpn.JamCheck(0))
      wpn.ProcessWeaponEvent(new WeaponEventTriggerToJam(m_player));
    else
      wpn.ProcessWeaponEvent(new WeaponEventTrigger(m_player));
  }
 
#ifdef DIAG_DEVELOPER
  int GetBurstOption()
  {
    return m_BurstOption;
  }
 
  void SetBurstOption(int value)
  {
    m_BurstOption = value;
  }
#endif
  //-------------------------------------------------------------------------------------
  // Synchronize - initialize from client side
  //-------------------------------------------------------------------------------------
 
  //Client
  private void Synchronize()
  {
    if (GetGame().IsClient())
    {
      m_PendingWeaponActionAcknowledgmentID = ++m_LastAcknowledgmentID;
      ScriptInputUserData ctx = new ScriptInputUserData;
 
      ctx.Write(INPUT_UDT_WEAPON_ACTION);
      ctx.Write(m_PendingWeaponAction);
      ctx.Write(m_PendingWeaponActionAcknowledgmentID);
 
 
      switch (m_PendingWeaponAction)
      {
      case AT_WPN_ATTACH_MAGAZINE:
      {
        ctx.Write(m_PendingTargetMagazine);
        break;
      }
      case AT_WPN_SWAP_MAGAZINE:
      {
        ctx.Write(m_PendingTargetMagazine);
        m_PendingInventoryLocation.WriteToContext(ctx);
        break;
      }
      case AT_WPN_DETACH_MAGAZINE:
      {
        m_PendingInventoryLocation.WriteToContext(ctx);
        break;
      }
      case AT_WPN_LOAD_BULLET:
      {
        ctx.Write(m_PendingTargetMagazine);
        break;
      }
      case AT_WPN_LOAD_MULTI_BULLETS_START:
      {
        ctx.Write(m_PendingTargetMagazine);
        break;
      }
      case AT_WPN_UNJAM:
      {
        break;
      }
      case AT_WPN_EJECT_BULLET:
      {
        break;
      }
      default:
        break;
      }
      ctx.Send();
      //if( !m_player.GetDayZPlayerInventory().HasLockedHands() )
      // m_player.GetDayZPlayerInventory().LockHands();
    }
  }
 
 
  void OnSyncJuncture(int pJunctureID, ParamsReadContext pCtx)
  {
    if (pJunctureID == DayZPlayerSyncJunctures.SJ_WEAPON_SET_JAMMING_CHANCE)
      pCtx.Read(m_NewJamChance);
    else
    {
      int AcknowledgmentID;
      pCtx.Read(AcknowledgmentID);
      if (AcknowledgmentID == m_PendingWeaponActionAcknowledgmentID)
      {
        if (pJunctureID == DayZPlayerSyncJunctures.SJ_WEAPON_ACTION_ACK_ACCEPT)
          m_readyToStart = true;
        else if (pJunctureID == DayZPlayerSyncJunctures.SJ_WEAPON_ACTION_ACK_REJECT)
        {
          if (m_PendingWeaponAction >= 0)
          {
            if (!(GetGame().IsServer() && GetGame().IsMultiplayer()))
            {
              InventoryLocation ilWeapon = new InventoryLocation();
              ItemBase weapon = m_player.GetItemInHands();
              weapon.GetInventory().GetCurrentInventoryLocation(ilWeapon);
              m_player.GetInventory().ClearInventoryReservationEx(m_player.GetItemInHands(), ilWeapon);
 
              if (m_PendingTargetMagazine)
                m_PendingTargetMagazine.GetInventory().ClearInventoryReservationEx(m_PendingTargetMagazine, m_TargetInventoryLocation);
 
              if (m_PendingInventoryLocation)
                m_player.GetInventory().ClearInventoryReservationEx(NULL, m_PendingInventoryLocation);
            }
            m_PendingWeaponActionAcknowledgmentID = -1;
            m_PendingTargetMagazine = NULL;
            m_PendingWeaponAction = -1;
            m_PendingInventoryLocation = NULL;
            m_InProgress = false;
          }
        }
      }
    }
  }
 
 
  //Server
  bool OnInputUserDataProcess(int userDataType, ParamsReadContext ctx)
  {
    Weapon_Base wpn;
    int mi;
    InventoryLocation il;
    int slotID;
    bool accepted = false;
    if (userDataType == INPUT_UDT_WEAPON_ACTION)
    {
      if (!ctx.Read(m_PendingWeaponAction))
        return false;
 
      if (!ctx.Read(m_PendingWeaponActionAcknowledgmentID))
        return false;
 
      if (m_PendingTargetMagazine)
      {
        GetGame().ClearJuncture(m_player, m_PendingTargetMagazine);
        m_PendingTargetMagazine = NULL;
      }
      m_InProgress = true;
      m_IsEventSended = false;
      Magazine mag = NULL;
 
      Weapon_Base.CastTo(wpn, m_player.GetItemInHands());
      if (wpn)
        mi = wpn.GetCurrentMuzzle();
 
      switch (m_PendingWeaponAction)
      {
      case AT_WPN_ATTACH_MAGAZINE:
      {
        if (!ctx.Read(mag))
          break;
 
        if (!mag || !wpn)
          break;
 
        slotID = wpn.GetSlotFromMuzzleIndex(mi);
        il = new InventoryLocation();
        il.SetAttachment(wpn, mag, slotID);
        if (GetGame().AddInventoryJunctureEx(m_player, mag, il, false, 10000))
          accepted = true;
 
        m_PendingTargetMagazine = mag;
        break;
      }
      case AT_WPN_SWAP_MAGAZINE:
      {
        if (!ctx.Read(mag))
          break;
 
        il = new InventoryLocation();
        if (!il.ReadFromContext(ctx))
          break;
 
        if (!mag || !wpn)
          break;
 
        if (!wpn.GetMagazine(mi))
          break;
 
        if (GetGame().AddActionJuncture(m_player, mag, 10000))
          accepted = true;
        m_PendingInventoryLocation = il;
        m_PendingTargetMagazine = mag;
 
        break;
      }
      case AT_WPN_DETACH_MAGAZINE:
      {
        il = new InventoryLocation();
        if (!il.ReadFromContext(ctx))
          break;
 
        if (!il.IsValid())
          break;
 
        if (!wpn)
          break;
 
        Magazine det_mag = wpn.GetMagazine(mi);
        mag = Magazine.Cast(il.GetItem());
        if (!det_mag || (mag != det_mag))
          break;
 
        if (GetGame().AddInventoryJunctureEx(m_player, il.GetItem(), il, true, 10000))
          accepted = true;
        m_PendingInventoryLocation = il;
        m_PendingTargetMagazine = mag;
        break;
      }
      case AT_WPN_LOAD_BULLET:
      {
        ctx.Read(mag);
 
        if (!mag)
          break;
 
        if (GetGame().AddActionJuncture(m_player, mag, 10000))
          accepted = true;
        m_PendingTargetMagazine = mag;
        break;
      }
      case AT_WPN_LOAD_MULTI_BULLETS_START:
      {
        ctx.Read(mag);
 
        if (!mag)
          break;
 
        if (GetGame().AddActionJuncture(m_player, mag, 10000))
          accepted = true;
        m_PendingTargetMagazine = mag;
        break;
      }
      case AT_WPN_UNJAM:
      {
        accepted = true;
        //Unjam();
        break;
      }
      case AT_WPN_EJECT_BULLET:
      {
        accepted = true;
        break;
      }
      case AT_WPN_SET_NEXT_MUZZLE_MODE:
      {
        accepted = true;
        break;
      }
      default:
        Error("unknown actionID=" + m_PendingWeaponAction);
        break;
      }
      DayZPlayerSyncJunctures.SendWeaponActionAcknowledgment(m_player, m_PendingWeaponActionAcknowledgmentID, accepted);
    }
 
    return accepted;
  }
 
  bool StartAction(int action, Magazine mag, InventoryLocation il, ActionBase control_action = NULL)
  {
    //if it is controled by action inventory reservation and synchronization provide action itself
    if (control_action)
    {
      m_ControlAction = ActionBase.Cast(control_action);
      m_PendingWeaponAction = action;
      m_InProgress = true;
      m_IsEventSended = false;
      m_PendingTargetMagazine = mag;
      m_PendingInventoryLocation = il;
      StartPendingAction();
 
      return true;
    }
 
 
    if (GetGame().IsMultiplayer() && GetGame().IsServer())
      return false;
 
    if (!ScriptInputUserData.CanStoreInputUserData())
      return false;
    if (!InventoryReservation(mag, il))
      return false;
 
    m_PendingWeaponAction = action;
    m_InProgress = true;
    m_IsEventSended = false;
 
    if (!GetGame().IsMultiplayer())
      m_readyToStart = true;
    else
      Synchronize();
 
    return true;
  }
 
  void StartPendingAction()
  {
    m_WeaponInHand = Weapon_Base.Cast(m_player.GetItemInHands());
    if (!m_WeaponInHand)
    {
      OnWeaponActionEnd();
      return;
    }
    switch (m_PendingWeaponAction)
    {
    case AT_WPN_ATTACH_MAGAZINE:
    {
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventAttachMagazine(m_player, m_PendingTargetMagazine));
      break;
    }
    case AT_WPN_SWAP_MAGAZINE:
    {
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventSwapMagazine(m_player, m_PendingTargetMagazine, m_PendingInventoryLocation));
      break;
    }
    case AT_WPN_DETACH_MAGAZINE:
    {
      Magazine mag = Magazine.Cast(m_PendingInventoryLocation.GetItem());
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventDetachMagazine(m_player, mag, m_PendingInventoryLocation));
      break;
    }
    case AT_WPN_LOAD_BULLET:
    {
      m_WantContinue = false;
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventLoad1Bullet(m_player, m_PendingTargetMagazine));
      break;
    }
    case AT_WPN_LOAD_MULTI_BULLETS_START:
    {
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventLoad1Bullet(m_player, m_PendingTargetMagazine));
      break;
    }
    case AT_WPN_LOAD_MULTI_BULLETS_END:
    {
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventContinuousLoadBulletEnd(m_player));
      break;
    }
    case AT_WPN_UNJAM:
    {
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventUnjam(m_player, NULL));
      break;
    }
    case AT_WPN_EJECT_BULLET:
    {
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventMechanism(m_player, NULL));
      break;
    }
    case AT_WPN_SET_NEXT_MUZZLE_MODE:
    {
      m_player.GetDayZPlayerInventory().PostWeaponEvent(new WeaponEventSetNextMuzzleMode(m_player, NULL));
      break;
    }
    default:
      m_InProgress = false;
      Error("unknown actionID=" + m_PendingWeaponAction);
    }
    m_IsEventSended = true;
    m_canEnd = false;
  }
 
  bool IsRunning()
  {
    return m_InProgress;
  }
 
  void SetRunning(bool value)
  {
    m_InProgress = value;
  }
 
  void Refresh()
  {
    OnWeaponActionEnd();
  }
 
  void Update(float deltaT)
  {
    if (m_WeaponInHand != m_player.GetItemInHands())
    {
      if (m_WeaponInHand)
      {
        m_SuitableMagazines.Clear();
        OnWeaponActionEnd();
      }
      m_WeaponInHand = Weapon_Base.Cast(m_player.GetItemInHands());
      if (m_WeaponInHand)
      {
        m_MagazineInHand = null;
        //SET new magazine
        SetSutableMagazines();
        m_WeaponInHand.SetSyncJammingChance(0);
      }
      m_AnimationRefreshCooldown = 0;
    }
 
    if (m_WeaponInHand)
    {
      if (m_AnimationRefreshCooldown)
      {
        m_AnimationRefreshCooldown--;
 
        if (m_AnimationRefreshCooldown == 0)
          RefreshAnimationState();
      }
 
      if (!GetGame().IsMultiplayer())
        m_WeaponInHand.SetSyncJammingChance(m_WeaponInHand.GetChanceToJam());
      else
      {
        if (m_NewJamChance >= 0)
        {
          m_WeaponInHand.SetSyncJammingChance(m_NewJamChance);
          m_NewJamChance = -1;
          m_WaitToSyncJamChance = false;
        }
        if (GetGame().IsServer() && !m_WaitToSyncJamChance)
        {
          float actual_chance_to_jam;
          actual_chance_to_jam = m_WeaponInHand.GetChanceToJam();
          if (Math.AbsFloat(m_WeaponInHand.GetSyncChanceToJam() - m_WeaponInHand.GetChanceToJam()) > 0.001)
          {
            DayZPlayerSyncJunctures.SendWeaponJamChance(m_player, m_WeaponInHand.GetChanceToJam());
            m_WaitToSyncJamChance = true;
          }
        }
      }
 
      if (m_readyToStart)
      {
        StartPendingAction();
        m_readyToStart = false;
        return;
      }
 
      if (!m_InProgress || !m_IsEventSended)
        return;
 
      if (m_canEnd)
      {
        if (m_WeaponInHand.IsIdle())
          OnWeaponActionEnd();
        else if (m_justStart)
        {
          m_InIronSight = m_player.IsInIronsights();
          m_InOptic = m_player.IsInOptics();
 
          if (m_InIronSight || m_InOptic)
          {
            //'RequestResetADSSync' can be called here, if ADS reset is desired
            m_player.ExitSights();
          }
 
          m_justStart = false;
        }
 
      }
      else
      {
        m_canEnd = true;
        m_justStart = true;
      }
    }
    else
    {
      if (m_MagazineInHand != m_player.GetItemInHands())
      {
        m_MagazineInHand = MagazineStorage.Cast(m_player.GetItemInHands());
        if (m_MagazineInHand)
          SetSutableMagazines();
      }
 
 
    }
  }
 
  void OnWeaponActionEnd()
  {
    if (!m_InProgress)
      return;
 
    if (!m_ControlAction)
    {
      if (GetGame().IsServer() && GetGame().IsMultiplayer())
      {
        if (m_PendingTargetMagazine)
          GetGame().ClearJuncture(m_player, m_PendingTargetMagazine);
      }
      else
      {
        InventoryLocation il = new InventoryLocation();
        il.SetHands(m_player, m_player.GetItemInHands());
        m_player.GetInventory().ClearInventoryReservationEx(m_player.GetItemInHands(), il);
 
        if (m_PendingTargetMagazine)
          m_player.GetInventory().ClearInventoryReservationEx(m_PendingTargetMagazine, m_TargetInventoryLocation);
 
        if (m_PendingInventoryLocation)
          m_player.GetInventory().ClearInventoryReservationEx(m_PendingInventoryLocation.GetItem(), m_PendingInventoryLocation);
      }
    }
 
    m_ControlAction = NULL;
    m_PendingWeaponAction = -1;
    m_PendingTargetMagazine = NULL;
    m_PendingInventoryLocation = NULL;
    m_TargetInventoryLocation = NULL;
    m_PendingWeaponActionAcknowledgmentID = -1;
    //m_WeaponInHand = NULL;
    m_InProgress = false;
    m_readyToStart = false;
    m_WantContinue = true;
 
  }
 
  void DelayedRefreshAnimationState(int delay)
  {
    if (m_WeaponInHand)
    {
      if (delay == 0)
        RefreshAnimationState();
      m_AnimationRefreshCooldown = delay;
    }
  }
 
  void RefreshAnimationState()
  {
    if (m_WeaponInHand)
    {
      WeaponStableState state = WeaponStableState.Cast(m_WeaponInHand.GetCurrentState());
 
      if (state)
      {
        HumanCommandWeapons hcw = m_player.GetCommandModifier_Weapons();
        if (hcw)
          hcw.SetInitState(state.m_animState);
      }
    }
  }
 
  bool WantContinue()
  {
    return m_WantContinue;
  }
 
  Magazine GetPreparedMagazine()
  {
    for (int i = 0; i < m_SuitableMagazines.Count(); i++)
    {
      if (!m_SuitableMagazines.Get(i) || m_SuitableMagazines.Get(i).IsRuined())
      {
        m_SuitableMagazines.Remove(i);
        i--;
        continue;
      }
      if (m_SuitableMagazines.Get(i).GetAmmoCount() > 0)
        return m_SuitableMagazines.Get(i);
    }
 
    return null;
  }
 
  Magazine GetNextPreparedMagazine(out int startIdx)
  {
    for (int i = startIdx; i < m_SuitableMagazines.Count(); i++)
    {
      if (m_SuitableMagazines.Get(i).GetAmmoCount() > 0)
      {
        startIdx = i;
        return m_SuitableMagazines.Get(i);
      }
    }
    return null;
  }
 
  void OnMagazineInventoryEnter(Magazine mag)
  {
    if (mag)
    {
      Weapon_Base weapon = Weapon_Base.Cast(mag.GetHierarchyParent());
 
      if (weapon)
        return;
    }
 
    int i;
    MagazineStorage sMag = MagazineStorage.Cast(mag);
    if (sMag)
    {
      for (i = 0; i < m_MagazineStorageInInventory.Count(); i++)
      {
        MagazineStorage s_mag_i = m_MagazineStorageInInventory[i];
        if (!s_mag_i)
        {
          m_MagazineStorageInInventory.RemoveOrdered(i);
          i--;
          continue;
        }
 
        if (CompareMagazinesSuitability(s_mag_i, sMag) < 0)
          break;
      }
      m_MagazineStorageInInventory.InsertAt(sMag, i);
 
      SetSutableMagazines(); //TODO optimalize
      return;
    }
 
    if (mag)
    {
 
      for (i = 0; i < m_MagazinePilesInInventory.Count(); i++)
      {
        Magazine mag_i = m_MagazinePilesInInventory[i];
        if (!mag_i)
        {
          m_MagazinePilesInInventory.RemoveOrdered(i);
          i--;
          continue;
        }
 
 
        if (CompareMagazinesSuitability(mag_i, mag) < 0)
          break;
      }
      m_MagazinePilesInInventory.InsertAt(mag, i);
      SetSutableMagazines(); //TODO optimalize
    }
 
  }
 
  void OnMagazineInventoryExit(Magazine mag)
  {
    m_SuitableMagazines.RemoveItem(mag);
 
    MagazineStorage sMag = MagazineStorage.Cast(mag);
    if (sMag)
    {
      m_MagazineStorageInInventory.RemoveItem(sMag);
      return;
    }
 
    if (mag)
      m_MagazinePilesInInventory.RemoveItem(mag);
  }
 
  void OnMagazineAttach(Magazine mag)
  {
    OnMagazineInventoryExit(mag);
  }
 
  void OnMagazineDetach(Magazine mag)
  {
    OnMagazineInventoryEnter(mag);
  }
 
  int CompareMagazinesSuitability(Magazine mag1, Magazine mag2)
  {
    return mag1.GetAmmoCount() - mag2.GetAmmoCount();
  }
 
  void SortMagazineAfterLoad()
  {
    array<MagazineStorage> magazines = new array<MagazineStorage>;
    array<Magazine> magazines_piles = new array<Magazine>;
    int low_mag1, high_mag1;
    int low_mag2, high_mag2;
    int i, j;
 
    for (i = 0; i < m_MagazineStorageInInventory.Count(); i++)
    {
      MagazineStorage mag = m_MagazineStorageInInventory.Get(i);
      mag.GetNetworkID(low_mag1, high_mag1);
      for (j = 0; j < magazines.Count(); j++)
      {
        magazines.Get(j).GetNetworkID(low_mag2, high_mag2);
        if (low_mag1 > low_mag2)
          break;
        else if (low_mag1 == low_mag2)
        {
          if (high_mag1 > high_mag2)
            break;
        }
      }
      magazines.InsertAt(mag, j);
    }
 
    m_MagazineStorageInInventory.Clear();
    m_MagazineStorageInInventory.Copy(magazines);
 
    for (i = 0; i < m_MagazinePilesInInventory.Count(); i++)
    {
      Magazine pile = m_MagazinePilesInInventory.Get(i);
      pile.GetNetworkID(low_mag1, high_mag1);
      for (j = 0; j < magazines_piles.Count(); j++)
      {
        magazines_piles.Get(j).GetNetworkID(low_mag2, high_mag2);
        if (low_mag1 > low_mag2)
          break;
        else if (low_mag1 == low_mag2)
        {
          if (high_mag1 > high_mag2)
            break;
        }
      }
      magazines_piles.InsertAt(pile, j);
    }
 
    m_MagazinePilesInInventory.Clear();
    m_MagazinePilesInInventory.Copy(magazines_piles);
 
    SetSutableMagazines();
  }
 
  void SetSutableMagazines()
  {
    m_SuitableMagazines.Clear();
    int i;
 
    if (m_WeaponInHand)
    {
      int mi = m_WeaponInHand.GetCurrentMuzzle();
 
      for (i = 0; i < m_MagazineStorageInInventory.Count(); i++)
      {
        MagazineStorage s_mag = m_MagazineStorageInInventory[i];
 
        if (!s_mag)
        {
          m_MagazineStorageInInventory.RemoveOrdered(i);
          i--;
          continue;
        }
 
        if (m_WeaponInHand.TestAttachMagazine(mi, s_mag, false, true))
          m_SuitableMagazines.Insert(s_mag);
      }
 
      for (i = 0; i < m_MagazinePilesInInventory.Count(); i++)
      {
        Magazine mag = m_MagazinePilesInInventory[i];
        if (!mag)
        {
          m_MagazinePilesInInventory.RemoveOrdered(i);
          i--;
          continue;
        }
 
        if (m_WeaponInHand.CanChamberFromMag(mi, mag))
          m_SuitableMagazines.Insert(mag);
      }
      //TODO m_MagazineStorageInInventory and m_MagazinePilesInInventory always sort
    }
    else if (m_MagazineInHand)
    {
      for (i = 0; i < m_MagazinePilesInInventory.Count(); i++)
      {
        Magazine m_mag = m_MagazinePilesInInventory[i];
        if (!m_mag)
        {
          m_MagazinePilesInInventory.RemoveOrdered(i);
          i--;
          continue;
        }
        if (m_MagazineInHand.IsCompatiableAmmo(m_mag))
          m_SuitableMagazines.Insert(m_mag);
      }
    }
    else
      m_PreparedMagazine = null;
 
  }
 
  void OnLiftWeapon()
  {
    if (m_WeaponInHand)
      m_WeaponInHand.ResetBurstCount();
  }
 
  string GetCurrentModeName()
  {
    if (m_WeaponInHand)
    {
      int mi = m_WeaponInHand.GetCurrentMuzzle();
      return m_WeaponInHand.GetCurrentModeName(mi);
    }
    return "";
  }
 
  bool PrepareInventoryLocationForMagazineSwap(notnull Weapon_Base wpn, notnull Magazine new_mag, out InventoryLocation new_il)
  {
    int muzzleIndex = wpn.GetCurrentMuzzle();
    Magazine old_mag = Magazine.Cast(wpn.GetMagazine(muzzleIndex));
    InventoryLocation temp = new InventoryLocation();
 
    if (old_mag)
    {
      bool result = GameInventory.CanSwapEntitiesEx(new_mag, old_mag);
      if (result)
      {
        new_mag.GetInventory().GetCurrentInventoryLocation(new_il);
        new_il.SetItem(old_mag);
      }
      else
      {
        result = GameInventory.CanForceSwapEntitiesEx(new_mag, null, old_mag, new_il);
        float dir[4];
        if (!result)
          new_il.SetGroundEx(old_mag, m_player.GetPosition(), dir);
      }
    }
    return true;
  }
}