SCR_ScenarioFrameworkLayerBase.c

Go to the documentation of this file.

[EntityEditorProps(category: "GameScripted/ScenarioFramework/Layer", description: "")]
class SCR_ScenarioFrameworkLayerBaseClass : ScriptComponentClass
{
}
 
// SCR_ScenarioFrameworkLayerBase Invoker
void ScriptInvokerScenarioFrameworkLayerMethod(SCR_ScenarioFrameworkLayerBase layer);
typedef func ScriptInvokerScenarioFrameworkLayerMethod;
typedef ScriptInvokerBase<ScriptInvokerScenarioFrameworkLayerMethod> ScriptInvokerScenarioFrameworkLayer;
 
enum SCR_EScenarioFrameworkSpawnChildrenType
{
    ALL,
    RANDOM_ONE,
    RANDOM_MULTIPLE,
    RANDOM_BASED_ON_PLAYERS_COUNT
}
 
class SCR_ScenarioFrameworkLayerBase : ScriptComponent
{
    [Attribute(defvalue: "0", UIWidgets.ComboBox, desc: "Spawn all children, only random one or random multiple ones?", "", ParamEnumArray.FromEnum(SCR_EScenarioFrameworkSpawnChildrenType), category: "Children")]
    SCR_EScenarioFrameworkSpawnChildrenType m_SpawnChildren;
 
    [Attribute(desc: "Faction key that corresponds with the SCR_Faction set in FactionManager", category: "Asset")]
    FactionKey m_sFactionKey;
 
    [Attribute(defvalue: "100", desc: "If the RANDOM_MULTIPLE option is selected, what's the percentage? ", UIWidgets.Graph, "0 100 1", category: "Children")]
    int m_iRandomPercent;
 
    [Attribute(desc: "When enabled, it will repeatedly spawn childern according to other parameters set", category: "Children")]
    bool m_bEnableRepeatedSpawn;
 
    [Attribute(defvalue: "-1", desc: "If Repeated Spawn is enabled, how many times can children be spawned? If set to -1, it is unlimited", params: "-1 inf 1", category: "Children")]
    int m_iRepeatedSpawnNumber;
 
    [Attribute(defvalue: "-1", UIWidgets.Slider, desc: "If Repeated Spawn is enabled, how frequently it will spawn next wave of children? Value -1 means disabled, thus children won't be spawned by the elapsed time.", params: "-1 86400 1", category: "Children")]
    float m_fRepeatedSpawnTimer;
 
    [Attribute(desc: "Show the debug shapes during runtime", category: "Debug")]
    bool m_bShowDebugShapesDuringRuntime;
    
    [Attribute(desc: "Show the debug shapes in Workbench", category: "Debug")]
    bool m_bShowDebugShapesInWorkbench;
 
    [Attribute("0", uiwidget: UIWidgets.ComboBox, "", "", ParamEnumArray.FromEnum(SCR_ScenarioFrameworkEActivationType), category: "Activation")]
    SCR_ScenarioFrameworkEActivationType m_eActivationType;
 
    [Attribute(desc: "Conditions that will be checked upon init and based on the result it will let this to finish init or not", category: "Activation")]
    ref array<ref SCR_ScenarioFrameworkActivationConditionBase> m_aActivationConditions;
 
    [Attribute(defvalue: SCR_EScenarioFrameworkLogicOperators.AND.ToString(), UIWidgets.ComboBox, "Which Boolean Logic will be used for Activation Conditions", "", enums: SCR_EScenarioFrameworkLogicOperatorHelper.GetParamInfo(), category: "Activation")]
    SCR_EScenarioFrameworkLogicOperators m_eActivationConditionLogic;
 
    [Attribute(desc: "Actions that will be activated on initalization.", category: "OnInit")]
    ref array<ref SCR_ScenarioFrameworkActionBase>  m_aActivationActions;
 
    [Attribute(desc: "Should the dynamic Spawn/Despawn based on distance from observer cameras be enabled?", category: "Activation")]
    bool m_bDynamicDespawn;
 
    [Attribute(defvalue: "750", params: "0 inf", desc: "How close at least one observer camera must be in order to trigger spawn", category: "Activation")]
    int m_iDynamicDespawnRange; 
    
    [Attribute(desc: "", category: "Activation")]
    bool m_bExcludeFromDynamicDespawn;
 
    [Attribute(UIWidgets.Auto, category: "Plugins")]
    ref array<ref SCR_ScenarioFrameworkPlugin> m_aPlugins;
 
    ref array<SCR_ScenarioFrameworkLayerBase> m_aChildren = {};
    ref array<SCR_ScenarioFrameworkLayerBase> m_aRandomlySpawnedChildren = {};
    ref array<SCR_ScenarioFrameworkLogic> m_aLogic = {};
 
    ref ScriptInvokerBase<ScriptInvokerScenarioFrameworkLayerMethod> m_OnAllChildrenSpawned;
    ref array<IEntity> m_aSpawnedEntities = {};
    IEntity m_Entity;
    SCR_ScenarioFrameworkArea m_Area;
    SCR_ScenarioFrameworkLayerBase m_ParentLayer;
    float m_fDebugShapeRadius = 0.25;
    WorldTimestamp m_fRepeatSpawnTimeStart;
    WorldTimestamp  m_fRepeatSpawnTimeEnd;
    int m_iDebugShapeColor = ARGB(32, 255, 255, 255);
    int m_iCurrentlySpawnedChildren;
    int m_iSupposedSpawnedChildren;
    bool m_bInitiated;
    bool m_bDynamicallyDespawned;
    bool m_bIsTerminated; //Marks if this was terminated - either by death or deletion
 
    //Default values we need to store
    int m_iRepeatedSpawnNumberDefault = m_iRepeatedSpawnNumber;
    SCR_ScenarioFrameworkEActivationType m_eActivationTypeDefault = m_eActivationType;
 
    static const int SPAWN_DELAY = 200;
 
    //------------------------------------------------------------------------------------------------
    string GetName()
    {
        return GetOwner().GetName();
    }
 
    //------------------------------------------------------------------------------------------------
    void SetEntity(IEntity entity)
    {
        m_Entity = entity;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetIsTerminated()
    {
        return m_bIsTerminated;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetIsTerminated(bool state)
    {
        m_bIsTerminated = state;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetRandomlySpawnedChildren(array<string> randomlySpawnedChildren)
    {
        IEntity entity;
        SCR_ScenarioFrameworkLayerBase layer;
        m_aRandomlySpawnedChildren.Clear();
        foreach (string child : randomlySpawnedChildren)
        {
            entity = GetGame().GetWorld().FindEntityByName(child);
            if (!entity)
                continue;
 
            layer = SCR_ScenarioFrameworkLayerBase.Cast(entity.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (!layer)
                continue;
 
            m_aRandomlySpawnedChildren.Insert(layer);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void AddRandomlySpawnedChild(SCR_ScenarioFrameworkLayerBase child)
    {
        if (child && !m_aRandomlySpawnedChildren.Contains(child))
            m_aRandomlySpawnedChildren.Insert(child);
    }
 
    //------------------------------------------------------------------------------------------------
    array<SCR_ScenarioFrameworkLayerBase> GetRandomlySpawnedChildren()
    {
        return m_aRandomlySpawnedChildren;
    }
 
    //------------------------------------------------------------------------------------------------
    int GetPlayersCount(FactionKey factionName = "")
    {
        if (factionName.IsEmpty())
            return GetGame().GetPlayerManager().GetPlayerCount();
 
        FactionManager factionManager = GetGame().GetFactionManager();
        if (!factionManager)
            return -1;
 
        int iCnt = 0;
        array<int> aPlayerIDs = {};
        SCR_PlayerController playerController;
        GetGame().GetPlayerManager().GetPlayers(aPlayerIDs);
        foreach (int iPlayerID : aPlayerIDs)
        {
            playerController = SCR_PlayerController.Cast(GetGame().GetPlayerManager().GetPlayerController(iPlayerID));
            if (!playerController)
                continue;
 
            if (playerController.GetLocalControlledEntityFaction() == factionManager.GetFactionByKey(factionName))
                iCnt++;
        }
        return iCnt;
    }
 
    //---- REFACTOR NOTE START: This code will need to be refactored as current implementation is not conforming to the standards ----
    //------------------------------------------------------------------------------------------------
    int GetMaxPlayersForGameMode(FactionKey factionName = "")
    {
        //TODO: separate players by faction (attackers / defenders)
        SCR_MissionHeader header = SCR_MissionHeader.Cast(GetGame().GetMissionHeader());
 
        if (!header)
            return 4;   //TODO: make a constant
 
        return header.m_iPlayerCount;
    }
    //---- REFACTOR NOTE END ----
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkArea GetParentArea()
    {
        if (m_Area)
            return m_Area;
 
        IEntity entity = GetOwner().GetParent();
        while (entity)
        {
            m_Area = SCR_ScenarioFrameworkArea.Cast(entity.FindComponent(SCR_ScenarioFrameworkArea));
            if (m_Area)
                return m_Area;
 
            entity = entity.GetParent();
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    void GetAllLayers(out notnull array<SCR_ScenarioFrameworkLayerBase> layers)
    {
        layers.Clear();
        array<SCR_ScenarioFrameworkLayerBase> aSiblingLayers = {};
        SCR_ScenarioFrameworkLayerBase layerBase;
        IEntity child = GetOwner().GetChildren();
        while (child)
        {
            layerBase = SCR_ScenarioFrameworkLayerBase.Cast(child.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (layerBase)
            {
                layers.Insert(layerBase);
 
                layerBase.GetAllLayers(aSiblingLayers);
                layers.InsertAll(aSiblingLayers);
            }
 
            child = child.GetSibling();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void GetAllLayers(out notnull array<SCR_ScenarioFrameworkLayerBase> layers, SCR_ScenarioFrameworkEActivationType activationType)
    {
        layers.Clear();
        array<SCR_ScenarioFrameworkLayerBase> aSiblingLayers = {};
        SCR_ScenarioFrameworkLayerBase layerBase;
        IEntity child = GetOwner().GetChildren();
        while (child)
        {
            layerBase = SCR_ScenarioFrameworkLayerBase.Cast(child.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (layerBase)
            {
                if (layerBase.m_eActivationType == activationType)
                    layers.Insert(layerBase);
 
                layerBase.GetAllLayers(aSiblingLayers, activationType);
                layers.InsertAll(aSiblingLayers);
            }
 
            child = child.GetSibling();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void GetAllLayerTasks(out notnull array<SCR_ScenarioFrameworkLayerTask> layerTasks)
    {
        layerTasks.Clear();
        array<SCR_ScenarioFrameworkLayerTask> aSiblingLayerTasks = {};
        SCR_ScenarioFrameworkLayerTask layerTask;
        SCR_ScenarioFrameworkLayerBase layerBase;
        IEntity child = GetOwner().GetChildren();
        while (child)
        {
            layerBase = SCR_ScenarioFrameworkLayerBase.Cast(child.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (layerBase)
            {
                layerTask = SCR_ScenarioFrameworkLayerTask.Cast(layerBase);
                if (layerTask)
                    layerTasks.Insert(layerTask);
 
                layerBase.GetAllLayerTasks(aSiblingLayerTasks);
                layerTasks.InsertAll(aSiblingLayerTasks);
            }
 
            child = child.GetSibling();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void GetAllSlotTasks(out notnull array<SCR_ScenarioFrameworkSlotTask> slotTasks)
    {
        slotTasks.Clear();
        array<SCR_ScenarioFrameworkSlotTask> aSiblingSlotTasks = {};
        SCR_ScenarioFrameworkSlotTask slotTask;
        SCR_ScenarioFrameworkLayerBase layerBase;
        IEntity child = GetOwner().GetChildren();
        while (child)
        {
            layerBase = SCR_ScenarioFrameworkLayerBase.Cast(child.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (layerBase)
            {
                slotTask = SCR_ScenarioFrameworkSlotTask.Cast(layerBase);
                if (slotTask)
                    slotTasks.Insert(slotTask);
 
                layerBase.GetAllSlotTasks(aSiblingSlotTasks);
                slotTasks.InsertAll(aSiblingSlotTasks);
            }
 
            child = child.GetSibling();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkLayerTask GetLayerTask()
    {
        SCR_ScenarioFrameworkLayerTask layer;
        IEntity entity = GetOwner().GetParent();
        while (entity)
        {
            layer = SCR_ScenarioFrameworkLayerTask.Cast(entity.FindComponent(SCR_ScenarioFrameworkLayerTask));
            if (layer)
                return layer;
 
            entity = entity.GetParent();
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkSlotTask GetSlotTask(array<SCR_ScenarioFrameworkLayerBase> aLayers)
    {
        SCR_ScenarioFrameworkSlotTask slotTask;
        foreach (SCR_ScenarioFrameworkLayerBase layer : aLayers)
        {
            IEntity child = layer.GetOwner();
            slotTask = SCR_ScenarioFrameworkSlotTask.Cast(child.FindComponent(SCR_ScenarioFrameworkSlotTask));
            if (slotTask)
                return slotTask;
 
            child = GetOwner().GetChildren();
            while (child)
            {
                slotTask = SCR_ScenarioFrameworkSlotTask.Cast(child.FindComponent(SCR_ScenarioFrameworkSlotTask));
                if (slotTask)
                    return slotTask;
 
                child = child.GetSibling();
            }
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void SetFactionKey(FactionKey factionKey)
    {
        m_sFactionKey = factionKey;
    }
 
    //------------------------------------------------------------------------------------------------
    protected FactionKey GetFactionKey()
    {
        return m_sFactionKey;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetParentLayer(SCR_ScenarioFrameworkLayerBase parentLayer)
    {
        m_ParentLayer = parentLayer;
    }
 
    //------------------------------------------------------------------------------------------------
    protected FactionKey GetParentFactionKeyRecursive()
    {
        if (!SCR_StringHelper.IsEmptyOrWhiteSpace(GetFactionKey()))
        {
            // Resolve Alias
            SCR_FactionAliasComponent factionAliasComponent = SCR_FactionAliasComponent.GetFactionAliasComponentForWB();
            if (!factionAliasComponent)
                return GetFactionKey();   // If the mission creator didn't define SCR_FactionAliasComponent, then alias resolution is not needed.
 
            return factionAliasComponent.ResolveFactionAlias(GetFactionKey());
        }
 
        IEntity parentEntity = GetOwner().GetParent();
        if (!parentEntity)
            return "";
 
        SCR_ScenarioFrameworkLayerBase parentLayer = SCR_ScenarioFrameworkLayerBase.Cast(parentEntity.FindComponent(SCR_ScenarioFrameworkLayerBase));
        if (!parentLayer)
            return "";
 
        FactionKey factionKey = parentLayer.GetParentFactionKeyRecursive();
        return factionKey;
 
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkLayerBase GetParentLayer()
    {
        if (m_ParentLayer)
            return m_ParentLayer;
 
        IEntity entity = GetOwner().GetParent();
        if (!entity)
            return null;
 
        m_ParentLayer = SCR_ScenarioFrameworkLayerBase.Cast(entity.FindComponent(SCR_ScenarioFrameworkLayerBase));
        return m_ParentLayer;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_EScenarioFrameworkSpawnChildrenType GetSpawnChildrenType()
    {
        return m_SpawnChildren;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetEnableRepeatedSpawn()
    {
        return m_bEnableRepeatedSpawn;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetEnableRepeatedSpawn(bool value)
    {
        m_bEnableRepeatedSpawn = value;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkEActivationType GetActivationType()
    {
        return m_eActivationType;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetActivationType(SCR_ScenarioFrameworkEActivationType activationType)
    {
        m_eActivationType = activationType;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetIsInitiated()
    {
        return m_bInitiated;
    }
    
    //------------------------------------------------------------------------------------------------
    bool GetDynamicDespawnEnabled()
    {
        return m_bDynamicDespawn;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetDynamicDespawnEnabled(bool enabled)
    {
        m_bDynamicDespawn = enabled;
    }
 
    //------------------------------------------------------------------------------------------------
    bool GetDynamicDespawnExcluded()
    {
        return m_bExcludeFromDynamicDespawn;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetDynamicDespawnRange()
    {
        return m_iDynamicDespawnRange;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetDynamicDespawnRange(int range)
    {
        m_iDynamicDespawnRange = range;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetDynamicDespawnExcluded(bool excluded)
    {
        m_bExcludeFromDynamicDespawn = excluded;
    }
 
    //------------------------------------------------------------------------------------------------
    array<IEntity> GetSpawnedEntities()
    {
        return m_aSpawnedEntities;
    }
 
    //------------------------------------------------------------------------------------------------
    array<SCR_ScenarioFrameworkLayerBase> GetChildrenEntities()
    {
        return m_aChildren;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_ScenarioFrameworkLayerBase GetRandomChildren()
    {
        if (m_aChildren.IsEmpty())
            return null;
        
        array<SCR_ScenarioFrameworkLayerBase> suitableChildren = {};
        foreach (SCR_ScenarioFrameworkLayerBase child : m_aChildren)
        {
            if (child.GetDynamicDespawnEnabled())
                continue;
            
            suitableChildren.Insert(child);
        }
 
        return suitableChildren.GetRandomElement();
    }
 
    //------------------------------------------------------------------------------------------------
    void GetChildren(out array<SCR_ScenarioFrameworkLayerBase> children)
    {
        children = {};
        map<string, SCR_ScenarioFrameworkLayerBase> childrenReversed = new map<string, SCR_ScenarioFrameworkLayerBase>;
        array<string> childrenStringsReversed = {};
        SCR_ScenarioFrameworkLayerBase layerBase;
        IEntity child = GetOwner().GetChildren();
        while (child)
        {
            layerBase = SCR_ScenarioFrameworkLayerBase.Cast(child.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (layerBase)
            {
                childrenReversed.Insert(layerBase.GetName(), layerBase);
                childrenStringsReversed.Insert(layerBase.GetName());
            }
 
            child = child.GetSibling();
        }
 
        childrenStringsReversed.Sort();
        foreach (string name : childrenStringsReversed)
        {
            layerBase = childrenReversed.Get(name);
 
            if (layerBase)
                children.Insert(layerBase);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void GetChildren(out array<SCR_ScenarioFrameworkLayerBase> children, SCR_ScenarioFrameworkEActivationType activationType)
    {
        children = {};
        map<string, SCR_ScenarioFrameworkLayerBase> childrenReversed = new map<string, SCR_ScenarioFrameworkLayerBase>;
        array<string> childrenStringsReversed = {};
        SCR_ScenarioFrameworkLayerBase layerBase;
        IEntity child = GetOwner().GetChildren();
        while (child)
        {
            layerBase = SCR_ScenarioFrameworkLayerBase.Cast(child.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (layerBase)
            {
                childrenReversed.Insert(layerBase.GetName(), layerBase);
                childrenStringsReversed.Insert(layerBase.GetName());
            }
 
            child = child.GetSibling();
        }
 
        childrenStringsReversed.Sort();
        foreach (string name : childrenStringsReversed)
        {
            layerBase = childrenReversed.Get(name);
 
            if (layerBase && layerBase.m_eActivationType == activationType)
                children.Insert(layerBase);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void GetLogics(out array<SCR_ScenarioFrameworkLogic> logics)
    {
        IEntity child = GetOwner().GetChildren();
        SCR_ScenarioFrameworkLogic logic;
        while (child)
        {
            logic = SCR_ScenarioFrameworkLogic.Cast(child);
            if (logic && !logics.Contains(logic))
                logics.Insert(logic);
 
            child = child.GetSibling();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    array<SCR_ScenarioFrameworkLogic> GetSpawnedLogics()
    {
        return m_aLogic;
    }
 
    //------------------------------------------------------------------------------------------------
    array<ref SCR_ScenarioFrameworkPlugin> GetSpawnedPlugins()
    {
        return m_aPlugins;
    }
 
    //------------------------------------------------------------------------------------------------
    int GetRepeatedSpawnNumber()
    {
        return m_iRepeatedSpawnNumber;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetRepeatedSpawnNumber(int number)
    {
        m_iRepeatedSpawnNumber = number;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void RepeatedSpawn()
    {
        if (!m_bEnableRepeatedSpawn || (m_iRepeatedSpawnNumber != -1 && m_iRepeatedSpawnNumber <= 0))
            return;
 
        //This calls the RepeatedSpawnCalled with set delay and is set in a way that it
        //Can be both queued that way or called manually from different place (pseudo-looped CallLater)
        SCR_ScenarioFrameworkSystem.GetCallQueuePausable().CallLater(RepeatedSpawnCalled, 1000 * m_fRepeatedSpawnTimer);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void RepeatedSpawnCalled()
    {
        if (m_iRepeatedSpawnNumber != -1)
            m_iRepeatedSpawnNumber--;
 
        SpawnChildren(true);
 
        if (!m_bEnableRepeatedSpawn || (m_iRepeatedSpawnNumber != -1 && m_iRepeatedSpawnNumber <= 0))
            return;
 
        RepeatedSpawn();
    }
 
    //------------------------------------------------------------------------------------------------
    ScriptInvokerScenarioFrameworkLayer GetOnAllChildrenSpawned()
    {
        if (!m_OnAllChildrenSpawned)
            m_OnAllChildrenSpawned = new ScriptInvokerBase<ScriptInvokerScenarioFrameworkLayerMethod>();
 
        return m_OnAllChildrenSpawned;
    }
 
    //------------------------------------------------------------------------------------------------
    void InvokeAllChildrenSpawned()
    {
        if (m_OnAllChildrenSpawned)
            m_OnAllChildrenSpawned.Invoke(this);
    }
 
    //------------------------------------------------------------------------------------------------
    void CalculateSupposedSpawnedChildren(bool previouslyRandomized = false)
    {
        m_iSupposedSpawnedChildren = 0;
        if (previouslyRandomized)
        {
            foreach (SCR_ScenarioFrameworkLayerBase child : m_aRandomlySpawnedChildren)
            {
                if (child.GetDynamicDespawnEnabled())
                    continue;
                
                int activationType = child.GetActivationType();
                if (activationType == SCR_ScenarioFrameworkEActivationType.ON_TRIGGER_ACTIVATION || activationType == SCR_ScenarioFrameworkEActivationType.ON_AREA_TRIGGER_ACTIVATION
                    || activationType == SCR_ScenarioFrameworkEActivationType.ON_TASKS_INIT)
                    continue;
 
                if (child.GetIsTerminated())
                    continue;
 
                if (!child.InitActivationConditions())
                    continue;
 
                if (child.GetIsInitiated())
                    m_iCurrentlySpawnedChildren++;
 
                m_iSupposedSpawnedChildren++;
            }
        }
        else
        {
            foreach (SCR_ScenarioFrameworkLayerBase child : m_aChildren)
            {
                if (child.GetDynamicDespawnEnabled())
                    continue;
                
                int activationType = child.GetActivationType();
                if (activationType == SCR_ScenarioFrameworkEActivationType.ON_TRIGGER_ACTIVATION || activationType == SCR_ScenarioFrameworkEActivationType.ON_AREA_TRIGGER_ACTIVATION
                    || activationType == SCR_ScenarioFrameworkEActivationType.ON_TASKS_INIT)
                    continue;
 
                if (child.GetIsTerminated())
                    continue;
 
                if (!child.InitActivationConditions())
                    continue;
 
                if (child.GetIsInitiated())
                    m_iCurrentlySpawnedChildren++;
 
                m_iSupposedSpawnedChildren++;
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void CheckAllChildrenSpawned(SCR_ScenarioFrameworkLayerBase layer = null)
    {
        if (!layer && layer.GetDynamicDespawnEnabled())
            return;
        
        if (m_SpawnChildren == SCR_EScenarioFrameworkSpawnChildrenType.ALL)
        {
            m_iCurrentlySpawnedChildren = 0;
            CalculateSupposedSpawnedChildren();
 
            if (m_iCurrentlySpawnedChildren == m_iSupposedSpawnedChildren)
                InvokeAllChildrenSpawned();
        }
        else if (m_SpawnChildren == SCR_EScenarioFrameworkSpawnChildrenType.RANDOM_ONE)
        {
            InvokeAllChildrenSpawned();
        }
        else
        {
            m_iCurrentlySpawnedChildren = 0;
            foreach (SCR_ScenarioFrameworkLayerBase child : m_aChildren)
            {
                if (child.GetDynamicDespawnEnabled())
                    continue;
                
                int activationType = child.GetActivationType();
                if (activationType == SCR_ScenarioFrameworkEActivationType.ON_TRIGGER_ACTIVATION || activationType == SCR_ScenarioFrameworkEActivationType.ON_AREA_TRIGGER_ACTIVATION)
                    continue;
 
                if (child.GetIsTerminated())
                    continue;
 
                if (!child.InitActivationConditions())
                    continue;
 
                if (child.GetIsInitiated())
                    m_iCurrentlySpawnedChildren++;
            }
 
            if (m_iCurrentlySpawnedChildren == m_iSupposedSpawnedChildren)
                InvokeAllChildrenSpawned();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SpawnChildren(bool previouslyRandomized = false)
    {
        if (m_aChildren.IsEmpty())
        {
            InvokeAllChildrenSpawned();
            return;
        }
 
        if (!previouslyRandomized && !m_aRandomlySpawnedChildren.IsEmpty())
            previouslyRandomized = true;
 
        const bool isWorldLoadInit = SCR_ScenarioFrameworkSystem.IsWorldLoadInit();
        
        if (m_SpawnChildren == SCR_EScenarioFrameworkSpawnChildrenType.ALL)
        {
            int slotCount;
            foreach (SCR_ScenarioFrameworkLayerBase child : m_aChildren)
            {
                if (child.GetDynamicDespawnEnabled())
                {
                    if (m_aChildren.Count() == 1)
                        InvokeAllChildrenSpawned(); 
                    
                    continue;
                }
                
                if (SCR_ScenarioFrameworkSlotBase.Cast(child))
                {
                    if (isWorldLoadInit || SCR_ScenarioFrameworkSlotMarker.Cast(child) || SCR_ScenarioFrameworkSlotWaypoint.Cast(child))
                    {
                        InitChild(child);   
                    }
                    else
                    {
                        SCR_ScenarioFrameworkCallQueueSystem.GetCallQueueNonPausable().CallLater(InitChild, SPAWN_DELAY * slotCount, false, child);
                        slotCount++;
                    }
                }
                else
                {
                    InitChild(child);
                }
            }
        }
        else if (m_SpawnChildren == SCR_EScenarioFrameworkSpawnChildrenType.RANDOM_ONE)
        {
            SpawnRandomOneChild(previouslyRandomized);
        }
        else
        {
            SpawnRandomMultipleChildren(previouslyRandomized);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SpawnPreviouslyRandomizedChildren()
    {
        CalculateSupposedSpawnedChildren(true);
        
        const bool isWorldLoadInit = SCR_ScenarioFrameworkSystem.IsWorldLoadInit();
        foreach (int i, SCR_ScenarioFrameworkLayerBase child : m_aRandomlySpawnedChildren)
        {
            if (isWorldLoadInit)
            {
                InitChild(child);
                continue;
            }
 
            SCR_ScenarioFrameworkCallQueueSystem.GetCallQueueNonPausable().CallLater(InitChild, 200 * i, false, child);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SpawnRandomOneChild(bool previouslyRandomized = false)
    {
        if (previouslyRandomized)
            SpawnPreviouslyRandomizedChildren();
        else
        {
            SCR_ScenarioFrameworkLayerBase child = GetRandomChildren();
            m_aRandomlySpawnedChildren.Insert(child);
            InitChild(child);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SpawnRandomMultipleChildren(bool previouslyRandomized = false)
    {
        if (previouslyRandomized)
            SpawnPreviouslyRandomizedChildren();
        else
        {
            array<SCR_ScenarioFrameworkLayerBase> suitableChildren = {};
            foreach (SCR_ScenarioFrameworkLayerBase child : m_aChildren)
            {
                if (child.GetDynamicDespawnEnabled())
                    continue;
                
                suitableChildren.Insert(child);
            }
 
            if (suitableChildren.IsEmpty())
                return;
 
            if (m_SpawnChildren == SCR_EScenarioFrameworkSpawnChildrenType.RANDOM_BASED_ON_PLAYERS_COUNT)
                m_iRandomPercent = Math.Ceil(GetPlayersCount() / GetMaxPlayersForGameMode() * 100);
 
            m_iSupposedSpawnedChildren = Math.Round(suitableChildren.Count() * 0.01 * m_iRandomPercent);
            SCR_ScenarioFrameworkLayerBase child;
            for (int i = 1; i <= m_iSupposedSpawnedChildren; i++)
            {
                child = suitableChildren.GetRandomElement();
                m_aRandomlySpawnedChildren.Insert(child);
                InitChild(child);
                suitableChildren.RemoveItem(child);
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void InitChild(SCR_ScenarioFrameworkLayerBase child)
    {
        if (!child)
            return;
 
        child.SetParentLayer(this);
        child.Init(GetParentArea(), SCR_ScenarioFrameworkEActivationType.SAME_AS_PARENT);
    }
 
    //------------------------------------------------------------------------------------------------
    IEntity GetSpawnedEntity()
    {
        return m_Entity;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void ActivateLogic()
    {
        GetLogics(m_aLogic);
        foreach (SCR_ScenarioFrameworkLogic logic : m_aLogic)
        {
            logic.Init();
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void RestoreToDefault(bool includeChildren = false, bool reinitAfterRestoration = false, bool affectRandomization = true, bool deleteSpawnedEntities = true)
    {
        m_Entity = null;
        m_iRepeatedSpawnNumber = m_iRepeatedSpawnNumberDefault;
        m_eActivationType = m_eActivationTypeDefault;
        m_bInitiated = false;
        m_bDynamicallyDespawned = false;
        m_bIsTerminated = false;
 
        RestoreActionsToDefault();
 
        if (includeChildren)
        {
            if (m_aChildren.IsEmpty())
                GetChildren(m_aChildren);
 
            foreach (SCR_ScenarioFrameworkLayerBase child : m_aChildren)
            {
                child.RestoreToDefault(includeChildren, false);
            }
        }
 
        m_aChildren.Clear();
        if (affectRandomization)
            m_aRandomlySpawnedChildren.Clear();
        
        if (deleteSpawnedEntities)
        {
            foreach (IEntity entity : m_aSpawnedEntities)
            {
                SCR_EntityHelper.DeleteEntityAndChildren(entity);
            }
        }
 
        m_aSpawnedEntities.Clear();
 
        foreach (SCR_ScenarioFrameworkLogic logic : m_aLogic)
        {
            logic.RestoreToDefault();
        }
 
        if (reinitAfterRestoration)
            Init(m_Area);
    }
 
    //------------------------------------------------------------------------------------------------
    void DynamicDespawn(SCR_ScenarioFrameworkLayerBase layer)
    {
        GetOnAllChildrenSpawned().Remove(DynamicDespawn);
        if (!m_bInitiated)
        {
            GetOnAllChildrenSpawned().Insert(DynamicDespawn);
            return;
        }
 
        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();
 
        foreach (IEntity entity : m_aSpawnedEntities)
        {
            SCR_EntityHelper.DeleteEntityAndChildren(entity);
        }
 
        m_aSpawnedEntities.Clear();
    }
 
    //------------------------------------------------------------------------------------------------
    void DynamicReinit()
    {
        Init(GetParentArea(), SCR_ScenarioFrameworkEActivationType.SAME_AS_PARENT);
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitAlreadyHappened()
    {
        return m_bInitiated;
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitParentLayer()
    {
        if (m_ParentLayer)
            return true;
 
        m_ParentLayer = GetParentLayer();
        return (m_ParentLayer != null);
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitNotTerminated()
    {
        if (!m_bIsTerminated)
            return true;
 
        if (m_ParentLayer)
            m_ParentLayer.CheckAllChildrenSpawned(this);
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitDynDespawnAndActivation(SCR_ScenarioFrameworkEActivationType activation)
    {
        if (!m_bDynamicallyDespawned && activation != m_eActivationType)
        {
            if (m_ParentLayer)
                m_ParentLayer.CheckAllChildrenSpawned(this);
 
            return false;
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitActivationConditions(bool calledFromInit = false)
    {
        if (m_aActivationConditions.IsEmpty())
            return true;
 
        IEntity owner = GetOwner();
        bool conditionStatus = SCR_ScenarioFrameworkActivationConditionBase.EvaluateEmptyOrConditions(m_eActivationConditionLogic, m_aActivationConditions, owner);
        if (!conditionStatus && m_ParentLayer && calledFromInit)
            m_ParentLayer.CheckAllChildrenSpawned(this);
 
        return conditionStatus;
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitArea(SCR_ScenarioFrameworkArea area)
    {
        if (area)
        {
            m_Area = area;
            return true;
        }
 
        m_Area = GetParentArea();
        if (!m_Area)
        {
            if (m_ParentLayer)
                m_ParentLayer.CheckAllChildrenSpawned(this);
 
            return false;
        }
 
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitFactionSettings()
    {
        if (SCR_StringHelper.IsEmptyOrWhiteSpace(m_sFactionKey))
        {
            // Try Inherit
            if (!m_ParentLayer)
                return true;
 
            FactionKey parentFactionKey = m_ParentLayer.GetFactionKey();
            if (!SCR_StringHelper.IsEmptyOrWhiteSpace(parentFactionKey))
                SetFactionKey(parentFactionKey);
            return true;
        }
 
        // Resolve Alias
        SCR_FactionAliasComponent factionAliasComponent = SCR_FactionAliasComponent.Cast(GetGame().GetFactionManager().FindComponent(SCR_FactionAliasComponent));
        if (factionAliasComponent)
            SetFactionKey(factionAliasComponent.ResolveFactionAlias(GetFactionKey()));
        // Its not a mistake if the mission creator didn't define SCR_FactionAliasComponent. It just means that alias resolution is not needed.
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    bool InitOtherThings()
    {
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    void FinishInitChildrenInsert()
    {
        GetOnAllChildrenSpawned().Insert(AfterAllChildrenSpawned);
    }
 
    //------------------------------------------------------------------------------------------------
    void FinishInit()
    {
        FinishInitChildrenInsert();
        GetChildren(m_aChildren);
        SpawnChildren();
    }
 
    //------------------------------------------------------------------------------------------------
    void Init(SCR_ScenarioFrameworkArea area = null, SCR_ScenarioFrameworkEActivationType activation = SCR_ScenarioFrameworkEActivationType.SAME_AS_PARENT)
    {
        if (InitAlreadyHappened())
            return;
 
        if (!InitParentLayer())
            return;
 
        if (!InitFactionSettings())
            return;
 
        if (!InitNotTerminated())
            return;
 
        if (!InitDynDespawnAndActivation(activation))
            return;
 
        if (!InitActivationConditions(true))
            return;
 
        if (!InitArea(area))
            return;
 
        if (!InitOtherThings())
            return;
 
        FinishInit();
    }
 
    //------------------------------------------------------------------------------------------------
    void AfterAllChildrenSpawned(SCR_ScenarioFrameworkLayerBase layer)
    {
        m_bInitiated = true;
 
        ActivateLogic();
        foreach (SCR_ScenarioFrameworkPlugin plugin : m_aPlugins)
        {
            plugin.Init(this);
        }
 
        InitActivationActions();
 
        if (m_ParentLayer)
            m_ParentLayer.CheckAllChildrenSpawned(this);
 
        GetOnAllChildrenSpawned().Remove(AfterAllChildrenSpawned);
 
        if (m_fRepeatedSpawnTimer >= 0)
            RepeatedSpawn();
    }
 
    //------------------------------------------------------------------------------------------------
    override void EOnFrame(IEntity owner, float timeSlice)
    {
        super.EOnFrame(owner, timeSlice);
 
        if (m_bShowDebugShapesDuringRuntime)
            DrawDebugShape(true);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnPostInit(IEntity owner)
    {
        super.OnPostInit(owner);
        if (m_bShowDebugShapesDuringRuntime || m_fRepeatedSpawnTimer >= 0)
        {
            //TODO: deactivate once the slots are not needed (after entity was spawned)
            SetEventMask(owner, EntityEvent.INIT | EntityEvent.FRAME);
 
            if (SCR_Global.IsEditMode())
                return;
 
            BaseGameMode gameMode = GetGame().GetGameMode();
            if (!gameMode)
                return;
 
            SCR_ScenarioFrameworkSystem scenarioFrameworkSystem = SCR_ScenarioFrameworkSystem.GetInstance();
            if (!scenarioFrameworkSystem)
                return;
 
            scenarioFrameworkSystem.ManageLayerDebugShape(GetOwner().GetID(), m_bShowDebugShapesDuringRuntime, m_fDebugShapeRadius, true);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void SetDebugShapeSize(float fSize)
    {
        m_fDebugShapeRadius = fSize;
    }
 
    //------------------------------------------------------------------------------------------------
    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
        );
    }
 
    //------------------------------------------------------------------------------------------------
    protected void InitActivationActions()
    {
        const IEntity owner = GetOwner();
 
        foreach (SCR_ScenarioFrameworkActionBase activationAction : m_aActivationActions)
        {
            activationAction.Init(owner);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected void RestoreActionsToDefault()
    {
        foreach (SCR_ScenarioFrameworkActionBase activationAction : m_aActivationActions)
        {
            activationAction.RestoreToDefault();
        }
    }
    
    //------------------------------------------------------------------------------------------------
    array<ref SCR_ScenarioFrameworkActionBase> GetActivationActions()
    {
        return m_aActivationActions;
    }
 
#ifdef WORKBENCH
 
    //------------------------------------------------------------------------------------------------
    override int _WB_GetAfterWorldUpdateSpecs(IEntity owner, IEntitySource src)
    {
        return EEntityFrameUpdateSpecs.CALL_WHEN_ENTITY_VISIBLE;
    }
 
    //------------------------------------------------------------------------------------------------
    override void _WB_AfterWorldUpdate(IEntity owner, float timeSlice)
    {
        DrawDebugShape(m_bShowDebugShapesInWorkbench);
    }
 
    //------------------------------------------------------------------------------------------------
    override void _WB_OnCreate(IEntity owner, IEntitySource src)
    {
        RenameOwnerEntity(owner);
 
        IEntity child = GetOwner().GetChildren();
        while (child)
        {
            RenameOwnerEntity(child);
            child = child.GetSibling();
        }
    }
    
    //------------------------------------------------------------------------------------------------
    override bool _WB_OnKeyChanged(IEntity owner, BaseContainer src, string key, BaseContainerList ownerContainers, IEntity parent)
    {
        if (key == "m_bShowDebugShapesInWorkbench")
            DrawDebugShape(m_bShowDebugShapesInWorkbench);
 
        return false;
    }
 
    //------------------------------------------------------------------------------------------------
    void RenameOwnerEntity(IEntity owner)
    {
        GenericEntity genericEntity = GenericEntity.Cast(owner);
 
        WorldEditorAPI api = genericEntity._WB_GetEditorAPI();
        if (!api.UndoOrRedoIsRestoring())
            api.RenameEntity(api.EntityToSource(owner), api.GenerateDefaultEntityName(api.EntityToSource(owner)));
    }
#endif
 
    //------------------------------------------------------------------------------------------------
    // constructor
    void SCR_ScenarioFrameworkLayerBase(IEntityComponentSource src, IEntity ent, IEntity parent)
    {
        if (m_bDynamicDespawn)
            m_fDebugShapeRadius = m_iDynamicDespawnRange;
        
        m_iDebugShapeColor = ARGB(32, 255, 255, 255);
#ifdef WORKBENCH
        foreach (SCR_ScenarioFrameworkPlugin plugin : m_aPlugins)
        {
            plugin.OnWBKeyChanged(this);
        }
#endif
    }
 
    //------------------------------------------------------------------------------------------------
    void ~SCR_ScenarioFrameworkLayerBase()
    {
        if (SCR_Global.IsEditMode())
            return;
 
        DynamicDespawn(this);
    }
}