ItemManager.c

Go to the documentation of this file.

class ItemManager
{
  private ref static ItemManager m_Instance;
  protected bool m_IsDragging;
  protected EntityAI m_HoveredItem;
  protected bool m_SlotInfoShown;
  protected EntityAI m_DraggedItem;
  protected Icon m_DraggedIcon;
  protected ref Widget m_TooltipWidget;
  protected ref Widget m_TooltipSlotWidget;
  protected ref Widget m_TooltipCategoryWidget;
  protected ItemPreviewWidget m_ItemPreviewWidget;
  protected Widget m_RootWidget;
  protected ref map<string, bool> m_DefautOpenStates;
  protected ref map<string, bool> m_DefautHeaderOpenStates;
  protected int m_HandsDefaultOpenState;
  protected ref Timer m_ToolTipTimer;
  protected ref Timer m_TooltipSlotTimer;
 
  protected EntityAI m_SelectedItem;
  protected Container m_SelectedContainer;
  protected Widget m_SelectedWidget;
  protected SlotsIcon m_SelectedIcon;
  protected LayoutHolder m_SelectedBaseIcon;
 
  protected HandsPreview m_HandsPreview;
 
  protected bool m_ItemMicromanagmentMode;
 
  protected Widget m_LeftDropzone;
  protected Widget m_CenterDropzone;
  protected Widget m_RightDropzone;
 
  protected int m_TooltipPosX;
  protected int m_TooltipPosY;
  protected Widget m_TooltipSourceWidget; //stored here for tooltip position updates
 
#ifndef PLATFORM_CONSOLE
  protected const float TOOLTIP_DELAY = 0.25; // in seconds
#else
  protected const float TOOLTIP_DELAY = 1.5; // in seconds
#endif
 
  void ItemManager(Widget root)
  {
    m_Instance = this;
    m_RootWidget = root;
    m_DefautOpenStates = new map<string, bool>;
    m_DefautHeaderOpenStates = new map<string, bool>;
    m_SlotInfoShown = false;
 
#ifdef PLATFORM_CONSOLE
    m_TooltipWidget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip_xbox.layout", root);
    m_TooltipSlotWidget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip_slot_xbox.layout", root);
#else
    m_TooltipWidget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip.layout", root);
    m_TooltipSlotWidget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip_slot.layout", root);
#endif
    m_TooltipWidget.Show(false);
    m_TooltipSlotWidget.Show(false);
  }
 
  void SetItemMicromanagmentMode(bool item_micromanagment_mode)
  {
    m_ItemMicromanagmentMode = item_micromanagment_mode;
    Inventory.GetInstance().UpdateConsoleToolbar();
  }
 
  bool IsMicromanagmentMode()
  {
    return m_ItemMicromanagmentMode;
  }
 
  HandsPreview GetHandsPreview()
  {
    return m_HandsPreview;
  }
 
  void SetHandsPreview(HandsPreview hansd_preview)
  {
    m_HandsPreview = hansd_preview;
  }
 
  EntityAI GetSelectedItem()
  {
    return m_SelectedItem;
  }
 
  Container GetSelectedContainer()
  {
    return m_SelectedContainer;
  }
 
  Widget GetSelectedWidget()
  {
    return m_SelectedWidget;
  }
 
  SlotsIcon GetSelectedIcon()
  {
    return m_SelectedIcon;
  }
 
  void SetSelectedItem(EntityAI selected_item, Container selected_container, Widget selected_widget, SlotsIcon selected_icon)
  {
    m_SelectedItem = selected_item;
    m_SelectedContainer = selected_container;
    m_SelectedWidget = selected_widget;
    m_SelectedIcon = selected_icon;
  }
 
  void SetSelectedItemEx(EntityAI selected_item, Container selected_container, LayoutHolder selected_icon)
  {
    SlotsIcon sIcon;
    Icon icon;
 
    m_SelectedItem = selected_item;
    m_SelectedContainer = selected_container;
 
    if (m_SelectedBaseIcon)
    {
      sIcon = SlotsIcon.Cast(m_SelectedBaseIcon);
      icon = Icon.Cast(m_SelectedBaseIcon);
      if (sIcon)
        sIcon.GetMicromanagedPanel().Show(false);
      else if (icon)
        icon.GetMicromanagedPanel().Show(false);
    }
 
    if (selected_icon)
    {
      sIcon = SlotsIcon.Cast(selected_icon);
      icon = Icon.Cast(selected_icon);
 
      if (sIcon)
      {
        m_SelectedWidget = sIcon.GetCursorWidget();
        sIcon.GetMicromanagedPanel().Show(true);
      }
      else if (icon)
      {
        m_SelectedWidget = icon.GetCursorWidget();
        icon.GetMicromanagedPanel().Show(true);
      }
    }
    else
      m_SelectedWidget = null;
    m_SelectedBaseIcon = selected_icon;
  }
 
  void ClearDefaultOpenStates()
  {
    m_DefautOpenStates.Clear();
  }
 
  void ClearDefaultHeaderOpenStates()
  {
    m_DefautHeaderOpenStates.Clear();
  }
 
  void SetDefaultOpenState(string type, bool is_opened)
  {
    m_DefautOpenStates.Set(type, is_opened);
  }
 
  void SetDefaultHeaderOpenState(string type, bool is_opened)
  {
    m_DefautHeaderOpenStates.Set(type, is_opened);
  }
 
  void SetDefaultOpenStateHands(bool is_opened)
  {
    m_HandsDefaultOpenState = is_opened;
    int hands_default_open_state = m_HandsDefaultOpenState; //from bool to int for easier parsing
    GetGame().SetProfileString("defaultOpenStateHands", hands_default_open_state.ToString());
    GetGame().SaveProfile();
  }
 
  bool GetDefaultOpenStateHands()
  {
    string value;
    GetGame().GetProfileString("defaultOpenStateHands", value);
    m_HandsDefaultOpenState = value.ToInt();
    return m_HandsDefaultOpenState;
  }
 
  void SerializeDefaultHeaderOpenStates()
  {
    TStringArray serialized_types = new TStringArray;
 
    for (int i = 0; i < m_DefautHeaderOpenStates.Count(); i++)
    {
      int is_opened = m_DefautHeaderOpenStates.GetElement(i); //from bool to int for easier parsing
      serialized_types.Insert(m_DefautHeaderOpenStates.GetKey(i) + "," + is_opened);
    }
 
    if (serialized_types.Count() > 0)
      GetGame().SetProfileStringList("defaultHeaderOpenStates", serialized_types);
    GetGame().SaveProfile();
  }
 
  void DeserializeDefaultHeaderOpenStates()
  {
    ClearDefaultHeaderOpenStates();
 
    TStringArray serialized_types = new TStringArray;
    GetGame().GetProfileStringList("defaultHeaderOpenStates", serialized_types);
 
    for (int i = 0; i < serialized_types.Count(); i++)
    {
      TStringArray strs = new TStringArray;
      serialized_types.Get(i).Split(",", strs);
      bool is_opened = strs.Get(1).ToInt();
      SetDefaultHeaderOpenState(strs.Get(0), is_opened);
    }
  }
 
  void SerializeDefaultOpenStates()
  {
    TStringArray serialized_types = new TStringArray;
 
    for (int i = 0; i < m_DefautOpenStates.Count(); i++)
    {
      int is_opened = m_DefautOpenStates.GetElement(i); //from bool to int for easier parsing
      serialized_types.Insert(m_DefautOpenStates.GetKey(i) + "," + is_opened);
    }
 
    if (serialized_types.Count() > 0)
      GetGame().SetProfileStringList("defaultOpenStates", serialized_types);
    GetGame().SaveProfile();
  }
 
  void DeserializeDefaultOpenStates()
  {
    ClearDefaultOpenStates();
 
    TStringArray serialized_types = new TStringArray;
    GetGame().GetProfileStringList("defaultOpenStates", serialized_types);
 
    for (int i = 0; i < serialized_types.Count(); i++)
    {
      TStringArray strs = new TStringArray;
      serialized_types.Get(i).Split(",", strs);
      bool is_opened = strs.Get(1).ToInt();
      SetDefaultOpenState(strs.Get(0), is_opened);
    }
  }
 
  bool GetDefaultOpenState(string type)
  {
    if (m_DefautOpenStates.Contains(type))
      return m_DefautOpenStates.Get(type);
    else
      return true;
  }
 
  bool GetDefaultHeaderOpenState(string type)
  {
    if (m_DefautHeaderOpenStates.Contains(type))
      return m_DefautHeaderOpenStates.Get(type);
    else
      return true;
  }
 
  static ItemManager GetInstance()
  {
    return m_Instance;
  }
 
  void HideDropzones()
  {
    GetRightDropzone().SetAlpha(0);
    GetLeftDropzone().SetAlpha(0);
    GetCenterDropzone().SetAlpha(0);
  }
 
  void ShowSourceDropzone(EntityAI item)
  {
    EntityAI owner = item.GetHierarchyParent();
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
    if (item == player)
      GetRightDropzone().SetAlpha(1);
    else if (owner && owner != player)
      ShowSourceDropzone(owner);
    else
    {
      InventoryLocation inv_loc_src = new InventoryLocation;
      item.GetInventory().GetCurrentInventoryLocation(inv_loc_src);
      int loc_type = inv_loc_src.GetType();
      HideDropzones();
      if (loc_type == InventoryLocationType.GROUND)
        GetLeftDropzone().SetAlpha(1);
      else if (loc_type == InventoryLocationType.HANDS)
        GetCenterDropzone().SetAlpha(1);
      else
        GetRightDropzone().SetAlpha(1);
    }
  }
 
  Widget GetLeftDropzone()
  {
    if (!m_LeftDropzone)
      m_LeftDropzone = m_RootWidget.FindAnyWidget("LeftPanel").FindAnyWidget("DropzoneX");
 
    return m_LeftDropzone;
  }
 
  Widget GetRightDropzone()
  {
    if (!m_RightDropzone)
      m_RightDropzone = m_RootWidget.FindAnyWidget("RightPanel").FindAnyWidget("DropzoneX");
    return m_RightDropzone;
  }
 
  Widget GetCenterDropzone()
  {
    if (!m_CenterDropzone)
      m_CenterDropzone = m_RootWidget.FindAnyWidget("HandsPanel").FindAnyWidget("DropzoneX");
    return m_CenterDropzone;
  }
 
  EntityAI GetHoveredItem()
  {
    return m_HoveredItem;
  }
 
  void SetDraggedItem(EntityAI dragged_item)
  {
    m_DraggedItem = dragged_item;
  }
 
  EntityAI GetDraggedItem()
  {
    return m_DraggedItem;
  }
 
  void SetDraggedIcon(Icon dragged_icon)
  {
    m_DraggedIcon = dragged_icon;
  }
 
  Icon GetDraggedIcon()
  {
    return m_DraggedIcon;
  }
 
  void SetIsDragging(bool is_dragging)
  {
    m_IsDragging = is_dragging;
    if (!is_dragging)
    {
      SetDraggedItem(null);
      SetDraggedIcon(null);
    }
  }
 
  bool IsDragging()
  {
    return m_IsDragging;
  }
 
  void HideTooltip()
  {
    m_TooltipWidget.Show(false);
    m_HoveredItem = null;
    delete m_ToolTipTimer;
 
    HideTooltipSlot();
  }
 
  void HideTooltipSlot()
  {
    if (m_SlotInfoShown)
    {
      m_TooltipSlotWidget.Show(false);
      m_SlotInfoShown = false;
      delete m_TooltipSlotTimer;
    }
  }
 
  static int GetItemHealthColor(int pHealthLevel)
  {
    switch (pHealthLevel)
    {
    case -1:
      break;
    case GameConstants.STATE_PRISTINE:
      return Colors.COLOR_PRISTINE;
    case GameConstants.STATE_WORN:
      return Colors.COLOR_WORN;
    case GameConstants.STATE_DAMAGED:
      return Colors.COLOR_DAMAGED;
    case GameConstants.STATE_BADLY_DAMAGED:
      return Colors.COLOR_BADLY_DAMAGED;
    case GameConstants.STATE_RUINED:
      return Colors.COLOR_RUINED;
    }
 
    return 0x00FFFFFF;
  }
 
  static int GetItemHealthColor(EntityAI item, string zone = "")
  {
    if (item)
    {
      switch (item.GetHealthLevel(zone))
      {
      case -1:
        break;
      case GameConstants.STATE_PRISTINE:
        return Colors.COLOR_PRISTINE;
      case GameConstants.STATE_WORN:
        return Colors.COLOR_WORN;
      case GameConstants.STATE_DAMAGED:
        return Colors.COLOR_DAMAGED;
      case GameConstants.STATE_BADLY_DAMAGED:
        return Colors.COLOR_BADLY_DAMAGED;
      case GameConstants.STATE_RUINED:
        return Colors.COLOR_RUINED;
      }
    }
 
    return 0x00FFFFFF;
  }
 
  static int ColorFromFloat(float fraction)
  {
    if (fraction > 1 || fraction < 0)
      return 0x00FFFFFF;
    else if (fraction > 0.80)
      return Colors.COLOR_PRISTINE;
    else if (fraction > 0.6)
      return Colors.COLOR_WORN;
    else if (fraction > 0.4)
      return Colors.COLOR_DAMAGED;
    else if (fraction > 0.2)
      return Colors.COLOR_BADLY_DAMAGED;
    else
      return Colors.COLOR_RUINED;
  }
 
  void SetTemperature(EntityAI item, Widget item_w)
  {
    if (item_w)
    {
      if (true/*show_temperature */)
      {
        if (item && item.IsInherited(ItemBase))
        {
          int color = ColorManager.GetInstance().GetItemColor(ItemBase.Cast(item)); // !!!!!
          if (color)
          {
            string name = item_w.GetName();
            name.Replace("Render", "Temperature");
            Widget temperature_widget = item_w.GetParent().FindAnyWidget(name);
            if (color != -1)
            {
              temperature_widget.Show(true);
              temperature_widget.SetColor(color);
            }
            else
              temperature_widget.Show(false);
 
            temperature_widget.SetAlpha(0.3);
          }
        }
      }
    }
  }
 
  void SetIconTemperature(EntityAI item, Widget item_w)
  {
    if (item_w)
    {
      if (item && item.IsInherited(ItemBase))
      {
        int color = ColorManager.GetInstance().GetItemColor(ItemBase.Cast(item));
 
        if (color)
        {
          Widget color_widget = item_w.FindAnyWidget("Color");
          if (color != -1)
            color_widget.SetColor(color);
          else
            color_widget.SetColor(ColorManager.BASE_COLOR);
        }
      }
    }
  }
 
  void PrepareTooltip(EntityAI item, int x = 0, int y = 0)
  {
    if (IsDragging() || !item)
      return;
 
    if (item.IsInherited(InventoryItem))
    {
      HideTooltip();
 
      m_HoveredItem = item;
      InspectMenuNew.UpdateItemInfo(m_TooltipWidget, item);
 
      int screen_w, screen_h;
      float w, h;
      GetScreenSize(screen_w, screen_h);
      m_TooltipWidget.GetScreenSize(w, h);
 
      if (x == -1)//set by icon focusing
      {
        x = screen_w / 2 - w / 2;
        float x1, y1;
        m_RootWidget.FindAnyWidget("InventoryFrameWidget").GetScreenPos(x1, y1); //allign to the same height
        y = y1;
      }
      else if (x == 0 && y == 0 && GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer())
        GetMousePos(x, y);
 
      //minimal edge distance adjustments..
      screen_w -= 10;
      screen_h -= 10;
 
      int rightEdge = x + w;
      if (rightEdge > screen_w)
        x = screen_w - w;
 
      int bottomEdge = y + h;
      if (bottomEdge > screen_h)
        y = screen_h - h;
 
      m_TooltipWidget.SetPos(x, y);
 
      m_ToolTipTimer = new Timer();
      m_ToolTipTimer.Run(TOOLTIP_DELAY, this, "ShowTooltip");
 
      Widget preview_frame = m_TooltipWidget.FindAnyWidget("ItemFrameWidget");
      if (preview_frame)
      {
        m_ItemPreviewWidget = ItemPreviewWidget.Cast(preview_frame);
        m_ItemPreviewWidget.SetItem(item);
        m_ItemPreviewWidget.SetView(item.GetViewIndex());
      }
    }
  }
 
  void PrepareSlotsTooltip(string name, string desc, int x = 0, int y = 0)
  {
    InspectMenuNew.UpdateSlotInfo(m_TooltipSlotWidget, name, desc);
 
    HideTooltip();
 
    if (name != "")
    {
      m_SlotInfoShown = true;
      //CalculateTooltipSlotPosition(x,y);
      m_TooltipSlotTimer = new Timer();
      m_TooltipSlotTimer.Run(TOOLTIP_DELAY, this, "ShowTooltipSlot");
    }
  }
 
  void CalculateTooltipSlotPosition(int x = 0, int y = 0)
  {
    int screen_w, screen_h;
    float w, h;
    GetScreenSize(screen_w, screen_h);
    //m_TooltipSlotWidget.GetScreenSize(w,h);
    m_TooltipSlotWidget.GetSize(w, h);
    int slot_normal_w = SlotsIcon.GetNormalWidth();
    int slot_normal_h = SlotsIcon.GetNormalHeight();
    //minimal edge distance adjustments..
    screen_w -= 10;
    screen_h -= 10;
 
#ifndef PLATFORM_CONSOLE
    x += 5;
    y += slot_normal_h + 5;
#else
    x += 5;
    y += 15;
#endif
    Widget scrollerWidget = m_TooltipSourceWidget.GetParent();
    while (scrollerWidget)
    {
      if (ScrollWidget.Cast(scrollerWidget))
        break;
      else
        scrollerWidget = scrollerWidget.GetParent();
    }
 
    int rightEdge = x + w;
    if (rightEdge > screen_w)
      x = screen_w - w;
 
    int bottomEdge = y + h;
    if (scrollerWidget)
    {
      float scrollerX, scrollerY, scrollerSizeX, scrollerSizeY;
      scrollerWidget.GetScreenPos(scrollerX, scrollerY);
      scrollerWidget.GetScreenSize(scrollerSizeX, scrollerSizeY);
 
      int scroller_bottom = scrollerY + scrollerSizeY;
      if (bottomEdge > scroller_bottom)
      {
        y = scroller_bottom - slot_normal_h;
        bottomEdge = y + h;
      }
    }
    /*else
      {
      ErrorEx("No scroller widget! | m_TooltipSourceWidget: " + m_TooltipSourceWidget);
      }*/
 
    if (bottomEdge > screen_h) //should mostly never proc now
      y = screen_h - h;
 
    m_TooltipPosX = x;
    m_TooltipPosY = y;
  }
 
  void UpdateTooltipSlotPosition()
  {
    float x, y;
    m_TooltipSourceWidget.GetScreenPos(x, y);
    CalculateTooltipSlotPosition(x, y);
  }
 
  void SetTooltipWidget(Widget w)
  {
    m_TooltipSourceWidget = w;
  }
 
  bool EvaluateContainerDragabilityDefault(EntityAI entity)
  {
    if (!ItemBase.Cast(entity))
      return false;
 
    bool draggable;
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    draggable = !player.GetInventory().HasInventoryReservation(entity, null) && !player.IsItemsToDelete();
    draggable = draggable && entity.CanPutIntoHands(GetGame().GetPlayer());
    draggable = draggable && entity.GetInventory().CanRemoveEntity();
 
    return draggable;
  }
 
  void SetWidgetDraggable(Widget w, bool draggable)
  {
    if (w)
    {
      if (draggable)
        w.SetFlags(WidgetFlags.DRAGGABLE);
      else
        w.ClearFlags(WidgetFlags.DRAGGABLE);
    }
  }
 
  void ShowTooltip()
  {
    if (m_ItemPreviewWidget)
      m_TooltipWidget.Show(true);
  }
 
  void ShowTooltipSlot()
  {
    UpdateTooltipSlotPosition();
    m_TooltipSlotWidget.SetPos(m_TooltipPosX, m_TooltipPosY);
    m_TooltipSlotWidget.Show(true);
  }
 
  static int GetChosenCombinationFlag(EntityAI selectedEntity, EntityAI targetEntity, int relevantFlags, out InventoryLocation dst = null)
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
    if (!selectedEntity || !targetEntity)
      return InventoryCombinationFlags.NONE;
 
    ItemBase selectedItem = ItemBase.Cast(selectedEntity);
    ItemBase targetItem = ItemBase.Cast(targetEntity);
 
    //EntityAI itemInHands = m_player.GetHumanInventory().GetEntityInHands();
    ActionManagerClient amc = ActionManagerClient.Cast(player.GetActionManager());
 
    if (relevantFlags & InventoryCombinationFlags.PERFORM_ACTION)
    {
      if (amc.CanPerformActionFromInventory(targetItem, selectedItem))
        return InventoryCombinationFlags.PERFORM_ACTION;
    }
 
    if (relevantFlags & InventoryCombinationFlags.SET_ACTION)
    {
      if (amc.CanSetActionFromInventory(targetItem, selectedItem))
        return InventoryCombinationFlags.SET_ACTION;
    }
 
    if (relevantFlags & InventoryCombinationFlags.COMBINE_QUANTITY2)
    {
      if (targetEntity.CanBeCombined(selectedEntity))
        return InventoryCombinationFlags.COMBINE_QUANTITY2;
    }
 
    if (relevantFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT)
    {
      if (targetEntity.GetInventory().CanAddAttachment(selectedEntity))
        return InventoryCombinationFlags.ADD_AS_ATTACHMENT;
    }
 
    if (relevantFlags & InventoryCombinationFlags.ADD_AS_CARGO)
    {
      if (!targetEntity.GetInventory().HasEntityInInventory(selectedEntity) && targetEntity.GetInventory().CanAddEntityInCargo(selectedEntity, selectedEntity.GetInventory().GetFlipCargo()))
        return InventoryCombinationFlags.ADD_AS_CARGO;
    }
 
    if (relevantFlags & InventoryCombinationFlags.SWAP_MAGAZINE)
    {
      Magazine mag = Magazine.Cast(targetEntity);
      Weapon_Base wpn = Weapon_Base.Cast(targetEntity.GetHierarchyParent());
      if (wpn && mag)
      {
        if (player.GetWeaponManager().CanSwapMagazine(wpn, Magazine.Cast(selectedEntity)))
          return InventoryCombinationFlags.SWAP_MAGAZINE;
      }
    }
 
    if (relevantFlags & InventoryCombinationFlags.SWAP)
    {
      if (GameInventory.CanSwapEntitiesEx(selectedEntity, targetEntity))
        return InventoryCombinationFlags.SWAP;
    }
 
    if (relevantFlags & InventoryCombinationFlags.FSWAP)
    {
      if (GameInventory.CanForceSwapEntitiesEx(selectedEntity, null, targetEntity, dst))
        return InventoryCombinationFlags.FSWAP;
    }
 
    return InventoryCombinationFlags.NONE;
  }
 
  static int GetCombinationFlags(EntityAI entity1, EntityAI entity2)
  {
    int flags = 0;
    PlayerBase m_player = PlayerBase.Cast(GetGame().GetPlayer());
 
    if (!entity1 || !entity2)
      return flags;
 
    if (entity1.IsInherited(ItemBase) && entity2.IsInherited(ItemBase))
    {
      ItemBase ent1 = ItemBase.Cast(entity1);
      if (ent1.CanBeCombined(ItemBase.Cast(entity2))) flags = flags | InventoryCombinationFlags.COMBINE_QUANTITY2;
    }
 
    if (entity1.GetInventory().CanAddAttachment(entity2))
    {
      if (!entity1.IsInherited(ZombieBase) && !entity1.IsInherited(Car) && !entity2.IsInherited(ZombieBase) && !entity2.IsInherited(Car))
        flags = flags | InventoryCombinationFlags.ADD_AS_ATTACHMENT;
    }
    if (!entity1.GetInventory().HasEntityInInventory(entity2) && entity1.GetInventory().CanAddEntityInCargo(entity2, entity2.GetInventory().GetFlipCargo())) flags = flags | InventoryCombinationFlags.ADD_AS_CARGO;
 
    if (entity1 == m_player.GetHumanInventory().GetEntityInHands() || entity2 == m_player.GetHumanInventory().GetEntityInHands())
    {
      ActionManagerClient amc;
      Class.CastTo(amc, m_player.GetActionManager());
      if (entity1 == m_player.GetHumanInventory().GetEntityInHands())
      {
        if (amc.CanPerformActionFromInventory(ItemBase.Cast(entity1), ItemBase.Cast(entity2)))
          flags = flags | InventoryCombinationFlags.PERFORM_ACTION;
        else if (amc.CanSetActionFromInventory(ItemBase.Cast(entity1), ItemBase.Cast(entity2)))
          flags = flags | InventoryCombinationFlags.SET_ACTION;
      }
      else
      {
        if (amc.CanPerformActionFromInventory(ItemBase.Cast(entity2), ItemBase.Cast(entity1)))
          flags = flags | InventoryCombinationFlags.PERFORM_ACTION;
        else if (amc.CanSetActionFromInventory(ItemBase.Cast(entity2), ItemBase.Cast(entity1)))
          flags = flags | InventoryCombinationFlags.SET_ACTION;
      }
    }
    return flags;
  }
 
  static int GetRecipeCount(bool recipe_anywhere, EntityAI entity1, EntityAI entity2)
  {
    PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
    return plugin_recipes_manager.GetValidRecipes(ItemBase.Cast(entity1), ItemBase.Cast(entity2), NULL, PlayerBase.Cast(GetGame().GetPlayer()));
  }
}