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