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;
 }
}