SCR_TaskSolverManagerComponent.c

Go to the documentation of this file.

[ComponentEditorProps(category: "GameScripted/Misc", description: "")]
class SCR_TaskSolverManagerComponentClass : SCR_BaseGameModeComponentClass
{
}
 
class SCR_TaskSolverManagerComponent : SCR_BaseGameModeComponent
{
    [Attribute()]
    protected ref SCR_TaskSolverConfig m_TaskSolverConfig;
 
    protected ref array<ref SCR_TaskSolverBase> m_aActiveSolvers = {};
 
    protected RplComponent m_RplComponent;
 
    static protected int s_iMaxSolverId = -1;
 
    //------------------------------------------------------------------------------------------------
    SCR_TaskSolverBase CreateSolver(typename solverType)
    {
        if (!solverType)
            return null;
 
        SCR_TaskSolverBase solver = SCR_TaskSolverBase.Cast(solverType.Spawn());
        if (!solver)
            return null;
 
        s_iMaxSolverId++;
        solver.SetId(s_iMaxSolverId);
 
        SetSolverEntry(solver);
 
        m_aActiveSolvers.Insert(solver);
 
        if (IsMaster())
        {
            SCR_ResupplyTaskSolver resupplyTaskSolver = SCR_ResupplyTaskSolver.Cast(solver);
            if (resupplyTaskSolver)
                resupplyTaskSolver.GetOnResupplyTaskSolverStateChanged().Insert(OnResupplyTaskSolverStateChanged);
        }
 
        return solver;
    }
 
    //------------------------------------------------------------------------------------------------
    void StartSolverTask(SCR_TaskSolverBase solver, SCR_Task task, SCR_TaskSolverContext context)
    {
        int index = m_aActiveSolvers.Find(solver);
        if (!m_aActiveSolvers.IsIndexValid(index))
            return;
 
        solver.Init(task, context);
        solver.StartTaskSolving();
    }
 
    //------------------------------------------------------------------------------------------------
    void RemoveSolver(notnull SCR_TaskSolverBase solver)
    {
        int idx = m_aActiveSolvers.Find(solver);
        if (idx != -1)
        {
            solver.Deinit();
            m_aActiveSolvers.Remove(idx);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_TaskSolverEntry GetTaskSolverEntry(typename type)
    {
        if (!m_TaskSolverConfig)
            return null;
 
        return m_TaskSolverConfig.GetTaskSolverEntry(type);
    }
 
    //------------------------------------------------------------------------------------------------
    void Update(float timeSlice)
    {
        foreach (SCR_TaskSolverBase solver : m_aActiveSolvers)
        {
            solver.Update(timeSlice);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    protected bool IsMaster()
    {
        return !m_RplComponent || m_RplComponent.IsMaster();
    }
 
    //------------------------------------------------------------------------------------------------
    protected void OnResupplyTaskSolverStateChanged(int solverId, SCR_EResupplyTaskSolverState resupplyTaskSolverState)
    {
        Rpc(RpcDo_SetResupplyTaskSolverState, solverId, resupplyTaskSolverState);
    }
 
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void RpcDo_SetResupplyTaskSolverState(int solverId, SCR_EResupplyTaskSolverState resupplyTaskSolverState)
    {
        SCR_ResupplyTaskSolver resupplyTaskSolver = SCR_ResupplyTaskSolver.Cast(Find(solverId));
        if (!resupplyTaskSolver)
            return;
 
        resupplyTaskSolver.SetResupplyTaskSolverState(resupplyTaskSolverState);
    }
 
    //------------------------------------------------------------------------------------------------
    protected SCR_TaskSolverBase Find(int solverId)
    {
        foreach (SCR_TaskSolverBase solver : m_aActiveSolvers)
        {
            if (solver.GetId() == solverId)
                return solver;
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    protected SCR_TaskSolverBase Find(notnull SCR_Task task)
    {
        foreach (SCR_TaskSolverBase solver : m_aActiveSolvers)
        {
            if (solver.GetTask() == task)
                return solver;
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void SetSolverEntry(SCR_TaskSolverBase solver)
    {
        if (!m_TaskSolverConfig || !solver)
            return;
 
        SCR_ResupplyTaskSolver resupplySolver = SCR_ResupplyTaskSolver.Cast(solver);
        if (resupplySolver)
        {
            SCR_ResupplyTaskSolverEntry entry = SCR_ResupplyTaskSolverEntry.Cast(
                m_TaskSolverConfig.GetTaskSolverEntry(SCR_ResupplyTaskSolverEntry)
            );
 
            if (entry)
                resupplySolver.SetResupplyTaskSolverEntry(entry);
        }
 
        // Extend as needed for other types.
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void OnPostInit(IEntity owner)
    {
        s_iMaxSolverId = -1;
 
        m_RplComponent = RplComponent.Cast(owner.FindComponent(RplComponent));
    }
 
    //------------------------------------------------------------------------------------------------
    override protected void OnDelete(IEntity owner)
    {
        SCR_ResupplyTaskSolver resupplyTaskSolver;
        foreach (SCR_TaskSolverBase solver : m_aActiveSolvers)
        {
            solver.Deinit();
 
            if (IsMaster())
            {
                resupplyTaskSolver = SCR_ResupplyTaskSolver.Cast(solver);
                if (resupplyTaskSolver)
                    resupplyTaskSolver.GetOnResupplyTaskSolverStateChanged().Remove(OnResupplyTaskSolverStateChanged);
            }
        }
 
        m_aActiveSolvers.Clear();
        super.OnDelete(owner);
    }
}