DayZPlayerInventory.c

Go to the documentation of this file.

//Post event containers
class DeferredEvent
{
  InventoryMode m_mode;
  bool ReserveInventory(HumanInventory inventory) {return true;}
  void ClearInventoryReservation(HumanInventory inventory) {}
}
 
 
class DeferredTakeToDst : DeferredEvent
{
  ref InventoryLocation m_src;
  ref InventoryLocation m_dst;
 
  void DeferredTakeToDst(InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
  {
    m_mode = mode;
    m_src = src;
    m_dst = dst;
  }
 
  override bool ReserveInventory(HumanInventory inventory)
  {
    if (!inventory.AddInventoryReservationEx(m_dst.GetItem(), m_dst, GameInventory.c_InventoryReservationTimeoutShortMS))
      return false;
    return true;
  }
 
  override void ClearInventoryReservation(HumanInventory inventory)
  {
    inventory.ClearInventoryReservationEx(m_dst.GetItem(), m_dst);
  }
}
 
class DeferredSwapEntities : DeferredEvent
{
  EntityAI m_item1;
  EntityAI m_item2;
  ref InventoryLocation m_dst1;
  ref InventoryLocation m_dst2;
 
  void DeferredSwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation dst1, notnull InventoryLocation dst2)
  {
    m_mode = mode;
    m_item1 = item1;
    m_item2 = item2;
    m_dst1 = dst1;
    m_dst2 = dst2;
  }
 
  override bool ReserveInventory(HumanInventory inventory)
  {
    if (!inventory.AddInventoryReservationEx(m_item1, m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS))
      return false;
    if (!inventory.AddInventoryReservationEx(m_item2, m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS))
    {
      inventory.ClearInventoryReservationEx(m_item1, m_dst1);
      return false;
    }
    return true;
  }
 
  override void ClearInventoryReservation(HumanInventory inventory)
  {
    inventory.ClearInventoryReservationEx(m_item1, m_dst1);
    inventory.ClearInventoryReservationEx(m_item2, m_dst2);
  }
}
 
class DeferredForceSwapEntities : DeferredEvent
{
  EntityAI m_item1;
  EntityAI m_item2;
  ref InventoryLocation m_dst1;
  ref InventoryLocation m_dst2;
 
  void DeferredForceSwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation dst1, notnull InventoryLocation dst2)
  {
    m_mode = mode;
    m_item1 = item1;
    m_item2 = item2;
    m_dst1 = dst1;
    m_dst2 = dst2;
  }
 
  override bool ReserveInventory(HumanInventory inventory)
  {
    if (!inventory.AddInventoryReservationEx(m_item1, m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS))
      return false;
    if (!inventory.AddInventoryReservationEx(m_item2, m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS))
    {
      inventory.ClearInventoryReservationEx(m_item1, m_dst1);
      return false;
    }
    return true;
  }
 
  override void ClearInventoryReservation(HumanInventory inventory)
  {
    inventory.ClearInventoryReservationEx(m_item1, m_dst1);
    inventory.ClearInventoryReservationEx(m_item2, m_dst2);
  }
}
 
class DeferredHandEvent: DeferredEvent
{
  ref HandEventBase m_event;
  void DeferredHandEvent(InventoryMode mode, HandEventBase e)
  {
    m_mode = mode;
    m_event = e;
  }
 
  override bool ReserveInventory(HumanInventory inventory)
  {
    return m_event.ReserveInventory();
  }
 
  override void ClearInventoryReservation(HumanInventory inventory)
  {
    m_event.ClearInventoryReservation();
  }
}
 
 
class DayZPlayerInventory : HumanInventoryWithFSM
{
  ref DeferredEvent m_DeferredEvent = NULL;
  ref Timer m_DeferredWeaponTimer = new Timer;
  //protected ref HandEventBase m_PostedHandEvent = NULL; /// deferred hand event
 
 
  protected ref HandEventBase m_DeferredPostedHandEvent = NULL; 
  ref WeaponEventBase m_DeferredWeaponEvent = NULL; 
  // states with animations
  protected ref HandAnimatedTakingFromAtt m_Taking;
  protected ref HandAnimatedMovingToAtt m_MovingTo;
  protected ref HandAnimatedSwapping m_Swapping;
  protected ref HandAnimatedForceSwapping m_FSwapping;
  protected ref HandAnimatedForceSwapping_Inst m_FSwappingInst;
 
  void DayZPlayerInventory()
  {
  }
 
  DayZPlayer GetDayZPlayerOwner() { return DayZPlayer.Cast(GetInventoryOwner()); }
 
  bool IsAuthoritative()
  {
    DayZPlayer player;
    if (!Class.CastTo(player, GetInventoryOwner()))
      return false;
 
    return (player.GetInstanceType() != DayZPlayerInstanceType.INSTANCETYPE_CLIENT && player.GetInstanceType() != DayZPlayerInstanceType.INSTANCETYPE_REMOTE);
  }
 
  bool IsOwner()
  {
    DayZPlayer player;
    if (!Class.CastTo(player, GetInventoryOwner()))
      return false;
 
    return (player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT || player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_SERVER || player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_SINGLEPLAYER);
  }
 
  bool IsProxy()
  {
    DayZPlayer player;
    if (!Class.CastTo(player, GetInventoryOwner()))
      return false;
 
    return (player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE || player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_REMOTE);
  }
 
  override void Init()
  {
    if (LogManager.IsInventoryHFSMLogEnable())
      hndDebugPrint("[hndfsm] Creating DayZPlayer Inventory FSM");
 
    CreateStableStates(); // stable states needs to be created first
 
    m_Taking = new HandAnimatedTakingFromAtt(GetManOwner(), null);
    m_MovingTo = new HandAnimatedMovingToAtt(GetManOwner(), null);
    m_Swapping = new HandAnimatedSwapping(GetManOwner(), null);
    m_FSwapping = new HandAnimatedForceSwapping(GetManOwner(), null);
    m_FSwappingInst = new HandAnimatedForceSwapping_Inst(GetManOwner(), null);
 
    // events
    HandEventBase _fin_ = new HandEventHumanCommandActionFinished;
    HandEventBase _abt_ = new HandEventHumanCommandActionAborted;
    HandEventBase __T__ = new HandEventTake;
    HandEventBase __M__ = new HandEventMoveTo;
    HandEventBase __W__ = new HandEventSwap;
    //HandEventBase __D__ = new HandEventDropping;
    HandEventBase __Xd_ = new HandEventDestroyed;
    HandEventBase __F__ = new HandEventForceSwap;
 
    // setup transitions
    m_FSM.AddTransition(new HandTransition(m_Empty, __T__, m_Taking, NULL, new HandSelectAnimationOfTakeToHandsEvent(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_Taking, _fin_, m_Empty, null, new HandGuardNot(new HandGuardHasItemInHands(GetManOwner()))));
    m_FSM.AddTransition(new HandTransition(m_Taking, _fin_, m_Equipped, null, null));
    m_FSM.AddTransition(new HandTransition(m_Taking, __Xd_, m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
    m_Taking.AddTransition(new HandTransition(m_Taking.m_Hide, _abt_, m_Empty));
    m_Taking.AddTransition(new HandTransition(m_Taking.m_Show, _abt_, m_Equipped));
 
    m_FSM.AddTransition(new HandTransition(m_Equipped, __M__, m_MovingTo, NULL, new HandSelectAnimationOfMoveFromHandsEvent(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_MovingTo, __Xd_, m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_MovingTo, _fin_, m_Equipped, null, new HandGuardHasItemInHands(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_MovingTo, _fin_, m_Empty, null, null));
    m_MovingTo.AddTransition(new HandTransition(m_MovingTo.m_Hide, _abt_, m_Equipped));
    m_MovingTo.AddTransition(new HandTransition(m_MovingTo.m_Show, _abt_, m_Empty));
 
    m_FSM.AddTransition(new HandTransition(m_Equipped, __W__, m_Swapping, NULL, new HandSelectAnimationOfSwapInHandsEvent(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_Swapping, __Xd_, m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_Swapping, _fin_, m_Empty, null, new HandGuardNot(new HandGuardHasItemInHands(GetManOwner()))));
    m_FSM.AddTransition(new HandTransition(m_Swapping, _fin_, m_Equipped, null, null));
    m_FSM.AddTransition(new HandTransition(m_Swapping, _abt_, m_Equipped, null, null));
 
    m_FSM.AddTransition(new HandTransition(m_Equipped, __F__, m_FSwappingInst, NULL, new HandGuardAnd(new HandSelectAnimationOfForceSwapInHandsEvent(GetManOwner()), new HandGuardInstantForceSwap(GetManOwner()))));
    m_FSM.AddTransition(new HandTransition(m_FSwappingInst, _fin_, m_Equipped, null, new HandGuardHasItemInHands(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_FSwappingInst, _fin_, m_Empty, null, null));
    m_FSM.AddTransition(new HandTransition(m_FSwappingInst, __Xd_, m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_FSwappingInst, _abt_, m_Equipped, null, null));
 
    m_FSM.AddTransition(new HandTransition(m_Equipped, __F__, m_FSwapping, NULL, new HandSelectAnimationOfForceSwapInHandsEvent(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_FSwapping, _fin_, m_Equipped, null, new HandGuardHasItemInHands(GetManOwner())));
    m_FSM.AddTransition(new HandTransition(m_FSwapping, _fin_, m_Empty, null, null));
    m_FSM.AddTransition(new HandTransition(m_FSwapping, __Xd_, m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
    m_FSwapping.AddTransition(new HandTransition(m_FSwapping.m_Start, _abt_, m_Equipped));
    m_FSwapping.AddTransition(new HandTransition(m_FSwapping.m_Hide, _abt_, m_Empty));
    m_FSwapping.AddTransition(new HandTransition(m_FSwapping.m_Show, _abt_, m_Equipped));
 
    super.Init(); // initialize ordinary human fsm (no anims)
  }
 
  void CancelHandEvent()
  {
    m_DeferredPostedHandEvent = null;
    //m_postedHandEvent = null;
  }
 
  void CancelWeaponEvent()
  {
    m_DeferredWeaponEvent = null;
    m_DeferredWeaponTimer.Stop();
  }
 
  void AbortWeaponEvent()
  {
    HumanCommandWeapons hcw = GetDayZPlayerOwner().GetCommandModifier_Weapons();
 
    Weapon_Base weapon;
    Class.CastTo(weapon, GetEntityInHands());
 
    if (hcw && weapon && weapon.CanProcessWeaponEvents() && !weapon.IsIdle())
    {
      if (LogManager.IsWeaponLogEnable())
        wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: ABORT! notifying running state=" + weapon.GetCurrentState());
 
      weapon.ProcessWeaponAbortEvent(new WeaponEventHumanCommandActionAborted(GetDayZPlayerOwner()));
    }
  }
 
  void PostWeaponEvent(WeaponEventBase e)
  {
    if (m_DeferredWeaponEvent == NULL)
    {
      m_DeferredWeaponEvent = e;
 
      if (LogManager.IsWeaponLogEnable())
        wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(GetInventoryOwner()) + " Posted event m_DeferredWeaponEvent=" + m_DeferredWeaponEvent.DumpToString());
    }
    else
      Error("[wpnfsm] " + Object.GetDebugName(GetInventoryOwner()) + " warning - pending event already posted, curr_event=" + m_DeferredWeaponEvent.DumpToString() + " new_event=" + e.DumpToString());
  }
 
  void DeferredWeaponFailed()
  {
    Weapon_Base weapon;
    Class.CastTo(weapon, GetEntityInHands());
 
    string secondPart = " - ENTITY IN HANDS IS NOT A WEAPON: " + Object.GetDebugName(GetEntityInHands());
 
    string firstPart = "[wpnfsm] " + Object.GetDebugName(GetInventoryOwner()) + " failed to perform weaponevent " + m_DeferredWeaponEvent.DumpToString();
    if (weapon)
    {
      secondPart = " on " + Object.GetDebugName(GetEntityInHands()) + " which is in state " + weapon.GetCurrentState();
      secondPart += " with physical state: J: " + weapon.IsJammed() + " | ";
      for (int i = 0; i < weapon.GetMuzzleCount(); ++i)
      {
        secondPart += "Chamber_" + i + ": B(" + weapon.IsChamberFull(i) + ") F(" + weapon.IsChamberFiredOut(i) + ") E(" + weapon.IsChamberEmpty(i) + ") | ";
        secondPart += "Magazine_" + i + ": " + weapon.GetMagazine(i);
        if (i < weapon.GetMuzzleCount() - 1)
          secondPart += " | ";
      }
    }
 
    Error(firstPart + secondPart);
    CancelWeaponEvent();
  }
 
  void HandleWeaponEvents(float dt, out bool exitIronSights)
  {
    HumanCommandWeapons hcw = GetDayZPlayerOwner().GetCommandModifier_Weapons();
 
    Weapon_Base weapon;
    Class.CastTo(weapon, GetEntityInHands());
 
    if (hcw && weapon && weapon.CanProcessWeaponEvents())
    {
      weapon.GetCurrentState().OnUpdate(dt);
 
      if (LogManager.IsWeaponLogEnable())
        wpnDebugSpamALot("[wpnfsm] " + Object.GetDebugName(weapon) + " HCW: playing A=" + typename.EnumToString(WeaponActions, hcw.GetRunningAction()) + " AT=" + WeaponActionTypeToString(hcw.GetRunningAction(), hcw.GetRunningActionType()) + " fini=" + hcw.IsActionFinished());
 
      if (!weapon.IsIdle())
      {
        while (true)
        {
          int weaponEventId = hcw.IsEvent();
          if (weaponEventId == -1)
            break;
 
          if (weaponEventId == WeaponEvents.CHANGE_HIDE)
            break;
 
          WeaponEventBase anim_event = WeaponAnimEventFactory(weaponEventId, GetDayZPlayerOwner(), NULL);
 
          if (LogManager.IsWeaponLogEnable())
            wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " HandleWeapons: event arrived " + typename.EnumToString(WeaponEvents, weaponEventId) + "(" + weaponEventId + ")  fsm_ev=" + anim_event.ToString());
 
          if (anim_event != NULL)
            weapon.ProcessWeaponEvent(anim_event);
        }
 
        if (hcw.IsActionFinished())
        {
          if (weapon.IsWaitingForActionFinish())
          {
            if (LogManager.IsWeaponLogEnable())
              wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: finished! notifying waiting state=" + weapon.GetCurrentState());
 
            weapon.ProcessWeaponEvent(new WeaponEventHumanCommandActionFinished(GetDayZPlayerOwner()));
          }
          else
          {
            if (LogManager.IsWeaponLogEnable())
              wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: ABORT! notifying running state=" + weapon.GetCurrentState());
 
            weapon.ProcessWeaponAbortEvent(new WeaponEventHumanCommandActionAborted(GetDayZPlayerOwner()));
          }
        }
      }
 
      if (m_DeferredWeaponEvent)
      {
        if (LogManager.IsWeaponLogEnable())
          wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: deferred " + m_DeferredWeaponEvent.DumpToString());
 
        if (weapon.ProcessWeaponEvent(m_DeferredWeaponEvent))
        {
          exitIronSights = true;
 
          if (LogManager.IsWeaponLogEnable())
            fsmDebugSpam("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: resetting deferred event" + m_DeferredWeaponEvent.DumpToString());
 
          m_DeferredWeaponEvent = NULL;
          m_DeferredWeaponTimer.Stop();
        }
        else if (!m_DeferredWeaponTimer.IsRunning())
          m_DeferredWeaponTimer.Run(3, this, "DeferredWeaponFailed");
      }
    }
  }
 
  void HandleInventory(float dt)
  {
    HumanCommandWeapons hcw = GetDayZPlayerOwner().GetCommandModifier_Weapons();
 
    EntityAI ih = GetEntityInHands();
    Weapon_Base weapon;
    Class.CastTo(weapon, ih);
 
    if (hcw)
    {
      m_FSM.GetCurrentState().OnUpdate(dt);
 
#ifdef DEVELOPER
      if (LogManager.IsInventoryHFSMLogEnable())
        hndDebugSpamALot("[hndfsm] HCW: playing A=" + typename.EnumToString(WeaponActions, hcw.GetRunningAction()) + " AT=" + WeaponActionTypeToString(hcw.GetRunningAction(), hcw.GetRunningActionType()) + " fini=" + hcw.IsActionFinished());
#endif
 
      if (!m_FSM.GetCurrentState().IsIdle() || !m_FSM.IsRunning())
      {
        while (true)
        {
          int weaponEventId = hcw.IsEvent();
          if (weaponEventId == -1)
            break;
 
          HandEventBase anim_event = HandAnimEventFactory(weaponEventId, GetManOwner(), NULL);
 
#ifdef DEVELOPER
          if (LogManager.IsInventoryHFSMLogEnable())
            hndDebugPrint("[hndfsm] HandleInventory: event arrived " + typename.EnumToString(WeaponEvents, weaponEventId) + "(" + weaponEventId + ")  fsm_ev=" + anim_event.ToString());
#endif
 
          if (anim_event != NULL)
          {
            SyncHandEventToRemote(anim_event);
            ProcessHandEvent(anim_event);
          }
        }
 
        if (hcw.IsActionFinished())
        {
          if (m_FSM.GetCurrentState().IsWaitingForActionFinish())
          {
#ifdef DEVELOPER
            if (LogManager.IsInventoryHFSMLogEnable())
              hndDebugPrint("[hndfsm] Hand-Weapon event: finished! notifying waiting state=" + m_FSM.GetCurrentState());
#endif
 
            HandEventBase fin_event = new HandEventHumanCommandActionFinished(GetManOwner());
            SyncHandEventToRemote(fin_event);
            ProcessHandEvent(fin_event);
          }
          else
          {
#ifdef DEVELOPER
            if (LogManager.IsInventoryHFSMLogEnable())
              hndDebugPrint("[hndfsm] Hand-Weapon event: ABORT! notifying running state=" + m_FSM.GetCurrentState());
#endif
 
            HandEventBase abt_event = new HandEventHumanCommandActionAborted(GetManOwner());
            SyncHandEventToRemote(abt_event);
            ProcessHandAbortEvent(abt_event);
            //m_FSM.ProcessHandAbortEvent(new WeaponEventHumanCommandActionAborted(GetManOwner()));
          }
        }
      }
    }
  }
 
 
 
  override bool OnInventoryJunctureFromServer(ParamsReadContext ctx)
  {
    int tmp = -1;
    ctx.Read(tmp);
 
    if (LogManager.IsSyncLogEnable())
      syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " store Juncture packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
 
    StoreJunctureData(ctx);
 
    return true;
  }
 
 
  override bool OnInventoryJunctureRepairFromServer(ParamsReadContext ctx)
  {
    /*    InventoryLocation il = new InventoryLocation;
        if (!il.ReadFromContext(ctx) )
          return false;
 
        InventoryLocation il_current = new InventoryLocation;
 
        EntityAI item = il.GetItem();
        item.GetInventory().GetCurrentInventoryLocation(il_current);
 
        if( !il_current.CompareLocationOnly(il))
        {
          LocationMoveEntity(il_current,il);
        }*/
    return true;
  }
 
 
  override void OnInventoryJunctureFailureFromServer(ParamsReadContext ctx)
  {
    if (GetGame().IsDedicatedServer())
      return;
 
    int udtIdentifier = -1;
    if (!ctx.Read(udtIdentifier) || udtIdentifier != INPUT_UDT_INVENTORY)
      return;
 
    InventoryLocation src = new InventoryLocation;
    InventoryLocation dst = new InventoryLocation;
    InventoryLocation temp = new InventoryLocation;
 
    InventoryCommandType type = -1;
    if (!ctx.Read(type))
      return;
 
    switch (type)
    {
    case InventoryCommandType.SYNC_MOVE:
    {
      src.ReadFromContext(ctx);
      dst.ReadFromContext(ctx);
      break;
    }
    case InventoryCommandType.HAND_EVENT:
    {
      HandEventBase e = HandEventBase.CreateHandEventFromContext(ctx);
      src = e.GetSrc();
      dst = e.GetDst();
      break;
    }
    case InventoryCommandType.SWAP:
    {
      src.ReadFromContext(ctx);
      temp.ReadFromContext(ctx);
      dst.ReadFromContext(ctx);
      temp.ReadFromContext(ctx);
      break;
    }
    case InventoryCommandType.FORCESWAP:
    {
      break;
    }
    case InventoryCommandType.DESTROY:
    {
      src.ReadFromContext(ctx);
      break;
    }
    }
 
    InventoryValidationReason reason;
    if (!ctx.Read(reason))
      reason = InventoryValidationReason.UNKNOWN;
 
    OnInventoryFailure(type, reason, src, dst);
  }
 
  override void OnInventoryFailure(InventoryCommandType type, InventoryValidationReason reason, InventoryLocation src, InventoryLocation dst)
  {
    if (reason == InventoryValidationReason.DROP_PREVENTED)
    {
      return;
    }
 
  }
 
  protected void OnHandleStoredJunctureData(ParamsReadContext ctx)
  {
    int tmp = -1;
    ctx.Read(tmp);
 
    if (LogManager.IsSyncLogEnable())
      syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " handle JunctureData packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
 
    ProcessInputData(ctx, true, false);
  }
 
  proto native void StoreJunctureData(ParamsReadContext ctx);
 
 
 
  override bool OnInputUserDataProcess(ParamsReadContext ctx)
  {
    if (LogManager.IsSyncLogEnable())
      syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " store InputUserData packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
 
    StoreInputUserData(ctx);
    return true;
  }
 
  protected void OnHandleStoredInputUserData(ParamsReadContext ctx)
  {
    int tmp = -1;
    ctx.Read(tmp);
 
    if (LogManager.IsSyncLogEnable())
      syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " handle InputUserData packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
 
    ProcessInputData(ctx, false, false);
  }
 
  proto native void StoreInputUserData(ParamsReadContext ctx);
 
  void OnInputUserDataForRemote(ParamsReadContext ctx)
  {
    if (LogManager.IsSyncLogEnable())
      syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " remote handling InputUserData packet from server");
 
    ProcessInputData(ctx, false, true);
  }
 
  override void OnServerInventoryCommand(ParamsReadContext ctx)
  {
    if (LogManager.IsSyncLogEnable())
      syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " DZPInventory command from server");
 
    ProcessInputData(ctx, true, true);
  }
 
  bool ValidateSyncMove(inout Serializer ctx, InventoryValidation validation)
  {
    InventoryCommandType type = InventoryCommandType.SYNC_MOVE;
 
    InventoryLocation src = new InventoryLocation;
    InventoryLocation dst = new InventoryLocation;
 
    src.ReadFromContext(ctx);
    dst.ReadFromContext(ctx);
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + "src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst), "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
    if (validation.m_IsRemote && (!src.GetItem() || !dst.GetItem()))
    {
 
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - item not in bubble", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[syncinv] HandleInputData remote input (cmd=SYNC_MOVE) dropped, item not in bubble! src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
      return true;
    }
 
    EnableMovableOverride(src.GetItem());
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src, GameInventory.c_MaxItemDistanceRadius))
    {
 
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckRequestSrc", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " failed src check with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src));
 
      RemoveMovableOverride(src.GetItem());
      return true;
    }
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestDst(src, dst, GameInventory.c_MaxItemDistanceRadius))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckMoveToDstRequest", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " is cheating with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
      RemoveMovableOverride(src.GetItem());
      return true;
    }
 
    RemoveMovableOverride(src.GetItem());
 
    if (LogManager.IsSyncLogEnable())
      syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " HandleInputData t=" + GetGame().GetTime() + "ms received cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
    if (!validation.m_IsJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
    {
      JunctureRequestResult result_mv = TryAcquireInventoryJunctureFromServer(GetDayZPlayerOwner(), src, dst);
      if (result_mv == JunctureRequestResult.JUNCTURE_NOT_REQUIRED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture not required", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
 
        LocationSyncMoveEntity(src, dst);
 
        validation.m_Result = InventoryValidationResult.SUCCESS;
        return true;
      }
      else if (result_mv == JunctureRequestResult.JUNCTURE_ACQUIRED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture sended", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
        if (!GameInventory.LocationCanMoveEntity(src, dst))
        {
#ifdef DEVELOPER
          DumpInventoryDebug();
 
          if (LogManager.IsInventoryMoveLogEnable())
            Debug.InventoryMoveLog("Failed - LocationCanMoveEntity - Juncture denied", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
          return true;
        }
 
        validation.m_Result = InventoryValidationResult.JUNCTURE;
        EnableMovableOverride(src.GetItem());
        return true;
      }
      else if (result_mv == JunctureRequestResult.JUNCTURE_DENIED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture denied", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
        validation.m_Reason = InventoryValidationReason.JUNCTURE_DENIED;
        return true;
      }
      else
      {
        Error("[syncinv] HandleInputData: unexpected return code from AcquireInventoryJunctureFromServer");
 
        return true;
      }
    }
 
    if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
      ClearInventoryReservationEx(dst.GetItem(), dst);
 
    if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
      CheckForRope(src, dst);
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !GameInventory.LocationCanMoveEntitySyncCheck(src, dst))
    {
#ifdef DEVELOPER
      DumpInventoryDebug();
 
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - LocationCanMoveEntity", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      Error("[desync] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " CANNOT move cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
      return true;
    }
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("Success - LocationSyncMoveEntity", "SYNC_MOVE", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
    LocationSyncMoveEntity(src, dst);
 
    validation.m_Result = InventoryValidationResult.SUCCESS;
    return true;
  }
 
  bool ValidateHandEvent(inout Serializer ctx, InventoryValidation validation)
  {
    InventoryCommandType type = InventoryCommandType.HAND_EVENT;
 
    HandEventBase e = HandEventBase.CreateHandEventFromContext(ctx);
    e.ClearInventoryReservation();
 
    e.m_IsRemote = validation.m_IsRemote;
    e.m_IsJuncture = validation.m_IsJuncture;
 
    EntityAI itemSrc = e.GetSrcEntity();
    EntityAI itemDst = e.GetSecondSrcEntity();
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("STS = " + e.m_Player.GetSimulationTimeStamp() + " event= " + e.DumpToString(), "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
    if (validation.m_IsRemote && !e.GetSrcEntity())
    {
 
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckRequestSrc", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
      Error("[syncinv] HandleInputData remote input (cmd=HAND_EVENT, event=" + e.DumpToString() + ") dropped, item not in bubble");
 
      return true;
    }
 
    if (itemSrc)
      RemoveMovableOverride(itemSrc);
    if (itemDst)
      RemoveMovableOverride(itemDst);
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !e.CheckRequestSrc())
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckRequestSrc", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
      if (!validation.m_IsRemote)
      {
        ctx = new ScriptInputUserData;
        InventoryInputUserData.SerializeHandEvent(ctx, e);
      }
 
      RemoveMovableOverride(itemSrc);
      RemoveMovableOverride(itemDst);
 
      return true;
    }
 
    if (!e.CheckRequestEx(validation))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckRequest", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
 
      ctx = new ScriptInputUserData;
      InventoryInputUserData.SerializeHandEvent(ctx, e);
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " is cheating with cmd=" + typename.EnumToString(InventoryCommandType, type) + " event=" + e.DumpToString());
 
      RemoveMovableOverride(itemSrc);
      RemoveMovableOverride(itemDst);
      return true;
    }
 
    if (!validation.m_IsRemote && !e.CanPerformEventEx(validation))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CanPerformEvent", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
 
      ctx = new ScriptInputUserData;
      InventoryInputUserData.SerializeHandEvent(ctx, e);
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[desync] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " CANNOT do cmd=HAND_EVENT e=" + e.DumpToString());
 
      RemoveMovableOverride(itemSrc);
      RemoveMovableOverride(itemDst);
      return true;
    }
 
    RemoveMovableOverride(itemSrc);
    RemoveMovableOverride(itemDst);
 
    if (!validation.m_IsJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
    {
      JunctureRequestResult result_ev = e.AcquireInventoryJunctureFromServer(GetDayZPlayerOwner());
      if (result_ev == JunctureRequestResult.JUNCTURE_NOT_REQUIRED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture not required", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
      }
      else if (result_ev == JunctureRequestResult.JUNCTURE_ACQUIRED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture sended", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
        ctx = new ScriptInputUserData;
        InventoryInputUserData.SerializeHandEvent(ctx, e);
 
        validation.m_Result = InventoryValidationResult.JUNCTURE;
 
        if (itemSrc)
          EnableMovableOverride(itemSrc);
        if (itemDst)
          EnableMovableOverride(itemDst);
        return true;
      }
      else if (result_ev == JunctureRequestResult.JUNCTURE_DENIED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture denied", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
        validation.m_Reason = InventoryValidationReason.JUNCTURE_DENIED;
        return true;
      }
      else
      {
        Error("[syncinv] HandleInputData: unexpected return code from AcquireInventoryJunctureFromServer");
 
        return true;
      }
    }
 
    if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
      CheckForRope(e.GetSrc(), e.GetDst());
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("Success - ProcessHandEvent", "HAND_EVENT", "n/a", "ProcessInputData", e.m_Player.ToString());
#endif
 
    validation.m_Result = InventoryValidationResult.SUCCESS;
    if (!e.m_Player.GetHumanInventory().ProcessHandEvent(e))
    {
      //result = InventoryValidationResult.FAILURE;
    }
 
    return true;
  }
 
  bool ValidateSwap(inout Serializer ctx, InventoryValidation validation)
  {
    InventoryCommandType type = InventoryCommandType.SWAP;
 
    InventoryLocation src1 = new InventoryLocation;
    InventoryLocation src2 = new InventoryLocation;
 
    InventoryLocation dst1 = new InventoryLocation;
    InventoryLocation dst2 = new InventoryLocation;
 
    bool skippedSwap = false;
 
    src1.ReadFromContext(ctx);
    src2.ReadFromContext(ctx);
    dst1.ReadFromContext(ctx);
    dst2.ReadFromContext(ctx);
    ctx.Read(skippedSwap);
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2), "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
    if (validation.m_IsRemote && (!src1.GetItem() || !src2.GetItem()))
    {
      if (skippedSwap)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Remote - skipped", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
        /*
                if (LogManager.IsSyncLogEnable())
                {
                  syncDebugPrint("[syncinv] HandleInputData remote input (cmd=SWAP) dropped, swap is skipped");
                }
        */
      }
      else
      {
 
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Failed - item1 or item2 not exist", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
        Error("[syncinv] HandleInputData remote input (cmd=SWAP) dropped, item not in bubble");
      }
 
      return true;
    }
 
    EnableMovableOverride(src1.GetItem());
    EnableMovableOverride(src2.GetItem());
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src1, GameInventory.c_MaxItemDistanceRadius))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckRequestSrc1", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " failed src1 check with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src1=" + InventoryLocation.DumpToStringNullSafe(src1));
 
      RemoveMovableOverride(src1.GetItem());
      RemoveMovableOverride(src2.GetItem());
      return true;
    }
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src2, GameInventory.c_MaxItemDistanceRadius))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckRequestSrc2", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " failed src2 check with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2));
 
      RemoveMovableOverride(src1.GetItem());
      RemoveMovableOverride(src2.GetItem());
      return true;
    }
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckSwapItemsRequest(src1, src2, dst1, dst2, GameInventory.c_MaxItemDistanceRadius))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CheckSwapItemsRequest", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " is cheating with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));
 
      RemoveMovableOverride(src1.GetItem());
      RemoveMovableOverride(src2.GetItem());
      return true;
    }
 
    RemoveMovableOverride(src1.GetItem());
    RemoveMovableOverride(src2.GetItem());
 
    if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
    {
      ClearInventoryReservationEx(dst1.GetItem(), dst1);
      ClearInventoryReservationEx(dst2.GetItem(), dst2);
    }
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !GameInventory.CanForceSwapEntitiesEx(src1.GetItem(), dst1, src2.GetItem(), dst2))
    {
#ifdef DEVELOPER
      DumpInventoryDebug();
 
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed - CanForceSwapEntitiesEx", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      Error("[desync] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " CANNOT swap cmd=" + typename.EnumToString(InventoryCommandType, type) + " src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " | src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));
      return true;
    }
 
    if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
    {
      AddInventoryReservationEx(dst1.GetItem(), dst1, GameInventory.c_InventoryReservationTimeoutShortMS);
      AddInventoryReservationEx(dst2.GetItem(), dst2, GameInventory.c_InventoryReservationTimeoutShortMS);
    }
 
    if (!(src1.IsValid() && src2.IsValid() && dst1.IsValid() && dst2.IsValid()))
    {
      Error("HandleInputData: cmd=" + typename.EnumToString(InventoryCommandType, type) + " invalid input(s): src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));
      return true;
    }
 
    if (!validation.m_IsJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
    {
      JunctureRequestResult result_sw = TryAcquireTwoInventoryJuncturesFromServer(GetDayZPlayerOwner(), src1, src2, dst1, dst2);
      if (result_sw == JunctureRequestResult.JUNCTURE_NOT_REQUIRED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture not required", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      }
      else if (result_sw == JunctureRequestResult.JUNCTURE_ACQUIRED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture sended", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
        validation.m_Result = InventoryValidationResult.JUNCTURE;
        EnableMovableOverride(src1.GetItem());
        EnableMovableOverride(src2.GetItem());
        return true;
      }
      else if (result_sw == JunctureRequestResult.JUNCTURE_DENIED)
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("Juncture denied", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
        validation.m_Reason = InventoryValidationReason.JUNCTURE_DENIED;
        return true;
      }
      else
      {
        Error("[syncinv] HandleInputData: unexpected return code from TryAcquireTwoInventoryJuncturesFromServer"); return true;
 
        return true;
      }
    }
 
    if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
    {
      ClearInventoryReservationEx(dst1.GetItem(), dst1);
      ClearInventoryReservationEx(dst2.GetItem(), dst2);
    }
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("Success - item swap", "SWAP", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
    bool isNotSkipped = LocationSwap(src1, src2, dst1, dst2);
 
    ctx = new ScriptInputUserData();
    InventoryInputUserData.SerializeSwap(ctx, src1, src2, dst1, dst2, !isNotSkipped);
 
    validation.m_Result = InventoryValidationResult.SUCCESS;
    return true;
  }
 
  bool ValidateDestroy(inout Serializer ctx, InventoryValidation validation)
  {
    InventoryCommandType type = InventoryCommandType.DESTROY;
 
    if (validation.m_IsJuncture)
    {
      return true;
    }
 
    InventoryLocation src = new InventoryLocation;
    src.ReadFromContext(ctx);
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " src=" + InventoryLocation.DumpToStringNullSafe(src), "DESTROY", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
    if (validation.m_IsRemote && !src.GetItem())
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed item not exist", "DESTROY", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      Error("[syncinv] HandleInputData remote input (cmd=DESTROY) dropped, item not in bubble");
      return true;
    }
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src, GameInventory.c_MaxItemDistanceRadius))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed CheckRequestSrc", "DESTROY", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      return true;
    }
 
    if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckDropRequest(src, GameInventory.c_MaxItemDistanceRadius))
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Failed CheckDropRequest", "DESTROY", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
      return true;
    }
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("Success ObjectDelete", "DESTROY", "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString());
#endif
 
    GetGame().ObjectDelete(src.GetItem());
 
    validation.m_Result = InventoryValidationResult.SUCCESS;
    return true;
  }
 
  bool ProcessInputData(ParamsReadContext ctx, bool isJuncture, bool isRemote)
  {
    if (isJuncture && isRemote)
    {
      return false;
    }
 
    int type = -1;
    if (!ctx.Read(type))
      return false;
 
    InventoryValidation validation();
    validation.m_IsJuncture = isJuncture;
    validation.m_IsRemote = isRemote;
 
    Serializer serializer = ctx;
 
    switch (type)
    {
    case InventoryCommandType.USER_RESERVATION_CANCEL:
      if (!ValidateUserReservationCancel(serializer, validation))
        return false;
      break;
    case InventoryCommandType.SYNC_MOVE:
      if (!ValidateSyncMove(serializer, validation))
        return false;
      break;
    case InventoryCommandType.HAND_EVENT:
      if (!ValidateHandEvent(serializer, validation))
        return false;
      break;
    case InventoryCommandType.SWAP:
      if (!ValidateSwap(serializer, validation))
        return false;
      break;
    case InventoryCommandType.DESTROY:
      if (!ValidateDestroy(serializer, validation))
        return false;
      break;
    default:
      break;
    }
 
    bool canSendJuncture = !isJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER;
 
    switch (validation.m_Result)
    {
    case InventoryValidationResult.FAILED:
      if (canSendJuncture) 
      {
        if (!serializer.CanWrite())
        {
          ScriptInputUserData writeableSerializer();
          writeableSerializer.CopyFrom(serializer);
          serializer = writeableSerializer;
        }
 
        serializer.Write(validation.m_Reason);
 
        GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY_FAILURE, serializer);
      }
      break;
    case InventoryValidationResult.JUNCTURE:
      if (canSendJuncture) 
      {
        GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY, serializer);
        //StoreInputForRemotes(isJuncture, isRemote, serializer);
      }
      else
        Error("InventoryValidationResult.JUNCTURE returned when not possible to send!");
      break;
    case InventoryValidationResult.SUCCESS:
      StoreInputForRemotes(isJuncture, isRemote, serializer);
      break;
    }
 
    return true;
  }
 
  void RemoveMovableOverride(EntityAI item)
  {
    ItemBase itemIB = ItemBase.Cast(item);
    if (itemIB)
      itemIB.SetCanBeMovedOverride(false);
  }
 
  void EnableMovableOverride(EntityAI item)
  {
    ItemBase itemIB = ItemBase.Cast(item);
    if (itemIB)
      itemIB.SetCanBeMovedOverride(true);
  }
 
  // Hacky solution for dealing with fencekit rope related issues, could be fixed by introducing some indicator that this item behaves differently or sth..
  void CheckForRope(InventoryLocation src, InventoryLocation dst)
  {
    Rope rope = Rope.Cast(src.GetItem());
    if (rope)
      rope.SetTargetLocation(dst);
  }
 
  bool IsServerOrLocalPlayer()
  {
    return GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER || GetDayZPlayerOwner() == GetGame().GetPlayer());
  }
 
  bool StoreInputForRemotes(bool handling_juncture, bool remote, ParamsReadContext ctx)
  {
    if (!remote && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp(), "n/a", "n/a", "StoreInputForRemotes", GetDayZPlayerOwner().ToString());
#endif
 
      GetDayZPlayerOwner().StoreInputForRemotes(ctx); // @NOTE: needs to be called _after_ the operation
      return true;
    }
 
    return false;
  }
 
  override bool TakeToDst(InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
  {
    if (GetManOwner().IsAlive() == false)
      return super.TakeToDst(mode, src, dst);
 
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst), "n/a", "n/a", "TakeToDst", GetDayZPlayerOwner().ToString());
#endif
 
    switch (mode)
    {
    case InventoryMode.SERVER:
      if (RedirectToHandEvent(mode, src, dst))
      {
#ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
          Debug.InventoryMoveLog("RedirectToHandEvent", "n/a", "n/a", "TakeToDst", GetDayZPlayerOwner().ToString());
#endif
 
        return true;
      }
 
 
      if (GetDayZPlayerOwner().NeedInventoryJunctureFromServer(src.GetItem(), src.GetParent(), dst.GetParent()))
      {
        if (GetGame().AddInventoryJunctureEx(GetDayZPlayerOwner(), src.GetItem(), dst, true, GameInventory.c_InventoryReservationTimeoutMS))
        {
          if (LogManager.IsSyncLogEnable())
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " DZPI::Take2Dst(" + typename.EnumToString(InventoryMode, mode) + ") got juncture");
        }
        else
        {
#ifdef DEVELOPER
          if (LogManager.IsInventoryMoveLogEnable())
            Debug.InventoryMoveLog("Juncture failed", "n/a", "n/a", "TakeToDst", GetDayZPlayerOwner().ToString());
#endif
 
          if (LogManager.IsSyncLogEnable())
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " DZPI::Take2Dst(" + typename.EnumToString(InventoryMode, mode) + ") got juncture");
 
          return false;
        }
 
      }
 
      ScriptInputUserData ctx = new ScriptInputUserData;
      InventoryInputUserData.SerializeMove(ctx, InventoryCommandType.SYNC_MOVE, src, dst);
 
      GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY, ctx);
 
      if (LogManager.IsSyncLogEnable())
        syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " store input for remote - DZPI::Take2Dst(" + typename.EnumToString(InventoryMode, mode) + " server sync move src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
      //GetDayZPlayerOwner().StoreInputForRemotes(ctx); // @TODO: is this right place? maybe in HandleInputData(server=true, ...)
#ifdef DEVELOPER
      if (LogManager.IsInventoryMoveLogEnable())
        Debug.InventoryMoveLog("Success - store input for remote mode - " + typename.EnumToString(InventoryMode, mode) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst), "n/a", "n/a", "TakeToDst", GetDayZPlayerOwner().ToString());
#endif
      return true;
 
    case InventoryMode.LOCAL:
      LocationSyncMoveEntity(src, dst);
      return true;
    }
    if (!super.TakeToDst(mode, src, dst))
    {
      if (!m_DeferredEvent)
      {
        m_DeferredEvent = new DeferredTakeToDst(mode, src, dst);
        if (m_DeferredEvent.ReserveInventory(this))
          return true;
      }
 
      m_DeferredEvent = null;
      return false;
    }
    return true;
  }
 
  void HandleTakeToDst(DeferredEvent deferred_event)
  {
    DeferredTakeToDst deferred_take_to_dst = DeferredTakeToDst.Cast(deferred_event);
    if (deferred_take_to_dst)
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryHFSMLogEnable())
        Debug.InventoryHFSMLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp(), "n/a", "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
#endif
 
      deferred_take_to_dst.ClearInventoryReservation(this);
 
      if (LogManager.IsInventoryMoveLogEnable())
        inventoryDebugPrint("[inv] I::Take2Dst(" + typename.EnumToString(InventoryMode, deferred_take_to_dst.m_mode) + ") src=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_src) + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_dst));
 
      switch (deferred_take_to_dst.m_mode)
      {
      case InventoryMode.PREDICTIVE:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("PREDICTIVE ", "n/a", "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
#endif
 
        if (LocationCanMoveEntity(deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst))
        {
          InventoryInputUserData.SendInputUserDataMove(InventoryCommandType.SYNC_MOVE, deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst);
          LocationSyncMoveEntity(deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst);
        }
        else
        {
#ifdef DEVELOPER
          if (LogManager.IsInventoryMoveLogEnable())
            Debug.InventoryMoveLog("Can not move entity (PREDICTIVE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item = " + deferred_take_to_dst.m_dst.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_dst), "n/a", "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
#endif
        }
        break;
      case InventoryMode.JUNCTURE:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("JUNCTURE ", "n/a", "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
#endif
 
        if (LocationCanMoveEntity(deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst))
        {
          DayZPlayer player = GetGame().GetPlayer();
          player.GetHumanInventory().AddInventoryReservationEx(deferred_take_to_dst.m_dst.GetItem(), deferred_take_to_dst.m_dst, GameInventory.c_InventoryReservationTimeoutShortMS);
          EnableMovableOverride(deferred_take_to_dst.m_dst.GetItem());
          InventoryInputUserData.SendInputUserDataMove(InventoryCommandType.SYNC_MOVE, deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst);
        }
        else
        {
#ifdef DEVELOPER
          if (LogManager.IsInventoryMoveLogEnable())
            Debug.InventoryMoveLog("Can not move entity (JUNCTURE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item = " + deferred_take_to_dst.m_dst.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_dst), "n/a", "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
#endif
        }
        break;
      case InventoryMode.LOCAL:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("LOCAL ", "n/a", "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
#endif
        break;
      case InventoryMode.SERVER:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("SERVER ", "n/a", "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
#endif
        break;
      default:
        Error("HandEvent - Invalid mode");
        break;
      }
    }
  }
 
  override bool SwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2)
  {
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + item1 + " item2 = " + item2, "n/a", "n/a", "SwapEntities", GetDayZPlayerOwner().ToString());
#endif
 
    InventoryLocation src1, src2, dst1, dst2;
    if (mode == InventoryMode.LOCAL)
    {
      if (GameInventory.MakeSrcAndDstForSwap(item1, item2, src1, src2, dst1, dst2))
      {
        LocationSwap(src1, src2, dst1, dst2);
        return true;
      }
    }
 
    if (!super.SwapEntities(mode, item1, item2))
    {
      if (!m_DeferredEvent)
      {
        if (GameInventory.MakeSrcAndDstForSwap(item1, item2, src1, src2, dst1, dst2));
        {
          m_DeferredEvent = new DeferredSwapEntities(mode, item1, item2, dst1, dst2);
          if (m_DeferredEvent.ReserveInventory(this))
            return true;
        }
      }
      m_DeferredEvent = null;
      return false;
    }
    return true;
  }
 
  void HandleSwapEntities(DeferredEvent deferred_event)
  {
    DeferredSwapEntities deferred_swap_entities = DeferredSwapEntities.Cast(deferred_event);
    if (deferred_swap_entities)
    {
      deferred_swap_entities.ClearInventoryReservation(this);
      InventoryLocation src1, src2, dst1, dst2;
      if (GameInventory.MakeSrcAndDstForSwap(deferred_swap_entities.m_item1, deferred_swap_entities.m_item2, src1, src2, dst1, dst2))
      {
        if (LogManager.IsInventoryMoveLogEnable())
          inventoryDebugPrint("[inv] I::Swap(" + typename.EnumToString(InventoryMode, deferred_swap_entities.m_mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst2));
 
        switch (deferred_swap_entities.m_mode)
        {
        case InventoryMode.PREDICTIVE:
          if (CanSwapEntitiesEx(deferred_swap_entities.m_dst1.GetItem(), deferred_swap_entities.m_dst2.GetItem()))
          {
            InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_swap_entities.m_dst1, deferred_swap_entities.m_dst2);
            LocationSwap(src1, src2, deferred_swap_entities.m_dst1, deferred_swap_entities.m_dst2);
          }
          else
          {
#ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
              Debug.InventoryMoveLog("Can not swap (PREDICTIVE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst2), "n/a", "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString());
#endif
          }
          break;
 
        case InventoryMode.JUNCTURE:
          if (CanSwapEntitiesEx(deferred_swap_entities.m_dst1.GetItem(), deferred_swap_entities.m_dst2.GetItem()))
          {
            DayZPlayer player = GetGame().GetPlayer();
            player.GetHumanInventory().AddInventoryReservationEx(deferred_swap_entities.m_dst1.GetItem(), deferred_swap_entities.m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS);
            player.GetHumanInventory().AddInventoryReservationEx(deferred_swap_entities.m_dst2.GetItem(), deferred_swap_entities.m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS);
            EnableMovableOverride(deferred_swap_entities.m_dst1.GetItem());
            EnableMovableOverride(deferred_swap_entities.m_dst2.GetItem());
            InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_swap_entities.m_dst1, deferred_swap_entities.m_dst2);
          }
          else
          {
#ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
              Debug.InventoryMoveLog("Can not swap (JUNCTURE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst2), "n/a", "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString());
#endif
          }
          break;
 
        case InventoryMode.LOCAL:
          break;
 
        default:
          Error("SwapEntities - HandEvent - Invalid mode");
        }
      }
      else
        Error("SwapEntities - MakeSrcAndDstForSwap - no inv loc");
    }
  }
 
  override bool ForceSwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
  {
#ifdef DEVELOPER
    if (LogManager.IsInventoryMoveLogEnable())
      Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + item1 + " item2 = " + item2 + " dst=" + InventoryLocation.DumpToStringNullSafe(item2_dst), "n/a", "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString());
#endif
 
    if (mode == InventoryMode.LOCAL)
    {
      InventoryLocation src1, src2, dst1;
      if (GameInventory.MakeSrcAndDstForForceSwap(item1, item2, src1, src2, dst1, item2_dst))
      {
        LocationSwap(src1, src2, dst1, item2_dst);
        return true;
      }
 
    }
 
    if (!super.ForceSwapEntities(mode, item1, item2, item2_dst))
    {
      if (!m_DeferredEvent)
      {
        if (GameInventory.MakeSrcAndDstForForceSwap(item1, item2, src1, src2, dst1, item2_dst))
        {
          m_DeferredEvent = new DeferredForceSwapEntities(mode, item1, item2, dst1, item2_dst);
          if (m_DeferredEvent.ReserveInventory(this))
            return true;
 
        }
      }
      m_DeferredEvent = null;
      return false;
    }
 
    return true;
  }
 
  void HandleForceSwapEntities(DeferredEvent deferred_event)
  {
    DeferredForceSwapEntities deferred_force_swap_entities = DeferredForceSwapEntities.Cast(deferred_event);
    if (deferred_force_swap_entities)
    {
      deferred_force_swap_entities.ClearInventoryReservation(this);
      InventoryLocation src1 = new InventoryLocation;
      InventoryLocation src2 = new InventoryLocation;
      deferred_force_swap_entities.m_item1.GetInventory().GetCurrentInventoryLocation(src1);
      deferred_force_swap_entities.m_item2.GetInventory().GetCurrentInventoryLocation(src2);
 
      DayZPlayer player = GetGame().GetPlayer();
 
      if (LogManager.IsInventoryMoveLogEnable())
        inventoryDebugPrint("[inv] I::FSwap(" + typename.EnumToString(InventoryMode, deferred_force_swap_entities.m_mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst2));
 
      switch (deferred_force_swap_entities.m_mode)
      {
      case InventoryMode.PREDICTIVE:
        if (CanForceSwapEntitiesEx(deferred_force_swap_entities.m_dst1.GetItem(), deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2.GetItem(), deferred_force_swap_entities.m_dst2))
        {
          InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2);
          LocationSwap(src1, src2, deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2);
        }
        else
        {
#ifdef DEVELOPER
          if (LogManager.IsInventoryMoveLogEnable())
            Debug.InventoryMoveLog("Can not force swap (PREDICTIVE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_force_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_force_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst2), "n/a", "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString());
#endif
        }
        break;
 
      case InventoryMode.JUNCTURE:
        if (CanForceSwapEntitiesEx(deferred_force_swap_entities.m_dst1.GetItem(), deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2.GetItem(), deferred_force_swap_entities.m_dst2))
        {
          player.GetHumanInventory().AddInventoryReservationEx(deferred_force_swap_entities.m_item1, deferred_force_swap_entities.m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS);
          player.GetHumanInventory().AddInventoryReservationEx(deferred_force_swap_entities.m_item2, deferred_force_swap_entities.m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS);
 
          InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2);
        }
        else
        {
#ifdef DEVELOPER
          if (LogManager.IsInventoryMoveLogEnable())
            Debug.InventoryMoveLog("Can not force swap (JUNCTURE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_force_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_force_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst2), "n/a", "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString());
#endif
        }
        break;
 
      case InventoryMode.LOCAL:
        break;
 
      default:
        Error("ForceSwapEntities - HandEvent - Invalid mode");
      }
    }
  }
 
  static void SendServerHandEventViaJuncture(notnull DayZPlayer player, HandEventBase e)
  {
    if (GetGame().IsServer())
    {
      if (e.IsServerSideOnly())
        Error("[syncinv] " + Object.GetDebugName(player) + " SendServerHandEventViaJuncture - called on server side event only, e=" + e.DumpToString());
 
      if (player.IsAlive())
      {
        InventoryLocation dst = e.GetDst();
        InventoryLocation src = e.GetSrc();
        if (src.IsValid() && dst.IsValid())
        {
          if (player.NeedInventoryJunctureFromServer(src.GetItem(), src.GetParent(), dst.GetParent()))
          {
            if (LogManager.IsSyncLogEnable())
              syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + ") need juncture src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
            if (GetGame().AddInventoryJunctureEx(player, src.GetItem(), dst, true, GameInventory.c_InventoryReservationTimeoutMS))
            {
              if (LogManager.IsSyncLogEnable())
                syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + ") got juncture");
            }
            else
            {
              if (LogManager.IsSyncLogEnable())
                syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + ") !got juncture");
            }
          }
 
          if (LogManager.IsSyncLogEnable())
            syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + " server hand event src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
          ScriptInputUserData ctx = new ScriptInputUserData;
          InventoryInputUserData.SerializeHandEvent(ctx, e);
          player.SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY, ctx);
 
          if (LogManager.IsSyncLogEnable())
            syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " store input for remote - SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + " server hand event src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
          //player.StoreInputForRemotes(ctx); // @TODO: is this right place? maybe in HandleInputData(server=true, ...)
        }
      }
      else
        Error("[syncinv] SendServerHandEventViaJuncture - called on dead player, juncture is for living only");
    }
  }
 
  override void NetSyncCurrentStateID(int id)
  {
    super.NetSyncCurrentStateID(id);
 
    GetDayZPlayerOwner().GetItemAccessor().OnItemInHandsChanged();
  }
 
  override void OnAfterStoreLoad()
  {
    GetDayZPlayerOwner().GetItemAccessor().OnItemInHandsChanged(true);
  }
 
  bool OnEventForRemoteWeapon(ParamsReadContext ctx)
  {
    if (GetEntityInHands())
    {
      Weapon_Base wpn = Weapon_Base.Cast(GetEntityInHands());
      if (wpn)
      {
        PlayerBase pb = PlayerBase.Cast(GetDayZPlayerOwner());
 
        WeaponEventBase e = CreateWeaponEventFromContext(ctx);
        if (pb && e)
        {
          pb.GetWeaponManager().SetRunning(true);
 
          if (LogManager.IsWeaponLogEnable())
            fsmDebugSpam("[wpnfsm] " + Object.GetDebugName(wpn) + " recv event from remote: created event=" + e);
 
          if (e.GetEventID() == WeaponEventID.HUMANCOMMAND_ACTION_ABORTED)
            wpn.ProcessWeaponAbortEvent(e);
          else
            wpn.ProcessWeaponEvent(e);
          pb.GetWeaponManager().SetRunning(false);
        }
      }
      else
        Error("OnEventForRemoteWeapon - entity in hands, but not weapon. item=" + GetEntityInHands());
    }
    else
      Error("OnEventForRemoteWeapon - no entity in hands");
    return true;
  }
 
 
  bool OnHandEventForRemote(ParamsReadContext ctx)
  {
    HandEventBase e = HandEventBase.CreateHandEventFromContext(ctx);
    if (e)
    {
      if (LogManager.IsInventoryHFSMLogEnable())
        hndDebugSpam("[hndfsm] recv event from remote: created event=" + e);
 
      //m_FSM.ProcessEvent(e);
 
      if (e.GetEventID() == HandEventID.HUMANCOMMAND_ACTION_ABORTED)
      {
        ProcessEventResult aa;
        m_FSM.ProcessAbortEvent(e, aa);
      }
      else
        m_FSM.ProcessEvent(e);
 
      return true;
    }
    return false;
  }
 
  void SyncHandEventToRemote(HandEventBase e)
  {
    DayZPlayer p = GetDayZPlayerOwner();
    if (p && p.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
    {
      ScriptRemoteInputUserData ctx = new ScriptRemoteInputUserData;
 
      ctx.Write(INPUT_UDT_HAND_REMOTE_EVENT);
      e.WriteToContext(ctx);
 
      if (LogManager.IsInventoryHFSMLogEnable())
        hndDebugPrint("[hndfsm] send 2 remote: sending e=" + e + " id=" + e.GetEventID() + " p=" + p + "  e=" + e.DumpToString());
 
      p.StoreInputForRemotes(ctx);
    }
  }
 
  override void OnHandsExitedStableState(HandStateBase src, HandStateBase dst)
  {
    super.OnHandsExitedStableState(src, dst);
 
    if (LogManager.IsInventoryHFSMLogEnable())
      hndDebugPrint("[hndfsm] hand fsm exit stable src=" + src.Type().ToString());
  }
 
  override void OnHandsEnteredStableState(HandStateBase src, HandStateBase dst)
  {
    super.OnHandsEnteredStableState(src, dst);
 
    if (LogManager.IsInventoryHFSMLogEnable())
      hndDebugPrint("[hndfsm] hand fsm entered stable dst=" + dst.Type().ToString());
  }
 
  override void OnHandsStateChanged(HandStateBase src, HandStateBase dst)
  {
    super.OnHandsStateChanged(src, dst);
 
    if (LogManager.IsInventoryHFSMLogEnable())
      hndDebugPrint("[hndfsm] hand fsm changed state src=" + src.Type().ToString() + " ---> dst=" + dst.Type().ToString());
 
    if (src.IsIdle())
      OnHandsExitedStableState(src, dst);
 
    if (dst.IsIdle())
      OnHandsEnteredStableState(src, dst);
 
#ifdef BOT
    PlayerBase p = PlayerBase.Cast(GetDayZPlayerOwner());
    if (p && p.m_Bot)
      p.m_Bot.ProcessEvent(new BotEventOnItemInHandsChanged(p));
#endif
  }
 
  override bool HandEvent(InventoryMode mode, HandEventBase e)
  {
    if (!IsProcessing())
    {
      EntityAI itemInHands = GetEntityInHands();
 
      InventoryLocation handInventoryLocation();
      handInventoryLocation.SetHands(GetInventoryOwner(), itemInHands);
 
      InventoryValidation validation();
      if (e.CanPerformEventEx(validation))
      {
        m_DeferredEvent = new DeferredHandEvent(mode, e);
        if (m_DeferredEvent.ReserveInventory(this))
          return true;
      }
 
      m_DeferredEvent = null;
 
      if (!GetGame().IsMultiplayer() || GetGame().IsClient())
      {
        OnInventoryFailure(InventoryCommandType.HAND_EVENT, validation.m_Reason, e.GetSrc(), e.GetDst());
      }
      else
      {
        ScriptInputUserData serializer();
 
        InventoryInputUserData.SerializeHandEvent(serializer, e);
        serializer.Write(validation.m_Reason);
 
        GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY_FAILURE, serializer);
      }
    }
 
    return false;
  }
 
 
  void HandleHandEvent(DeferredEvent deferred_event)
  {
    InventoryValidation validation();
 
    DeferredHandEvent deferred_hand_event = DeferredHandEvent.Cast(deferred_event);
    if (deferred_hand_event)
    {
#ifdef DEVELOPER
      if (LogManager.IsInventoryHFSMLogEnable())
        Debug.InventoryHFSMLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp(), "n/a", "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
#endif
 
      if (LogManager.IsInventoryHFSMLogEnable())
        hndDebugPrint("[inv] HumanInventory::HandEvent(" + typename.EnumToString(InventoryMode, deferred_hand_event.m_mode) + ") ev=" + deferred_hand_event.m_event.DumpToString());
 
      switch (deferred_hand_event.m_mode)
      {
      case InventoryMode.PREDICTIVE:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("PREDICTIVE", "n/a", "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
#endif
 
        deferred_hand_event.ClearInventoryReservation(this);
        if (deferred_hand_event.m_event.CanPerformEventEx(validation))
        {
          InventoryInputUserData.SendInputUserDataHandEvent(deferred_hand_event.m_event);
          ProcessHandEvent(deferred_hand_event.m_event);
        }
        break;
 
      case InventoryMode.JUNCTURE:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("JUNCTURE", "n/a", "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
#endif
 
        deferred_hand_event.ClearInventoryReservation(this);
        if (deferred_hand_event.m_event.CanPerformEventEx(validation))
        {
          deferred_hand_event.ReserveInventory(this);
          InventoryInputUserData.SendInputUserDataHandEvent(deferred_hand_event.m_event);
 
          //Functionality to prevent desync when two players perform interfering action at the same time
          EntityAI itemSrc = deferred_hand_event.m_event.GetSrcEntity();
          EntityAI itemDst = null;
          if (deferred_hand_event.m_event.GetDst())
            itemDst = deferred_hand_event.m_event.GetDst().GetItem();
          if (itemSrc)
            EnableMovableOverride(itemSrc);
          if (itemDst)
            EnableMovableOverride(itemDst);
        }
        break;
 
      case InventoryMode.LOCAL:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("LOCAL", "n/a", "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
#endif
 
        deferred_hand_event.ClearInventoryReservation(this);
        ProcessHandEvent(deferred_hand_event.m_event);
        //PostHandEvent(deferred_hand_event.m_event);
        break;
 
      case InventoryMode.SERVER:
#ifdef DEVELOPER
        if (LogManager.IsInventoryHFSMLogEnable())
          Debug.InventoryHFSMLog("SERVER", "n/a", "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
#endif
 
        if (LogManager.IsInventoryHFSMLogEnable())
          hndDebugPrint("[inv] DZPI::HandEvent(" + typename.EnumToString(InventoryMode, deferred_hand_event.m_mode) + ")");
 
        if (!deferred_hand_event.m_event.IsServerSideOnly())
        {
          if (GetDayZPlayerOwner().IsAlive())
            SendServerHandEventViaJuncture(GetDayZPlayerOwner(), deferred_hand_event.m_event);
          else
            InventoryInputUserData.SendServerHandEventViaInventoryCommand(GetDayZPlayerOwner(), deferred_hand_event.m_event);
        }
        else
          ProcessHandEvent(deferred_hand_event.m_event);
        break;
 
      default:
        Error("HumanInventory::HandEvent - Invalid mode");
      }
    }
  }
 
  override void HandleInventoryManipulation()
  {
    super.HandleInventoryManipulation();
    if (m_DeferredEvent && ScriptInputUserData.CanStoreInputUserData())
    {
      HandleHandEvent(m_DeferredEvent);
      HandleTakeToDst(m_DeferredEvent);
      HandleSwapEntities(m_DeferredEvent);
      HandleForceSwapEntities(m_DeferredEvent);
 
      m_DeferredEvent = null;
    }
  }
 
 
  bool IsProcessing()
  {
    return !m_FSM.GetCurrentState().IsIdle() || m_DeferredEvent || m_DeferredPostedHandEvent;
  }
 
  bool PlayerCheckRequestSrc(notnull InventoryLocation src, float radius)
  {
    bool result = true;
 
    EntityAI ent = src.GetParent();
    if (ent)
    {
      PlayerBase player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
      if (player)
      {
        if (GetDayZPlayerOwner() != player)
        {
          if (player.IsAlive())
          {
            if (!player.IsRestrained() && !player.IsUnconscious())
              return false;
          }
        }
      }
    }
 
    if (result)
      result = CheckRequestSrc(GetManOwner(), src, radius);
 
    return result;
  }
 
  bool PlayerCheckRequestDst(notnull InventoryLocation src, notnull InventoryLocation dst, float radius)
  {
    bool result = true;
 
    EntityAI ent = dst.GetParent();
    if (ent)
    {
      PlayerBase player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
      if (player)
      {
        if (GetDayZPlayerOwner() != player)
        {
          if (player.IsAlive())
          {
            if (!player.IsRestrained() && !player.IsUnconscious())
              return false;
          }
        }
      }
    }
 
    if (result)
      result = CheckMoveToDstRequest(GetManOwner(), src, dst, radius);
 
    return result;
  }
 
  bool PlayerCheckSwapItemsRequest(notnull InventoryLocation src1, notnull InventoryLocation src2, notnull InventoryLocation dst1, notnull InventoryLocation dst2, float radius)
  {
    bool result = true;
 
    EntityAI ent = dst1.GetParent();
    PlayerBase player;
    if (ent)
    {
      player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
      if (player)
      {
        if (GetDayZPlayerOwner() != player)
        {
          if (player.IsAlive())
          {
            if (!player.IsRestrained() && !player.IsUnconscious())
              return false;
          }
        }
      }
    }
 
    ent = dst2.GetParent();
    if (ent)
    {
      player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
      if (player)
      {
        if (GetDayZPlayerOwner() != player)
        {
          if (player.IsAlive())
          {
            if (!player.IsRestrained() && !player.IsUnconscious())
              return false;
          }
        }
      }
    }
 
 
    if (result)
      result = CheckSwapItemsRequest(GetManOwner(), src1, src2, dst1, dst2, GameInventory.c_MaxItemDistanceRadius);
 
    return result;
 
  }
 
  bool PlayerCheckDropRequest(notnull InventoryLocation src, float radius)
  {
    bool result = true;
 
    EntityAI ent = src.GetParent();
    if (ent)
    {
      PlayerBase player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
      if (player)
      {
        if (GetDayZPlayerOwner() != player)
        {
          if (player.IsAlive())
          {
            if (!player.IsRestrained() && !player.IsUnconscious())
              return false;
          }
        }
      }
    }
 
    if (result)
      result = CheckDropRequest(GetManOwner(), src, radius);
 
    return result;
  }
};