IngameHud.c

Go to the documentation of this file.

class IngameHud extends Hud
{
  protected const float FADE_IN_TIME = 0.3;
  protected const float FADE_OUT_TIME = 0.3;
  protected const float HIDE_MENU_TIME = 5;
 
  protected ref map<int, string> m_StatesWidgetNames;
  protected ref map<int, ImageWidget> m_StatesWidgets; // [key] ImageWidget
 
  protected ref map<ImageWidget, int> m_TendencyStatusCritical; //array of icons that are blinking due to critical tendency status
  protected const float TENDENCY_BLINK_TIME = 0.25;
  protected float m_BlinkTime;
 
  protected ref map<int, string> m_BadgesWidgetNames;
  protected ref map<int, int> m_BadgesSupportedLevels;
  protected ref map<int, int> m_BadgesWidgetDisplay;
  protected ref map<int, ImageWidget> m_BadgesWidgets; // [key] ImageWidget
  protected bool m_AnyBadgeVisible;
  protected bool m_IsTemperatureVisible;
  protected float m_TemperatureTimer;
  protected float m_TemperatureShowTime = 30;
  protected ImageWidget m_HeatBufferPlus;
 
  protected bool m_IsStaminaVisible;
  protected float m_StaminaTimer;
  protected float m_StaminaShowTime = 0.15;
 
  protected ref map<int, string> m_VehicleGearTable;
  protected ref map<int, string> m_VehicleGearTableAuto;
 
  protected Widget m_HudPanelWidget;
  protected Widget m_LeftHudPanelWidget;
  protected Widget m_QuickbarWidget;
  protected ref InventoryQuickbar m_Quickbar;
 
  protected Widget m_VehiclePanel;
 
  protected ImageWidget m_VehicleRPMPointer;
  protected ImageWidget m_VehicleRPMDial;
  protected ImageWidget m_VehicleRPMRedline;
  protected ImageWidget m_VehicleSpeedPointer;
  protected Widget m_VehicleTemperatureIndicator;
  protected ImageWidget m_VehicleTemperaturePointer;
  protected ImageWidget m_VehicleTemperatureLight;
  protected ImageWidget m_VehicleFuelPointer;
  protected ImageWidget m_VehicleFuelLight;
 
  protected TextWidget m_VehicleSpeedValue;
 
  protected TextWidget m_VehicleCurrentGearValue;
  protected TextWidget m_VehicleNextGearValue;
  protected TextWidget m_VehiclePrevGearValue;
 
  protected ImageWidget m_VehicleBatteryLight;
  protected ImageWidget m_VehicleEngineLight;
  protected ImageWidget m_VehicleOilLight;
  protected ImageWidget m_VehicleHandBrakeLight;
  protected ImageWidget m_VehicleWheelLight;
 
  protected bool m_VehicleDamageZoneHitEngineState;
  protected float m_VehicleDamageZonesHitTimer;
 
  protected bool m_InVehicleAsDriver;
  protected CarScript m_CurrentVehicle;
 
 
  protected Widget m_GameStatusIconsPanel;
  protected ImageWidget m_HighPingA;
  protected ImageWidget m_HighPingB;
  protected ImageWidget m_LowServerPerfA;
  protected ImageWidget m_LowServerPerfB;
  protected ImageWidget m_ConnectionLost;
 
  protected Widget m_Notifiers;
  protected TextWidget m_BloodType;
  protected TextWidget m_BloodPosType;
  protected Widget m_BadgeNotifierDivider;
  protected Widget m_Badges;
  protected ref Timer m_HideTimer;
  protected ref WidgetFadeTimer m_FadeTimerCrosshair;
  protected ref WidgetFadeTimer m_FadeTimerActionCursor;
  // protected ref WidgetFadeTimer       m_FadeTimerWeaponMode;
  // protected ref WidgetFadeTimer       m_FadeTimerZeroing;
  protected ref WidgetFadeTimer m_FadeTimerZeroingOld;
  protected ref WidgetFadeTimer m_FadeTimerMagazineName;
  protected ref WidgetFadeTimer m_FadeTimerWeaponName;
  protected ref WidgetFadeTimer m_FadeTimerWeaponStats;
  protected ref WidgetFadeTimer m_FadeTimerQuickbar;
  protected ref WidgetFadeTimer m_FadeTimerWalkieTalkie;
  protected ref WidgetFadeTimer m_FadeTimerWalkieTalkieText;
 
  protected ProgressBarWidget m_Stamina;
  protected Widget m_StaminaBackground;
  protected Widget m_Presence;
  protected Widget m_StanceProne;
  protected Widget m_StanceStand;
  protected Widget m_StanceStandWalk;
  protected Widget m_StanceCrouch;
  protected Widget m_StanceCar;
  protected Widget m_StancePanel;
  protected Widget m_PresenceLevel0;
  protected Widget m_PresenceLevel1;
  protected Widget m_PresenceLevel2;
  protected Widget m_PresenceLevel3;
  protected Widget m_PresenceLevel4;
  protected ref Timer myTimer; //TEMP
  protected ref array<ref WidgetFadeTimer> m_FadeTimers = new array<ref WidgetFadeTimer>;
  protected Widget m_MouseSingleAction;
  protected Widget m_MouseContinuousAction;
  protected Widget m_RadialProgressBar1;
  protected Widget m_RadialProgressBarCrossHair;
  protected Widget m_RadialProgressBar;
  protected Widget m_CursorWidget;
  protected ImageWidget m_CursorIcon;
  protected Widget m_WalkieTalkie;
 
  protected Widget m_ActionWidget;
  protected TextWidget m_ActionDesc;
  protected TextWidget m_ActionItemDesc;
  protected Widget m_ActionItemQuantityWrapper
  protected ImageWidget m_ActionHealthMark;
  protected ProgressBarWidget m_ActionQuantityBar;
  protected Widget m_ActionQuantityBox;
  protected TextWidget m_ActionQuantityBoxText;
  protected ImageWidget m_ActionIcon;
  protected TextWidget m_ActionButtonText;
 
  protected Widget m_ActionIconFrame;
  protected Widget m_ActionMultipleItemsFrame;
 
  protected Widget m_ActionTarget;
  protected ActionTargetsCursor m_ActionTargetsCursor;
 
  // CrossHairs
  protected ImageWidget m_PermanentCrossHair;
 
  protected bool m_HudHideUI;
  protected bool m_HudHidePlayer;
  protected bool m_HudInventory;
  protected bool m_HudState; //options-driven global setting
  protected bool m_QuickbarHideUI;
  protected bool m_QuickbarHidePlayer;
  protected bool m_QuickbarState; //options-driven global setting
  protected bool m_IsQuickbarVisible;
  protected bool m_IsHudVisible;
  protected bool m_Faded;
  protected bool m_ZeroingKeyPressed;
 
  protected Widget m_HitIndicatorUp;
  protected Widget m_HitIndicatorDown;
  protected Widget m_HitIndicatorLeft;
  protected Widget m_HitIndicatorRight;
  protected Widget m_HitIndicatorSingle;
  protected Widget m_SpecializatonPanel;
  protected Widget m_SpecializationIcon;
 
  ref array<ref HitDirectionEffectBase> m_HitDirEffectArray;
 
  void IngameHud()
  {
    m_FadeTimerCrosshair = new WidgetFadeTimer;
    m_FadeTimerActionCursor = new WidgetFadeTimer;
    m_FadeTimerQuickbar = new WidgetFadeTimer;
    m_FadeTimerWalkieTalkie = new WidgetFadeTimer;
    m_FadeTimerWalkieTalkieText = new WidgetFadeTimer;
 
    m_StatesWidgets = new map<int, ImageWidget>; // [key] widgetName
    m_StatesWidgetNames = new map<int, string>;
 
    m_TendencyStatusCritical = new map<ImageWidget, int>;
 
    m_BadgesWidgets = new map<int, ImageWidget>; // [key] widgetName
    m_BadgesWidgetNames = new map<int, string>;
    m_BadgesSupportedLevels = new map<int, int>;
    m_BadgesWidgetDisplay = new map<int, int>;
 
    m_VehicleDamageZonesHitTimer = 0;
 
    m_VehicleGearTable = new map<int, string>;
    m_VehicleGearTable.Set(-1, "");
    m_VehicleGearTable.Set(CarGear.REVERSE, "R");
    m_VehicleGearTable.Set(CarGear.NEUTRAL, "N");
    m_VehicleGearTable.Set(CarGear.FIRST, "1");
    m_VehicleGearTable.Set(CarGear.SECOND, "2");
    m_VehicleGearTable.Set(CarGear.THIRD, "3");
    m_VehicleGearTable.Set(CarGear.FOURTH, "4");
    m_VehicleGearTable.Set(CarGear.FIFTH, "5");
    m_VehicleGearTable.Set(CarGear.SIXTH, "6");
    m_VehicleGearTable.Set(CarGear.SEVENTH, "7");
    m_VehicleGearTable.Set(CarGear.EIGTH, "8");
 
    m_VehicleGearTableAuto = new map<int, string>;
    m_VehicleGearTableAuto.Set(-1, "");
    m_VehicleGearTableAuto.Set(CarAutomaticGearboxMode.R, "R");
    m_VehicleGearTableAuto.Set(CarAutomaticGearboxMode.N, "N");
    m_VehicleGearTableAuto.Set(CarAutomaticGearboxMode.D, "D");
 
  }
 
  override void Init(Widget hud_panel_widget)
  {
    m_HudPanelWidget = hud_panel_widget;
    m_HudPanelWidget.Show(true);
 
    //Quickbar
    m_QuickbarWidget = m_HudPanelWidget.FindAnyWidget("QuickbarGrid");
    m_QuickbarWidget.Show(false);
 
    //Left HUD Panel
    m_LeftHudPanelWidget = m_HudPanelWidget.FindAnyWidget("LeftHUDPanel");
 
    //TEMPORARY HACK!!! player is not present when Hud is being initialized
    myTimer = new Timer(CALL_CATEGORY_GAMEPLAY);
    myTimer.Run(1, this, "InitQuickbar");
 
    m_CursorWidget = m_HudPanelWidget.FindAnyWidget("CursorIcons");
    m_CursorWidget.Show(true);
    Class.CastTo(m_CursorIcon, m_HudPanelWidget.FindAnyWidget("Cursor"));
 
    //Permanent Crosshair
    Class.CastTo(m_PermanentCrossHair, m_HudPanelWidget.FindAnyWidget("PermanentCrossHair"));
 
    m_WalkieTalkie = m_HudPanelWidget.FindAnyWidget("WalkieTalkie");
 
    //Panels
    Class.CastTo(m_Stamina, m_HudPanelWidget.FindAnyWidget("StaminaBar"));
    m_Presence = m_HudPanelWidget.FindAnyWidget("PresencePanel");
    m_Badges = hud_panel_widget.FindAnyWidget("BadgesPanel");
    m_Notifiers = m_HudPanelWidget.FindAnyWidget("NotifiersPanel");
    m_SpecializatonPanel = m_HudPanelWidget.FindAnyWidget("SpecializationPanel");
    m_SpecializationIcon = m_HudPanelWidget.FindAnyWidget("SpecializationIcon");
    m_BadgeNotifierDivider = m_HudPanelWidget.FindAnyWidget("BadgeNotifierDivider");
    m_BloodType = TextWidget.Cast(m_HudPanelWidget.FindAnyWidget("BloodType"));
    m_BloodPosType = TextWidget.Cast(m_HudPanelWidget.FindAnyWidget("BloodPosType"));
 
    m_VehiclePanel = m_HudPanelWidget.FindAnyWidget("VehiclePanel");
    m_VehiclePanel.Show(false);
 
    m_VehicleRPMPointer = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("RPMPointer"));
    m_VehicleRPMDial = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("RPMDial"));
    m_VehicleRPMRedline = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("RPMDialRedline"));
    m_VehicleSpeedPointer = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("SpeedPointer"));
    m_VehicleSpeedValue = TextWidget.Cast(m_VehiclePanel.FindAnyWidget("SpeedValue"));
 
    m_VehicleCurrentGearValue = TextWidget.Cast(m_VehiclePanel.FindAnyWidget("Current"));
    m_VehicleNextGearValue = TextWidget.Cast(m_VehiclePanel.FindAnyWidget("Next"));
    m_VehiclePrevGearValue = TextWidget.Cast(m_VehiclePanel.FindAnyWidget("Prev"));
 
    m_VehicleBatteryLight = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("BatteryLight"));
    m_VehicleEngineLight = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("EngineLight"));
    m_VehicleOilLight = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("OilLight"));
    m_VehicleHandBrakeLight = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("HandBrakeLight"));
    m_VehicleWheelLight = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("WheelLight"));
 
    m_VehicleTemperatureIndicator = m_VehiclePanel.FindAnyWidget("TemperatureIndicator");
    m_VehicleTemperaturePointer = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("TemperaturePointer"));
    m_VehicleTemperatureLight = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("TemperatureLight"));
    m_VehicleFuelPointer = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("FuelPointer"));
    m_VehicleFuelLight = ImageWidget.Cast(m_VehiclePanel.FindAnyWidget("FuelLight"));
 
    m_StaminaBackground = m_HudPanelWidget.FindAnyWidget("StaminaBackground");
    m_StaminaBackground.Show(true);
    m_StanceProne = m_HudPanelWidget.FindAnyWidget("StanceProne");
    m_StanceCrouch = m_HudPanelWidget.FindAnyWidget("StanceCrouch");
    m_StanceStand = m_HudPanelWidget.FindAnyWidget("StanceStand");
    m_StanceStandWalk = m_HudPanelWidget.FindAnyWidget("StanceStandWalk");
    m_StanceCar = m_HudPanelWidget.FindAnyWidget("StanceCar");
    m_StancePanel = m_HudPanelWidget.FindAnyWidget("StancePanel");
 
    m_ActionTarget = m_HudPanelWidget.FindAnyWidget("ActionTargetsCursorWidget");
    m_ActionTarget.GetScript(m_ActionTargetsCursor);
 
    // heat buffer plus sign
    m_HeatBufferPlus = ImageWidget.Cast(m_HudPanelWidget.FindAnyWidget("HeatBuffer"));
 
    //Game State Icons
    m_GameStatusIconsPanel = m_HudPanelWidget.FindAnyWidget("GameStatusIcons");
    m_HighPingA = ImageWidget.Cast(m_HudPanelWidget.FindAnyWidget("HighPingA"));
    m_HighPingB = ImageWidget.Cast(m_HudPanelWidget.FindAnyWidget("HighPingB"));
    m_LowServerPerfA = ImageWidget.Cast(m_HudPanelWidget.FindAnyWidget("LowServerPerfA"));
    m_LowServerPerfB = ImageWidget.Cast(m_HudPanelWidget.FindAnyWidget("LowServerPerfB"));
    m_ConnectionLost = ImageWidget.Cast(m_HudPanelWidget.FindAnyWidget("ConnectionLost"));
 
    if (m_HeatBufferPlus)
      m_HeatBufferPlus.Show(false);
 
#ifndef NO_GUI
    m_Timer = new Timer(CALL_CATEGORY_GAMEPLAY);
    m_Timer.Run(0.333, this, "RefreshQuickbar", NULL, true);
#endif
    InitBadgesAndNotifiers();
 
    m_PresenceLevel0 = hud_panel_widget.FindAnyWidget("Presence0");
    m_PresenceLevel1 = hud_panel_widget.FindAnyWidget("Presence1");
    m_PresenceLevel2 = hud_panel_widget.FindAnyWidget("Presence2");
    m_PresenceLevel3 = hud_panel_widget.FindAnyWidget("Presence3");
    m_PresenceLevel4 = hud_panel_widget.FindAnyWidget("Presence4");
    m_PresenceLevel0.Show(false);
    m_PresenceLevel1.Show(false);
    m_PresenceLevel2.Show(false);
    m_PresenceLevel3.Show(false);
    m_PresenceLevel4.Show(false);
 
    SetLeftStatsVisibility(true);
    m_HudState = g_Game.GetProfileOption(EDayZProfilesOptions.HUD);
    MissionGameplay.Cast(GetGame().GetMission()).GetConnectivityInvoker().Insert(OnConnectionIconsSettingsChanged);
    m_GameStatusIconsPanel.Show(g_Game.GetProfileOption(EDayZProfilesOptions.CONNECTIVITY_INFO));
    //ShowQuickBar(GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer() && g_Game.GetProfileOption(EDayZProfilesOptions.QUICKBAR)); //unreliable
  }
 
  void InitBadgesAndNotifiers()
  {
    // state notifiers
    m_StatesWidgetNames.Clear();
    m_StatesWidgets.Clear();
    m_StatesWidgetNames.Set(NTFKEY_THIRSTY, "Thirsty");
    m_StatesWidgetNames.Set(NTFKEY_HUNGRY, "Hungry");
    m_StatesWidgetNames.Set(NTFKEY_SICK, "Health");
    m_StatesWidgetNames.Set(NTFKEY_BLEEDISH, "Blood");
    m_StatesWidgetNames.Set(NTFKEY_FEVERISH, "Temperature");
 
    m_Notifiers.Show(true);
    m_Badges.Show(true);
 
    int i = 0;
    int key = 0;
    for (i = 0; i < m_StatesWidgetNames.Count(); i++)
    {
      string widget_name = m_StatesWidgetNames.GetElement(i);
      key = m_StatesWidgetNames.GetKey(i);
      ImageWidget w;
      Class.CastTo(w, m_Notifiers.FindAnyWidget(String("Icon" + widget_name)));
      m_StatesWidgets.Set(key, w);
      w.Show(true);
      for (int y = 0; y < 5; y++)
        w.LoadImageFile(y, "set:dayz_gui image:icon" + widget_name + y);
 
      w.SetImage(0);
      float alpha = w.GetAlpha();
      w.SetColor(ARGB(alpha * 255, 220, 220, 220)); //white
      m_TendencyStatusCritical.Remove(w);
      // clear all arrows
      for (int x = 1; x < 4; x++)
      {
        Class.CastTo(w, m_Notifiers.FindAnyWidget(String(widget_name + "ArrowUp" + x.ToString())));
        w.Show(false);
        Class.CastTo(w, m_Notifiers.FindAnyWidget(String(widget_name + "ArrowDown" + x.ToString())));
        w.Show(false);
      }
 
 
    }
 
    // badges
    m_BadgesWidgetNames.Clear();
    m_BadgesWidgets.Clear();
    m_BadgesWidgetDisplay.Clear();
    m_BadgesSupportedLevels.Clear();
 
    m_BadgesWidgetNames.Set(NTFKEY_FRACTURE, "Fracture");
    m_BadgesWidgetNames.Set(NTFKEY_STUFFED, "Stomach");
    m_BadgesWidgetNames.Set(NTFKEY_SICK, "Sick");
    m_BadgesWidgetNames.Set(NTFKEY_WETNESS, "Wetness");
    m_BadgesWidgetNames.Set(NTFKEY_POISONED, "Poisoned");
    m_BadgesWidgetNames.Set(NTFKEY_BLEEDISH, "Bleeding");
    m_BadgesWidgetNames.Set(NTFKEY_LIVES, "Shock");
    m_BadgesWidgetNames.Set(NTFKEY_PILLS, "Pills");
    m_BadgesWidgetNames.Set(NTFKEY_LEGS, "InjuredLegs");
 
    // any badges not included bellow are just ON/OFF
    m_BadgesSupportedLevels.Insert(NTFKEY_LEGS, 3);
 
    for (i = 0; i < m_BadgesWidgetNames.Count(); i++)
    {
      string badge_name = m_BadgesWidgetNames.GetElement(i);
      key = m_BadgesWidgetNames.GetKey(i);
      ImageWidget badge_widget;
 
 
      Class.CastTo(badge_widget, m_Badges.FindAnyWidget(badge_name));
 
      if (m_BadgesSupportedLevels.Contains(key))
      {
        int badgeCountMax = m_BadgesSupportedLevels.Get(key);
 
        for (int q = 0; q < badgeCountMax; q++)
          badge_widget.LoadImageFile(q, "set:dayz_gui image:icon" + badge_name + q);
      }
 
      m_BadgesWidgets.Set(key, badge_widget);
      badge_widget.Show(false);
      m_BadgesWidgetDisplay.Set(key, false);
    }
    m_AnyBadgeVisible = false;
    m_BadgeNotifierDivider.Show(false);
 
  }
 
  void OnConnectionIconsSettingsChanged(bool enabled)
  {
    m_GameStatusIconsPanel.Show(enabled);
  }
 
  override void OnResizeScreen()
  {
    float x, y;
    m_HudPanelWidget.GetScreenSize(x, y);
    m_HudPanelWidget.Update();
    m_Badges.Update();
    m_Notifiers.SetPos(0, 0);
  }
 
  override void Show(bool show)
  {
    m_HudPanelWidget.Show(show);
  }
 
  override void ShowWalkieTalkie(bool show)
  {
    m_FadeTimerWalkieTalkie.Stop();
    m_FadeTimerWalkieTalkieText.Stop();
    m_WalkieTalkie.Show(show);
  }
 
  override void ShowWalkieTalkie(int fadeOutSeconds)
  {
    m_WalkieTalkie.Show(true);
    m_FadeTimerWalkieTalkie.Stop();
    m_FadeTimerWalkieTalkieText.Stop();
    m_FadeTimerWalkieTalkie.FadeOut(m_WalkieTalkie.FindAnyWidget("Icon"), fadeOutSeconds);
    m_FadeTimerWalkieTalkieText.FadeOut(m_WalkieTalkie.FindAnyWidget("Text"), fadeOutSeconds);
  }
 
  override void SetWalkieTalkieText(string text)
  {
    TextWidget txt;
    Class.CastTo(txt, m_WalkieTalkie.FindAnyWidget("Text"));
    txt.SetText(text);
  }
 
  override void SetCursorIcon(string icon)
  {
    if (icon.Length() == 0 || icon == CursorIcons.None)
      m_CursorIcon.Show(false);
    else
    {
      m_CursorIcon.LoadImageFile(0, icon);
      m_CursorIcon.Show(true);
    }
  }
 
  override void ShowCursor()
  {
    m_CursorWidget.Show(true);
  }
 
  override void HideCursor()
  {
    m_CursorWidget.Show(false);
  }
 
  override void SetCursorIconScale(string type, float percentage)
  {
    float x, y;
    m_CursorIcon.FindAnyWidget(type).GetParent().GetSize(x, y);
    m_CursorIcon.FindAnyWidget(type).GetParent().SetSize(x * percentage, y * percentage);
  }
 
  override void SetCursorIconOffset(string type, float x, float y)
  {
    m_CursorIcon.FindAnyWidget(type).GetParent().SetPos(x, y);
  }
 
  override void SetCursorIconSize(string type, float x, float y)
  {
    m_CursorIcon.FindAnyWidget(type).GetParent().SetSize(x, y);
  }
 
#ifdef DIAG_DEVELOPER
  // Debug Crosshair
  override void SetPermanentCrossHair(bool show)
  {
    m_PermanentCrossHair.Show(show);
  }
#endif
 
  override void DisplayNotifier(int key, int tendency, int status)
  {
    ImageWidget w;
    if (key == NTFKEY_FEVERISH)
      DisplayTendencyTemp(key, tendency, status);
    else
      DisplayTendencyNormal(key, tendency, status);
 
    // tendency arrows
    string arrow_name = "ArrowUp";
    if (tendency < 0)
      arrow_name = "ArrowDown";
    tendency = Math.AbsInt(tendency);
 
    for (int x = 1; x < 4; x++)
    {
      Class.CastTo(w, m_Notifiers.FindAnyWidget(String(m_StatesWidgetNames.Get(key) + "ArrowUp" + x.ToString())));
      if (w)
        w.Show(false);
      Class.CastTo(w, m_Notifiers.FindAnyWidget(String(m_StatesWidgetNames.Get(key) + "ArrowDown" + x.ToString())));
      if (w)
        w.Show(false);
    }
 
    if (tendency > 0)
    {
      string widget_name = m_StatesWidgetNames.Get(key) + arrow_name + Math.Clamp(tendency, 1, 3);
      Class.CastTo(w, m_Notifiers.FindAnyWidget(widget_name));
      if (w)
        w.Show(true);
    }
  }
 
  void DisplayTendencyNormal(int key, int tendency, int status)
  {
    ImageWidget w;
    Class.CastTo(w, m_Notifiers.FindAnyWidget(String("Icon" + m_StatesWidgetNames.Get(key))));
 
    if (w)
    {
      w.SetImage(Math.Clamp(status - 1, 0, 4));
      float alpha = w.GetAlpha();
 
      switch (status)
      {
      case 3:
        w.SetColor(ARGB(alpha * 255, 220, 220, 0)); //yellow
        m_TendencyStatusCritical.Remove(w); //remove from blinking group
        break;
      case 4:
        w.SetColor(ARGB(alpha * 255, 220, 0, 0)); //red
        m_TendencyStatusCritical.Remove(w); //remove from blinking group
        break;
      case 5:
        if (!m_TendencyStatusCritical.Contains(w))
        {
          m_TendencyStatusCritical.Insert(w, ARGB(alpha * 255, 220, 0, 0)); //add to blinking group
        }
        break;
      default:
        w.SetColor(ARGB(alpha * 255, 220, 220, 220)); //white
        m_TendencyStatusCritical.Remove(w); //remove from blinking group
        break;
      }
    }
  }
 
  void DisplayTendencyTemp(int key, int tendency, int status)
  {
    ImageWidget w = ImageWidget.Cast(m_Notifiers.FindAnyWidget(String("Icon" + m_StatesWidgetNames.Get(key))));
    TextWidget temp_top = TextWidget.Cast(m_Notifiers.FindAnyWidget("TemperatureValueTop"));
    TextWidget temp_bot = TextWidget.Cast(m_Notifiers.FindAnyWidget("TemperatureValueBottom"));
    //string temp = player..ToString() + "°C";
    float alpha = w.GetAlpha();
 
    if (tendency < 0)
    {
      temp_top.Show(true);
      temp_bot.Show(false);
    }
    else
    {
      temp_top.Show(false);
      temp_bot.Show(true);
    }
 
    switch (status)
    {
    case 2:
      w.SetColor(ARGB(alpha * 255, 220, 220, 0)); //WARNING_PLUS
      m_TendencyStatusCritical.Remove(w);
      w.SetImage(1);
 
      break;
    case 3:
      w.SetColor(ARGB(alpha * 255, 220, 0, 0)); //CRITICAL_PLUS
      m_TendencyStatusCritical.Remove(w);
      w.SetImage(0);
      break;
    case 4:
      if (!m_TendencyStatusCritical.Contains(w)) //BLINKING_PLUS
        m_TendencyStatusCritical.Insert(w, ARGB(alpha * 255, 220, 0, 0));
      w.SetImage(0);
      break;
    case 5:
      w.SetColor(ARGB(alpha * 255, 0, 206, 209)); //WARNING_MINUS
      m_TendencyStatusCritical.Remove(w);
      w.SetImage(3);
      break;
    case 6:
      w.SetColor(ARGB(alpha * 255, 30, 144, 220)); //CRITICAL_MINUS
      m_TendencyStatusCritical.Remove(w);
      w.SetImage(4);
      break;
    case 7: //BLINKING_MINUS
      if (!m_TendencyStatusCritical.Contains(w))
        m_TendencyStatusCritical.Insert(w, ARGB(alpha * 255, 30, 144, 220));
      w.SetImage(4);
      break;
    default:
      w.SetColor(ARGB(alpha * 255, 220, 220, 220)); //DEFAULT
      m_TendencyStatusCritical.Remove(w);
      w.SetImage(2);
      break;
    }
  }
 
  override void DisplayBadge(int key, int value)
  {
    TextWidget bleed_count = TextWidget.Cast(m_Badges.FindAnyWidget("BleedingCount"));
 
    m_BadgesWidgetDisplay.Set(key, value);
    m_AnyBadgeVisible = false;
    for (int i = 0; i < m_BadgesWidgetDisplay.Count(); i++)
    {
      int badge_key = m_BadgesWidgetDisplay.GetKey(i);
      int badge_value = m_BadgesWidgetDisplay.Get(badge_key);
      string badge_name = m_BadgesWidgetNames.Get(badge_key);
 
      ImageWidget badge_widget
      Class.CastTo(badge_widget, m_Badges.FindAnyWidget(badge_name));
      if (badge_widget)
      {
        if (badge_value > 0)
        {
          if (m_BadgesSupportedLevels.Contains(badge_key))
          {
            int levelIndex = badge_value - 1;
            int maxSupportedIndex = m_BadgesSupportedLevels.Get(badge_key) - 1;
            if (maxSupportedIndex >= levelIndex)
              badge_widget.SetImage(levelIndex);
          }
 
          badge_widget.Show(true);
          m_AnyBadgeVisible = true;
          if (badge_key == NTFKEY_BLEEDISH)
          {
            bleed_count.Show(true);
            bleed_count.SetText(m_BadgesWidgetDisplay.Get(badge_key).ToString());
          }
        }
        else
        {
          if (badge_key == NTFKEY_BLEEDISH)
            bleed_count.Show(false);
          badge_widget.Show(false);
        }
      }
    }
 
    RefreshHudVisibility();
  }
 
  override void SetTemperature(string temp)
  {
    m_IsTemperatureVisible = true;
    TextWidget temp_top = TextWidget.Cast(m_Notifiers.FindAnyWidget("TemperatureValueTop"));
    TextWidget temp_bot = TextWidget.Cast(m_Notifiers.FindAnyWidget("TemperatureValueBottom"));
    temp_top.SetText(temp);
    temp_bot.SetText(temp);
    m_TemperatureTimer = 0;
  }
 
  void HideTemperature()
  {
    m_IsTemperatureVisible = false;
    TextWidget temp_top = TextWidget.Cast(m_Notifiers.FindAnyWidget("TemperatureValueTop"));
    TextWidget temp_bot = TextWidget.Cast(m_Notifiers.FindAnyWidget("TemperatureValueBottom"));
    temp_top.SetText("");
    temp_bot.SetText("");
    m_TemperatureTimer = 0;
  }
 
  override void SetStaminaBarVisibility(bool show)
  {
    //m_StaminaBackground.Show( show );
    //m_Stamina.Show( show );
    if (show)
    {
      m_Stamina.SetAlpha(1);
      //m_Stamina.SetTextColor( ColorManager.COLOR_NORMAL_TEXT );
    }
    else
    {
      m_Stamina.SetAlpha(0.3);
      //m_Stamina.SetTextColor( ColorManager.RED_COLOR );
    }
 
    m_IsStaminaVisible = show;
    m_StaminaTimer = 0;
  }
 
  // state 0 = empty
  // state 1 = digesting
  // state 2 = full
  void SetStomachState(int state)
  {
    ImageWidget stomach = ImageWidget.Cast(m_Badges.FindAnyWidget("Stomach"));
    stomach.LoadImageFile(0, "set:dayz_gui image:iconStomach" + state);
  }
 
  override void SetStamina(int value, int range)
  {
    float sx, sy;
    float max = CfgGameplayHandler.GetStaminaMax();
    float percentage = 1;
    if (max != 0)
      percentage = range / max;
 
    if (range != 0)
      m_Stamina.SetCurrent((value / range) * 100);
    else
      m_Stamina.SetCurrent(0);
 
    m_Stamina.GetSize(sx, sy);
    m_Stamina.SetSize(percentage, sy);
    m_StaminaBackground.SetSize(1 - percentage, sy);
 
    // set health & blood values
    if (!GetGame().IsMultiplayer())
    {
      if (GetGame().GetPlayer())
      {
        PlayerBase player;
        Class.CastTo(player, GetGame().GetPlayer());
 
        if (player)
        {
          float h1 = player.GetHealth("", "");
          float b1 = player.GetHealth("", "Blood");
 
          GetDayZGame().GetBacklit().SetHealth(h1);
          GetDayZGame().GetBacklit().SetBlood(b1);
        }
      }
    }
 
    // update backlit
    GetDayZGame().GetBacklit().UpdatePlayer(false);
  }
 
  bool KeyPress(int key)
  {
    return false;
  }
 
  void ZeroingKeyPress()
  {
    m_ZeroingKeyPressed = true;
  }
 
  override void DisplayStance(int stance)
  {
    PlayerBase player;
    Class.CastTo(player, GetGame().GetPlayer());
    Car car;
    if (!Class.CastTo(car, player.GetDrivingVehicle()))
    {
      if (stance == 1)
      {
        bool is_walking;
        m_StanceStand.Show(!is_walking);
        m_StanceStandWalk.Show(is_walking);
        m_StanceCrouch.Show(false);
        m_StanceProne.Show(false);
        m_StanceCar.Show(false);
      }
      if (stance == 2)
      {
        m_StanceStand.Show(false);
        m_StanceStandWalk.Show(false);
        m_StanceCrouch.Show(true);
        m_StanceProne.Show(false);
        m_StanceCar.Show(false);
      }
      if (stance == 3)
      {
        m_StanceStand.Show(false);
        m_StanceStandWalk.Show(false);
        m_StanceCrouch.Show(false);
        m_StanceProne.Show(true);
        m_StanceCar.Show(false);
      }
    }
    else
    {
      m_StanceStand.Show(false);
      m_StanceCrouch.Show(false);
      m_StanceProne.Show(false);
      m_StanceCar.Show(true);
    }
  }
 
  override void DisplayPresence()
  {
    PlayerBase player;
 
    if (Class.CastTo(player, GetGame().GetPlayer()))
    {
      int presence_level = player.GetNoisePresenceInAI();
      m_PresenceLevel0.Show(false);
      m_PresenceLevel1.Show(false);
      m_PresenceLevel2.Show(false);
      m_PresenceLevel3.Show(false);
      m_PresenceLevel4.Show(false);
 
      if (presence_level > 0)
        m_PresenceLevel0.Show(true);
      if (presence_level > 1)
        m_PresenceLevel1.Show(true);
      if (presence_level > 2)
        m_PresenceLevel2.Show(true);
      if (presence_level > 3)
        m_PresenceLevel3.Show(true);
      if (presence_level > 4)
        m_PresenceLevel4.Show(true);
    }
  }
 
  int m_VehicleGearCount = -1;
  float m_TimeSinceLastEngineLightChange;
  bool m_VehicleHasOil;
  bool m_VehicleHasCoolant;
 
  override void ShowVehicleInfo()
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    if (player)
    {
      HumanCommandVehicle hcv = player.GetCommand_Vehicle();
      if (hcv)
      {
        m_CurrentVehicle = CarScript.Cast(hcv.GetTransport());
        if (m_CurrentVehicle)
        {
          m_InVehicleAsDriver = true;
          m_VehicleGearCount = m_CurrentVehicle.GetGearsCount();
          m_VehicleOilLight.Show(m_VehicleHasOil);
 
          float rpm_value_red = m_CurrentVehicle.EngineGetRPMRedline() / m_CurrentVehicle.EngineGetRPMMax();
          m_VehicleRPMDial.SetMaskProgress(rpm_value_red);
          m_VehicleRPMRedline.SetMaskProgress(1 - rpm_value_red);
 
          m_HudPanelWidget.FindAnyWidget("PlayerPanel").Show(false);
          m_Presence.Show(false);
          m_StancePanel.Show(false);
 
          m_VehiclePanel.Show(true);
        }
      }
    }
  }
 
  override void HideVehicleInfo()
  {
    m_HudPanelWidget.FindAnyWidget("PlayerPanel").Show(true);
    m_Presence.Show(true);
    m_StancePanel.Show(true);
    m_VehiclePanel.Show(false);
 
    m_InVehicleAsDriver = false;
    m_CurrentVehicle = null;
    m_VehicleGearCount = -1;
  }
 
  void RefreshVehicleHud(float timeslice)
  {
    if (m_CurrentVehicle && !GetGame().GetUIManager().GetMenu())
    {
      m_VehiclePanel.Show(true);
      float rpm_value = m_CurrentVehicle.EngineGetRPM() / m_CurrentVehicle.EngineGetRPMMax();
      float rpm_value_red = m_CurrentVehicle.EngineGetRPMRedline() / m_CurrentVehicle.EngineGetRPMMax();
      float speed_value = m_CurrentVehicle.GetSpeedometerAbsolute() / 200;
 
      m_VehicleRPMPointer.SetRotation(0, 0, rpm_value * 270 - 130, true);
      m_VehicleSpeedPointer.SetRotation(0, 0, speed_value * 260 - 130, true);
      m_VehicleSpeedValue.SetText(Math.AbsInt(m_CurrentVehicle.GetSpeedometer()).ToString());
 
      int engineHealthLevel = m_CurrentVehicle.GetHealthLevel("Engine");
      int fuelTankHealthLevel = m_CurrentVehicle.GetHealthLevel("FuelTank");
      bool newHealth = false;
 
      if (m_CurrentVehicle.HasEngineZoneReceivedHit())
      {
        if (m_TimeSinceLastEngineLightChange > 0.35)
        {
          m_VehicleEngineLight.Show(!m_VehicleEngineLight.IsVisible());
          if (engineHealthLevel <= GameConstants.STATE_WORN)
            m_VehicleEngineLight.SetColor(Colors.WHITE);
          else
            m_VehicleEngineLight.SetColor(ItemManager.GetItemHealthColor(engineHealthLevel));
 
          m_VehicleEngineLight.SetAlpha(1);
          m_TimeSinceLastEngineLightChange = 0;
        }
 
        m_TimeSinceLastEngineLightChange += timeslice;
        newHealth = true;
      }
      else if (engineHealthLevel > GameConstants.STATE_WORN)
      {
        m_VehicleEngineLight.SetColor(ItemManager.GetItemHealthColor(engineHealthLevel));
        m_VehicleEngineLight.SetAlpha(1);
        m_VehicleEngineLight.Show(true);
      }
      else
        m_VehicleEngineLight.Show(false);
 
      if (fuelTankHealthLevel <= GameConstants.STATE_WORN)
      {
        m_VehicleFuelLight.SetColor(Colors.WHITE);
        m_VehicleFuelLight.SetAlpha(1);
        m_VehicleFuelLight.Show(true);
      }
      else if (fuelTankHealthLevel > GameConstants.STATE_WORN)
      {
        m_VehicleFuelLight.SetColor(ItemManager.GetItemHealthColor(fuelTankHealthLevel));
        m_VehicleFuelLight.SetAlpha(1);
        m_VehicleFuelLight.Show(true);
      }
 
      if (m_CurrentVehicle.IsVitalRadiator())
      {
        m_VehicleTemperatureIndicator.Show(true);
        if (m_CurrentVehicle.HasRadiator())
        {
          int radiatorHealthLevel = m_CurrentVehicle.GetRadiator().GetHealthLevel("");
          if (radiatorHealthLevel <= GameConstants.STATE_WORN)
          {
            m_VehicleTemperatureLight.SetColor(Colors.WHITE);
            m_VehicleTemperatureLight.SetAlpha(1);
            m_VehicleTemperatureLight.Show(true);
          }
          else if (radiatorHealthLevel > GameConstants.STATE_WORN)
          {
            m_VehicleTemperatureLight.SetColor(ItemManager.GetItemHealthColor(radiatorHealthLevel));
            m_VehicleTemperatureLight.SetAlpha(1);
            m_VehicleTemperatureLight.Show(true);
          }
        }
        else
        {
          m_VehicleTemperatureLight.SetColor(Colors.COLOR_RUINED);
          m_VehicleTemperatureLight.SetAlpha(1);
          m_VehicleTemperatureLight.Show(true);
        }
      }
      else
        m_VehicleTemperatureIndicator.Show(false);
 
      m_VehicleHandBrakeLight.Show(m_CurrentVehicle.IsHandbrakeActive());
      m_VehicleWheelLight.Show(m_CurrentVehicle.WheelIsAnyLocked());
 
 
      int engagedGear = -1;
      int prevGear = -1;
      int nextGear = -1;
 
      if (m_CurrentVehicle.GearboxGetType() == CarGearboxType.MANUAL)
      {
        engagedGear = m_CurrentVehicle.GetGear();
        prevGear = engagedGear - 1;
        nextGear = engagedGear + 1;
 
        if (engagedGear == CarGear.NEUTRAL)
          prevGear = CarGear.REVERSE;
        else if (engagedGear == CarGear.REVERSE)
        {
          prevGear = -1;
          nextGear = CarGear.NEUTRAL;
        }
 
        m_VehicleCurrentGearValue.SetText(m_VehicleGearTable.Get(engagedGear));
        m_VehicleNextGearValue.Show(nextGear < m_VehicleGearCount);
 
        m_VehicleNextGearValue.SetText(m_VehicleGearTable.Get(nextGear));
        m_VehiclePrevGearValue.SetText(m_VehicleGearTable.Get(prevGear));
      }
      else
      {
        engagedGear = m_CurrentVehicle.GearboxGetMode();
        prevGear = engagedGear - 1;
        nextGear = engagedGear + 1;
 
        m_VehicleCurrentGearValue.SetText(m_VehicleGearTableAuto.Get(engagedGear));
        m_VehicleNextGearValue.Show(nextGear < EnumTools.GetEnumSize(CarAutomaticGearboxMode));
 
        m_VehicleNextGearValue.SetText(m_VehicleGearTableAuto.Get(nextGear));
        m_VehiclePrevGearValue.SetText(m_VehicleGearTableAuto.Get(prevGear));
      }
 
      // refresh backlit
      GetDayZGame().GetBacklit().RefreshVehicleLayout(engagedGear, newHealth);
 
      m_VehicleFuelPointer.SetRotation(0, 0, m_CurrentVehicle.GetFluidFraction(CarFluid.FUEL) * 260 - 130, true);
      m_VehicleTemperaturePointer.SetRotation(0, 0, -1 * m_CurrentVehicle.GetFluidFraction(CarFluid.COOLANT) * 260 + 130, true);
 
      if (m_VehicleDamageZonesHitTimer > 1)
      {
        m_VehicleDamageZoneHitEngineState = false;
        m_VehicleDamageZonesHitTimer = 0;
      }
 
      m_VehicleDamageZonesHitTimer += timeslice;
    }
    else
      m_VehiclePanel.Show(false);
  }
 
  void InitQuickbar()
  {
    if (m_Quickbar == NULL)
      m_Quickbar = new InventoryQuickbar(m_QuickbarWidget);
  }
 
  InventoryQuickbar GetQuickbar()
  {
    return m_Quickbar;
  }
 
  bool IsQuickbarVisible()
  {
    return m_IsQuickbarVisible;
  }
 
  bool IsHudVisible()
  {
    return m_IsHudVisible;
  }
 
  override void UpdateQuickbarGlobalVisibility()
  {
#ifdef PLATFORM_CONSOLE
    ShowQuickBar(GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer());
#else
    ShowQuickBar(g_Game.GetProfileOption(EDayZProfilesOptions.QUICKBAR));
#endif
  }
 
  void RefreshQuickbarVisibility()
  {
    m_IsQuickbarVisible = !m_QuickbarHideUI && !m_QuickbarHidePlayer && m_QuickbarState;
    m_QuickbarWidget.Show(m_IsQuickbarVisible);
  }
 
  void RefreshHudVisibility()
  {
    m_IsHudVisible = (!m_HudHidePlayer && !m_HudHideUI && m_HudState) || m_HudInventory;
 
    SetLeftStatsVisibility(m_IsHudVisible);
    m_Badges.Show(m_IsHudVisible);
    m_Notifiers.Show(m_IsHudVisible);
    m_BadgeNotifierDivider.Show(m_IsHudVisible && m_AnyBadgeVisible);
#ifdef PLATFORM_CONSOLE
    m_SpecializatonPanel.Show(m_HudInventory);
#else
    m_SpecializatonPanel.Show(false);
#endif
  }
 
  void UpdateSpecialtyMeter(float x, float y)
  {
#ifdef PLATFORM_CONSOLE
    m_SpecializationIcon.SetPos(x, y, true);
#endif
  }
 
  bool IsHideQuickbarPlayer()
  {
    return m_QuickbarHidePlayer;
  }
 
  bool IsHideHudPlayer()
  {
    return m_HudHidePlayer;
  }
 
  override void ShowQuickbarUI(bool show)
  {
    m_QuickbarHideUI = !show;
    RefreshQuickbarVisibility();
  }
 
  override void ShowQuickbarPlayer(bool show)
  {
    m_QuickbarHidePlayer = !show;
    RefreshQuickbarVisibility();
  }
 
  override void ShowHudPlayer(bool show)
  {
    m_HudHidePlayer = !show;
    if (m_HudState)
      RefreshHudVisibility();
  }
 
  override void ShowHudUI(bool show)
  {
    m_HudHideUI = !show;
    if (m_HudState)
      RefreshHudVisibility();
  }
 
  override void ShowHudInventory(bool show)
  {
    m_HudInventory = show;
    RefreshHudVisibility();
  }
 
  override void ToggleHeatBufferPlusSign(bool show)
  {
    m_HeatBufferPlus.Show(show);
  }
 
  override void ShowQuickBar(bool show)
  {
    m_QuickbarState = show;
    //shown by default
    m_QuickbarHidePlayer = false;
    RefreshQuickbarVisibility();
  }
 
  override void ShowHud(bool show)
  {
    m_HudState = show;
    m_HudHidePlayer = false;
    RefreshHudVisibility();
  }
 
  bool GetQuickBarState()
  {
    return m_QuickbarState;
  }
 
  bool GetHudState()
  {
    return m_HudState;
  }
 
 
  override void SetConnectivityStatIcon(EConnectivityStatType type, EConnectivityStatLevel level)
  {
    if (type == EConnectivityStatType.PING)
    {
      switch (level)
      {
      case EConnectivityStatLevel.OFF:
        m_HighPingA.Show(false);
        m_HighPingB.Show(false);
        break;
      case EConnectivityStatLevel.LEVEL1:
        m_HighPingA.Show(true);
        m_HighPingB.Show(false);
        break;
      case EConnectivityStatLevel.LEVEL2:
        m_HighPingA.Show(false);
        m_HighPingB.Show(true);
        break;
      }
    }
    else if (type == EConnectivityStatType.SERVER_PERF)
    {
      switch (level)
      {
      case EConnectivityStatLevel.OFF:
        m_LowServerPerfA.Show(false);
        m_LowServerPerfB.Show(false);
        break;
      case EConnectivityStatLevel.LEVEL1:
        m_LowServerPerfA.Show(true);
        m_LowServerPerfB.Show(false);
        break;
      case EConnectivityStatLevel.LEVEL2:
        m_LowServerPerfA.Show(false);
        m_LowServerPerfB.Show(true);
        break;
      }
    }
    else if (type == EConnectivityStatType.CONN_LOST)
    {
      switch (level)
      {
      case EConnectivityStatLevel.OFF:
        m_ConnectionLost.Show(false);
        break;
      case EConnectivityStatLevel.LEVEL1:
        m_ConnectionLost.Show(true);
        break
      }
    }
  }
 
  void SetLeftStatsVisibility(bool visible)
  {
    Widget child = m_LeftHudPanelWidget.GetChildren();
    while (child)
    {
      if (child.GetName() == "ChatFrameWidget")
      {
        child = child.GetSibling();
        continue
      }
 
      child.Show(visible);
      child = child.GetSibling();
    }
  }
 
  override void RefreshQuickbar(bool itemChanged = false)
  {
    if ((!m_QuickbarState || m_QuickbarHidePlayer || m_QuickbarHideUI) && !itemChanged) // Don't update when it is hidden or disabled
      return;
 
    if (itemChanged)
    {
      UIManager manager = GetGame().GetUIManager();
 
      InventoryMenu inventory = InventoryMenu.Cast(manager.FindMenu(MENU_INVENTORY));
      MissionGameplay mission = MissionGameplay.Cast(GetGame().GetMission());
 
      if (mission)
        inventory = mission.GetInventory();
 
      if (inventory)
        inventory.RefreshQuickbar();
    }
 
    if (m_Quickbar)
      m_Quickbar.UpdateItems(m_QuickbarWidget);
  }
 
  Widget GetHudPanelWidget()
  {
    return m_HudPanelWidget;
  }
 
  override void UpdateBloodName()
  {
    PlayerBase player;
    Class.CastTo(player, GetGame().GetPlayer());
 
    if (player)
    {
      string blood_name;
      bool positive;
      BloodTypes.GetBloodTypeName(player.GetBloodType(), blood_name, positive);
      bool blood_type_visible = player.HasBloodTypeVisible();
 
      if (blood_type_visible)
      {
        m_BloodType.SetText(blood_name);
        if (positive)
          m_BloodPosType.SetText("+");
        else
          m_BloodPosType.SetText("-");
      }
      else
      {
        m_BloodType.SetText("");
        m_BloodPosType.SetText("");
      }
    }
  }
 
  void RefreshPlayerTags()
  {
    if (GetGame().GetPlayer())
    {
      bool found = false;
      vector head_pos = GetGame().GetCurrentCameraPosition();
      float distance;
      foreach (Man player : ClientData.m_PlayerBaseList)
      {
        vector target_player = player.GetPosition();
        distance = vector.Distance(head_pos, target_player);
 
        target_player[1] = target_player[1] + 1.2;
 
        if (distance <= 15 && player != GetGame().GetPlayer())
        {
          vector screen_pos = GetGame().GetScreenPosRelative(target_player);
          vector end_pos = head_pos + GetGame().GetCurrentCameraDirection() * 25;
          RaycastRVParams params = new RaycastRVParams(head_pos, end_pos, GetGame().GetPlayer(), 0);
          params.sorted = true;
 
          array<ref RaycastRVResult> results = new array<ref RaycastRVResult>;
          DayZPhysics.RaycastRVProxy(params, results);
          if (results.Count() > 0)
          {
            if (results.Get(0).obj == player)
            {
              m_CurrentTaggedPlayer = PlayerBase.Cast(player);
              found = true;
            }
          }
        }
      }
      if (!found)
        m_CurrentTaggedPlayer = null;
    }
  }
 
  int m_PlayerSpineIndex;
  PlayerBase m_CurrentTaggedPlayer;
  Widget m_PlayerTag;
  TextWidget m_PlayerTagText;
 
  void ShowPlayerTag(float timeslice)
  {
    if (m_CurrentTaggedPlayer && m_CurrentTaggedPlayer.GetIdentity())
    {
      if (!m_PlayerTag)
      {
        m_PlayerTag = GetGame().GetWorkspace().CreateWidgets("gui/layouts/new_ui/hud/hud_player_tag.layout");
        m_PlayerTagText = TextWidget.Cast(m_PlayerTag.FindAnyWidget("TagText"));
      }
      m_PlayerSpineIndex = m_CurrentTaggedPlayer.GetBoneIndex("Spine2");
      vector player_pos = m_CurrentTaggedPlayer.GetBonePositionWS(m_PlayerSpineIndex);
      vector screen_pos = GetGame().GetScreenPosRelative(player_pos);
 
      if (screen_pos[2] > 0)
      {
        if (screen_pos[0] > 0 && screen_pos[0] < 1)
        {
          if (screen_pos[1] > 0 && screen_pos[1] < 1)
          {
            m_PlayerTagText.SetAlpha(Math.Clamp(m_PlayerTagText.GetAlpha() + timeslice * 10, 0, 1));
            m_PlayerTag.SetPos(0.55, 0.55);
            m_PlayerTagText.SetText(m_CurrentTaggedPlayer.GetIdentity().GetPlainName());
 
            //m_PlayerTagText.SetSize( 1, 1 - screen_pos[2] / 25  );
            return;
          }
        }
      }
    }
 
    if (m_PlayerTag)
    {
      float new_alpha = Math.Clamp(m_PlayerTagText.GetAlpha() - timeslice * 10, 0, 1);
      m_PlayerTagText.SetAlpha(Math.Clamp(m_PlayerTagText.GetAlpha() - timeslice * 10, 0, 1));
      if (new_alpha == 0)
      {
        m_PlayerTagText.SetText("");
        m_CurrentTaggedPlayer = null;
      }
    }
  }
 
  override void Update(float timeslice)
  {
    super.Update(timeslice);
 
    m_ActionTargetsCursor.Update();
    DisplayPresence();
    //
    //modifiers - tendency status (critical)
    if (m_BlinkTime > TENDENCY_BLINK_TIME)
    {
      //get color & alpha
      if (m_TendencyStatusCritical.Count() > 0)
      {
        for (int i = 0; i < m_TendencyStatusCritical.Count(); ++i)
        {
 
          ImageWidget widget = m_TendencyStatusCritical.GetKey(i);
          int alpha = widget.GetAlpha() * 255;
          int color;
          int colorA = ARGB(alpha, 255, 255, 255);
          int colorB = m_TendencyStatusCritical.Get(widget);
 
          //set new color to different color
          if (widget.GetColor() == colorA)
            color = colorB;
          else
            color = colorA;
 
          widget.SetColor(color);
        }
      }
 
      m_BlinkTime = 0; //reset
    }
    else
      m_BlinkTime += timeslice;
 
    if (m_IsTemperatureVisible)
    {
      m_TemperatureTimer += timeslice;
      if (m_TemperatureTimer > m_TemperatureShowTime)
        HideTemperature();
    }
 
    if (!m_IsStaminaVisible)
    {
      m_StaminaTimer += timeslice;
      if (m_StaminaTimer > m_StaminaShowTime)
        SetStaminaBarVisibility(true);
 
    }
 
    if (m_HitDirEffectArray && m_HitDirEffectArray.Count() > 0)
    {
      UpdateHitDirEffects(timeslice);
      CleanupHitDirEffects();
    }
 
    RefreshVehicleHud(timeslice);
 
#ifdef PLATFORM_PS4
    RefreshPlayerTags();
    ShowPlayerTag(timeslice);
#endif
  }
 
  override void SpawnHitDirEffect(DayZPlayer player, float hit_direction, float intensity_max)
  {
    if (HitDirectionEffectBase.m_Mode == HitDirectionModes.DISABLED)
      return;
 
    if (m_HitDirEffectArray == null)
      m_HitDirEffectArray = new array<ref HitDirectionEffectBase>;
    HitDirectionEffectBase hiteff = HitDirectionEffectBase.Cast(HitDirectionEffectBase.GetCurrentType().Spawn());
    hiteff.Init(player, hit_direction, intensity_max);
    m_HitDirEffectArray.Insert(hiteff);
  }
 
  void UpdateHitDirEffects(float timeslice)
  {
    for (int i = 0; i < m_HitDirEffectArray.Count(); i++)
      m_HitDirEffectArray[i].Update(timeslice);
  }
 
  void CleanupHitDirEffects()
  {
    for (int i = m_HitDirEffectArray.Count() - 1; i > -1; i--)
    {
      if (m_HitDirEffectArray[i].DurationCheck())
        m_HitDirEffectArray.Remove(i);
    }
  }
 
  void Debug()
  {
    foreach (int val: m_BadgesWidgetDisplay)
    {
      int key = m_BadgesWidgetDisplay.GetKeyByValue(val);
      Print(EnumTools.EnumToString(eDisplayElements, key));
      Print(val);
      Print("---------------------");
    }
  }
 
  //------------------------------------------
  //ye olde unused methods
 
  //DEPRECATED
  void HideQuickbarTimer()
  {
  }
}