SCR_ScenarioFrameworkArea.c

Go to the documentation of this file.

[EntityEditorProps(category: "GameScripted/ScenarioFramework", description: "")]
class SCR_ScenarioFrameworkAreaClass : SCR_ScenarioFrameworkLayerBaseClass
{
}
 
// Helper class for designer to specify what tasks will be available in this area
[BaseContainerProps()]
class SCR_ScenarioFrameworkTaskType
{
    [Attribute("Type of task", UIWidgets.ComboBox, enums: ParamEnumArray.FromEnum(SCR_ESFTaskType))]
    protected SCR_ESFTaskType m_eTypeOfTask;
 
    //------------------------------------------------------------------------------------------------
    SCR_ESFTaskType GetTaskType()
    {
        return m_eTypeOfTask;
    }
}

class SCR_ScenarioFrameworkArea : SCR_ScenarioFrameworkLayerBase
{
    [Attribute(uiwidget: UIWidgets.ResourcePickerThumbnail, "Trigger for area", category: "Trigger")]
    ResourceName m_sTriggerResource;
 
    [Attribute(defvalue: "5.0", UIWidgets.Slider, params: "0 inf", desc: "Radius of the trigger area", category: "Trigger")]
    float m_fAreaRadius;
 
    [Attribute(defvalue: "1", UIWidgets.CheckBox, desc: "Activate the trigger once or everytime the activation condition is true?", category: "Trigger")]
    bool m_bOnce;
 
    [Attribute(desc: "Actions that will be activated when Trigger gets activated", category: "OnActivation")]
    ref array<ref SCR_ScenarioFrameworkActionBase>  m_aTriggerActions;
 
    SCR_BaseTriggerEntity m_Trigger;
    ref ScriptInvoker<SCR_ScenarioFrameworkArea, SCR_ScenarioFrameworkEActivationType>  m_OnTriggerActivated;
    ref ScriptInvoker m_OnAreaInit = new ScriptInvoker();
    bool m_bAreaSelected;
    SCR_Task m_Task;
    string m_sItemDeliveryPointName;
    SCR_ScenarioFrameworkLayerTask m_LayerTask;
    SCR_ScenarioFrameworkSlotTask m_SlotTask;               //storing this one in order to get the task title and description
 
    ref array<ref Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int>> m_aSpawnedLayers = {};
    ref array<ref Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int>> m_aDespawnedLayers = {};
 
    //------------------------------------------------------------------------------------------------
    SCR_Task GetTask()
    {
        return m_Task;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkSlotTask GetSlotTask()
    {
        return m_SlotTask;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetSlotTask(SCR_ScenarioFrameworkSlotTask slotTask)
    {
        m_SlotTask = slotTask;
    }
 
    //------------------------------------------------------------------------------------------------
    override SCR_ScenarioFrameworkLayerTask GetLayerTask()
    {
        return m_LayerTask;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetLayerTask(SCR_ScenarioFrameworkLayerTask layerTask)
    {
        m_LayerTask = layerTask;
    }
 
    //------------------------------------------------------------------------------------------------
    string GetLayerTaskName()
    {
        return m_LayerTask.GetOwner().GetName();
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ESFTaskType GetLayerTaskType()
    {
        return m_LayerTask.GetTaskType();
    }
 
    //------------------------------------------------------------------------------------------------
    string GetDeliveryPointName()
    {
        return m_sItemDeliveryPointName;
    }
 
    //------------------------------------------------------------------------------------------------
    void StoreDeliveryPoint(string sDeliveryPointName)
    {
        m_sItemDeliveryPointName = sDeliveryPointName;
        if (!SCR_TaskDeliver.Cast(m_Task))
            return;
 
        SCR_TaskDeliver.Cast(m_Task).SetTriggerNameToDeliver(sDeliveryPointName);
    }
 
    //------------------------------------------------------------------------------------------------
    void StoreTaskToArea(SCR_Task task)
    {
        m_Task = task;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkLayerTask Create()
    {
        array<SCR_ScenarioFrameworkLayerBase> aSlotsOut = {};
        GetChildren(aSlotsOut);
        if (aSlotsOut.IsEmpty())
            return null;
 
        SCR_ScenarioFrameworkLayerBase layer = aSlotsOut.GetRandomElement();
        if (layer)
            layer.Init(this);
 
        return SCR_ScenarioFrameworkLayerTask.Cast(layer);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkLayerTask Create(SCR_ESFTaskType eTaskType)
    {
        array<SCR_ScenarioFrameworkLayerBase> aSlotsOut = {};
        GetSuitableLayersForTaskType(aSlotsOut, eTaskType);
        if (aSlotsOut.IsEmpty())
            return null;
 
        //there might be more layers in the area conforming to the task type (i.e. 2x the Truck task)
        m_LayerTask = SCR_ScenarioFrameworkLayerTask.Cast(aSlotsOut.GetRandomElement());
        if (m_LayerTask)
            m_LayerTask.Init(this, SCR_ScenarioFrameworkEActivationType.ON_TASKS_INIT);
 
        return m_LayerTask;
    }
 
    //------------------------------------------------------------------------------------------------
    void Create(SCR_ScenarioFrameworkLayerTask layerTask, SCR_ScenarioFrameworkSlotTask slotTask = null)
    {
        if (!layerTask)
            return;
 
        m_LayerTask = layerTask;
        m_LayerTask.AddRandomlySpawnedChild(slotTask);
        m_LayerTask.Init(this, SCR_ScenarioFrameworkEActivationType.ON_TASKS_INIT);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_BaseTriggerEntity GetTrigger()
    {
        return m_Trigger;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void SetupTrigger()
    {
        if (!m_Trigger)
        {
            EntitySpawnParams spawnParams = new EntitySpawnParams();
            spawnParams.TransformMode = ETransformMode.WORLD;
            GetOwner().GetWorldTransform(spawnParams.Transform);
            m_Trigger = SCR_BaseTriggerEntity.Cast(GetGame().SpawnEntityPrefabEx(m_sTriggerResource, false, params: spawnParams));
        }
 
        if (!m_Trigger)
            return;
 
        m_Trigger.SetSphereRadius(m_fAreaRadius);
        m_Trigger.GetOnActivate().Insert(OnAreaTriggerActivated);
 
        SCR_ScenarioFrameworkTriggerEntity sfTrigger = SCR_ScenarioFrameworkTriggerEntity.Cast(m_Trigger);
        if (sfTrigger)
            sfTrigger.SetOnce(m_bOnce);
 
        if (m_Trigger)
        {
            foreach (SCR_ScenarioFrameworkActionBase triggerAction : m_aTriggerActions)
            {
                triggerAction.Init(m_Trigger);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void MoveTaskIconToArea(notnull SCR_Task task)
    {
        task.SetOrigin(GetOwner().GetOrigin());
 
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetIsTaskSuitableForArea(SCR_ESFTaskType eTaskType)
    {
        array<SCR_ESFTaskType> aTaskTypes = {};
        GetAvailableTaskTypes(aTaskTypes);
        if (aTaskTypes.IsEmpty())
            return false;
 
        return aTaskTypes.Find(eTaskType) != -1;
    }
 
    //------------------------------------------------------------------------------------------------
    void GetAvailableTaskTypes(out array<SCR_ESFTaskType> aTaskTypes)
    {
        array<SCR_ScenarioFrameworkLayerBase> aSlots = {};
        GetChildren(aSlots);
        SCR_ESFTaskType eType;
        SCR_ScenarioFrameworkLayerTask pos;
        foreach (SCR_ScenarioFrameworkLayerBase layer : aSlots)
        {
            pos = SCR_ScenarioFrameworkLayerTask.Cast(layer);
            if (!pos)
                continue;
 
            eType = pos.GetTaskType();
            if (aTaskTypes.Find(eType) == -1)
                aTaskTypes.Insert(eType);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void GetSuitableLayersForTaskType(out notnull array<SCR_ScenarioFrameworkLayerBase> aSlotsOut, SCR_ESFTaskType eTaskType)
    {
        SCR_ESFTaskType eType;
        array<SCR_ScenarioFrameworkLayerBase> aSlots = {};
        GetChildren(aSlots);
        SCR_ScenarioFrameworkLayerTask pos;
        foreach (SCR_ScenarioFrameworkLayerBase layer : aSlots)
        {
            pos = SCR_ScenarioFrameworkLayerTask.Cast(layer);
            if (!pos)
                continue;
 
            eType = pos.GetTaskType();
            if (eTaskType == eType)
                aSlotsOut.Insert(pos);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SetAreaSelected(bool bSet)
    {
         m_bAreaSelected = bSet;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetIsAreaSelected()
    {
        return m_bAreaSelected;
    }
 
    //------------------------------------------------------------------------------------------------
    void OnAreaTriggerActivated(IEntity entity)
    {
        if (m_OnTriggerActivated)
        {
            m_OnTriggerActivated.Invoke(this, SCR_ScenarioFrameworkEActivationType.ON_AREA_TRIGGER_ACTIVATION, false);
            m_OnTriggerActivated.Clear();
            if (!m_bOnce)
                return;
 
            m_Trigger.EnablePeriodicQueries(false);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnAreaTriggerActivated()
    {
        if (!m_OnTriggerActivated)
            m_OnTriggerActivated = new ScriptInvoker<SCR_ScenarioFrameworkArea, SCR_ScenarioFrameworkEActivationType>();
 
        return m_OnTriggerActivated;
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvoker GetOnAreaInit()
    {
        return m_OnAreaInit;
    }
 
    //------------------------------------------------------------------------------------------------
    override void RestoreToDefault(bool includeChildren = false, bool reinitAfterRestoration = false, bool affectRandomization = true, bool deleteSpawnedEntities = true)
    {
        m_bAreaSelected = false;
        m_Trigger = null;
        m_sItemDeliveryPointName = "";
        m_LayerTask = null;
        m_SlotTask = null;
 
        super.RestoreToDefault(includeChildren, reinitAfterRestoration, affectRandomization, deleteSpawnedEntities);
    }
 
    //------------------------------------------------------------------------------------------------
    override void DynamicReinit()
    {
        Init();
    }
 
    //------------------------------------------------------------------------------------------------
    override void DynamicDespawn(SCR_ScenarioFrameworkLayerBase layer)
    {
        if (m_bExcludeFromDynamicDespawn)
            return;
 
        m_bInitiated = false;
        m_bDynamicallyDespawned = true;
        m_aChildren.RemoveItem(null);
        foreach (SCR_ScenarioFrameworkLayerBase child : m_aChildren)
        {
            // Check if the child has its own Dynamic Despawn in place that is managed by the parent area and not the parent layer
            if (!child.m_bDynamicDespawn)
                child.DynamicDespawn(this);
        }
 
        m_aChildren.Clear();
    }
 
    //------------------------------------------------------------------------------------------------
    override bool InitParentLayer()
    {
        // Areas do not have parents
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override void Init(SCR_ScenarioFrameworkArea area = null, SCR_ScenarioFrameworkEActivationType activation = SCR_ScenarioFrameworkEActivationType.SAME_AS_PARENT)
    {
        if (m_eActivationType != SCR_ScenarioFrameworkEActivationType.ON_INIT)
            PrintFormat("ScenarioFramework: Area %1 is set to %2 activation type, but area will always spawn on Init as default", GetOwner().GetName(), activation, LogLevel.WARNING);
 
        // Area is always spawned on the start
        super.Init(this, SCR_ScenarioFrameworkEActivationType.ON_INIT);
    }
    
    //------------------------------------------------------------------------------------------------
    override void AfterAllChildrenSpawned(SCR_ScenarioFrameworkLayerBase layer)
    {
        super.AfterAllChildrenSpawned(layer);
 
        SetupTrigger();
    }
    
    //------------------------------------------------------------------------------------------------
    void PrepareLayerSpecificDynamicDespawn(SCR_ScenarioFrameworkLayerBase layer, bool staySpawned = false, int despawnRange = 0)
    {
        layer.SetDynamicDespawnEnabled(true);
        layer.SetDynamicDespawnRange(despawnRange);
        
        if (m_aDespawnedLayers.IsEmpty() && m_aSpawnedLayers.IsEmpty())
            PrepareDynamicDespawn();
 
        //If this method is called with staySpawned = false, layer will be added to m_aDespawnedLayers and gets despawned
        if (!staySpawned)
        {
            m_aDespawnedLayers.Insert(new Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int>(layer, layer.GetOwner().GetOrigin(), (despawnRange * despawnRange)));
            layer.DynamicDespawn(layer);
        }
        else
        {
            m_aSpawnedLayers.Insert(new Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int>(layer, layer.GetOwner().GetOrigin(), (despawnRange * despawnRange)));
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void RemoveLayerSpecificDynamicDespawn(SCR_ScenarioFrameworkLayerBase layer, bool staySpawned = false)
    {
        layer.SetDynamicDespawnEnabled(false);
        
        //If this method is called with staySpawned = false, layer will be despawned
        if (!staySpawned)
            layer.DynamicDespawn(layer);
 
        for (int i = m_aDespawnedLayers.Count() - 1; i >= 0; i--)
        {
            Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int> layerInfo = m_aDespawnedLayers[i];
            if (layer == layerInfo.param1)
                m_aDespawnedLayers.Remove(i);
        }
 
        for (int i = m_aSpawnedLayers.Count() - 1; i >= 0; i--)
        {
            Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int> layerInfo = m_aSpawnedLayers[i];
            if (layer == layerInfo.param1)
                m_aSpawnedLayers.Remove(i);
        }
        
        if (m_aDespawnedLayers.IsEmpty() && m_aSpawnedLayers.IsEmpty())
            RemoveDynamicDespawn();
    }
    
    //------------------------------------------------------------------------------------------------
    void PrepareDynamicDespawn()
    {
        if (!m_bDynamicDespawn)
            return;
        
        SCR_ScenarioFrameworkSystem scenarioFrameworkSystem = SCR_ScenarioFrameworkSystem.GetInstance();
        if (!scenarioFrameworkSystem)
            return;
        
        ExecuteDynamicDespawn(scenarioFrameworkSystem);
        SCR_ScenarioFrameworkSystem.GetCallQueuePausable().CallLater(ExecuteDynamicDespawn, 1000 * scenarioFrameworkSystem.m_iUpdateRate, true, scenarioFrameworkSystem);
    }
    
    //------------------------------------------------------------------------------------------------
    void RemoveDynamicDespawn()
    {
        if (!m_bDynamicDespawn)
            return;
        
        SCR_ScenarioFrameworkSystem scenarioFrameworkSystem = SCR_ScenarioFrameworkSystem.GetInstance();
        if (!scenarioFrameworkSystem)
            return;
        
        SCR_ScenarioFrameworkSystem.GetCallQueuePausable().Remove(ExecuteDynamicDespawn);
    }
    
    //------------------------------------------------------------------------------------------------
    void ExecuteDynamicDespawn(SCR_ScenarioFrameworkSystem scenarioFrameworkSystem)
    {
        if (!scenarioFrameworkSystem)
            return;
        
        DynamicSpawnLayer(scenarioFrameworkSystem.m_aObservers);
        DynamicDespawnLayer(scenarioFrameworkSystem.m_aObservers);
    }
    
    //------------------------------------------------------------------------------------------------
    void DynamicSpawnLayer(array<vector> observers)
    {
        Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int> layerInfo;
        for (int i = m_aDespawnedLayers.Count() - 1; i >= 0; i--)
        {
            layerInfo = m_aDespawnedLayers[i];
            if (!layerInfo.param1)
            {
                continue;
            }
            
            foreach (vector observerPos : observers)
            {
                if (vector.DistanceSqXZ(observerPos, layerInfo.param2) < layerInfo.param3)
                {
                    layerInfo.param1.DynamicReinit();
                    m_aSpawnedLayers.Insert(layerInfo);
                    m_aDespawnedLayers.Remove(i);
                    break;
                }
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void DynamicDespawnLayer(array<vector> observers)
    {
        Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int> layerInfo;
        for (int i = m_aSpawnedLayers.Count() - 1; i >= 0; i--)
        {
            layerInfo = m_aSpawnedLayers[i];
            if (!layerInfo.param1)
                continue;
            
            bool observerInRange;
            foreach (vector observerPos : observers)
            {
                if (vector.DistanceSqXZ(observerPos, layerInfo.param2) < layerInfo.param3)
                {
                    observerInRange = true;
                    break;
                }
            }
 
            if (!observerInRange)
            {
                layerInfo.param1.DynamicDespawn(null);
                m_aDespawnedLayers.Insert(layerInfo);
                m_aSpawnedLayers.Remove(i);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    override void EOnInit(IEntity owner)
    {
        SCR_BaseGameMode gameMode = SCR_BaseGameMode.Cast(GetGame().GetGameMode());
        if (!gameMode)
            return;
 
        SCR_ScenarioFrameworkSystem scenarioFrameworkSystem = SCR_ScenarioFrameworkSystem.GetInstance();
        if (scenarioFrameworkSystem)
            scenarioFrameworkSystem.RegisterArea(this);
 
        array<SCR_ScenarioFrameworkLayerBase> children = {};
        GetAllLayers(children);
 
        foreach (SCR_ScenarioFrameworkLayerBase child : children)
        {
            if (child.GetActivationType() == SCR_ScenarioFrameworkEActivationType.ON_INIT)
            {
                if (scenarioFrameworkSystem && scenarioFrameworkSystem.IsMaster())
                    child.Init(this, SCR_ScenarioFrameworkEActivationType.ON_INIT);
 
                child.SetActivationType(SCR_ScenarioFrameworkEActivationType.SAME_AS_PARENT);
            }
            
            if (!child.GetDynamicDespawnEnabled())
                continue;
            
            int despawnRange = child.GetDynamicDespawnRange();
            m_aDespawnedLayers.Insert(new Tuple3<SCR_ScenarioFrameworkLayerBase, vector, int>(child, child.GetOwner().GetOrigin(), (despawnRange * despawnRange)));
        }
        
        if (!m_aDespawnedLayers.IsEmpty())
            PrepareDynamicDespawn();
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnPostInit(IEntity owner)
    {
        SetEventMask(owner, EntityEvent.INIT);
 
        super.OnPostInit(owner);
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void DrawDebugShape(bool draw)
    {
        Shape dbgShape = null;
        if (!draw)
            return;
 
        dbgShape = Shape.CreateSphere(
                                        m_iDebugShapeColor,
                                        ShapeFlags.TRANSP | ShapeFlags.DOUBLESIDE | ShapeFlags.NOZWRITE | ShapeFlags.ONCE | ShapeFlags.NOOUTLINE,
                                        GetOwner().GetOrigin(),
                                        m_fDebugShapeRadius
                                );
 
        if (m_sTriggerResource.IsEmpty())
            return;
 
        Shape triggerdbgShape = null;
        triggerdbgShape = Shape.CreateSphere(
                                        ARGB(100, 0x99, 0x10, 0xF2),
                                        ShapeFlags.TRANSP | ShapeFlags.DOUBLESIDE | ShapeFlags.NOZWRITE | ShapeFlags.ONCE | ShapeFlags.NOOUTLINE,
                                        GetOwner().GetOrigin(),
                                        m_fAreaRadius
                                );
    }
    //------------------------------------------------------------------------------------------------
    // constructor
    void SCR_ScenarioFrameworkArea(IEntityComponentSource src, IEntity ent, IEntity parent)
    {
        m_fDebugShapeRadius = m_iDynamicDespawnRange;
#ifdef WORKBENCH
        m_iDebugShapeColor = ARGB(32, 0x99, 0xF3, 0x12);
#endif
    }
    
    //------------------------------------------------------------------------------------------------
    void ~SCR_ScenarioFrameworkArea()
    {
        SCR_ScenarioFrameworkSystem scenarioFrameworkSystem = SCR_ScenarioFrameworkSystem.GetInstance();
        if (scenarioFrameworkSystem)
            scenarioFrameworkSystem.UnregisterArea(this);
    }
}