BleedingIndicator.c

Go to the documentation of this file.

 
class BleedingIndicator extends Managed
{
  protected bool m_Initialized;
  protected bool m_Terminating = false; //doesn't spawn more drops and ends when the last one does
  protected bool m_EndNow = false;
  protected bool m_IsRunning = false;
  protected int m_DropSpawnsQueued;
  protected int m_ActiveDropsCount;
  protected int m_Severity;
  protected int m_SourceID; //pairs this with the 'BleedingSource' bit/ID
  protected GameplayEffectsDataBleeding m_ParentMetaData;
  protected array<float> m_DropProbabilityArray;
 
  protected float m_AverageFrequency; //average drops per interval. NOT changeable on the fly, just a helper value!
  protected float m_SequenceTick;
  protected float m_SequenceDuration;
  protected float m_TimeElapsedTotal;
  protected float m_TimeElapsedSequence;
  protected float m_LastDropSpawnTime; //relative to the TOTAL time, not the sequence!
  protected float m_DropSpawnMinDelay;
  protected float m_DropSpawnMaxDelay;
  protected int m_CurrentDropProbabilityStep;
  protected int m_DropProbabilityRollsCount;
  protected vector m_BasePosition;
 
  ref set<ref BleedingIndicatorDropData> m_ActiveDrops;
  ref set<int> m_CleanupQueue;
 
  void BleedingIndicator(int source_ID, int severity, GameplayEffectsDataBleeding parent)
  {
    m_Initialized = false;
    m_SourceID = source_ID;
    m_Severity = severity;
    m_ParentMetaData = parent;
    m_CurrentDropProbabilityStep = 0;
    m_ActiveDrops = new set<ref BleedingIndicatorDropData>;
    m_CleanupQueue = new set<int>;
    m_DropProbabilityArray = m_ParentMetaData.GetProbabilities(m_Severity);
    m_DropProbabilityRollsCount = m_DropProbabilityArray.Count();
 
    switch (m_Severity)
    {
    case BleedingIndicationConstants.INDICATOR_SEVERITY_LOW:
    {
      m_SequenceDuration = BleedingIndicationConstants.SEQUENCE_DURATION_LOW;
      m_AverageFrequency = BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_LOW;
      m_DropSpawnMinDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MIN_LOW;
      m_DropSpawnMaxDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MAX_LOW;
      break;
    }
    case BleedingIndicationConstants.INDICATOR_SEVERITY_MEDIUM:
    {
      m_SequenceDuration = BleedingIndicationConstants.SEQUENCE_DURATION_MEDIUM;
      m_AverageFrequency = BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_MEDIUM;
      m_DropSpawnMinDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MIN_MEDIUM;
      m_DropSpawnMaxDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MAX_MEDIUM;
      break;
    }
    case BleedingIndicationConstants.INDICATOR_SEVERITY_HIGH:
    {
      m_SequenceDuration = BleedingIndicationConstants.SEQUENCE_DURATION_HIGH;
      m_AverageFrequency = BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_HIGH;
      m_DropSpawnMinDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MIN_HIGH;
      m_DropSpawnMaxDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MAX_HIGH;
      break;
    }
 
    default:
    {
      m_AverageFrequency = BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_LOW;
      m_DropSpawnMinDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MIN_LOW;
      m_DropSpawnMaxDelay = BleedingIndicationConstants.SEQUENCE_DROP_DELAY_MAX_LOW;
      Debug.Log("Unknown severity value!");
    }
#ifdef DIAG_DEVELOPER
    if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
    {
      m_SequenceDuration = DbgBleedingIndicationStaticInfo.m_DbgSequenceDuration;
      m_DropSpawnMinDelay = DbgBleedingIndicationStaticInfo.m_DbgDropMinDelay;
      m_DropSpawnMaxDelay = DbgBleedingIndicationStaticInfo.m_DbgDropMaxDelay;
    }
#endif
    }
 
    m_TimeElapsedTotal = 0;
    m_TimeElapsedSequence = 0;
  }
 
  void InitIndicator(vector position)
  {
    m_BasePosition = position;
    ResetIndicator();
    m_Initialized = true;
  }
 
  void StopIndicator(bool instant = false)
  {
    if (!m_Terminating)
    {
      m_IsRunning = false;
 
      if (instant)
        m_EndNow = true;
      m_Terminating = true;
    }
  }
 
  protected void StartRunningDrops()
  {
    m_ActiveDropsCount = 0;
    m_IsRunning = true;
    TrySpawnNextDrop();
    m_DropSpawnsQueued = 0;
 
    m_CurrentDropProbabilityStep = (int)(m_DropProbabilityRollsCount - (m_DropProbabilityRollsCount / m_AverageFrequency));
  }
 
  protected bool IsRunningDrops()
  {
    return m_ActiveDropsCount > 0;
  }
 
  void TrySpawnNextDrop()
  {
    ImageWidget dropImage;
    if (Class.CastTo(dropImage, m_ParentMetaData.GetNextDropImage()) && !dropImage.IsVisible()) //IsVisible false means the drop is free to be used
    {
      BleedingIndicatorDropData data = new BleedingIndicatorDropData(dropImage, m_Severity);
      data.SetBasePosition(m_BasePosition);
      data.StartDrop();
 
      m_ActiveDrops.Insert(data);
      m_ActiveDropsCount++;
    }
 
    m_LastDropSpawnTime = m_TimeElapsedTotal;
    m_DropSpawnsQueued--;
  }
 
  protected void ResetSequence()
  {
    m_CurrentDropProbabilityStep = 0;
    m_TimeElapsedSequence = 0;
    m_DropSpawnsQueued = 0;
  }
 
  void ResetIndicator()
  {
    m_Terminating = false;
    m_EndNow = false;
    m_TimeElapsedTotal = 0;
    m_CurrentDropProbabilityStep = 0;
    m_TimeElapsedSequence = 0;
    m_LastDropSpawnTime = 0;
    m_DropSpawnsQueued = 0;
  }
 
  void Update(float timeSlice)
  {
    if (!m_Initialized)
      return;
 
#ifdef DIAG_DEVELOPER
    if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
      m_SequenceDuration = DbgBleedingIndicationStaticInfo.m_DbgSequenceDuration;
#endif
    m_SequenceTick = m_SequenceDuration / m_DropProbabilityRollsCount;
 
    //run drops, if possible
    if (!m_Terminating)
    {
      if (m_IsRunning)
      {
        if (m_TimeElapsedSequence > (m_SequenceTick * m_CurrentDropProbabilityStep))
        {
          if (m_CurrentDropProbabilityStep < m_DropProbabilityRollsCount)
          {
            float rnd = Math.RandomFloat01();
            if (rnd < m_DropProbabilityArray[m_CurrentDropProbabilityStep])
              m_DropSpawnsQueued++;
 
            m_CurrentDropProbabilityStep++;
          }
        }
 
        float sinceLastDrop = m_TimeElapsedTotal - m_LastDropSpawnTime;
        if (m_TimeElapsedSequence > m_SequenceDuration)
          ResetSequence();
        else if (m_DropSpawnsQueued > 0) //spawn queued drop
        {
          if (sinceLastDrop >= m_DropSpawnMinDelay)
            TrySpawnNextDrop();
        }
        else if (sinceLastDrop > m_DropSpawnMaxDelay)
        {
          TrySpawnNextDrop(); //guaranteed drop
          m_CurrentDropProbabilityStep++; //substitutes a regular roll..
        }
      }
      else //1st drop ignores delay
        StartRunningDrops();
    }
 
    for (int i = 0; i < m_ActiveDropsCount; i++)
    {
      if (!m_EndNow)
      {
        //Simulate drops
        m_ActiveDrops[i].Update(timeSlice);
      }
      else
        m_ActiveDrops[i].StopDrop();
 
      if (!m_ActiveDrops[i].IsRunning())
        m_CleanupQueue.Insert(i);
    }
 
    //Cleanup drops
    for (i = m_CleanupQueue.Count() - 1; i >= 0; i--)
    {
      m_ActiveDrops.Remove(m_CleanupQueue[i]);
      m_ActiveDropsCount--;
    }
    m_CleanupQueue.Clear();
 
    if (m_Terminating && !IsRunningDrops())
      m_EndNow = true;
 
    m_TimeElapsedTotal += timeSlice;
    m_TimeElapsedSequence += timeSlice;
  }
 
  bool GetEndNow()
  {
    return m_EndNow;
  }
 
  int GetSeverity()
  {
    return m_Severity;
  }
}