Zoomi的虚幻世界

我的邮箱:LFF3216689784@outlook.com

0%

GAS系统API百科全书

发表于 分类于 ，

GAS系统简介-什么是GAS系统

GAS​​ 即 ​​Gameplay Ability System​​（游戏玩法能力系统），是 ​​Epic Games​​ 在 ​​Unreal Engine（虚幻引擎）​​ 中开发的一套功能强大且灵活的框架，用于管理和实现复杂的游戏玩法机制。​

GAS 的核心组件

GAS 主要由以下三个核心组件构成：

  1. ​​Ability System Component (ASC)​​:

    • ​​作用​​：作为 GAS 的核心，ASC 负责管理角色的能力、属性和效果。每个拥有 GAS 的角色通常都有一个 ASC 实例。
    • ​​功能​​：
      • 管理和激活能力（Abilities）。
      • 处理属性（Attributes）的增减和查询。
      • 应用和管理效果（Effects），如增益、减益、伤害等。
      • 提供输入绑定和能力激活的接口。

  2. ​​Abilities（能力）​​:

    • ​​定义​​：能力代表角色可以执行的特定动作或行为，如攻击、跳跃、治疗等。
    • ​​实现​​：通过继承 UGameplayAbility 类来创建自定义能力，定义能力的激活条件、执行逻辑和冷却时间等。

  3. ​​Attributes（属性）​​:

    • ​​定义​​：属性代表角色的各种数值特征，如生命值、法力值、攻击力等。
    • ​​实现​​：通过继承 UAttributeSet 类来创建自定义属性集，定义角色的基础属性和衍生属性。

  4. ​​Effects（效果）​​:

    • ​​定义​​：效果用于修改角色的属性或状态，如增加攻击力、减少移动速度、施加中毒效果等。
    • ​​实现​​：通过创建 GameplayEffect 子类来定义各种效果，设置效果的类型、持续时间、数值变化等。

GAS 的优势与使用步骤

  • ​​模块化设计​​：GAS 将能力、属性和效果分离，使得系统更加清晰和易于维护。
  • ​​高度可扩展​​：开发者可以根据项目需求自定义能力、属性和效果，满足各种复杂的游戏玩法需求。
  • ​​灵活的激活机制​​：支持基于输入、状态或其他条件的能力激活，适应不同的游戏设计模式。
  • ​​网络同步​​：内置的网络同步机制，确保在多人游戏中能力、属性和效果的一致性和实时性。
  • ​​可视化编辑​​：通过蓝图系统，开发者可以在编辑器中直观地配置和调试 GAS 组件，提高开发效率。

  • 如何在项目中启用 GAS

  1. ​​启用 GAS 插件​​：

    • 在 Unreal Engine 编辑器中，导航到 编辑 > 插件。
    • 搜索并启用 Gameplay Ability System 插件。
    • 重启编辑器以应用更改。

  2. ​​创建 Ability System Component (ASC)​​：

    • 在角色类中添加一个 UAbilitySystemComponent 类型的成员变量。
    • 初始化并绑定 ASC 到角色。

  3. ​​定义 Attributes​​：

    • 创建继承自 UAttributeSet 的自定义属性集类。
    • 定义所需的属性，如生命值、法力值等。

  4. ​​创建 Abilities​​：

    • 创建继承自 UGameplayAbility 的自定义能力类。
    • 实现能力的激活逻辑、执行过程和冷却机制。

  5. ​​配置 Effects​​：

    • 创建继承自 UGameplayEffect 的自定义效果类。
    • 定义效果的类型、数值变化和应用逻辑。

  6. ​​绑定输入和激活能力​​：

    • 在角色或控制器中绑定输入事件，调用 ASC 的能力激活函数。
    • 根据游戏逻辑决定何时激活特定能力。

示例代码

以下是一个简单的示例，展示如何在角色类中初始化 GAS 组件并激活一个能力：

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
// MyCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "AbilitySystemInterface.h"
#include "MyCharacter.generated.h"

UCLASS()
class MYGAME_API AMyCharacter : public ACharacter, public IAbilitySystemInterface
{
    GENERATED_BODY()

public:
    AMyCharacter();

    // IAbilitySystemInterface 实现
    virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override;

protected:
    // ASC 实例
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Abilities", meta = (AllowPrivateAccess = "true"))
    class UAbilitySystemComponent* AbilitySystemComponent;

    virtual void BeginPlay() override;
    virtual void PossessedBy(AController* NewController) override;

public:
    // 激活特定能力
    void ActivateAbility(FGameplayAbilitySpecHandle AbilityHandle);
};

// MyCharacter.cpp
#include "MyCharacter.h"
#include "AbilitySystemComponent.h"
#include "MyAbilitySet.h" // 自定义属性集
#include "MyGameplayAbility.h" // 自定义能力

AMyCharacter::AMyCharacter()
{
    // 创建并附加 ASC
    AbilitySystemComponent = CreateDefaultSubobject<UAbilitySystemComponent>(TEXT("AbilitySystemComponent"));
    AbilitySystemComponent->SetupAttachment(RootComponent);
}

UAbilitySystemComponent* AMyCharacter::GetAbilitySystemComponent() const
{
    return AbilitySystemComponent;
}

void AMyCharacter::BeginPlay()
{
    Super::BeginPlay();

    if (AbilitySystemComponent)
    {
        // 初始化属性集
        AbilitySystemComponent->InitAbilityActorInfo(this, this);

        // 加载并赋予基础能力（假设在蓝图中配置）
    }
}

void AMyCharacter::PossessedBy(AController* NewController)
{
    Super::PossessedBy(NewController);

    if (AbilitySystemComponent && NewController)
    {
        AbilitySystemComponent->InitAbilityActorInfo(this, this);

        // 可以在这里根据控制器类型进行额外的初始化
    }
}

void AMyCharacter::ActivateAbility(FGameplayAbilitySpecHandle AbilityHandle)
{
    if (AbilitySystemComponent)
    {
        AbilitySystemComponent->TryActivateAbility(AbilityHandle);
    }
}

API百科

virtual void UAibilitySystemComponent::InitAbilityActorInfo(AActor *InOwnerActor, AActor *InAvatarActor) 函数说明

  • ​​功能​​：初始化能力的 Actor 信息——用于保存关于我们作用于谁以及谁控制我们的信息的结构体。
  • ​​参数​​：
    • InOwnerActor：从逻辑上拥有此组件的 Actor。
    • InAvatarActor：我们在世界中实际作用的物理 Actor。通常是 Pawn，但也可能是 Tower、Building、Turret 等，可能与 InOwnerActor 是同一个对象。

解释

在虚幻引擎的 Gameplay Ability System（GAS）中，这个函数起着关键作用。它确保了能力系统能够正确识别和管理与角色相关的 Actor 信息。OwnerActor 帮助确定逻辑上的所属关系，而 InAvatarActor 则明确了实际进行交互操作的对象，这对于能力的触发、效果应用等方面都非常重要。

示例代码（假设在自定义组件中调用该函数进行初始化）

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
// 假设在某个自定义组件类中
#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "MyAbilitySystemComponent.h" // 引入你的 Ability System Component 头文件
#include "MyCustomComponent.generated.h"

UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class YOURGAMENAME_API UMyCustomComponent : public UActorComponent
{
    GENERATED_BODY()
    
public:    
    // Sets default values for this component's properties
    UMyCustomComponent();
    
protected:
    // Called when the game starts
    virtual void BeginPlay() override;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "AbilitySystem")
    UAbilitySystemComponent* AbilitySystemComp; // 假设你有一个 Ability System Component 成员变量
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Actors")
    AActor* OwnerActor; // 可以设置逻辑拥有者 Actor
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Actors")
    AActor* AvatarActor; // 可以设置实际作用的 Actor
    
private:
    // 其他私有成员变量和函数
};

// 实现 BeginPlay 函数，在其中调用 InitAbilityActorInfo 进行初始化
void UMyCustomComponent::BeginPlay()
{
    Super::BeginPlay();
    
    if (AbilitySystemComp && OwnerActor && AvatarActor)
    {
        AbilitySystemComp->InitAbilityActorInfo(OwnerActor, AvatarActor);
    }
}

使用场景说明

在游戏开发中，当你需要使用 GAS 来管理角色的能力时，通常会在角色或相关组件的初始化阶段调用 InitAbilityActorInfo 函数。例如，在角色生成时，或者在自定义组件初始化时，确保 GAS 能够正确关联到对应的 Actor 信息，以便后续进行能力的激活、效果的管理等操作。

注意事项

  • 确保 AbilitySystemComp、OwnerActor 和 AvatarActor 在调用函数时都已经正确初始化且不为空，否则可能会导致运行时错误。
  • 根据实际游戏逻辑，合理设置 OwnerActor 和 AvatarActor 的值，以准确反映角色之间的所属和交互关系。
  • 如果在多人联机环境下，要注意这些 Actor 信息的同步问题，确保客户端和服务器端的一致性。

PossessedBy(AController* NewController) 函数详解

核心内容分析

PossessedBy(AController* NewController) 是 Unreal Engine（虚幻引擎）中 ACharacter 类的一个重要虚函数，用于处理控制器（Controller）拥有（Possess）角色（Character）时的逻辑。在游戏开发中，控制器负责管理玩家的输入或 AI 的决策，而角色则是游戏中实际执行动作的实体。当控制器拥有一个角色时，PossessedBy 函数会被调用，允许开发者在角色被控制时进行必要的初始化和设置。

函数签名

1
virtual void PossessedBy(AController* NewController) override;
  • ​​PossessedBy​​: 虚函数，用于响应控制器拥有角色的事件。
  • ​​AController* NewController​​: 指向新拥有该角色的控制器的指针。

在 GAS 中的作用

在 ​​Gameplay Ability System (GAS)​​ 中，PossessedBy 函数的作用尤为重要，因为它涉及到 ​​Ability System Component (ASC)​​ 的初始化和管理。ASC 是 GAS 的核心组件，负责管理角色的能力（Abilities）、属性（Attributes）和效果（Effects）。当控制器拥有角色时，需要确保 ASC 能够正确地与控制器关联，并进行必要的初始化操作。

详细解释

  1. ​​初始化 Ability System Component (ASC)​​:
    当控制器拥有一个角色时，通常需要确保该角色的 ASC 被正确初始化。这包括绑定与控制器相关的输入、设置默认的游戏玩法标签（Gameplay Tags）等。

  2. ​​绑定输入和能力激活​​:
    控制器可能负责处理玩家的输入，这些输入用于激活角色的能力。通过在 PossessedBy 中设置适当的绑定，可以确保当控制器发出指令时，ASC 能够正确响应并激活相应的能力。

  3. ​​管理游戏玩法标签和效果​​:
    控制器的拥有关系变化可能会影响角色的游戏玩法标签或应用的效果。例如，当 AI 控制器拥有角色时，可能需要应用特定的效果或标签，以反映 AI 的行为模式。

示例代码

以下是一个示例，展示如何在自定义的 Character 类中重写 PossessedBy 函数，并在其中初始化 GAS 相关的逻辑：

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
// MyCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "AbilitySystemInterface.h"
#include "MyCharacter.generated.h"

UCLASS()
class MYGAME_API AMyCharacter : public ACharacter, public IAbilitySystemInterface
{
    GENERATED_BODY()

public:
    AMyCharacter();

    // IAbilitySystemInterface 实现
    virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override;

protected:
    // ASC 实例
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Abilities", meta = (AllowPrivateAccess = "true"))
    class UMyAbilitySystemComponent* AbilitySystemComponent;

    virtual void PossessedBy(AController* NewController) override;
    virtual void UnPossess() override; // 可选：处理控制器失去控制的情况
};

// MyCharacter.cpp
#include "MyCharacter.h"
#include "AbilitySystemComponent.h"
#include "MyAbilitySystemComponent.h" // 假设你有一个自定义的 ASC 类

AMyCharacter::AMyCharacter()
{
    // 创建并附加 ASC
    AbilitySystemComponent = CreateDefaultSubobject<UMyAbilitySystemComponent>(TEXT("AbilitySystemComponent"));
    AbilitySystemComponent->SetupAttachment(RootComponent);
}

UAbilitySystemComponent* AMyCharacter::GetAbilitySystemComponent() const
{
    return AbilitySystemComponent;
}

void AMyCharacter::PossessedBy(AController* NewController)
{
    Super::PossessedBy(NewController);

    if (AbilitySystemComponent && NewController)
    {
        // 初始化 ASC，例如绑定输入、设置默认标签等
        AbilitySystemComponent->InitAbilityActorInfo(this, this);

        // 如果有玩家控制器，可以进一步初始化与玩家相关的内容
        APlayerController* PlayerController = Cast<APlayerController>(NewController);
        if (PlayerController)
        {
            // 例如，绑定输入映射
            // AbilitySystemComponent->BindToInput(PlayerController);
        }

        // 激活默认能力（如果需要）
        // AbilitySystemComponent->ActivateAbility(FGameplayAbilitySpecHandle());
    }
}

void AMyCharacter::UnPossess()
{
    Super::UnPossess();

    if (AbilitySystemComponent)
    {
        // 清理与控制器相关的逻辑，例如清除输入绑定、重置状态等
        // AbilitySystemComponent->ClearBindings();
    }
}

关键步骤解释

  1. ​​调用父类函数​​:

    1
    Super::PossessedBy(NewController);

    确保基类的 PossessedBy 逻辑被执行，以处理默认的拥有行为。

  2. ​​初始化 ASC​​:

    1
    AbilitySystemComponent->InitAbilityActorInfo(this, this);

    这一步将角色和控制器信息绑定到 ASC，使其能够正确管理角色的能力和属性。

  3. ​​处理特定类型的控制器​​:

    1
    2
    3
    4
    5
    APlayerController* PlayerController = Cast<APlayerController>(NewController);
    if (PlayerController)
    {
        // 绑定输入或其他玩家特定逻辑
    }

    根据控制器的类型（玩家控制器或 AI 控制器），执行不同的初始化逻辑。

  4. ​​激活默认能力​​:
    根据需要，可以在控制器拥有角色时激活某些默认的能力，确保角色在拥有后立即具备所需的行为。

    1
    // AbilitySystemComponent->ActivateAbility(FGameplayAbilitySpecHandle());

  5. ​​处理失去控制的情况​​（可选）:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void AMyCharacter::UnPossess()
    {
        Super::UnPossess();

        if (AbilitySystemComponent)
        {
            // 清理与控制器相关的逻辑，例如清除输入绑定、重置状态等
            // AbilitySystemComponent->ClearBindings();
        }
    }

    在控制器失去对角色的控制时，进行必要的清理工作，确保角色状态的一致性。

使用场景说明

在游戏开发中，PossessedBy 函数通常用于以下场景：

  • ​​角色初始化​​: 当玩家或 AI 控制器首次拥有角色时，进行必要的初始化设置，如绑定输入、激活默认能力等。
  • ​​控制器切换​​: 当控制器在运行时切换（例如，玩家死亡后重新控制另一个角色），确保新控制器正确地与角色关联。
  • ​​状态管理​​: 根据控制器的类型（玩家或 AI），调整角色的行为和状态，以适应不同的游戏逻辑。

注意事项

  • ​​避免重复初始化​​: 确保 PossessedBy 中的初始化逻辑不会在每次控制器切换时重复执行不必要的操作，可以通过标志位或其他机制来管理初始化状态。

  • ​​处理失去控制的情况​​: 除了 PossessedBy，还需要重写 UnPossess 函数，以处理控制器失去对角色控制时的清理工作，确保角色状态的一致性。

  • ​​同步问题​​: 在多人联机环境下，要注意这些 Actor 信息的同步问题，确保客户端和服务器端的一致性，特别是在激活能力和应用效果时。

  • ​​输入绑定​​: 确保输入绑定与控制器的类型匹配，避免在 AI 控制器上绑定不必要的玩家输入逻辑。

​​FGameplayAbilitySpec​​

​​是Unreal Engine (UE)​​ 中 ​​Gameplay Ability System (GAS)​​ 的核心结构体，用于定义和管理单个游戏玩法能力实例。

​​1. 主要组成部分​​

属性 类型 描述
​​Ability​​ TSubclassOf<UGameplayAbility> 具体的能力类（如 UMyGameplayAbility）。
​​InputID​​ int32 输入绑定 ID（如键盘按键或手柄按钮）。
​​Level​​ int32 能力等级（影响强度或效果）。
​​ActivationBlockedBy​​ FGameplayTagContainer 阻止激活的标签（如“眩晕”状态）。
​​GrantedTags​​ FGameplayTagContainer 激活时授予的标签（影响其他能力）。
​​SourceObject​​ UObject* 能力来源（如角色、道具）。
​​StartTime​​ float 激活时间（用于计算持续时间/冷却）。
​​Duration​​ float 持续时间（持续型能力）。
​​CooldownTimeRemaining​​ float 剩余冷却时间。
​​bIsActive​​ bool 是否处于激活状态。

​​2. 创建与管理​​

​​2.1 创建 FGameplayAbilitySpec​​

1
2
3
4
5
6
7
8
9
10
11
12
13
// 获取 AbilitySystemComponent
UAbilitySystemComponent* ASC = xxx/* 获取或初始化 */;

// 定义能力类和等级
TSubclassOf<UGameplayAbility> AbilityClass = UMyGameplayAbility::StaticClass();
int32 Level = 1;
int32 InputID = 0; // 绑定输入（如按键）

// 创建 Spec
FGameplayAbilitySpec Spec(AbilityClass, Level, InputID);

// 添加到 AbilitySystemComponent
ASC->GiveAbility(Spec);

​​3.1 激活/取消能力​​

1
2
3
4
5
// 激活能力
ASC->ActivateAbility(Spec.Handle);

// 取消能力
ASC->CancelAbility(Spec.Handle, Spec.ActivationInfo, true);

GAS-通知蓝图-很重要必须看！

看不到图片请联系我，我会给你发本地文档，因为本人很懒，暂时不想添加图片显示。

![[Pasted image 20250422172242.png]]

通知蓝图中有个接受通知事件，节点如下
该节点发送通知给角色，接受一个角色标签
![[Pasted image 20250422172549.png]]
通知的的原理：一定要使得游戏标签可见，使用send gameplayevent to actor 节点将通知通过游戏标签发送给角色，Event gameplay enent节点用于接受通知并执行
![[Pasted image 20250422173850.png]]
那么可以利用在动画蓝图中放置自定义通知，一旦动画播放完，收到通知则将武器绑定到手部，实现或者实现其它任意功能了。