UE消息系统（上）：无参消息广播

字数统计: 2.2k字   |   阅读时长≈ 10分

前言

消息系统允许对象之间进行通信而不需要知道对象的具体类型，只需要接受消息的对象完成注册即可接收从各个地方发送来的消息从而执行相关的逻辑。

与UE中的委托类似，但是使用委托在绑定时仍需要知道具体的对象，而消息则不需要，所以使用消息能更进一步完成解耦。

基本的实现方式

可以采取与委托类似的方式，不同的是可以将绑定的信息存储在一个容器中，当消息被发送时就从容器中查找相应的委托并执行逻辑。

定义最基本的结构体

首先在这个容器中存储了一个委托，其次需要一个唯一的标识符，所以相应的应该还有一个ID。

消息的最基本结构体定义完成后，还需要知道消息的具体类型，采用FGameplayTag作为消息类型的标识符。

定义委托：

1
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

所以消息结构体的基本构成为：

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageListenerHandle
{
public:
    FGameplayMessageListenerHandle()
    {

    }

    FMessageDelegate MessageDelegate;
    int64 HandleID;
    FGameplayTag Channel;
};

消息的存储容器

有了消息的基本结构体后，就需要一个容器来存放这些消息。之前定义了FGameplayTag作为消息类型，一个消息同时有一组接收者，因而采取map的形式维护消息类型与接收者之间的映射关系。

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageHandleWarpper
{
public:
    FGameplayMessageHandleWarpper()
    {

    }

    TArray<FGameplayMessageListenerHandle> Events;
};

TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

每个消息的唯一标识ID

使用一个静态成员变量作为标识ID，没当调用注册函数时就为其注册的Handle分配一个HandleID。

消息本身应提供的方法

同时消息本身应该具有合法性判断、解绑、委托执行的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct FGameplayMessageListenerHandle
{
public:
    bool IsValid() const { return HandleID > 0; }
    // 稍后实现
    void Unregister();
protected:
    void Broadcast()
    {
        if(HandleID > 0)
        {
            MessageDelegate.ExecuteIfBound();
        }
    }
};

消息系统的实现

消息系统在整个游戏中明显应该只存在一份，所以采用UE的子系统来实现，同时让消息结构体中持有一份该系统的弱引用：

1
2
3
4
5
6
7
8
9
class UMessageSubsystem:public UGameInstanceSubsystem
{
public:
    bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

    TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

    static TAtomic<int64> HandleID;
};

对于C++的实现

消息的注册

我们提供一个模板方法来完成对消息的注册，为了完成消息的注册，我们需要一些注册的基本信息：注册的消息类型、注册者以及注册的委托函数，所以需要三个基本参数：FGameplayTag、UserObject、Function。

最终提供一个静态方法完成注册：

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
template<typename UserClass>
FGameplayMessageHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* UserObject, FName FunctionName)
{
    if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
                    // 为其分配ID
					MessageHandler.HandleID = ++MessageHanderAlloc;
					// 完成委托的绑定
                    MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					// 确定消息类型
                    MessageHandler.Channel = Channel;
                    // 让该消息持有消息系统
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

消息的执行

在消息执行时只需要传入一个消息类型即可完成消息的发送，同样将其定义为静态方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

消息的解绑

直接对对象持有的消息本身进行解绑，之前我们对消息结构体中定义了Unregister方法，现在只需要实现该方法即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void FGameplayMessageListenerHandle::Unregister()
{
    if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
                // 提供线程安全的移除方法
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	} 
}

对于蓝图实现

蓝图与C++实现最大的区别在于无法直接使用FGameplayMessageHandle这个结构体，在蓝图与C++的交互中，结构体会以值传递的方式传递，即使定义了以引用的方式传递，在蓝图中的结构体进入C++时仍然会拷贝出一个副本，此时无法保证操作的一致性；而类类型在蓝图与C++的交互中是以引用的方式传递，此时可以保证操作的一致性，所以需要对消息结构在做一层类封装。

1
2
3
4
5
6
7
8
9
class UGameplayMessageAction: public UObject
{
public:
    FGameplayMessageListenerHandle ListenerHandler;

    // 用于给蓝图提供注册消息的方法，这也是不选用结构体的另一个原因：蓝图无法调用结构体中的方法
	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

蓝图消息的注册

同样提供静态方法进行注册，不同的是这次不传入函数名而是直接传入一个事件引脚，当发送消息时直接通过蓝图事件来执行，此时便不再需要传入UserObject：

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
UFUNCTION(BlueprintCallable, Category = "Message")
UGameplayMessageAction* K2_RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

蓝图消息的执行与C++消息的执行方式相同，直接调用BroadcastMessage即可。

蓝图消息的解绑

在注册消息时我们使用一个MessageAction接收返回值，并使用它的完成消息解绑：

1
2
3
4
void UGameplayMessageAction::Unregister()
{
    ListenerHandler.Unregister();
}

完整的代码

头文件部分：

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
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

USTRUCT(BlueprintType)
struct FGameplayMessageListenerHandle
{
public:
	friend UMessageSubsystem;

	FGameplayMessageListenerHandle():HandleID(-1)
	{

	}

	FGameplayMessageListenerHandle(UMessageSubsystem* _Subsystem, FGameplayTag _Channel, int64 _HandleID) :Subsystem(_Subsystem), Channel(_Channel), HandleID(_HandleID)
	{

	}

	void Unregister();
	bool IsValid() { return HandleID > 0; }

	FMessageDelegate MessageDelegate;
	TWeakObjectPtr<UMessageSubsystem> Subsystem;
	FGameplayTag Channel;
	int64 HandleID; 
protected:
	void Boardcast();
};

USTRUCT()
struct FMessageHandleWarpper
{
public:
    // 用于结束游戏时清理消息
	void Clear()
	{
		for (FGameplayMessageListenerHandle& Handler : Events)
		{
			Handler.Unregister();
		}
	}

	TArray<FGameplayMessageListenerHandle> Events;
};

UCLASS(BlueprintType)
class UGameplayMessageAction :public UObject
{
public:
	FGameplayMessageListenerHandle ListenerHandler;

	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

/**
 * 
 */
UCLASS()
class UMessageSubsystem : public UGameInstanceSubsystem
{
	GENERATED_BODY()
	
public:
	bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

	virtual void Initialize(FSubsystemCollectionBase& Collection);

	virtual void Deinitialize();

	template<class UserClass>
	static FGameplayMessageListenerHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static UGameplayMessageAction* K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel);

	static TAtomic<int64> MessageHanderAlloc;

	UPROPERTY()
	TMap<FGameplayTag, FMessageHandleWarpper> Messages;
};

template<class UserClass>
inline FGameplayMessageListenerHandle UMessageSubsystem::RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
					MessageHandler.HandleID = ++MessageHanderAlloc;
					MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					MessageHandler.Channel = Channel;
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

源文件部分：

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

TAtomic<int64> UMessageSubsystem::MessageHanderAlloc = -1;

void UMessageSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);
	MessageHanderAlloc = 0;
}

void UMessageSubsystem::Deinitialize()
{
	for (auto& Pair : Messages)
	{
		Pair.Value.Clear();
	}

	Messages.Empty();
	MessageHanderAlloc = -1;
}

UGameplayMessageAction* UMessageSubsystem::K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

void UMessageSubsystem::BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Unregister()
{
	if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Boardcast()
{
	if (HandleID > 0)
	{
		MessageDelegate.ExecuteIfBound();
	}
}

void UGameplayMessageAction::Unregister()
{
	ListenerHandler.Unregister();
}

测试

使用默认的主角类进行测试，在C++中提供以下函数并绑定一些按键进行：

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
   FGameplayMessageListenerHandle TestListenerHandler;

UFUNCTION(BlueprintCallable)
void TestAddListener()
   {
       TestListenerHandler = UETMessageSubsystem::RegisterGameplayMessageListener<AMainCharacter>(this, YourTestTag, this, "TestMessageFunc");
   }

UFUNCTION(BlueprintCallable)
void TestBroadcastListener()
   {      
    UETMessageSubsystem::BroadcastMessage(this, YourTestTag);
   }

UFUNCTION(BlueprintCallable)
void TestUnregisterListener()
   {
       TestListenerHandler.Unregister();
   }

UFUNCTION()
void TestMessageFunc()
   {
   	UE_LOG(LogTemp,Warning,TEXT("TestMessageFunc"));    
   }

在蓝图中则直接可以搜索K2_RegisterGameplayMessageListerner和BroadcastMessage进行绑定和广播，直接调用Action的Unregister()函数即可取消监听。

后续

后续会增加消息的参数传递功能，使其能够携带任意数量的参数进行传递。

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true


个人简介:
大学生一枚，想要从事游戏开发,
希望能做出自己的游戏

主要涉及技术：
UE4、Unity2D、C++