1. 项目概述与核心价值

在上一篇文章里，我们花了大量篇幅把对话系统的里里外外都拆解了一遍，从配置表设计到UI状态机，再到事件驱动的流程控制。今天，我们终于要进入这个系列最核心、也是最能体现游戏“玩法”的部分——任务系统的实现。

一个设计精良的任务系统，绝不仅仅是给玩家一个“去A点杀10只怪”的清单。它应该是驱动游戏叙事、引导玩家探索、反馈成长进度的核心骨架。我见过太多项目，初期用几个布尔变量和枚举硬编码任务逻辑，结果随着内容膨胀，代码迅速变成一团乱麻，添加一个新任务类型堪比重构。所以，这次我们不谈空中楼阁，直接落地一套可扩展、数据驱动、易于策划配置的任务系统基础架构。这套架构的目标是：让策划能通过配置表自由设计复杂的任务链、多目标、条件分支和奖励，而程序只需要维护一套稳定的执行引擎。

简单来说，我们要实现的是一个“任务收集器”。它持续监听游戏世界中的各种事件（如击杀怪物、拾取物品、到达地点、与NPC对话），并根据当前激活的任务配置，判断这些事件是否匹配某个任务目标，进而驱动任务状态的流转。整个过程应该是自动化的、解耦的，任务逻辑不散落在游戏各个角落。下面，我们就从最核心的数据结构开始，一步步把它搭建起来。

2. 任务系统核心数据结构设计

任务系统的健壮性，一半取决于其数据模型的设计。我们的目标是设计出既能表达简单“跑腿”任务，也能支撑“收集A、B、C任意两样，并在雨天到达D地点”这种复杂多条件任务的配置结构。

2.1 多层次任务数据模型

参考成熟的游戏设计，我们将一个任务分解为四个层次：任务概要（Task）、任务目标（Objective）、完成条件（Condition）和奖励（Reward）。这种分层解耦了任务逻辑，让每个部分都可以独立配置和扩展。

首先是最顶层的TaskData，它定义了一个任务的元信息。

[Serializable] public class TaskData { public int taskId; // 任务唯一ID public string taskName; // 任务名称（用于UI显示） public string description; // 任务描述 public string icon; // 任务图标资源路径 public TaskType taskType; // 任务类型：主线、支线、日常等 public TaskState initialState; // 初始状态：通常为NotStarted public int nextTaskId; // 后续任务ID，用于任务链 public List<int> prerequisiteTaskIds; // 前置任务ID列表 public List<TaskObjective> objectives; // 任务目标列表 public List<TaskReward> rewards; // 任务奖励列表 public string startDialogueGroupId; // 接取任务时的对话组ID public string completeDialogueGroupId; // 提交任务时的对话组ID }

这里有几个关键点：prerequisiteTaskIds支持任务链和依赖关系；objectives是一个列表，意味着一个任务可以包含多个并行或顺序的目标；startDialogueGroupId和completeDialogueGroupId直接与上一篇文章的对话系统挂钩，实现了叙事与玩法的无缝衔接。

接下来是TaskObjective，它描述了一个具体的、可追踪的目标单元。

[Serializable] public class TaskObjective { public int objectiveId; // 目标唯一ID（在任务内唯一即可） public string description; // 目标描述（如“击败骷髅士兵：0/5”） public ObjectiveType type; // 目标类型：击杀、收集、到达、对话等 public string target; // 目标对象标识（如怪物ID“Enemy_Skeleton”、物品ID“Item_Herb”） public int requiredAmount; // 需要完成的数量 public int currentAmount; // 当前已完成数量（运行时状态） public bool isOptional; // 是否为可选目标（不影响任务完成） public List<TaskCondition> conditions; // 完成此目标需满足的额外条件列表 }

ObjectiveType枚举定义了系统能识别的所有目标类型，这是任务收集器能够正确监听事件的关键。conditions字段是灵活性的关键，它允许我们为一个“击杀骷髅士兵”的目标附加“必须在夜晚”或“必须使用火焰武器”等条件。

TaskCondition结构用于定义这些额外的、可能非常复杂的条件。

[Serializable] public class TaskCondition { public ConditionType type; // 条件类型：时间、天气、装备、状态等 public string param1; // 参数1（如“Night”， “Rainy”） public string param2; // 参数2（如比较运算符“>=”， 数值“5”） public string param3; // 参数3（备用） }

例如，一个条件可以是type=ConditionType.TimeOfDay, param1="Night"，表示仅在夜晚有效。条件评估是一个独立的系统，我们稍后会详细讲。

最后是TaskReward，定义任务完成后的反馈。

[Serializable] public class TaskReward { public RewardType type; // 奖励类型：经验、金币、物品、装备、解锁内容 public string rewardId; // 奖励标识（如物品ID“Item_Gold_Coin”） public int amount; // 奖励数量 public float probability; // 概率（用于随机奖励） }

2.2 任务状态枚举与运行时数据

有了静态配置，我们还需要定义任务的动态生命周期，即TaskState。

public enum TaskState { NotStarted, // 未开始（未达到接取条件） Available, // 可接取（前置任务已完成，玩家可主动接取） InProgress, // 进行中（已接取，目标未全部完成） ReadyToComplete, // 可完成（所有必需目标已完成，等待提交） Completed, // 已完成（已提交并领取奖励） Failed // 已失败（可能因时间耗尽或条件无法满足） }

ReadyToComplete是一个非常重要的中间状态。它明确区分了“目标达成”和“任务完结”。这给了玩家一个缓冲期，他们可以继续探索或准备后再去提交任务，也为设计“提交任务前发生意外”的剧情留下了空间。

任务在运行时的状态需要被持久化。我们定义一个轻量的TaskRuntimeData来记录进度。

public class TaskRuntimeData { public int taskId; public TaskState currentState; public Dictionary<int, int> objectiveProgress; // key: objectiveId, value: currentAmount public bool isTracked; // 是否在UI中被玩家追踪 public DateTime acceptTime; // 接取时间（用于限时任务） }

这里使用Dictionary来记录每个目标的当前进度，比在TaskObjective列表里直接修改更清晰，也便于序列化存储。isTracked字段让玩家可以自由选择在任务列表中高亮显示哪些任务。

2.3 配置表示例与解析

让我们看一个综合性的配置表示例，它描述了一个经典的新手村任务：“老兵的试炼”。

TaskData表：

TaskObjective表：

TaskReward表：

这个任务要求玩家击杀5只狼并收集3个狼牙（通常掉落获得）。完成后奖励经验、一把铜剑和金币。配置表通过ID关联，清晰地将任务、目标、奖励联系在一起。策划只需要在Excel或Google Sheets中填充这些表格，通过我们编写的编辑器工具导出为JSON或ScriptableObject，游戏运行时加载即可。

注意：在设计配置表时，务必保持ID的唯一性和稳定性。任务ID、目标ID最好划分号段（如任务1000-1999，目标2000-2999），避免后续添加内容时产生冲突。同时，target字段的字符串（如“Enemy_Wolf”）必须与游戏中实际的怪物标识符完全一致，这是事件匹配的基础。

3. 核心管理器：任务收集器与状态引擎

数据模型建立后，我们需要一个强大的“大脑”来驱动它，这就是TaskManager。它的核心职责是：管理所有任务的生命周期、监听游戏事件、更新任务进度、处理任务状态的流转。

3.1 任务管理器的初始化与任务池

TaskManager应该是一个单例，在游戏启动时初始化，并加载所有任务配置。

public class TaskManager : MonoSingleton<TaskManager> { private Dictionary<int, TaskData> _allTaskData = new Dictionary<int, TaskData>(); private Dictionary<int, TaskRuntimeData> _activeRuntimeData = new Dictionary<int, TaskRuntimeData>(); public event Action<TaskRuntimeData> OnTaskProgressUpdated; public event Action<TaskRuntimeData> OnTaskStateChanged; public async ETTask Init(string taskDataPath) { // 1. 加载所有TaskData配置 var configText = await Resources.LoadAsync<TextAsset>(taskDataPath) as TextAsset; var taskList = JsonUtility.FromJson<TaskDataList>(configText.text); foreach (var task in taskList.tasks) { _allTaskData[task.taskId] = task; } // 2. 加载玩家存档中的任务进度 LoadRuntimeDataFromSave(); // 3. 初始化事件监听 InitializeEventListeners(); // 4. 根据加载的进度，重新计算所有任务的状态（特别是Available状态） RefreshAllTaskStates(); } private void InitializeEventListeners() { // 订阅游戏内各种可能影响任务的事件 UniEvent.AddListener<EnemyKilledEvent>(OnEnemyKilled); UniEvent.AddListener<ItemCollectedEvent>(OnItemCollected); UniEvent.AddListener<LocationReachedEvent>(OnLocationReached); UniEvent.AddListener<DialogueCompletedEvent>(OnDialogueCompleted); // ... 订阅其他事件 } }

这里使用字典来存储数据，便于通过ID快速查找。事件总线的使用（如UniEvent）是实现系统间解耦的关键。任务管理器只关心“发生了什么事件”，而不需要知道是哪个系统发出的。

3.2 任务收集器：事件驱动的进度更新

“收集器”模式的精髓在于OnEnemyKilled、OnItemCollected这类事件处理方法。它们像过滤器一样，检查每一个发生的事件是否对当前进行中的任务有意义。

private void OnEnemyKilled(EnemyKilledEvent e) { // 遍历所有进行中(InProgress)的任务 foreach (var runtimeData in _activeRuntimeData.Values.Where(rd => rd.currentState == TaskState.InProgress)) { var taskData = _allTaskData[runtimeData.taskId]; // 遍历该任务的所有目标 foreach (var objective in taskData.objectives) { // 检查目标类型是否为击杀，且目标标识匹配 if (objective.type == ObjectiveType.Kill && objective.target == e.EnemyId) { // 检查额外条件是否满足（如时间、天气） if (EvaluateConditions(objective.conditions)) { // 更新该目标的进度 int currentProgress = runtimeData.objectiveProgress.GetValueOrDefault(objective.objectiveId, 0); currentProgress++; runtimeData.objectiveProgress[objective.objectiveId] = currentProgress; // 通知UI更新 OnTaskProgressUpdated?.Invoke(runtimeData); // 检查该目标是否完成，以及整个任务状态是否需要变更 CheckObjectiveCompletion(objective, runtimeData); CheckTaskCompletion(runtimeData); } } } } }

这段代码是任务系统的“心脏”。它高效地完成了以下工作：1）过滤无关任务；2）精确匹配事件与目标；3）评估复杂条件；4）更新进度；5）触发状态检查。EvaluateConditions方法会遍历目标的conditions列表，调用对应的条件评估器，只有全部返回true，这次击杀才被计入进度。

3.3 任务状态流转与自动推进

任务的各个状态不是孤立的，它们构成一个严格的状态机。CheckTaskCompletion方法负责在进度更新后，驱动状态向前流转。

private void CheckTaskCompletion(TaskRuntimeData runtimeData) { var taskData = _allTaskData[runtimeData.taskId]; bool allRequiredObjectivesComplete = true; bool anyOptionalObjectiveComplete = false; foreach (var objective in taskData.objectives) { int current = runtimeData.objectiveProgress.GetValueOrDefault(objective.objectiveId, 0); bool isComplete = current >= objective.requiredAmount; if (!objective.isOptional && !isComplete) { allRequiredObjectivesComplete = false; } if (objective.isOptional && isComplete) { anyOptionalObjectiveComplete = true; } } // 状态流转逻辑 switch (runtimeData.currentState) { case TaskState.InProgress: if (allRequiredObjectivesComplete) { runtimeData.currentState = TaskState.ReadyToComplete; OnTaskStateChanged?.Invoke(runtimeData); Debug.Log($"任务 {taskData.taskName} 目标已完成，可提交。"); } break; // ... 其他状态转换 } }

当任务进入ReadyToComplete状态后，通常需要玩家与特定的NPC（提交NPC）交互来最终完成。这可以通过在对话系统中配置completeDialogueGroupId来实现。当玩家触发该对话组并选择“提交任务”选项时，对话系统会触发一个CompleteTaskEvent，任务管理器监听到后，执行发放奖励、更新状态为Completed、并可能激活下一个链式任务的操作。

实操心得：状态流转的逻辑一定要集中、清晰。避免在其他地方（如UI按钮回调里）直接修改TaskState。所有状态变更都应通过TaskManager的公开方法（如TryAcceptTask，TryCompleteTask）进行，并在方法内部做条件校验和状态转换。这能极大减少状态不同步的Bug。

4. 条件系统与动态目标评估

基础的目标匹配（如击杀指定ID的怪物）只能满足简单需求。为了支持“在暴风雪天气下，用银质武器击杀狼人”这种复杂目标，我们需要一个独立且强大的条件评估系统。

4.1 条件评估器的设计与注册

我们为每一种ConditionType定义一个评估器。首先定义一个条件评估接口。

public interface IConditionEvaluator { bool Evaluate(TaskCondition condition); }

然后实现具体的评估器。例如，一个检查游戏内时间的评估器：

public class TimeOfDayConditionEvaluator : IConditionEvaluator { public bool Evaluate(TaskCondition condition) { // condition.param1 可能为 “Day”, “Night”, “Dawn”, “Dusk” GameTime currentTime = GameWorld.Instance.GetCurrentTimeOfDay(); string requiredTime = condition.param1; return currentTime.ToString().Equals(requiredTime, StringComparison.OrdinalIgnoreCase); } }

再比如一个检查玩家是否装备特定物品的评估器：

public class EquipmentConditionEvaluator : IConditionEvaluator { public bool Evaluate(TaskCondition condition) { // condition.param1 为装备位，如 “Weapon” // condition.param2 为需要匹配的装备ID，如 “Weapon_Silver_Sword” string slot = condition.param1; string requiredItemId = condition.param2; Item equippedItem = PlayerInventory.Instance.GetEquippedItem(slot); return equippedItem != null && equippedItem.ItemId == requiredItemId; } }

在TaskManager初始化时，注册所有这些评估器到一个字典中。

private Dictionary<ConditionType, IConditionEvaluator> _conditionEvaluators = new Dictionary<ConditionType, IConditionEvaluator>(); private void InitializeConditionEvaluators() { _conditionEvaluators[ConditionType.TimeOfDay] = new TimeOfDayConditionEvaluator(); _conditionEvaluators[ConditionType.Weather] = new WeatherConditionEvaluator(); _conditionEvaluators[ConditionType.Equipment] = new EquipmentConditionEvaluator(); _conditionEvaluators[ConditionType.PlayerStat] = new PlayerStatConditionEvaluator(); // 检查生命值>50%等 _conditionEvaluators[ConditionType.QuestFlag] = new QuestFlagConditionEvaluator(); // 检查其他任务标记 }

4.2 动态评估与实时反馈

有了评估器，之前提到的EvaluateConditions方法就可以实现了。

private bool EvaluateConditions(List<TaskCondition> conditions) { if (conditions == null || conditions.Count == 0) return true; foreach (var condition in conditions) { if (_conditionEvaluators.TryGetValue(condition.type, out var evaluator)) { if (!evaluator.Evaluate(condition)) { return false; // 任何一个条件不满足，则整体不满足 } } else { Debug.LogWarning($"未找到条件类型 {condition.type} 的评估器，默认返回true。"); // 或者根据项目需求返回false } } return true; }

这个系统的强大之处在于它的可扩展性。如果想增加一个新的条件类型（例如“队伍中必须有某个角色”），只需要：1）在ConditionType枚举中添加新值；2）实现对应的IConditionEvaluator；3）在初始化时注册。完全不需要修改任务管理器的核心逻辑或已有的任务配置。

注意事项：条件评估可能涉及查询其他游戏系统（如背包、角色属性、世界状态），要确保这些查询是高效的，避免在每帧或每次事件触发时造成性能瓶颈。对于变化不频繁的条件（如天气），可以在条件变更时主动通知任务管理器重新评估相关任务，而不是在每次击杀事件时都去查询当前天气。

5. 任务UI与数据持久化

一个清晰的任务界面和可靠的存档系统，是玩家体验的保障。

5.1 任务UI：列表、追踪与提示

任务UI通常包括几个部分：可接任务列表、进行中任务列表、已完成任务列表，以及一个独立的追踪面板（HUD）用于显示当前追踪任务的详细信息。

任务列表项UI逻辑：

public class UITaskListItem : MonoBehaviour { public Text taskNameText; public Text stateText; public Button trackButton; private TaskRuntimeData _runtimeData; public void BindData(TaskRuntimeData runtimeData) { _runtimeData = runtimeData; var taskData = TaskManager.Instance.GetTaskData(runtimeData.taskId); taskNameText.text = taskData.taskName; stateText.text = GetStateString(runtimeData.currentState); trackButton.gameObject.SetActive(runtimeData.currentState == TaskState.InProgress || runtimeData.currentState == TaskState.ReadyToComplete); trackButton.onClick.RemoveAllListeners(); trackButton.onClick.AddListener(() => TaskManager.Instance.ToggleTaskTracking(runtimeData.taskId)); } private string GetStateString(TaskState state) { return state switch { TaskState.Available => "[可接取]", TaskState.InProgress => "[进行中]", TaskState.ReadyToComplete => "[！可完成]", TaskState.Completed => "[已完成]", _ => "" }; } }

任务追踪面板（HUD）逻辑：这个面板需要实时更新。我们可以在TaskManager的OnTaskProgressUpdated事件中刷新它。

public class UITaskTracker : MonoBehaviour { public Text trackedTaskTitle; public Transform objectivesParent; public GameObject objectivePrefab; private int _trackedTaskId = -1; private void OnEnable() { TaskManager.Instance.OnTaskProgressUpdated += OnTaskUpdated; TaskManager.Instance.OnTaskStateChanged += OnTaskUpdated; } private void OnDisable() { // ... 取消订阅 } private void OnTaskUpdated(TaskRuntimeData data) { if (data.taskId == _trackedTaskId) { RefreshUI(data); } } private void RefreshUI(TaskRuntimeData runtimeData) { var taskData = TaskManager.Instance.GetTaskData(runtimeData.taskId); trackedTaskTitle.text = taskData.taskName; // 清空并重新生成目标列表 foreach (Transform child in objectivesParent) Destroy(child.gameObject); foreach (var objective in taskData.objectives) { var obj = Instantiate(objectivePrefab, objectivesParent); var comp = obj.GetComponent<UITaskObjective>(); int current = runtimeData.objectiveProgress.GetValueOrDefault(objective.objectiveId, 0); comp.SetObjective(objective, current); } } }

UITaskObjective组件负责显示单条目标，例如将“收集狼牙 (0/3)”更新为“收集狼牙 (2/3)”，并在完成时打勾或变灰。

5.2 数据持久化：保存与加载

玩家退出游戏后，任务进度必须被保存。我们只需要序列化TaskRuntimeData的集合。

[System.Serializable] public class TaskSaveData { public List<TaskRuntimeData> allRuntimeData; } public void SaveRuntimeData() { TaskSaveData saveData = new TaskSaveData(); saveData.allRuntimeData = _activeRuntimeData.Values.ToList(); string json = JsonUtility.ToJson(saveData, true); // 使用PlayerPrefs、BinaryFormatter、或第三方存档系统保存json字符串 PlayerPrefs.SetString("TaskSaveData", json); PlayerPrefs.Save(); } public void LoadRuntimeDataFromSave() { _activeRuntimeData.Clear(); if (PlayerPrefs.HasKey("TaskSaveData")) { string json = PlayerPrefs.GetString("TaskSaveData"); TaskSaveData saveData = JsonUtility.FromJson<TaskSaveData>(json); foreach (var runtimeData in saveData.allRuntimeData) { _activeRuntimeData[runtimeData.taskId] = runtimeData; } } }

重要提醒：直接使用JsonUtility序列化Dictionary可能会出现问题，这就是为什么我们在TaskSaveData中使用List。同时，要确保TaskRuntimeData及其所有字段都是[Serializable]的。对于更复杂的存档需求（如加密、版本管理、云存档），可以考虑使用Newtonsoft.Json或专业的存档插件。

加载存档后，TaskManager需要根据加载的进度数据，重新初始化每个任务的状态。这包括重新计算哪些任务应该处于Available状态（检查其前置任务是否已在存档中标记为Completed）。

6. 高级功能与系统集成

基础框架搭建好后，我们可以在此基础上扩展一些提升体验和设计自由度的功能。

6.1 任务链与依赖关系自动解锁

任务链通过nextTaskId和prerequisiteTaskIds实现。当任务A完成时，系统会自动检查是否存在nextTaskId为A的任务B，并将其状态从NotStarted推进到Available（如果满足其他前提条件）。同时，任务B的prerequisiteTaskIds可能包含A，这确保了任务顺序。

private void ProcessTaskCompletion(int completedTaskId) { var completedTaskData = _allTaskData[completedTaskId]; // 1. 发放奖励... // 2. 更新状态为Completed... // 3. 解锁后续任务 if (completedTaskData.nextTaskId > 0) { var nextTaskRuntime = GetOrCreateRuntimeData(completedTaskData.nextTaskId); if (nextTaskRuntime.currentState == TaskState.NotStarted) { // 检查新任务的所有前置是否都已完成 var nextTaskData = _allTaskData[completedTaskData.nextTaskId]; bool allPrereqMet = true; foreach (var prereqId in nextTaskData.prerequisiteTaskIds) { if (!IsTaskCompleted(prereqId)) { allPrereqMet = false; break; } } if (allPrereqMet) { nextTaskRuntime.currentState = TaskState.Available; OnTaskStateChanged?.Invoke(nextTaskRuntime); } } } }

6.2 与对话系统的深度集成

这是让游戏世界“活”起来的关键。我们在TaskData中配置了startDialogueGroupId和completeDialogueGroupId。当玩家与NPC交互时，对话系统在开始前，可以询问TaskManager：“这个NPC有没有我可以接或交的任务？”。

public class DialogueTrigger : MonoBehaviour { public string defaultDialogueGroupId; private void OnInteract() { int availableTaskId = TaskManager.Instance.GetAvailableTaskFromNPC(this.name); int completableTaskId = TaskManager.Instance.GetCompletableTaskFromNPC(this.name); string dialogueGroupToPlay = defaultDialogueGroupId; if (completableTaskId != -1) { // 优先触发提交任务的对话 var taskData = TaskManager.Instance.GetTaskData(completableTaskId); dialogueGroupToPlay = taskData.completeDialogueGroupId; } else if (availableTaskId != -1) { // 其次触发接取任务的对话 var taskData = TaskManager.Instance.GetTaskData(availableTaskId); dialogueGroupToPlay = taskData.startDialogueGroupId; } DialogueManager.Instance.StartDialogueChapter(dialogueGroupToPlay); } }

而在对话系统内部，当执行到配置了“启动任务”事件的对话选项时（如上一篇文章所述），会触发TaskStartEvent，TaskManager监听到后，将对应任务的状态改为InProgress。这样就形成了“对话接任务 -> 游戏玩法推进任务 -> 对话交任务”的完美闭环。

6.3 编辑器工具支持

为了让策划高效工作，一个可视化的任务编辑器是必不可少的。我们可以利用Unity Editor的ScriptableObject和自定义Inspector来创建。

#if UNITY_EDITOR [CreateAssetMenu(fileName = "New Task", menuName = "Game/Task Data")] public class TaskDataSO : ScriptableObject { public TaskData taskData; } [CustomEditor(typeof(TaskDataSO))] public class TaskDataSOEditor : Editor { private SerializedProperty _taskDataProp; private void OnEnable() { _taskDataProp = serializedObject.FindProperty("taskData"); } public override void OnInspectorGUI() { serializedObject.Update(); // 使用SerializedProperty绘制一个友好的、带折叠和数组管理的UI EditorGUILayout.PropertyField(_taskDataProp, true); serializedObject.ApplyModifiedProperties(); } } #endif

更进一步，可以开发一个独立的任务编辑窗口，以树状图或流程图的形式展示任务链，并支持拖拽连接，这将极大提升复杂任务网的设计效率。

7. 性能优化、调试与常见问题

7.1 性能优化要点

1. 事件监听优化：TaskManager监听了大量全局事件。确保在场景切换或管理器禁用时正确取消订阅，防止内存泄漏。
2. 进度检查频率：CheckTaskCompletion和EvaluateConditions可能在一次事件触发中被调用多次（如果多个任务监听同一事件）。确保这些方法内的逻辑是轻量级的。对于复杂的条件评估，可以考虑缓存评估结果。
3. UI更新优化：OnTaskProgressUpdated事件可能被频繁触发。UI的刷新应避免每帧重建大量GameObject。对于任务列表，使用对象池来复用列表项。对于追踪面板，可以设置一个最小更新间隔（如0.2秒），或者使用Dirty标记，在下一帧统一更新。
4. 配置表加载：使用Addressables或AssetBundle异步加载任务配置，避免在启动时卡顿。

7.2 调试与日志

在开发阶段，详细的日志至关重要。

// 在TaskManager的关键方法中添加条件编译的日志 [System.Diagnostics.Conditional("UNITY_EDITOR"), System.Diagnostics.Conditional("DEVELOPMENT_BUILD")] private void LogTaskProgress(int taskId, int objectiveId, int oldValue, int newValue) { Debug.Log($"[TaskSystem] 任务{taskId} 目标{objectiveId} 进度更新: {oldValue} -> {newValue}"); }

可以创建一个简单的调试窗口，实时显示所有激活任务的状态和进度。

private void OnGUI() { if (!showDebugWindow) return; GUILayout.Window(0, new Rect(10, 10, 400, 500), DrawDebugWindow, "任务系统调试"); } private void DrawDebugWindow(int windowId) { foreach (var runtimeData in _activeRuntimeData.Values) { var taskData = _allTaskData[runtimeData.taskId]; GUILayout.Label($"[{runtimeData.currentState}] {taskData.taskName}"); foreach (var obj in taskData.objectives) { int cur = runtimeData.objectiveProgress.GetValueOrDefault(obj.objectiveId, 0); GUILayout.Label($" - {obj.description} ({cur}/{obj.requiredAmount})"); } } }

7.3 常见问题与排查

1. 事件不触发任务进度：

   • 检查事件是否发出：确认EnemyKilledEvent等事件在怪物死亡时被正确发布。
   • 检查目标匹配：确认任务配置中的target字符串（如“Enemy_Wolf”）与事件中传递的ID完全一致，包括大小写。
   • 检查任务状态：确保任务处于InProgress状态。Available状态的任务不会监听进度事件。
   • 检查条件评估：在EvaluateConditions方法内添加调试日志，查看是哪个条件返回了false。

2. 任务状态未按预期流转：

   • 检查CheckTaskCompletion逻辑：特别是allRequiredObjectivesComplete的计算是否正确，是否忽略了可选目标。
   • 检查前置任务依赖：确认prerequisiteTaskIds配置正确，且前置任务的状态确实是Completed。

3. 存档后任务进度丢失：

   • 检查序列化：确保TaskRuntimeData类及其所有字段都是[Serializable]的，并且没有不可序列化的类型（如委托、Unity对象引用）。
   • 检查保存/加载时机：确保在游戏退出、场景切换等关键节点调用SaveRuntimeData。
   • 验证数据：加载存档后，打印出加载的TaskRuntimeData列表，确认数据被正确还原。

4. UI显示异常：

   • 检查事件绑定：确认UI脚本在OnEnable时订阅了TaskManager的事件，在OnDisable时取消订阅。
   • 检查数据绑定：在BindData方法中，确保传入的TaskRuntimeData不为空，并且能通过taskId找到对应的TaskData。

这套任务系统基础架构，从数据模型、事件驱动、条件评估到UI和持久化，形成了一个闭环。它足够灵活，能应对大多数中小型项目的需求，并且每个模块都足够独立，方便进行替换或增强。最重要的是，它通过配置表将游戏内容与代码逻辑分离，让策划能够最大限度地发挥创造力，而程序员则能专注于维护一个稳定高效的系统引擎。