GameplayEffectWidgets.c

Go to the documentation of this file.

/*
  TODO - doxygen formating
*/
 
class GameplayEffectWidgets extends GameplayEffectWidgets_base
{
  protected ref Widget m_Root; //dummy parent node
  protected ref map<int, ref Widget> m_Layouts;
  protected ref set<ref Widget> m_UniqueLayouts;
  protected ref GameplayEffectDataMap m_WidgetDataMap;
  protected ref set<int> m_RunningEffects;
  protected ref set<int> m_RunningEffectsPrevious;
  protected ref array<int> m_UpdatingEffects;
  protected ref array<ref Widget> m_UpdatedWidgetsCheck; //to make sure widgets are not updated over and over (case of multiple IDs sharing same widget set)
  protected ref array<int> m_UpdatedWidgetSetsCheck; //to make sure sets are not updated over and over (case of multiple IDs sharing same widget set)
  protected ref set<int> m_SuspendRequests;
  protected ref map<int, typename> m_IDToTypeMap;
 
  protected float m_TimeProgBreath;
  protected float m_BreathMultStamina;
  protected float m_BreathResidue;
 
  //UserID's for widget containers that use something different from 'EffectWidgetsTypes' defaults
  protected const int WIDGETSET_BREATH = 100;
 
  //effect values
  protected int m_BreathColor;
  protected float m_BreathAlphaVal;
  protected float m_FlashbangCoverAlphaVal;
 
  void GameplayEffectWidgets()
  {
    m_Root = GetGame().GetWorkspace().CreateWidget(FrameWidgetTypeID, 0, 0, 1.0, 1.0, WidgetFlags.VISIBLE | WidgetFlags.HEXACTPOS | WidgetFlags.VEXACTPOS, 0xffffffff, 0);
    m_Layouts = new map<int, ref Widget>;
    m_UniqueLayouts = new set<ref Widget>;
    m_WidgetDataMap = new GameplayEffectDataMap;
    m_RunningEffects = new set<int>;
    m_RunningEffectsPrevious = new set<int>;
    m_UpdatingEffects = new array<int>;
    m_UpdatedWidgetsCheck = new array<ref Widget>;
    m_UpdatedWidgetSetsCheck = new array<int>;
    m_SuspendRequests = new set<int>;
    m_IDToTypeMap = new map<int, typename>;
 
    m_TimeProgBreath = 0.0;
    m_BreathMultStamina = 1.0;
 
    PairIDToTypes();
 
    RegisterLayouts("gui/layouts/gameplay/CameraEffects.layout", CompileEffectListing());
    RegisterLayouts("gui/layouts/gameplay/BleedingEffects.layout", {EffectWidgetsTypes.BLEEDING_LAYER});
 
    InitWidgetSet(EffectWidgetsTypes.MASK_BREATH, true, WIDGETSET_BREATH);
    InitWidgetSet(EffectWidgetsTypes.HELMET_BREATH, true, WIDGETSET_BREATH);
    InitWidgetSet(EffectWidgetsTypes.MOTO_BREATH, true, WIDGETSET_BREATH);
 
    InitWidgetSet(EffectWidgetsTypes.MASK_OCCLUDER, false, EffectWidgetsTypes.MASK_OCCLUDER);
    InitWidgetSet(EffectWidgetsTypes.HELMET_OCCLUDER);
    InitWidgetSet(EffectWidgetsTypes.HELMET2_OCCLUDER);
    InitWidgetSet(EffectWidgetsTypes.MOTO_OCCLUDER);
    InitWidgetSet(EffectWidgetsTypes.NVG_OCCLUDER, false, EffectWidgetsTypes.NVG_OCCLUDER);
    InitWidgetSet(EffectWidgetsTypes.PUMPKIN_OCCLUDER, false, EffectWidgetsTypes.NVG_OCCLUDER);
    InitWidgetSet(EffectWidgetsTypes.EYEPATCH_OCCLUDER);
 
    InitWidgetSet(EffectWidgetsTypes.COVER_FLASHBANG);
 
    InitWidgetSet(EffectWidgetsTypes.BLEEDING_LAYER, true);
 
    UpdateVisibility();
  }
 
  void ~GameplayEffectWidgets()
  {
    for (int i = 0; i < m_Layouts.Count(); i++)
    {
      if (m_Layouts.GetElement(i))
        m_Layouts.GetElement(i).Unlink();
    }
  }
 
  protected void RegisterLayouts(string path, array<int> types)
  {
    Widget w = GetGame().GetWorkspace().CreateWidgets(path, m_Root, false);
    m_UniqueLayouts.Insert(w);
    w.Show(false);
    foreach (int i : types)
      m_Layouts.Set(i, w);
  }
 
  protected void PairIDToTypes()
  {
    m_IDToTypeMap.Insert(EffectWidgetsTypes.BLEEDING_LAYER, GameplayEffectsDataBleeding);
  }
 
  protected typename TranslateIDToType(int typeID)
  {
    return m_IDToTypeMap.Get(typeID);
  }
 
  override void RegisterGameplayEffectData(int id, Param p)
  {
    if (!m_WidgetDataMap.Get(id).DataInitialized())
      m_WidgetDataMap.Get(id).RegisterData(p);
  }
 
  protected void InitWidgetSet(int type, bool updating = false, int user_id_override = -1)
  {
    Widget parent = null;
    if (user_id_override != -1)
      parent = m_Layouts.Get(type).FindAnyWidgetById(user_id_override);
    else
      parent = m_Layouts.Get(type).FindAnyWidgetById(type);
 
    if (!parent)
    {
      Print("InitWidgetSet | type: " + type + " - parent not found!");
      return;
    }
 
    array<ref Widget> output;
    Widget w = parent.GetChildren();
    if (w)
    {
      output = new array<ref Widget>;
      while (w)
      {
        w.Update();
        w.Show(false, true);
        output.Insert(w);
 
        w = w.GetSibling();
      }
 
      if (parent.GetChildren())
      {
        typename handled_type = TranslateIDToType(type);
        if (handled_type)
          CreateHandledClass(handled_type, output, type, user_id_override);
        else
        {
          if (ImageWidget.Cast(parent.GetChildren()))
            m_WidgetDataMap.Set(type, new GameplayEffectsDataImage(output, type, user_id_override));
          else
            m_WidgetDataMap.Set(type, new GameplayEffectsData(output, type, user_id_override));
        }
      }
 
      if (updating)
        m_UpdatingEffects.Insert(type);
    }
  }
 
  bool CreateHandledClass(typename handled_type, array<ref Widget> input, int type, int user_override)
  {
    if (handled_type)
    {
      GameplayEffectsData data = GameplayEffectsData.Cast(handled_type.Spawn());
      data.Init(input, type, m_Layouts.Get(type), user_override);
      m_WidgetDataMap.Set(type, data);
      return true;
    }
    return false;
  }
 
  array<int> CompileEffectListing()
  {
    array<int> ret = new array<int>;
    ret.Insert(EffectWidgetsTypes.MASK_OCCLUDER);
    ret.Insert(EffectWidgetsTypes.MASK_BREATH);
    ret.Insert(EffectWidgetsTypes.HELMET_OCCLUDER);
    ret.Insert(EffectWidgetsTypes.HELMET_BREATH);
    ret.Insert(EffectWidgetsTypes.MOTO_OCCLUDER);
    ret.Insert(EffectWidgetsTypes.MOTO_BREATH);
    ret.Insert(EffectWidgetsTypes.COVER_FLASHBANG);
    ret.Insert(EffectWidgetsTypes.NVG_OCCLUDER);
    ret.Insert(EffectWidgetsTypes.PUMPKIN_OCCLUDER);
    ret.Insert(EffectWidgetsTypes.EYEPATCH_OCCLUDER);
    ret.Insert(EffectWidgetsTypes.HELMET2_OCCLUDER);
 
    return ret;
  }
 
  protected void UpdateVisibility()
  {
    Widget w;
    //Hide diff
    int value;
    int runningEffectCount = m_RunningEffects.Count();
    bool runningEffectsPresent = runningEffectCount > 0;
    GameplayEffectsData dta;
    for (int i = 0; i < m_RunningEffectsPrevious.Count(); i++)
    {
      value = m_RunningEffectsPrevious.Get(i);
      dta = m_WidgetDataMap.Get(value);
      if (runningEffectCount < 1 || m_RunningEffects.Find(value) == -1)
      {
        if (dta.HasDefinedHandle())
          dta.UpdateVisibility(false);
        else
        {
          for (int j = 0; j < m_WidgetDataMap.Get(value).GetWidgetSet().Count(); j++)
          {
            w = m_WidgetDataMap.Get(value).GetWidgetSet().Get(j);
            w.Show(false);
          }
          w.GetParent().Show(false);
        }
      }
    }
 
    //Show running effects
    if (runningEffectsPresent)
    {
      value = 0;
      for (i = 0; i < runningEffectCount; i++)
      {
        value = m_RunningEffects.Get(i);
        dta = m_WidgetDataMap.Get(value);
        if (dta.HasDefinedHandle())
        {
          dta.m_LayoutRoot.Show(true);
          dta.UpdateVisibility(true);
        }
        else
        {
          for (j = 0; j < m_WidgetDataMap.Get(value).GetWidgetSet().Count(); j++)
          {
            w = m_WidgetDataMap.Get(value).GetWidgetSet().Get(j);
            w.Update();
            w.Show(true);
          }
 
          while (w) //dumb but necessary because of uncertain "visible" setting of the layout
          {
            w = w.GetParent();
            if (w)
              w.Show(true);
          }
        }
      }
    }
 
    m_Root.Show(runningEffectsPresent && m_SuspendRequests.Count() < 1);
    m_RunningEffectsPrevious.Clear();
  }
 
  override void AddActiveEffects(array<int> effects)
  {
    if (effects && effects.Count() > 0)
    {
      m_RunningEffectsPrevious.Copy(m_RunningEffects);
 
      int value;
      for (int i = 0; i < effects.Count(); i++)
      {
        value = effects.Get(i);
        m_RunningEffects.Insert(value);
      }
 
      if (m_RunningEffectsPrevious.Count() != m_RunningEffects.Count())
        UpdateVisibility();
    }
  }
 
  override void RemoveActiveEffects(array<int> effects)
  {
    if (effects && effects.Count() > 0)
    {
      m_RunningEffectsPrevious.Copy(m_RunningEffects);
 
      int value;
      int idx;
      for (int i = 0; i < effects.Count(); i++)
      {
        value = effects.Get(i);
        idx = m_RunningEffects.Find(value);
        if (idx != -1)
          m_RunningEffects.Remove(idx);
      }
 
      if (m_RunningEffectsPrevious.Count() != m_RunningEffects.Count())
        UpdateVisibility();
    }
  }
 
  override void StopAllEffects()
  {
    m_Root.Show(false); //to avoid visual 'peeling'
 
    if (IsAnyEffectRunning())
    {
      int count = m_RunningEffects.Count();
      GameplayEffectsData data;
      for (int i = 0; i < count; i++) //iterates over running metadata, in case anything requires its own stop handling
      {
        data = m_WidgetDataMap.Get(m_RunningEffects[i]);
        data.ForceStop();
      }
    }
 
    m_RunningEffectsPrevious.Copy(m_RunningEffects);
    m_RunningEffects.Clear();
    UpdateVisibility();
  }
 
  override bool IsAnyEffectRunning()
  {
    return m_RunningEffects && m_RunningEffects.Count() > 0;
  }
 
  override void AddSuspendRequest(int request_id)
  {
    m_SuspendRequests.Insert(request_id);
    UpdateVisibility();
  }
 
  override void RemoveSuspendRequest(int request_id)
  {
    int idx = m_SuspendRequests.Find(request_id);
    if (idx != -1)
      m_SuspendRequests.Remove(idx);
    UpdateVisibility();
  }
 
  override void ClearSuspendRequests()
  {
    m_SuspendRequests.Clear();
    UpdateVisibility();
  }
 
  override int GetSuspendRequestCount()
  {
    return m_SuspendRequests.Count();
  }
 
  override void UpdateWidgets(int type = -1, float timeSlice = 0, Param p = null, int handle = -1)
  {
    GameplayEffectsData dta;
    array<ref Widget> widget_set;
 
    if (type == EffectWidgetsTypes.ROOT)
      HandleWidgetRoot(timeSlice, p, handle);
    else if (type == -1) //update stuff from the m_UpdatingEffects
    {
      int type_widgetset = 0;
      for (int i = 0; i < m_UpdatingEffects.Count(); i++)
      {
        if (m_RunningEffects.Find(m_UpdatingEffects.Get(i)) != -1)
        {
          type_widgetset = m_UpdatingEffects.Get(i);
 
          dta = m_WidgetDataMap.Get(type_widgetset);
 
          if (dta.HasDefinedHandle() && dta.DataInitialized())
          {
            dta.Update(timeSlice, p, handle); //calculate and apply
          }
          else
          {
            CalculateValues(type_widgetset, timeSlice, p, handle);
            widget_set = dta.GetWidgetSet();
            foreach (Widget w : widget_set)
            {
              if (w.IsVisibleHierarchy() && m_UpdatedWidgetsCheck.Find(w) == -1)
              {
                m_UpdatedWidgetsCheck.Insert(w);
                ProcessWidgetUpdate(w, type_widgetset, timeSlice, p, handle);
              }
            }
          }
        }
      }
    }
    else //update specific widget set
    {
      if (m_RunningEffects.Find(type) != -1) //only do if the effect is running (FPS stonks!)
      {
        dta = m_WidgetDataMap.Get(type);
 
        if (dta.HasDefinedHandle() && dta.DataInitialized())
        {
          dta.Update(timeSlice, p, handle); //calculate and apply
        }
        else
        {
          CalculateValues(type, timeSlice, p, handle);
          widget_set = dta.GetWidgetSet();
          foreach (Widget w2 : widget_set)
          {
            if (w2.IsVisibleHierarchy() && m_UpdatedWidgetsCheck.Find(w2) == -1)
            {
              m_UpdatedWidgetsCheck.Insert(w2);
              ProcessWidgetUpdate(w2, type, timeSlice, p, handle);
            }
          }
        }
      }
    }
 
    m_UpdatedWidgetsCheck.Clear();
    m_UpdatedWidgetSetsCheck.Clear();
  }
 
  protected void CalculateValues(int type = -1, float timeSlice = 0, Param p = null, int handle = -1)
  {
    if (m_UpdatedWidgetSetsCheck.Find(m_WidgetDataMap.Get(type).GetWidgetSetID()) != -1)
    {
      //Print("skipped updating set ID " + m_WidgetDataMap.Get(type).GetWidgetSetID() + " | effect: " + type);
      return;
    }
 
    switch (type)
    {
    case EffectWidgetsTypes.MOTO_BREATH:
    case EffectWidgetsTypes.HELMET_BREATH:
    case EffectWidgetsTypes.MASK_BREATH:
    {
      CalculateBreathEffect(timeSlice);
    }
    break;
 
    case EffectWidgetsTypes.MOTO_OCCLUDER:
    case EffectWidgetsTypes.EYEPATCH_OCCLUDER:
    case EffectWidgetsTypes.HELMET_OCCLUDER:
    case EffectWidgetsTypes.HELMET2_OCCLUDER:
    case EffectWidgetsTypes.MASK_OCCLUDER:
    {
      CalculateOccluderEffect(type, timeSlice, p, handle);
    }
    break;
 
    case EffectWidgetsTypes.COVER_FLASHBANG:
    {
      CalculateFlashbangEffect(type, timeSlice, p, handle);
    }
    break;
 
    default:
      return; //no need to calculate anything
      break;
    }
 
    m_UpdatedWidgetSetsCheck.Insert(m_WidgetDataMap.Get(type).GetWidgetSetID());
  }
 
  protected void ProcessWidgetUpdate(Widget w, int type, float timeSlice = 0, Param p = null, int handle = -1)
  {
    switch (type)
    {
    case EffectWidgetsTypes.MOTO_BREATH:
    case EffectWidgetsTypes.HELMET_BREATH:
    case EffectWidgetsTypes.MASK_BREATH:
    {
      UpdateBreathEffect(ImageWidget.Cast(w));
    }
    break;
 
    case EffectWidgetsTypes.MOTO_OCCLUDER:
    case EffectWidgetsTypes.EYEPATCH_OCCLUDER:
    case EffectWidgetsTypes.HELMET_OCCLUDER:
    case EffectWidgetsTypes.HELMET2_OCCLUDER:
    case EffectWidgetsTypes.MASK_OCCLUDER:
    {
      UpdateOccluderEffect(ImageWidget.Cast(w), type, timeSlice, p, handle);
    }
    break;
 
    case EffectWidgetsTypes.COVER_FLASHBANG:
    {
      UpdateFlashbangEffect(ImageWidget.Cast(w));
    }
    break;
 
    default:
      //Print("---invalid widget type to update---");
      break;
    }
  }
 
  //-----------------------------------------
  //specific widget 'handlers'
 
  const float BREATH_HDR_MIN = 0.005; //dusk?
  const float BREATH_HDR_MAX = 1.0; //dark?
  const float BREATH_COLOR_MULT_MIN = 0.5;
  const float BREATH_COLOR_MULT_MAX = 0.8;
 
  //-----------------------------------------
  //Breath
  //-----------------------------------------
  protected void CalculateBreathEffect(float timeSlice = 0, int type = -1, Param p = null)
  {
    float modifier = Math.Lerp(0.25, 0.5, m_BreathResidue);
    float speed = timeSlice * modifier;
    m_BreathResidue -= speed;
    m_BreathResidue = Math.Clamp(m_BreathResidue, 0, 1);
    float residue_final = Math.Lerp(0, 0.7, m_BreathResidue);
 
    float hdr_mult;
    hdr_mult = GetSceneHDRMul(0);
    hdr_mult = Math.Clamp(hdr_mult, BREATH_HDR_MIN, BREATH_HDR_MAX);
    hdr_mult = Math.InverseLerp(BREATH_HDR_MIN, BREATH_HDR_MAX, hdr_mult);
    hdr_mult = Math.Lerp(BREATH_COLOR_MULT_MAX, BREATH_COLOR_MULT_MIN, hdr_mult);
    m_BreathColor = ARGBF(0.0, 1.0 * hdr_mult, 1.0 * hdr_mult, 1.0 * hdr_mult); //grayscaling of the image
 
 
    m_BreathAlphaVal = Math.Lerp(m_BreathAlphaVal, residue_final, timeSlice);
  }
 
  protected void UpdateBreathEffect(ImageWidget w)
  {
    w.SetColor(m_BreathColor);
    w.SetAlpha(m_BreathAlphaVal);
  }
 
  //-----------------------------------------
  //Occluders
  //-----------------------------------------
  protected void CalculateOccluderEffect(int type, float timeSlice, Param p, int handle)
  {
  }
 
  protected void UpdateOccluderEffect(ImageWidget w, int type, float timeSlice, Param p, int handle)
  {
  }
 
  //-----------------------------------------
  //Flashbang
  //-----------------------------------------
  protected void CalculateFlashbangEffect(int type, float timeSlice, Param p, int handle)
  {
    Param1<float> par = Param1<float>.Cast(p);
    m_FlashbangCoverAlphaVal = par.param1;
 
    /*if (m_FlashbangCoverAlphaVal <= 0.0)
      {
      RemoveActiveEffects({EffectWidgetsTypes.COVER_FLASHBANG});
      return;
      }*/
  }
 
  protected void UpdateFlashbangEffect(ImageWidget w)
  {
    w.SetAlpha(1 - m_FlashbangCoverAlphaVal);
  }
 
  //-----------------------------------------
  //root handling (generic 'Widget', so mainly alpha and hiding?)
  //-----------------------------------------
  protected void HandleWidgetRoot(float timeSlice = 0, Param p = null, int handle = -1)
  {
    switch (handle)
    {
    default:
    {
      Param1<float> par = Param1<float>.Cast(p);
      if (par)
      {
        float alpha_mod = Math.Clamp(par.param1, 0.0, 1.0);
        //Print(alpha_mod);
        m_Root.SetAlpha(alpha_mod);
      }
    }
    break;
    }
  }
 
  //-----------------------------------------
  override void Update(float timeSlice)
  {
    if (m_SuspendRequests.Count() > 0)
      return;
 
    UpdateWidgets(-1, timeSlice);
  }
 
  /*
    override void SetBreathIntensityStamina(float stamina_cap, float stamina_current)
    {
    float stamina_normalized = Math.InverseLerp(0, stamina_cap, stamina_current);
    stamina_normalized = Math.Clamp(stamina_normalized,0,1);
 
    if ( stamina_normalized < STAMINA_SOUND_TR2 )
    {
      m_BreathMultStamina = 2.0;
    }
    else if ( stamina_normalized < STAMINA_SOUND_TR1 )
    {
      m_BreathMultStamina = 1.5;
    }
    else
    {
      m_BreathMultStamina = 1.0;
    }
    }
  */
  override void OnVoiceEvent(float breathing_resistance01)
  {
    m_BreathResidue += Math.Lerp(0, 0.35, breathing_resistance01);
    m_BreathResidue = Math.Clamp(m_BreathResidue, 0, 1);
  }
}