对话与任务系统#

1 设计思路#

在设计这个系统的时候，我一开始想到的闭环其实非常直觉：

接近 NPC -> E 键交互 -> 触发扫描 -> 检测到可对话人物 -> 进入对话 -> 选择选项 -> 接取任务 -> 收集道具 -> 提交道具 -> 判断是否满足条件 -> 给出完成当前任务的反馈

这个闭环看起来挺顺的，甚至一眼看过去会觉得“那不就是按顺序写函数吗”。但是稍微拆一下就会发现，这里面其实混了好几层东西：

玩家怎么检测到 NPC，这是交互系统的问题；
NPC 怎么知道自己能不能说话，这是 NPC / DialogueParticipant 的问题；
对话内容从哪里来，这是 DialogueDefinition 的问题；
点选项之后要发生什么，这是 Effect 的问题；
任务状态怎么保存，这是 QuestRuntimeState / SaveGame 的问题；
UI 怎么刷新，这是 Widget 的问题。

所以如果一上来就想把整条链路全部写完，很容易变成一个巨大的、什么都管的类。

后面我又想了一下，最前面的这一段：

接近 NPC -> E 键交互 -> 触发扫描 -> 检测到可对话人物 -> 进入对话

其实也不一定应该一直这么做。更理想的交互应该是：玩家进入某个范围之后，系统先知道“附近有可交互对象”，然后显示一个交互提示，玩家按 E 再真正开始对话。

不过这部分属于交互体验的优化，不应该卡住对话系统本身。所以当前阶段我还是先跑通最小闭环：

开始对话 -> 显示节点 -> 显示选项 -> 点击选项 -> 执行效果 -> 跳转或关闭

基于这个目标，我暂时把系统拆成了下面几层。

DialogueDefinition

一段对话的静态资产。里面保存对话 ID、起始节点、所有节点。
QuestDefinition

一个任务的静态资产。里面保存任务 ID、任务标题、任务目标、任务奖励和前置条件。
DialogueNPC

NPC 的 Actor 层。现在主要用来承载碰撞体、模型和对话组件。
DialogueParticipantComponent

对话参与者组件。挂到某个 Actor 上之后，这个 Actor 就可以作为对话对象。
DialogueQuestSubsystem

对话和任务的运行时管理器。这个名字听起来很大，但当前最重要的职责其实就是：保存当前对话会话、对话进度、任务进度、全局旗标。
EscapeDialogueTypes

各种枚举和结构体定义。比如对话节点、对话选项、条件、效果、任务状态、奖励结构、存档结构等。

这里有个地方我一开始也容易想偏：DialogueQuestSubsystem 不是每次对话创建出来的东西，也不是每个任务一个管理器。它是挂在 GameInstance 上的全局运行时管理器。也就是说，它更像当前存档里的“对话/任务状态中心”。

2 DialogueType ENUM 部分#

我先把对话里可能出现的概念枚举出来。

1
UENUM(BlueprintType)
2
enum class EDialogueNodeType : uint8
3
{
4
  Line UMETA(DisplayName="普通对白节点"),
5
  Choice UMETA(DisplayName="玩家选项节点"),
6
  Reward UMETA(DisplayName="奖励发放节点"),
7
  Exit UMETA(DisplayName="结束对话节点"),
8
  Branch UMETA(DisplayName="条件分支节点"),
9
  BossIntro UMETA(DisplayName="Boss 开场对白节点")
10
};

目前真正用到的其实主要是普通对白、选项和结束节点。Reward、Branch、BossIntro 更偏向后续扩展。这里先定义出来，是为了让数据结构一开始就知道未来可能会接什么，但不代表这些功能现在都已经实现了。

触发方式也先列出来：

1
UENUM(BlueprintType)
2
enum class EDialogueTriggerMode : uint8
3
{
4
  ManualInteract UMETA(DisplayName="手动交互触发"),
5
  AutoOnOverlap UMETA(DisplayName="进入范围自动触发"),
6
  ForcedBeforeCombat UMETA(DisplayName="战斗前强制触发"),
7
  BossIntro UMETA(DisplayName="Boss 开场触发"),
8
  ScriptedOnly UMETA(DisplayName="仅脚本触发")
9
};

当前最基础的触发方式就是 ManualInteract，也就是玩家按 E 交互。后续如果要做进入范围自动对话、Boss 战前强制对白，也可以接在这个枚举上。

条件类型：

1
UENUM(BlueprintType)
2
enum class EDialogueConditionType : uint8
3
{
4
  QuestStateIs UMETA(DisplayName="任务状态满足"),
5
  ObjectiveCompleted UMETA(DisplayName="任务目标已完成"),
6
  HasItem UMETA(DisplayName="持有指定物品"),
7
  GlobalFlagIs UMETA(DisplayName="全局旗标满足"),
8
  DialogueNodeSeen UMETA(DisplayName="已看过指定对白节点"),
9
  PuzzleSolved UMETA(DisplayName="谜题已解开"),
10
  BossStateIs UMETA(DisplayName="Boss 状态满足")
11
};

这里现在已经实现的只有两个：

GlobalFlagIs
DialogueNodeSeen

其他条件现在只是“系统知道未来可能需要它”，还没真正落地。

效果类型：

1
UENUM(BlueprintType)
2
enum class EDialogueEffectType : uint8
3
{
4
  StartQuest UMETA(DisplayName="开始任务"),
5
  SetQuestState UMETA(DisplayName="设置任务状态"),
6
  AddObjectiveProgress UMETA(DisplayName="增加目标进度"),
7
  SetGlobalFlag UMETA(DisplayName="设置全局旗标"),
8
  GiveItem UMETA(DisplayName="给予物品"),
9
  RemoveItem UMETA(DisplayName="移除物品"),
10
  GrantReward UMETA(DisplayName="发放奖励"),
11
  StartBossEncounter UMETA(DisplayName="启动 Boss 遭遇战"),
12
  BroadcastWorldEvent UMETA(DisplayName="广播世界事件"),
13
  CloseDialogue UMETA(DisplayName="关闭对话"),
14
  SaveGame UMETA(DisplayName="保存游戏")
15
};

这里也是一样，当前真正实现的是：

SetGlobalFlag
CloseDialogue

这两个很小，但是已经足够验证“点击选项之后，系统真的能改变状态或者关闭对话”。

任务状态暂时这么定义：

1
UENUM(BlueprintType)
2
enum class EQuestState : uint8
3
{
4
  NotStarted UMETA(DisplayName="未开始"),
5
  Active UMETA(DisplayName="进行中"),
6
  ReadyToTurnIn UMETA(DisplayName="可交付"),
7
  Completed UMETA(DisplayName="已完成"),
8
  RewardClaimed UMETA(DisplayName="奖励已领取"),
9
  Failed UMETA(DisplayName="已失败")
10
};

这部分现在更多是为后续任务系统做准备。当前对话闭环跑通后，下一步比较自然的推进顺序就是：StartQuest -> QuestStateIs -> AddObjectiveProgress -> GrantReward。

3 DialogueType STRUCT 部分#

主要结构有这些。

3.1 DialogueCondition#

FDialogueCondition 是一条“是否满足”的判断规则。

比如：

某个任务是否已经开始；
某个全局旗标是否为 true；
玩家是否看过某个对话节点；
玩家是否拥有某个道具。

当前最小实现只支持 GlobalFlagIs 和 DialogueNodeSeen。这也是为了先把选项筛选跑通。

3.2 DialogueEffect#

FDialogueEffect 是一条“要做什么”的规则。

它可以挂在选项上，也可以后续挂在节点进入时：

点击选项后开始任务；
点击选项后设置旗标；
点击选项后关闭对话；
点击选项后给物品；
点击选项后触发 Boss 战。

我现在先只做 SetGlobalFlag 和 CloseDialogue，因为它们刚好能验证最小闭环。

3.3 FDialogueOption#

FDialogueOption 是玩家能点的一条对话选项。

1
USTRUCT(BlueprintType)
2
struct ESCAPEGAME_API FDialogueOption
3
{
4
  GENERATED_BODY()
5

6
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
7
  FGameplayTag OptionID;
8

9
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
10
  FText OptionText;
11

12
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
13
  TArray<FDialogueCondition> Conditions;
14

15
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
16
  TArray<FDialogueEffect> Effects;
17

18
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
19
  FGameplayTag NextNodeID;
20

21
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
22
  bool bCloseDialogueAfterSelected = false;
23

24
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
25
  bool bHideWhenUnavailable = false;
26

27
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
28
  int32 SortOrder = 0;
29
};

我觉得这个结构比较关键，因为它把一条选项会发生什么都收在一起了：

Conditions 决定它能不能显示；
Effects 决定点下去之后要执行什么；
NextNodeID 决定点完之后跳到哪里；
bCloseDialogueAfterSelected 决定点完之后是否直接结束。

这样选项就不是一个单纯的 UI 按钮，而是对话流程里的一个小分支。

3.4 FDialogueNode#

FDialogueNode 是对话树里的一个节点。

1
USTRUCT(BlueprintType)
2
struct ESCAPEGAME_API FDialogueNode
3
{
4
  GENERATED_BODY()
5

6
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
7
  FGameplayTag NodeID;
8

9
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
10
  FGameplayTag SpeakerID;
11

12
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
13
  FText SpeakerText;
14

15
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
16
  EDialogueNodeType NodeType = EDialogueNodeType::Line;
17

18
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
19
  TArray<FDialogueCondition> Conditions;
20

21
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
22
  TArray<FDialogueOption> Options;
23

24
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
25
  TArray<FDialogueEffect> OnEnterEffects;
26

27
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
28
  FInterruptPolicy InterruptPolicy;
29

30
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
31
  bool bAllowSkip = true;
32
};

这个节点本身只是一份数据。它不会自己推动流程。

真正推动流程的是 DialogueQuestSubsystem：它根据当前 ActiveSession.CurrentNodeID 找到当前节点，然后 UI 再根据这个节点显示文本和选项。

3.5 FConversationSession#

FConversationSession 表示当前正在进行的一次对话。

它只存在于运行时，用来回答：

当前是不是正在对话；
当前跟哪个 NPC 对话；
当前是哪一段 Dialogue；
当前显示到哪个 Node；
上一次点了哪个 Option；
这次对话能不能跳过、是否锁玩家。

这个结构存在之后，UI 就不用自己保存流程状态了。

3.6 FDialogueRuntimeState#

FDialogueRuntimeState 记录某段对话的长期进度。

比如：

玩家是否看过这段对话；
玩家看过哪些节点；
玩家点过哪些选项；
最近一次和谁说过话。

这部分后续可以进入存档。

3.7 FGlobalFlagState#

全局旗标用来记录跨对话、跨任务都会关心的世界状态。

比如：

某个门是否打开；
某个 NPC 是否见过；
某个 Boss 是否死亡；
某个剧情分支是否触发。

1
USTRUCT(BlueprintType)
2
struct ESCAPEGAME_API FGlobalFlagState
3
{
4
  GENERATED_BODY()
5

6
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
7
  FGameplayTag FlagID;
8

9
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
10
  bool bValue = false;
11

12
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
13
  int32 NumericValue = 0;
14

15
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
16
  FText TextValue;
17

18
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
19
  float LastChangedTimeSeconds = 0.0f;
20
};

这里我之前有一个地方容易说不清：这个 FlagID 不是去玩家身上找一个 Tag。

它只是 GlobalFlagMap 里的 Key。

1
TMap<FGameplayTag, FGlobalFlagState> GlobalFlagMap;

也就是说，GlobalFlagIs 判断的是 Dialogue/Quest 系统自己维护的世界状态表，而不是 PlayerActor->ActorHasTag()。

4 DialogueParticipantComponent#

DialogueParticipantComponent 主要存一个可对话对象的基础信息：

1
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
2
FGameplayTag ParticipantID;
3

4
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
5
FText DisplayName;
6

7
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
8
TSoftObjectPtr<UTexture2D> Portrait;
9

10
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
11
FGameplayTag DefaultStartNodeID;
12

13
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
14
TSoftObjectPtr<UDialogueDefinition> DialogueDefinition;

还有一些运行时行为配置，例如是否可以对话、是否锁住玩家、是否看向玩家、是否战斗前强制对白等。

我把这些放在 Component 里，是因为“能对话”不应该只属于 NPC。后面一个机关、一个门、一个可调查物体，也可以挂这个组件来复用对话逻辑。

5 DialogueQuestSubsystem#

这个类目前是对话和任务系统最核心的部分。

它里面主要有这些运行时数据：

1
// 当前正在进行的对话会话。
2
UPROPERTY(Transient)
3
FConversationSession ActiveSession;
4

5
// 对话运行时进度缓存。
6
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
7
TMap<FGameplayTag, FDialogueRuntimeState> DialogueRuntimeMap;
8

9
// 任务运行时进度缓存。
10
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
11
TMap<FGameplayTag, FQuestRuntimeState> QuestRuntimeMap;
12

13
// 全局旗标缓存。
14
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Dialogue")
15
TMap<FGameplayTag, FGlobalFlagState> GlobalFlagMap;
16

17
// 已加载的对话资产缓存。
18
UPROPERTY(Transient)
19
TMap<FGameplayTag, TObjectPtr<UDialogueDefinition>> LoadedDialogueDefinitions;
20

21
// 当前正在对话的参与者组件。
22
UPROPERTY(Transient)
23
TObjectPtr<UDialogueParticipantComponent> ActiveParticipantComponent;

一开始看这些 Map 可能有点多，但其实它们分工还算清楚：

DialogueRuntimeMap 管“对话进度”；
QuestRuntimeMap 管“任务进度”；
GlobalFlagMap 管“世界状态”；
LoadedDialogueDefinitions 管“已经加载过的对话资产”；
ActiveSession 管“当前这一刻正在进行的对话”。

下面是几个核心函数。

6 Subsystem 实现讲解#

6.1 StartConversation#

StartConversation 做的事情是：尝试从某个对话参与者身上开启一段对话。

它并不负责创建 UI。它只负责建立运行时会话，然后广播 OnConversationStarted。UI 或 PlayerController 可以监听这个广播，再去创建 Widget。

1
bool UDialogueQuestSubsystem::StartConversation(AActor* Instigator, UDialogueParticipantComponent* Participant)
2
{
3
  if (!IsValid(Instigator))
4
  {
5
    UE_LOG(LogTemp, Error, TEXT("StartConversation 失败：Instigator 无效。"));
6
    return false;
7
  }
8

9
  if (!IsValid(Participant))
10
  {
11
    UE_LOG(LogTemp, Error, TEXT("StartConversation 失败：Participant 无效。"));
12
    return false;
13
  }
14

15
  if (!Participant->bCanTalk)
16
  {
17
    UE_LOG(LogTemp, Error, TEXT("StartConversation 失败：Participant 当前不允许对话。Owner=%s"),
18
      *GetNameSafe(Participant->GetOwner()));
19
    return false;
20
  }
21

22
  if (bConversationOpen)
23
  {
24
    UE_LOG(LogTemp, Error, TEXT("StartConversation 失败：当前已有对话正在进行。"));
25
    return false;
26
  }
27

28
  if (Participant->DialogueDefinition.IsNull())
29
  {
30
    UE_LOG(LogTemp, Error, TEXT("StartConversation 失败：Participant 未配置 DialogueDefinition。Owner=%s"),
31
      *GetNameSafe(Participant->GetOwner()));
32
    return false;
33
  }
34

35
  UDialogueDefinition* DialogueAsset = Participant->DialogueDefinition.LoadSynchronous();
36
  if (!IsValid(DialogueAsset))
37
  {
38
    UE_LOG(LogTemp, Error, TEXT("StartConversation 失败：DialogueDefinition 加载失败。Owner=%s"),
39
      *GetNameSafe(Participant->GetOwner()));
40
    return false;
41
  }
42

43
  const FGameplayTag StartNodeID = Participant->DefaultStartNodeID.IsValid()
44
    ? Participant->DefaultStartNodeID
45
    : DialogueAsset->StartNodeID;
46

47
  if (!StartNodeID.IsValid())
48
  {
49
    UE_LOG(LogTemp, Error, TEXT("StartConversation 失败：未配置有效起始节点。DialogueID=%s"),
50
      *DialogueAsset->DialogueID.ToString());
51
    return false;
52
  }
53

54
  LoadedDialogueDefinitions.Add(DialogueAsset->DialogueID, DialogueAsset);
55

56
  ActiveSession = FConversationSession();
57
  ActiveSession.SessionId = FGuid::NewGuid();
58
  ActiveSession.NPC_ID = Participant->ParticipantID;
59
  ActiveSession.DialogueID = DialogueAsset->DialogueID;
60
  ActiveSession.CurrentNodeID = StartNodeID;
61
  ActiveSession.bIsActive = true;
62
  ActiveSession.bLockPlayer = Participant->bLockPlayer;
63
  ActiveSession.bCanSkip = Participant->bCanSkip;
64
  ActiveSession.InterruptPolicy = Participant->DefaultInterruptPolicy;
65
  ActiveSession.StartTimeSeconds = GetWorld() ? GetWorld()->GetTimeSeconds() : 0.0f;
66

67
  bConversationOpen = true;
68

69
  FDialogueRuntimeState& State = DialogueRuntimeMap.FindOrAdd(ActiveSession.DialogueID);
70
  State.DialogueID = ActiveSession.DialogueID;
71
  State.bHasSeenDialogue = true;
72
  State.CurrentNodeID = StartNodeID;
73
  State.LastTalkPartnerID = Participant->ParticipantID;
74
  State.SeenNodeIDs.Add(StartNodeID);
75

76
  ActiveParticipantComponent = Participant;
77

78
  OnConversationStarted.Broadcast(ActiveSession);
79

80
  return true;
81
}

这段函数的流程其实挺固定：

先检查参数，再检查是否能对话，再加载资产，再确定起始节点，最后写入 ActiveSession 和 DialogueRuntimeMap。

我现在觉得这里比较重要的设计点是：对话是否开始成功，应该由 Subsystem 决定，而不是 UI 决定。

6.2 GetCurrentNode#

GetCurrentNode 根据当前会话里的 CurrentNodeID，去已经加载的 DialogueDefinition 里找到对应节点。

1
FDialogueNode UDialogueQuestSubsystem::GetCurrentNode() const
2
{
3
  if (!IsConversationActive())
4
  {
5
    UE_LOG(LogTemp, Error, TEXT("GetCurrentNode 失败：当前没有激活的对话。"));
6
    return FDialogueNode();
7
  }
8

9
  const TObjectPtr<UDialogueDefinition>* DialogueDefinitionPtr =
10
    LoadedDialogueDefinitions.Find(ActiveSession.DialogueID);
11

12
  if (!DialogueDefinitionPtr || !IsValid(DialogueDefinitionPtr->Get()))
13
  {
14
    UE_LOG(LogTemp, Error, TEXT("GetCurrentNode 失败：未找到已加载的对话资产。DialogueID=%s"),
15
      *ActiveSession.DialogueID.ToString());
16
    return FDialogueNode();
17
  }
18

19
  const FDialogueNode* FoundNode = DialogueDefinitionPtr->Get()->Nodes.FindByPredicate(
20
    [this](const FDialogueNode& Node)
21
    {
22
      return Node.NodeID == ActiveSession.CurrentNodeID;
23
    });
24

25
  if (!FoundNode)
26
  {
27
    UE_LOG(LogTemp, Error, TEXT("GetCurrentNode 失败：对话资产中找不到节点。NodeID=%s"),
28
      *ActiveSession.CurrentNodeID.ToString());
29
    return FDialogueNode();
30
  }
31

32
  return *FoundNode;
33
}

这也是为什么 UI 不需要自己保存“当前显示到哪里了”。UI 每次刷新时问 Subsystem 要当前节点就行。

6.3 GetAvailableOptions#

GetAvailableOptions 做的是最小条件筛选。

它会遍历当前节点的所有选项，只把条件全部满足的选项返回给 UI。

1
TArray<FDialogueOption> UDialogueQuestSubsystem::GetAvailableOptions() const
2
{
3
  if (!IsConversationActive())
4
  {
5
    UE_LOG(LogTemp, Error, TEXT("GetAvailableOptions 失败：当前没有激活的对话。"));
6
    return TArray<FDialogueOption>();
7
  }
8

9
  const FDialogueNode CurrentNode = GetCurrentNode();
10
  if (!CurrentNode.NodeID.IsValid())
11
  {
12
    UE_LOG(LogTemp, Error, TEXT("GetAvailableOptions 失败：当前节点无效。"));
13
    return TArray<FDialogueOption>();
14
  }
15

16
  TArray<FDialogueOption> AvailableOptions;
17
  for (const FDialogueOption& Option : CurrentNode.Options)
18
  {
19
    bool bAllConditionsPassed = true;
20

21
    for (const FDialogueCondition& Condition : Option.Conditions)
22
    {
23
      if (!EvaluateCondition(Condition))
24
      {
25
        bAllConditionsPassed = false;
26
        break;
27
      }
28
    }
29

30
    if (bAllConditionsPassed)
31
    {
32
      AvailableOptions.Add(Option);
33
    }
34
  }
35

36
  return AvailableOptions;
37
}

这里我觉得比较舒服的一点是：UI 不用关心条件怎么判断。它只负责拿到数组，然后生成按钮。

6.4 SelectOption#

SelectOption 是目前整个对话闭环里最关键的函数。

它做的事是：

检查当前是否有激活对话；
找到玩家点的选项；
记录这次选择；
执行这个选项上的 Effects；
如果对话还没关闭，就根据 NextNodeID 跳转。

1
bool UDialogueQuestSubsystem::SelectOption(FGameplayTag OptionID)
2
{
3
  if (!IsConversationActive())
4
  {
5
    UE_LOG(LogTemp, Error, TEXT("SelectOption 失败：当前没有激活的对话。"));
6
    return false;
7
  }
8

9
  if (!OptionID.IsValid())
10
  {
11
    UE_LOG(LogTemp, Error, TEXT("SelectOption 失败：OptionID 无效。"));
12
    return false;
13
  }
14

15
  FDialogueNode CurrentNode = GetCurrentNode();
16
  if (!CurrentNode.NodeID.IsValid())
17
  {
18
    UE_LOG(LogTemp, Error, TEXT("SelectOption 失败：CurrentNode 无效。"));
19
    return false;
20
  }
21

22
  const FDialogueOption* SelectedOption = CurrentNode.Options.FindByPredicate(
23
    [OptionID](const FDialogueOption& Option)
24
    {
25
      return Option.OptionID == OptionID;
26
    });
27

28
  if (!SelectedOption)
29
  {
30
    UE_LOG(LogTemp, Error, TEXT("SelectOption 失败：无效选项。"));
31
    return false;
32
  }
33

34
  ActiveSession.LastSelectedOptionID = OptionID;
35

36
  FDialogueRuntimeState& State = DialogueRuntimeMap.FindOrAdd(ActiveSession.DialogueID);
37
  State.DialogueID = ActiveSession.DialogueID;
38
  State.bHasSeenDialogue = true;
39
  State.CurrentNodeID = ActiveSession.CurrentNodeID;
40
  State.LastTalkPartnerID = ActiveSession.NPC_ID;
41
  State.VisitedOptionIDs.Add(OptionID);
42

43
  for (const FDialogueEffect& Effect : SelectedOption->Effects)
44
  {
45
    ApplyEffect(Effect);
46

47
    if (!IsConversationActive())
48
    {
49
      return true;
50
    }
51
  }
52

53
  if (SelectedOption->bCloseDialogueAfterSelected)
54
  {
55
    return EndConversation(EInterruptReason::NormalEnd);
56
  }
57

58
  if (!SelectedOption->NextNodeID.IsValid())
59
  {
60
    UE_LOG(LogTemp, Warning, TEXT("SelectOption 成功：选项没有 NextNodeID，保持当前节点。OptionID=%s"),
61
      *OptionID.ToString());
62
    return true;
63
  }
64

65
  ActiveSession.CurrentNodeID = SelectedOption->NextNodeID;
66
  State.CurrentNodeID = SelectedOption->NextNodeID;
67
  State.SeenNodeIDs.Add(SelectedOption->NextNodeID);
68

69
  return true;
70
}

这里有一个之前很容易漏掉的点：执行 ApplyEffect 之后，对话可能已经被关闭了。

比如某个选项的效果就是 CloseDialogue。这种情况下如果后面还继续走 NextNodeID，逻辑就会很奇怪。所以每执行完一个 Effect，都要检查一次 IsConversationActive()。

6.5 EvaluateCondition#

当前 EvaluateCondition 只支持两个条件。

第一个是 GlobalFlagIs：

1
case EDialogueConditionType::GlobalFlagIs:
2
{
3
  const FGlobalFlagState* FlagState = GlobalFlagMap.Find(Condition.FlagID);
4
  if (!FlagState)
5
  {
6
    UE_LOG(LogTemp, Warning, TEXT("EvaluateCondition GlobalFlagIs 失败：找不到 FlagID=%s。"),
7
      *Condition.FlagID.ToString());
8
    bResult = false;
9
    break;
10
  }
11

12
  bResult = FlagState->bValue == Condition.ExpectedBoolValue;
13
  break;
14
}

这个条件查的是 GlobalFlagMap。也就是说，如果之前某个选项执行了 SetGlobalFlag，后面的选项就可以通过 GlobalFlagIs 判断它。

第二个是 DialogueNodeSeen：

1
case EDialogueConditionType::DialogueNodeSeen:
2
{
3
  const FDialogueRuntimeState* DialogueState = DialogueRuntimeMap.Find(ActiveSession.DialogueID);
4
  if (!DialogueState)
5
  {
6
    UE_LOG(LogTemp, Warning, TEXT("EvaluateCondition DialogueNodeSeen 失败：找不到 DialogueID=%s 的运行时状态。"),
7
      *ActiveSession.DialogueID.ToString());
8
    bResult = false;
9
    break;
10
  }
11

12
  const bool bHasSeenNode = DialogueState->SeenNodeIDs.Contains(Condition.ExpectedTagValue);
13
  bResult = bHasSeenNode == Condition.ExpectedBoolValue;
14
  break;
15
}

它查的是当前对话的运行时状态，判断某个节点是否已经看过。

最后再统一处理反转：

1
return Condition.bInvert ? !bResult : bResult;

这个 bInvert 很实用。比如“没有见过某节点”“某旗标不是 true”这种条件，就不用再单独加一个枚举。

6.6 ApplyEffect#

ApplyEffect 根据传入的 EffectType 执行对应效果。

当前实现很小：

1
void UDialogueQuestSubsystem::ApplyEffect(const FDialogueEffect& Effect)
2
{
3
  switch (Effect.EffectType)
4
  {
5
  case EDialogueEffectType::SetGlobalFlag:
6
    {
7
      if (!Effect.FlagID.IsValid())
8
      {
9
        UE_LOG(LogTemp, Error, TEXT("ApplyEffect SetGlobalFlag 失败：FlagID 无效。"));
10
        return;
11
      }
12

13
      FGlobalFlagState& FlagState = GlobalFlagMap.FindOrAdd(Effect.FlagID);
14
      FlagState.FlagID = Effect.FlagID;
15
      FlagState.bValue = Effect.BoolValue;
16
      FlagState.LastChangedTimeSeconds = GetWorld() ? GetWorld()->GetTimeSeconds() : 0.0f;
17
      return;
18
    }
19

20
  case EDialogueEffectType::CloseDialogue:
21
    {
22
      if (!IsConversationActive())
23
      {
24
        UE_LOG(LogTemp, Warning, TEXT("ApplyEffect CloseDialogue 跳过：当前没有激活的对话。"));
25
        return;
26
      }
27

28
      EndConversation(EInterruptReason::NormalEnd);
29
      return;
30
    }
31

32
  default:
33
    UE_LOG(LogTemp, Warning, TEXT("ApplyEffect 不支持的效果类型：EffectType=%d。"),
34
      static_cast<int32>(Effect.EffectType));
35
    return;
36
  }
37
}

一开始我也会有一种冲动：既然枚举都列出来了，那就把 StartQuest、GiveItem、GrantReward 全部写掉。

但是这样很容易变成“看起来写了很多，实际上每个都没有被验证”。所以现在先只做两个最小效果：

SetGlobalFlag：证明选项可以改变世界状态；
CloseDialogue：证明选项可以结束当前对话。

这个闭环通过之后，再加任务系统会稳很多。

6.7 EndConversation#

结束对话的时候，不只是把窗口关掉。

Subsystem 还需要把当前状态写回运行时记录，然后广播对话结束事件。

1
bool UDialogueQuestSubsystem::EndConversation(EInterruptReason Reason)
2
{
3
  if (!IsConversationActive())
4
  {
5
    UE_LOG(LogTemp, Error, TEXT("EndConversation 失败：当前没有激活的对话。"));
6
    return false;
7
  }
8

9
  if (ActiveSession.DialogueID.IsValid())
10
  {
11
    FDialogueRuntimeState& State = DialogueRuntimeMap.FindOrAdd(ActiveSession.DialogueID);
12
    State.DialogueID = ActiveSession.DialogueID;
13
    State.LastTalkPartnerID = ActiveSession.NPC_ID;
14
    State.bHasSeenDialogue = true;
15

16
    if (ActiveSession.CurrentNodeID.IsValid())
17
    {
18
      State.CurrentNodeID = ActiveSession.CurrentNodeID;
19
      State.SeenNodeIDs.Add(ActiveSession.CurrentNodeID);
20
    }
21
  }
22

23
  ActiveSession.InterruptReason = Reason;
24
  ActiveSession.bIsActive = false;
25
  bConversationOpen = false;
26

27
  OnConversationEnded.Broadcast(Reason);
28
  ActiveParticipantComponent = nullptr;
29

30
  return true;
31
}

这样 UI 层就可以很简单：监听 OnConversationEnded，然后隐藏或移除 Widget。

7 UI 部分#

UI 这边我现在做得比较朴素。

WBP_Dialogue 里面大概有：

SpeakerNameTextBlock
SpeakerContentTextBlock
OptionsBox

然后再做一个单独的 WBP_DialogueOption，里面放一个按钮和文本。

这里有个点我之前也想了一下：动态创建选项按钮的话，WBP 里就不需要提前拖三个 OptionWidget。因为每个节点有几个选项是不固定的。

正确的方式更像这样：

1
刷新对话 UI
2
  -> 清空 OptionsBox
3
  -> 调用 GetAvailableOptions
4
  -> 遍历选项数组
5
  -> CreateWidget<WBP_DialogueOption>
6
  -> 绑定点击事件
7
  -> AddChild 到 OptionsBox

也就是说，WBP_DialogueOption 是模板，不是手动摆死在界面上的固定控件。

8 当前已经跑通的最小闭环#

目前实际已经跑通的是：

玩家按 E 和 NPC 交互；
交互组件扫到 NPC；
NPC 身上有 DialogueParticipantComponent；
调用 StartConversation；
UI 弹出；
UI 显示当前节点文本；
UI 根据 GetAvailableOptions 生成选项；
点击选项调用 SelectOption；
选项可以执行 SetGlobalFlag；
选项可以执行 CloseDialogue；
选项也可以通过 NextNodeID 跳到下一个节点。

这个阶段看起来功能还很少，但是它已经把最重要的链路打通了：

数据资产 -> Subsystem -> UI -> 玩家点击 -> Subsystem 状态变化 -> UI 刷新/关闭

我觉得这个闭环比一口气写完任务奖励系统更重要。因为只要这个通了，后面的任务、背包、奖励基本都可以当作新的 Effect 慢慢接进去。

9 后续还需要做什么#

现在还没落地的模块主要有：

StartQuest

点击选项之后创建任务运行时状态。
QuestStateIs

根据任务状态决定某些选项是否出现。
AddObjectiveProgress

推进任务目标进度，比如收集道具、击杀敌人、触发机关。
GiveItem / RemoveItem

和背包系统打通。
GrantReward

任务完成后发奖励。
OnEnterEffects

进入某个节点时自动执行效果。
SaveGame

把 RuntimeMap 转成存档记录，再从存档记录恢复回来。
中断策略

离开范围、打开菜单、死亡、进入战斗时，对话应该暂停、结束还是继续。
Boss / Encounter

对话结束后触发战斗，或者战斗前强制播放某段对白。

后面倾向于做：

1
对话闭环
2
  -> StartQuest
3
  -> QuestStateIs
4
  -> AddObjectiveProgress
5
  -> GrantReward
6
  -> SaveGame

也就是每次只推进一个小闭环，不把所有功能一起塞进去。

10 小结#

这次做下来，我感觉这个系统最重要的不是结构体写了多少，也不是枚举列得多完整，而是先把边界划清楚：

DialogueDefinition 只描述对话内容；
DialogueParticipantComponent 只描述谁能参与对话；
DialogueQuestSubsystem 负责运行时流程和状态；
Widget 只负责展示和把点击传回 Subsystem；
Effect 负责把对话和任务、奖励、世界状态连接起来。

一开始我会很自然地想把“对话、任务、奖励、存档”放在一起想，但真正写的时候还是要拆成一个个能验证的小闭环。

当前这个版本还远远不是完整系统，不过至少已经不是纸面设计了。它已经能在关卡里完成一次真实的 NPC 对话流程，这对后续继续接任务系统来说就够了。

ようこそ！ここはインターネットの果てだよ！ゆっくり休んでね