HumanInventory.c

Go to the documentation of this file.

 
class HumanInventory : GameInventory
{
  int m_syncClearUserReservationindex = -1;
  //int m_UserReservationToClear = -1;
  proto native EntityAI GetEntityInHands();
 
  proto native bool CanAddEntityInHands(EntityAI e);
 
  proto native bool TestAddEntityInHands(EntityAI e, bool do_resevation_check, bool do_item_check, bool do_lock_check, bool do_occupancy_test, bool do_script_check);
 
  proto native bool CanRemoveEntityInHands();
 
  proto native bool CanOpenInventory();
 
  proto native EntityAI CreateInHands(string typeName);
 
  proto native int GetUserReservedLocationCount();
  proto native int FindUserReservedLocationIndex(notnull EntityAI e);
  proto native int FindCollidingUserReservedLocationIndex(notnull EntityAI e, notnull InventoryLocation dst);
  proto native void GetUserReservedLocation(int index, out notnull InventoryLocation dst);
  proto native int FindFirstUserReservedLocationIndexForContainer(notnull EntityAI e);
 
  proto native void SetUserReservedLocation(notnull EntityAI eai, notnull InventoryLocation dst);
  proto native void ClearUserReservedLocation(notnull EntityAI eai);
  proto native bool ClearUserReservedLocationAtIndex(int index);
  proto native void ClearUserReservedLocationForContainer(notnull EntityAI eai);
  proto native bool GetDebugFlag();
 
  override EntityAI CreateInInventory(string type)
  {
    EntityAI newEntity = super.CreateInInventory(type);
    if (newEntity == null)
      newEntity = CreateInHands(type);
    return newEntity;
  }
 
  void ClearUserReservedLocationSynced(notnull EntityAI eai)
  {
    if (GetGame().IsClient())
      m_syncClearUserReservationindex = FindUserReservedLocationIndex(eai);
    else if (!GetGame().IsMultiplayer())
    {
      ClearUserReservedLocation(eai);
      eai.GetOnReleaseLock().Invoke(eai);
    }
 
  }
 
  void ClearUserReservedLocationAtIndexSynced(int index)
  {
    if (GetGame().IsClient())
      m_syncClearUserReservationindex = index;
    else if (!GetGame().IsMultiplayer())
    {
      ClearUserReservedLocationAtIndex(index);
 
      InventoryLocation il = new InventoryLocation();
 
      GetUserReservedLocation(index, il);
      EntityAI item = il.GetItem();
      item.GetOnReleaseLock().Invoke(item);
    }
 
  }
 
  Man GetManOwner()
  {
    return Man.Cast(GetInventoryOwner());
  }
 
  bool HasEntityInHands(EntityAI e)
  {
    return e == GetEntityInHands();
  }
 
  bool ProcessHandEvent(HandEventBase e);
 
  void OnHandsStateChanged(HandStateBase src, HandStateBase dst);
  void OnHandsExitedStableState(HandStateBase src, HandStateBase dst);
  void OnHandsEnteredStableState(HandStateBase src, HandStateBase dst);
 
  void OnEntityInHandsCreated(InventoryLocation src)
  {
    InventoryLocation cpy = new InventoryLocation();
    cpy.Copy(src);
    if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] OnEntityInHandsCreated src=" + InventoryLocation.DumpToStringNullSafe(cpy));
    ProcessHandEvent(new HandEventCreated(GetManOwner(), src));
  }
 
  void OnEntityInHandsDestroyed(InventoryLocation src)
  {
    InventoryLocation cpy = new InventoryLocation();
    cpy.Copy(src);
    if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] OnEntityInHandsDestroyed src=" + InventoryLocation.DumpToStringNullSafe(cpy));
    ProcessHandEvent(new HandEventDestroyed(GetManOwner(), cpy));
  }
 
  bool HandEvent(InventoryMode mode, HandEventBase e)
  {
    return true;
  }
 
  override bool DropEntity(InventoryMode mode, EntityAI owner, notnull EntityAI item)
  {
    InventoryLocation src = new InventoryLocation();
    if (item && item.GetInventory() && item.GetInventory().GetCurrentInventoryLocation(src))
    {
      switch (src.GetType())
      {
      case InventoryLocationType.HANDS:
        if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::DropEntity(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        HandEvent(mode, new HandEventDrop(GetManOwner(), src));
        return true;
 
      default:
        return super.DropEntity(mode, owner, item);
      }
    }
 
    Error("No inventory location");
    return false;
  }
 
  bool ThrowEntity(EntityAI item, vector dir, float force)
  {
    if (GetGame().IsServer() && GetGame().IsMultiplayer())
      return false;
 
    DayZPlayer player = DayZPlayer.Cast(item.GetHierarchyRootPlayer());
    InventoryMode invMode = InventoryMode.PREDICTIVE;
 
    if (player.NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), null))
      invMode = InventoryMode.JUNCTURE;
 
    InventoryLocation src = new InventoryLocation();
    if (item && item.GetInventory() && item.GetInventory().GetCurrentInventoryLocation(src))
    {
      switch (src.GetType())
      {
      case InventoryLocationType.HANDS:
        if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::ThrowEntity item=" + item);
        HandEventThrow throwEvent = new HandEventThrow(GetManOwner(), src);
        throwEvent.SetForce(dir * force);
        HandEvent(invMode, throwEvent);
        return true;
 
      default:
        DropEntity(invMode, player, item);
        return true;
      }
    }
    Error("No inventory location");
    return false;
  }
 
  bool RedirectToHandEvent(InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
  {
    if (src.GetType() == InventoryLocationType.HANDS)
    {
      Man man_src = Man.Cast(src.GetParent());
      if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HI::RedirectToHandEvent - source location == HANDS, player has to handle this");
 
      EntityAI item = src.GetItem();
 
      int r_index = FindUserReservedLocationIndex(item);
 
      if (r_index >= 0)
      {
        InventoryLocation r_il = new InventoryLocation();
        GetUserReservedLocation(r_index, r_il);
 
        ClearUserReservedLocationAtIndex(r_index);
        int r_type = r_il.GetType();
        if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
          r_il.GetParent().GetOnReleaseLock().Invoke(item);
        else if (r_type == InventoryLocationType.ATTACHMENT)
          r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(item, r_il.GetSlot());
      }
 
      man_src.GetHumanInventory().HandEvent(mode, new HandEventMoveTo(man_src, src, dst));
      return true;
    }
 
    if (dst.GetType() == InventoryLocationType.HANDS)
    {
      if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HI::RedirectToHandEvent - dst location == HANDS, player has to handle this");
 
      Man man_dst = Man.Cast(dst.GetParent());
      man_dst.GetHumanInventory().HandEvent(mode, new HandEventTake(man_dst, src));
      return true;
    }
    return false;
  }
 
  override bool TakeToDst(InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
  {
    if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] Take2Dst(" + typename.EnumToString(InventoryMode, mode) + ") src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
    if (GetManOwner().IsAlive() && RedirectToHandEvent(mode, src, dst))
      return true;
 
    return super.TakeToDst(mode, src, dst);
  }
 
  override bool TakeEntityToInventory(InventoryMode mode, FindInventoryLocationType flags, notnull EntityAI item)
  {
    InventoryLocation src = new InventoryLocation();
    if (item.GetInventory().GetCurrentInventoryLocation(src))
    {
      InventoryLocation dst = new InventoryLocation();
      if (FindFreeLocationFor(item, flags, dst))
      {
        if (RedirectToHandEvent(mode, src, dst))
          return true;
 
        if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::Take2Inv(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        return super.TakeEntityToInventory(mode, flags, item);
      }
      else
        return false; // no room
    }
    Error("HumanInventory::TakeEntityToInventory: No inventory location");
    return false;
  }
 
  override bool TakeEntityToCargoEx(InventoryMode mode, notnull EntityAI item, int idx, int row, int col)
  {
    InventoryLocation src = new InventoryLocation();
    if (item.GetInventory().GetCurrentInventoryLocation(src))
    {
      switch (src.GetType())
      {
      case InventoryLocationType.HANDS:
        if (GetInventoryOwner().IsAlive())
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::Take2Cgo(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " row=" + row + " col=" + col);
          InventoryLocation dst = new InventoryLocation();
          dst.SetCargo(GetInventoryOwner(), item, idx, row, col, item.GetInventory().GetFlipCargo());
 
          HandEvent(mode, new HandEventMoveTo(GetManOwner(), src, dst));
          return true;
        }
 
        return super.TakeEntityToCargoEx(mode, item, idx, row, col);
 
      default:
        return super.TakeEntityToCargoEx(mode, item, idx, row, col);
      }
    }
 
    Error("HumanInventory::TakeEntityToCargoEx: No inventory location");
    return false;
  }
 
  override bool TakeEntityAsAttachmentEx(InventoryMode mode, notnull EntityAI item, int slot)
  {
    InventoryLocation src = new InventoryLocation();
    if (item.GetInventory().GetCurrentInventoryLocation(src))
    {
      switch (src.GetType())
      {
      case InventoryLocationType.HANDS:
        if (GetInventoryOwner().IsAlive())
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::Take2Att(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " slot=" + slot);
          InventoryLocation dst = new InventoryLocation();
          EntityAI src_entity = GetInventoryOwner();
          dst.SetAttachment(src_entity, item, slot);
 
          HandEvent(mode, new HandEventMoveTo(GetManOwner(), src, dst));
          return true;
        }
 
        return super.TakeEntityAsAttachmentEx(mode, item, slot);
 
      default:
        return super.TakeEntityAsAttachmentEx(mode, item, slot);
      }
    }
 
    Error("HumanInventory::TakeEntityAsAttachmentEx: No inventory location");
    return false;
  }
 
  override bool SwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2)
  {
    InventoryLocation src1, src2, dst1, dst2;
    if (GameInventory.MakeSrcAndDstForSwap(item1, item2, src1, src2, dst1, dst2))
    {
      bool handled = false;
      switch (src1.GetType())
      {
      case InventoryLocationType.HANDS:
        InventoryLocation fswap_dst2 = new InventoryLocation;
        if (SwappingToPreviousLocation(item1, item2, fswap_dst2))
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::Swap HandEventForceSwap(" + typename.EnumToString(InventoryMode, mode) + ") IH=src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2));
          HandEvent(mode, new HandEventForceSwap(GetManOwner(), src1, src2, dst1, fswap_dst2));
        }
        else
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::Swap HandEventSwap(" + typename.EnumToString(InventoryMode, mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + "src2=" + InventoryLocation.DumpToStringNullSafe(src2));
          HandEvent(mode, new HandEventSwap(GetManOwner(), src1, src2, dst1, dst2));
        }
        handled = true;
        break;
      }
 
      switch (src2.GetType())
      {
      case InventoryLocationType.HANDS:
        if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::Swap HandEventSwap2(" + typename.EnumToString(InventoryMode, mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " IH=src2=" + InventoryLocation.DumpToStringNullSafe(src2));
        HandEvent(mode, new HandEventSwap(GetManOwner(), src2, src1, dst2, dst1));
        handled = true;
        break;
      }
 
      if (!handled)
        return super.SwapEntities(mode, item1, item2);
 
      return true;
    }
 
    Error("HumanInventory::SwapEntities: cannot create src1, src2, dst1, dst2");
    return false;
  }
 
  override bool ForceSwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
  {
    InventoryLocation src1, src2, dst1;
    if (GameInventory.MakeSrcAndDstForForceSwap(item1, item2, src1, src2, dst1, item2_dst))
    {
      GameInventory manOwnerInventory = GetManOwner().GetInventory();
 
      if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::FSwap(" + typename.EnumToString(InventoryMode, mode) + ") dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(item2_dst));
      bool handled = false;
      switch (src1.GetType())
      {
      case InventoryLocationType.HANDS:
        if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::FSwap-HND@1(" + typename.EnumToString(InventoryMode, mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " item2_dst=" + InventoryLocation.DumpToStringNullSafe(item2_dst));
        HandEventBase e = new HandEventForceSwap(GetManOwner(), src1, src2, dst1, item2_dst);
        e.ReserveInventory();
        HandEvent(mode, e);
        handled = true;
        break;
 
      }
 
      switch (src2.GetType())
      {
      case InventoryLocationType.HANDS:
        InventoryLocation fswap_dst2 = new InventoryLocation;
        if (SwappingToPreviousLocation(item2, item1, fswap_dst2))
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::FSwap-PREV(" + typename.EnumToString(InventoryMode, mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " fswap_dst2=" + InventoryLocation.DumpToStringNullSafe(fswap_dst2));
          HandEvent(mode, new HandEventForceSwap(GetManOwner(), src1, src2, dst1, fswap_dst2));
        }
        else
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::FSwap-HND@2(" + typename.EnumToString(InventoryMode, mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " item2_dst=" + InventoryLocation.DumpToStringNullSafe(item2_dst));
          HandEvent(mode, new HandEventForceSwap(GetManOwner(), src1, src2, dst1, item2_dst));
        }
 
        handled = true;
        break;
      }
 
      bool returnValue = true;
 
      if (!handled)
        returnValue = super.ForceSwapEntities(mode, item1, item2, item2_dst);
 
      return returnValue;
    }
 
    Error("HumanInventory::ForceSwapEntities: No inventory location");
    return false;
  }
 
  override bool LocalDestroyEntity(notnull EntityAI item)
  {
    InventoryLocation src = new InventoryLocation();
    if (item.GetInventory().GetCurrentInventoryLocation(src))
    {
      switch (src.GetType())
      {
      case InventoryLocationType.HANDS:
        if (GetInventoryOwner().IsAlive())
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::LocalDestroy inv item=" + item);
          HandEvent(InventoryMode.LOCAL, new HandEventDestroy(GetManOwner(), src));
          return true;
        }
 
        return super.LocalDestroyEntity(item);
 
      default:
        return super.LocalDestroyEntity(item);
      }
    }
 
    Error("LocalDestroyEntity: No inventory location");
    return false;
  }
 
  override bool ReplaceItemWithNew(InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
  {
    EntityAI itemInHands = GetEntityInHands();
    if (itemInHands == lambda.m_OldItem)
      return ReplaceItemInHandsWithNew(mode, lambda);
 
    return super.ReplaceItemWithNew(mode, lambda);
  }
 
  bool ReplaceItemElsewhereWithNewInHands(InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
  {
    return ReplaceItemInElsewhereWithNewinHandsImpl(mode, new HandEventDestroyElsewhereAndReplaceWithNewInHands(GetManOwner(), null, lambda));
  }
 
  protected bool ReplaceItemInElsewhereWithNewinHandsImpl(InventoryMode mode, HandEventBase e)
  {
    if (GetEntityInHands())
    {
      Error("[inv] HumanInventory::ReplaceItemInElsewhereWithNewinHandsImpl Item in hands, event=" + e.DumpToString());
      return false;
    }
 
    InventoryLocation dst = e.GetDst();
    if (dst)
    {
      switch (dst.GetType())
      {
      case InventoryLocationType.HANDS:
        if (GetInventoryOwner().IsAlive())
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::ReplaceItemInElsewhereWithNewinHandsImpl event=" + e);
          HandEvent(mode, e);
          return true;
        }
 
        if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::ReplaceItemInElsewhereWithNewinHandsImpl DEAD_owner=" + GetInventoryOwner().GetName() + "=" + GetInventoryOwner());
        Error("HumanInventory::ReplaceItemInElsewhereWithNewinHandsImpl TODO"); // replace-with-new in corpse's hands, not implemented
        return false;
 
      default:
        Error("[inv] HumanInventory::ReplaceItemInElsewhereWithNewinHandsImpl src has to be hands");
        return false;
      }
    }
 
    Error("[inv] HumanInventory::ReplaceItemInElsewhereWithNewinHandsImpl no dst in event, event=" + e.DumpToString());
    return false;
  }
 
  protected bool ReplaceItemInHandsWithNewImpl(InventoryMode mode, HandEventBase e)
  {
    EntityAI itemInHands = GetEntityInHands();
    InventoryLocation src = new InventoryLocation();
    if (itemInHands && itemInHands.GetInventory().GetCurrentInventoryLocation(src))
    {
      switch (src.GetType())
      {
      case InventoryLocationType.HANDS:
        if ((mode != InventoryMode.SERVER) && GetInventoryOwner().IsAlive())
        {
          if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::ReplaceItemInHandsWithNewImpl event=" + e);
          HandEvent(mode, e);
          return true;
        }
 
        if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[inv] HumanInventory::ReplaceItemInHandsWithNewImpl DEAD_owner=" + GetInventoryOwner().GetName() + "=" + GetInventoryOwner());
        HandEvent(mode, e);
        return true;
 
      default:
        Error("[inv] HumanInventory::ReplaceItemInHandsWithNewImpl src has to be hands");
        return false;
      }
    }
 
    Error("[inv] HumanInventory::ReplaceItemInHandsWithNewImpl No item in hands, event=" + e.DumpToString());
    return false;
  }
 
  bool ReplaceItemInHandsWithNew(InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
  {
    return ReplaceItemInHandsWithNewImpl(mode, new HandEventDestroyAndReplaceWithNew(GetManOwner(), null, lambda));
  }
 
  bool ReplaceItemInHandsWithNewElsewhere(InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
  {
    return ReplaceItemInHandsWithNewImpl(mode, new HandEventDestroyAndReplaceWithNewElsewhere(GetManOwner(), null, lambda));
  }
 
  bool SwappingToPreviousLocation(EntityAI item1, EntityAI item2, out InventoryLocation dst)
  {
    bool SwapToPrevious = true;
    InventoryLocation src1 = new InventoryLocation();
    InventoryLocation src2 = new InventoryLocation();
    dst = new InventoryLocation();
    if (item1.GetInventory().GetCurrentInventoryLocation(src1) && item2.GetInventory().GetCurrentInventoryLocation(src2))
    {
      if (item1.m_OldLocation && item1.m_OldLocation.IsValid() && !item1.m_OldLocation.CollidesWith(src2) && item1.m_OldLocation.GetParent() && item1.m_OldLocation.GetParent().GetHierarchyRootPlayer())
      {
        dst.Copy(item1.m_OldLocation);
 
        int count = item1.GetInventory().GetSlotIdCount();
        if (count > 0 && src2.GetType() == InventoryLocationType.ATTACHMENT) //item2 is currently attached somewhere
        {
          for (int i = 0; i < count; i++)
          {
            int slotID = item1.GetInventory().GetSlotId(i);
            if (src2.GetSlot() == slotID) //can be attached into the same slot. And will be.
              return false;
          }
        }
 
        if (!item1.m_OldLocation.GetParent().GetInventory().LocationCanAddEntity(item1.m_OldLocation))
          SwapToPrevious = false;
 
        if (CanSwapEntitiesEx(item1, item2))
          SwapToPrevious = false;
 
        if (SwapToPrevious)
          return true;
      }
    }
 
    return false;
  }
 
  void HandleInventoryManipulation();
 
  void Update(float delta_time)
  {
    HandleInventoryManipulation();
    if (m_syncClearUserReservationindex != -1 && ScriptInputUserData.CanStoreInputUserData())
    {
      ScriptInputUserData ctx = new ScriptInputUserData();
      ctx.Write(INPUT_UDT_INVENTORY);
      ctx.Write(InventoryCommandType.USER_RESERVATION_CANCEL);
      ctx.Write(m_syncClearUserReservationindex);
      ctx.Send();
 
      InventoryLocation il = new InventoryLocation();
 
      GetUserReservedLocation(m_syncClearUserReservationindex, il);
      ClearUserReservedLocationAtIndex(m_syncClearUserReservationindex);
      EntityAI item = il.GetItem();
      item.GetOnReleaseLock().Invoke(item);
      m_syncClearUserReservationindex = -1;
    }
  }
 
  bool ValidateUserReservationCancel(inout Serializer ctx, InventoryValidation validation)
  {
    validation.m_Result = InventoryValidationResult.SUCCESS;
 
    int index = -1;
    if (!ctx.Read(index))
    {
      return true;
    }
 
    ClearUserReservedLocationAtIndex(index);
    //m_UserReservationToClear = index;
 
    return true;
  }
}