ItemActionsWidget.c

Go to the documentation of this file.

class ItemActionsWidget extends ScriptedWidgetEventHandler
{
  protected PlayerBase m_Player;
  protected EntityAI m_EntityInHands;
  protected ActionBase m_Interact;
  protected ActionBase m_ContinuousInteract;
  protected ActionBase m_Single;
  protected ActionBase m_Continuous;
  protected ActionManagerClient m_AM;
  protected IngameHud m_Hud;
 
  protected UAIDWrapper m_UseActionWrapper;
 
  protected int m_InteractActionsNum;
  protected int m_ContinuousInteractActionsNum;
  protected int m_ItemActionsNum;
  protected int m_ContinuousItemActionsNum;
  protected bool m_HealthEnabled;
  protected bool m_QuantityEnabled;
 
  protected ref WidgetFadeTimer m_FadeTimer;
  protected bool m_Faded;
  protected bool m_Hidden;
 
  protected Widget m_Root;
  protected Widget m_ItemLeft;
 
  protected float m_MaxWidthChild;
  protected float m_RootWidth;
  protected float m_RootHeight;
 
  void ItemActionsWidget()
  {
    m_Interact = null;
    m_ContinuousInteract = null;
    m_Single = null;
    m_Continuous = null;
    m_AM = null;
 
    m_FadeTimer = new WidgetFadeTimer;
    m_Faded = true;
 
    m_HealthEnabled = true;
    m_QuantityEnabled = true;
 
    m_Hud = GetHud();
    m_Hidden = true;
 
    m_UseActionWrapper = GetUApi().GetInputByID(UAAction).GetPersistentWrapper();
 
    GetGame().GetUpdateQueue(CALL_CATEGORY_GUI).Insert(Update);
    GetGame().GetMission().GetOnInputPresetChanged().Insert(OnInputPresetChanged);
    GetGame().GetMission().GetOnInputDeviceChanged().Insert(OnInputDeviceChanged);
  }
 
  void ~ItemActionsWidget()
  {
    GetGame().GetUpdateQueue(CALL_CATEGORY_GUI).Remove(Update);
  }
 
  void SetInteractXboxIcon(string imageset_name, string image_name) {};
  void SetContinuousInteractXboxIcon(string imageset_name, string image_name) {};
  void SetSingleXboxIcon(string imageset_name, string image_name) {};
  void SetContinuousXboxIcon(string imageset_name, string image_name) {};
  protected void SetXboxIcon(string name, string imageset_name, string image_name) {};
 
  protected void SetControllerIcon(string pWidgetName, string pInputName)
  {
    RichTextWidget w = RichTextWidget.Cast(m_Root.FindAnyWidget(pWidgetName + "_btn_icon_xbox"));
    w.SetText(InputUtils.GetRichtextButtonIconFromInputAction(pInputName, "", EUAINPUT_DEVICE_CONTROLLER));
  }
 
  protected void ShowXboxHidePCIcons(string widget, bool show_xbox_icon)
  {
    m_Root.FindAnyWidget(widget + "_btn_icon_xbox").Show(show_xbox_icon);
    m_Root.FindAnyWidget(widget + "_btn_icon").Show(!show_xbox_icon);
  }
 
  protected void OnWidgetScriptInit(Widget w)
  {
    m_Root = w;
    m_Root.SetHandler(this);
    m_Root.Show(false);
 
    m_ItemLeft = w.FindAnyWidget("ia_item_left");
 
    UpdateControllerInputIcons();
    UpdatePCIconsVisibility();
  }
 
  protected void OnInputPresetChanged()
  {
#ifdef PLATFORM_CONSOLE
    UpdateControllerInputIcons();
#endif
  }
 
  protected void OnInputDeviceChanged(EInputDeviceType pInputDeviceType)
  {
    UpdatePCIconsVisibility();
  }
 
  private void UpdateControllerInputIcons()
  {
    SetControllerIcon("ia_interact", "UAAction");
    SetControllerIcon("ia_continuous_interact", "UAAction");
    SetControllerIcon("ia_single", "UADefaultAction");
    SetControllerIcon("ia_continuous", "UADefaultAction");
  }
 
  private void UpdatePCIconsVisibility()
  {
    bool showConsoleIcons = false;
#ifdef PLATFORM_CONSOLE
    showConsoleIcons = GetGame().GetInput().GetCurrentInputDevice() == EInputDeviceType.CONTROLLER || !GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer();
#endif
 
    ShowXboxHidePCIcons("ia_interact", showConsoleIcons);
    ShowXboxHidePCIcons("ia_continuous_interact", showConsoleIcons);
    ShowXboxHidePCIcons("ia_single", showConsoleIcons);
    ShowXboxHidePCIcons("ia_continuous", showConsoleIcons);
  }
 
  protected void BuildCursor()
  {
    int health = -1;
    int quantityType = 0;
    int quantityMin = -1;
    int quantityMax = -1;
    float quantityCurrent = -1.0;
 
    // item health
    health = GetItemHealth();
    SetItemHealth(health, "ia_item", "ia_item_health_mark", m_HealthEnabled);
 
    // quantity
    if (m_EntityInHands && m_EntityInHands.IsWeapon())
    {
      SetWeaponQuantity(0, 0, "ia_item", "ia_item_quantity_pb", "ia_item_quantity_text", m_QuantityEnabled);
      SetWeaponModeAndZeroing("ia_item_subdesc", "ia_item_subdesc_up", "ia_item_subdesc_down", true);
    }
    else if (m_EntityInHands && m_EntityInHands.IsTransmitter())
    {
      SetRadioFrequency(GetRadioFrequency(), "ia_item_subdesc", "ia_item_subdesc_up", "ia_item_subdesc_down", m_QuantityEnabled);
      GetItemQuantity(quantityType, quantityCurrent, quantityMin, quantityMax);
      SetItemQuantity(quantityType, quantityCurrent, quantityMin, quantityMax, "ia_item", "ia_item_quantity_pb", "ia_item_quantity_text", true);
    }
    else
    {
      GetItemQuantity(quantityType, quantityCurrent, quantityMin, quantityMax);
      SetItemQuantity(quantityType, quantityCurrent, quantityMin, quantityMax, "ia_item", "ia_item_quantity_pb", "ia_item_quantity_text", m_QuantityEnabled);
      SetWeaponModeAndZeroing("ia_item_subdesc", "", "", false);
    }
 
    SetItemDesc(m_EntityInHands, GetItemDesc(m_EntityInHands), "ia_item", "ia_item_desc");
    SetInteractActionIcon("ia_interact", "ia_interact_icon_frame", "ia_interact_btn_inner_icon", "ia_interact_btn_text");
    SetActionWidget(m_Interact, GetActionDesc(m_Interact), "ia_interact", "ia_interact_action_name");
 
    SetInteractActionIcon("ia_continuous_interact", "ia_continuous_interact_icon_frame", "ia_continuous_interact_btn_inner_icon", "ia_continuous_interact_btn_text");
    SetActionWidget(m_ContinuousInteract, GetActionDesc(m_ContinuousInteract), "ia_continuous_interact", "ia_continuous_interact_action_name");
 
    SetActionWidget(m_Single, GetActionDesc(m_Single), "ia_single", "ia_single_action_name");
    SetActionWidget(m_Continuous, GetActionDesc(m_Continuous), "ia_continuous", "ia_continuous_action_name");
    SetMultipleInteractAction("ia_interact_mlt_wrapper");
    SetMultipleContinuousInteractAction("ia_continuous_interact_mlt_wrapper");
    SetMultipleItemAction("ia_single_mlt_wrapper");
    SetMultipleContinuousItemAction("ia_continuous_mlt_wrapper");
  }
 
  protected void Update()
  {
    if (!g_Game.GetProfileOption(EDayZProfilesOptions.HUD) || !m_Hud.IsHudVisible())
    {
      m_Root.Show(false);
      return;
    }
 
    if (m_Player && !m_Player.IsAlive()) // handle respawn
    {
      m_Player = null;
      m_AM = null;
    }
 
    if (!m_Player)
      GetPlayer();
 
    if (!m_AM)
      GetActionManager();
 
    GetActions();
    GetEntityInHands();
 
    if ((m_EntityInHands || !m_Hidden) && GetGame().GetUIManager().GetMenu() == null)
    {
      CheckForActionWidgetOverrides();
      BuildCursor();
      CheckRefresherFlagVisibility();
      m_Root.Show(true);
    }
    else
      m_Root.Show(false);
 
    m_MaxWidthChild = 200;
  }
 
  // getters
  protected void GetPlayer()
  {
    Class.CastTo(m_Player, GetGame().GetPlayer());
  }
 
  protected void GetActionManager()
  {
    if (m_Player && m_Player.IsPlayerSelected())
      ActionManagerClient.CastTo(m_AM, m_Player.GetActionManager());
    else
      m_AM = null;
  }
 
  protected void GetActions()
  {
    m_Interact = null;
    m_ContinuousInteract = null;
    m_Single = null;
    m_Continuous = null;
 
    if (!m_AM)
      return;
 
    if (m_Player.IsSprinting())
      return;
 
    m_Interact = m_AM.GetPossibleAction(InteractActionInput);
    m_ContinuousInteract = m_AM.GetPossibleAction(ContinuousInteractActionInput);
    m_Single = m_AM.GetPossibleAction(DefaultActionInput);
    m_Continuous = m_AM.GetPossibleAction(ContinuousDefaultActionInput);
 
    if (!m_Interact && !m_ContinuousInteract && !m_Continuous && !m_Single)
      m_Hidden = false;
 
    m_InteractActionsNum = m_AM.GetPossibleActionCount(InteractActionInput);
    m_ContinuousInteractActionsNum = m_AM.GetPossibleActionCount(ContinuousInteractActionInput);
    m_ItemActionsNum = m_AM.GetPossibleActionCount(DefaultActionInput);
    m_ContinuousItemActionsNum = m_AM.GetPossibleActionCount(ContinuousDefaultActionInput);
  }
 
  protected void GetEntityInHands()
  {
    if (!m_Player) return;
 
    EntityAI eai = m_Player.GetHumanInventory().GetEntityInHands();
 
    if (eai && !eai.IsInherited(DummyItem))
      m_EntityInHands = eai;
    else
      m_EntityInHands = null;
  }
 
  protected string GetActionDesc(ActionBase action)
  {
    if (action && action.GetText())
      return action.GetText();
 
    return string.Empty;
  }
 
  protected string GetItemDesc(EntityAI entity)
  {
    if (m_EntityInHands)
      return m_EntityInHands.GetDisplayName();
 
    return string.Empty;
  }
 
  protected int GetItemHealth()
  {
    if (m_EntityInHands)
      return m_EntityInHands.GetHealthLevel();
 
    return -1;
  }
 
  protected void GetItemQuantity(out int q_type, out float q_cur, out int q_min, out int q_max)
  {
    if (m_EntityInHands)
    {
      InventoryItem item = InventoryItem.Cast(m_EntityInHands);
      q_type = QuantityConversions.HasItemQuantity(m_EntityInHands);
      if (q_type > 0)
      {
        if (q_type == QUANTITY_PROGRESS)
        {
          QuantityConversions.GetItemQuantity(item, q_cur, q_min, q_max);
 
          q_cur = (q_cur / q_max);
          // to percents
          q_min = 0;
          q_cur = q_cur * 100;
          q_max = 100;
        }
        else
          QuantityConversions.GetItemQuantity(item, q_cur, q_min, q_max);
      }
    }
  }
 
  protected string GetRadioFrequency()
  {
    TransmitterBase trans;
    if (Class.CastTo(trans, m_EntityInHands))
      return trans.GetTunedFrequency().ToString();
 
    return string.Empty;
  }
 
  // setters
  protected void SetItemDesc(EntityAI entity, string descText, string itemWidget, string descWidget)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(itemWidget);
 
    if (entity && m_Player && !m_Player.GetItemAccessor().IsItemInHandsHidden())
    {
      descText.ToUpper();
      TextWidget itemName;
      Class.CastTo(itemName, widget.FindAnyWidget(descWidget));
      itemName.SetText(descText);
      widget.Show(true);
    }
    else
      widget.Show(false);
  }
 
  protected void SetItemHealth(int health, string itemWidget, string healthWidget, bool enabled)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(itemWidget);
 
    if (enabled)
    {
      ImageWidget healthMark;
      Class.CastTo(healthMark, widget.FindAnyWidget(healthWidget));
 
      switch (health)
      {
      case -1 :
        healthMark.GetParent().Show(false);
        break;
      case GameConstants.STATE_PRISTINE :
        healthMark.SetColor(Colors.COLOR_PRISTINE);
        healthMark.SetAlpha(0.5);
        healthMark.GetParent().Show(true);
        break;
      case GameConstants.STATE_WORN :
        healthMark.SetColor(Colors.COLOR_WORN);
        healthMark.SetAlpha(0.5);
        healthMark.GetParent().Show(true);
        break;
      case GameConstants.STATE_DAMAGED :
        healthMark.SetColor(Colors.COLOR_DAMAGED);
        healthMark.SetAlpha(0.5);
        healthMark.GetParent().Show(true);
        break;
      case GameConstants.STATE_BADLY_DAMAGED:
        healthMark.SetColor(Colors.COLOR_BADLY_DAMAGED);
        healthMark.SetAlpha(0.5);
        healthMark.GetParent().Show(true);
        break;
      case GameConstants.STATE_RUINED :
        healthMark.SetColor(Colors.COLOR_RUINED);
        healthMark.SetAlpha(0.5);
        healthMark.GetParent().Show(true);
        break;
      default :
        healthMark.SetColor(0x00FFFFFF);
        healthMark.SetAlpha(0.5);
        healthMark.GetParent().Show(true);
        break;
      }
 
      widget.Show(true);
    }
    else
      widget.Show(false);
  }
 
  protected void SetItemQuantity(int type, float current, int min, int max, string itemWidget, string quantityPBWidget, string quantityTextWidget, bool enabled)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(itemWidget);
 
    if (enabled)
    {
      ProgressBarWidget progressBar;
      TextWidget textWidget;
      Class.CastTo(progressBar, widget.FindAnyWidget(quantityPBWidget));
      Class.CastTo(textWidget, widget.FindAnyWidget(quantityTextWidget));
 
      //check for volume vs. count and display progressbar or "bubble" with exact count/max text
      switch (type)
      {
      case QUANTITY_HIDDEN :
        progressBar.Show(false);
        textWidget.Show(false);
        textWidget.GetParent().Show(false);
        break;
      case QUANTITY_COUNT :
        if (max > 1 || current > 1)
        {
          string qty_text = string.Format("%1/%2", Math.Round(current).ToString(), max.ToString());
          progressBar.Show(false);
          textWidget.SetText(qty_text);
          textWidget.Show(true);
          textWidget.GetParent().Show(true);
          break;
        }
        else
        {
          progressBar.Show(false);
          textWidget.Show(false);
          textWidget.GetParent().Show(false);
          break;
        }
      case QUANTITY_PROGRESS :
        textWidget.Show(false);
        progressBar.SetCurrent(current);
        progressBar.Show(true);
        textWidget.GetParent().Show(true);
        break;
      }
      widget.Show(true);
    }
    else
      widget.Show(false);
  }
 
  protected void SetWeaponQuantity(int chamber, int mag, string itemWidget, string quantityPBWidget, string quantityTextWidget, bool enabled)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(itemWidget);
 
    if (enabled)
    {
      string wpn_qty = "";
 
      ProgressBarWidget progressBar;
      TextWidget textWidget;
      Class.CastTo(progressBar, widget.FindAnyWidget(quantityPBWidget));
      Class.CastTo(textWidget, widget.FindAnyWidget(quantityTextWidget));
 
      Weapon_Base wpn;
      Magazine maga;
      int mag_quantity = -1;
 
      if (Class.CastTo(wpn, m_EntityInHands))
      {
        if (Magnum_Base.Cast(wpn))
        {
          mag_quantity = 0;
          for (int j = 0; j < wpn.GetMuzzleCount(); j++)
          {
            if (wpn.IsChamberFull(j) && !wpn.IsChamberFiredOut(j))
              mag_quantity++;
          }
          wpn_qty = mag_quantity.ToString();
        }
        else
        {
          for (int i = 0; i < wpn.GetMuzzleCount(); i++)
          {
            if (i > 0 && (wpn.GetMuzzleCount() < 3 || i % 2 == 0))
              wpn_qty = wpn_qty + " ";
            if (wpn.IsChamberEmpty(i))
              wpn_qty = wpn_qty + "0";
            else if (wpn.IsChamberFiredOut(i))
              wpn_qty = wpn_qty + "F";
            else
              wpn_qty = wpn_qty + "1";
 
            maga = wpn.GetMagazine(i);
            if (maga)
              mag_quantity = maga.GetAmmoCount();
            else if (wpn.GetInternalMagazineMaxCartridgeCount(i) > 0)
              mag_quantity = wpn.GetInternalMagazineCartridgeCount(i);
 
          }
 
          if (wpn.IsJammed())
          {
            if (mag_quantity != -1)
              wpn_qty = string.Format("X (+%1)", mag_quantity);
            else
              wpn_qty = "X";
          }
          else
          {
            if (mag_quantity != -1)
              wpn_qty = wpn_qty + " (" + mag_quantity.ToString() + ")";
          }
        }
      }
 
      progressBar.Show(false);
      textWidget.SetText(wpn_qty);
      textWidget.Show(true);
      textWidget.GetParent().Show(true);
    }
    else
      widget.Show(false);
  }
 
  protected void SetWeaponModeAndZeroing(string itemWidget, string upWidget, string downWidget, bool enabled)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(itemWidget);
 
    if (enabled && m_Player)
    {
      TextWidget txtModeWidget;
      TextWidget txtZeroingWidget;
 
      Class.CastTo(txtModeWidget, widget.FindAnyWidget(upWidget));
      Class.CastTo(txtZeroingWidget, widget.FindAnyWidget(downWidget));
 
      Weapon w = Weapon.Cast(m_Player.GetHumanInventory().GetEntityInHands());
      string zeroing = string.Empty;
      if (w)
        zeroing = string.Format("%1 m", w.GetCurrentZeroing(w.GetCurrentMuzzle()));
 
      txtModeWidget.SetText(m_Player.GetWeaponManager().GetCurrentModeName());
      txtZeroingWidget.SetText(zeroing);
      widget.Show(true);
    }
    else
      widget.Show(false);
  }
 
  // not used instead of this is used confing parameter for fire mode
  protected string WeaponModeTextTemp()
  {
    return "unused";
  }
 
  protected void SetRadioFrequency(string freq, string itemWidget, string upWidget, string downWidget, bool enabled)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(itemWidget);
 
    if (enabled)
    {
      TextWidget txtUpWidget;
      TextWidget txtDownWidget;
      Class.CastTo(txtUpWidget, widget.FindAnyWidget(upWidget));
      Class.CastTo(txtDownWidget, widget.FindAnyWidget(downWidget));
 
      txtUpWidget.SetText(freq);
      txtDownWidget.SetText("MHz");
      widget.Show(true);
    }
    else
      widget.Show(false);
  }
 
  protected void SetActionWidget(ActionBase action, string descText, string actionWidget, string descWidget)
  {
    Widget widget = m_Root.FindAnyWidget(actionWidget);
 
    if (action && (!action.HasTarget() || (m_Player && m_Player.GetCommand_Vehicle())))
    {
      TextWidget actionName;
      Class.CastTo(actionName, widget.FindAnyWidget(descWidget));
 
 
      if (action.GetInput().GetInputType() == ActionInputType.AIT_CONTINUOUS)
      {
        descText = descText + " " + "#action_target_cursor_hold";
        actionName.SetText(descText);
      }
      else
        actionName.SetText(descText);
 
      widget.Show(true);
    }
    else
      widget.Show(false);
  }
 
  protected void SetMultipleInteractAction(string multiActionsWidget)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(multiActionsWidget);
    widget.Show(m_InteractActionsNum > 1);
  }
 
  protected void SetMultipleContinuousInteractAction(string multiActionsWidget)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(multiActionsWidget);
    widget.Show(m_ContinuousInteractActionsNum > 1);
  }
 
  protected void SetMultipleItemAction(string multiActionsWidget)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(multiActionsWidget);
    widget.Show(m_ItemActionsNum > 1);
  }
 
  protected void SetMultipleContinuousItemAction(string multiActionsWidget)
  {
    Widget widget;
 
    widget = m_Root.FindAnyWidget(multiActionsWidget);
    widget.Show(m_ContinuousItemActionsNum > 1);
  }
 
  protected void SetInteractActionIcon(string actionWidget, string actionIconFrameWidget, string actionIconWidget, string actionIconTextWidget)
  {
    string keyName = string.Empty;
    Widget widget, frameWidget;
    ImageWidget iconWidget;
    TextWidget textWidget;
 
    widget = m_Root.FindAnyWidget(actionWidget);
    Class.CastTo(frameWidget, widget.FindAnyWidget(actionIconFrameWidget));
    Class.CastTo(iconWidget, widget.FindAnyWidget(actionIconWidget));
    Class.CastTo(textWidget, widget.FindAnyWidget(actionIconTextWidget));
 
    m_UseActionWrapper.InputP().SelectAlternative(0); 
    for (int c = 0; c < m_UseActionWrapper.InputP().BindKeyCount(); c++)
    {
      int _hc = m_UseActionWrapper.InputP().GetBindKey(0);
      keyName = GetUApi().GetButtonName(_hc);
    }
 
    // uses text in floating widget
    iconWidget.Show(false);
    textWidget.SetText(keyName);
    textWidget.Show(true);
  }
 
  protected void CheckRefresherFlagVisibility()
  {
    Widget w = m_Root.FindAnyWidget("ia_item_flag_icon");
    if (m_Player && m_Player.GetHologramLocal())
    {
      EntityAI entity = m_Player.GetHologramLocal().GetProjectionEntity();
      w.Show(entity.IsRefresherSignalingViable() && m_Player.IsTargetInActiveRefresherRange(entity));
    }
    else if (w.IsVisible())
      w.Show(false);
  }
 
  protected void CheckForActionWidgetOverrides()
  {
    ItemBase item;
    typename actionName;
    if (Class.CastTo(item, m_EntityInHands) && item.GetActionWidgetOverride(actionName))
    {
      ActionBase action = ActionManagerBase.GetAction(actionName);
      if (action)
        m_Single = action;
    }
  }
 
  protected IngameHud GetHud()
  {
    Mission mission = GetGame().GetMission();
    if (mission)
    {
      IngameHud hud = IngameHud.Cast(mission.GetHud());
      return hud;
    }
 
    return null;
  }
}