GEWidgetsMetaDataBleeding.c

Go to the documentation of this file.

 
class GameplayEffectsDataBleeding extends GameplayEffectsData
{
  protected bool m_Initialized; //tied to initialization of 'BleedingSourcesManagerBase' on player object, skips updates until ready, even when formally active
  protected bool m_Visible; //overall visibility
  protected ref map<int, ref BleedingIndicator> m_RegisteredInstances;
  protected ref array<int> m_CleanupQueue;
  protected ref array<int> m_RunningIndicators;
  protected int m_LastDropIdx;
  protected int m_ImageWidgetCount; //number of available blood drop image widgets
  protected ref map<int, ref array<float>> m_ProbabilityMap;
  protected ref array<Widget> m_PositioningFramesArray;
  protected Widget m_BloodDropsFrame;
 
  protected int m_LastPositionFrameUsed;
 
  void GameplayEffectsDataBleeding(array<ref Widget> input, int type, int user_override = -1)
  {
    m_RegisteredInstances = new map<int, ref BleedingIndicator>;
    m_CleanupQueue = new array<int>;
    m_RunningIndicators = new array<int>;
    m_Initialized = false;
  }
 
  override void Init(array<ref Widget> input, int type, Widget layout_root, int user_override = -1)
  {
    super.Init(input, type, layout_root, user_override);
 
    m_WidgetArray.ShuffleArray(); //shuffles order of the widgets on every init
    m_ImageWidgetCount = m_WidgetArray.Count();
    m_BloodDropsFrame = m_LayoutRoot.FindAnyWidgetById(EffectWidgetsTypes.BLEEDING_LAYER);
    m_Visible = g_Game.GetProfileOption(EDayZProfilesOptions.BLEEDINGINDICATION);
    m_BloodDropsFrame.Show(m_Visible);
    m_LastDropIdx = -1;
    m_LastPositionFrameUsed = -1;
 
    BuildProbabilityData(BleedingIndicationConstants.INDICATOR_SEVERITY_LOW, BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_LOW);
    BuildProbabilityData(BleedingIndicationConstants.INDICATOR_SEVERITY_MEDIUM, BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_MEDIUM);
    BuildProbabilityData(BleedingIndicationConstants.INDICATOR_SEVERITY_HIGH, BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_HIGH);
    BuildPositioningData();
  }
 
  override bool HasDefinedHandle()
  {
    return true;
  }
 
  override bool DataInitialized()
  {
    return m_Initialized;
  }
 
  override void RegisterData(Param p)
  {
    if (m_Initialized)
    {
#ifdef DEVELOPER
      ErrorEx("" + this + " is already initialized, further registration not possible!");
#else
      Debug.Log("ERROR: " + this + " is already initialized, further registration not possible!");
#endif
      return;
    }
 
    //<finish registration,bit,flow_modifier>
    Param3<bool, int, float> par;
    if (Class.CastTo(par, p))
    {
      if (par.param1 == true) //finish registration
      {
        m_Initialized = true;
        return;
      }
 
      RegisterBleedingIndicatorInstance(par.param2, par.param3);
    }
  }
 
  void RegisterBleedingIndicatorInstance(int bit, float flow_modifier)
  {
    int severity = CalculateSeverity(flow_modifier);
    BleedingIndicator indicator = new BleedingIndicator(bit, severity, this); //source_ID == bit for the purpose of pairing
    m_RegisteredInstances.Set(bit, indicator);
  }
 
  void SpawnBleedingIndicator(int source_ID, vector position)
  {
    if (m_RunningIndicators.Find(source_ID) != -1)
      return;
    BleedingIndicator indicator = m_RegisteredInstances.Get(source_ID);
    //indicator.InitIndicator(position); //would be nice if we could pair the indicator position to the hit position that caused the bleeding, wouldn't it
    indicator.InitIndicator(GenerateSequenceRandomPosition());
    m_RunningIndicators.Insert(source_ID);
  }
 
  int CalculateSeverity(float flow_modifier)
  {
    switch (flow_modifier)
    {
    case PlayerConstants.BLEEDING_SOURCE_FLOW_MODIFIER_LOW:
      return BleedingIndicationConstants.INDICATOR_SEVERITY_LOW;
 
    case PlayerConstants.BLEEDING_SOURCE_FLOW_MODIFIER_MEDIUM:
      return BleedingIndicationConstants.INDICATOR_SEVERITY_MEDIUM;
 
    case PlayerConstants.BLEEDING_SOURCE_FLOW_MODIFIER_HIGH:
      return BleedingIndicationConstants.INDICATOR_SEVERITY_HIGH;
    }
    return BleedingIndicationConstants.INDICATOR_SEVERITY_LOW;
  }
 
  ImageWidget GetNextDropImage()
  {
    m_LastDropIdx++;
    if (m_LastDropIdx > (m_ImageWidgetCount - 1))
      m_LastDropIdx = 0;
 
    return ImageWidget.Cast(m_WidgetArray[m_LastDropIdx]);
  }
 
  void StopBleedingIndicator(int source_ID, bool instant = false)
  {
    m_RegisteredInstances.Get(source_ID).StopIndicator(instant); //stop queued, evaluated on update!
  }
 
  void UpdateBleedingIndicators(float timeSlice)
  {
    BleedingIndicator bib;
    for (int i = 0; i < m_RunningIndicators.Count(); i++)
    {
      bib = m_RegisteredInstances.Get(m_RunningIndicators[i]);
      bib.Update(timeSlice);
      if (bib.GetEndNow())
        m_CleanupQueue.Insert(m_RunningIndicators[i]);
    }
  }
 
  void CleanupBleedingIndicators()
  {
    for (int i = 0; i < m_CleanupQueue.Count(); i++)
      m_RunningIndicators.RemoveItem(m_CleanupQueue[i]);
    m_CleanupQueue.Clear();
  }
 
  override void Update(float timeSlice = 0, Param p = null, int handle = -1)
  {
    //starts or ends a bleeding indicator
    if (p)
    {
      //start/stop of the indicator
      //<state,bit,position,immediate>
      Param4<bool, int, vector, bool> par;
 
      //hide/show of bleeding effect visuals
      //<state>
      Param1<bool> parShow;
 
      if (Class.CastTo(par, p))
      {
        bool state = par.param1;
        if (state) //queue add indicator
          SpawnBleedingIndicator(par.param2, par.param3);
        else //queue stop indicator
          StopBleedingIndicator(par.param2, par.param4);
      }
      else if (Class.CastTo(parShow, p) && m_Visible != parShow.param1)
      {
        m_Visible = parShow.param1;
        m_BloodDropsFrame.Show(m_Visible);
      }
    }
 
    //updates bleeding indicators
    UpdateBleedingIndicators(timeSlice);
    CleanupBleedingIndicators();
 
    if (m_RunningIndicators.Count() <= 0)
    {
      GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.BLEEDING_LAYER});
      m_WidgetArray.ShuffleArray();
    }
  }
 
  override void UpdateVisibility(bool state)
  {
    m_Visible = g_Game.GetProfileOption(EDayZProfilesOptions.BLEEDINGINDICATION); //ugh
    //manage layout visibility
    Widget w = m_BloodDropsFrame;
    while (w && w != m_LayoutRoot && m_Visible == state && w.IsVisibleHierarchy() != state)
    {
      w.Show(state);
      w = w.GetParent();
    }
  }
 
  override void ForceStop()
  {
    super.ForceStop();
 
    foreach (int i: m_RunningIndicators)
      m_RegisteredInstances.Get(i).StopIndicator(true);
    Update();
  }
 
  void BuildProbabilityData(int severity, float frequency)
  {
    if (!m_ProbabilityMap)
      m_ProbabilityMap = new map<int, ref array<float>>;
 
    array<float> probabilities = new array<float>;
 
    for (int i = 0; i < BleedingIndicationConstants.SEQUENCE_STEPS; i++)
      probabilities.Insert(Math.Poisson(frequency, i));
 
    m_ProbabilityMap.Insert(severity, probabilities);
  }
 
  array<float> GetProbabilities(int severity)
  {
    array<float> ret = m_ProbabilityMap.Get(severity);
    if (!ret)
      ErrorEx("No defined data for the selected severity!");
    return ret;
  }
 
  void BuildPositioningData()
  {
    Widget frameParent = m_LayoutRoot.FindAnyWidget("PoisitioningFrames");
    if (frameParent)
    {
      if (!m_PositioningFramesArray)
        m_PositioningFramesArray = new array<Widget>;
 
      Widget frame = frameParent.GetChildren();
      while (frame)
      {
        m_PositioningFramesArray.Insert(frame);
        frame = frame.GetSibling();
      }
    }
  }
 
  vector GenerateSequenceRandomPosition()
  {
    if (m_PositioningFramesArray)
    {
      int arrayCount = m_PositioningFramesArray.Count();
      int index = Math.RandomInt(0, arrayCount);
      if (index == m_LastPositionFrameUsed)
      {
        index++;
        if (index >= arrayCount)
          index = 0;
      }
 
      Widget frame = m_PositioningFramesArray[index];
      m_LastPositionFrameUsed = index;
 
      if (frame)
      {
        int screenX, screenY;
        float x, y, x_size, y_size;
        frame.GetScreenPos(x, y);
        frame.GetScreenSize(x_size, y_size);
 
        x = Math.RandomFloatInclusive(x, x + x_size);
        y = Math.RandomFloatInclusive(y, y + y_size);
 
        return Vector(x, y, 0);
      }
    }
    return vector.Zero;
  }
}