项目地址： https://github.com/liuke101/ProjectGASRPG

GAS 插件

GAS 由多个组件构成：

• **Ability System Component**：核心组件，由 C++ 编写，维持所属 Actor 拥有的所有技能的列表，并处理激活。
• Gameplay Ability ，表示角色的技能，包括攻击、疾跑、施法、翻滚、使用道具等，但不包括基础移动和 UI
  • 由 Gameplay Ability Tasks 以及其他函数构成。
• Attribute Set ，附加到 ASC。
  • 包含 GameplayAttribute ，用于驱动计算或表示资源。
• Gameplay Effects ，处理 Actor 因使用技能而发生的属性更改。
  • Gameplay Effect Calculations ，提供模块化、可复用的方法来计算效果。
  • GameplayCue ，与 GE 关联，并提供数据驱动的方法来处理特效、音效。

GAS 指在处理所有这些用例，方法是将技能建模为负责自身执行的完全独立的实体。

• 谁可以释放技能？ 持有 ASC 组件的 Actor
• 如何编写技能逻辑？ 使用 GameAbility
• 如何技能效果？ 使用 GameEffect (属性修改、增减 Buff, 并不是特效)
• 技能改变的什么属性？ 使用 GamePlayAttribute 属性系统
• 技能释放的条件？ 使用 GameplayTag 进行条件判断
• 技能的视角表现效果？ 使用 GameplayCue
• 技能的长时行动？ 使用 GameplayTask
• 技能消息事件？ 使用 GameplayEvent

在多人游戏中, GAS提供客户端预测支持:

• Ability 激活
• 播放蒙太奇
• 对Attribute的修改
• 应用GameplayTag
• 生成GameplayCue
• 通过连接于CharacterMovementComponent的RootMotionSource函数形成的移动

0 开启 GAS

使用GAS建立一个项目的基本步骤:

1. 在编辑器中启用 GameplayAbilitySystem 插件.。
2. 编辑YourProjectName.Build.cs, 添加"GameplayAbilities", "GameplayTags", "GameplayTasks"到你的PrivateDependencyModuleNames.
3. 刷新/重新生成Visual Studio项目文件.
4. 从4.24开始, 需要强制调用 UAbilitySystemGlobals::InitGlobalData() 来使用 TargetData, 样例项目在 UEngineSubsystem::Initialize() 中调用该函数. 参阅 InitGlobalData() 获取更多信息.

这就是你启用GAS所需做的全部了. 从这里开始, 添加一个ASC和AttributeSet到你的Character或PlayerState, 并开始着手GameplayAbility和GameplayEffect!

1 Ability System Component

ASC 是 GAS 的核心组件（是一个 UActorComponent），用于处理整个框架下的交互逻辑，交互对象包括：

• GameAbility
• GameplayEffect
• GameplayAttribute

从上图的继承关系可以发现, ASC 继承自 UGameplayTasksComponent, 所以它具有执行 Task 的能力; 同时实现了多个接口

所有期望使用 GA, 包含 Attribute, 或者接受 GE 的 Actor 都必须附加 ASC. 这些对象都存于 ASC 并由其管理和复制(除了由 AttributeSet 复制的 Attribute)

• ASC 附加的 Actor 被引用作为该 ASC 的 **OwnerActor**（逻辑上拥有这个 ASC 的 Actor）
• 该 ASC 的物理代表 Actor 被称为 **AvatarActor**（通常是 Pawn，但也可以是塔楼、建筑、炮塔等）.
• OwnerActor 和 AvatarActor 可以是同一个 Actor, 比如 AIController 控制的敌人。
• 它们也可以是不同的 Actor, 比如玩家控制的 Character, 其中 OwnerActor 是 PlayerState, AvatarActor 是 Character 类。
• **绝大多数 Actor 的 ASC 都附加在其自身, 如果你的 Actor 会重生并且重生时需要持久化 Attribute 或 GameplayEffect , 那么 ASC 理想的位置就是 PlayerState*。
• 技能间的互相作用其实就是一个 Actor 上的 ASC 作用到另一个 Actor 上的 ASC

Pawn 被销毁时，身上的 ASC 和属性集也会被销毁。重生后 ASC 和属性集也是新创建的，为默认值。如果使用 PlayState 则可以保存数据！
比如怪物不需要持久化数据，我们可以直接在怪物自身的 Actor 上使用 ASC。而玩家角色需要持久化数据，我们就要使用 PlayState。

IAbilitySystemInterface

OwnerActor 需要继承并实现 **IAbilitySystemInterface**（如果 AvatarActor 和 OwnerActor 是不同的 Actor, 那么 AvatarActor 也应该继承并实现 IAbilitySystemInterface）。

• 该接口只有一个必须重写的 Getter 函数： UAbilitySystemComponent* GetAbilitySystemComponent() const, 其返回一个指向 ASC 的指针, ASC 通过寻找该接口函数来和系统内部进行交互.
• UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(AActor *Actor) 方法也可以获取实现了该接口函数的 Actor 的 ASC

  1 2 3 4 5 6 7 8

  //常规方法：获取实现了接口函数的 Actor 的 ASC if (IAbilitySystemInterface* ASInterface = Cast<IAbilitySystemInterface>(TestActor)) { UAbilitySystemComponent* ASC = ASInterface->GetAbilitySystemComponent() } //⭐使用ASC蓝图库：更方便，若TestActor本身没有实现接口，还会遍历组件 UAbilitySystemComponent* ASC = UAbilitySystemBlueprintLibrary::GetAbilitySystemComponent(TestActor);

OwnerActor 与 AvatarActor 实现接口

项目中角色相关的类有三个，抽象基类 MageCharacterBase ，该基类由两个子类：

• 由 PlayerController 控制的 MageCharacter （后文简称玩家角色）

• 由 AIController 控制的 MageEnemy。（后文简称敌人角色）

• MageCharacter 类需要持久化 Attribute 和 GE 数据，故采用 OwnerActor 和 AvatarActor 分离的方式： MagePlayerState 为 OwnerActor，MageCharacter 为 AvatarActor

• MageEnemy 类采用 OwnerActor 和 AvatarActor 合一的方式，OwnerActor, AvatarActor 都是自身

**OwnerActor 和 AvatarActor 都需要继承并实现 IAbilitySystemInterface**，我们在角色基类中继承了 IAbilitySystemInterface（这样子类 MageCharacter，MageEnemy 也完成了继承）, 我们只需要再在 MagePlayerState 中继承即可。继承后需要实现 GetAbilitySystemComponent () 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//后文的 AMageCharacter、AMageEnemy 都继承自该基类 AMageCharacterBase
class PROJECTGASRPG_API AMageCharacterBase : public ACharacter, public IAbilitySystemInterface
{
    GENERATED_BODY()  
  
public:  
    AMageCharacterBase();  
  
#pragma region GAS
public:
	FORCEINLINE virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override { return AbilitySystemComponent; };
	
protected:
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
	TObjectPtr<UAbilitySystemComponent> AbilitySystemComponent;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

CLASS()
class PROJECTGASRPG_API AMagePlayerState : public APlayerState, public IAbilitySystemInterface
{
	GENERATED_BODY()
	
public:
    //在构造函数中
	AMagePlayerState();

#pragma region GAS
public:
    //实现接口的抽象Getter函数
	FORCEINLINE virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override {return AbilitySystemComponent;}
	
protected:
    // 声明ASC
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Mage_GAS")
	TObjectPtr<UAbilitySystemComponent> AbilitySystemComponent;
#pragma endregion
}

创建

ASC 一般在 OwnerActor 的构造函数中创建并且多人游戏需要明确标记为 Replicated. 必须在 C++中完成.

对于玩家角色，OwnerActor 为 PlayerState，即在 PlayerState 中创建 ASC：

1
2
3
4
5
6
7
8
9
10
11
12
13

AMagePlayerState::AMagePlayerState()
{
    //必须提高网络更新率，后文会讲原因
	NetUpdateFrequency = 100.0f;  

    // 创建ASC组件
	AbilitySystemComponent = CreateDefaultSubobject<UMageAbilitySystemComponent>(TEXT("AbilitySystemComponent"));
	
	//多人游戏需要设置复制
	AbilitySystemComponent->SetIsReplicated(true); 
	AbilitySystemComponent
	->SetReplicationMode(EGameplayEffectReplicationMode::Mixed);
}

对于敌人角色，OwnerActor 为自身：

1
2
3
4
5
6
7

AMageEnemy::AMageEnemy()
{
    AbilitySystemComponent = CreateDefaultSubobject<UMageAbilitySystemComponent>(TEXT("AbilitySystemComponent"));
    AbilitySystemComponent->SetIsReplicated(true);
    AbilitySystemComponent
    ->SetReplicationMode(EGameplayEffectReplicationMode::Minimal);// 注意复制模式和玩家角色类是不同的
}

初始化

OwnerActor 和 AvatarActor 的 ASC 在服务端和客户端上均需初始化，你应该在 Pawn 的 Controller 设置之后(Possess 之后)进行初始化, 单人游戏只需参考服务端的做法。

• 对于玩家角色且 ASC 位于自身（项目采用的是分离方案）：
  • 在服务端 Pawn 的 PossessedBy() 函数中初始化,
  • 在客户端 PlayerController 的 AcknowledgePossession() 函数中初始化.

    1 2 3 4 5 6 7 8 9 10 11 12

    void MyCharacterBase::PossessedBy(AController * NewController) { Super::PossessedBy(NewController); if (AbilitySystemComponent) { AbilitySystemComponent->InitAbilityActorInfo(this, this); } // ASC MixedMode replication requires that the ASC Owner's Owner be the Controller. SetOwner(NewController); }

1
2
3
4
5
6
7
8
9
10
11
12

void MyPlayerControllerBase::AcknowledgePossession(APawn* P)
{
	Super::AcknowledgePossession(P);

	MyCharacterBase* CharacterBase = Cast<MyCharacterBase>(P);
	if (CharacterBase)
	{
		CharacterBase->GetAbilitySystemComponent()->InitAbilityActorInfo(CharacterBase, CharacterBase);
	}

	//...
}

• @ ⭐对于玩家角色且 ASC 位于 PlayerState
  • 在服务端 Pawn 的 PossessedBy() 函数中初始化,
  • 在客户端 PlayerController 的 OnRep_PlayerState() 函数中初始化 （在 Pawn 的 OnRep_PlayerState() 也可以）, 这将确保 PlayerState 成功从服务器复制到客户端

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

/** 服务器初始化 */
void AMageCharacter::PossessedBy(AController* NewController)
{
	Super::PossessedBy(NewController);
	
	InitASC();
}

/** 客户端初始化, 在 PlayerState 复制到客户端时进行回调 */
void AMageCharacter::OnRep_PlayerState()
{
	Super::OnRep_PlayerState();
	
	InitASC();
}

void AMageCharacter::InitASC()
{
	/*
	 * 该函数被 PossessedBy() 和 OnRep_PlayerState()调用 
	 *
	 * PossessedBy(): 在服务器上设置 ASC
	 * - AI 没有 PlayerController，因此我们可以在这里再次 init 以确保万无一失。
	 * - 对于拥有 PlayerController 的 Character，init两次也无妨。
	 *
	 * OnRep_PlayerState():为客户端设置 ASC
	 * - 为客户端init AbilityActorInfo
	 * - 当服务器 possess 一个新的 Actor 时，它将init自己的 ASC。
	 */

    // 获取PlayerState
	AMagePlayerState* MagePlayerState = GetMagePlayerState();
	
    // 将AvatarActor的ASC设置为和OwnerActor创建的的ASC
	AbilitySystemComponent = MagePlayerState->GetAbilitySystemComponent();
	
    // 初始化AbilityActorInfo, 保存ASC的AvatarActor和OwnerActor
	AbilitySystemComponent->InitAbilityActorInfo(MagePlayerState, this);
    ...
}

如果你遇到了错误消息 LogAbilitySystem: Warning: Can't activate LocalOnly or LocalPredicted Ability %s when not local!， 那么就表明 ASC 没有在客户端中初始化.

• @ ⭐对于敌人角色 ASC 位于自身，只需要在 BeginPlay() 中初始化 `

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  void AGDEnemy::BeginPlay() { Super::BeginPlay(); InitASC(); } void AMageEnemy::InitASC() { if(AbilitySystemComponent == nullptr) return; /** 初始化ASC */ AbilitySystemComponent->InitAbilityActorInfo(this, this); ... }

FGameplayAbilityActorInfo

用于缓存 Ability 需要经常访问的 owning Actor 数据（Movement Component, Mesh Component, Anim Instance 等）。

Abilities 使用它来了解要对哪个 actor 进行操作，而不是与特定的 actor 类耦合。
项目可以重载 UAbilitySystemGlobals::AllocAbilityActorInfo 来创建的默认结构类型。

1
2
3
4
5
6
7
8
9
10
11
12
13

//缓存的所有数据类型：
TWeakObjectPtr<AActor>	OwnerActor;
TWeakObjectPtr<AActor>	AvatarActor;

TWeakObjectPtr<APlayerController>	PlayerController;
TWeakObjectPtr<UAbilitySystemComponent>	AbilitySystemComponent;
TWeakObjectPtr<USkeletalMeshComponent>	SkeletalMeshComponent; //avatar 
TWeakObjectPtr<UAnimInstance>	AnimInstance; //avatar
TWeakObjectPtr<UMovementComponent>	MovementComponent; //avatar
	
UPROPERTY(BlueprintReadOnly, Category = "ActorInfo")
FName AffectedAnimInstanceTag; 
UAnimInstance* GetAnimInstance() const;

两个容器

ASC 维护两个容器：

1. 在 FActiveGameplayEffectContainer ActiveGameplayEffect 中保存其当前已经 Apply 的 GE
2. 在 FGameplayAbilitySpecContainer ActivatableAbility 中保存其已经授予的（GiveAbility） GA

ABILITYLIST_SCOPE_LOCK

当你想遍历 ActivatableAbility 时, 确保在循环体之上添加 ABILITYLIST_SCOPE_LOCK(); 来锁定列表以防其改变 (比如移除一个 Ability).

1
2

//GameplayAbilitySpec.h中的一个宏定义
#define ABILITYLIST_SCOPE_LOCK()	FScopedAbilityListLock ActiveScopeLock(*this);

FScopedAbilityListLock 用于阻止我们在迭代 Ability 时从 ASC 中移除 Ability

• 每个域中的 ABILITYLIST_SCOPE_LOCK() 会增加 AbilityScopeLockCount, 之后出域时会减量.
• 不要尝试在 ABILITYLIST_SCOPE_LOCK() 域中移除某个 Ability (Ability 删除函数会在内部检查 AbilityScopeLockCount 以防在列表锁定时移除 Ability).

示例：

1
2
3
4
5
6
7
8
9
10

void UMageAbilitySystemComponent::ForEachAbility(const FForEachAbilityDelegate& AbilityDelegate)
{
	/** 遍历 ActivatableAbilities 时, 锁定列表 */
	ABILITYLIST_SCOPE_LOCK();
	
	for(const FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
	{
		...
	}
}

复制模式

• ASC 定义了三种不同的复制模式用于复制 GameplayEffect 到客户端, GameplayTag 和 GameplayCue ： Full, Mixed 和 Minimal.
• Attribute 由其 AttributeSet 复制。

2023.10.6 根据 GAS 视频教程修正描述

• Mixed 模式要求 OwnerActor 的 Owner 必须是 Controller。
• Pawn 在 PossessedBy() 中自动设置，PlayerState 的 Owner 默认是 Controller ，但是 Character 不是。
• 如果 OwnerActor 不是 PlayerState 时使用 Mixed 模式, 那么需要使用 PossessedBy() 设置新的 Controller 为 Pawn 的 Owner。

  PossessedBy() ：当该 Pawn 被 possess 时调用。仅在服务器（或单机）上调用。

NetUpdateFrequency

如果 ASC 位于 PlayerState, 那么你需要提高 PlayerState 的 NetUpdateFrequency, 其默认是一个很低的值（在 PlayerState 构造函数中设为 100.0f 即可）, 因此在客户端上发生 Attribute 和 GameplayTag 改变时会造成延迟或卡顿. 确保启用 Adaptive Network Update Frequency, Fortnite 就启用了该项.

1
2
3
4
5
6

//在PlayerState构造函数中设置
AMagePlayerState::AMagePlayerState()
{
	NetUpdateFrequency = 100.0f;
	...
}

2 Gameplay Tags

Gameplay Tags 有助于确定玩法技能之间的交互方式。每种技能都拥有一组标记，以可影响其行为的方式识别和分类技能，还有玩法标记容器和游戏标记查询，用于支持与其他技能进行交互。

FGameplayTag 是由 GameplayTagManager 注册的形似 Parent.Child.Grandchild... 的层级 FName, 这些标签对于分类和描述对象的状态非常有用, 例如, 如果某个 Character 处于眩晕状态, 我们可以给一个 State.Debuff.Stun 的 GameplayTag.

你会发现自己使用 GameplayTag替换了过去使用布尔值或枚举值来编程, 并且需要对对象有无特定的 GameplayTag 做布尔逻辑判断. 比如 AI 在行为树的 Decorator 节点中，通过玩家拥有的 Gameplay Tag 来判断玩家是否处于无敌帧、喝药。

当给某个对象设置标签时, 如果它有 ASC 的话, 我们一般添加标签到 ASC 以与其交互。 UAbilitySystemComponent 继承 IGameplayTagAssetInterface 接口的函数来访问其拥有的 GameplayTag.

IGameplayTagAssetInterface

如果 Actor 想要使用 FGameplayTagContainer 来保存 GameplayTag，需要继承 IGameplayTagAssetInterface 接口。

• 该 Actor 必须重载 Getter 函数 GetOwnedGameplayTags ，返回 Actor 中的 FGameplayTagContainer
• 同时 Actor 会继承三个标签匹配函数，用于对 TagContainer 存储的标签进行匹配

1
2
3
4
5
6
7
8

// 必须重载该Getter函数
virtual void GetOwnedGameplayTags(FGameplayTagContainer& TagContainer) const=0;

// 同时Actor会继承三个函数，用于对TagContainer存储的标签进行匹配
virtual bool HasMatchingGameplayTag(FGameplayTag TagToCheck) const;
virtual bool HasAllMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const;
virtual bool HasAnyMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const;

FGameplayTagContainer

[!quote]

• 跟踪 Tag 应用的数量（次数）结构体。明确跟踪添加或删除的 Tag, 同时跟踪 Parent Tag 的数量。
• 每当任何 Tag（或其 Parent Tag）的标签计数被修改时，都会触发事件/委托。

多个 GameplayTag 可被保存于一个 FGameplayTagContainer 中, 内部封装了 TArray<FGameplayTag> 。不建议自定义 TArray 来保存 Tag, 因为 GameplayTagContainer 做了一些很有效率的优化，并且为我们实现了很多标签匹配相关的功能函数。

• GameplayTagContainer 或 ASC 可以使用 GetGameplayTagArray 函数返回指定 FGameplayTag 的 TArray 用于遍历。
• GameplayTagContainer 使用 GameplayTagCountMap 保存了每个 GameplayTag 和其实例数量的映射，可以通过 GetTagCount 访问实例数量。（或 ASC 得 GetGameplayTagCount 函数）
• 因为标签是标准的 FName, 所以当在项目设置中启用 Fast Replication 后, 它们可以高效地打包进 FGameplayTagContainer 以用于复制。 Fast Replication 要求服务端和客户端有相同的 GameplayTag 列表, 这通常不是问题, 因此你应该启用该选项。
• 除了 Fast Replication, GameplayTag 编辑器可以选择填充普遍需要复制的 GameplayTag 以对其深度优化.

Tag 变化委托

FGameplayTagContainer 实现了两个委托返回函数，可以绑定这两个委托监听 Tag 变化（ASC 对其进行了封装，可以通过 ASC 调用）

1
2
3
4
5

//监听指定Tag的变化
FOnGameplayEffectTagCountChanged& RegisterGameplayTagEvent(const FGameplayTag& Tag, EGameplayTagEventType::Type EventType=EGameplayTagEventType::NewOrRemoved);
	
//监听全部Tag的变化
FOnGameplayEffectTagCountChanged& RegisterGenericGameplayEvent()

ASC 使用该委托监听 Tag 变化的例子：
监听 Effects_HitReact Tag 的变化，来决定是否应用受击反馈

1
2
3

/** 受击反馈, 当角色被GE授予 Tag 时触发 */
AbilitySystemComponent->RegisterGameplayTagEvent
(FMageGameplayTags::Get().Effects_HitReact,EGameplayTagEventType::NewOrRemoved).AddUObject(this, &AMageEnemy::HitReactTagChanged);

1
2
3
4
5
6
7

void AMageEnemy::HitReactTagChanged(const FGameplayTag CallbackTag, const int32 NewCount)
{
    //NewCount即Tag的数量，大于0说明该Tag被授予给了敌人
	bHitReacting = NewCount > 0; 
	// 如果受击，则禁止移动
	GetCharacterMovement()->MaxWalkSpeed = bHitReacting ? 0.0f : DefaultMaxWalkSpeed;
}

获取 Tag

C++中获取 GameplayTag 引用:

1

FGameplayTag::RequestGameplayTag(FName("Your.GameplayTag.Name"))

对于像获取父或子 GameplayTag 的高阶操作, 请查看 GameplayTagManager 提供的函数.

网络复制与 LooseGameplayTag

Loose：松散，意思就是这个 Tag 不是通过 GE 授予得 Tag，而是直接添加到 ASC 的。

如果 GameplayTag 由 GameplayEffect 添加, 那么其就是可复制的。

ASC 允许你添加不可复制的 LooseGameplayTag 且必须手动管理 TagCount 。ASC 为我们提供了一些函数来更新 LooseGameplayTag 数量：

1
2
3

void AddLooseGameplayTag(const FGameplayTag& GameplayTag, int32 Count=1)
void RemoveLooseGameplayTag(const FGameplayTag& GameplayTag, int32 Count = 1)
...

过滤Tag

GameplayTag 和 GameplayTagContainer 有可选 UPROPERTY 元数据标签 Meta = (Categories = "GameplayCue") 用于在蓝图中过滤标签而只显示父标签为 GameplayCue 的 GameplayTag, 当你知道 GameplayTag 或 GameplayTagContainer 变量应该只用于 GameplayCue 时, 这将是非常有用的.
作为选择, 有一单独的FGameplayCueTag结构体可以包裹FGameplayTag并且可以在蓝图中自动过滤GameplayTag而只显示父标签为GameplayCue的标签.

通过 C++ 创建和管理 Tag

使用 C++来创建和管理 Tag 可以使得代码更加灵活，这是除了使用 ini 或数据表配置 Tag 的另外一种方式。重要的是，我们可以在 C++中访问这些 Tag!

实现步骤如下：

1. 创建饿汉式单例 C++ 类 FMageGameplayTags

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

#pragma once
#include "CoreMinimal.h"
#include "GameplayTagContainer.h"

/**
  * 饿汉式单例模式
  * 
  * 访问GameplayTag的方法：
  * 1. 获取单例：const FMageGameplayTags& GameplayTagsInstance = FMageGameplayTags::Instance();
  * 2. 通过单例访问FGameplayTag成员变量：GameplayTagsInstance.Character_Player
  */
class FMageGameplayTags
{
public:
	static const FMageGameplayTags& Instance() { return TagsInstance; } 

	/* 添加C++Native(原生) GameplayTag, 不再使用ini或数据表配置Tag */
	static void InitNativeGameplayTags();
	
	// 示例Tag
	FGameplayTag Character_Player;
	FGameplayTag Character_Enemy;

private:  
    static FMageGameplayTags TagsInstance;
}

1
2
3
4
5
6
7
8
9
10

/** 全局变量,但是由于TagsInstance是private成员,其他类访问不到。所以这里只起到初始化静态成员变量的作用（创建实例） */
FMageGameplayTags FMageGameplayTags::TagsInstance; 

void FMageGameplayTags::InitNativeGameplayTags()  
{  
    /** AddNativeGameplayTag() 将Tag注册到引擎， GameplayTagsInstance则将Tag存储一份，放便读取 */
    TagsInstance.Character_Player = UGameplayTagsManager::Instance().AddNativeGameplayTag(FName("Character.Player"),FString("玩家"));

    TagsInstance.Character_Enemy = UGameplayTagsManager::Instance().AddNativeGameplayTag(FName("Character.Enemy"),FString("敌人"));
}

2. 创建 UMageAssetManager 类继承 UAssetManager，调用 InitNativeGameplayTags();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#pragma once
#include "CoreMinimal.h"
#include "Engine/AssetManager.h"
#include "MageAssetManager.generated.h"

UCLASS()
class PROJECTGASRPG_API UMageAssetManager : public UAssetManager
{
	GENERATED_BODY()

public:
	static UMageAssetManager& Get();

protected:
	virtual void StartInitialLoading() override;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

UMageAssetManager& UMageAssetManager::Get()
{
	check(GEngine);
	UMageAssetManager* MageAssetManager = Cast<UMageAssetManager>(GEngine->AssetManager);
	return *MageAssetManager;
}

void UMageAssetManager::StartInitialLoading()
{
	Super::StartInitialLoading();

    // 调用InitNativeGameplayTags();
	FMageGameplayTags::InitNativeGameplayTags();

	/** TargetData必须执行该操作，否则造成ScriptStructCache错误 */
	UAbilitySystemGlobals::Get().InitGlobalData();
}

3. 设置引擎的资产管理器类
   
   或通过 ini 设置：

   1 2 3 4 5

   [/Script/Engine.Engine] //... //添加 = /Script/项目名/资产管理类名 AssetManagerClassName = /Script/ProjectGASRPG.MageAssetManager

完成后，就可以在项目设置的 GameplayTagList 中查看到添加的 GameplayTag。

3 Attribute

01 定义

Attribute 是由 FGameplayAttributeData 结构体定义的浮点值，其可以表示生命值、等级、药水回复量等, 如果某项数值是属于某个 Actor 且游戏相关的, 你就应该考虑使用 Attribute。

Attribute 一般应该只能由 GE 修改, 这样 ASC 才能预测(Predict)其改变. [[#与 Gameplay Effects 互动]]
![[GAS精粹#^nwhtjz]]

Attribute 也可以由 AttributeSet 定义并存于其中.。**AttributeSet 用于复制那些标记为 Replication 的 Attribute**

[!tip]
如果你不想某个 Attribute 显示在编辑器的 Attribute 列表, 可以使用 Meta = (HideInDetailsView) 元属性

02 BaseValue 与 CurrentValue

FGameplayAttributeData 定义了 BaseValue 和 CurrentValue 。并提供获取他们的函数。

一个 Attribute 是由两个值 ： BaseValue 和 CurrentValue 组成的。

• BaseValue 是 Attribute 的永久值
• CurrentValue 是 BaseValue 加上 GameplayEffect 给的临时修改值后得到的。

  例如, 你的 Character 可能有一个 BaseValue 为600的移动速度 Attribute, BaseValue 和 CurrentValue 为600。如果 Character 通过 GE 获得了一个50 的移动速度加成, 那么 BaseValue 仍然是600 ，而 CurrentValue 是600+50=650, 当该移动速度加成消失后, CurrentValue 就会变回 BaseValue 的600。

[!bug]
不能将 BaseValue 作为 Attribute 的最大值使用！可以修改或引用的 Ability/UI 中的 Attribute 最大值应该是另外单独的一个 Attribute。

对于硬编码的最大值和最小值, 有一种方法是使用可以设置最大值和最小值的 FAttributeMetaData 定义一个 DataTable [[#使用数据表初始化(不推荐)]], 但是 Epic 在该结构体上的注释称之为”work in progress”, 详见 AttributeSet.h.

为了避免这种疑惑, 我建议引用在 Ability 或 UI 中的最大值应该单独定义 Attribute, 只用于限制(Clamp) Attribute 大小的硬编码最大值和最小值应该在 AttributeSet 中定义为硬编码浮点值。

关于 Clamp Attribute 值的问题在 [[#06 PreAttributeChange()]] 中讨论了 CurrentValue 的修改, 在 [[#07 PostGameplayEffectExecute()]] 中讨论了 GameplayEffect 对 BaseValue 的修改。**

DurationType 与 Value 的关系：

• (Instant)GE 可以永久性的修改 BaseValue
• (Periodic)GE 被视为 (Instant)GE 并且可以修改 BaseValue。
• (Duration)GE 和 (Infinite)GE 可以修改 CurrentValue.

03 MetaAttribute

首先说明，MetaAttribute 并没有对应的类，而只是一种特殊的 Attribute，和其他属性一样都是 FGameplayAttributeData 。

我们通常定义伤害值为 MetaAttribute, 项目中称为 MetaDamage 。使用 MetaDamage 作为临时占位符（可以理解为中间值，temp 值） , 而不是使用 GE 直接修改生命值属性, 使用这种方法，允许我们在造成伤害之前执行所有的数学运算（在 Execution Calculation 中计算，在属性集中处理）。处理结束后 MetaAttribute 归零。

伤害值就可以在 Execution(GameplayEffectExecutionCalculation) 中由 buff 和 debuff 修改, 并且可以在 AttributeSet 中进一步操作, 例如, 在最终将生命值减去伤害值之前, 要将伤害值减去当前的护盾值.

• 伤害值 MetaAttribute 在 GE 之间不是持久化的, 并且可以被任何一方重写。
• MetaAttribute 是不可复制的.
• MetaAttribute 对于在”我们应该造成多少伤害?”和”我们该如何处理伤害值?”这种问题之中的伤害值和治疗值做了很好的解构, 这种解构意味着 GE 和 Execution Calculation 无需了解目标是如何处理伤害值的。

尽管 MetaAttribute 是一个很好的设计模式, 但其并不是强制使用的。如果你只有一个用于所有伤害实例的 Execution Calculation 和一个所有 Character 共用的 AttributeSet 类, 那么你就可以在 Exeuction Calculation 中分配伤害到生命, 护盾等等, 并直接修改那些 Attribute, 这种方式你只会丢失灵活性, 但总体上并无大碍.

使用方法

项目中使用元属性计算伤害值和获得的经验值，下面以伤害值元属性 MetaDamage 为例：

1. 在 AttributeSet 中创建 MetaAttribute（不需要设置复制）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   UCLASS() class PROJECTGASRPG_API UMageAttributeSet : public UAttributeSet { GENERATED_BODY() public: /** Meta Attributes */ #pragma region "伤害值元属性 MetaDamage" UPROPERTY(BlueprintReadOnly, Category = "Mage_Attributes|Meta") FGameplayAttributeData MetaDamage; ATTRIBUTE_ACCESSORS(UMageAttributeSet, MetaDamage) #pragma endregion }

2. 我们需要使用 GE 修改 MetaDamage 的值。首先建立一个 GE 蓝图，项目中命名为 GE_ExecCalc_Damage 。从名字也可以看出来，我们使用了 Execution Calculation 的方法计算伤害值。详细用法可见： [[#12 Execution Calculation]]

   • GE 设置如下：
     • 其中 Calculation Class 指定我们创建的 C++类 ExecCalc_Damage
     • 使用 Execution Calculation 方法允许我们捕获 GE 源对象和目标对象的 Attribute，从而我们可以知道玩家角色的攻击力和敌人角色的防御力等信息，完成伤害值的数学运算。

1
2
3
4
5
6
7
8
9

void UExecCalc_Damage::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams,
	FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
{
    /** 执行数学运算，计算最终的伤害值FinalDamage */
    ...
    /** 修改MetaDamage属性 */
	const FGameplayModifierEvaluatedData EvaluatedData(UMageAttributeSet::GetMetaDamageAttribute(), EGameplayModOp::Additive, FinalDamage);
	OutExecutionOutput.AddOutputModifier(EvaluatedData);
}

3. 完成伤害计算后，我们可以在属性集 PostGameplayEffectExecute 函数中 GetMetaDamage()，进而判断角色是否受伤，是否死亡。
4. 最后记得将元属性清零，防止干扰下一次伤害计算。

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

void UMageAttributeSet::PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data)
{
    /** 伤害计算, MetaAttribute不会被复制，所以以下只在服务器中进行 */
	if(Data.EvaluatedData.Attribute == GetMetaDamageAttribute())
	{
		CalcMetaDamage(Property);
	}
}

void UMageAttributeSet::CalcMetaDamage(const FEffectProperty& Property)
{
    //获取元属性
	const float TempMetaDamage = GetMetaDamage();
		
	if(TempMetaDamage > 0.0f)
	{
		const float NewHealth = GetHealth() - TempMetaDamage;
		SetHealth(FMath::Clamp<float>(NewHealth, 0.0f, GetMaxHealth()));
			
		const bool bIsDead = NewHealth <= 0.0f; // 用来判断死亡
		if(bIsDead)
		{
			/** 死亡反馈 */
		}
		else
		{
			/** 受击反馈 */
		}
		/** 显示伤害浮动数字 */
		/** Debuff */
	}
	else
	{
		//伤害为0仍显示伤害浮动数字
	}
		
	SetMetaDamage(0.0f); //元属性清0
}

04 派生属性 Derived Attribute

**要使 Attribute 的部分或全部值派生于（继承）一个或多个其他 Attribute, 可以使用基于一个或多个 Attribute 或 MMC Modifiers 的 (Infinite)GE**。当 Derived Attribute 依赖的 Attribute 更新时它也会自动更新。

在 Derived Attribute 上的所有 Modifier 形成的最终公式和 Modifier Aggregators 的公式是一样的。 如果您需要按特定顺序进行计算，请在 MMC 内完成所有操作。

1

((CurrentValue + Additive) * Multiplicitive) / Division

Backing : 备份的意思

一个关于对派生属性应用 (Infinite)GE 的 BUG（此 BUG 只影响 PIE，打包后正常）：
本项目应用名为 GE_Secondary_Attributes 的 (Infinite)GE，基于主属性来改变副属性。当主属性发生变化时，该 GE 会将其 Modifiers 应用到副属性中。这在单人游戏中有效。

但在多人游戏中，使用派生属性的 (Infinite)GE 只对最后进入游戏的客户端应用其 Modifiers。 无论 (Infinite)GE 是否应用于所有玩家，也无论是否应用于服务器，这种情况都会发生。由于 (Infinite)GE 无法应用于所有玩家，因此这对多人游戏来说并不理想，您需要以不同的方式实现派生属性。

最简单的解决方法是在 PostGameplayEffectExecute 中检查 Primary Attributes 的变化，并在此应用您对 Secondary Attributes 的自定义修改(本项目就采用这种方法更新副属性，舍弃了 MMC 方案, MMC 方案也会有派生属性的这个 BUG???)

1
2
3
4
5
6
7
8
9
10
11
12
13

/** 根据 Primary Attribute 的变化更新 Secondary Attributes */
if(Data.EvaluatedData.Attribute == GetStrengthAttribute())
{
    /** 更新相关的属性 */
    UpdateMaxHealth(PSourceCharacterLevel);
}

void UMageAttributeSet::UpdateMaxHealth(float CharacterLevel)
{
	const float NewMaxHealth = GetStrength() * 2.0f + GetStamina() * 19.4f + CharacterLevel * 10.0f;
	SetMaxHealth(NewMaxHealth);
}
...

在这里，由于您可以访问 owning player 的相关类（包括 PlayerState），您可以在这里考虑任何值，例如玩家的等级等。这在多人游戏中适用于所有客户端和服务器上的 hosting player。实际上，这比创建 Infinite Duration Gameplay 和相应的 MMC 要省事得多。

[!BUG]
如果在 PIE 中打开多个窗口, 你需要在编辑器首选项中禁用 Run Under One Process, 否则当自动推导 Attribute 所依赖的 Attribute 更新时, 除了第一个窗口外其不会更新.

4 AttributeSet

[!NOTE]
只能用 C++ 中创建属性和属性集

GAS 主要通过 属性集（AttributeSet） 与 Actor 交互，其中包含 Gameplay Attribute。

使用 Attribute 可带来多项优势：

• 属性集提供了一组一致、可复用的属性，可用于构建系统。
• GA 可以通过反射访问 GameplayAttribute，以便可以直接在蓝图编辑器中创建简单的计算和效果。
• GameplayAttribute 会单独追踪 Base Value 和 Current Value，这样就更容易创建临时修改（增益和减益）以及持久效果。
• GameplayAttribute 还会将其值复制到所有客户端，适合直观地显示敌方血条等本地 UI。

使用多个属性集是完全可能的应用场景，比如玩家和敌人都拥有同一个属性集，包含 Health, Mana, Attack Damage, Defense。而玩家拥有一个额外的属性集包含常见的 RPG 属性，比如 Strength, Intelligence, Constitution 等等。很棒的一点是系统让你能够混用这些属性集，因为属性集注册到 ASC 后，系统可以自动识别属性集属于哪个ASC。

[!bug]
在某些情况下，GameplayAttribute 可以在没有属性集的情况下存在。这通常表明，某个 GameplayAttribute 被保存在一个 ASC 上，而这个组件没有一个包含适当类型 GameplayAttribute 的属性集。这种方法并不推荐，因为这种 GameplayAttribute 除了作为浮点值保存外，不会与 GAS 的任何部分交互。

01 注册 AttributeSet 到 ASC

AttributeSet 继承自 UAttributeSet，用于定义, 保存以及管理对 Attribute 的修改。在 OwnerActor 的构造函数中创建的 AttributeSet 将会自动注册到 ASC。在此之后，ASC 可以访问你分配给 AttributeSet 的属性。

必须在 C++中注册：

1. 继承属性集类 UAttributeSet，重载两个重要的函数：

   1 2 3 4 5 6 7 8 9 10 11 12

   UCLASS() class PROJECTGASRPG_API UMageAttributeSet : public UAttributeSet { GENERATED_BODY() public: UMageAttributeSet(); virtual void PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue) override; virtual void PostGameplayEffectExecute(const FGameplayEffectModCallbackData& Data) override; }

2. 在 OwnerActor 和 AvatarActor 上创建属性集，Getter 函数使用 const 关键字 来确保代码不能直接修改属性集：

• 对于玩家角色类，在 PlayerState 构造函数中创建属性集

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  class PROJECTGASRPG_API AMagePlayerState : public APlayerState, public IAbilitySystemInterface { public: AMagePlayerState(); //为了方便获取属性集，创建一个Getter函数 FORCEINLINE virtual UAttributeSet* GetAttributeSet() const { return AttributeSet; }; protected: UPROPERTY(VisibleAnywhere, BlueprintReadOnly) TObjectPtr<UAttributeSet> AttributeSet; } AMagePlayerState::AMagePlayerState() { AttributeSet = CreateDefaultSubobject<UMageAttributeSet>(TEXT("AttributeSet")); }

在 AvatarActor 上拷贝 MagePlayerState 中的属性集，即 OwnerActor 和 AvatarActor 的属性集是相同的。前文 ASC 的创建也是这样实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class PROJECTGASRPG_API AMageCharacterBase : public ACharacter, public IAbilitySystemInterface
{
	FORCEINLINE virtual UAttributeSet* GetAttributeSet() const { return AttributeSet; };

	UPROPERTY()
	TObjectPtr<UAttributeSet> AttributeSet;

	/** 初始化ASC，前面介绍ASC的时候已经讲过,我们在这里复制属性集，这样就可以随着ASC一起被初始化 */
	virtual void InitASC();
}

void AMageCharacter::InitASC()
{
	AttributeSet = MagePlayerState->GetAttributeSet(); 
}

• 对于敌人角色类，直接在自身构造函数中创建

  1 2 3 4

  AMageEnemy::AMageEnemy() { AttributeSet = CreateDefaultSubobject<UMageAttributeSet>(TEXT("AttributeSet")); }

[!warning] 注意

• 一个 ASC 可以有多个属性集，但每个属性集必须与所有其它属性集的类不同。
• 如果使用 GE 来修改 ASC 没有的 GamplayAttribute ，这样做会使技能系统组件为自己创建一个匹配的游戏玩法属性。然而，这个方法并不会创建一个属性集，也不会将游戏玩法属性添加到任何现有的属性集中。

02 定义 Attribute

Attribute 只能使用 C++ 在 AttributeSet 头文件中定义.

建议把下面这个 ATTRIBUTE_ACCESSORS宏添加到每个 AttributeSet 头文件的顶部, 可以很方便的定义每个属性的 Getter、Setter、Init 函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/**
 * 该宏复制自AttributeSet.h，使用时将该宏复制到自定义的属性集头文件中，项目中在MageAttributeSet.h中
 * 
 * 自动为每个Attribute生成以下函数：（以Health为例）
 * static FGameplayAttribute UMyHealthSet::GetHealthAttribute(); 
 * FORCEINLINE float UMyHealthSet::GetHealth() const; ==> GetCurrentValue
 * FORCEINLINE void UMyHealthSet::SetHealth(float NewVal); ==>  SetBaseValue
 * FORCEINLINE void UMyHealthSet::InitHealth(float NewVal); ==> SetBaseValue / SetCurrentValue
 *	
 * 用法：ATTRIBUTE_ACCESSORS(UMyHealthSet, Health)
 */
#define ATTRIBUTE_ACCESSORS(ClassName, PropertyName) \
		GAMEPLAYATTRIBUTE_PROPERTY_GETTER(ClassName, PropertyName) \
		GAMEPLAYATTRIBUTE_VALUE_GETTER(PropertyName) \
		GAMEPLAYATTRIBUTE_VALUE_SETTER(PropertyName) \
		GAMEPLAYATTRIBUTE_VALUE_INITTER(PropertyName)

添加完这些之后，你的属性集类定义应该是如下所示（以 Health 属性为例）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

UCLASS()
class PROJECTGASRPG_API UMageAttributeSet : public UAttributeSet
{
	GENERATED_BODY()

public:
	UMageAttributeSet();

public:
// 项目为了添加属性格式统一，将属性声明和宏声明放在了一起，建议实际项目中将属性声明设为protected或private
// 多人游戏需要考虑属性复制
#pragma region "生命值 Health"
	UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_Health)
	FGameplayAttributeData Health;
	ATTRIBUTE_ACCESSORS(UMageAttributeSet, Health)
	
	UFUNCTION()
	virtual void OnRep_Health(const FGameplayAttributeData& OldData) const;
#pragma endregion
    ...
}

AttributeSet 的. cpp 文件应该用预测系统使用的 GAMEPLAYATTRIBUTE_REPNOTIFY 宏填充 OnRep 函数。
该辅助宏用于 RepNotify 函数，以处理将被客户端预测修改的属性。

1
2
3
4

void UMageAttributeSet::OnRep_Health(const FGameplayAttributeData& OldData) const
{
	GAMEPLAYATTRIBUTE_REPNOTIFY(UMageAttributeSet, Health, OldData);
}

最后, Attribute需要添加到GetLifetimeReplicatedProps:

1
2
3
4
5
6
7
8
9
10
11
12

void UMageAttributeSet::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

	/*
	 * 这里列出我们想要复制的属性
	 * 
	 * COND_None：此属性没有条件，并将在其发生变化时随时发送（服务器）
	 * REPNOTIFY_Always：RepNotify函数在客户端值已经与服务端复制的值相同的情况下也会触发(因为有预测)
	 */
	DOREPLIFETIME_CONDITION_NOTIFY(UMageAttributeSet, Health, COND_None, REPNOTIFY_Always);
}

REPTNOTIFY_Always 用于设置 OnRep 函数在客户端值已经与服务端复制的值相同的情况下触发(因为有预测), 默认设置下, 客户端值与服务端复制的值相同时, OnRep 函数是不会触发的。

如果 Attribute 无需复制（比如 MetaAttribute ）, 那么 OnRep 和 GetLifetimeReplicatedProps 步骤可以跳过。

03 初始化 Attribute

有多种方法可以初始化 Attribute (将 BaseValue 和 CurrentValue 设置为某初始值).

通过 GE（推荐）

建议使用 (Instant)GE修改属性，这种方法可以支持预测, 这也是项目使用的方法。

创建 GE 并设置 Modifier 指定要修改的属性，然后将 GE 应用到角色类的 ASC 即可。

详情可查看角色类的 InitDefaultAttributes() 函数

通过 ATTRIBUTE_ACCESSORS 宏的 Init 方法

如果在定义Attribute时使用了ATTRIBUTE_ACCESSORS宏, 那么在AttributeSet中会自动为每个Attribute生成一个初始化函数.

1
2

// InitHealth(float InitialValue) 是一个自动生成的函数，用于使用 "ATTRIBUTE_ACCESSORS "宏定义的属性 "Health"。
AttributeSet->InitHealth(100.0f);

查看AttributeSet.h获取更多初始化Attribute的方法.

使用数据表初始化(不推荐)

如果你选择不通过调用有硬编码值的初始化函数来初始化你的属性集和游戏玩法属性，你可以使用一个数据表来初始化，使用 AttributeMetaData 类。你可以从外部文件导入数据，或者在编辑器中手动填充数据表。

注意命名，必须是已经在C++定义的属性

Character 的 ASC 组件中查看

导入数据表

开发者通常会从. csv 文件中导入数据表，如下所示：

1
2

---,BaseValue,MinValue,MaxValue,DerivedAttributeInfo,bCanStack
MyAttributeSet.Health,"100.000000","0.000000","150.000000","","False"

“MinValue”和”MaxValue”栏不会在默认的 GAS 插件中执行，这些值不会有任何影响。

将. csv 文件导入为数据表资产时，请选择”AttributeMetaData”行类型。

手动填充数据表

如果你喜欢在虚幻编辑器中编辑数值，而不是在外部电子表格或文本编辑程序中编辑数值，你可以创建表格，然后像其它蓝图资产一样打开它来编辑数值。使用窗口顶部的”添加”按键为每个游戏玩法属性添加一行。请记住，命名惯例是”AttributeSetName.AttributeName“，也就是”属性集名称. 属性名称”，而且是区分大小写的。

多属性集 FAttributeSetInitter

FAttributeSetInitter 是定义在 AttributeSet.h 中的Helper struct，有助于从电子表格（UCurveTable）初始化属性集默认值。

可以读取不同的属性集，适合多个属性集的项目

基本思想是在这种形式的电子表格中：

• 表格中行的形式为：[GroupName].[AttributeSetName].[Attribute]
  • GroupName：用于标识 “组 “的任意名称
  • AttributeSetName ：该属性属于哪个 UAttributeSet。(请注意，这只是 UClass 名称的简单部分匹配。”Health”匹配 “UMyGameHealthSet”）。
  • Attribute： 实际属性的名称（与全名匹配）。
• 列表示 “Level “。

1
2
3
4
5

// 这将把 CurveTable 转换为更有效的格式，以便在运行时读取。例如，应从 UAbilitySystemGlobals 中调用。  
FAttributeSetInitter::PreloadAttributeSetData(UCurveTable*)  

// 使用指定的 GroupName 和 Level 初始化给定 ASC 的属性集。游戏代码会在 Spawn新的Actor 或 Actor升级 等情况下调用此功能。  
FAttributeSetInitter::InitAttributeSetDefaults(UAbilitySystemComponent* AbilitySystemComponent, FName GroupName, int32 Level) const;

代码示例：

1

IGameplayAbilitiesModule::Get().GetAbilitySystemGlobals()->GetAttributeSetInitter()->InitAttributeSetDefaults(MyCharacter->AbilitySystemComponent, "Hero1", MyLevel);

• 这样，系统设计人员就可以为属性指定任意值。它们可以基于任何他们想要的公式。
• 等级上限非常高的项目可能希望采用更简单的 “每级获得属性 “方法。
• 在此方法中初始化的任何东西都不应该被 GE 直接修改。例如，如果 MaxMoveSpeed 随等级变化，那么其他任何修改 MaxMoveSpeed 的行为都应使用non-instant 的GE
• “Default”目前是硬编码的后备组名。如果调用 InitAttributeSetDefaults 时没有有效的组名，我们将回退到默认组名。

04 使用 GE 修改 Attribute

• ! 我们可以直接修改 Attribute ，方法是使用 const_cast 移除 const。但不推荐在 GAS 框架中这样使用 ^nwhtjz

  1 2 3 4 5 6 7 8 9 10 11

  if(IAbilitySystemInterface* ASInterface = Cast<IAbilitySystemInterface>(OtherActor)) { if(const UMageAttributeSet* MageAttributeSet = Cast<UMageAttributeSet>(ASInterface->GetAbilitySystemComponent()->GetAttributeSet(UMageAttributeSet::StaticClass()))) { //使用const_cast移除 const，进而以一种Hack的方式修改Attribute，危险！ UMageAttributeSet* MutableMageAttributeSet = const_cast<UMageAttributeSet*>(MageAttributeSet); MutableMageAttributeSet->SetHealth(MageAttributeSet->GetHealth() + 10.0f); Destroy(); } }

为了实现网络预测，必须通过与之相关的 GE 来修改。

05 生命周期函数

属性集提供了多个生命周期函数方法：

• PreAttributeBaseChange ()
  • 当属性的聚合器存在时，当属性 BaseValue 修改之前调用。
  • 此函数应强制执行 Clamp
  • 此函数不应调用与游戏相关的事件或回调。
• `PostAttributeBaseChange()
  • 当属性的聚合器存在时，当属性的 BaseValue 修改之后调用
• PreAttributeChange()
  • 属性的 CurrentValue 修改之前调用
• PostAttributeChange()
  • 属性的 CurrentValue 修改之后调用
• PreGameplayEffectExecute()
  • 在 GE 通过 ExecutionCalculation 修改属性集之前调用
  • 带有一个 FGameplayEffectModCallbackData 参数，由 GameplayEffectExecutionCalculation 提供(包含它要修改那个状态，值为多少)。
  • 通过返回一个 bool 值决定是否允许 GameplayEffectExecutionCalculation 影响属性集，默认为true
• PostGameplayEffectExecute()
  • 在 PreGameplayEffectExecute 返回 true 之后，允许 GE 通过 ExecutionCalculation 修改属性集。该函数发生在 GE 执行之后，Base Value 被修改之前调用。
  • 可以利用被 ExecutionCalculation 修改过的属性来编写逻辑，比如项目中的伤害值元属性 MetaDamage 由 ExecutionCalculation 修改，可以使用 MetaDamage 在这里判断角色是否死亡。

以下两个函数是最常用的

06 PreAttributeChange()

1

PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue)

• **在 Attribute 的 CurrentValue 被修改前触发。
  • (Duration)GE 和 (Infinite)GE 可以修改 CurrentValue.
• Clamp 属性值的理想位置。

例如项目中 Clamp 生命值属性：

1
2
3
4
5
6
7
8
9
10
11
12

void UMageAttributeSet::PreAttributeChange(const FGameplayAttribute& Attribute, float& NewValue)
{
	Super::PreAttributeChange(Attribute, NewValue);

	/* 只负责Clamp，不要再这写游戏逻辑 */
	/* 可以响应 Setter 函数和 GameplayEffect 对 CurrentValue 的修改 */
	/* 预修改属性获取Clamp后的NewValue值，但这只发生在属性修改前，不会影响最后NewValue值（即NewValue值最终仍没有被Clamp） */
	if (Attribute == GetHealthAttribute())
	{
		NewValue = FMath::Clamp<float>(NewValue, 0.0f, GetMaxHealth());
	}
}

在这里做的任何 Clamp 都不会永久性地修改 ASC 中的 Modifier, 只会修改查询 Modifier 的返回值。
这意味着属性修改之后的操作，像 ExecutionCalculations 和 MMC 这种根据所有 Modifier 重新计算 CurrentValue 的函数需要再次执行限制 (Clamp)操作。执行的位置是 PostGameplayEffectExecute()

[!bug]
源码对于 PreAttributeChange()的注释说明不要将该函数用于游戏逻辑事件, 而主要在其中做 Clamp 操作. 对于修改 Attribute 的游戏逻辑事件的建议位置是 UAbilitySystemComponent::GetGameplayAttributeValueChangeDelegate(FGameplayAttribute Attribute) [[#04 监听 Attribute 变化委托]].

07 PostGameplayEffectExecute()

1

PostGameplayEffectExecute(const FGameplayEffectModCallbackData & Data)

• 在 PreGameplayEffectExecute 返回 true 之后，允许 GE 通过 ExecutionCalculation 修改属性集。该函数发生在 GE 执行之后，Base Value 被修改之前调用。
• 可以利用被 ExecutionCalculation 修改过的属性来编写逻辑，比如项目中的伤害值元属性 MetaDamage 由 ExecutionCalculation 修改，可以使用 MetaDamage 在这里判断角色是否死亡。

项目中在这里进行如下操作：

1. 对由 (Instant)GE 进行初始化的主属性再次 Clamp（只由 (Instant)GE 修改 BaseValue 的 Attribute 都可以在这里Clamp）
2. 根据主属性的变化更新副属性（使用 Attribute 的 Getter，Setter 函数）
3. 使用 MetaAttribute 进行了伤害计算和经验值计算

[!NOTE]
当 PostGameplayEffectExecute() 被调用时, 对 Attribute 的修改已经发生, 但是还没有被复制回客户端, 因此在这里限制值不会造成对客户端的二次复制, 客户端只会接收到限制后的值。

06 监听 Attribute 变化委托

[[#06 生命周期函数]] 该小节中的生命周期函数虽然可以感知属性的变化，但是不允许我们在其中执行游戏逻辑。比如执行诸如”生命值属性变化时，让血条 UI 更新”的操作。

为了监听 Attribute 何时变化以便更新 UI 和其他游戏逻辑, ASC 提供了一个委托和对应的 Getter 函数：

1
2
3
4
5

/** Attribute 改变时广播 */
DECLARE_MULTICAST_DELEGATE_OneParam(FOnGameplayAttributeValueChange, const FOnAttributeChangeData&);

/** Getter函数，返回上述委托 */  
FOnGameplayAttributeValueChange& GetGameplayAttributeValueChangeDelegate(FGameplayAttribute Attribute);

我们只需要调用这个 Getter 函数将其绑定一个当 Attribute 变化时需要调用的回调函数，在回调函数中实现游戏逻辑。

项目中 OverlayWidgetController 中使用该委托绑定生命值属性变化回调（没有使用回调函数，而是用的 Lambda 表达式），通过回调再次广播 OnHealthChanged 委托，将新的生命值属性值广播到控件蓝图 WBP_HealthBar 中以更新血条。

1
2
3
4
5
6
7
8

void UOverlayWidgetController::BindCallbacks()
{
    /** 绑定ASC属性变化回调，接收属性变化 */
	AbilitySystemComponent->GetGameplayAttributeValueChangeDelegate(GetMageAttributeSet()->GetHealthAttribute()).AddLambda([this](const FOnAttributeChangeData& Data)
	{
		OnHealthChanged.Broadcast(Data.NewValue);
	});
}

WBP_HealthBar 中绑定了 OnHealthChanged 委托：

还可以通过创建蓝图异步节点 UBlueprintAsyncActionBase [[异步节点#示例]]，或 GAS 内置的 AbilityAsync 类 AbilityAsync_WaitAttributeChanged 实现上述功能。

07 聚合器 Aggregator

聚合器 “聚” 的是什么？
聚的是属性相关的修改信息。

从下图可知，一个 ASC 有一个 FActiveGameplayEffectsContainer 实例，一个 FActiveGameplayEffectsContainer 有一个 “属性 -> 聚合器”的映射。

也就是说，一个聚合器实例聚合了，针对一个 ASC 实例的一个属性的**所有修改信息。

聚合器的作用：

• 属性的计算
  属性的计算方法，即 Modifier（代码中的 Mod）都在聚合器中，所以属性的计算都在 Aggregator 的一系列数据类型中完成。

• 属性推导
  属性之间可以建立相关性，例如，属性 A=f (属性 B)。在 B 发生变化后，A 的值也会自动变化。也就是说，我们只需要驱动 B 的变化，然后不需要再调用任何函数，就可以期待 A 的变化发生。

源码解析：[[ 03-1 GameplayEffect 标签面面观 - 属性与聚合器]]

OnAttributeAggregatorCreated()

OnAttributeAggregatorCreated() 会在 Aggregator 为集合中的某个 Attribute 创建时触发, 它允许 FAggregatorEvaluateMetaData 的自定义设置, AggregatorEvaluateMetaData 是 Aggregator 基于所有应用的 Modifier(Modifier) 评估 Attribute 的 CurrentValue 的。

默认情况下, AggregatorEvaluateMetaData 只由 Aggregator 用于确定哪些 Modifier 是满足条件的, 以 MostNegativeMod_AllPositiveMods 为例, 其允许所有正(Positive) Modifier 但是限制负(Negative) Modifier (仅最负的那一个), 这在 Paragon 中只允许将最负移动速度减速效果应用到玩家, 而不用管应用所有正移动速度 buff 时有多少负移动效果. 不满足条件的 Modifier 仍存于 ASC 中, 只是不被总合进最终的 CurrentValue, 一旦条件改变, 它们之后就可能满足条件, 就像如果最负 Modifier 过期后, 下一个最负 Modifier (如果存在的话)就是满足条件的.

为了在只允许最负Modifier和所有正Modifier的例子中使用AggregatorEvaluateMetaData:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

virtual void OnAttributeAggregatorCreated(const FGameplayAttribute& Attribute, FAggregator* NewAggregator) const override;

void UGSAttributeSetBase::OnAttributeAggregatorCreated(const FGameplayAttribute& Attribute, FAggregator* NewAggregator) const
{
	Super::OnAttributeAggregatorCreated(Attribute, NewAggregator);

	if (!NewAggregator)
	{
		return;
	}

	if (Attribute == GetMoveSpeedAttribute())
	{
		NewAggregator->EvaluationMetaData = &FAggregatorEvaluateMetaDataLibrary::MostNegativeMod_AllPositiveMods;
	}
}

你的自定义AggregatorEvaluateMetaData应该作为静态变量添加到FAggregatorEvaluateMetaDataLibrary.

5 Gameplay Effect

01 定义

GE 可以改变 Attribute 和 GameplayTag ，其可以立即修改 Attribute （例如伤害或治疗）或应用持续状态（buff/debuff）。

1. UGameplayEffect 只是一个定义单一游戏效果的数据类, 不应该在其中添加额外的逻辑（没有 blueprint graph）。
2. GE 通常不重载基类 UGameplayEffect，被设计成完全通过变量来配置
3. GE 通过 Modifier 和 ExecutionCalculation 修改 Attribute.

02 配置项

（1）Gameplay Effect

• Modifier 和 Executions 后面会讲
• Conditional Gameplay Effects：当 GE 成功应用时，可以应用其他 GE，嵌套调用 GE 的方法之一。

持续策略 Duration Policy

GE 有三种持续策略: (Instant), (Duration) 和 (Infinite)。

Duration Policy 与 Value 的关系：

• (Instant)GE ：立即永久性修改 BaseValue
• (Periodic)GE ：周期性应用 (Instant)GE 修改 BaseValue。
• (Duration)GE ：在指定时间内修改 CurrentValue，时间结束后移除该 GE，CurrentValue 值恢复为与 BaseValue 相等。
• (Infinite)GE：在无限时间内修改 CurrentValue，直到手动移除该 GE，CurrentValue 值恢复为与 BaseValue 相等。

（2）Period 周期

[!warning]
(Periodic) GE 不能被预测

(Duration)GE 和 (Infinite)GE 可以通过设置 Period 转变为 (Periodic)GE , 其每过 X 秒(由周期定义)就应用一次 Modifier 和 EExecution

• 如果由 Duration 转变为 Periodic，则在持续时间内按周期执行
• 如果由 Infinite 转变为 Periodic，则一直按周期执行，直到手动移除。

周期性抑制策略 Periodic Inhibition Policy：GE 中断并恢复后的处理方式。

• Never Reset：从被打断时的位置开始计算周期，相当于暂停再播放。
• Reset Period：从 0 开始计算周期。
• Execute and Reset Period：打断时立即执行一次，下次从 0 开始计算周期。

（3）Application 设置 Apply 概率和条件

设置 GE 的应用概率和条件。

条件可以简单地用 Tag 去限制，也可以用 Application Requirement 进行更复杂的逻辑判断。

使用 Application Requirement 需要用 C++或蓝图实现 Gameplay Effect Custom Application Requirement（简称 GECAR）类，重载里面的唯一方法，用于判断是否可以应用 GE。

官方文档推荐在以下情况使用GECAR

• 目标需要有一定数量的 Attribute.
• 目标需要有一定数量的 GameplayEffect 堆栈.
• 除此之外 GECAR 还能够做更多事情，比如检查 Target 是否应用了一个 GE 的实例，在应用一个新实例时如果同类型的实例已存在则只改变其持续时间而（CanApplyGameplayEffect() 要返回 false）。

（4）Stacking 堆叠

堆叠处理对已具有 buff 或 debuff（GE）的目标再次应用 buff 或 debuff ，以及处理”Overflow 溢出”的策略，溢出是指在原 Gameplay 效果的影响下已完全饱和的目标被应用了新的游戏性效果（例如，不断累积的毒药计时条只有在溢出后才会产生持续伤害效果）。

• GE 默认会应用新的 GE Spec 实例, 而不关心之前已经应用过的尚且存在的 GE Spec 实例。**`
• GE 可以设置到的堆栈中, 新的 GE Spec 实例不会添加到堆栈中, 而是修改当前已经存在的 GE Spec 堆栈数.
• 只适用于 (Duration)GE 和 (Infinite)GE

堆叠类型

Stacking Type:Aggregate（总计） by Source 和 Aggregate by Target.
即叠加栈在目标身上 or 施法者身上。

每层 GE 如果是 Modifiers 来计算，则为直接叠加的效果，比如用 Modifiers 来增加 3 攻击力，则第一层为增加 3 攻击力，则第二层为增加 6 攻击力，则第三层为增加 9 攻击力，而如果需要根据层数不同而改变增加的值，则需要使用 Executions。

限制堆叠数量

Stack Limit Count 限制 Stack 数量：

1. 对于 Aggregate by Source：只限制单个 Source 下的堆栈数量，多个 Source 单独计算
2. 对于 Aggregate by Source，只限制 Target 上的堆栈数量

持续时间刷新、周期刷新、过期处理

• Stack Duration Refresh Policy：Apply 新 GE 时是否刷新持续时间，注意溢出的 Apply 也会刷新，想关闭可以在下面的 Overflow 条目关闭。
• Stack Period Reset Policy：同上，是否刷新周期。
• Stack Expiration Policy：当一层 GE 的 Duration 到期后的处理方式。
  • Clear Entire Stack：清空全部层数，如 LOL 征服者。
  • Remove Single Stack and Refresh Duration：清空一层，如 LOL 致命节奏。
  • Refresh Duration：不清空，相当于无限长的 Duration，但可以通过调用 {cpp}FActiveGameplayEffectsContainer::OnStackCountChange(FActiveGameplayEffect& ActiveEffect, int32 OldStackCount, int32 NewStackCount) 方法来自己处理细节，如一次掉两层。

监听堆栈变化

使用 GAS 自带的 AbilityTask WatiForGameplayEffectStackChange
例如，可以用它来更新玩家拥有的被动护盾堆栈 (层数)

溢出 Overflow

可以设置 Stack 溢出会 Apply 的 GE。通过 GE 应用 GE 的方法之一，需要配合 Stacking 来使用。
Deny Overflow Application：如果为 True，则溢出的 Apply 不会刷新 Duration。
Clear Stack On Overflow：溢出时清空堆栈，需要勾选上一个选项后才能选中。

（5）Expiration 到期应用 GE

仅能用于 (Duration)GE

• Premature Expiration Effect Classes：当 (Duration)GE 的 Duration 被打断或结束时（如通过强制删除，清除标签等）应用 GE
• Routine Expiration Effect Classes：当 (Duration)GE 的正常到期时应用 GE

（6）Tags 标签

和 GA 的 Tag 条目类似，设置各种限制条件。

GE 可以带有多个 GameplayTagContainer, 设计师可以编辑每个类别的 Added 和 Removed GameplayTagContainer

• 结果会在编译后显示在 Combined GameplayTagContainer 中.
  • Added 标签是该 GameplayEffect 新增的之前其父类没有的标签,
  • Removed 标签是其父类拥有但该类没有的标签.
  • Combined Tag = Parent‘s Tag+ Added - Removed

1. GameplayEffectAssetTag：GE 的 Tag，它们自身没有任何功能且只用于描述 GE。
2. GrantedTags：GE 会赋予目标 ASC 的 Tag，仅适用于 (Infinite)GE 和 (Duration)GE。
3. GrantedBlockedAbilityTags：
4. Ongoing Tag Requirements：GE 满足 Tag 条件才能修改值（Modifier or Execution）。
   • 一旦 GE 应用后, 这些标签将决定 GE 是开启还是关闭. GE 可以是关闭但仍然是应用的, 通过这项设置 GE 可以仅 Apply 而不修改值
   • 关闭 GE 会移除其已应用地 Modifier 和 GameplayTag , 但是不会移除该 GE, 重新打开 GE 会重新应用其 Modifier 和 GameplayTag.
   • 仅适用于 (Infinite)GE 和 (Duration)GE。
   • Ongoing：持续存在的
5. Application Tag Requirements：GE 满足 Tag 条件才能应用（Apply）。
6. Removal Tag Requirements：GE 满足 Tag 条件就会被移除。
7. Remove Gameplay Effects with Tags：Apply 后移除指定 Tag 的 GE。
8. Remove Gameplay Effect Query：上面一条的高级版，可以匹配 GE 的类（Effect Definition），匹配来源（Effect Source）以及匹配 GE 修改的属性（Modifying Attribute），移除成功匹配的 GE。

TagResponseTable（标签响应表）

这也是一种 Stacking 机制，并不在 GE 本身配置。
配置以后，可以自动根据标签的状况改变对应 GE 的 Stacking 数。

制作和配置方法如下：

• 制作响应表数据资产

再将资产路径配置到 DefaultGame. ini 中生效。

1
2

[/Script/GameplayAbilities.AbilitySystemGlobals]
GameplayTagResponseTableName="/Game/资产路径/NewDataAsset.NewDataAsset"

• 配置资产数据

需要配置的内容是 Entries 数组，每一个成员分为 Possitive 和 Negative 两部分。在起作用时，会分别结算两者的标签层数，来决定最终效果。大致步骤如下（UGameplayTagReponseTable:: TagResponseEvent ）：

1. 分别获取 Positive（P）和 Negative（N）的标签层数
2. 将读取的 P 和 N 值约束到不大于各自的 SoftCountCap（>0 为有效配置）值
3. 得 | P-N|，即绝对值
4. 若 P>=N，则移除 N 的 GE，若 N>=P，则移除 P 的 GE
5. 施加 P 和 N 中较大者的 GE，层数为 | P-N|（根据 4，P=N 时，所有 GE 都会移除）

（7）Immunity 免疫

GE 可以基于 GameplayTag 实现免疫, 有效阻止其他 GE 应用。

尽管免疫可以由 Application Tag Requirements 等方式有效地实现, 但是使用该系统可以在 GE 被免疫阻止时提供 {cpp} UAbilitySystemComponent::OnImmunityBlockGameplayEffectDelegate 委托 (Delegate).

选项：

• GrantedApplicationImmunityTags 会检查 (Source)ASC (包括源 Ability 的 AbilityTag, 如果有的话)是否包含特定的 Tag , 这是一种基于确定 Character 或源 (Source)的标签对其所有 GE 提供免疫的方法.
  • 如果拥有 Require Tags 的所有 Tag，并且没有 Ignore Tags 的所有 Tag，则认为匹配成功，该 GE 不会被 Apply。
• Granted Application Immunity Query 会检查传入的 GameplayEffectSpec 是否与其查询条件相匹配, 从而阻止或允许其应用。更细粒度地匹配，更消耗性能。
  • 最后三个选项，分别是根据 GE 修改的 Attribute 匹配、根据 GE 来源匹配以及根据 GE 的类匹配。

（8）Display 显示

与特效相关的设置，调用 Gameplay Cue 的方式之一
Require Modifier Success to Trigger Cues：需要 GE 的 Modifier 应用成功来才触发 Cue
Suppress Stacking Cues: 如果为 true，GameplayCues 将只在堆叠 GE 的第一个实例中被触发。

（9）Granted Abilities

使用 GE 添加 GA 的方式。仅适用于 (Infinite)GE 和 (Duration)GE。

• Level：GA 的等级。
• Input ID：如果使用旧版输入，每一个操作映射都对应着一个枚举值，输入对应的枚举值就可以将这个新 GA 绑定到输入上。
• Removal Policy：设置当 GE 被移除时，GA 是否要移除。
  • Cancel Ability Immediately：移除，并立即触发 EndAbility，结束 GA。
  • Remove Ability on End：移除，但是不立即触发 EndAbility，GA 继续运行逻辑直到 EndAbility。
  • Do Nothing：GA 不会被移除，直到手动移除。

用法思路：

1. 当与 ExecCalc 配合使用时，可将它们用于设置高度特殊的游戏性组合。例如，某个 Actor 具有指示该 Actor 浸在油中的 Gameplay Tags 或属性，当它被以火为主题的 GE 击中时，它就可以获得”着火”技能，从而被动地烧毁附近的 Actor 并在接下来的十秒钟之内产生具有粒子和动态光照的视觉效果。
2. 一个普遍用法是当想要强制另一个玩家做某些事的时候, 像击退或拉取时移动他们, 就会对它们应用一个 GE 来授予其一个自动激活的 GA (查看[[#被动Ability]] 来了解如何在 Ability 被授予时自动激活它), 从而使其做出相应的动作.

（10）GE 嵌套

涉及 3 个配置项，对应不同的条件：

• [[#(1) Gameplay Effect]] ：Conditional Gameplay Effects：当 GE 成功应用时，可以应用其他 GE。

• [[#溢出 Overflow]]： Stack 溢出会 Apply 的 GE
• [[#(5) Expiration 到期应用 GE]]：GE 中断或正常结束时，应用配置好的 GE

03 GameplayEffectSpec

[!NOTE] 应用场景
不需要立即 Apply 的 GE，例如发射物：直到命中目标后再对目标应用 GE。

Specification：规格/格式

Make Outgoing Spec 源码，内部主要实现了：

1
2
3

FGameplayEffectSpec* NewSpec = new FGameplayEffectSpec(GameplayEffect, Context, Level);

return FGameplayEffectSpecHandle(NewSpec);

• GE Spec 默认属性和创建时指定的 GE 的 CDO 相同，在 Apply 之前可以在运行时自由的创建和修改。

• 内部保存了 FGameplayEffectContextHandle, 表明该 GameplayEffectSpec 由谁创建。
• GE Spec 不是 FActiveGameplayEffect，后者是 GE Spec Apply 后返回的新实例，被添加到目标 ASC 的 FActiveGameplayEffectContainer 容器
• 除了 GE 中设置的授予标签, GE Spec 还会授予目标 (Target) DynamicGrantedTags

• 存储 TMap<FGameplayTag, float> SetByCallerTagMagnitudes 用于 SetByCaller

FGameplayEffectSpecHandle 允许蓝图生成一个 GameplayEffectSpec，然后通过句柄的共享指针 Data 引用它，以便多次应用/应用多个目标。 创建 GameplayEffectSpec 需要先创建 FGameplayEffectSpecHandle ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//TSubclassOf<UGameplayEffect> GameplayEffectClass

//创建FGameplayEffectContextHandle
//FGameplayEffectContextHandle告诉我们该Effect是如何来到这里的（是谁/是什么Apply了该Effect）
FGameplayEffectContextHandle EffectContextHandle = 
AbilitySystemComponent->MakeEffectContext();  
...

//创建FGameplayEffectSpecHandle
FGameplayEffectSpecHandle EffectSpecHandle =  
AbilitySystemComponent->MakeOutgoingSpec(GameplayEffectClass, 1.0f, EffectContextHandle);

//拓展
//通过EffectSpecHandle获取GameplayEffect类的信息：
EffectSpecHandle.Data.Get()->Def.Get()->DurationPolicy

04 GameplayEffectContext

存有 GE Spec 的创建者 Instigator 和相关数据（如 TargetData）, 在 GE Spec 执行的整个过程中都会传递，因此它是追踪执行过程中瞬时信息的绝佳位置，可以在以在 MMC/ ExecutionCalculation, AttributeSet 和 GameplayCue) 之间传递任意数据。
默认可以传递的数据：

• Instigator
• EffectCauser
• AbilityCDO
• AbilityLevel
• SourceObject
• Actors
• HitResult
• WorldOrigin
• …

几个可以添加传递数据的函数

Instigator 和 EffectCauser

在 ASC->MakeOutgoingSpec() 前，我们会调用 ASC->MakeEffectContex() 创建 FGameplayEffectContextHandle，MakeEffectContex() 会将 OwnerActor 设置为 Instigator，将 AvartarActor 设置为 EffectCauser。

Instigator 是指拥有产生该效果的 Ability 的对象
EffectCauser 是指 Effect 的物理来源（如武器）。它们可以是相同的。

1
2

// 获取EffectCauser
EffectSpecHandle.Data->GetContext().GetEffectCauser()

创建 EffectContext 子类

可以对该结构进行子类化，并添加特定于游戏的信息

步骤：

1. 继承 FGameplayEffectContext.
2. 重写 FGameplayEffectContext::GetScriptStruct().
3. 重写 FGameplayEffectContext::Duplicate().
4. 如果新数据需要复制的话, 重写 FGameplayEffectContext::NetSerialize().
5. 对子结构体实现 TStructOpsTypeTraits, 就像父结构体 FGameplayEffectContext 有的那样.
6. 继承 UAbilitySystemGlobals 类，重载 AllocGameplayEffectContext() 以返回一个新的子结构体对象.

继承 GameplayEffectContext

本项目在 MageAbilityTypes.h 文件中创建了一个子结构体 FMageGameplayEffectContext，用于监控自定义的瞬时信息。下面的例子在 EffectContext 中添加了 bool 值 IsCriticalHit

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

/* 继承 FGameplayEffectContext, 添加自定义数据，在MageAbilitySystemGlobals中配置 */
USTRUCT(BlueprintType)
struct FMageGameplayEffectContext : public FGameplayEffectContext
{
	GENERATED_BODY()

public:
	/** Getter/Setter */
	FORCEINLINE bool GetIsCriticalHit() const { return bIsCriticalHit; }
	FORCEINLINE void SetIsCriticalHit(const bool InbIsCriticalHit) { bIsCriticalHit = InbIsCriticalHit; }
	
	/// 自定义网络序列化，子类必须重载该函数（新添加的变量不要忘了加入到该函数中）
	/// @param Ar 保存、加载、储存、序列化数据
	/// @param Map 将对象和名字映射到索引，用于网络通信
	/// @param bOutSuccess 输出是否成功
	/// @return 
	virtual bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess) override;

	/** 返回用于序列化的实际结构体，子类必须重载该函数 */
	virtual UScriptStruct* GetScriptStruct() const override
	{
		return StaticStruct();
	}

	/** 创建此 GameplayEffectContext 的副本，用于复制以便以后修改 */
	virtual FMageGameplayEffectContext* Duplicate() const override
	{
		FMageGameplayEffectContext* NewContext = new FMageGameplayEffectContext();
		*NewContext = *this;
		if (GetHitResult())
		{
			// Does a deep copy of the hit result
			NewContext->AddHitResult(*GetHitResult(), true);
		}
		return NewContext;
	}

protected:
	/** 是否暴击 */
	UPROPERTY()
	bool bIsCriticalHit = false;
};


/**
 * 定义了结构体<FMageGameplayEffectContext>可以做什么
 * 在TStructOpsTypeTraitsBase2类中可以看到所有功能，标记为true即为开启对应功能
 */ 
template<>
struct TStructOpsTypeTraits<FMageGameplayEffectContext> : public TStructOpsTypeTraitsBase2<FMageGameplayEffectContext>
{
	enum
	{
		WithNetSerializer = true,
		WithCopy = true		//必须开启，用于将 TSharedPtr<FHitResult> 数据复制到各处
	};
};

NetSerialize

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

bool FMageGameplayEffectContext::NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess)
{
	/**
	 *当序列化所有对象时，构造的 所有变量都转换为0和1的字符串
	 *FArchive重载 <<左移运算符，可以用于序列化和反序列化
	 */
	uint32 RepBits = 0; //默认为无符号8位整数，用于存储8个bool值。二进制为0000 0000，每一位代表一个bool值, 因为我们用到了多个参数, 扩展到uint32

	if (Ar.IsSaving())
	{
		if (bReplicateInstigator && Instigator.IsValid())
		{
			RepBits |= 1 << 0;
			//等价于 RepBits = RepBits | (1 << 0);
			//首先计算(1 << 0)：1（0000 0001）左移0位，结果为0000 0001
			//然后进行按位或：RepBits = 0000 0000 | 0000 0001 = 0000 0001
		}
		
		if (bReplicateEffectCauser && EffectCauser.IsValid())
		{
			RepBits |= 1 << 1;
			//等价于 RepBits = RepBits | (1 << 1);
			//首先计算(1 << 1)：1（0000 0001）左移1位，结果为0000 0010
			//然后进行按位或：RepBits = 0000 0001 | 0000 0010 = 0000 0011
			//...以此类推, 每一位对应一个bool值
		}
		
		if (AbilityCDO.IsValid())
		{
			RepBits |= 1 << 2;
		}
		
		if (bReplicateSourceObject && SourceObject.IsValid())
		{
			RepBits |= 1 << 3;
		}
		
		if (Actors.Num() > 0)
		{
			RepBits |= 1 << 4;
		}
		
		if(HitResult.IsValid())
		{
			RepBits |= 1 << 5;
		}
		
		if (bHasWorldOrigin)
		{
			RepBits |= 1 << 6;
		}
		
		/** 自定义数据 */
		if (bIsCriticalHit)
		{
			RepBits |= 1 << 7;
		}
	}

	Ar.SerializeBits(&RepBits, 7); //序列化位数

	/**
	 * 获取序列化数据
	 * 
	 * 按位与，假设经过上述的处理得到了RepBits = 0111 1101
	 */
	if (RepBits & (1 << 0)) // 0111 1101 & 0000 0001 = 0000 0001, 对应的倒数第一位为1，所以从Ar中取值
	{
		Ar << Instigator;
	}
	if (RepBits & (1 << 1)) // 0111 1101 & 0000 0010 = 0000 0000, 对应的倒数第二位为0, 所以不从Ar中取值
	{
		Ar << EffectCauser;
	}
	if (RepBits & (1 << 2)) // 0111 1101 & 0000 0100 = 0000 0100, 对应的倒数第三位为1，所以从Ar中取值
	{
		Ar << AbilityCDO;
	}
	if (RepBits & (1 << 3))
	{
		Ar << SourceObject;
	}
	if (RepBits & (1 << 4))
	{
		SafeNetSerializeTArray_Default<31>(Ar, Actors);
	}
	if (RepBits & (1 << 5))
	{
		if (Ar.IsLoading())
		{
			if (!HitResult.IsValid())
			{
				HitResult = TSharedPtr<FHitResult>(new FHitResult());
			}
		}
		HitResult->NetSerialize(Ar, Map, bOutSuccess);
	}
	if (RepBits & (1 << 6))
	{
		Ar << WorldOrigin;
		bHasWorldOrigin = true;
	}
	else
	{
		bHasWorldOrigin = false;
	}
	if (RepBits & (1 << 7))
	{
		Ar << bIsCriticalHit;
	}
	

	if (Ar.IsLoading())
	{
		AddInstigator(Instigator.Get(), EffectCauser.Get()); // Just to initialize InstigatorAbilitySystemComponent
	}

	bOutSuccess = true;
	return true;
}

继承 UAbilitySystemGlobals

参考本项目中的 MageAbilitySystemGlobals.h

需要在 DefaultGame.ini 中指定全局类

1
2
3

/** 指定全局类 */
[/Script/GameplayAbilities.AbilitySystemGlobals]
AbilitySystemGlobalsClassName="/Script/ProjectGASRPG.MageAbilitySystemGlobals"

1
2
3
4
5
6
7
8
9

UCLASS()
class PROJECTGASRPG_API UMageAbilitySystemGlobals : public UAbilitySystemGlobals
{
	GENERATED_BODY()

	/** 创建一个新的FMageGameplayEffectContext让ASC使用, 在 UAbilitySystemComponent::MakeEffectContext() 中调用 */
	virtual FGameplayEffectContext* AllocGameplayEffectContext() const override;
	
};

1
2
3
4
5

FGameplayEffectContext* UMageAbilitySystemGlobals::AllocGameplayEffectContext() const
{
	return new FMageGameplayEffectContext(); //返回自定义的MageGameplayEffectContext结构体
}

使用自定义的信息

完成上述步骤后，就可以通过访问 FMageGameplayEffectContext 来 Getter/Setter bIsCriticalHit 。

本项目在自定义的蓝图函数库中实现了静态 Getter/Setter 函数 , 用于访问 bIsCriticalHit。

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

/**
 * 设置暴击状态
 * - UPARAM(ref)宏：使参数通过非const引用传递并仍然显示为输入引脚（默认为输出）
 */
UFUNCTION(BlueprintCallable)
static void SetIsCriticalHit(UPARAM(ref) FGameplayEffectContextHandle& EffectContextHandle, const bool bIsCriticalHit)

void UMageAbilitySystemLibrary::SetIsCriticalHit(FGameplayEffectContextHandle& EffectContextHandle,const bool bIsCriticalHit)
{
	if (FMageGameplayEffectContext* MageEffectContext = static_cast<FMageGameplayEffectContext*>(EffectContextHandle.
		Get())) //注意这里不能用Cast, Cast不能用于结构体
	{
		MageEffectContext->SetIsCriticalHit(bIsCriticalHit);
	}
}
	
/** 获取爆击状态 */
UFUNCTION(BlueprintPure)
static bool GetIsCriticalHit(const FGameplayEffectContextHandle& EffectContextHandle);
    	
bool UMageAbilitySystemLibrary::GetIsCriticalHit(const FGameplayEffectContextHandle& EffectContextHandle)
{
    if (const FMageGameplayEffectContext* MageEffectContext = static_cast<const FMageGameplayEffectContext*>(
        EffectContextHandle.Get()))
    {
        return MageEffectContext->GetIsCriticalHit();
    }
    
    return false;
}

在 ExecCalc_Damage 中计算伤害时，将爆击状态传入 EffectContext：

1
2
3
4
5

/** 是否暴击 */
const bool bIsCriticalHit = FMath::RandRange(0.f, 1.f) <= Source_CriticalHitChance;

/** 获取EffectContext，同步暴击状态 */
UMageAbilitySystemLibrary::SetIsCriticalHit(EffectContextHandle, bIsCriticalHit);

在属性集中计算 MetaDamage 时，获取爆击状态，根据是否暴击显示不同样式的伤害浮动数字

1
2
3

/** 显示伤害浮动数字 */
const bool bIsCriticalHit = UMageAbilitySystemLibrary::GetIsCriticalHit(Property.EffectContextHandle);
ShowDamageFloatingText(Property, TempMetaDamage,bIsCriticalHit);

05 应用 Apply

GameplayEffect 可以被 GA 和 ASC 中的多个函数应用, 其通常是 ApplyGameplayEffectTo 的形式。

这些函数最终都在目标上调用 ApplyGameplayEffectSpecToSelf() 。当调用 ApplyGameplayEffect 时, 内部会从 GE 创建 GE Spec ，实际 Apply 到目标 (Target)的是该 GE Spec。

为了在 GA 之外应用 GE, 例如对于某个投掷物, 你就需要获取到目标的 ASC 并使用它的函数之一来 ApplyGameplayEffectToSelf。

1
2
3
4
5
6
7
8
9

//项目中封装的函数，展示了应用GE的简单流程
void UMageAbilitySystemLibrary::ApplyEffectToSelf(UAbilitySystemComponent* ASC,
{
	checkf(GameplayEffectClass, TEXT("GameplayEffectClass为空，请在 %s 中设置"), *ASC->GetOwner()->GetName());
	FGameplayEffectContextHandle EffectContextHandle = ASC->MakeEffectContext();
	EffectContextHandle.AddSourceObject(ASC->GetAvatarActor()); //添加源对象，计算MMC时会用到
	const FGameplayEffectSpecHandle EffectSpecHandle = ASC->MakeOutgoingSpec(GameplayEffectClass, Level, EffectContextHandle);
	ASC->ApplyGameplayEffectSpecToSelf(*EffectSpecHandle.Data); //返回FActiveGameplayEffectHandle
}

06 移除 Remove

GameplayEffect 可以被 GameplayAbility 和 ASC 中的多个函数移除，本质上都是最终在目标上调用 RemoveActiveEffects() 函数。
Remove 函数需要传入一个 FActiveGameplayEffectHandle 来引用指定的 GE，通常来自与 Apply 函数 的返回值。

07 修饰符 Modifier

[!NOTE] 理解
Modifier 就是一个数学运算的过程！变量 && 操作符 = Modifier

Modifier 可以修改 Attribute 并且是唯一可以预测修改 Attribute 的方法。
一个 GE 可以有0个或多个 Modifier, 每个 Modifier 通过某个指定的操作只能修改一个 Attribute。

运算符

Attribute 的 CurrentValue 是其所有 Modifier 与其 BaseValue 计算得到的结果。
像下面这样的 Modifier 计算公式被定义在 GameplayEffectAggregator.cpp 中的 FAggregatorModChannel::EvaluateWithBase：

1

((InlineBaseValue + Additive) * Multiplicitive) / Division

Override Modifier 会优先覆盖最后应用的 Modifier 得出的最终值.

[!NOTE]
对于基于百分比的修改, 确保使用Multiply操作以使其在加法操作之后

[!bug]
预测(Prediction)对于百分比修改有些问题.

计算类型

有四种 Magnitude Calculation Type:

• ScalableFloat
• AttributeBased
• CustomCalculationClass（MMC）
• SetByCaller,
  它们全都生成一些浮点数, 用于之后基于各自的操作修改指定 Modifier 的 Attribute.

Scalable Float

指定一个 FScalableFloat 直接计算

FScalableFloat 结构体可以指向某个横向为变量, 纵向为等级的 Data Table, Scalable Float 会以 Ability 的当前等级自动读取指定 Data Table 的某行值(或者在 GE Spec 中重写的不同等级), 读取到的值会乘以系数(默认为 1)

Attribute Based

基于已有的属性进行计算 [[#05 派生属性 Derived Attribute]]

• Backing Attribute：将 Source(GE Spec 的创建者)或 Target(GE Spec 的接收者)上的 CurrentValue 或 BaseValue 视为 Backing Attribute (备份属性),
  • 可以使用系数（Coefficient）和 Pre Add 与 Post Add 来修改它：
• 多个 Modifier 计算顺序：从上到下
• Attribute Curve：基于 CurveTable 计算，代替直接使用 Backing Attribute
• Attribute Calculation Type：
  • Attribute Magnitude：使用最终的计算值（默认选项，即捕获的属性经过数 Coefficient 和 Pre Add 与 Post Add 计算后的值 ）
  • Attribute Base Value：使用属性的BaseValue
  • Attribute Bonus Magnitude: 使用属性的加成值，即 Attribute Magnitude - Attribute Base Value

CustomCalculationClass（MMC）

[!NOTE] 应用场景
可以捕获多个 Attribute，但只能修改一个 Atrribute。比如可以用于属性计算，攻击力由力量和敏捷属性共同影响，捕获力量和敏捷属性，然后修改攻击力属性。

CustomCalculationClass 需要指定 UGameplayModMagnitudeCalculation 类来计算 Modifier （简称 MMC）

• MMC 为复杂的 Modifier 提供了最大的灵活性
• MMC 的优势在于能够完全访问 GameplayEffectSpec 来读取 GameplayTag 和 SetByCaller，从而能够捕获 GE 的 源(Source) 或 目标(Target) 上任意数量的 Attribute 值。
  

捕获 Attribute 会自 ASC 现有的 Modifier 重新计算它们的 CurrentValue, 该重新计算不会执行 AbilitySet 中的 PreAttributeChange(), 因此 Clamp 操作必须在 PostGameplayEffectExecute() 中重新处理。

UGameplayModMagnitudeCalculation

UGameplayModMagnitudeCalculation 是用于通过蓝图或 C++ 执行自定义 Modifier 计算的类。它的功能相比 GameplayEffectExecutionCalculation 要弱一些（只能修改一个 Attribute）, 但优点是它是可预测的.

它唯一要做的就是自 CalculateBaseMagnitude_Implementation() 返回浮点值（可以使用系数（Coefficient）和 Pre 与 Post 进一步处理浮点值结果），你可以在 C++和蓝图中继承并重写该函数.

1
2

UFUNCTION(BlueprintNativeEvent, Category="Calculation")
float CalculateBaseMagnitude(const FGameplayEffectSpec& Spec) const;

内置宏，用于声明捕获属性的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/// 声明捕获属性
/// @param P 捕获的属性
#define DECLARE_ATTRIBUTE_CAPTUREDEF(P) \
	FProperty* P##Property; \
	FGameplayEffectAttributeCaptureDefinition P##Def; \

/// 定义捕获属性
/// @param S 属性集
/// @param P 捕获的属性
/// @param T 从GE的Source还是Target处捕获属性
/// @param B 是否Snapshot
#define DEFINE_ATTRIBUTE_CAPTUREDEF(S, P, T, B) \
{ \
	P##Property = FindFieldChecked<FProperty>(S::StaticClass(), GET_MEMBER_NAME_CHECKED(S, P)); \
	P##Def = FGameplayEffectAttributeCaptureDefinition(P##Property, EGameplayEffectAttributeCaptureSource::T, B); \
}

以项目中的 MMC_Defence 类为例，该类继承自 UGameplayModMagnitudeCalculation，用于计算副属性防御力。需要捕获 Source Attribute
Stamina (主属性-体力)，计算公式为 Defence = (Stamina * 4.8f) + PlayerLevel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

UCLASS()
class PROJECTGASRPG_API UMMC_Defence : public UGameplayModMagnitudeCalculation
{
	GENERATED_BODY()

public:
	UMMC_Defence();

    // 重载
	virtual float CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& Spec) const override;

private:
	/** 声明捕获属性*/
	DECLARE_ATTRIBUTE_CAPTUREDEF(Stamina);
};

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

UMMC_Defence::UMMC_Defence()
{
    //定义捕获属性，第四个参数是Snapshot
	DEFINE_ATTRIBUTE_CAPTUREDEF(UMageAttributeSet, Stamina, Target, false);

    // 捕捉与计算相关的属性
    // 可以通过 GetAttributeCaptureDefinitions() 访问
	RelevantAttributesToCapture.Add(StaminaDef);
}


float UMMC_Defence::CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& Spec) const
{
	// 获取Tag
	const FGameplayTagContainer* SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
	const FGameplayTagContainer* TargetTags = Spec.CapturedTargetTags.GetAggregatedTags();

    //在聚合器评估中使用的数据
	FAggregatorEvaluateParameters EvaluationParameters;
	EvaluationParameters.SourceTags = SourceTags;
	EvaluationParameters.TargetTags = TargetTags;

    //从捕获属性中获取BaseValue
	float Stamina = 0.0f;
	GetCapturedAttributeMagnitude(StaminaDef, Spec, EvaluationParameters, Stamina);
	Stamina = FMath::Max<float>(Stamina,0.0f);

    //自定义的接口，获取角色等级
	const ICombatInterface* CombatInterface = Cast<ICombatInterface>(Spec.GetContext().GetSourceObject());
	const int32 PlayerLevel = CombatInterface->GetCharacterLevel();

    //应用计算公式
	return (Stamina * 4.8f) + PlayerLevel;
}

如果你没有在 MMC 的构造函数中将 FGameplayEffectAttributeCaptureDefinition 添加到 RelevantAttributesToCapture 中并且尝试捕获 Attribute, 那么将会得到一个关于捕获时缺失 Spec 的错误. 如果不需要捕获 Attribute, 那么就不必添加什么到 RelevantAttributesToCapture.

Set By Caller

直译就是由调用者（即 GA 或 GE Spec 的创建者 ）设置

SetByCaller Modifier 是运行时由 GA 或 GE Spec 的创建者于 GE 之外设置的值, 例如, 如果你想让伤害值随玩家蓄力技能的长短而变化（本项目的技能蓝图 GA_Laser 实现了该功能）, 那么就需要使用 SetByCaller。

1
2
3
4
5
6
7
8
9
10

/** 设置SetbyCaller Magnitude，将float值与Tag一一对应，获取时指定Tag即可获取*/
FGameplayEffectSpecHandle UAbilitySystemBlueprintLibrary::AssignTagSetByCallerMagnitude(FGameplayEffectSpecHandle SpecHandle, FGameplayTag DataTag, float Magnitude)
// 内部调用了这个函数：
/** Sets the magnitude of a SetByCaller modifier */  
void SetSetByCallerMagnitude(FGameplayTag DataTag, float Magnitude);


/** 获取SetbyCaller Magnitude*/
/** Returns the magnitude of a SetByCaller modifier. Will return 0.f and Warn if the magnitude has not been set. */  
float GetSetByCallerMagnitude(FGameplayTag DataTag, bool WarnIfNotFound = true, float DefaultIfNotFound = 0.f) const;

SetByCaller 本质上是存于 GE Spec 中的 TMap<FGameplayTag, float>, Modifier 只是告知 Aggregator 去寻找与提供的 GameplayTag 相关联的 SetByCaller 值。

[!tip]
另外还有根据 FName 标记 SetbyCaller 的函数，建议只使用 GameplayTag 形式而不是 FName 形式, 这可以避免蓝图中的拼写错误, 并且当 GE Spec 复制时, GameplayTag 比 FName 在网络传输中更有效率, 因为 TMap 也会复制.

用法：
首先创建一个 Outgoing GE Spec, 在应用 GE 之前调用 SetSetByCallerMagnitude，完成设置（GE 中设置的 DataTag 要与 Assign Tag Set by Caller Magenitude 输入的DataTag一致）。后续在在 MMC 或者 ExecCalc 中计算结果时通过返回的 GE Spec 调用 GetSetByCallerMagnitude 就可以获取到设置的值。

我认为 Set By Caller 这种计算方法在蓝图的使用中更为灵活，比如有一个 GE 用来对敌人造成伤害，伤害的大小可以在该项技能的 GA 中通过 Caller 传入。当然 C++中也可以使用。

在本项目技能蓝图 GA_Laser 中，实现了根据蓄力时间增加伤害：

1. 通过内置的 AbilityTask：WaitInputRelease 获取了按键按压时间
2. 然后使用 Set by Caller 设置蓄力后的伤害值
3. 最后应用 GE_ExecCalc_Damage 通过 ExecCalc 获取 SetbyCaller Magnitude 来计算最终伤害。
   
   

Snapshot 快照

使用 Attribute Base 或 MMC、ExecCalc 时都可以设置是否开启 Snapshot，Snapshot 用于确定捕获属性的时机

• 开启，则捕获 GE Spec 创建时的 Attribute
  • 这时只能捕获 Source 属性，因为刚创建也不知道 Target 是谁！
  • 如果仍选择 Target 属性，则是在应用时捕获
  • 不会自动更新
• 关闭，则捕获 GE Spec 应用时的 Attribute
  • 该 Attribute 被 (Infinite)GE 或 (Duration)GE 修改时会自动更新

Multiply 和 Divide Modifier

默认情况下, 所有的Multiply和DivideModifier在对Attribute的BaseValue乘除前都会先加到一起.

1
2
3
4
5
6
7
8
9
10

float FAggregatorModChannel::EvaluateWithBase(float InlineBaseValue, const FAggregatorEvaluateParameters& Parameters) const
{
	...
	float Additive = SumMods(Mods[EGameplayModOp::Additive], GameplayEffectUtilities::GetModifierBiasByModifierOp(EGameplayModOp::Additive), Parameters);
	float Multiplicitive = SumMods(Mods[EGameplayModOp::Multiplicitive], GameplayEffectUtilities::GetModifierBiasByModifierOp(EGameplayModOp::Multiplicitive), Parameters);
	float Division = SumMods(Mods[EGameplayModOp::Division], GameplayEffectUtilities::GetModifierBiasByModifierOp(EGameplayModOp::Division), Parameters);
	...
	return ((InlineBaseValue + Additive) * Multiplicitive) / Division;
	...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

float FAggregatorModChannel::SumMods(const TArray<FAggregatorMod>& InMods, float Bias, const FAggregatorEvaluateParameters& Parameters)
{
	float Sum = Bias;

	for (const FAggregatorMod& Mod : InMods)
	{
		if (Mod.Qualifies())
		{
			Sum += (Mod.EvaluatedMagnitude - Bias);
		}
	}

	return Sum;
}

摘自GameplayEffectAggregator.cpp

在该公式中Multiply和DivideModifier都有一个值为1的Bias值(加法的Bias值为0), 因此它看起来像:

1

1 + (Mod1.Magnitude - 1) + (Mod2.Magnitude - 1) + ...

该公式会导致一些意料之外的结果, 首先, 它在对BaseValue乘除之前将所有的Modifier都加到了一起, 大部分人都期望将其乘或除在一起, 例如, 你有两个值为1.5的MultiplyModifier, 大部分人都期望将BaseValue乘上1.5 x 1.5 = 2.25, 然而, 这里是将两个1.5加在一起再乘以BaseValue(50%增量 + 另一个50%增量 = 100%增量).拿GameplayPrediction.h中的一个例子来说, 给基值速度500加上10%的加速buff就是550, 再加上另一个10%的加速buff就是600.

其次, 该公式还有一些对于可以使用哪些值而未说明的的规则, 因为这是考虑Paragon的情况而设计的.

译者注: 说实话, 我没有搞懂下文中原文档作者的逻辑, 可能是没有充分了解项目的原因? 比如在样例项目中, 删除BP_DamageVolume的GameplayEffect中的Executions, 并按照下文例4添加两个Multiply Multipliers, Attribute均为GDAttributeSetBase.XP, Modifier Magnitude均为Scalable Float/5.0, 回到游戏, 击杀一个小兵使XP增加到1, 然后进入BP_DamageVolume, 会发现XP依次变为25, 625…, 进行调试也会发现是Modifier依次相乘的, 并不是作者所说的乘法分配律逻辑. 还有就是为什么符合公式规则的1 + (0.5 - 1) + (1.1 - 1) = 0.6是正确的而不符合公式规则的1 + (0.5 - 1) + (0.5 - 1) = 0和1 + (5 - 1) + (5 - 1) = 9就是错误预期? 这个正确和错误预期是以什么为评判标准的? 是否符合公式规则么? 如果各位明白其中道理, 还请不吝赐教, 在此感谢!*

对于Multiply和Divide中乘法加法公式的规则:

• (最多不超过1个值 < 1) AND (任意数量值位于[1, 2))
• OR (一个值 >= 2)

公式中的Bias基本上都会减去[1, 2)区间中的整数位, 第一个Modifier的Bias会从最开始的Sum值减值(在循环体前设置Bias), 这就是为什么某个值它本身能起作用的原因以及某个小于1的值与[1, 2)区间中的值起作用的原因.

Multiply的一些例子:
Multipliers: 0.5
1 + (0.5 - 1) = 0.5, 正确.

Multipliers: 0.5, 0.5
1 + (0.5 - 1) + (0.5 - 1) = 0, 错误预期1? 多个小于1的值在Modifier相加中不起作用. Paragon这样设计只是为了使用Multiply Modifier的最负值, 因此最多只会有一个小于1的值乘到BaseValue.

Multipliers: 1.1, 0.5
1 + (0.5 - 1) + (1.1 - 1) = 0.6, 正确.

Multipliers: 5, 5
1 + (5 - 1) + (5 - 1) = 9, 错误预期10. 它总会是Modifier值的和 - Modifier个数 + 1.

很多游戏会想要它们的Modify和DivideModifier在应用到BaseValue之前先乘或除到一起, 为了实现这种需求, 你需要修改FAggregatorModChannel::EvaluateWithBase()的引擎代码.

1
2
3
4
5
6
7
8

float FAggregatorModChannel::EvaluateWithBase(float InlineBaseValue, const FAggregatorEvaluateParameters& Parameters) const
{
	...
	float Multiplicitive = MultiplyMods(Mods[EGameplayModOp::Multiplicitive], Parameters);
	...

	return ((InlineBaseValue + Additive) * Multiplicitive) / Division;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

float FAggregatorModChannel::MultiplyMods(const TArray<FAggregatorMod>& InMods, const FAggregatorEvaluateParameters& Parameters)
{
	float Multiplier = 1.0f;

	for (const FAggregatorMod& Mod : InMods)
	{
		if (Mod.Qualifies())
		{
			Multiplier *= Mod.EvaluatedMagnitude;
		}
	}

	return Multiplier;
}

Modifier 的 GameplayTag

每个 Modifier 都可以设置 SourceTag 和 TargetTag, 它们的作用就像 GE 的 Application Tag requirements, 因此只有当GE 应用后才会考虑标签, 对于周期性的 (Infinite)GE, 这些标签只会在第一次应用 Effect 时才会被考虑, 而不是在每次周期执行时.

Attribute Based Modifier 可以额外设置 SourceTagFilter 和 TargetTagFilter. 当确定的 (Source)Attribute 的 Magnitude 时, 这些过滤器就会用来将某些 Modifier 排除在该 Attribute 之外, 源(Source)或目标(Target)中没有过滤器所有标签的 Modifier 也会被排除在外.

这更详尽的意思是: 源(Source) ASC 和目标(Target) ASC 的标签都被 GE 所捕获, 当 GE Spec 创建时, 源(Source) ASC 的标签被捕获, 当执行 Effect 时, 目标(Target) ASC 的标签被捕获. 当确定 (Infinite)GE 或 (Duration)GE 的 Modifier 是否满足条件可以被应用(也就是聚合器条件(Aggregator Qualify))并且过滤器已经设置时, 被捕获的标签就会和过滤器进行比对.

如果这些要求无法满足游戏的需求，可以从UGameplayEffectCustomApplicationRequirement 基类派生数据对象，在其中你可以编写可任意定义复杂应用规则的本地代码。

08 Execution Calculation (ExecCalc)

[!quote] 应用场景
需要 Source 或 Target 的大量属性和其他值的伤害计算，可以捕获和修改多个 Attribute。

UGameplayEffectExecutionCalculation

ExecutionCalculation 简称 Execution 或 ExecCalc（我喜欢后者）。是 GE 对 ASC 进行修改最强有力的方式.

• 和 MMC 一样, 它也可以捕获 Attribute 并选择性地为其创建 Snapshot。
• 和 MMC 不同的是, 它可以修改多个 Attribute 并且基本上可以处理程序员想要做的任何事。
• ExecCalc 只能由 (Instant)GE 和 (Periodic)GE 使用

网络：

• 不可预测
• 对于 Local Predicted, Server Only 和 Server Initiated 的 GA， ExecCalc 只在服务端调用.

ExecutionParams

UGameplayEffectExecutionCalculation 子类只需要重载 Execute 函数：

1
2
3
4
5
6
7
8
9

 /**
 * 每当执行 owning GE 时都会调用。允许做任何想做的事，包括生成即时执行的新Modifier。
 * 注：本地子类应重载自动生成的 Execute_Implementation 函数，而不是此函数。
 * 
 * @param ExecutionParams 自定义执行计算的参数
 * @param OutExecutionOutput [OUT] 由执行程序生成的输出数据，详细说明执行程序的进一步行为或结果
 */
UFUNCTION(BlueprintNativeEvent, Category="Calculation")
void Execute(const FGameplayEffectCustomExecutionParameters& ExecutionParams, FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const;

该函数的第一个参数十分强大，通过该参数可以获取 OwningSpec、TargetASC、SourceASC。几乎获得了一切计算资源！

1
2
3
4
5
6
7
8

/** Simple accessor to owning gameplay spec */
const FGameplayEffectSpec& GetOwningSpec() const;

/** Simple accessor to target ability system component */
UAbilitySystemComponent* GetTargetAbilitySystemComponent() const;

/** Simple accessor to source ability system component (could be null!) */
UAbilitySystemComponent* GetSourceAbilitySystemComponent() const;

使用方法

本项目中用于计算伤害的 GE_ExecCalc_Damage 使用了 ExecCalc，以此为例讲述一下 ExecCalc 的使用方法。

1. 创建 UGameplayEffectExecutionCalculation 子类 UExecCalc_Damage， GE_ExecCalc_Damage 指定该类为 Calculation Class

1
2
3
4
5
6
7
8
9
10
11

/** Execution Calculation 计算伤害 */
UCLASS()
class PROJECTGASRPG_API UExecCalc_Damage : public UGameplayEffectExecutionCalculation
{
	GENERATED_BODY()

public:
	UExecCalc_Damage();

	virtual void Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams, FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const override;
};

2. 为了设置 Attribute 捕获, 我们采用 Epic 的 ActionRPG 样例项目使用的方式, 定义一个保存和声明如何捕获 Attribute 的结构体, 并在该结构体的构造函数中创建一个它的副本(Copy). 每个 ExecCalc 都需要有一个这样的结构体.
   • 项目中用于计算伤害的 GE_ExecCalc_Damage 使用的 Calc Class 中定义了一个结构体（以下为简化版本）：该结构体指明了我们要捕获 Source 的攻击力和 Target 的防御力。

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

/** 该结构体用于捕获属性的声明和定义 */
struct MageDamageStatics
{
	/** 声明捕获属性 */
	/** Source */
	DECLARE_ATTRIBUTE_CAPTUREDEF(Attack);

	/** Target */
	DECLARE_ATTRIBUTE_CAPTUREDEF(Defense);

	MageDamageStatics()
	{
		/** 定义捕获属性 */
		/** Source */
		DEFINE_ATTRIBUTE_CAPTUREDEF(UMageAttributeSet, Attack, Source, true); 

		/** Target */
		DEFINE_ATTRIBUTE_CAPTUREDEF(UMageAttributeSet, Defense, Target, false);
	}
};

/** MageDamageStatics 单例 */
// 静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
static const MageDamageStatics& DamageStatics()
{
	//C++11 局部静态变量只会初始化一次
	static MageDamageStatics DmgStatics;
	return DmgStatics;
}

[!BUG]
每个结构体需要一个独一无二的名字, 因为它们共享同一个命名空间, 多个结构体使用相同名字在捕获 Attribute 时会造成错误 (大多是捕获到错误的 Attribute 值).

3. 实现重载的 Execute 函数，输出计算结果到元属性MetaDamage

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

UExecCalc_Damage::UExecCalc_Damage()
{
    //捕捉与计算相关的属性
	RelevantAttributesToCapture.Add(DamageStatics().AttackDef);

	RelevantAttributesToCapture.Add(DamageStatics().DefenseDef);
}

void UExecCalc_Damage::Execute_Implementation(const FGameplayEffectCustomExecutionParameters& ExecutionParams,
	FGameplayEffectCustomExecutionOutput& OutExecutionOutput) const
{
	/** 获取ASC */
	UAbilitySystemComponent* SourceASC = ExecutionParams.GetSourceAbilitySystemComponent();
	UAbilitySystemComponent* TargetASC = ExecutionParams.GetTargetAbilitySystemComponent();

	/** 获取AvatarActor */
	AActor* SourceAvatarActor = SourceASC ? SourceASC->GetAvatarActor() : nullptr;
	AActor* TargetAvatarActor = TargetASC ? TargetASC->GetAvatarActor() : nullptr;

	/** 获取GameplayEffectSpec */
	const FGameplayEffectSpec& EffectSpec = ExecutionParams.GetOwningSpec();

	/** 获取GameplayEffectContext */
	FGameplayEffectContextHandle EffectContextHandle = EffectSpec.GetContext();
	
	/** 获取Tag */
	const FGameplayTagContainer* SourceTags = EffectSpec.CapturedSourceTags.GetAggregatedTags();
	const FGameplayTagContainer* TargetTags = EffectSpec.CapturedTargetTags.GetAggregatedTags();

	FAggregatorEvaluateParameters EvaluationParameters;
	EvaluationParameters.SourceTags = SourceTags;
	EvaluationParameters.TargetTags = TargetTags;

	/** 获取捕获的属性值 */
	float Source_Attack= 0.0f;
	float Target_Defense = 0.0f;
		ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().MaxMagicAttackDef, EvaluationParameters, Source_Attack);
		Source_Attack = FMath::Max<float>(0.0f,Source_Attack);
	}
ExecutionParams.AttemptCalculateCapturedAttributeMagnitude(DamageStatics().DefenseDef, EvaluationParameters, Target_Defense);
	Target_Defense = FMath::Max<float>(0.0f,Target_Defense);
	
    //...使用捕获的属性值进行后续计算得到FinalDamage

    /** 最后计算的结果输出，用于修改MetaDamage属性 */
	const FGameplayModifierEvaluatedData EvaluatedData(UMageAttributeSet::GetMetaDamageAttribute(), EGameplayModOp::Additive, FinalDamage);
	OutExecutionOutput.AddOutputModifier(EvaluatedData);
}

发送数据到 ExecCalc

除了捕获Attribute, 还有几种方法可以发送数据到ExecutionCalculation.

SetByCaller

通过 GetOwningSpec() 可以获取 OwningSpec ，任何设置在 GE Spec 中的 SetByCaller 都可以直接在 Execute() 中读取.