VicinitySlotsContainer.c

Go to the documentation of this file.

class VicinitySlotsContainer: Container
{
  protected ref AttachmentsGroupContainer m_Container;
  protected int m_ItemsCount;
  protected int m_SlotsCount;
  protected ref array<EntityAI> m_ShowedItems;
 
  void VicinitySlotsContainer(LayoutHolder parent)
  {
    m_Container = new AttachmentsGroupContainer(this);
    ref SlotsContainer con = new SlotsContainer(m_Container, null);
    m_Container.Insert(con);
    m_Body.Insert(m_Container);
    for (int j = 0; j < ITEMS_IN_ROW; j++)
    {
      SlotsIcon icon = con.GetSlotIcon(j);
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), m_Parent, "OnDropReceivedFromIcon");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), m_Parent, "OnDropReceivedFromHeader");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(), m_Parent, "OnDropReceivedFromHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), m_Parent, "DraggingOverIcon");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), m_Parent, "DraggingOverHeader");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(), m_Parent, "DraggingOverHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
      WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "MouseClick");
      WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown(icon.GetPanelWidget(), this, "MouseButtonDown");
    }
 
    con.SetColumnCount(0);
    con.SetForceShow(true);
 
    WidgetEventHandler.GetInstance().RegisterOnDropReceived(m_Container.GetMainWidget(), m_Parent, "OnDropReceivedFromHeader");
    WidgetEventHandler.GetInstance().RegisterOnDraggingOver(m_Container.GetMainWidget(), m_Parent, "DraggingOverHeader");
 
    m_ShowedItems = new array<EntityAI>;
  }
 
  bool IsItemWithContainerActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent && (ent.GetInventory().GetCargo() || (ent.GetSlotsCountCorrect() > 0 && ent.CanDisplayAnyAttachmentSlot()));
    //TODO: also check for cargo visibility maybe?
  }
 
  override bool IsItemWithQuantityActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent && QuantityConversions.HasItemQuantity(ent) && ent.CanBeSplit();
  }
 
  override bool IsItemActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent && !IsItemWithQuantityActive() && !IsItemWithContainerActive();
  }
 
  bool IsEmptyItemActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent == null;
  }
 
  //TODO MW Adjust this
  override bool IsDisplayable()
  {
    return true;
  }
 
  bool IsTakeable()
  {
    EntityAI ent = GetFocusedItem();
    return ent.IsTakeable();
  }
 
  override bool CanCombineAmmo()
  {
    PlayerBase m_player = PlayerBase.Cast(GetGame().GetPlayer());
    ItemBase ent = ItemBase.Cast(GetFocusedItem());
    ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
    ActionManagerClient amc;
    Class.CastTo(amc, m_player.GetActionManager());
 
    return (amc.CanPerformActionFromInventory(item_in_hands, ent) || amc.CanSetActionFromInventory(item_in_hands, ent));
  }
 
  override bool EquipItem()
  {
    if (CanEquip())
    {
      EntityAI ent = GetFocusedItem();
      bool res = false;
 
      if (ent && !ent.IsInherited(Magazine))
      {
        res = GetGame().GetPlayer().PredictiveTakeOrSwapAttachment(ent);
        if (!res)
          res = GetGame().GetPlayer().GetInventory().TakeEntityToInventory(InventoryMode.JUNCTURE, FindInventoryLocationType.ATTACHMENT, ent);
      }
      return res;
    }
    return false;
  }
 
  override bool InspectItem()
  {
    EntityAI ent = GetFocusedItem();
 
    if (ent)
    {
      InspectItem(ent);
      return true;
    }
    return false;
  }
 
  override bool TransferItem()
  {
    if (CanTakeToInventory())
    {
      ItemBase ent = ItemBase.Cast(GetFocusedItem());
      if (ent)
      {
        if (ent.IsTakeable())
        {
          InventoryLocation il = new InventoryLocation;
          GetGame().GetPlayer().GetInventory().FindFreeLocationFor(ent, FindInventoryLocationType.CARGO, il);
          if (il.IsValid() && GetGame().GetPlayer().GetInventory().LocationCanAddEntity(il))
          {
            SplitItemUtils.TakeOrSplitToInventoryLocation(PlayerBase.Cast(GetGame().GetPlayer()), il);
            return true;
          }
        }
      }
    }
    return false;
  }
 
  override bool Combine()
  {
    ItemBase ent = ItemBase.Cast(GetFocusedItem());
 
    ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
 
    Icon hands_icon = ItemManager.GetInstance().GetHandsPreview().GetIcon();
 
    if (item_in_hands && ent && hands_icon)
      return hands_icon.CombineItems(item_in_hands, ent);
    return false;
  }
 
  override bool Select()
  {
    SlotsIcon selected_slot = ItemManager.GetInstance().GetSelectedIcon();
    EntityAI ent = GetFocusedItem();
    ItemBase selected_item = ItemBase.Cast(ItemManager.GetInstance().GetSelectedItem());
 
    if (!(selected_slot && selected_slot.IsOutOfReach()))
    {
      if (selected_item)
      {
        if (ent != selected_item)
        {
          if (selected_item && GetGame().GetPlayer().CanDropEntity(selected_item))
          {
            bool draggable = false;
 
            PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
            draggable = !player.GetInventory().HasInventoryReservation(selected_item, null) && !player.IsItemsToDelete();
            draggable = draggable && selected_item.GetInventory().CanRemoveEntity();
 
            if (draggable && m_ShowedItems.Find(selected_item) == -1)
            {
              if (selected_item.GetTargetQuantityMax() < selected_item.GetQuantity())
                selected_item.SplitIntoStackMaxClient(null, -1);
              else
                player.PhysicalPredictiveDropItem(selected_item);
              ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
              return true;
            }
          }
        }
      }
      else
      {
        if (ent && ent.GetInventory().CanRemoveEntity())
        {
          EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
          if (item_in_hands)
          {
            if (GameInventory.CanSwapEntitiesEx(item_in_hands, ent))
            {
              GetGame().GetPlayer().PredictiveSwapEntities(item_in_hands, ent);
              return true;
            }
          }
          else
          {
            if (GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands(ent))
            {
              GetGame().GetPlayer().PredictiveTakeEntityToHands(ent);
              return true;
            }
          }
        }
      }
    }
 
    return false;
  }
 
  void ~VicinitySlotsContainer()
  {
    for (int i = 0; i < m_Container.Count(); i++)
    {
      Container c = ClosableContainer.Cast(m_Container.Get(i / ITEMS_IN_ROW));
      if (c && c.GetMainWidget())
        delete m_Container.Get(i / ITEMS_IN_ROW).GetMainWidget();
    }
  }
 
  override void SetLayoutName()
  {
    m_LayoutName = WidgetLayoutName.Container;
  }
 
  override void OnShow()
  {
    super.OnShow();
  }
 
  int GetRowSlotCount()
  {
    return GetFocusedContainer().GetColumnCount();
  }
 
  bool ExcludeFromContainer(EntityAI item)
  {
    int mask = item.GetHideIconMask();
    return mask & EInventoryIconVisibility.HIDE_VICINITY;
  }
 
  void ShowItemsInContainers(array<EntityAI> items)
  {
    EntityAI item;
    SlotsIcon icon;
    int x;
    int visible_items_count = 0;
    int visible_rows = 0;
    ref array<EntityAI> visible_items = new array<EntityAI>;
 
    for (x = 0; x < items.Count(); ++x)
    {
      item = items.Get(x);
 
      if (item == null || ExcludeFromContainer(item))
        continue;
 
      visible_items.Insert(item);
      visible_items_count++;
    }
 
    RecomputeNumberOfContainers(visible_items);
 
    for (x = 0; x < visible_items_count; ++x)
    {
      item = visible_items.Get(x);
      int row = (int)Math.Floor(x / ITEMS_IN_ROW);
      int column = x % ITEMS_IN_ROW;
      icon = SlotsContainer.Cast(m_Container.Get(row)).GetSlotIcon(column);
 
      icon.GetMainWidget().Show(true);
      icon.GetPanelWidget().SetUserID(item.GetID());
 
      if (m_ShowedItems.Find(item) != x)
        icon.Init(item);
      icon.UpdateInterval();
 
      if (!ItemManager.GetInstance().IsDragging())
        ItemManager.GetInstance().SetTemperature(item, icon.GetRender());
 
      bool draggable = ItemManager.GetInstance().EvaluateContainerDragabilityDefault(item);
      if (!draggable && GetDragWidget() == icon.GetPanelWidget())
        CancelWidgetDragging();
      ItemManager.GetInstance().SetWidgetDraggable(icon.GetPanelWidget(), draggable);
 
      ref map<int, ref Container> showed_items = (VicinityContainer.Cast(m_Parent)).m_ShowedItemsIDs;
 
      Container conta = Container.Cast(showed_items.Get(item.GetID()));
      if (conta)
        conta.SetSlotIcon(icon);
 
      if (conta && conta.IsDisplayable())
        conta.UpdateRadialIcon();
      else
      {
        icon.GetRadialIconPanel().Show(false);
        if (conta)
          conta.OnHide();
      }
    }
 
    SlotsContainer slots_last = SlotsContainer.Cast(m_Container.Get(visible_items.Count() / ITEMS_IN_ROW));
 
    for (int c = visible_items_count % ITEMS_IN_ROW; c < ITEMS_IN_ROW; ++c)
    {
      icon = slots_last.GetSlotIcon(c);
      icon.GetMainWidget().Show(false);
      icon.Clear();
    }
 
    //#ifndef PLATFORM_CONSOLE
    if (visible_items_count % ITEMS_IN_ROW == 0)
    {
      slots_last = SlotsContainer.Cast(m_Container.Get(m_Container.Count() - 1));
      slots_last.GetSlotIcon(0).GetMainWidget().Show(true);
      slots_last.GetSlotIcon(0).GetGhostSlot().Show(false);
      slots_last.GetMainWidget().Update();
    }
    //#endif
 
    m_ShowedItems = visible_items;
  }
 
  void DoubleClick(Widget w, int x, int y, int button)
  {
    if (button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
    {
      if (w == null)
        return;
      ItemPreviewWidget iw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
      if (!iw)
      {
        string name = w.GetName();
        name.Replace("PanelWidget", "Render");
        iw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
      }
 
      if (!iw)
        iw = ItemPreviewWidget.Cast(w);
 
      ItemBase item = ItemBase.Cast(iw.GetItem());
      if (!item)
        return;
 
      if (!item.IsTakeable())
        return;
 
      if (GetGame().GetPlayer().GetInventory().HasInventoryReservation(item, null))
        return;
 
      if (!item.GetInventory().CanRemoveEntity())
        return;
 
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
      if (player.GetInventory().HasEntityInInventory(item) && GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands(item))
        player.PredictiveTakeEntityToHands(item);
      else
      {
        InventoryLocation dst = new InventoryLocation;
        player.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ANY, dst);
        if (dst.IsValid() && player.GetInventory().LocationCanAddEntity(dst))
          SplitItemUtils.TakeOrSplitToInventoryLocation(player, dst);
      }
 
      HideOwnedTooltip();
      InventoryMenu menu = InventoryMenu.Cast(GetGame().GetUIManager().FindMenu(MENU_INVENTORY));
      if (menu)
        menu.RefreshQuickbar();
    }
  }
 
  string GetItemQuantityText(EntityAI item)
  {
    string quantity_text = "";
    if (item.IsInherited(InventoryItem))
    {
      ItemBase item_base = ItemBase.Cast(item);
      float quantity = item_base.GetQuantity();
      int ammo;
      if (item.IsInherited(Magazine))
      {
        Magazine magazine_item = Magazine.Cast(item);
        ammo = magazine_item.GetAmmoCount();
        quantity_text = ammo.ToString();
        return quantity_text;
      }
      else if (item.IsInherited(ItemBook))
        return "";
      int max = item.GetQuantityMax();
      //string unit = item.ConfigGetString( "stackedUnit" );
 
      if (max > 0)
      {
        if (max == 1)
        {
          float tmp = Math.Round((quantity / max) * 100);
          quantity_text = tmp.ToString() + "%";
        }
        else
          quantity_text = quantity.ToString();
      }
    }
    return quantity_text;
  }
 
  int HasItemQuantity(EntityAI item)
  {
    if (item.IsInherited(InventoryItem))
    {
      ItemBase item_base = ItemBase.Cast(item);
      if (item.IsInherited(Magazine))
        return QUANTITY_COUNT;
      else if (item.IsInherited(ItemBook))
        return QUANTITY_HIDDEN;
      int max = item.GetQuantityMax();
      bool bar = item.ConfigGetBool("quantityBar");
      if (max > 0)
      {
        if (max == 1 || bar)
          return QUANTITY_PROGRESS;
        else
          return QUANTITY_COUNT;
      }
    }
    return QUANTITY_HIDDEN;
  }
 
  float GetItemQuantity(InventoryItem item)
  {
    float quantity = 0;
    if (item.IsInherited(InventoryItem))
    {
      ItemBase item_base = ItemBase.Cast(item);
      if (item.IsInherited(Magazine))
      {
        Magazine magazine_item = Magazine.Cast(item);
        quantity = magazine_item.GetAmmoCount();
      }
      else
        quantity = item_base.GetQuantity();
    }
    return quantity;
  }
 
  // Mouse button DOWN
  void MouseButtonDown(Widget w, int x, int y, int button)
  {
    string name = w.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    ItemBase item = ItemBase.Cast(item_preview.GetItem());
    bool draggable = ItemManager.GetInstance().EvaluateContainerDragabilityDefault(item);
    ItemManager.GetInstance().SetWidgetDraggable(w, draggable);
  }
 
  // Mouse button UP <---- exist button down MouseButtonDown ^
  void MouseClick(Widget w, int x, int y, int button)
  {
    string name = w.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    EntityAI item = item_preview.GetItem();
    InventoryItem itemAtPos = InventoryItem.Cast(item);
    Container conta;
 
#ifdef DIAG_DEVELOPER
    if (ItemBase.Cast(item))
    {
      if (GetDayZGame().IsLeftCtrlDown() && button == MouseState.RIGHT)
        ShowActionMenu(ItemBase.Cast(item));
    }
#endif
 
    if (m_Parent)
    {
      ref map<int, ref Container> showed_items = (VicinityContainer.Cast(m_Parent)).m_ShowedItemsIDs;
 
      if (item && showed_items)
      {
        conta = showed_items.Get(item.GetID());
 
        (VicinityContainer.Cast(m_Parent)).ToggleContainer(w, item);
        if (button == MouseState.RIGHT)
        {
          if (itemAtPos)
            itemAtPos.OnRightClick();
        }
        else if (button == MouseState.MIDDLE)
        {
          InspectItem(itemAtPos);
          return;
        }
      }
    }
  }
 
  override void OnDropReceivedFromHeader(Widget w, int x, int y, Widget receiver)
  {
    ItemPreviewWidget ipw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
    if (!ipw)
    {
      string name = w.GetName();
      name.Replace("PanelWidget", "Render");
      ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    }
    if (!ipw)
      ipw = ItemPreviewWidget.Cast(w);
 
    if (!ipw.IsInherited(ItemPreviewWidget))
      return;
 
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    ItemBase item = ItemBase.Cast(ipw.GetItem());
 
    if (item)
    {
      if (!item.GetInventory().CanRemoveEntity())
        return;
 
      if (player.CanDropEntity(item))
      {
        if (item.GetTargetQuantityMax() < item.GetQuantity())
          item.SplitIntoStackMaxClient(null, -1);
        else
          player.PhysicalPredictiveDropItem(item);
      }
    }
  }
 
  void RecomputeNumberOfContainers(array<EntityAI> items)
  {
    int number_of_containers = m_Container.m_Body.Count();
    int number_of_containers_needed = (items.Count() / ITEMS_IN_ROW) + 1;
    int difference = number_of_containers_needed - number_of_containers;
    int g;
 
    for (g = number_of_containers; g < number_of_containers_needed; g++)
    {
      SlotsContainer con = new SlotsContainer(m_Container, null);
      m_Container.Insert(con, -1, false);
      for (int j = 0; j < ITEMS_IN_ROW; j++)
      {
        SlotsIcon icon = con.GetSlotIcon(j);
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), m_Parent, "OnDropReceivedFromIcon");
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), m_Parent, "OnDropReceivedFromHeader");
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(), m_Parent, "OnDropReceivedFromHeader");
 
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), m_Parent, "DraggingOverIcon");
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), m_Parent, "DraggingOverHeader");
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(), m_Parent, "DraggingOverHeader");
 
        WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
        WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "MouseClick");
        WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown(icon.GetPanelWidget(), this, "MouseButtonDown");
      }
 
      con.SetColumnCount(items.Count() % ITEMS_IN_ROW);
    }
 
    for (g = number_of_containers - 1 ; g >= number_of_containers_needed ; g--)
    {
      Widget w = m_Container.m_Body.Get(g).GetMainWidget();
      delete w;
      m_Container.m_Body.Remove(g);
    }
 
    if ((items.Count() % ITEMS_IN_ROW) == 0)
      SlotsContainer.Cast(m_Container.Get(number_of_containers_needed - 1)).SetColumnCount(ITEMS_IN_ROW);
    else
      SlotsContainer.Cast(m_Container.Get(number_of_containers_needed - 1)).SetColumnCount(items.Count() % ITEMS_IN_ROW);
 
    for (int i = 0; i < number_of_containers_needed - 1; i++)
      SlotsContainer.Cast(m_Container.Get(i)).SetColumnCount(ITEMS_IN_ROW);
 
    RecomputeOpenedContainers();
    m_Container.RecomputeOpenedContainers();
  }
}