SCR_ScenarioFrameworkSlotTrigger.c

Go to the documentation of this file.

[EntityEditorProps(category: "GameScripted/ScenarioFramework/Slot", description: "")]
class SCR_ScenarioFrameworkSlotTriggerClass : SCR_ScenarioFrameworkSlotBaseClass
{
}
 
class SCR_ScenarioFrameworkSlotTrigger : SCR_ScenarioFrameworkSlotBase
{
    [Attribute(desc: "Actions that will be performed after trigger conditions are true and the trigger itself activates (not the slot itself)", category: "OnActivation")];
    protected ref array<ref SCR_ScenarioFrameworkActionBase>    m_aTriggerActions;
    
    //------------------------------------------------------------------------------------------------
    override void RestoreToDefault(bool includeChildren = false, bool reinitAfterRestoration = false)
    {
        foreach (SCR_ScenarioFrameworkActionBase activationAction : m_aTriggerActions)
        {
            activationAction.m_iNumberOfActivations = 0;
        }
        
        super.RestoreToDefault(includeChildren, reinitAfterRestoration);
    }
    
    //------------------------------------------------------------------------------------------------
    override void Init(SCR_ScenarioFrameworkArea area = null, SCR_ScenarioFrameworkEActivationType activation = SCR_ScenarioFrameworkEActivationType.SAME_AS_PARENT)
    {
        if (m_bIsTerminated)
        {
            if (m_ParentLayer)
                m_ParentLayer.CheckAllChildrenSpawned(this);
            
            return;
        }
        
        if (!m_ParentLayer)
        {
            IEntity entity = GetOwner().GetParent();
            if (!entity)
                return;
            
            m_ParentLayer = SCR_ScenarioFrameworkLayerBase.Cast(entity.FindComponent(SCR_ScenarioFrameworkLayerBase));
        }
    
        if (!m_bDynamicallyDespawned && activation != m_eActivationType)
        {
            if (m_ParentLayer)
                m_ParentLayer.CheckAllChildrenSpawned(this);
        }
        
        foreach (SCR_ScenarioFrameworkActivationConditionBase activationCondition : m_aActivationConditions)
        {
            //If just one condition is false, we don't continue and interrupt the init
            if (!activationCondition.Init(GetOwner()))
            {
                if (m_ParentLayer)
                    m_ParentLayer.CheckAllChildrenSpawned(this);
 
                return;
            }
        }
 
        if (m_Entity && !m_bEnableRepeatedSpawn)
        {
            IEntity entity = GetOwner().GetParent();
            if (!entity)
                return;
                
            SCR_ScenarioFrameworkLayerBase layerBase = SCR_ScenarioFrameworkLayerBase.Cast(entity.FindComponent(SCR_ScenarioFrameworkLayerBase));
            if (!layerBase)
                return;
                
            if (!layerBase.GetEnableRepeatedSpawn())
            {
                Print(string.Format("ScenarioFramework: Object %1 already exists and won't be spawned for %2, exiting...", m_Entity, GetOwner().GetName()), LogLevel.ERROR);
                return;
            }
        }
        
        // Handles inheritance of faction settings from parents
        if (m_sFactionKey.IsEmpty() && m_ParentLayer && !m_ParentLayer.GetFactionKey().IsEmpty())
            SetFactionKey(m_ParentLayer.GetFactionKey());
        
        if (!m_bUseExistingWorldAsset)
        {
            m_Entity = SpawnAsset();
        }
        else
        {
            QueryObjectsInRange();  //sets the m_Entity in subsequent callback
        }
        
        GetOnAllChildrenSpawned().Insert(AfterAllChildrenSpawned);
        
        if (m_Entity)
        {
            BaseGameTriggerEntity trigger = BaseGameTriggerEntity.Cast(m_Entity);
            if (trigger)
                trigger.EnablePeriodicQueries(false);
        }
        else
        {
            InvokeAllChildrenSpawned();
            return;
        }
        
        if (!m_sID.IsEmpty())
            m_Entity.SetName(m_sID);    
        
        SCR_DamageManagerComponent objectDmgManager = SCR_DamageManagerComponent.GetDamageManager(m_Entity);
        if (objectDmgManager)
            objectDmgManager.GetOnDamageStateChanged().Insert(OnObjectDamage);
        
        if (Vehicle.Cast(m_Entity))
        {
            EventHandlerManagerComponent ehManager = EventHandlerManagerComponent.Cast(m_Entity.FindComponent(EventHandlerManagerComponent));
            if (ehManager)
                ehManager.RegisterScriptHandler("OnCompartmentEntered", this, OnCompartmentEntered, true);
        }
        
        if (!area)
        {
            SCR_GameModeSFManager gameModeComp = SCR_GameModeSFManager.Cast(GetGame().GetGameMode().FindComponent(SCR_GameModeSFManager));
            if (gameModeComp)
                area = gameModeComp.GetParentArea(GetOwner());
        }
        m_Area = area;
        
        InvokeAllChildrenSpawned();
    }
    
    //------------------------------------------------------------------------------------------------
    override void AfterAllChildrenSpawned(SCR_ScenarioFrameworkLayerBase layer)
    {
        m_bInitiated = true;
        
        if (m_ParentLayer)
            m_ParentLayer.CheckAllChildrenSpawned(this);
        
        if (!m_Area)
            m_Area = GetParentArea();
        
        if (m_Area)
        {
            m_Area.GetOnAllChildrenSpawned().Insert(AfterParentAreaChildrenSpawned);
            m_Area.CheckAllChildrenSpawned(this);
        }
 
        GetOnAllChildrenSpawned().Remove(AfterAllChildrenSpawned);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void AfterParentAreaChildrenSpawned(SCR_ScenarioFrameworkLayerBase layer)
    {
        foreach (SCR_ScenarioFrameworkPlugin plugin : m_aPlugins)
        {
            plugin.Init(this);
        }
        
        foreach (SCR_ScenarioFrameworkActionBase activationAction : m_aActivationActions)
        {
            activationAction.Init(GetOwner());
        }
        
        foreach (SCR_ScenarioFrameworkActionBase triggerAction : m_aTriggerActions)
        {
            triggerAction.Init(m_Entity);
        }
 
        if (m_fRepeatedSpawnTimer >= 0)
            RepeatedSpawn();
        
        if (m_Area)
            m_Area.GetOnAllChildrenSpawned().Remove(AfterParentAreaChildrenSpawned);
        
        if (m_Entity)
        {
            BaseGameTriggerEntity trigger = BaseGameTriggerEntity.Cast(m_Entity);
            if (trigger)
                trigger.EnablePeriodicQueries(true);
        }
    }
}