【游戏开发实战】Unity从零做一个任务系统，人生如梦，毕业大学生走上人生巅峰（含源码工程 | 链式任务

link之家
链接快照平台
输入网页链接，自动生成快照
标签化管理网页链接
二、什么是任务系统

任务系统就是一个有明确目标性的系统。通过设置任务来引导玩家进行游戏，让玩家更快的融入游戏中。
可以说任务系统几乎是游戏必备的模块，我们随便找个游戏都可以看到任务系统。

根据这位小朋友的需求，是要做 主线任务/支线任务 的系统。
简单的说，就是有一条 主线任务链 ，在完成主线任务链上的某个节点时，开启下一个任务，并可以开启一条或多条 支线任务链 ，主线任务和多条支线任务并行。画个图，方便大家理解：
三、需求文档

由于只有我一个人，没有策划，那我就先充当策划，给自己写个需求文档吧~
1、故事背景

主人公林新发刚刚大学毕业，开始面临一个人生难题：如何走上人生巅峰！
现在我们为林新发设计一套任务，帮助他走上人生巅峰吧~
2、任务链设计

下面，就是走上人生巅峰的任务链啦~
3、任务规则

主线任务必须按顺序完成；
主线任务与支线任务可以并行；
支线任务并不影响主线任务；
每完成一个任务都可以得到相应的奖励；
任务界面只显示当前要执行或已完成但还未领取奖励的任务；
任务界面中要显示每个任务当前的进度；
每个任务有个前往按钮，点击前往按钮触发任务执行或跳转到相应的界面；
每个任务有对应的图标，可配置；
界面底部有一键领奖按钮，点击一键领奖领取所有可以领奖的任务奖励。
4、界面样式设计

使用 原型图设计 软件制作界面样式，如下：
四、从哪里开始着手

对于萌新来说，拿到需求时可能不知道从哪里开始做，是先写代码还是先做界面？代码又是从哪里开始写？
我总结了一个客户端开发流程，大家可以按这个流程执行，
五、任务配置表

1、定义表头字段

根据需求，我们先定义表头字段，
字段解释：
字段	数据类型	说明
task_chain_id	int	`链id` ，每个任务都有它对应的 `链id` ，同一条链上的任务的 `链id` 相同
task_sub_id	int	`任务id` ，它是链上的 `任务id` ，不同链的 `任务id` 可以重复，从 `1` 开始往下自增
icon	string	任务图标
desc	string	任务描述，这个会显示到界面中
task_target	string	任务目标，定义一个字符串来表示任务的目标类别，比如 `加班5次` 和 `加班10次` 的任务目标是一样的，只是数量不同，同理， `写博客5篇` 和 `写博客100篇` 的任务目标也是一样的
target_amount	int	目标数量，比如加班 `5次` 的目标数量就是 `5` ，写博客 `100篇` 的目标数量就是 `100`
award	string	奖励， `json` 格式，例： `{"gold":1000}` ，表示奖励 `1000` 金币
open_chain	string	要打开的支线任务，格式：```链id
2、配置表格数据

根据我们上面设计的任务链，在配置表中配置任务数据，入下：
注：黄色的是主线任务，每条支线任务我都单独标了颜色方便阅读。
表格保存为 链式任务.xlsx ，如下
3、转表工具：Excel转Json

Excel 表格是方便策划进行配置数值，游戏中并不是直接读取 Excel 配置，实际项目中一般都是将 Excel 转为 xml 、 json 、 lua 或自定义的文本格式的配置。
我这里就以 Excel 转 Json 为例，处理 Excel 我推荐大家使用 python 来写工具，我之前写过一篇文章：《教你使用python读写Excel表格（增删改查操作），使用openpyxl库》，里面我详细介绍了使用 python 的 openpyxl 库来读写 Excel ，建议大家先认真看一下这篇文章。
这里我就直接把最终我写好的 python 代码贴出来，代码也很简单，这里不赘述了~
import openpyxl
import json
# excel表格转json文件
def excel_to_json(excel_file, json_f_name):
    jd = []
    heads = []
    book = openpyxl.load_workbook(




    
excel_file)
    sheet = book[u'Sheet1']
    max_row = sheet.max_row
    max_column = sheet.max_column
    # 解析表头
    for column in range(max_column):
        heads.append(sheet.cell(1, column + 1).value)
    # 遍历每一行
    for row in range(max_row):
        if row < 2:
        	# 前两行跳过
            continue
        one_line = {}
        # 遍历一行中的每一个单元格
        for column in range(max_column): 
            k = heads[column]
            v = sheet.cell(row + 1, column + 1).value
            one_line[k] = v
        jd.append(one_line)
    book.close()
    # 将json保存为文件
    save_json_file(jd, json_f_name)
# 将json保存为文件
def save_json_file(jd, json_f_name):
    f = open(json_f_name, 'w', encoding='utf-8')
    txt = json.dumps(jd, indent=2, ensure_ascii=False)
    f.write(txt)
    f.close()
if '__main__' == __name__:
     excel_to_json(u'链式任务.xlsx', 'task_cfg.bytes')
上面的python代码保存为excel_to_json.py，如下
 
 把excel_to_json.py放在上面的链式任务.xlsx文件的同级目录中，执行excel_to_json.py，生成task_cfg.bytes，
 
 使用文本编辑器打开task_cfg.bytes，看下生成效果，如下，格式正确：
  
六、读取配置表
 
上面配置表做好了，接下来就可以开始动手Unity部分了。
 在Unity中如何读取配置表呢？其实配置表也是一种资源，关于资源读取我之前写过相关文章：
 《Unity游戏开发——新发教你做游戏（三）：3种资源加载方式》
  
这里我就简单处理，通过Resources.Load来读取文件。 
1、资源加载：Resources.Load
 
先新建一个Resources文件夹，
 
 把task_cfg.bytes放在Resources目录中，
 
 这样我们就可以直接使用Resources.Load来读取task_cfg.bytes文件了，如下： 
string txt = Resources.Load<TextAsset>("task_cfg").text;
2、C#的json库：LitJson
 
因为我们使用的是json格式的文本，要解析它我们需要使用json库，这里我推荐使用LitJson，可以在GitHub中找到LitJson的开源项目，
 地址：https://hub.fastgit.org/LitJSON/litjson
 
 我们下载下来后，把src目录中的LitJson文件夹整个拷贝到我们Unity工程中，如下：
 
 这样我们就可以在C#中使用LitJson了。
 使用时引入命名空间： 
using LitJson;
3、任务配置配置读取：TaskCfg.cs脚本
 
3.1、创建TaskCfg.cs脚本
 
现在我们开始写C#代码，养成好习惯，先建好Scripts目录。我们的数据代码、逻辑代码和界面代码要分开，所以建立Data、Logic和View三个子目录，
 
 在Data目录中新建一个TaskCfg.cs脚本，
  
3.2、定义任务配置结构：TaskCfgItem
 
LitJson提供了一个JsonMapper.ToObject<T>(jsonString)方法，可以直接将json字符串转为类对象，前提是类的字段名要与json的字段相同，所以我们先定义一个与json字段名相同的类TaskCfgItem，如下： 
// TaskCfg.cs
/// <summary>
/// 任务配置结构
/// </summary>
public class TaskCfgItem
    public int task_chain_id;
    public int task_sub_id;
    public string icon;
    public string desc;
    public string task_target;
    public int target_amount;
    public string award;
    public string open_chain;
3.3、定义存储配置的容器
 
为了方便在内存中索引配置表，我们使用字典来存储，定义一个用来存放配置数据的字典： 
// TaskCfg.cs
// 任务配置，(链id : 子任务id : TaskCfgItem)
private Dictionary<int, Dictionary<int, TaskCfgItem>> m_cfg;
3.4、读取配置：LoadCfg
 
我们封装一个LoadCfg方法来读取配置，如下： 
// TaskCfg.cs
/// <summary>
/// 读取配置
/// </summary>
public void LoadCfg()
    m_cfg = new Dictionary<int, Dictionary<int, TaskCfgItem>>();
    var txt = Resources.Load<TextAsset>("task_cfg").text;
    var jd = JsonMapper.ToObject<JsonData>(txt);
    for (int i = 0, cnt = jd.Count; i < cnt; ++i)
        var itemJd = jd[i] as JsonData;
        TaskCfgItem cfgItem = JsonMapper.ToObject<TaskCfgItem>(itemJd.ToJson());
        if (!m_cfg.ContainsKey(cfgItem.task_chain_id))
            m_cfg[cfgItem.task_chain_id] = new Dictionary<int, TaskCfgItem>();
        m_cfg[cfgItem.task_chain_id].Add(cfgItem.task_sub_id, cfgItem);
3.5、索引任务配置项：GetCfgItem
 
为了索引任务配置项，我们再封装一个GetCfgItem方法， 
// TaskCfg.cs
/// <summary>
/// 获取配置项
/// </summary>
/// <param name="chainId">链id</param>
/// <param name="taskSubId">任务子id</param>
/// <returns></returns>
public TaskCfgItem GetCfgItem(int chainId, int taskSubId)
    if (




    
m_cfg.ContainsKey(chainId) && m_cfg[chainId].ContainsKey(taskSubId))
        return m_cfg[chainId][taskSubId];
    return null;
3.6、使用单例模式
 
我们希望TaskCfg全局只有一个对象，我们使用单例模式， 
// TaskCfg.cs
// 单例模式
private static TaskCfg s_instance;
public static TaskCfg instance
        if (null == s_instance)
            s_instance = new TaskCfg();
        return s_instance;
这样我们就可以通过TaskCfg.instance来调用它的public方法了，如下 
// 调用读取配置的方法
TaskCfg.instance.LoadCfg();
3.7、思维导图
 
3.8、TaskCfg.cs完整代码
 
最终，TaskCfg.cs完整代码如下： 
/// <summary>
/// 任务配置读取与查询
/// 作者：林新发，博客：https://blog.csdn.net/linxinfa
/// </summary>
using System.Collections.Generic;
using UnityEngine;
using LitJson;
public class TaskCfg
    /// <summary>
    /// 读取配置
    /// </summary>
    public void LoadCfg()
        m_cfg = new Dictionary<int, Dictionary<int, TaskCfgItem>>();
        var txt = Resources.Load<TextAsset>("task_cfg").text;
        var jd = JsonMapper.ToObject<JsonData>(txt);
        for (int i = 0, cnt = jd.Count; i < cnt; ++i)
            var itemJd = jd[i] as JsonData;
            TaskCfgItem cfgItem = JsonMapper.ToObject<TaskCfgItem>(itemJd.ToJson());
            if (!m_cfg.ContainsKey(cfgItem.task_chain_id))
                m_cfg[cfgItem.task_chain_id] = new Dictionary<int, TaskCfgItem>();
            m_cfg[cfgItem.task_chain_id].Add(cfgItem.task_sub_id, cfgItem);
    /// <summary>
    /// 获取配置项
    /// </summary>
    /// <param name="chainId">链id</param>
    /// <param name="taskSubId">任务子id</param>
    /// <returns></returns>
    public TaskCfgItem GetCfgItem(int chainId, int taskSubId)
        if (m_cfg.ContainsKey(chainId) && m_cfg[chainId].ContainsKey(taskSubId))
            return m_cfg[chainId][taskSubId];
        return null;
    // 任务配置，(链id : 子任务id : TaskCfgItem)
    private Dictionary<int, Dictionary<int, TaskCfgItem>> m_cfg;
    private static TaskCfg s_instance;
    public static TaskCfg instance
            if (null == s_instance)
                s_instance = new TaskCfg();
            return s_instance;
/// <summary>
/// 任务配置结构
/// </summary>
public class TaskCfgItem
    public int task_chain_id;
    public int task_sub_id;
    public string icon;
    public string desc;
    public string task_target;
    public int target_amount;
    public string award;
    public string open_chain;
七、任务数据增删改查：TaskData.cs脚本
 
1、创建TaskData.cs脚本
 
严格来说，我们需要在服务端存储任务数据、更新任务进度等，这里我就只是在客户端进行模拟，不做服务端了。
 在Scripts / Data目录中新建一个TaskData.cs脚本，来实现任务数据增删改查的功能。
  
2、定义任务数据：TaskDataItem
 
我们要读写任务数据，需要先定义任务数据结构TaskDataItem， 
// TaskData.cs
/// <summary>
/// 任务数据
/// </summary>
public class TaskDataItem
    // 链id
    public int task_chain_id;
    // 任务子id
    public int task_sub_id;
    // 进度
    public int progress;
    // 奖励是否被领取了，0：未被领取，1：已被领取
    public short award_is_get;
3、本地数据读写：PlayerPrefs
 
Unity提供了一个PlayerPrefs类给我们，可以很方便进行本地持久化数据读写。
 
 读： 
string defaultJson = "[{'task_chain_id':1,'task_sub_id':1,'progress':0,'award_is_get':0}]";
string jsonStr = PlayerPrefs.GetString("TASK_DATA", defaultJson);
string jsonStr = "[{'task_chain_id':1,'task_sub_id':1,'progress':0,'award_is_get':0}]";
PlayerPrefs.SetString("TASK_DATA", jsonStr);
PlayerPrefs.DeleteKey("TASK_DATA");
4、定义存储数据的容器
 
定义一个容器用于内存中存储数据， 
private List<




    
TaskDataItem> m_taskDatas;
5、从本地读取任务数据
 
使用PlayerPrefs.GetString接口从本地读取数据，使用Action cb回调是为了模拟实际场景中从服务端数据库读取数据（异步）的过程， 
/// <summary>
/// 从数据库读取任务数据
/// </summary>
/// <param name="cb"></param>
public void GetTaskDataFromDB(Action cb)
    // 正规是与服务端通信，从数据库中读取，这里纯客户端进行模拟，直接使用PlayerPrefs从客户端本地读取
    var jsonStr = PlayerPrefs.GetString("TASK_DATA", "[{'task_chain_id':1,'task_sub_id':1,'progress':0,'award_is_get':0}]");
    var taskList = JsonMapper.ToObject<List<TaskDataItem>>(jsonStr);
    for (int i = 0, cnt = taskList.Count; i < cnt; ++i)
        AddOrUpdateData(taskList[i]);
    cb();
6、写任务数据到本地
 
使用PlayerPrefs.SetString接口写数据到本地， 
/// <summary>
/// 写数据到数据库
/// </summary>
private void SaveDataToDB()
    var jsonStr = JsonMapper.ToJson(m_taskDatas);
    PlayerPrefs.SetString("TASK_DATA", jsonStr);
7、查询指定任务的数据
 
/// <summary>
/// 获取某个任务数据
/// </summary>
/// <param name="chainId">链id</param>
/// <param name="subId">任务子id</param>
/// <returns></returns>
public TaskDataItem GetData(int chainId, int subId)
    for (int i = 0, cnt = m_taskDatas.Count; i < cnt; ++i)
        var item = m_taskDatas[i];
        if (chainId == item.task_chain_id && subId == item.task_sub_id)
            return item;
    return null;
8、任务数据增加或更新
 
新增任务时，需要对列表进行重新排序，确保主线任务（即task_chain_id为1）的任务排在最前面， 
/// <summary>
/// 添加或更新任务
/// </summary>
public void AddOrUpdateData(TaskDataItem itemData)
    bool isUpdate = false;
    for (int i = 0, cnt = m_taskDatas.Count; i < cnt; ++i)
        var item = m_taskDatas[i];
        if (itemData.task_chain_id == item.task_chain_id && itemData.task_sub_id == item.task_sub_id)
            // 更新数据
            m_taskDatas[i] = itemData;
            isUpdate = true;
            break;
    if(!isUpdate)
        m_taskDatas.Add(itemData);
    // 排序，确保主线在最前面
    m_taskDatas.Sort((a, b) => 
        return a.task_chain_id.CompareTo(b.task_chain_id);
    });
    SaveDataToDB();
9、任务数据删除
 
/// <summary>
/// 移除任务数据
/// </summary>
/// <param name="chainId">链id</param>
/// <param name="subId">任务子id</param>
public void RemoveData(int chainId, int subId)
    for (int i = 0, cnt = m_taskDatas.Count; i < cnt; ++i)
        var item = m_taskDatas[i];
        if (chainId == item.task_chain_id && subId == item.task_sub_id)
            m_taskDatas.Remove(item);
            SaveDataToDB();
            return;
10、思维导图
 
按照惯例，画个图：
  
11、TaskData.cs完整代码
 
最终TaskData.cs完整代码如下： 
/// <summary>
/// 任务数据增删改查
/// 作者：林新发，博客：https://blog.csdn.net/linxinfa
/// </summary>
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using LitJson;
using System;
public class TaskData
    public TaskData()
        m_taskDatas = new List<TaskDataItem>();
    /// <summary>
    /// 从数据库读取任务数据
    /// </summary>
    /// <param name="cb"></param>
    public void GetTaskDataFromDB(Action cb)
        // 正规是与服务端通信，从数据库中读取，这里纯客户端进行模拟，直接使用PlayerPrefs从客户端本地读取
        var jsonStr = PlayerPrefs.GetString("TASK_DATA", "[{'task_chain_id':1,'task_sub_id':1,'progress':0,'award_is_get':0}]");
        var taskList = JsonMapper.ToObject<List<TaskDataItem>>(jsonStr);
        for (int i = 0, cnt = taskList.Count; i < cnt; ++i)
            AddOrUpdateData(taskList[i]);
        cb();




    

    /// <summary>
    /// 添加或更新任务
    /// </summary>
    public void AddOrUpdateData(TaskDataItem itemData)
        bool isUpdate = false;
        for (int i = 0, cnt = m_taskDatas.Count; i < cnt; ++i)
            var item = m_taskDatas[i];
            if (itemData.task_chain_id == item.task_chain_id && itemData.task_sub_id == item.task_sub_id)
                // 更新数据
                m_taskDatas[i] = itemData;
                isUpdate = true;
                break;
        if(!isUpdate)
            m_taskDatas.Add(itemData);
        // 排序，确保主线在最前面
        m_taskDatas.Sort((a, b) => 
            return a.task_chain_id.CompareTo(b.task_chain_id);
        });
        SaveDataToDB();
    /// <summary>
    /// 获取某个任务数据
    /// </summary>
    /// <param name="chainId">链id</param>
    /// <param name="subId">任务子id</param>
    /// <returns></returns>
    public TaskDataItem GetData(int chainId, int subId)
        for (int i = 0, cnt = m_taskDatas.Count; i < cnt; ++i)
            var item = m_taskDatas[i];
            if (chainId == item.task_chain_id && subId == item.task_sub_id)
                return item;
        return null;
    /// <summary>
    /// 移除任务数据
    /// </summary>
    /// <param name="chainId">链id</param>
    /// <param name="subId">任务子id</param>
    public void RemoveData(int chainId, int subId)
        for (int i = 0, cnt = m_taskDatas.Count; i < cnt; ++i)
            var item = m_taskDatas[i];
            if (chainId == item.task_chain_id && subId == item.task_sub_id)
                m_taskDatas.Remove(item);
                SaveDataToDB();
                return;
    /// <summary>
    /// 写数据到数据库
    /// </summary>
    private void SaveDataToDB()
        var jsonStr = JsonMapper.ToJson(m_taskDatas);
        PlayerPrefs.SetString("TASK_DATA", jsonStr);
    public void ResetData(Action cb)
        PlayerPrefs.DeleteKey("TASK_DATA");
        m_taskDatas.Clear();
        GetTaskDataFromDB(cb);
    public List<TaskDataItem> taskDatas
        get { return m_taskDatas; }
    // 任务数据
    private List<TaskDataItem> m_taskDatas;
/// <summary>
/// 任务数据
/// </summary>
public class TaskDataItem
    // 链id
    public int task_chain_id;
    // 任务子id
    public int task_sub_id;
    // 进度
    public int progress;
    // 奖励是否被领取了，0：未被领取，1：已被领取
    public short award_is_get;
八、任务逻辑：TaskLogic.cs
 
1、创建TaskLogics脚本
 
在Scripts / Logic目录中创建TaskLogic.cs脚本，
 
 任务的逻辑其实就是进度更新、任务完成后领奖、开启下一个任务、开启分支任务等，我们挨个来实现。 
2、成员：TaskData
 
先把TaskData作为成员变量，并提供一个数据属性taskDatas，方便访问， 
private TaskData m_taskData;
public List<TaskDataItem> taskDatas
    get { return m_taskData.taskDatas; }
public TaskLogic()
    m_taskData = new TaskData();
3、获取任务数据
 
/// <summary>
/// 获取任务数据
/// </summary>
/// <param name="cb">回调</param>
public void GetTaskData(Action cb)
    m_taskData.GetTaskDataFromDB(cb);
4、更新任务进度
 
使用Action<int, bool>回调是为了模拟实际场景中与服务端通信（异步），处理结果会有个返回码ErrorCode（回调函数第一个参数），客户端需判断ErrorCode的值来进行处理，一般约定ErrorCode为0表示成功，回调函数第二个参数是是否任务进度已达成，如果任务达成，客户端需要显示领奖按钮， 
/// <summary>
/// 更新任务进度
/// </summary>
/// <param name="chainId">链id</param>
/// <param name="subId">任务子id</param>
/// <param name="deltaProgress">进度增加量</param>
/// <param name="cb">回调</param>
public void AddProgress(int chainId, int subId, int deltaProgress, Action<int, bool> cb)
    var data = m_taskData.GetData(chainId, subId);
    if (null != data)
        data.progress += deltaProgress;
        m_taskData.AddOrUpdateData(data);
        var cfg = TaskCfg.instance.GetCfgItem(data.task_chain_id,




    
 data.task_sub_id);
        if (null != cfg)
            cb(0, data.progress >= cfg.target_amount);
            cb(-1, false);
        cb(-1, false);
5、领取任务奖励
 
是否领奖的状态字段为award_is_get ，为0表示未领奖，为1表示已领过奖。
 领完奖的任务从列表中移除，并开启下一个任务（如果配置了开启支线任务，则还需要配套开启对应的支线任务）， 
/// <summary>
/// 领取任务奖励
/// </summary>
/// <param name="chainId">链id</param>
/// <param name="subId">任务子id</param>
/// <param name="cb">回调</param>
public void GetAward(int chainId, int subId, Action<int, string> cb)
    var data = m_taskData.GetData(chainId, subId);
    if (null == data)
        cb(-1, "{}");
        return;
    if (0 == data.award_is_get)
        data.award_is_get = 1;
        m_taskData.AddOrUpdateData(data);
        GoNext(chainId, subId);
        var cfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id);
        cb(0, cfg.award);
        cb(-2, "{}");
6、一键领取任务的奖励
 
遍历所有达成进度且未领奖的任务，支线领奖，并开开启每个领完奖的任务的下一个任务（如果配置了开启支线任务，则还需要配套开启对应的支线任务）， 
/// <summary>
/// 一键领取所有任务的奖励
/// </summary>
/// <param name="cb"></param>
public void OneKeyGetAward(Action<int, string> cb)
    int totalGold = 0;
    var tmpTaskDatas = new List<TaskDataItem>(m_taskData.taskDatas);
    for (int i = 0, cnt = tmpTaskDatas.Count; i < cnt; ++i)
        var oneTask = tmpTaskDatas[i];
        var cfg = TaskCfg.instance.GetCfgItem(oneTask.task_chain_id, oneTask.task_sub_id);
        if (oneTask.progress >= cfg.target_amount && 0 == oneTask.award_is_get)
            oneTask.award_is_get = 1;
            m_taskData.AddOrUpdateData(oneTask);
            var awardJd = JsonMapper.ToObject(cfg.award);
            totalGold += int.Parse(awardJd["gold"].ToString());
            GoNext(oneTask.task_chain_id, oneTask.task_sub_id);
    if (totalGold > 0)
        JsonData totalAward = new JsonData();
        totalAward["gold"] = totalGold;
        cb(0, JsonMapper.ToJson(totalAward));
        cb(-1, null);
7、开启下一个任务（含支线）
 
约定任务id递增，开启下一个任务就是查找id+1的任务并开启。
 支线任务的开启是open_chain字段，格式链id|任务子id，多个支线以,号隔开，例：3|1,5|1表示开启链3的子任务1和链5的子任务1， 
/// <summary>
/// 开启下一个任务（含支线）
/// </summary>
/// <param name="chainId">链id</param>
/// <param name="subId">任务子id</param>
private void GoNext(int chainId, int subId)
    var data = m_taskData.GetData(chainId, subId);
    var cfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id);
    var nextCfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id + 1);
    if (1 == data.award_is_get)
        // 移除掉已领奖的任务
        m_taskData.RemoveData(chainId, subId);
        // 开启下一个任务
        if (null != nextCfg)
            TaskDataItem dataItem = new TaskDataItem();
            dataItem.task_chain_id = nextCfg.task_chain_id;
            dataItem.task_sub_id = nextCfg.task_sub_id;
            dataItem.progress = 0;
            dataItem.award_is_get = 0;
            m_taskData.AddOrUpdateData(dataItem);
        // 开启支线任务
        if (!string.IsNullOrEmpty(cfg.open_chain))
            // 开启新分支
            var chains = cfg.open_chain.Split(',');
            for (int i =




    
 0, len = chains.Length; i < len; ++i)
                var task = chains[i].Split('|');
                TaskDataItem subChainDataItem = new TaskDataItem();
                subChainDataItem.task_chain_id = int.Parse(task[0]);
                subChainDataItem.task_sub_id = int.Parse(task[1]);
                subChainDataItem.progress = 0;
                subChainDataItem.award_is_get = 0;
                m_taskData.AddOrUpdateData(subChainDataItem);
8、思维导图
 
画一下图，
  
9、TaskLogic.cs完整代码
 
最终TaskLogic.cs完整代码如下 
/// <summary>
/// 任务逻辑
/// 作者：林新发，博客：https://blog.csdn.net/linxinfa
/// </summary>
using System.Collections.Generic;
using UnityEngine;
using LitJson;
using System;
public class TaskLogic
    public TaskLogic()
        m_taskData = new TaskData();
    /// <summary>
    /// 获取任务数据
    /// </summary>
    /// <param name="cb">回调</param>
    public void GetTaskData(Action cb)
        m_taskData.GetTaskDataFromDB(cb);
    /// <summary>
    /// 更新任务进度
    /// </summary>
    /// <param name="chainId">链id</param>
    /// <param name="subId">任务子id</param>
    /// <param name="deltaProgress">进度增加量</param>
    /// <param name="cb">回调</param>
    public void AddProgress(int chainId, int subId, int deltaProgress, Action<int, bool> cb)
        var data = m_taskData.GetData(chainId, subId);
        if (null != data)
            data.progress += deltaProgress;
            m_taskData.AddOrUpdateData(data);
            var cfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id);
            if (null != cfg)
                cb(0, data.progress >= cfg.target_amount);
                cb(-1, false);
            cb(-1, false);
    /// <summary>
    /// 一键领取所有任务的奖励
    /// </summary>
    /// <param name="cb"></param>
    public void OneKeyGetAward(Action<int, string> cb)
        int totalGold = 0;
        var tmpTaskDatas = new List<TaskDataItem>(m_taskData.taskDatas);
        for (int i = 0, cnt = tmpTaskDatas.Count; i < cnt; ++i)
            var oneTask = tmpTaskDatas[i];
            var cfg = TaskCfg.instance.GetCfgItem(oneTask.task_chain_id, oneTask.task_sub_id);
            if (oneTask.progress >= cfg.target_amount && 0 == oneTask.award_is_get)
                oneTask.award_is_get = 1;
                m_taskData.AddOrUpdateData(oneTask);
                var awardJd = JsonMapper.ToObject(cfg.award);
                totalGold += int.Parse(awardJd["gold"].ToString());
                GoNext(oneTask.task_chain_id, oneTask.task_sub_id);
        if (totalGold > 0)
            JsonData totalAward = new JsonData();
            totalAward["gold"] = totalGold;
            cb(0, JsonMapper.ToJson(totalAward));
            cb(-1, null);
    /// <summary>
    /// 领取任务奖励
    /// </summary>
    /// <param name="chainId">链id</param>
    /// <param name="subId">任务子id</param>
    /// <param name="cb">回调</param>
    public void GetAward(int chainId, int subId, Action<int, string> cb)
        var data = m_taskData.GetData(chainId, subId);
        if (null == data)
            cb(-1, "{}");
            return;
        if (0 == data.award_is_get)




    

            data.award_is_get = 1;
            m_taskData.AddOrUpdateData(data);
            GoNext(chainId, subId);
            var cfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id);
            cb(0, cfg.award);
            cb(-2, "{}");
    /// <summary>
    /// 触发下一个任务，并开启支线任务
    /// </summary>
    /// <param name="chainId">链id</param>
    /// <param name="subId">任务子id</param>
    private void GoNext(int chainId, int subId)
        var data = m_taskData.GetData(chainId, subId);
        var cfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id);
        var nextCfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id + 1);
        if (1 == data.award_is_get)
            // 移除掉已领奖的任务
            m_taskData.RemoveData(chainId, subId);
            // 开启下一个任务
            if (null != nextCfg)
                TaskDataItem dataItem = new TaskDataItem();
                dataItem.task_chain_id = nextCfg.task_chain_id;
                dataItem.task_sub_id = nextCfg.task_sub_id;
                dataItem.progress = 0;
                dataItem.award_is_get = 0;
                m_taskData.AddOrUpdateData(dataItem);
            // 开启支线任务
            if (!string.IsNullOrEmpty(cfg.open_chain))
                // 开启新分支
                var chains = cfg.open_chain.Split(',');
                for (int i = 0, len = chains.Length; i < len; ++i)
                    var task = chains[i].Split('|');
                    TaskDataItem subChainDataItem = new TaskDataItem();
                    subChainDataItem.task_chain_id = int.Parse(task[0]);
                    subChainDataItem.task_sub_id = int.Parse(task[1]);
                    subChainDataItem.progress = 0;
                    subChainDataItem.award_is_get = 0;
                    m_taskData.AddOrUpdateData(subChainDataItem);
    public void ResetAll(Action cb)
        m_taskData.ResetData(cb);
    public List<TaskDataItem> taskDatas
        get { return m_taskData.taskDatas; }
    private TaskData m_taskData;
    private static TaskLogic s_instance;
    public static TaskLogic instance
            if (null == s_instance)
                s_instance = new TaskLogic();
            return s_instance;
九、UI界面制作
 
1、UI资源获取
 
简单的UI资源我是在阿里巴巴矢量图库上找，地址：https://www.iconfont.cn/
 比如搜索按钮，
 
 找一个形状合适的，可以进行调色，我一般是调成白色，
  
因为Unity中可以设置Color，这样我们只需要一个白色按钮就可以在Unity中创建不同颜色的按钮了。
 弄点基础的美术资源，
 
 注：那个头像是我自己用PhotoShop画的哦，我之前用PhotoShop画过一幅原创连环画，如下：
 
 同时，我们还需要任务图标，也找一些，
 
 注意所有要使用UGUI来展示资源都设置为Sprite (2D and UI)格式。
  
 注，关于资源的获取，我之前写过一篇文章：《Unity游戏开发——新发教你做游戏（二）：60个Unity免费资源获取网站》，感兴趣的同学可以看下， 
2、场景界面制作：Main场景，人生如梦
 
养成好习惯，不管你是单场景还是多场景，入口场景命名为Main。
 在场景中使用UGUI简单做下入口界面：MainPanel，
 
 这个任务系统的主题我定为：人生如梦。
  
3、制作列表界面预设：TaskPanel.prefab
 
根据需求，我们的任务要以列表的显示展示，使用UGUI制作任务列表界面，
 
 如下，
 
 界面保存为TaskPanel.prefab，放在Resources目录中，
  
4、制作提示框界面预设：TipsPanel.prefab
 
为了在客户端模拟测试，做一个提示框界面，
 
 如下：
 
 界面保存为TipsPanel.prefab，放在Resources目录中，
 
 嘛，顺手做个界面动画吧， 
 注：关于动画相关的教程，我之前写过一些，感兴趣的同学可以看下：
 《Unity使用Animator控制动画播放，皮皮猫打字机游戏》
 《Unity动画状态机Animator使用》
 《Unity动画使用混合树BlendTree实现动画过渡控制》
 《新发教你做游戏（七）：Animator控制角色动画播放》 
5、制作奖励界面预设：AwardPanel.prefab
 
领取任务奖励要有个奖励UI展示，做一个，
 
 界面保存为AwardPanel.prefab，放在Resources目录中，
  
也顺手做个动画，
  
十、编写界面代码
 
界面预设制作好了，接下来就是写界面交互的代码了。 
1、入口脚本：Main.cs
 
像C/C++有Main入口函数一样，我们的游戏也需要有一个脚本作为入口脚本。
 我们创建一个Main.cs脚本，挂到场景中的MainPanel节点上，
 
 Main.cs脚本代码如下，主要是做一些全局变量、配置、数据等的初始化，然后显示界面，不过我们任务界面代码还没写，先留个TODO， 
using UnityEngine;
/// <summary>
/// 入口脚本
/// </summary>
public class Main : MonoBehaviour
    void Start()
        GlobalObj.s_canvasTrans = GameObject.Find("Canvas").transform;
        // 加载任务配置
        TaskCfg.instance.LoadCfg(




    
);
        // 获取任务数据
        TaskLogic.instance.GetTaskData(()=> 
            // TODO: 显示任务界面
        });
public class GlobalObj
    public static Transform s_canvasTrans;
2、任务列表界面
 
2.1、循环复用列表
 
任务界面以列表展示任务，我之前做过一个循环复用列表的功能，可以参见我之前这篇文章：《Unity UGUI实现循环复用列表，显示巨量列表信息，含Demo工程源码》
 
 我把之前写的RecyclingList脚本拷贝过来，
 RecyclingList脚本地址：https://codechina.csdn.net/linxinfa/UnityRecyclingListDemo/-/tree/master/Assets/Scripts/RecyclingList
 
 给ScrollVIew挂上RecyclingListView脚本，脚本的ChildObj对象需要是RecyclingListViewItem类型的，我们下面会写一个TaskItemUI继承RecyclingListViewItem，这里ChildObj先留空，
  
2.2、列表项脚本：TaskItemUI.cs
 
在Scripts / View目录中创建TaskItemUI.cs脚本，它要继承RecyclingListViewItem， 
public class TaskItemUI : RecyclingListViewItem
定义一些UI对象， 
// 描述
public Text desText;
// 进度
public Text progressText;
// 前往按钮
public Button goAheadBtn;
// 领奖按钮
public Button getAwardBtn;
// 进度条
public Slider progressSlider;
// 任务图标
public Image icon;
// 任务类型标记，主线/支线 
public Image taskType;
把TaskItemUI脚本挂到ChildItem节点上，并赋值各个UI对象，
 
 现在我们可以给RecyclingListView脚本赋值ChildObj对象了，
 
 TaskItemUI.cs脚本唯一要做的事情就是根据数据更新UI，
  
// TaskItemUI.cs
public Action updateListCb;
/// <summary>
/// 更新UI
/// </summary>
/// <param name="data"></param>
public void UpdateUI(TaskDataItem data)
    var cfg = TaskCfg.instance.GetCfgItem(data.task_chain_id, data.task_sub_id);
    if (null != cfg)
        desText.text = cfg.desc;
        // TODO 设置图标
        // icon.sprite 
        // TODO 设置主线/支线图标
        // var taskTypeSpriteName = 1 == cfg.task_chain_id ? "zhu" : "zhi";
        // taskType.sprite
        progressText.text = data.progress + "/" + cfg.target_amount;
        progressSlider.value = (float)data.progress / cfg.target_amount;
        // 前往按钮
        goAheadBtn.onClick.RemoveAllListeners();
        goAheadBtn.onClick.AddListener(() =>
            // TODO 前往任务
        });
		// 领奖按钮
        getAwardBtn.onClick.RemoveAllListeners();
        getAwardBtn.onClick.AddListener(() =>
            TaskLogic.instance.GetAward(data.task_chain_id, data.task_sub_id, (errorCode, award) => 
                if(0 == errorCode)
                    // TODO 领奖界面
                    updateListCb();
            });
        });
        goAheadBtn.gameObject.SetActive(data.progress < cfg.target_amount);
        getAwardBtn.gameObject.SetActive(data.progress >= cfg.target_amount && 0 == data.award_is_get);
上面代码有几个TODO，
 1 设置图标我们等下写个图标资源管理器；
 2 任务的前往逻辑，我们要弹出提示框；
 3 领奖要显示奖励界面。
 现在，我们继续往下做。 
2.3、列表界面脚本：TaskPanel.cs
 
在Scripts / View目录中创建TaskPanel.cs脚本，把它挂到TaskPanel界面的根节点上，
 
 最关键的，定义RecyclingListView成员对象， 
// TaskPanel.cs
public RecyclingListView scrollList;
我们的列表更新就是监听它的ItemCallback回调的， 
// TaskPanel.cs
// 列表item更新回调
scrollList.ItemCallback = PopulateItem;
// ...
private void PopulateItem(RecyclingListViewItem item, int rowIndex)
	var child = item as TaskItemUI;
	// 刷新某个item
	child.UpdateUI(TaskLogic.instance.taskDatas[rowIndex]);
	child.updateListCb = () =>
    	// 刷新整个列表
        RefreshAll();
/// <summary>
/// 刷新整个列表
/// </summary>
private void RefreshAll()
    scrollList.RowCount = TaskLogic.instance.taskDatas.Count;
    scrollList.Refresh();
我们需要告诉RecyclingListView我们的列表的item的数量，方便它进行计算， 
// TaskPanel.cs
// 设置数据，此时列表会执行更新
scrollList.RowCount = TaskLogic.instance.taskDatas.Count;
为了便于显示TaskPanel界面，我们封装一个static的Show方法， 
// TaskPanel.cs
private static GameObject s_taskPanelPrefab;
// 显示任务界面
public static void Show()
    if (null == s_taskPanelPrefab)
        s_taskPanelPrefab = Resources.Load<GameObject>("TaskPanel");
    var panelObj = Instantiate(s_taskPanelPrefab);
    panelObj.transform.SetParent(GlobalObj.s_canvasTrans, false);
这样，我们就可以在Main.cs脚本中加上这个TaskPanel.Show()的调用了， 
// Main.cs
void Start()
	// ...
    // 获取任务数据
    TaskLogic.instance.GetTaskData((




    
)=> 
        // 显示任务界面
        TaskPanel.Show();
    });
3、提示框界面：TipsPanel.cs
 
在Scripts / View目录中创建TipsPanel.cs脚本，先定义三个按钮对象， 
public Button closeBtn;
public Button addProgressBtn;
public Button onekeyBtn;

 给TipsPanel预设跟节点挂上TipsPanel.cs脚本，赋值按钮对象，
 
 分别写三个按钮的点击逻辑。
 关闭按钮： 
// TipsPanel.cs
// 关闭按钮
closeBtn.onClick.AddListener(() =>
    Destroy(gameObject);
});
进度+1按钮： 
// TipsPanel.cs
private int m_taskChainId;
private int m_tasksubId;
private Action updateTaskDataCb;
// 进度+1
addProgressBtn.onClick.AddListener(() =>
    Destroy(gameObject);
    TaskLogic.instance.AddProgress(m_taskChainId, m_tasksubId, 1, (errorCode, finishTask) =>
        updateTaskDataCb();
    });
});
一键完成按钮： 
// TipsPanel.cs
// 一键完成
onekeyBtn.onClick.AddListener(() =>
    Destroy(gameObject);
    var cfg = TaskCfg.instance.GetCfgItem(m_taskChainId, m_tasksubId);
    TaskLogic.instance.AddProgress(m_taskChainId, m_tasksubId, cfg.target_amount, (errorCode, finishTask) =>
        updateTaskDataCb();
    });
});
同理，为了方便显示，也封装一个静态的Show方法： 
// TipsPanel.cs
private static GameObject s_tipsPanelPrefab;
// 显示任务界面
public static void Show(int chainId, int subId, Action cb)
	if (null == s_tipsPanelPrefab)
	    s_tipsPanelPrefab = Resources.Load<GameObject>("TipsPanel");
	var panelObj = Instantiate(s_tipsPanelPrefab);
	panelObj.transform.SetParent(GlobalObj.s_canvasTrans, false);
	var panelBhv = panelObj.GetComponent<TipsPanel>();
	panelBhv.Init(chainId, subId, cb);
public void Init(int chainId, int subId, Action cb)
   	m_taskChainId = chainId;
   	m_tasksubId = subId;
   	updateTaskDataCb = cb;
TaskItemUI.cs脚本的前往按钮补上TipsPanel.Show调用， 
// TaskItemUI.cs
goAheadBtn.onClick.AddListener(() =>
   TipsPanel.Show(data.task_chain_id, data.task_sub_id, () =>
       UpdateUI(data);
   });
});
4、奖励界面：AwardPanel.cs
 
在Scripts / View目录中创建AwardPanel.cs脚本，
 定义UI对象， 
public Text goldText;
public Button bgBtn;
private GameObject m_selfGo;
private void Awake()
    m_selfGo = gameObject;
把AwardPanel.cs脚本挂到AwardPanel预设跟节点上，赋值UI对象，
 
 逻辑很简单，显示金币奖励，加个1.5秒自动销毁，点击空白处销毁的逻辑，如下： 
// AwardPanel.cs
public void Init(string award)
    var jd = JsonMapper.ToObject(award);
    goldText.text = jd["gold"].ToString();
    bgBtn.onClick.AddListener(() =>
        SelfDestroy();
    });
    // 3秒后自动销毁
    Invoke("SelfDestroy", 1.5f);
private void Awake()
    m_selfGo = gameObject;
private void SelfDestroy()
    if (null != m_selfGo)
        Destroy(m_selfGo);
        m_selfGo = null;
也封装一个静态的Show方法， 
private static GameObject s_awardPanelPrefab;
/// <summary>
/// 显示奖励界面
/// </summary>
public static void Show(string award)
    if (null == s_awardPanelPrefab)
        s_awardPanelPrefab = Resources.Load<GameObject>("AwardPanel");
    var panelObj = Instantiate(s_awardPanelPrefab);
    panelObj.transform.SetParent(GlobalObj.s_canvasTrans, false);
    var panelBhv = panelObj.GetComponent<AwardPanel>();
    panelBhv.Init(award);
TaskItemUI.cs脚本的领奖按钮补上AwardPanel.Show调用， 
// TaskItemUI.cs
getAwardBtn.onClick.AddListener(() =>
    TaskLogic.instance.GetAward(data.task_chain_id, data.task_sub_id, (errorCode, award) => 
        Debug.Log("errorCode： " + errorCode + ", award: " + award);
        if(0 == errorCode)
            AwardPanel.Show(award);
            updateListCb();
    });
});
5、精灵资源管理器
 
我们需要根据任务配置来显示任务的图标，封装一个精灵管理器。
  
在Scripts / View目录中创建一个SpriteManager.cs脚本，
 代码如下： 
// SpriteManager.cs
using System.Collections.Generic;
using UnityEngine;
public class SpriteManager
    /// <summary>
    /// 根据名字加载精灵资源
    /// </summary>
    public Sprite GetSprite(string name)
        if (m_sprites.ContainsKey(name))
            return m_sprites[name];
        var sprite = Resources.Load<Sprite>("Sprites/" + name);
        m_sprites.Add(name, sprite);
        return sprite;
    private Dictionary<string, Sprite> m_sprites = new Dictionary<string, Sprite>();
    private static SpriteManager s_instance;
    public static SpriteManager instance
            if (null == s_instance)
                s_instance = new SpriteManager();
            return s_instance;
回到TaskItemUI.cs脚本中，补上精灵设置的调用： 
// TaskItemUI.cs
public void UpdateUI(TaskDataItem data)
	// ...
	// 图标
	icon.sprite = SpriteManager.instance.GetSprite(cfg.icon);
	// 主线/支线标记
	var taskTypeSpriteName = 1 == cfg.task_chain_id ? "zhu" : "zhi";
	taskType.sprite = SpriteManager.instance.GetSprite(taskTypeSpriteName);
这样就可以根据配置显示不同的图标了，
  
十一、运行测试
 
代码写完了，一切就绪，运行Unity，测试效果如下：
 
 
 人生如梦，究竟是要选梦醒来还是继续做梦呢？
  
十二、工程源码
 
本文的工程我一上传到GitCode，感兴趣的同学可以自行下载下来学习。
 工程地址：https://gitcode.net/linxinfa/UnityChainTaskDemo
 注：我的Unity版本是Unity 2020.1.14f1c1 (64-bit)
  
十三、完毕
 
好了，写得有点多了，就写到这里吧~
 人生如梦，祝大家都能走上人生巅峰~
 我是林新发：https://blog.csdn.net/linxinfa
 原创不易，若转载请注明出处，感谢大家~
 喜欢我的可以点赞、关注、收藏，如果有什么技术上的疑问，欢迎留言或私信，拜拜~
					Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！想进粉丝福利群及免费送书群，直接私信我拉你。交流学习、商务合作：https://bbs.csdn.net/topics/614347534
					01-21
创建任务类：创建一个任务类来描述任务的基本信息，如任务名称、任务描述、任务奖励等。
创建任务管理器：创建一个任务管理器来管理所有任务。任务管理器可以通过单例模式来实现。
添加任务：在任务管理器中添加任务，并将任务状态设置为未完成。
完成任务：当任务条件达成时，将任务状态设置为完成。
领取奖励：完成任务后，可以领取任务奖励。奖励可以是游戏内物品、金...
				一年多没写博了，因为迫不得已转行，这破游戏也搁置了好久，过完年也有一个月了，回来找找感觉。那就记录一下任务系统的开发吧，方便以后回忆。
任务系统是每个RPG游戏的核心，很大程度上它支撑着RPG的剧情以及角色的互动等方面的内容。
作为一个单机，任务系统用的当然是C#的委托和事件来写了，如果大家有更好的实现方法，那就当看个思路吧（虽然我的思路也不咋地）。
因为任务系统往往伴随着任务报酬，例如给一...
				玩过游戏的朋友都知道，市面上最常见的游戏多数分为2D和3D两种。
2D和3D游戏之间的差异大家都知道，一个是类似纸片游戏属于二维层面，另一个则是在3D立体空间中游玩。
其中还夹杂着一个2.5D游戏，本篇文章就来讲一下怎么通过Unity进行2.5D游戏是怎样的以及如何制作2.5D游戏。
制作方法很简单，文中使用到了Tile Map Editor制作2D地图，通过控制相机角度来形成伪3D来制作2.5D效果的游戏。
下面就一起来看看到底是怎样制作的吧！
				1.任务管理类与任务类是一对一的关系，而任务管理类与其他类是一对多的关系。对于一对多，比较容易想到的就是观察者模式了。在观察者模式中，是观察者决定要监视的东西，而不是事件的发生者决定谁观察它。
2.对于任务类/任务条件类/任务奖励类来说，有逻辑意义上的，也有界面意义上的，因此要分开处理。
这里给出主要的逻辑代码：
using System.Collections;
using Sys
				参考 ： “海游移动” 博客http://jxwgame.blog.51cto.com/943299/1602630
先考虑需求
 在任何时候，我需要能够通过new创建一个任务（完成事件，获得奖励），任务自动开始运行 ，并且自动判断运行状态，是否完成等。	我们要做的，只是创建这个任务，并赋一些完成条件。
 所以任务类（Class MyTask） 必须是脱离于Mono的独立类。并且有一些对...
				转载来源：https://blog.csdn.net/martins19
这段时间比较闲，所以抽时间写了游戏中常见的系统，任务系统，可以接受任务啊，然后通过刷怪等条件去触发任务条件，直到完成任务。
这个系统相对来说比较的简单，可以满足小型的游戏任务系统的基本要求吧！这里面的任务的描述是通过读取Json数据来获取的，当然你也可以去写Excel和XML格式的。序列化Json数据不是用的Unity自带...
先搭建好ui，需要的内容大概是一个横版，然后创建一个scrow view，使用其中的vertical，创建一个任务物体（里面存放单个任务的ui，如框，文字等），保存为一个预制体放在resources文件里方便后期通过代码自动生成，从而做出简单的任务列表
数据库准备
需要在数据库中添加一个用户表和一个任务表，两者用一个id进行绑定，我这里是用的missionId进行多表查询。这里可以看表设计相关的知识，篇幅和时间有限就不多讲了，任务表
				之前分享过一个游戏引导教程的插件Tutorial Master2的文章：Unity 实用插件篇 | Tutorial Master 2 游戏引导教程 快速上手
本篇文章就拿该插件为一个小游戏制作一个简单的游戏引导实战案例。
一起来看看该插件在实际游戏中的使用效果如何吧！
                【游戏开发实战】Unity使用Socket通信实现简单的多人聊天室（万字详解 | 网络 | TCP | 通信 | Mirror | Networking）
                    m0_46279112: 
                    webgl不支持socket，要使用unitywebrequest
                【游戏开发教程】Unity Cinemachine快速上手，详细案例讲解（虚拟相机系统 | 新发出品 | 良心教程）
                    Panbigda: 
                    BossCam场景是如何实现的啊？
                【游戏开发探究】Unity Addressables资源管理方式用起来太爽了，资源打包、加载、热更变得如此轻松（Addressable Asset System | 简称AA）
                    Saxoviva: 
                    质量非常高的文章，感谢up的分享
                Unity使用tolua框架教程: LuaFramewrk
                    不知道来自哪个星球: 
                    你好。想请教下，tolua.dll是你自己编译生成的吗？我使用github源码生成的dll，在项目里无法使用，请问有什么思路吗？