InventoryGrid.c

Go to the documentation of this file.

// -----------------------------------------------------------
class InventoryGridController extends ScriptedWidgetEventHandler
{
  void OnItemEnter(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemLeave(InventoryGrid grid, Widget w) {}
  void OnItemDrag(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemDraggingOver(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemDrop(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemDropReceived(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemClick(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemLeftClick(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemRightClick(InventoryGrid grid, Widget w, int row, int col) {}
  void OnItemDoubleClick(InventoryGrid grid, Widget w, int row, int col) {}
  // float GetItemQuantity(InventoryGrid grid, InventoryItem item) {}
  int GetItemColor(ScriptedWidgetEventHandler grid, InventoryItem item)
  {
    return 0;
  }
  int GetQuickbarItemColor(InventoryGrid grid, InventoryItem item) {}
  vector GetItemSize(InventoryGrid grid, InventoryItem item)
  {
    return Vector(0, 1, 1);
  }
  string GetItemQuantityText(InventoryItem item) {}
  int HasItemQuantity(InventoryItem item) {}
  float GetItemQuantity(InventoryItem item) {}
  int GetItemQuantityMax(InventoryItem item) {}
  int GetItemCount(InventoryItem item) {}
  bool CanAddItemInHandToInventory() {}
};
 
// -----------------------------------------------------------
typedef map<InventoryItem, vector> TItemsMap
 
class InventoryGrid extends ScriptedWidgetEventHandler
{
  // AARRGGBB
  static int ITEM_COLOR_QUICKBAR_NORMAL = 0x0AFFFFFF;
  static int ITEM_COLOR_QUICKBAR_H_GOOD = 0x2A6e980d;
  static int ITEM_COLOR_QUICKBAR_H_BAD = 0x2A980d0d;
  static int ITEM_COLOR_QUICKBAR_I_BAD = 0x2A986e0d;
  static int ITEM_COLOR_NORMAL = 0x0AFFFFFF;
  static int ITEM_COLOR_DRAG = 0x0AFFFFFF;
 
  reference bool m_IsDebugOutput;
 
  protected ref map<int, Widget> m_BackgroundWidgets;
  protected ref map<int, Widget> m_ItemWidgets;
  protected ref TItemsMap m_Items;
  protected InventoryGridController m_Controller;
 
 
  protected Widget m_Root;
  protected int m_GridSize;
  protected bool m_IsMouseLeftDown;
  protected bool m_CanAddItemInHandToInventory;
 
  void InventoryGrid()
  {
    m_Items = new TItemsMap;
    m_BackgroundWidgets = new map<int, Widget>;
    m_ItemWidgets = new map<int, Widget>;
  }
 
  protected void OnWidgetScriptInit(Widget w)
  {
    m_Root = w;
    m_Root.SetHandler(this);
  }
 
  // NOTE: This is a cached value, depending on when it is called it might not be 100% accurate
  bool CanAddItemInHandToInventory()
  {
    return m_CanAddItemInHandToInventory;
  }
 
  // ScriptedWidgetEventHandler override
  override bool OnUpdate(Widget w)
  {
    return false;
  }
 
  // -----------------------------------------------------------
  override bool OnMouseEnter(Widget w, int x, int y)
  {
    int col = GetCol(w);
 
    if (!IsValidPos(col))
      return false;
 
    if (m_IsDebugOutput)
      PrintString(m_Root.GetName() + "::OnMouseEnter(" + col.ToString() + ")");
 
    if (m_Controller) m_Controller.OnItemEnter(this, w, 0, col);
 
    return true;
  }
 
  // -----------------------------------------------------------
  override bool OnMouseLeave(Widget w, Widget enterW, int x, int y)
  {
    if (m_Controller) m_Controller.OnItemLeave(this, w);
 
    return true;
  }
 
  // -----------------------------------------------------------
  override bool OnMouseButtonDown(Widget w, int x, int y, int button)
  {
    if (button == MouseState.RIGHT || button == MouseState.LEFT)
    {
      int col = GetCol(w);
 
      if (!IsValidPos(col))
        return false;
 
      if (m_IsDebugOutput)
        PrintString(m_Root.GetName() + "::OnMouseButtonDown(" + col.ToString() + ")");
 
      if (m_Controller)
      {
        if (button == MouseState.RIGHT)
          m_Controller.OnItemRightClick(this, w, 0, col);
 
        if (button == MouseState.LEFT)
          m_IsMouseLeftDown = true;
      }
      return true;
    }
    else
      return false;
  }
 
  // -----------------------------------------------------------
  override bool OnMouseButtonUp(Widget w, int x, int y, int button)
  {
    if (button == MouseState.LEFT)
    {
      if (m_IsMouseLeftDown)
      {
        m_Controller.OnItemLeftClick(this, w, 0, m_col);
        m_IsMouseLeftDown = false;
      }
    }
 
    if (button == MouseState.RIGHT || button == MouseState.LEFT)
    {
      int col = GetCol(w);
 
      if (!IsValidPos(col))
        return false;
 
      if (m_IsDebugOutput)
        PrintString(m_Root.GetName() + "::OnMouseButtonUp(" + col.ToString() + ")");
 
      return true;
    }
    else
      return false;
  }
 
  // -----------------------------------------------------------
  override bool OnDoubleClick(Widget w, int x, int y, int button)
  {
    if (button != MouseState.LEFT) return false;
 
    int col = GetCol(w);
 
    if (!IsValidPos(col))
      return false;
 
    if (m_IsDebugOutput)
      PrintString(m_Root.GetName() + "::OnDoubleClick(" + col.ToString() + ")");
 
    if (m_Controller) m_Controller.OnItemDoubleClick(this, w, 0, col);
 
    return true;
  }
 
  //--------------------------------------------------------------------------
  override bool OnDrop(Widget w, int x, int y, Widget reciever)
  {
    if (m_IsDebugOutput)
      PrintString(m_Root.GetName() + "::OnDrop()");
 
    if (m_Controller)
      m_Controller.OnItemDrop(this, w, 0, m_col);
 
    if (w)
    {
      ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(w.FindAnyWidget("Preview"));
      if (item_preview)
        item_preview.SetView(item_preview.GetItem().GetViewIndex());
    }
 
    return true;
  }
 
  int GetCol(Widget w)
  {
    int index;
 
    if (m_ItemWidgets.GetKeyByValueChecked(w, index))
      return index;
    else if (m_BackgroundWidgets.GetKeyByValueChecked(w, index))
      return index;
    else
      return -1;
  }
 
  int GetColFromBg(Widget w)
  {
    return m_BackgroundWidgets.GetKeyByValue(w);
  }
 
  int GetGridSize()
  {
    return m_GridSize;
  }
 
  void SetGridSize(int size)
  {
    m_GridSize = size;
    for (int i = 0; i < m_BackgroundWidgets.Count(); i++)
    {
      if (i < size)
        m_BackgroundWidgets.Get(i).Show(true);
      else
        m_BackgroundWidgets.Get(i).Show(false);
    }
  }
 
  bool IsValidPos(int index)
  {
    return (m_GridSize > index && index > -1);
  }
 
  private Widget m_on_drag_item;
  private int m_col;
 
  //--------------------------------------------------------------------------
  override bool OnDrag(Widget w, int x, int y)
  {
    w.SetPos(x, y);
 
    m_col = GetCol(w);
 
    if (!IsValidPos(m_col))
      return false;
 
    if (m_IsDebugOutput)
      PrintString(m_Root.GetName() + "::OnDrag(" + m_col.ToString() + ")");
 
    if (m_Controller) m_Controller.OnItemDrag(this, w, 0, m_col);
 
    ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(w.FindAnyWidget("Preview"));
    if (item_preview)
      item_preview.SetView(item_preview.GetItem().GetViewIndex());
    return true;
  }
 
  //--------------------------------------------------------------------------
  override bool OnDraggingOver(Widget w, int x, int y, Widget reciever)
  {
    int col = GetCol(reciever);
 
    if (!IsValidPos(col))
      return false;
 
    if (m_IsDebugOutput)
      PrintString(m_Root.GetName() + "::OnDraggingOver(" + col.ToString() + ")");
 
    if (m_Controller) m_Controller.OnItemDraggingOver(this, w, 0, col);
 
 
    return true;
  }
 
  //--------------------------------------------------------------------------
  override bool OnDropReceived(Widget w, int x, int y, Widget reciever)
  {
    int col = GetCol(reciever);
 
    if (!IsValidPos(col))
      return false;
 
    if (m_IsDebugOutput)
      PrintString(m_Root.GetName() + "::OnDropReceived(" + col.ToString() + ")");
 
    if (m_Controller) m_Controller.OnItemDropReceived(this, w, 0, col);
 
 
    return true;
  }
 
  TItemsMap GetItems()
  {
    return m_Items;
  }
 
  //--------------------------------------------------------------------------
  Widget GetItem(int index)
  {
    if (m_ItemWidgets.Contains(index))
      return m_ItemWidgets.Get(index);
    else
      return null;
  }
 
  //--------------------------------------------------------------------------
  Widget GetItemBackground(int index)
  {
    if (m_BackgroundWidgets.Contains(index))
      return m_BackgroundWidgets.Get(index);
    else
      return null;
  }
 
  Widget GetRoot()
  {
    return m_Root;
  }
 
  void SetItemColor(InventoryItem item, int color)
  {
    if (m_Items.Contains(item))
    {
      vector data = m_Items.Get(item);
      int index = Math.Round(data[0]);
 
      Widget w = GetItem(index);
      if (w)
        w.SetColor(color);
    }
  }
 
  void SetController(InventoryGridController controller)
  {
    m_Controller = controller;
  }
 
  InventoryGridController GetController()
  {
    return m_Controller;
  }
 
  //--------------------------------------------------------------------------
  void GenerateQuickBarBackgroundTiles(int count)
  {
    for (int i = 0; i < count; i++)
    {
      Widget root_widget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory/inventoryGridBackground.layout", m_Root);
      TextWidget label_widget = TextWidget.Cast(root_widget.FindAnyWidget("Label1"));
      TextWidget label_widget2 = TextWidget.Cast(root_widget.FindAnyWidget("Label2"));
      label_widget.SetText((i + 1).ToString());
      label_widget2.SetText((i + 1).ToString());
      m_BackgroundWidgets.Insert(i, root_widget);
    }
  }
 
  //--------------------------------------------------------------------------
  void UpdateQuickbarItems(TItemsMap items)
  {
    int i;
    int c;
    int index;
    int width;
    int height;
    int row;
    int col;
    InventoryItem item;
    vector data;
    Widget bck;
    Widget item_w;
 
    // remove not actual items
    c = m_Items.Count();
    for (i = 0; i < c; i++)
    {
      item = m_Items.GetKey(i);
      if (item != NULL)
      {
        bool remove_item = false;
 
        if (items.Contains(item) == false)
          remove_item = true;
        else
        {
          // check items position actual
          if ((m_Items.Get(item) - items.Get(item)).LengthSq() > 0.01)
          {
            // item has different position or size
            remove_item = true;
          }
        }
 
        if (remove_item)
        {
          RemoveItem(item);
          c--;
          i--;
        }
      }
    }
 
    // add new items
    for (i = 0; i < items.Count(); i++)
    {
      item = items.GetKey(i);
      data = items.Get(item);
 
      if (m_Items.Contains(item) == false)
        AddItem(item, data, Vector(0, 0, 0));
    }
 
    // cache if entity in hands can be added to inventory
    m_CanAddItemInHandToInventory = m_Controller.CanAddItemInHandToInventory();
 
    // refresh quickbar
    for (i = 0; i < items.Count(); i++)
    {
      item = items.GetKey(i);
      data = items.Get(item);
      RefreshQuickbarItemVariables(item, data);
    }
  }
 
 
  //--------------------------------------------------------------------------
  void UpdateItems(TItemsMap items, bool show_quantity, bool show_temperature)
  {
    int i;
    int c;
    int index;
    int width;
    int height;
    int row;
    int col;
    InventoryItem item;
    vector data;
    Widget bck;
    Widget item_w;
 
    // remove not actual items
    c = m_Items.Count();
    for (i = 0; i < c; i++)
    {
      item = m_Items.GetKey(i);
 
      bool remove_item = false;
 
      if (items.Contains(item) == false)
        remove_item = true;
      else
      {
        // check items position actual
        if ((m_Items.Get(item) - items.Get(item)).LengthSq() > 0.01)
        {
          // item has different position or size
          remove_item = true;
        }
      }
 
      if (remove_item)
      {
        RemoveItem(item);
        c--;
        i--;
      }
    }
 
    // add new items
    for (i = 0; i < items.Count(); i++)
    {
      item = items.GetKey(i);
      data = items.Get(item);
 
      if (m_Items.Contains(item) == false)
        AddItem(item, data, Vector(0, 0, 0));
    }
 
    // add new items
    for (i = 0; i < items.Count(); i++)
    {
      item = items.GetKey(i);
      data = items.Get(item);
      // refresh quantity
      RefreshItemVariables(item, data, show_quantity, show_temperature);
    }
  }
 
  //--------------------------------------------------------------------------
  void UpdateQuantityItems()
  {
    int i;
    int index;
    InventoryItem item;
    vector data;
    for (i = 0; i < m_Items.Count(); i++)
    {
      item = m_Items.GetKey(i);
      data = m_Items.Get(item);
      index = Math.Round(data[0]);
      RefreshItemVariables(item, data, true, false);
    }
  }
 
  //--------------------------------------------------------------------------
  void UpdateTemperatureItems()
  {
    int i;
    int index;
    InventoryItem item;
    vector data;
    for (i = 0; i < m_Items.Count(); i++)
    {
      item = m_Items.GetKey(i);
      data = m_Items.Get(item);
      index = Math.Round(data[0]);
      RefreshItemVariables(item, data, false, true);
    }
  }
 
  //--------------------------------------------------------------------------
  void RefreshQuickbarItemVariables(InventoryItem item, vector data)
  {
    int index = Math.Round(data[0]);
    Widget bck = GetItemBackground(index);
    if (bck)
    {
      Widget item_w = bck.FindAnyWidget("GridItem");
      if (item_w)
      {
        int color = m_Controller.GetQuickbarItemColor(this, item); // !!!!!
        item_w.SetColor(color);
      }
    }
    RefreshItemVariables(item, data, true, false);
  }
 
  //--------------------------------------------------------------------------
  void RefreshItemVariables(InventoryItem item, vector data, bool show_quantity, bool show_temperature)
  {
    int index = Math.Round(data[0]);
    Widget bck = GetItemBackground(index);
    Widget item_w;
 
    if (bck)
    {
      item_w = bck.FindAnyWidget("GridItem");
      if (item_w)
      {
        int has_quantity = m_Controller.HasItemQuantity(item);
        Widget quantity_panel = bck.FindAnyWidget("QuantityPanel");
        TextWidget item_quantity = TextWidget.Cast(bck.FindAnyWidget("Quantity"));
        ProgressBarWidget quantity_progress = ProgressBarWidget.Cast(bck.FindAnyWidget("QuantityBar"));
        Widget quantity_stack = bck.FindAnyWidget("QuantityStackPanel");
        if (has_quantity == QUANTITY_HIDDEN)
          quantity_panel.Show(false);
        else
        {
          quantity_panel.Show(true);
          if (has_quantity == QUANTITY_COUNT)
          {
            item_quantity.SetText(m_Controller.GetItemQuantityText(item));
            quantity_stack.Show(true);
            quantity_progress.Show(false);
          }
          else if (has_quantity == QUANTITY_PROGRESS)
          {
            float progress_max = quantity_progress.GetMax();
            int max = m_Controller.GetItemQuantityMax(item);
            int count = m_Controller.GetItemCount(item);
            float quantity = m_Controller.GetItemQuantity(item);
            if (count > 0)
              max = count;
            if (max > 0)
            {
 
              float value = Math.Round((quantity / max) * 100);
              quantity_progress.SetCurrent(value);
            }
            quantity_stack.Show(false);
            quantity_progress.Show(true);
          }
        }
 
        if (show_temperature)
        {
          if (item && item.IsInherited(InventoryItem))
          {
            int color = m_Controller.GetItemColor(this, item); // !!!!!
            if (color)
              item_w.SetColor(color);
          }
        }
      }
    }
  }
 
  //--------------------------------------------------------------------------
  void AddItem(InventoryItem item, vector data, vector rotation)
  {
    m_Items.Set(item, data);
 
    int index = Math.Round(data[0]);
    int width = Math.Round(data[1]);
    int height = Math.Round(data[2]);
 
    Widget bck = GetItemBackground(index);
    Widget item_w_bck = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory/inventoryGridItem.layout", bck);
    Widget item_w = item_w_bck.FindAnyWidget("GridItem");
 
    bck.FindAnyWidget("LabelTR").Show(true);
    bck.FindAnyWidget("LabelCC").Show(false);
 
    m_ItemWidgets.Insert(index, item_w);
 
    ResetItemWidget(item_w, width, height);
 
    if (item)
    {
      ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(item_w.FindAnyWidget("Preview"));
      item_preview.SetItem(item);
      item_preview.SetModelOrientation(rotation);
      item_preview.SetView(item_preview.GetItem().GetViewIndex());
 
      RefreshItemVariables(item, data, true, true);
    }
  }
 
  //--------------------------------------------------------------------------
  void SetItem(InventoryItem item, vector data, vector rotation)
  {
    m_Items.Set(item, data);
 
    int index = Math.Round(data[0]);
    int width = Math.Round(data[1]);
    int height = Math.Round(data[2]);
 
    Widget bck = GetItemBackground(index);
    Widget item_w_bck = bck.FindAnyWidget("GridItemBck");
 
    if (item_w_bck)
    {
      bck.FindAnyWidget("LabelTR").Show(true);
      bck.FindAnyWidget("LabelCC").Show(false);
 
      Widget item_w = item_w_bck.FindAnyWidget("GridItem");
      ResetItemWidget(item_w, width, height);
 
      if (item)
      {
        ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(item_w.FindAnyWidget("Preview"));
        item_preview.SetItem(item);
        item_preview.Show(true);
        item_preview.SetModelOrientation(rotation);
        item_preview.SetView(item_preview.GetItem().GetViewIndex());
 
        RefreshItemVariables(item, data, true, true);
      }
      else
      {
        item_preview = ItemPreviewWidget.Cast(item_w.FindAnyWidget("Preview"));
        item_preview.Show(false);
      }
    }
  }
 
  //--------------------------------------------------------------------------
  protected void ResetItemWidget(Widget item_w, int width, int height)
  {
    if (item_w)
      item_w.SetColor(ITEM_COLOR_NORMAL);
  }
 
  //--------------------------------------------------------------------------
  void ResetItem(InventoryItem item)
  {
    if (m_Items.Contains(item))
    {
      vector data = m_Items.Get(item);
      int index = Math.Round(data[0]);
      int width = Math.Round(data[1]);
      int height = Math.Round(data[2]);
      Widget bck = GetItemBackground(index);
      Widget item_w = bck.FindAnyWidget("GridItem");
      ResetItemWidget(item_w, width, height);
      RefreshItemVariables(item, data, true, true);
    }
  }
 
  //--------------------------------------------------------------------------
  bool HasItem(InventoryItem item)
  {
    return m_Items.Contains(item);
  }
 
  //--------------------------------------------------------------------------
  void RemoveItem(InventoryItem item)
  {
    Widget bck;
    Widget itemW;
    if (item && m_Items.Contains(item))
    {
      vector data = m_Items.Get(item);
      int index = Math.Round(data[0]);
      int width = Math.Round(data[1]);
      int height = Math.Round(data[2]);
      bck = GetItemBackground(index);
      if (bck)
      {
        itemW = bck.FindAnyWidget("GridCell");
        if (itemW)
          delete itemW;
        bck.FindAnyWidget("LabelTR").Show(false);
        bck.FindAnyWidget("LabelCC").Show(true);
      }
 
      m_Items.Remove(item);
      m_ItemWidgets.Remove(index);
    }
  }
};