SCR_ScenarioFrameworkLogic.c

Go to the documentation of this file.

[BaseContainerProps()]
class SCR_ScenarioFrameworkLogicInput
{
    [Attribute(desc: "Input connector", category: "Input")]
    ref SCR_ScenarioFrameworkActionInputBase m_InputAction;
    
    SCR_ScenarioFrameworkLogic m_MasterLogic;
    
    //------------------------------------------------------------------------------------------------
    void Init(SCR_ScenarioFrameworkLogic logic)
    {
        m_MasterLogic = logic;
        if (m_InputAction)
            m_InputAction.Init(this);
    }
    
    //------------------------------------------------------------------------------------------------
    void OnActivate(bool bSignal, IEntity entity)
    {
        if (m_MasterLogic)
            m_MasterLogic.OnInput(bSignal, entity);
    }
}
 
class SCR_ScenarioFrameworkLogicClass : GenericEntityClass
{
}
 
class SCR_ScenarioFrameworkLogic : GenericEntity
{
    [Attribute(desc: "If set to true, when this Logic gets activated, it will break the breakpoint in the Script Editor in respective methods. This can be also set during runtime via Debug Menu > ScenarioFramework > Logic Inspector")]
    bool m_bDebug;
    
    [Attribute(desc: "What causes the increase", category: "Input")]
    ref array<ref SCR_ScenarioFrameworkLogicInput> m_aInputs;
        
    [Attribute(desc: "What to do once counter is reached", category: "OnActivate")]
    ref array<ref SCR_ScenarioFrameworkActionBase>  m_aActions;
    
    bool m_bIsTerminated; //Marks if this was terminated - either by death or deletion
    
    //------------------------------------------------------------------------------------------------
    void Init()
    {
        if (m_bIsTerminated)
            return;
        
        foreach (SCR_ScenarioFrameworkLogicInput input : m_aInputs)
        {
            input.Init(this);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void SetIsTerminated(bool state)
    {
        m_bIsTerminated = state;
    }
    
    //------------------------------------------------------------------------------------------------
    bool GetIsTerminated()
    {
        return m_bIsTerminated;
    }
    
    //------------------------------------------------------------------------------------------------
    void OnInput(bool pSignal = true, IEntity entity = null);
    
    //------------------------------------------------------------------------------------------------
    void OnActivate(IEntity entity)
    {
        // Here you can debug specific Logic instance.
        // This can be also adjusted during runtime via Debug Menu > ScenarioFramework > Logic Inspector
        if (m_bDebug)
            Print("[SCR_ScenarioFrameworkLogic.OnActivate] debug line (" + __FILE__ + " L" + __LINE__ + ")", LogLevel.WARNING);
        
        foreach (SCR_ScenarioFrameworkActionBase action : m_aActions)
            action.OnActivate(entity);
    }
    
    //------------------------------------------------------------------------------------------------
    void RestoreToDefault()
    {
        foreach (SCR_ScenarioFrameworkActionBase action : m_aActions)
        {
            action.RestoreToDefault();
        }
    }
    
#ifdef WORKBENCH    
    //------------------------------------------------------------------------------------------------
    override void _WB_OnCreate(IEntitySource src)
    {
        WorldEditorAPI api = _WB_GetEditorAPI();
        IEntitySource thisSrc = api.EntityToSource(this);
        api.RenameEntity(thisSrc, api.GenerateDefaultEntityName(thisSrc));
    }
#endif
}
 
class SCR_ScenarioFrameworkLogicCounterClass : SCR_ScenarioFrameworkLogicClass
{
}
 
class SCR_ScenarioFrameworkLogicCounter : SCR_ScenarioFrameworkLogic
{   
    [Attribute(defvalue: "1", desc: "Threshold", UIWidgets.Graph, category: "Counter")]
    int m_iCountTo;
    
    [Attribute(desc: "What to do once value is increased", category: "OnIncrease")]
    ref array<ref SCR_ScenarioFrameworkActionBase>  m_aOnIncreaseActions;
    
    [Attribute(desc: "What to do once value is decreased", category: "OnDecrease")]
    ref array<ref SCR_ScenarioFrameworkActionBase>  m_aOnDecreaseActions;
            
    int m_iCnt = 0;
    
    //------------------------------------------------------------------------------------------------
    override void OnInput(bool pSignal = true, IEntity entity = null)
    {
        if (entity)
            Increase(entity);
        else
            Increase(this);
    }
    
    //------------------------------------------------------------------------------------------------
    int GetCounterValue()
    {
        return m_iCnt;
    }
    
    //------------------------------------------------------------------------------------------------
    void SetCounterValue(int value)
    {
        m_iCnt = value;
    }
    
    //------------------------------------------------------------------------------------------------
    void Increase(IEntity entity)
    {
        // Here you can debug specific Logic instance.
        // This can be also adjusted during runtime via Debug Menu > ScenarioFramework > Logic Inspector
        if (m_bDebug)
            Print("[SCR_ScenarioFrameworkLogicCounter.Increase] debug line (" + __FILE__ + " L" + __LINE__ + ")", LogLevel.WARNING);
        
        m_iCnt++;
        if (m_iCnt == m_iCountTo)
        {
            OnActivate(entity);
        }
        
        foreach (SCR_ScenarioFrameworkActionBase increaseAction : m_aOnIncreaseActions)
        {
            increaseAction.OnActivate(entity);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void Decrease(IEntity entity)
    {
        // Here you can debug specific Logic instance.
        // This can be also adjusted during runtime via Debug Menu > ScenarioFramework > Logic Inspector
        if (m_bDebug)
            Print("[SCR_ScenarioFrameworkLogicCounter.Decrease] debug line (" + __FILE__ + " L" + __LINE__ + ")", LogLevel.WARNING);
        
        m_iCnt--;
        if (m_iCnt == m_iCountTo)
        {
            OnActivate(entity);
        }
        
        foreach (SCR_ScenarioFrameworkActionBase decreaseAction : m_aOnDecreaseActions)
        {
            decreaseAction.OnActivate(entity);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void Reset()
    {
        m_iCnt = 0;
    }
    
    //------------------------------------------------------------------------------------------------
    override void RestoreToDefault()
    {
        super.RestoreToDefault();
        
        Reset();
        
        foreach (SCR_ScenarioFrameworkActionBase action : m_aOnIncreaseActions)
        {
            action.RestoreToDefault();
        }
        
        foreach (SCR_ScenarioFrameworkActionBase action : m_aOnDecreaseActions)
        {
            action.RestoreToDefault();
        }
    }
}
 
//---- REFACTOR NOTE START: This code will need to be refactored as current implementation is not conforming to the standards ----
class SCR_ScenarioFrameworkLogicORClass : SCR_ScenarioFrameworkLogicClass
{
}
 
class SCR_ScenarioFrameworkLogicOR : SCR_ScenarioFrameworkLogic
{
    int  m_iActivations = 0;
    
    //------------------------------------------------------------------------------------------------
    override void OnInput(bool pSignal = true, IEntity entity = null)
    {
        if (pSignal)
            m_iActivations = Math.Min(++m_iActivations, m_aInputs.Count());
        else
            m_iActivations--;
    }   
}
 
class SCR_ScenarioFrameworkLogicSwitchClass : SCR_ScenarioFrameworkLogicClass
{
}
 
class SCR_ScenarioFrameworkLogicSwitch : SCR_ScenarioFrameworkLogic
{
}
//---- REFACTOR NOTE END ----