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。通过事件层层调用注册的函数去执行。