抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

任务系统

Unity工具

发布于：2023年11月7日

次浏览

字数：3.2k 字

时长：17 分钟

简介

基于任务树的任务系统，支持普通任务、分支任务，一个系列任务以树的形式保存。任务支持多需求、多奖励。任务进度支持任务开启后统计和预统计。

后续会更新其他功能。

演示

原理

任务管理类设置三个字典_lockedMission、_unlockedMission、_doneMission来保存未解锁任务，已解锁任务和已完成任务。

任务数据结构

任务树自身与之间的结构如图所示。

不同任务以树的形式链接，单个任务以链表的形式链接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
using System.Collections.Generic;
using UnityEngine;

public class MissionTree
{
    /// <summary>
    /// 任务步骤id
    /// </summary>
    public int id { get; set; }
    /// <summary>
    /// 任务id
    /// </summary>
    public int m_id { get; set; }
    /// <summary>
    /// 任务标题
    /// </summary>
    public string title { get; set; }
    /// <summary>
    /// 任务描述
    /// </summary>
    public string describe { get; set; }
    /// <summary>
    /// 任务类型
    /// </summary>
    public MissionType type { get; set; }
    /// <summary>
    /// 任务类别
    /// </summary>
    public MissionFilter filter { get; set; }
    /// <summary>
    /// 任务目标
    /// </summary>
    public List<int> target { get; set; }
    /// <summary>
    /// 任务目标描述
    /// </summary>
    public List<string> target_describe { get; set; }
    /// <summary>
    /// 任务目标数量
    /// </summary>
    public Dictionary<int, float> target_num { get; set; }
    /// <summary>
    /// 任务完成数量
    /// </summary>
    public Dictionary<int, float> complete_num { get; set; }
    /// <summary>
    /// 任务奖励
    /// </summary>
    public List<string> award { get; set; }
    /// <summary>
    /// 任务奖励数量
    /// </summary>
    public List<float> award_num { get; set; }
    /// <summary>
    /// 是否预统计
    /// </summary>
    public bool is_pre_count { get; set; }
    /// <summary>
    /// 下一任务
    /// </summary>
    public MissionTree next { get; set; }
    /// <summary>
    /// 任务解锁列表
    /// </summary>
    public List<int> unlock_mission { get; set; }
    /// <summary>
    /// 任务分支
    /// </summary>
    public List<int> branch { get; set; }
    /// <summary>
    /// 分支所属任务
    /// </summary>
    public int branch_belong { get; set; }
    /// <summary>
    /// 是否直接解锁
    /// </summary>
    public bool is_pre_unlock { get; set; }

    public MissionTree()
    {
        target = new List<int>();
        target_num = new Dictionary<int, float>();
        complete_num = new Dictionary<int, float>();
        award = new List<string>();
        award_num = new List<float>();
        unlock_mission = new List<int>();
        target_describe = new List<string>();
        branch = new List<int>();
    }
}

判断任务完成

判断任务完成需要判断所有的任务目标完成数量是否都大于等于任务目标需求数量。这里我们遍历任务目标，只要有一个目标数量不达标就可以判断任务未完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// <summary>
/// 检测任务是否完成
/// </summary>
/// <param name="missionId"></param>
/// <returns></returns>
public bool CheckComplete(MissionTree mission)
{
    for (int i = 0, len = mission.target.Count; i < len; i++)
    {
        int target = mission.target[i];
        if (mission.is_pre_count)
        {
            if (mission.target_num[target] > _preCount[target])
            {
                return false;
            }
        }
        else
        {
            if (mission.complete_num.Count == 0 || mission.target_num[target] > mission.complete_num[target])
            {
                return false;
            }
        }
    }
    return true;
}

增加任务目标数量

任务目标数量的增加调用SetCompleteNum方法，默认是累加模式。预统计数量的增加则是通过RefreshPreCountNum方法保存数据到_preCount字典中，以供预统计类型任务使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/// <summary>
/// 刷新预计数类型任务的完成数量
/// </summary>
/// <param name="targetId"></param>
/// <param name="num"></param>
public void RefreshPreCountNum(int targetId, float num, bool isAdd = false)
{
    if (!_preCount.ContainsKey(targetId))
    {
        _preCount.Add(targetId, 0);
    }
    if (isAdd)
    {
        _preCount[targetId] += num;
    }
    else
    {
        _preCount[targetId] = num;
    }
}

/// <summary>
/// 设置任务完成数量
/// </summary>
/// <param name="missionId"></param>
/// <param name="completeNum"></param>
/// <param name="isAdd"></param>
public void SetCompleteNum(int missionId, int targetId, float completeNum, bool isAdd = true)
{
    MissionTree mission;
    _unlockedMission.TryGetValue(missionId, out mission);
    if (mission != null)
    {
        if (!mission.complete_num.ContainsKey(targetId))
        {
            mission.complete_num.Add(targetId, 0);
        }
        if (isAdd)
        {
            mission.complete_num[targetId] += completeNum;
        }
        else
        {
            mission.complete_num[targetId] = completeNum;
        }
        //保存数据
        SaveMissionData(missionId, mission.id, mission.complete_num, false);
    }
}

下一任务

任务完成的时候除了推进本任务链的任务以外，还要检测是否有可以解锁的任务，可以解锁则把其从_lockedMission转移到_unlockedMission，任务链完成则转移到_doneMission。在完成任务的时候，调用奖励方法来发放奖励。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public void Next(MissionTree mission)
{
    //MissionTree mission = _unlockedMission[missionId];
    int missionId = mission.m_id;
    MissionTree next = mission.next;
    if (next != null)
    {
        if (mission.unlock_mission.Count > 0)
        {
            for (int i = 0, len = mission.unlock_mission.Count; i < len; i++)
            {
                int id = mission.unlock_mission[i];
                MissionTree unlockMission = _lockedMission[id];
                _unlockedMission.Add(unlockMission.m_id, unlockMission);
                _lockedMission.Remove(id);
                //保存数据
                SaveMissionData(id, unlockMission.id, unlockMission.complete_num, false);
            }
        }
        //下一任务
        _unlockedMission[missionId] = next;
        //保存数据
        SaveMissionData(missionId, next.id, next.complete_num, false);
    }
    else
    {
        _unlockedMission.Remove(missionId);
        _doneMission.Add(missionId, mission);
        //保存数据
        SaveMissionData(missionId, mission.id, mission.complete_num, true);
    }

    //获得奖励
    GetAward(mission);

    if (mission.filter == MissionFilter.Branch)
    {
        bool missionDone = true;
        foreach (var id in mission.branch)
        {
            MissionTree branch = GetUnlockedMissionById(id);
            if (mission != null)
            {
                missionDone = false;
                break;
            }
        }
        if (!missionDone)
        {
            Next(GetUnlockedMissionById(mission.branch_belong));
        }
    }
}

UI

因为任务面板 UI 是简单拼凑，因此在此不做介绍。有关任务面板滚动列表的说明见滚动列表

代码

MissionTree
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
using System.Collections.Generic;
using UnityEngine;

public class MissionTree
{
    /// <summary>
    /// 任务步骤id
    /// </summary>
    public int id { get; set; }
    /// <summary>
    /// 任务id
    /// </summary>
    public int m_id { get; set; }
    /// <summary>
    /// 任务标题
    /// </summary>
    public string title { get; set; }
    /// <summary>
    /// 任务描述
    /// </summary>
    public string describe { get; set; }
    /// <summary>
    /// 任务类型
    /// </summary>
    public MissionType type { get; set; }
    /// <summary>
    /// 任务类别
    /// </summary>
    public MissionFilter filter { get; set; }
    /// <summary>
    /// 任务目标
    /// </summary>
    public List<int> target { get; set; }
    /// <summary>
    /// 任务目标描述
    /// </summary>
    public List<string> target_describe { get; set; }
    /// <summary>
    /// 任务目标数量
    /// </summary>
    public Dictionary<int, float> target_num { get; set; }
    /// <summary>
    /// 任务完成数量
    /// </summary>
    public Dictionary<int, float> complete_num { get; set; }
    /// <summary>
    /// 任务奖励
    /// </summary>
    public List<string> award { get; set; }
    /// <summary>
    /// 任务奖励数量
    /// </summary>
    public List<float> award_num { get; set; }
    /// <summary>
    /// 是否预统计
    /// </summary>
    public bool is_pre_count { get; set; }
    /// <summary>
    /// 下一任务
    /// </summary>
    public MissionTree next { get; set; }
    /// <summary>
    /// 任务解锁列表
    /// </summary>
    public List<int> unlock_mission { get; set; }
    /// <summary>
    /// 任务分支
    /// </summary>
    public List<int> branch { get; set; }
    /// <summary>
    /// 分支所属任务
    /// </summary>
    public int branch_belong { get; set; }
    /// <summary>
    /// 是否直接解锁
    /// </summary>
    public bool is_pre_unlock { get; set; }

    public MissionTree()
    {
        target = new List<int>();
        target_num = new Dictionary<int, float>();
        complete_num = new Dictionary<int, float>();
        award = new List<string>();
        award_num = new List<float>();
        unlock_mission = new List<int>();
        target_describe = new List<string>();
        branch = new List<int>();
    }
}
MissionManager
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using UnityEngine;

public enum MissionType
{
    Find,
    Collection,
    Kill
}

public enum MissionFilter
{
    Main,
    Sub,
    Branch//这个类型一定放最后 因为该类型不参与计算，枚举数不能影响计算
}

/// <summary>
/// 任务管理器
/// <para>请在预统计物品数量（即背包、杀人数等）加载之前加载本类，并且在预统计物品数量加载时执行RefreshPreCountNum方法</para>
/// </summary>
public class MissionManager
{
    private static MissionManager instance;

    private Dictionary<int, MissionTree> _lockedMission = new Dictionary<int, MissionTree>();

    private Dictionary<int, MissionTree> _unlockedMission = new Dictionary<int, MissionTree>();

    private Dictionary<int, MissionTree> _doneMission = new Dictionary<int, MissionTree>();

    private Dictionary<int, MissionSaveData> _missionSaveData = new Dictionary<int, MissionSaveData>();

    private Dictionary<int, float> _preCount = new Dictionary<int, float>();

    private MissionTree _curMission;

    public static MissionManager Instance()
    {
        if (instance == null)
        {
            instance = new MissionManager();
        }
        return instance;
    }

    private MissionManager() { }

    /// <summary>
    /// 加载存档
    /// </summary>
    /// <param name="save"></param>
    public void LoadSaveData(MissionSaveDataSO save)
    {
        for (int i = 0, len = save._missionSaveDatas.Count; i < len; i++)
        {
            MissionSaveData missionSaveData = save._missionSaveDatas[i];
            _missionSaveData.Add(missionSaveData.m_id, missionSaveData);
        }
    }

    public void Init()
    {
        //硬编码数据
        List<MissionTree> missions = new List<MissionTree>();

        MissionTree m1 = new MissionTree();
        m1.id = 0;
        m1.m_id = 0;
        m1.title = "任务1-1";
        m1.describe = "任务1-1的任务描述\n测试换行";
        m1.type = MissionType.Collection;
        m1.filter = MissionFilter.Main;
        m1.is_pre_count = true;
        m1.target.Add(0);
        m1.target_describe.Add("收集id=0的物品");
        m1.target_num.Add(0, 2);
        m1.award.Add("奖励1");
        m1.award_num.Add(1);
        m1.is_pre_unlock = true;

        MissionTree m2 = new MissionTree();
        m2.id = 1;
        m2.m_id = 0;
        m2.title = "任务1-2";
        m2.describe = "任务1-2的任务描述";
        m2.type = MissionType.Collection;
        m2.filter = MissionFilter.Main;
        m2.is_pre_count = false;
        m2.target.Add(0);
        m2.target_describe.Add("收集id=0的物品");
        m2.target_num.Add(0, 2);
        //m2.award.Add("奖励1");
        //m2.award_num.Add(1);

        m1.next = m2;

        MissionTree m3 = new MissionTree();
        m3.id = 0;
        m3.m_id = 1;
        m3.title = "任务2-1";
        m3.describe = "任务2-1的任务描述";
        m3.type = MissionType.Collection;
        m3.filter = MissionFilter.Sub;
        m3.is_pre_count = false;
        m3.target.Add(0);
        m3.target_describe.Add("收集id=0的物品");
        m3.target_num.Add(0, 2);
        m3.award.Add("奖励1");
        m3.award_num.Add(1);
        //m3.is_pre_unlock = true;


        MissionTree m4 = new MissionTree();
        m4.id = 0;
        m4.m_id = 2;
        m4.title = "任务3-1";
        m4.describe = "任务3-1的任务描述";
        m4.type = MissionType.Collection;
        m4.filter = MissionFilter.Branch;
        m4.is_pre_count = false;
        m4.target.Add(0);
        m4.target_describe.Add("收集id=0的物品");
        m4.target_num.Add(0, 2);
        m4.award.Add("奖励1");
        m4.award_num.Add(1);
        m4.is_pre_unlock = true;
        m4.branch_belong = 0;

        MissionTree m5 = new MissionTree();
        m5.id = 0;
        m5.m_id = 3;
        m5.title = "任务4-1";
        m5.describe = "任务4-1的任务描述";
        m5.type = MissionType.Collection;
        m5.filter = MissionFilter.Branch;
        m5.is_pre_count = false;
        m5.target.Add(0);
        m5.target_describe.Add("收集id=0的物品");
        m5.target_num.Add(0, 2);
        m5.award.Add("奖励1");
        m5.award_num.Add(1);
        m5.is_pre_unlock = true;
        m5.branch_belong = 0;

        m1.unlock_mission.Add(1);
        m2.branch.Add(2);
        m2.branch.Add(3);

        missions.Add(m1);
        missions.Add(m3);
        missions.Add(m4);
        missions.Add(m5);

        //初始化
        for (int i = 0, len = missions.Count; i < len; i++)
        {
            MissionTree mission = missions[i];
            MissionSaveData missionSaveData;

            _missionSaveData.TryGetValue(mission.m_id, out missionSaveData);

            if (missionSaveData != null)
            {
                if (missionSaveData.isDone)
                {
                    _doneMission.Add(mission.m_id, mission);
                }
                else
                {
                    while (mission.id != missionSaveData.id)
                    {
                        mission = mission.next;
                    }
                    _unlockedMission.Add(mission.m_id, mission);
                    mission.complete_num = missionSaveData.complete_num;
                }
            }
            else
            {
                if (mission.is_pre_unlock)
                {
                    _unlockedMission.Add(mission.m_id, mission);
                }
                else
                {
                    _lockedMission.Add(mission.m_id, mission);
                }
            }
        }
    }

    public MissionTree GetCurMission()
    {
        return _curMission;
    }

    public Dictionary<int, MissionTree> GetUnlockedMission()
    {
        return _unlockedMission;
    }

    public Dictionary<int, MissionTree> GetDoneMission()
    {
        return _doneMission;
    }

    public MissionTree GetUnlockedMissionById(int id)
    {
        MissionTree missionTree;
        _unlockedMission.TryGetValue(id, out missionTree);
        return missionTree;
    }

    /// <summary>
    /// 获得任务筛选类型文字描述
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public string GetMissionFilterString(MissionFilter type)
    {
        switch (type)
        {
            case MissionFilter.Main:
            default:
                return "主线";
            case MissionFilter.Sub:
                return "支线";
        }
    }

    /// <summary>
    /// 获得任务筛选类型
    /// </summary>
    /// <param name="filter"></param>
    /// <returns></returns>
    public MissionFilter GetMissionFileter(string filter)
    {
        switch (filter)
        {
            case "主线":
            default:
                return MissionFilter.Main;
            case "支线":
                return MissionFilter.Sub;
        }
    }

    /// <summary>
    /// 刷新预统计类型任务的完成数量
    /// </summary>
    /// <param name="targetId"></param>
    /// <param name="num"></param>
    public void RefreshPreCountNum(int targetId, float num, bool isAdd = false)
    {
        if (!_preCount.ContainsKey(targetId))
        {
            _preCount.Add(targetId, 0);
        }
        if (isAdd)
        {
            _preCount[targetId] += num;
        }
        else
        {
            _preCount[targetId] = num;
        }
    }

    /// <summary>
    /// 获得预统计数量
    /// </summary>
    /// <param name="targetId"></param>
    /// <returns></returns>
    public float GetPreCountNum(int targetId)
    {
        return _preCount[targetId];
    }

    /// <summary>
    /// 设置任务完成数量
    /// </summary>
    /// <param name="missionId"></param>
    /// <param name="completeNum"></param>
    /// <param name="isAdd"></param>
    public void SetCompleteNum(int missionId, int targetId, float completeNum, bool isAdd = true)
    {
        MissionTree mission;
        _unlockedMission.TryGetValue(missionId, out mission);
        if (mission != null)
        {
            if (!mission.complete_num.ContainsKey(targetId))
            {
                mission.complete_num.Add(targetId, 0);
            }
            if (isAdd)
            {
                mission.complete_num[targetId] += completeNum;
            }
            else
            {
                mission.complete_num[targetId] = completeNum;
            }
            //保存数据
            SaveMissionData(missionId, mission.id, mission.complete_num, false);
        }
    }

    /// <summary>
    /// 检测任务是否完成
    /// </summary>
    /// <param name="missionId"></param>
    /// <returns></returns>
    public bool CheckComplete(MissionTree mission)
    {
        for (int i = 0, len = mission.target.Count; i < len; i++)
        {
            int target = mission.target[i];
            if (mission.is_pre_count)
            {
                if (mission.target_num[target] > _preCount[target])
                {
                    return false;
                }
            }
            else
            {
                if (mission.complete_num.Count == 0 || mission.target_num[target] > mission.complete_num[target])
                {
                    return false;
                }
            }
        }
        return true;
    }

    public void Next(MissionTree mission)
    {
        //MissionTree mission = _unlockedMission[missionId];
        int missionId = mission.m_id;
        MissionTree next = mission.next;
        if (next != null)
        {
            if (mission.unlock_mission.Count > 0)
            {
                for (int i = 0, len = mission.unlock_mission.Count; i < len; i++)
                {
                    int id = mission.unlock_mission[i];
                    MissionTree unlockMission = _lockedMission[id];
                    _unlockedMission.Add(unlockMission.m_id, unlockMission);
                    _lockedMission.Remove(id);
                    //保存数据
                    SaveMissionData(id, unlockMission.id, unlockMission.complete_num, false);
                }
            }
            //下一任务
            _unlockedMission[missionId] = next;
            //保存数据
            SaveMissionData(missionId, next.id, next.complete_num, false);
        }
        else
        {
            _unlockedMission.Remove(missionId);
            _doneMission.Add(missionId, mission);
            //保存数据
            SaveMissionData(missionId, mission.id, mission.complete_num, true);
        }

        //获得奖励
        GetAward(mission);

        if (mission.filter == MissionFilter.Branch)
        {
            MissionTree branchMissionRoot = GetUnlockedMissionById(mission.branch_belong);
            bool missionDone = true;
            foreach (var id in branchMissionRoot.branch)
            {
                MissionTree branch = GetUnlockedMissionById(id);
                if (branch != null)
                {
                    missionDone = false;
                    break;
                }
            }
            if (missionDone)
            {
                Next(branchMissionRoot);
            }
        }
    }

    private void GetAward(MissionTree mission)
    {
        string award = "";
        for (int i = 0, len = mission.award.Count; i < len; i++)
        {
            award += mission.award[i] + " 数量:" + mission.award_num[i];
        }
        Debug.Log("获得任务奖励 ===> " + award);
    }

    private void SaveMissionData(int missionId, int stepId, Dictionary<int, float> completeNum, bool isDone)
    {

        //保存数据
        MissionSaveData missionSaveData;
        _missionSaveData.TryGetValue(missionId, out missionSaveData);
        if (missionSaveData == null)
        {
            missionSaveData = new MissionSaveData();
            missionSaveData.m_id = missionId;
            _missionSaveData.Add(missionId, missionSaveData);
        }

        missionSaveData.id = stepId;
        missionSaveData.complete_num = completeNum;
        missionSaveData.isDone = isDone;
    }
}

更新日志

2023-12-12

  1. 修复分支任务判定 bug。

2023-11-7

1.更新基础版本

更新于：2024年9月18日

C#

工具类

系统架构

Unity

评论