SCR_ResourceGrid.c

Go to the documentation of this file.

class SCR_ResourceGrid : AABGridMap
{
    static const int MAX_FRAME_BUDGET = 20;
    
    protected ref array<SCR_ResourceComponent> m_aFlaggedItems = {};
    protected ref set<SCR_ResourceContainer> m_aQueriedContainers = new set<SCR_ResourceContainer>();
    protected int m_iGridUpdateId = int.MIN;
    protected int m_iFrameBudget;
    
    //------------------------------------------------------------------------------------------------
    int GetGridUpdateId()
    {
        return m_iGridUpdateId;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetFrameBudget()
    {
        return m_iFrameBudget;
    }
    
    //------------------------------------------------------------------------------------------------
    void ResetFrameBudget()
    {
        m_iFrameBudget = SCR_ResourceGrid.MAX_FRAME_BUDGET;
    }
    
    //------------------------------------------------------------------------------------------------
    int IncreaseGridUpdateId()
    {
        if (++m_iGridUpdateId == int.MAX)
            Debug.Error2(ClassName(), "Maximum grid update id has been reached.");
        
        return m_iGridUpdateId;
    }
    
    //------------------------------------------------------------------------------------------------
    void FlagResourceItem(notnull SCR_ResourceComponent item)
    {
        m_aFlaggedItems.Insert(item);
    }
    
    //------------------------------------------------------------------------------------------------
    void UnflagResourceItem(notnull SCR_ResourceComponent item)
    {
        m_aFlaggedItems.RemoveItem(item);
    }
    
    //------------------------------------------------------------------------------------------------
    void ProcessFlaggedItems()
    {
        if (m_aFlaggedItems.IsEmpty())
            return;
        
        IncreaseGridUpdateId();
        
        // Clear out null flagged items.
        m_aFlaggedItems.RemoveItem(null);
        
        foreach (SCR_ResourceComponent item: m_aFlaggedItems)
        {
            ProcessResourceItem(item);
        }
        
        m_aFlaggedItems.Clear();
    }
    
    //------------------------------------------------------------------------------------------------
    void UpdateResourceItem(notnull SCR_ResourceComponent item)
    {
        const IEntity owner = item.GetOwner();
        
        if (!owner)
            return;
        
        vector boundsMins, boundsMaxs;
        
        item.SetGridUpdateId(m_iGridUpdateId);
        item.GetGridContainersBoundingBox(boundsMins, boundsMaxs);
        UpdatePosition(owner, owner.GetOrigin());
        UpdateAABB(owner, boundsMins, boundsMaxs);
    }
    
    //------------------------------------------------------------------------------------------------
    protected bool ProcessResourceItem(notnull SCR_ResourceComponent item)
    {
        const IEntity owner = item.GetOwner();
        
        if (!owner)
            return false;
        
        vector boundsMins, boundsMaxs;
        const Physics phys = owner.GetPhysics();
        
        item.GetGridContainersBoundingBox(boundsMins, boundsMaxs);
        
        if (phys)
            Insert(owner, boundsMins, boundsMaxs, phys.IsDynamic());
        else
            Insert(owner, boundsMins, boundsMaxs, false);
        
        item.SetGridUpdateId(m_iGridUpdateId);
        
        return true;
    }
    
    //------------------------------------------------------------------------------------------------
    void UnregisterResourceItem(notnull SCR_ResourceComponent item)
    {
        item.SetGridUpdateId(int.MIN);
        
        const IEntity owner = item.GetOwner();
        
        if (!owner)
            return;
        
        Remove(owner);
    }
    
    //------------------------------------------------------------------------------------------------
    void UpdateInteractor(notnull SCR_ResourceInteractor interactor, bool useFrameBudget = false)
    {   
        // This check is to prevent nested calls of UpdateInteractor function
        if (!m_aQueriedContainers.IsEmpty())
            return;
        
        const vector interactorOrigin = interactor.GetOwnerOrigin();
        
        if  (vector.DistanceSq(interactorOrigin, interactor.GetLastPosition()) <= SCR_ResourceComponent.UPDATE_DISTANCE_TRESHOLD_SQUARE 
        &&  interactor.GetGridUpdateId() == m_iGridUpdateId 
        ||  interactor.IsIsolated())
            return;
        
        array<IEntity> foundEntities = {};
        const float resourceGridRange = interactor.GetResourceGridRange();
        SCR_ResourceContainer resourceContainer;
        const SCR_ResourceContainerQueueBase containerQueue = interactor.GetContainerQueue();
        
        FindEntitiesInRange(foundEntities, interactorOrigin, resourceGridRange);
        containerQueue.CopyContainers(m_aQueriedContainers);
        
        foreach (IEntity entity : foundEntities)
        {
            m_aQueriedContainers.Insert(SCR_ResourceComponent.Cast(entity.FindComponent(SCR_ResourceComponent)).GetContainer(interactor.GetResourceType()));
        }
        
        m_aQueriedContainers.RemoveItem(null);
        
        const int containerCount = m_aQueriedContainers.Count();
        
        if (useFrameBudget)
            m_iFrameBudget -= containerCount;
        
        for (int idx = containerCount - 1; idx >= 0; --idx)
        {
            resourceContainer = m_aQueriedContainers[idx];
            
            if (resourceContainer.IsIsolated())
                continue;
            
            if (interactor.CanInteractWith(resourceContainer) && resourceContainer.IsInRange(interactorOrigin, resourceGridRange))
            {
                if (!resourceContainer.IsInteractorLinked(interactor))
                    interactor.RegisterContainerForced(resourceContainer);
            }
            else
                interactor.UnregisterContainer(resourceContainer);
        }
        
        interactor.OnResourceGridUpdated(this);
        m_aQueriedContainers.Clear();
    }
}