Unity3D 任務系統設計

 參考 ： “海游移動” 博客 http://jxwgame.blog.51cto.com/943299/1602630

先考慮需求

在任何時候，我需要能夠通過new創建一個任務（完成事件，獲得獎勵），任務自動開始運行 ，並且自動判斷運行狀態，是否完成等。
我們要做的，只是創建這個任務，並賦一些完成條件。

所以任務類（Class MyTask） 必須是脫離於Mono的獨立類。並且有一些對任務的控制（開始，暫停，完成）。
大致如下

public class MyTask
{
   public MyTask()
   {
      //構造一個任務並且自動開始
      //createTask
   }
}

任務建立后，需要不停地監測任務的狀態，是個循環，在u3d中只能通過協程，而這個類不繼承mono是沒有協程的
所以建立一個TaskManager類，繼承自mono。用來創建並且監測。

    public class MyTaskManager：MonoBehavior
    {
        static MyTaskManager singleton;

        public static TaskState CreateTask()
        {
            //專門用來startCorutine
            if(singleton == null)
            {
                GameObject go = new GameObject("MyTaskManager");
                singleton = go.AddComponent<MyTaskManager>();
            }

            //既然要創建對象，那么創建完成之后就必須返回給Task類。所以還要建立一個TaskState類用來返回
            return new TaskState();
        }

        //不繼承mono
        public class TaskState
        {    


        }
    }

 

完整的3部分代碼：

 

using UnityEngine;
using System.Collections;

/// <summary>
/// 任務類，用來被調用
/// </summary>
public class MyTask
{
    //string TaskName;

    MyTaskManager.TaskState task;

    public delegate void FinishedHander(bool isFinished);
    public event FinishedHander Finished;

    public MyTask(IEnumerator c,bool autoStart = true)
    {
        //構造一個任務並且自動開始
        //由於需要協程(檢測運行狀態)，所以只能再寫一個類來提供
        task =  MyTaskManager.CreateTask(c);

        //將本類中的TaskFinished 加入到 MyTaskManager中的TaskFinished。 所以 在myTaskManager中調用的時候，
        //會先調用myTaskmanager的taskState中的，然后再調用本類中的
        task.Finished += TaskFinished;

        if(autoStart)
        {
            //創建完之后運行
            task.Start();
        }
      
    }


    void TaskFinished(bool isFinished)
    {
        FinishedHander handler = Finished;
        if(handler!=null)
        {
            handler(isFinished);
        }
    }


    //任務有 停止，繼續，終結等處理方式
    public void Pause()
    {
        task.Pause();
    }

    public void Resume()
    {
        task.Resume();
    }

    public void Finish()
    {
        task.Finish();
    }
   
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 提供給MyTask類輔助
/// </summary>
public class MyTaskManager : MonoBehaviour 
{

    //單例
    static MyTaskManager singleton;
    public static TaskState CreateTask(IEnumerator c)
    {
        //既然要創建對象，那么創建完后就要返回，所以必須有個返回的類
        if(singleton == null)
        {
            GameObject go = new GameObject("MyTaskManager");
            singleton = go.AddComponent<MyTaskManager>();
        }
        return new TaskState(c);
    }

    


    //類 類
    public class TaskState
    {
        IEnumerator coroutine; //用來保存傳遞過來的函數。
        public enum State
        {
            Running,//正在運行
            Paused, //暫停
            Stopped,//停止/放棄
            Finished,//完成
        }

        public State state;

        public delegate void FinishedHander(bool isFinished);
        public event FinishedHander Finished;
      
        public TaskState(IEnumerator c)
        {
            coroutine = c;
            state = State.Running;
        }


        public void Start()
        {
            //改變任務的狀態，並且開啟一個監測協程
            state = State.Running;
            singleton.StartCoroutine(TaskStateMonitor());
        }

        //與task中的操作相對應
        public void Pause()
        {
            state = State.Paused;
        }
        public void Resume()
        {
            if (state == State.Paused)
            {
                state = State.Running;
            }
        }
        public void Finish()
        {
            state = State.Finished;
        }

        //主要是用來判斷是否完成任務
        IEnumerator TaskStateMonitor()
        {
            yield return null;
            IEnumerator e = coroutine;
            while(state == State.Running)
            {
                if (state == State.Paused)
                    yield return null;
                else
                {
                    //IEnumerator 有current ，movenext，reset
                    //就是說不停地執行 new出來的任務，因為new出來的任務是Enumrator，直到不能movenext了
                    if(e !=null && e.MoveNext())
                    {
                        yield return e.Current;
                    }
                    else
                    {
                        state = State.Finished;
                    }
                }
            }
            FinishedHander handler = Finished;
            if (handler != null)
                handler(true); //true
                     
        }

    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 使用示例
/// </summary>
public class UseTask : MonoBehaviour
{
    
    IEnumerator TaskOne()
    {
        while(true)
        {
            Debug.Log("TaskOne running");
            if(CheckTaskOneFinished())
            {
                Debug.Log("TaskOne Finished");
                DealWithTaskOneFinished();
                break; //跳出后 執行e.moveNext()就沒有了，狀態就finished
            }
            yield return null;
        }
    }

    /// <summary>
    /// 用來檢測任務是否完成，里面放條件
    /// </summary>
    /// <returns></returns>
    bool CheckTaskOneFinished()
    {
        if(Time.time >3)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    void DealWithTaskOneFinished()
    {
        ///
    }


    void Start()
    {
        MyTask task = new MyTask(TaskOne());
        
        //匿名添加finished后的操作。
        task.Finished += delegate(bool value)
        {
            if(value)
            {
                Debug.Log("after 匿名 finished");
            }
        };

    }
    
}

 

執行結果：

 

可以自行加一些任務的處理。完善整個系統。

重要幾點：
1： IEnumerator ： 我的理解是一個類似Interator的接口，它有三個方法。current，movenext，reset 。
每次就movenext去執行，執行到yield 位置。
2： yiled return: 每次調用到yield 的時候，就返回，下次在yiled之后的地方繼續執行。
3： event 調用順序 。 TaskState -> myTask 。所有的finished事件都是注冊到TaskState中的。

所以當上述的任務正在執行的時候，會一直在while循環中，一直可以movenext，一旦完成條件達到，跳出循環。則movenext馬上為null，
改變state為Finished。通過事件層層調用注冊的函數去執行。