SCR_BaseTaskManager.c

Go to the documentation of this file.

[EntityEditorProps(category: "GameScripted/Tasks", description: "Entity that takes care of managing tasks.", color: "0 0 255 255")]
class SCR_BaseTaskManagerClass: GenericEntityClass
{
};
 
SCR_BaseTaskManager g_TaskManagerInstance;
SCR_BaseTaskManager GetTaskManager()
{
    return g_TaskManagerInstance;
};
 
//------------------------------------------------------------------------------------------------
enum SCR_ETaskEventMask
{
    TASK_CREATED = 1,
    TASK_CANCELED = 2,
    TASK_PROPERTY_CHANGED = 4,
    TASK_ASSIGNEE_CHANGED = 8,
    TASK_FINISHED = 16,
    TASK_FAILED = 32,
    TASK_REMOVED = 64,
};
 
//------------------------------------------------------------------------------------------------
class SCR_BaseTaskManager : GenericEntity
{
 
#ifdef ENABLE_DIAG
    protected bool m_bPrintedTasks = false;
#endif
    static const float DEFAULT_ABANDON_WAITING_TIME = 15;
    
    //**************************//
    //PROTECTED MEMBER VARIABLES//
    //**************************//
    protected ref array<SCR_BaseTaskSupportEntity> m_aSupportedTaskTypes = {};
    
    [RplProp()]
    protected float m_fTimestamp = 0;
    protected float m_fTimestampTimer = 0;
    protected ref array<SCR_BaseTask> m_aTaskList = new array<SCR_BaseTask>();
    protected ref array<SCR_BaseTask> m_aFinishedTaskList = {};
    protected ref array<ref SCR_TaskAssignmentData> m_aCachedTaskAssignments = new array<ref SCR_TaskAssignmentData>();
    
    [Attribute("1")]
    protected float m_fAssigneeCacheTimer;
    
    [Attribute("#AR-Tasks_TitleLocalRequest-UC")]
    string m_sLocalRequestTitle;
    
    [Attribute("#AR-Tasks_ReassignPopup")]
    string m_sReassignPopup;
    
    [Attribute("#AR-Tasks_AssignPopupGM")]
    string m_sAssignPopupGM;
    
    protected float m_fAssigneeCacheCheckTimestamp;
    protected ref map<SCR_BaseTaskExecutor, float> m_mAssigneesAbandoned = new map<SCR_BaseTaskExecutor, float>();
    
    protected bool m_bInitialized = false;
    
    protected RplComponent m_RplComponent;
    
    ref map<SCR_BaseTask, SCR_ETaskEventMask> m_mTaskEventMaskMap = new map<SCR_BaseTask, SCR_ETaskEventMask>();
    
    protected ref array<SCR_BaseTask> m_aTasksToDelete = {};
    
    //*****************************//
    //PUBLIC STATIC SCRIPT INVOKERS//
    //*****************************//
    
    static ref ScriptInvoker s_OnTaskUpdate = new ScriptInvoker();
    static ref ScriptInvoker s_OnTaskFinished = new ScriptInvoker();
    static ref ScriptInvoker s_OnTaskFailed = new ScriptInvoker();
    static ref ScriptInvoker s_OnTaskRemoved = new ScriptInvoker();
    static ref ScriptInvoker s_OnTaskCancelled = new ScriptInvoker();
    
    static ref ScriptInvoker s_OnTaskAssigned = new ScriptInvoker();
    static ref ScriptInvoker s_OnTaskUnassigned = new ScriptInvoker();
    
    static ref ScriptInvoker s_OnTaskFactionAssigned = new ScriptInvoker();
    
    static ref ScriptInvoker s_OnTaskCreated = new ScriptInvoker();
    static ref ScriptInvoker s_OnTaskDeleted = new ScriptInvoker();
    
    static ref ScriptInvoker s_OnPeriodicalCheck2Second = new ScriptInvoker();
    static ref ScriptInvoker s_OnPeriodicalCheck5Second = new ScriptInvoker();
    static ref ScriptInvoker s_OnPeriodicalCheck60Second = new ScriptInvoker();
    
    //***************************//
    //PUBLIC EVENT MEMBER METHODS//
    //***************************//
    
    //------------------------------------------------------------------------------------------------
    void OnPlayerDisconnected(int id)
    {
#ifdef ENABLE_DIAG
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_EXECUTE_TASKS))
            return;
#endif
        
        SCR_BaseTaskExecutor executor = SCR_BaseTaskExecutor.GetTaskExecutorByID(id);
        SCR_BaseTask task = null;
        if (executor)
            task = executor.GetAssignedTask();
        
        SCR_BaseTaskSupportEntity supportEntity = SCR_BaseTaskSupportEntity.Cast(FindSupportEntity(SCR_BaseTaskSupportEntity));
        if (!supportEntity)
            return;
        
        if (task)
            supportEntity.UnassignTask(task, executor, SCR_EUnassignReason.ASSIGNEE_DISCONNECT);
        
        task = FindRequestedTask(executor);
        
        if (!task)
            return;
        
        supportEntity.CancelTask(task.GetTaskID());
    }
    
    //------------------------------------------------------------------------------------------------
    void OnTaskDeleted(SCR_BaseTask task)
    {
        if (m_aTaskList.Contains(task))
            m_aTaskList.RemoveItem(task);
    }
    
    //------------------------------------------------------------------------------------------------
    void OnTaskCreated(SCR_BaseTask task)
    {
        s_OnTaskFactionAssigned.Insert(RefreshTaskList);
        
        SCR_EditorTask editorTask = SCR_EditorTask.Cast(task);
        if (!editorTask)
            return;
        
        SCR_EditableDescriptorComponent editableDescriptor = SCR_EditableDescriptorComponent.Cast(editorTask.FindComponent(SCR_EditableDescriptorComponent));
        if (!editableDescriptor)
            return;
        
        editableDescriptor.GetOnChange().Insert(RefreshTaskListCommentComponent);
        editableDescriptor.GetOnUIRefresh().Insert(RefreshTaskListVoid);
    }
    
    //------------------------------------------------------------------------------------------------
    private void RefreshTaskListCommentComponent(SCR_EditableCommentComponent editableCommentComponent)
    {
        RefreshTaskList();
    }
    
    //------------------------------------------------------------------------------------------------
    private void RefreshTaskListVoid()
    {
        RefreshTaskList();
    }
    
    //------------------------------------------------------------------------------------------------
    void RefreshTaskList(SCR_BaseTask task = null)
    {
        s_OnTaskFactionAssigned.Remove(RefreshTaskList);
        
        SCR_UITaskManagerComponent UItaskManager = SCR_UITaskManagerComponent.GetInstance();
        if (!UItaskManager || !UItaskManager.IsTaskListOpen())
            return;
        
        if (task)
        {
            SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
            if (!factionManager)
                return;
 
            Faction taskTargetFaction = task.GetTargetFaction();
            Faction playerFaction = factionManager.GetLocalPlayerFaction(); 
            if (taskTargetFaction != playerFaction)
                return;
        }
            
        SCR_MapEntity mapEntity = SCR_MapEntity.GetMapInstance();
        if (!mapEntity)
            return;
        
        SCR_MapTaskListUI taskListUI = SCR_MapTaskListUI.Cast(mapEntity.GetMapUIComponent(SCR_MapTaskListUI));
        if (taskListUI)
            taskListUI.RefreshTaskList();
    }
    
    //------------------------------------------------------------------------------------------------
    void OnTaskFinished(SCR_BaseTask task)
    {
        if (!m_aFinishedTaskList.Contains(task))
            m_aFinishedTaskList.Insert(task);
        
        OnTaskDeleted(task);
    }
    
    //------------------------------------------------------------------------------------------------
    void OnTaskUpdate(SCR_BaseTask task, SCR_ETaskEventMask mask)
    {
        if (m_mTaskEventMaskMap.Contains(task))
        {
            SCR_ETaskEventMask tempMask;
            tempMask = m_mTaskEventMaskMap.Get(task); // returns mask for the task
            tempMask = tempMask | mask;
            m_mTaskEventMaskMap.Set(task, tempMask);
        }
        else
        {
            m_mTaskEventMaskMap.Insert(task, mask);
        }
    }
    
    //************************//
    //PROTECTED MEMBER METHODS//
    //************************//
    
    //------------------------------------------------------------------------------------------------
    protected void PeriodicalCheck2Second()
    {
        s_OnPeriodicalCheck2Second.Invoke();
    }
    
    //------------------------------------------------------------------------------------------------
    protected void PeriodicalCheck5Second()
    {
        s_OnPeriodicalCheck5Second.Invoke();
    }
    
    //------------------------------------------------------------------------------------------------
    protected void PeriodicalCheck60Second()
    {
        s_OnPeriodicalCheck60Second.Invoke();
    }
    
    //------------------------------------------------------------------------------------------------
    protected SCR_EvacuateTask CreateNewEvacuationTask(int requesterID)
    {
        SCR_BaseTaskSupportEntity supportClass = GetTaskManager().FindSupportEntity(SCR_EvacuateTaskSupportEntity);
        if (!supportClass)
            return null;
        
        SCR_EvacuateTask evacuateTask = SCR_EvacuateTask.Cast(GetGame().SpawnEntityPrefab(supportClass.GetTaskPrefab(), GetWorld()));
        if (!evacuateTask)
            return null;
        
        SCR_BaseTaskExecutor requester = SCR_BaseTaskExecutor.GetTaskExecutorByID(requesterID);
        
        evacuateTask.SetRequester(requester);
        
        return evacuateTask;
    }
    
    //------------------------------------------------------------------------------------------------
    protected void CheckAssigneeTimeout()
    {
        foreach (SCR_BaseTask task : m_aTaskList)
        {
            if (task && task.IsIndividual())
                task.CheckAssigneeTimeout();
        }
    }
    
    //*********************//
    //PUBLIC MEMBER METHODS//
    //*********************//
    
    //------------------------------------------------------------------------------------------------
    string GetReassignText()
    {
        return m_sReassignPopup;
    }
    
    //------------------------------------------------------------------------------------------------
    void AddAssigneeAbandoned(SCR_BaseTaskExecutor assignee)
    {
        if (m_mAssigneesAbandoned)
            m_mAssigneesAbandoned.Set(assignee, m_fTimestamp + DEFAULT_ABANDON_WAITING_TIME);
    }
    
    //------------------------------------------------------------------------------------------------
    bool IsProxy()
    {
        return (m_RplComponent && m_RplComponent.IsProxy());
    }
    
    //------------------------------------------------------------------------------------------------
    void UnregisterSupportEntity(SCR_BaseTaskSupportEntity supportEntity)
    {
        m_aSupportedTaskTypes.RemoveItem(supportEntity);
    }
    
    //------------------------------------------------------------------------------------------------
    void RegisterSupportEntity(SCR_BaseTaskSupportEntity supportEntity)
    {
        m_aSupportedTaskTypes.Insert(supportEntity);
        supportEntity.Initialize();
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_BaseTask GetTask(int taskID)
    {
        if (taskID == -1)
            return null;
        
        foreach (SCR_BaseTask task : m_aTaskList)
        {
            if (task.GetTaskID() == taskID)
            {
                return task;
            }
        }
        
        return null;
    }
    
    //------------------------------------------------------------------------------------------------
    void RegisterTask(SCR_BaseTask task)
    {
        if (task.GetTaskState() == SCR_TaskState.OPENED && !m_aTaskList.Contains(task))
            m_aTaskList.Insert(task);
            
        if (task.GetTaskState() == SCR_TaskState.FINISHED && !m_aFinishedTaskList.Contains(task))
        {
            m_aFinishedTaskList.Insert(task);
            m_aTaskList.RemoveItem(task);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_BaseTask GetFinishedTask(int taskID)
    {
        if (taskID == -1)
            return null;
        
        foreach (SCR_BaseTask task : m_aFinishedTaskList)
        {
            if (task.GetTaskID() == taskID)
            {
                return task;
            }
        }
        
        return null;
    }
    
    #ifdef ENABLE_DIAG
    //------------------------------------------------------------------------------------------------
    bool CheckMasterOnlyMethod(string methodName)
    {
        if (IsProxy())
        {
            Print("Master-only method (SCR_BaseTaskManager." + methodName + ") called on proxy, some functionality might be broken!", LogLevel.WARNING);
            return false;
        }
        
        return true;
    }
    #endif
    
    //------------------------------------------------------------------------------------------------
    bool HasRequestedTask(int playerID)
    {
        SCR_BaseTaskExecutor executor = SCR_BaseTaskExecutor.GetTaskExecutorByID(playerID);
        if (!executor)
            return true;
        
        return GetTaskManager().FindRequestedTask(executor) != null;
    }
    
    //------------------------------------------------------------------------------------------------
    bool Initialized()
    {
        return m_bInitialized;
    }
    
    //------------------------------------------------------------------------------------------------
    void DeleteTask(SCR_BaseTask task)
    {
        if (m_aTasksToDelete.Contains(task))
            return;
        
        m_aTasksToDelete.Insert(task);
        task.OnDelete();
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_BaseTaskSupportEntity FindSupportEntity(typename type)
    {
        if (!m_aSupportedTaskTypes)
            return null;
        
        for (int i = m_aSupportedTaskTypes.Count() - 1; i >= 0; i--)
        {
            if (type == m_aSupportedTaskTypes[i].Type())
                return m_aSupportedTaskTypes[i];
        }
        
        return null;
    }
    
    //------------------------------------------------------------------------------------------------
    //Returns the list of all supported task types
    //Used f.e. for request buttons in task list, which is temporarily disabled
    array<SCR_BaseTaskSupportEntity> GetSupportedTasks()
    {
        return m_aSupportedTaskTypes;
    }
    
    //------------------------------------------------------------------------------------------------
    notnull SCR_BaseTaskExecutor LocalCreateTaskExecutor(int playerID)
    {
        SCR_BaseTaskExecutor executor = SCR_BaseTaskExecutor.FindTaskExecutorByID(playerID);
        if (executor)
            return executor;
        
        executor = SCR_BaseTaskExecutor.Cast(GetGame().SpawnEntity(SCR_BaseTaskExecutor, GetGame().GetWorld()));
        executor.SetPlayerID(playerID);
        
        return executor;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_RequestedTask FindRequestedTask(SCR_BaseTaskExecutor requester)
    {
        for (int i = 0; i < m_aTaskList.Count(); i++)
        {
            SCR_RequestedTask requestedTask = SCR_RequestedTask.Cast(m_aTaskList[i]);
            if (!requestedTask)
                continue;
            
            SCR_BaseTaskExecutor taskRequester = requestedTask.GetRequester();
            if (requester == taskRequester)
                return requestedTask;
        }
        
        return null;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetFilteredTasks(notnull out array<SCR_BaseTask> tasks, Faction filterFaction = null)
    {
        int count = 0;
        tasks.Clear();
        
        if (!filterFaction)
            return GetTasks(tasks);
        
        Faction taskFaction;
        foreach (SCR_BaseTask task : m_aTaskList)
        {
            taskFaction = task.GetTargetFaction();
            if (!taskFaction || taskFaction == filterFaction)
            {
                tasks.Insert(task);
                count++;
            }
        }
        
        return count;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetFilteredFinishedTasks(notnull out array<SCR_BaseTask> tasks, Faction filterFaction = null)
    {
        int count = 0;
        tasks.Clear();
        
        if (!filterFaction)
            return GetTasks(tasks);
        
        Faction taskFaction;
        foreach (SCR_BaseTask task : m_aFinishedTaskList)
        {
            taskFaction = task.GetTargetFaction();
            if (!taskFaction || taskFaction == filterFaction)
            {
                tasks.Insert(task);
                count++;
            }
        }
        
        return count;
    }
    
    //------------------------------------------------------------------------------------------------
    bool GetAssigneeAbandoned(SCR_BaseTaskExecutor assignee)
    {
        if (!m_mAssigneesAbandoned || !assignee)
            return false;
        
        float timestamp = m_mAssigneesAbandoned.Get(assignee);
        
        if (m_fTimestamp < timestamp)
            return true;
        
        return false;
    }
    
    //------------------------------------------------------------------------------------------------
    //This should only be called on the server!
    void AbandonTask(int taskID, notnull SCR_BaseTaskExecutor assignee)
    {
        #ifdef ENABLE_DIAG
        if (!CheckMasterOnlyMethod("AbandonTask()"))
            return;
        #endif
        
        SCR_BaseTask task = GetTask(taskID);
        
        if (!task)
            return;
        
        if (task.NotifyUnassign())
            task.DoNotifyUnassign(SCR_BaseTaskExecutor.GetTaskExecutorID(assignee));
        
        SCR_BaseTaskSupportEntity supportEntity = SCR_BaseTaskSupportEntity.Cast(FindSupportEntity(SCR_BaseTaskSupportEntity));
        if (!supportEntity)
            return;
        
        supportEntity.UnassignTask(task, assignee, SCR_EUnassignReason.ASSIGNEE_ABANDON);
    }
    
    //------------------------------------------------------------------------------------------------
    void RequestAssignment(int taskID, notnull SCR_BaseTaskExecutor assignee)
    {
        if (!assignee || IsProxy())
            return;
        
        SCR_BaseTask task = GetTask(taskID);
        
        if (!task)
            return;
        
        if (task.NotifyAssignment())
            task.DoNotifyAssignment(SCR_BaseTaskExecutor.GetTaskExecutorID(assignee));
        
        SCR_BaseTaskSupportEntity supportEntity = SCR_BaseTaskSupportEntity.Cast(GetTaskManager().FindSupportEntity(SCR_BaseTaskSupportEntity));
        if (!supportEntity)
            return;
        
        supportEntity.AssignTask(task, assignee);
    }
    
    //------------------------------------------------------------------------------------------------
    void OnPlayerRegistered(int registeredPlayerID)
    {
        if (registeredPlayerID == SCR_PlayerController.GetLocalPlayerId())
            CreateTaskExecutors();
        else
            LocalCreateTaskExecutor(registeredPlayerID);
    }
    
    //------------------------------------------------------------------------------------------------
    void CreateTaskExecutors()
    {
        array<int> players = new array<int>();
        GetGame().GetPlayerManager().GetPlayers(players);
        
        foreach (int playerID : players)
        {
            if (SCR_BaseTaskExecutor.GetTaskExecutorByID(playerID))
                continue;
            
            LocalCreateTaskExecutor(playerID);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    float GetTimestamp()
    {
        return m_fTimestamp;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetTasks(notnull out array<SCR_BaseTask> tasks)
    {
        int count = 0;
        
        foreach (SCR_BaseTask task : m_aTaskList)
        {
            tasks.Insert(task);
            count++;
        }
        
        return count;
    }
    
    //------------------------------------------------------------------------------------------------
    int GetFinishedTasks(notnull out array<SCR_BaseTask> tasks)
    {
        int count = 0;
        
        foreach (SCR_BaseTask task : m_aFinishedTaskList)
        {
            tasks.Insert(task);
            count++;
        }
        
        return count;
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_BaseTask LocalSpawnTask(ResourceName resourceName)
    {
        if (resourceName.IsEmpty())
            return null;
        
        Resource resource = Resource.Load(resourceName);
        if (!resource.IsValid())
            return null;
        
        return SCR_BaseTask.Cast(GetGame().SpawnEntityPrefab(resource, GetWorld()));
    }
    
    //------------------------------------------------------------------------------------------------
    SCR_BaseTask SpawnTask(ResourceName resourceName)
    {
        SCR_BaseTask task = LocalSpawnTask(resourceName);
        if (!task)
            return null;
        
        Rpc(RPC_SpawnTask, resourceName, task.GetTaskID());
        
        return task;
    }
    
    //***********//
    //RPC METHODS//
    //***********//
    
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void RPC_SpawnTask(ResourceName resourceName, int taskID)
    {
        SCR_BaseTask task = LocalSpawnTask(resourceName);
        if (!task)
            return;
        
        task.SetTaskID(taskID);
    }
    
    //*************//
    //ENTITY EVENTS//
    //*************//
 
    //------------------------------------------------------------------------------------------------
    protected override void EOnInit(IEntity owner)
    {
        m_bInitialized = true;
        
        SCR_BaseGameMode gameMode = SCR_BaseGameMode.Cast(GetGame().GetGameMode());
        if (gameMode)
            gameMode.GetOnPlayerRegistered().Insert(OnPlayerRegistered);
        
        // If replicated make sure it never streams out
        auto rplComponent = RplComponent.Cast(FindComponent(RplComponent));
        if (rplComponent && rplComponent.IsSelfInserted())
        {
            auto ctx = new GameRplSchedulerInsertionCtx;
            ctx.CanBeStreamed = false;
            rplComponent.InsertToReplication(ctx);
        }
        
        m_RplComponent = RplComponent.Cast(FindComponent(RplComponent));
        
        // This is for individual tasks, so they don't have to tick their own timers, but it's centralized on the task manager.
        // This could be further improved for more custom timers, but for now it is sufficient as is.
        GetGame().GetCallqueue().CallLater(PeriodicalCheck2Second, 2000, true);
        GetGame().GetCallqueue().CallLater(PeriodicalCheck5Second, 5000, true);
        GetGame().GetCallqueue().CallLater(PeriodicalCheck60Second, 60000, true);
    }
    //------------------------------------------------------------------------------------------------
    void UpdateTasks()
    {
        SCR_BaseTask task;
        SCR_ETaskEventMask mask;
        
        for (int i = m_mTaskEventMaskMap.Count() - 1; i >= 0; i--)
        {
            task = m_mTaskEventMaskMap.GetKey(i);
            mask = m_mTaskEventMaskMap.Get(task);
            s_OnTaskUpdate.Invoke(task, mask);
        }
        
        m_mTaskEventMaskMap.Clear();
        
        foreach (SCR_BaseTask taskToDelete : m_aTasksToDelete)
        {
            if (!taskToDelete)
                continue;
            
            IEntity taskChild = taskToDelete.GetChildren();
            while (taskChild)
            {
                IEntity childToDelete = taskChild;
                taskChild = taskChild.GetSibling();
 
                delete childToDelete;
            }
            
            m_aTaskList.RemoveItem(taskToDelete);
            delete taskToDelete;
        }
        
        for (int i = m_aFinishedTaskList.Count() - 1; i >= 0; i--)
        {
            if (!m_aFinishedTaskList[i])
                m_aFinishedTaskList.Remove(i);
        }
        
        m_aTasksToDelete.Clear();
    }
    //------------------------------------------------------------------------------------------------
    protected override void EOnFrame(IEntity owner, float timeSlice)
    {
        if (GetTaskManager() && GetTaskManager() != this)
        {
            delete this;
            return;
        }
        
        if (!m_mTaskEventMaskMap.IsEmpty())
            UpdateTasks();
#ifdef ENABLE_DIAG
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_SHOW_ALL_TASKS))
        {
            if (!m_bPrintedTasks)
            {
                m_bPrintedTasks = true;
                for (int i = m_aTaskList.Count() - 1; i >= 0; i--)
                {
                    Print(m_aTaskList[i].GetDescription());
                }
            }
        }
        else
            m_bPrintedTasks = false;
        
        if (DiagMenu.GetBool(SCR_DebugMenuID.DEBUGUI_EXECUTE_TASKS))
            return;
#endif
        
        m_fTimestamp += timeSlice;
        m_fTimestampTimer -= timeSlice;
        if (m_fTimestampTimer <= 0)
        {
            Replication.BumpMe();
            m_fTimestampTimer = 1;
        }
        
        if (!IsProxy() && m_fTimestamp > m_fAssigneeCacheCheckTimestamp)
        {
            m_fAssigneeCacheCheckTimestamp = m_fTimestamp + m_fAssigneeCacheTimer;
            CheckAssigneeTimeout();
        }
    }
    
    //***********//
    //JIP METHODS//
    //***********//
    
    //------------------------------------------------------------------------------------------------
    void SaveTasksForRpl(ScriptBitWriter writer, array<SCR_BaseTask> taskArray)
    {
        int count = taskArray.Count();
        writer.WriteInt(count);
        
        for (int i = 0; i < count; i++)
        {
            SCR_BaseTask task = taskArray[i];
            if (!task || task.FindComponent(RplComponent)) //--- Assume that tasks with their own replication will sync data themselves
            {
                writer.WriteBool(false);
                continue;
            }
            
            writer.WriteBool(true);
            
            EntityPrefabData prefabData = task.GetPrefabData();
            ResourceName resourceName;
            if (prefabData)
                resourceName = prefabData.GetPrefabName();
            
            writer.WriteResourceName(prefabData.GetPrefabName()); //Write prefab, then read it in load & spawn correct task
            
            task.Serialize(writer);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    override bool RplSave(ScriptBitWriter writer)
    {
        
        SaveTasksForRpl(writer, m_aTaskList);
        SaveTasksForRpl(writer, m_aFinishedTaskList);
        
        return true;
    }
    
    //------------------------------------------------------------------------------------------------
    void LoadTasksForRpl(ScriptBitReader reader, int count)
    {
        reader.ReadInt(count);
        
        ResourceName resourceName;
        Resource resource;
        SCR_BaseTask task;
        bool readTask;
        for (int i = 0; i < count; i++)
        {
            reader.ReadBool(readTask);
            if (!readTask)
                continue;
            
            reader.ReadResourceName(resourceName);
            
            resource = Resource.Load(resourceName);
            if (!resource.IsValid())
                continue;
            
            task = SCR_BaseTask.Cast(GetGame().SpawnEntityPrefab(resource, GetWorld()));
            if (!task)
                continue;
            
            task.Deserialize(reader);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    override bool RplLoad(ScriptBitReader reader)
    {
        int count;
        LoadTasksForRpl(reader, count);
        LoadTasksForRpl(reader, count);
        
        //Let the game mode know, the tasks are ready
        SCR_BaseGameMode gamemode = SCR_BaseGameMode.Cast(GetGame().GetGameMode());
        if (gamemode)
            gamemode.HandleOnTasksInitialized();
        
        //AssignCachedTasks();
        
        return true;
    }
    
    //************************//
    //CONSTRUCTOR & DESTRUCTOR//
    //************************//
    
    //------------------------------------------------------------------------------------------------
    void SCR_BaseTaskManager(IEntitySource src, IEntity parent)
    {
        if (!g_TaskManagerInstance)
            g_TaskManagerInstance = this;
        
#ifdef ENABLE_DIAG
        DiagMenu.RegisterMenu(SCR_DebugMenuID.DEBUGUI_TASKS_MENU, "Tasks", "");
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_EXECUTE_TASKS, "", "Execute tasks", "Tasks", true);
        DiagMenu.RegisterBool(SCR_DebugMenuID.DEBUGUI_SHOW_ALL_TASKS, "", "Print all tasks", "Tasks", false);
#endif
        SetEventMask(EntityEvent.FRAME | EntityEvent.INIT);
        SetFlags(EntityFlags.NO_LINK, false);
        
        //Register to Script Invokers
        s_OnTaskCreated.Insert(OnTaskCreated);
        s_OnTaskFinished.Insert(OnTaskFinished);
        s_OnTaskDeleted.Insert(OnTaskDeleted);
    }
    
    //------------------------------------------------------------------------------------------------
    void ~SCR_BaseTaskManager()
    {
        
        //Unregister from Script Invokers
        s_OnTaskCreated.Remove(OnTaskCreated);
        s_OnTaskFinished.Remove(OnTaskFinished);
        s_OnTaskDeleted.Remove(OnTaskDeleted);
    }
};