rainprocurementhandler.c

Go to the documentation of this file.

class RainProcurementHandler : Managed
{
 protected MissionBaseWorld m_Mission;
 protected ref set<RainProcurementComponentBase> m_ActiveComponents;
 protected ref set<RainProcurementComponentBase> m_ChangedQueue;
 protected ref set<int> m_CleanupQueue;
 protected const int UPDATE_BATCH_SIZE = 20; //Tweak this to adjust max batch size
 const int UPDATE_TIME = 10; //seconds
 protected bool m_Update;
 protected bool m_ProcessComponents;
 protected bool m_ProcessingFinished;
 protected int m_NextToProcessIdx;
 protected float m_UpdateTimer;
 protected float m_LiquidAmountCoef;
 
 void RainProcurementHandler(MissionBaseWorld mission)
 {
 m_Mission = mission;
 m_Update = false;
 m_ProcessComponents = false;
 m_ProcessingFinished = true;
 m_ActiveComponents = new set<RainProcurementComponentBase>;
 m_ChangedQueue = new set<RainProcurementComponentBase>;
 m_CleanupQueue = new set<int>;
 m_NextToProcessIdx = 0;
 m_UpdateTimer = 0;
 }
 
 void QueueStart(RainProcurementComponentBase component)
 {
 m_ChangedQueue.Insert(component);
 m_Update = true;
 }
 
 void QueueStop(RainProcurementComponentBase component)
 {
 m_ChangedQueue.Insert(component);
 m_Update = true;
 }
 
 void Update(float timeslice)
 {
 if (!m_Update)
 return;
 
 if (m_ProcessComponents)
 {
 if (m_ProcessingFinished) //do on start and after the batch is finished
 {
 m_LiquidAmountCoef = DetermineAmountCoef();
 if (m_LiquidAmountCoef == 0) //skip processing when not raining
 {
 Reset();
 return;
 }
 }
 
 m_ProcessingFinished = ProcessBatch();
 
 if (m_ProcessingFinished)
 {
 Reset();
 }
 }
 else
 {
 m_UpdateTimer += timeslice;
 if (m_UpdateTimer >= UPDATE_TIME)
 {
 HandleChangedComponents();
 Cleanup();
 CheckUpdating();
 m_ProcessComponents = m_Update;
 if (!m_Update)
 Reset();
 }
 }
 }
 
 protected bool ProcessBatch()
 {
 bool ret = false;
 int count = m_ActiveComponents.Count();
 int target = (int)Math.Clamp(m_NextToProcessIdx + UPDATE_BATCH_SIZE,0,count);
 
 for (m_NextToProcessIdx; m_NextToProcessIdx < target; m_NextToProcessIdx++)
 {
 if (m_ActiveComponents[m_NextToProcessIdx])
 m_ActiveComponents[m_NextToProcessIdx].OnUpdate(m_UpdateTimer, m_LiquidAmountCoef);
 else
 m_CleanupQueue.Insert(m_NextToProcessIdx);
 }
 
 ret = target == count;
 if (ret)
 {
 m_NextToProcessIdx = 0;
 }
 
 return ret;
 }
 
 protected void Cleanup()
 {
 int count = m_CleanupQueue.Count();
 if (count == 0)
 return;
 
 for (int i = count - 1; i > -1; i--)
 {
 m_ActiveComponents.Remove(m_CleanupQueue[i]);
 }
 m_CleanupQueue.Clear();
 }
 
 protected void Reset()
 {
 m_ProcessComponents = false;
 m_ProcessingFinished = true;
 m_UpdateTimer = 0;
 }
 
 protected void HandleChangedComponents()
 {
 RainProcurementComponentBase component;
 int count = m_ChangedQueue.Count();
 int idx;
 
 for (int i = 0; i < count; i++)
 {
 component = m_ChangedQueue[i];
 if (!component)
 continue;
 
 if (component.IsActive())
 {
 m_ActiveComponents.Insert(component);
 }
 else
 {
 idx = m_ActiveComponents.Find(component);
 if (idx != -1)
 m_ActiveComponents.Remove(idx);
 }
 }
 m_ChangedQueue.Clear();
 }
 
 protected void CheckUpdating()
 {
 m_Update = m_ActiveComponents.Count() != 0;
 }
 
 float GetLiquidAmountCoef()
 {
 return m_LiquidAmountCoef;
 }
 
 float DetermineAmountCoef()
 {
 return GetGame().GetWeather().GetRain().GetActual();
 }
};