1
// ===== 没有 GAS 时，一个"火球技能"长什么样？ =====
2

3
// ✗ 传统做法：所有逻辑塞进一个类
4
UCLASS()
5
class AFireballSkill_Bad : public AActor
6
{
7
    GENERATED_BODY()
8

9
public:
10
    // ---- 数值逻辑 ----
11
    float Damage;
12
    float ManaCost;
13
    float CooldownTime;
14

15
    // ---- 表现逻辑 ----
16
    UPROPERTY()
17
    TObjectPtr<UParticleSystem> VFX;
18

19
    UPROPERTY()
20
    TObjectPtr<USoundCue> SFX;
21

22
    // ---- 状态管理 ----
23
    bool bIsOnCooldown;
24
    float CooldownRemaining;
25

26
    // ---- 网络同步 ----
27
    UPROPERTY(Replicated)
28
    bool bIsActive;
29

30
    void Cast()
31
    {
32
        // 检查法力 → 扣除法力 → 造成伤害 → 播放特效 → 进入冷却
33
        // 300 行代码全在一个函数里——策划改伤害值要改 C++！
34
    }
35
};
36
// 问题：
37
// - 数值（Damage/ManaCost）散落在代码里，策划改不了
38
// - 表现（VFX/SFX）和逻辑（伤害计算）硬耦合——换个特效要改技能类
39
// - 冷却逻辑每个技能都要重新实现
40
// - 网络同步靠手写 Replicated + RPC——极易出错

1
// ===== GAS 六层架构一句话总结 =====
2
//
3
// GameplayTag —— "技能系统的 HTTP 协议"——所有通信都通过标签
4
//   → 用层级命名（Ability.Skill.Fire.Fireball）建立全局命名空间
5
//   → 任何组件可以通过标签查询/匹配，无需知道对方的具体类型
6
//
7
// AbilitySystemComponent —— "技能系统的 CPU"
8
//   → 每个需要技能的 Actor 挂一个 ASC（通常在 PlayerState 或 Character 上）
9
//   → 管理 Ability 的激活/取消、Effect 的应用/移除、网络复制
10
//
11
// AttributeSet —— "技能系统的内存"
12
//   → 存所有数值：Health、Mana、Stamina、AttackPower、Speed...
13
//   → 不包含行为——数值如何变化由 GameplayEffect 决定
14
//
15
// GameplayEffect —— "数值变化的配方"
16
//   → 定义一个"数值变化"：哪个属性、怎么变、持续多久
17
//   → 四种类型：Instant（立即）/ Duration（持续）/ Infinite（永久）/ Periodic（周期）
18
//
19
// GameplayAbility —— "技能的执行流程"
20
//   → 激活时检查 Cost/Cooldown → 应用 Effect → 结束或持续
21
//   → 只管逻辑流程：检查条件 → 消耗资源 → 产生效果
22
//   → 不碰表现层——VFX/SFX 通过 GameplayCue 解耦
23
//
24
// GameplayCue —— "技能的表现层"
25
//   → 接收 GameplayCue 通知 → 播放 VFX、SFX、CameraShake
26
//   → 完全与数值逻辑解耦——换个特效不需要改技能代码

1
// ===== ASC 的归属决策 =====
2
//
3
// 这是 GAS 的第一个架构决策——ASC 挂在哪里？
4
//
5
// 方案 A：ASC 在 PlayerState 上（Epic 官方推荐）
6
//   ✓ 网络复制天然正确——PlayerState 跨关卡持久存在
7
//   ✓ 死亡/重生时数据不丢失（PlayerState 生命周期 = 连接生命周期）
8
//   ✓ 适合大多数游戏——MOBA、RPG、射击游戏
9
//
10
// 方案 B：ASC 在 Character/Pawn 上
11
//   ✓ 简单直观——技能属于角色
12
//   ✗ 死亡/重生时可能需要迁移或重建 ASC
13
//   ✗ 网络复制需要额外处理
14
//   适合：简单游戏、单机游戏、快速原型
15
//
16
// 方案 C：ASC 在 PlayerController 上
17
//   不推荐——PlayerController 不适合承载属性数据
18

19
// ---------- 方案 A 实现（推荐） ----------
20
UCLASS()
21
class AMyPlayerState : public APlayerState
22
{
23
    GENERATED_BODY()
24

25
public:
26
    AMyPlayerState()
27
    {
28
        // PlayerState 上创建 ASC
29
        AbilitySystem = CreateDefaultSubobject<UAbilitySystemComponent>(
30
            TEXT("AbilitySystem"));
31
        AbilitySystem->SetIsReplicated(true);        // 开启网络复制
32
        AbilitySystem->SetReplicationMode(           // 设置复制模式
33
            EGameplayEffectReplicationMode::Mixed);   // Mixed = 推荐
34
    }
35

36
    // 注意：在 PlayerState 上时，ASC 的 Owner 和 Avatar 需要正确设置
37
    // Owner = PlayerState（拥有者）
38
    // Avatar = Character（物理化身——执行动画、显示特效的实际 Actor）
39

40
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
41
    TObjectPtr<UAbilitySystemComponent> AbilitySystem;
42
};
43

44
// ---------- 角色侧：访问 ASC ----------
45
UCLASS()
46
class AMyCharacter : public ACharacter, public IAbilitySystemInterface
47
{
48
    GENERATED_BODY()
49

50
public:
51
    // 实现 IAbilitySystemInterface —— GAS 标准接口
52
    virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override
53
    {
54
        if (AMyPlayerState* PS = GetPlayerState<AMyPlayerState>())
55
        {
56
            return PS->AbilitySystem;
57
        }
58
        return nullptr;
59
    }
60
};

1
// ===== ASC 的核心操作 =====
2

3
// ① 授予技能（Give Ability）
4
void GiveAbility(TSubclassOf<UGameplayAbility> AbilityClass)
5
{
6
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
7
    {
8
        // 创建一个 GameplayAbilitySpec —— 技能的"实例描述"
9
        FGameplayAbilitySpecHandle Handle = ASC->GiveAbility(
10
            FGameplayAbilitySpec(
11
                AbilityClass,           // 技能类
12
                1,                      // 等级
13
                INDEX_NONE,             // InputID（-1 = 不绑定输入）
14
                this                    // SourceObject
15
            )
16
        );
17
    }
18
}
19

20
// ② 激活技能
21
bool TryActivateAbility(FGameplayAbilitySpecHandle Handle)
22
{
23
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
24
    {
25
        return ASC->TryActivateAbility(Handle);
26
    }
27
    return false;
28
}
29

30
// ③ 按标签激活
31
bool TryActivateAbilityByTag(FGameplayTagContainer AbilityTags)
32
{
33
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
34
    {
35
        return ASC->TryActivateAbilityByTag(AbilityTags);
36
    }
37
    return false;
38
}
39

40
// ④ 应用 GameplayEffect
41
void ApplyEffect(TSubclassOf<UGameplayEffect> EffectClass, float Level = 1.0f)
42
{
43
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
44
    {
45
        FGameplayEffectContextHandle Context = ASC->MakeEffectContext();
46
        Context.AddSourceObject(this);
47

48
        FGameplayEffectSpecHandle Spec = ASC->MakeOutgoingSpec(
49
            EffectClass, Level, Context);
50

51
        if (Spec.IsValid())
52
        {
53
            ASC->ApplyGameplayEffectSpecToSelf(*Spec.Data.Get());
54
        }
55
    }
56
}
57

58
// ⑤ 获取属性值
59
float GetAttributeValue(FGameplayAttribute Attribute) const
60
{
61
    if (const UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
62
    {
63
        return ASC->GetNumericAttribute(Attribute);
64
    }
65
    return 0.0f;
66
}

1
// ===== GameplayTag：层级命名 + 模糊匹配 =====
2
//
3
// GameplayTag 不是枚举！它是以 "." 分隔的层级字符串：
4
//
5
// Ability.Skill.Fire.Fireball      ← 最具体
6
// Ability.Skill.Fire               ← 父标签（匹配所有火系技能）
7
// Ability.Skill                    ← 更上级
8
// Ability                          ← 最上级
9
//
10
// 核心能力：RequestGameplayTagChildren / MatchesTag ——
11
//   "给我所有火系技能" → 查询 Ability.Skill.Fire 的子标签
12

13
// ---------- 定义 GameplayTag ----------
14
// 方法 1：在 DefaultGameplayTags.ini 中定义（推荐）
15
// [/Script/GameplayTags.GameplayTagsSettings]
16
// +GameplayTagList=(Tag="Ability.Skill.Fire.Fireball",DevComment="火球术")
17

18
// 方法 2：C++ 中注册
19
namespace MyGameplayTags
20
{
21
    // 在 .cpp 中定义
22
    UE_DEFINE_GAMEPLAY_TAG(TAG_Ability_Fire_Fireball, "Ability.Skill.Fire.Fireball");
23
    UE_DEFINE_GAMEPLAY_TAG(TAG_State_Debuff_Burning, "State.Debuff.Burning");
24
    UE_DEFINE_GAMEPLAY_TAG(TAG_State_Cooldown_Fire,  "State.Cooldown.Fire");
25
    UE_DEFINE_GAMEPLAY_TAG(TAG_Event_Damage_Fire,     "Event.Damage.Fire");
26

27
    // 在 .h 中声明
28
    extern UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Ability_Fire_Fireball);
29
    extern UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_State_Debuff_Burning);
30
    extern UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_State_Cooldown_Fire);
31
    extern UE_DECLARE_GAMEPLAY_TAG_EXTERN(TAG_Event_Damage_Fire);
32
}
33

34
// ---------- GameplayTag 的核心操作 ----------
35
void GameplayTagOperations()
36
{
37
    FGameplayTag FireballTag = MyGameplayTags::TAG_Ability_Fire_Fireball;
38
    FGameplayTag FireTag    = FGameplayTag::RequestGameplayTag(
39
        TEXT("Ability.Skill.Fire"));
40
    FGameplayTag DebuffTag  = MyGameplayTags::TAG_State_Debuff_Burning;
41

42
    // ① 精确匹配
43
    bool bIsFireball = FireballTag.MatchesTagExact(
44
        FGameplayTag::RequestGameplayTag(TEXT("Ability.Skill.Fire.Fireball")));
45

46
    // ② 模糊匹配——Fireball 也是 Fire 的一种
47
    bool bIsFireSkill = FireballTag.MatchesTag(FireTag);  // true！
48

49
    // ③ 查询子标签
50
    FGameplayTagContainer AllFireSkills;
51
    AllFireSkills.AddTag(FireTag);
52
    // 然后用 HasAny / HasAll 匹配
53

54
    // ④ GameplayTagContainer
55
    FGameplayTagContainer MyTags;
56
    MyTags.AddTag(FireballTag);
57
    MyTags.AddTag(DebuffTag);
58

59
    // 有没有火系标签？
60
    bool bHasFire = MyTags.HasTag(FireTag);  // true（Fireball 匹配 Fire）
61
}
62

63
// ---------- GameplayTag 的最佳命名规范 ----------
64
// Ability.Skill.{Element}.{Name}    —— 技能标签
65
// State.Buff.{Name}                 —— Buff 状态
66
// State.Debuff.{Name}               —— Debuff 状态
67
// State.Cooldown.{Name}             —— 冷却状态
68
// Event.Damage.{Type}               —— 伤害事件
69
// GameplayCue.{Name}                —— 表现触发
70
//
71
// 规范不是强制——但让你的团队能快速理解标签的含义

1
// ===== AttributeSet 的定义 =====
2
UCLASS()
3
class UMyAttributeSet : public UAttributeSet
4
{
5
    GENERATED_BODY()
6

7
public:
8
    // ---------- 基础属性 ----------
9
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_Health,
10
              Category = "Vital")
11
    FGameplayAttributeData Health;
12
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, Health)  // ← 自动生成 Get/Set/Init
13

14
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_MaxHealth,
15
              Category = "Vital")
16
    FGameplayAttributeData MaxHealth;
17
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, MaxHealth)
18

19
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_Mana,
20
              Category = "Vital")
21
    FGameplayAttributeData Mana;
22
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, Mana)
23

24
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_MaxMana,
25
              Category = "Vital")
26
    FGameplayAttributeData MaxMana;
27
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, MaxMana)
28

29
    // ---------- 战斗属性 ----------
30
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_AttackPower,
31
              Category = "Combat")
32
    FGameplayAttributeData AttackPower;
33
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, AttackPower)
34

35
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_Defense,
36
              Category = "Combat")
37
    FGameplayAttributeData Defense;
38
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, Defense)
39

40
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_MoveSpeed,
41
              Category = "Combat")
42
    FGameplayAttributeData MoveSpeed;
43
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, MoveSpeed)
44

45
    // ---------- ReplicatedUsing 回调 ----------
46
    UFUNCTION()
47
    void OnRep_Health(const FGameplayAttributeData& OldValue)
48
    {
49
        GAMEPLAYATTRIBUTE_REPNOTIFY(UMyAttributeSet, Health, OldValue);
50
    }
51

52
    UFUNCTION()
53
    void OnRep_MaxHealth(const FGameplayAttributeData& OldValue)
54
    {
55
        GAMEPLAYATTRIBUTE_REPNOTIFY(UMyAttributeSet, MaxHealth, OldValue);
56
    }
57

58
    UFUNCTION()
59
    void OnRep_Mana(const FGameplayAttributeData& OldValue)
60
    {
61
        GAMEPLAYATTRIBUTE_REPNOTIFY(UMyAttributeSet, Mana, OldValue);
62
    }
63

64
    UFUNCTION()
65
    void OnRep_MaxMana(const FGameplayAttributeData& OldValue)
66
    {
67
        GAMEPLAYATTRIBUTE_REPNOTIFY(UMyAttributeSet, MaxMana, OldValue);
68
    }
69

70
    UFUNCTION()
71
    void OnRep_AttackPower(const FGameplayAttributeData& OldValue)
72
    {
73
        GAMEPLAYATTRIBUTE_REPNOTIFY(UMyAttributeSet, AttackPower, OldValue);
74
    }
75

76
    UFUNCTION()
77
    void OnRep_Defense(const FGameplayAttributeData& OldValue)
78
    {
79
        GAMEPLAYATTRIBUTE_REPNOTIFY(UMyAttributeSet, Defense, OldValue);
80
    }
81

82
    UFUNCTION()
83
    void OnRep_MoveSpeed(const FGameplayAttributeData& OldValue)
84
    {
85
        GAMEPLAYATTRIBUTE_REPNOTIFY(UMyAttributeSet, MoveSpeed, OldValue);
86
    }
87

88
    // ---------- 网络复制注册 ----------
89
    virtual void GetLifetimeReplicatedProps(
90
        TArray<FLifetimeProperty>& OutLifetimeProps) const override
91
    {
92
        Super::GetLifetimeReplicatedProps(OutLifetimeProps);
93

94
        DOREPLIFETIME_CONDITION_NOTIFY(UMyAttributeSet, Health,
95
            COND_None, REPNOTIFY_Always);
96
        DOREPLIFETIME_CONDITION_NOTIFY(UMyAttributeSet, MaxHealth,
97
            COND_None, REPNOTIFY_Always);
98
        DOREPLIFETIME_CONDITION_NOTIFY(UMyAttributeSet, Mana,
99
            COND_None, REPNOTIFY_Always);
100
        DOREPLIFETIME_CONDITION_NOTIFY(UMyAttributeSet, MaxMana,
101
            COND_None, REPNOTIFY_Always);
102
        DOREPLIFETIME_CONDITION_NOTIFY(UMyAttributeSet, AttackPower,
103
            COND_None, REPNOTIFY_Always);
104
        DOREPLIFETIME_CONDITION_NOTIFY(UMyAttributeSet, Defense,
105
            COND_None, REPNOTIFY_Always);
106
        DOREPLIFETIME_CONDITION_NOTIFY(UMyAttributeSet, MoveSpeed,
107
            COND_None, REPNOTIFY_Always);
108
    }
109
};

1
// ===== PreAttributeChange vs PreAttributeBaseChange vs PostGameplayEffectExecute =====
2
//
3
// 这是 GAS 最易混淆的三个回调——很多人把 Clamping 放在错误的地方导致数据溢出：
4
//
5
// PreAttributeBaseChange：
6
//   - 在属性的**基础值（Base Value）**被修改之前调用
7
//   - 用于对基础值做 Clamping——例如装备变动导致 Base MaxHealth 变更时
8
//   - 只拦截直接修改 Base Value 的操作（如 Instant GE 以 Override 方式设置 Base）
9
//
10
// PreAttributeChange：
11
//   - 在属性的**当前值（Current Value）**被修改之前调用
12
//   - ⚠️ 致命误区：Duration/Infinite GE 的 Modifier 修改的是 Current Value，
13
//     但这些临时 Modifier 会**完全绕过** PreAttributeChange！
14
//     在 PreAttributeChange 中 Clamp 持续性 Buff 的溢出——根本拦截不到！
15
//   - ⚠️ 更致命的时序漏洞：当 MaxHealth 因 Buff 变化时，
16
//     Health 的 PreAttributeChange **不会被触发**——如果 MaxHealth 瞬间暴跌，
17
//     当前 Health 卡在超过上限的非法值，产生恶性 Bug！
18
//
19
// PostGameplayEffectExecute：
20
//   - 在 GameplayEffect **执行完毕**后调用
21
//   - **这里才是做 Current Value 最终钳制的正确位置**（针对 Instant/Periodic GE）
22
//   - 同时触发游戏逻辑——死亡检测、UI 更新
23
//   - 持续性的 Duration/Infinite GE 的 Current Value 约束，
24
//     需要通过重写属性的计算通道或自定义 MMC 来动态钳制
25
//
26
// ✓ 现代 UE5 正确分层：
27
//   PreAttributeBaseChange  → 基础值 Clamping（装备/等级变动）
28
//   PostGameplayEffectExecute → Instant GE 的最终值钳制 + 游戏逻辑触发
29

30
void UMyAttributeSet::PreAttributeBaseChange(const FGameplayAttribute& Attribute,
31
                                               float& NewBaseValue) const
32
{
33
    Super::PreAttributeBaseChange(Attribute, NewBaseValue);
34

35
    // 基础值的 Clamping —— 装备/等级变动导致的 Base Value 变更
36
    if (Attribute == GetHealthAttribute())
37
    {
38
        NewBaseValue = FMath::Clamp(NewBaseValue, 0.0f, GetMaxHealth());
39
    }
40
    else if (Attribute == GetMaxHealthAttribute())
41
    {
42
        NewBaseValue = FMath::Max(NewBaseValue, 1.0f);  // MaxHealth 不能为 0
43
    }
44
}
45

46
void UMyAttributeSet::PreAttributeChange(const FGameplayAttribute& Attribute,
47
                                          float& NewValue)
48
{
49
    Super::PreAttributeChange(Attribute, NewValue);
50

51
    // ⚠️ PreAttributeChange 对 Duration/Infinite GE 的 Modifier 完全无效
52
    //    这里的 Clamp 只在 Base Value 的直接修改时才触发
53
    //    大多数情况下这个回调几乎不做事——Clamp 逻辑已移到 PostGameplayEffectExecute
54
}
55

56
void UMyAttributeSet::PostGameplayEffectExecute(
57
    const FGameplayEffectModCallbackData& Data)
58
{
59
    Super::PostGameplayEffectExecute(Data);
60

61
    // Data.EvaluatedData.Attribute — 被修改的属性
62
    // Data.EvaluatedData.Magnitude — 修改的量值
63

64
    if (Data.EvaluatedData.Attribute == GetHealthAttribute())
65
    {
66
        // ✓ 在这里做 Instant GE 的 Current Value 最终钳制
67
        //   因为 Duration/Infinite GE 的 Modifier 会绕过 PreAttributeChange
68
        //   PostGameplayEffectExecute 是拦截 Instant GE 导致超限的最后防线
69
        float ClampedHealth = FMath::Clamp(GetHealth(), 0.0f, GetMaxHealth());
70
        if (ClampedHealth != GetHealth())
71
        {
72
            SetHealth(ClampedHealth);  // 强制修正到合法范围
73
        }
74

75
        // 触发游戏逻辑——健康值变化后的处理
76
        if (GetHealth() <= 0.0f)
77
        {
78
            // 角色死亡——通知 GameMode 或 Ability
79
            OnCharacterDeath();
80

81
            // 移除所有 Buff/Debuff
82
            if (UAbilitySystemComponent* ASC = Data.Target.GetOwner()
83
                ? Data.Target.GetOwner()->FindComponentByClass<
84
                      UAbilitySystemComponent>()
85
                : nullptr)
86
            {
87
                // 移除所有 GameplayEffect
88
            }
89
        }
90

91
        // 更新 HUD
92
        OnHealthChangedDelegate.Broadcast(GetHealth(), GetMaxHealth());
93
    }
94
    else if (Data.EvaluatedData.Attribute == GetManaAttribute())
95
    {
96
        OnManaChangedDelegate.Broadcast(GetMana(), GetMaxMana());
97
    }
98
}
99

100
// 事件委托——供 UI 绑定
101
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnAttributeChanged, float, float);
102
FOnAttributeChanged OnHealthChangedDelegate;
103
FOnAttributeChanged OnManaChangedDelegate;

1
// ===== Meta Attribute —— 不持久化、不网络复制的"临时属性" =====
2
//
3
// 场景：伤害计算需要"本次攻击的暴击率"——但这个值不是角色的永久属性
4
// 解决：用 Meta Attribute——只在当前 GE 执行期间存在的临时变量
5

6
UCLASS()
7
class UMyAttributeSet : public UAttributeSet
8
{
9
public:
10
    // ---- 正常属性（持久化 + 网络复制） ----
11
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_Health)
12
    FGameplayAttributeData Health;
13
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, Health)
14

15
    // ---- Meta Attribute（临时属性——不复制，不持久化） ----
16
    UPROPERTY(BlueprintReadOnly)
17
    FGameplayAttributeData IncomingDamage;   // 本次受到的原始伤害
18
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, IncomingDamage)
19

20
    UPROPERTY(BlueprintReadOnly)
21
    FGameplayAttributeData CritChance;       // 本次攻击的暴击率
22
    ATTRIBUTE_ACCESSORS(UMyAttributeSet, CritChance)
23
};
24

25
// GE 执行流程中使用 Meta Attribute：
26
// 1. GE Modifier 计算 IncomingDamage = BaseDamage × CritMultiplier
27
// 2. PostGameplayEffectExecute 中读取 IncomingDamage
28
// 3. 应用护甲减免 → 最终 Damage → 修改 Health
29
// 4. IncomingDamage 在下一帧被重置（不持久化）

1
// ===== GameplayEffect 的数据结构（蓝图中配置，C++ 中定义） =====
2
//
3
// GE 不是 C++ 类——而是蓝图 DataAsset！
4
// 你在 C++ 中定义的是 AttributeSet 和 Ability，
5
// GE 则在编辑器中通过蓝图编辑器的表单配置：
6
//
7
// ┌─────────────────────────────────────────────────┐
8
// │ GameplayEffect 蓝图编辑器 - FireDamage           │
9
// ├─────────────────────────────────────────────────┤
10
// │ Duration Policy: Instant                        │
11
// │                                                 │
12
// │ Modifiers:                                      │
13
// │   [0] Attribute: UMyAttributeSet.Health          │
14
// │       ModifierOp: Add                            │
15
// │       Magnitude: -25.0  (Scalable Float)         │
16
// │       SourceTags: Require (None)                 │
17
// │       TargetTags: Require (None)                 │
18
// │                                                 │
19
// │ GameplayEffect Tags:                             │
20
// │   AssetTags: Effect.Damage.Fire                  │
21
// │   GrantedTags: State.OnFire (Duration GE 专用)   │
22
// │                                                 │
23
// │ Stacking:                                       │
24
// │   StackingType: AggregateByTarget                │
25
// │   StackLimitCount: 3                             │
26
// │   StackDurationRefreshPolicy: RefreshOnSuccess   │
27
// │                                                 │
28
// │ Overflow (溢出效果):                             │
29
// │   OverflowEffects: [HealOverflowEffect]          │
30
// │   (如果血量已被扣到 <=0，溢出的伤害转为治疗)       │
31
// │                                                 │
32
// │ Execution:                                      │
33
// │   CalculationClass: UMyDamageCalculation          │
34
// │   (自定义 C++ 计算类——见下文)                     │
35
// └─────────────────────────────────────────────────┘

1
// ===== Modifier 的类型与计算 =====
2
//
3
// GE 的核心是 Modifier —— 描述"哪个属性、怎么变、变多少"
4
//
5
// ModifierOp（操作类型）：
6
//   Add           → Attribute += Magnitude
7
//   Multiply      → Attribute *= Magnitude
8
//   Override      → Attribute  = Magnitude（直接覆盖）
9
//   Divide        → Attribute /= Magnitude
10
//
11
// Magnitude（量值来源）：
12
//   ScalableFloat        → 固定值（如 25.0 伤害）
13
//   AttributeBased       → 基于另一个属性的值（如 AttackPower × 1.5）
14
//   CustomCalculationClass → 自定义 C++ 计算类
15
//   SetByCaller          → 运行时传入的值（最灵活）
16
//
17

18
// ---------- 自定义 Calculation 类（MMC） ----------
19
UCLASS()
20
class UDamageCalculation : public UGameplayModMagnitudeCalculation
21
{
22
    GENERATED_BODY()
23

24
public:
25
    // 捕获属性——从 Source 和目标获取
26
    FGameplayEffectAttributeCaptureDefinition AttackPowerDef;
27

28
    UDamageCalculation()
29
    {
30
        // 捕获来源的攻击力
31
        AttackPowerDef.AttributeToCapture =
32
            UMyAttributeSet::GetAttackPowerAttribute();
33
        AttackPowerDef.AttributeSource =
34
            EGameplayEffectAttributeCaptureSource::Source;
35
        AttackPowerDef.bSnapshot = false;  // 不快照——实时读取
36

37
        RelevantAttributesToCapture.Add(AttackPowerDef);
38
    }
39

40
    virtual float CalculateBaseMagnitude_Implementation(
41
        const FGameplayEffectSpec& Spec) const override
42
    {
43
        // 获取捕获的属性值
44
        FAggregatorEvaluateParameters EvalParams;
45
        EvalParams.SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
46
        EvalParams.TargetTags = Spec.CapturedTargetTags.GetAggregatedTags();
47

48
        float AttackPower = 0.0f;
49
        GetCapturedAttributeMagnitude(AttackPowerDef, Spec, EvalParams, AttackPower);
50

51
        // 自定义计算：伤害 = 攻击力 × 技能倍率 × 暴击倍率
52
        float SkillMultiplier = Spec.GetSetByCallerMagnitude(
53
            FGameplayTag::RequestGameplayTag(TEXT("Data.SkillMultiplier")),
54
            false, 1.0f);
55

56
        float CritMultiplier = Spec.GetSetByCallerMagnitude(
57
            FGameplayTag::RequestGameplayTag(TEXT("Data.CritMultiplier")),
58
            false, 1.0f);
59

60
        return AttackPower * SkillMultiplier * CritMultiplier;
61
    }
62
};
63

64
// ---------- SetByCaller —— 运行时动态传参 ----------
65
void ApplyDamageWithSetByCaller(float BaseDamage, float CritChance)
66
{
67
    FGameplayEffectSpecHandle Spec = ASC->MakeOutgoingSpec(
68
        DamageGEClass, 1.0f, ASC->MakeEffectContext());
69

70
    // 运行时设置 Magnitude —— 策划可以在技能中动态计算
71
    Spec.Data->SetSetByCallerMagnitude(
72
        FGameplayTag::RequestGameplayTag(TEXT("Data.SkillMultiplier")),
73
        BaseDamage);
74
    Spec.Data->SetSetByCallerMagnitude(
75
        FGameplayTag::RequestGameplayTag(TEXT("Data.CritMultiplier")),
76
        FMath::FRand() < CritChance ? 2.0f : 1.0f);
77

78
    ASC->ApplyGameplayEffectSpecToSelf(*Spec.Data.Get());
79
}

1
// ===== GE 堆叠机制 =====
2
//
3
// 场景：同一个中毒效果可以堆叠 3 层——每层每秒 5 伤害
4
//
5
// StackingType：
6
//   None                       → 不堆叠——每个 GE 独立
7
//   AggregateBySource          → 同一来源的效果堆叠
8
//   AggregateByTarget          → 同一目标上的效果堆叠（最常用）
9
//
10
// StackDurationRefreshPolicy：
11
//   RefreshOnSuccess           → 堆叠成功时刷新持续时间
12
//   NeverRefresh               → 不刷新——每层独立倒计时
13

14
// ===== Overflow 机制 —— 效果过载时触发其他效果 =====
15
//
16
// 场景：血量低于 25% → 治疗效果翻倍
17
//      中毒层数达到 3 → 触发爆发伤害
18

19
// 在 GE 蓝图中配置：
20
// OverflowEffects: 添加一个 ExecuteOnOverflow GE
21
// StackLimitCount: 3（堆到 3 层时触发溢出效果）

1
// ===== GameplayAbility 的最小定义 =====
2
UCLASS()
3
class UFireballAbility : public UGameplayAbility
4
{
5
    GENERATED_BODY()
6

7
public:
8
    UFireballAbility()
9
    {
10
        // 技能的网络执行策略
11
        // LocalPredicted —— 本地预测（客户端先行，服务器校验）
12
        // LocalOnly       —— 纯本地（单机技能）
13
        // ServerInitiated —— 仅服务器发起
14
        // ServerOnly      —— 仅服务器执行
15
        InstancingPolicy = EGameplayAbilityInstancingPolicy::InstancedPerActor;
16

17
        // 网络执行策略
18
        NetExecutionPolicy = EGameplayAbilityNetExecutionPolicy::LocalPredicted;
19

20
        // 输入按键绑定
21
        AbilityTags.AddTag(
22
            FGameplayTag::RequestGameplayTag(TEXT("Ability.Skill.Fire.Fireball")));
23

24
        // 激活时自身会被添加的标签（用于其他系统检测）
25
        ActivationOwnedTags.AddTag(
26
            FGameplayTag::RequestGameplayTag(TEXT("State.Casting.Fireball")));
27

28
        // 激活期间阻止的标签
29
        BlockAbilitiesWithTag.AddTag(
30
            FGameplayTag::RequestGameplayTag(TEXT("State.Stunned")));
31
        BlockAbilitiesWithTag.AddTag(
32
            FGameplayTag::RequestGameplayTag(TEXT("State.Dead")));
33

34
        // 激活时取消的技能
35
        CancelAbilitiesWithTag.AddTag(
36
            FGameplayTag::RequestGameplayTag(TEXT("State.Casting")));
37
    }
38

39
    // 技能激活
40
    virtual void ActivateAbility(
41
        const FGameplayAbilitySpecHandle Handle,
42
        const FGameplayAbilityActorInfo* ActorInfo,
43
        const FGameplayAbilityActivationInfo ActivationInfo,
44
        const FGameplayEventData* TriggerEventData) override
45
    {
46
        if (!CommitAbility(Handle, ActorInfo, ActivationInfo))
47
        {
48
            // Cost 或 Cooldown 检查失败 → 取消激活
49
            EndAbility(Handle, ActorInfo, ActivationInfo, true, false);
50
            return;
51
        }
52

53
        // ---- 技能逻辑开始 ----
54

55
        // 1. 获取 Actor 信息
56
        AActor* Avatar = ActorInfo->AvatarActor.Get();
57
        APlayerController* PC = ActorInfo->PlayerController.Get();
58

59
        // 2. 计算目标位置（从玩家视角做射线检测）
60
        FVector AimLocation;
61
        if (!GetAimLocation(AimLocation))
62
        {
63
            EndAbility(Handle, ActorInfo, ActivationInfo, true, true);
64
            return;
65
        }
66

67
        // 3. 生成火球投射物
68
        // ⚠️ 关键！此技能设置了 LocalPredicted → ActivateAbility 会在客户端和服务器各执行一次
69
        //    如果两边都 SpawnActor → 客户端出现两个重叠火球（预测实体 + 服务器复制实体）
70
        //    ✓ 正确做法 A：只在服务器生成权威的复制 Actor
71
        //    ✓ 正确做法 B：使用 UAbilityTask_SpawnActor —— GAS 专用的预测安全生成
72
        if (HasAuthority())
73
        {
74
            FActorSpawnParameters SpawnParams;
75
            SpawnParams.Owner = Avatar;
76
            SpawnParams.Instigator = Cast<APawn>(Avatar);
77

78
            AFireballProjectile* Projectile = GetWorld()->SpawnActor<AFireballProjectile>(
79
                FireballClass,
80
                Avatar->GetActorLocation() + Avatar->GetActorForwardVector() * 100.0f,
81
                AimLocation.Rotation(),
82
                SpawnParams);
83

84
            if (Projectile)
85
            {
86
                // 将 GE Spec 传给投射物——命中时应用
87
                Projectile->DamageEffectSpec = MakeOutgoingGameplayEffectSpec(
88
                    DamageGEClass, GetAbilityLevel());
89
            }
90
        }
91

92
        // 4. 结束技能
93
        EndAbility(Handle, ActorInfo, ActivationInfo, true, false);
94
    }
95

96
    // 技能结束
97
    virtual void EndAbility(
98
        const FGameplayAbilitySpecHandle Handle,
99
        const FGameplayAbilityActorInfo* ActorInfo,
100
        const FGameplayAbilityActivationInfo ActivationInfo,
101
        bool bReplicateEndAbility,
102
        bool bWasCancelled) override
103
    {
104
        // 清理技能状态
105
        Super::EndAbility(Handle, ActorInfo, ActivationInfo,
106
                          bReplicateEndAbility, bWasCancelled);
107
    }
108

109
    UPROPERTY(EditDefaultsOnly, Category = "Fireball")
110
    TSubclassOf<UGameplayEffect> DamageGEClass;
111

112
    UPROPERTY(EditDefaultsOnly, Category = "Fireball")
113
    TSubclassOf<AFireballProjectile> FireballClass;
114
};

1
// ===== GameplayAbility 的激活流程（五阶段状态机）=====
2
//
3
// ① CanActivateAbility —— 条件检查
4
//    检查 Cost（法力够不够）、Cooldown（是否冷却中）、Tags（是否被沉默/眩晕）
5
//    → 失败返回 false，技能不激活
6
//
7
// ② PreActivate —— 预激活
8
//    ASC 锁定技能槽（防止同一技能被重复激活）
9
//    标记 ActivationOwnedTags（如 "State.Casting.Fireball"）
10
//
11
// ③ CommitAbility —— 消耗资源
12
//    扣除 Cost GE（法力消耗）
13
//    启动 Cooldown GE（进入冷却）
14
//    → 失败则取消激活
15
//
16
// ④ ActivateAbility —— 核心逻辑
17
//    你的技能逻辑在这里——生成投射物、应用伤害、播放动画...
18
//    → 可以在此期间的任何时刻调用 EndAbility
19
//
20
// ⑤ EndAbility —— 清理
21
//    移除 ActivationOwnedTags
22
//    通知 ASC 技能已结束
23
//    清理技能内部状态
24

25
// ===== 技能之间的交互 =====
26
//
27
// 一个技能激活时，可以通过 Tag 策略影响其他技能：
28
//
29
// BlockAbilitiesWithTag：  持有 State.Stunned 时 → 阻止所有需要"非眩晕"的技能
30
// CancelAbilitiesWithTag： 持有 State.Casting 时 → 新技能激活时取消"正在施法"的技能
31
// ActivationRequiredTags：  必须持有某些标签才能激活（如"装备了法杖"）
32
// ActivationBlockedTags：   持有某些标签时不能激活（如"被沉默"）

1
// ===== NetExecutionPolicy 详解 =====
2
//
3
// LocalPredicted（本地预测 —— 首选）：
4
//   客户端立即执行技能（预测），同时发 Server RPC
5
//   服务器也执行技能（权威）
6
//   如果服务器执行结果与客户端预测不同 → 服务器校正
7
//   适用：大多数伤害技能、移动技能——需要即时反馈
8
//
9
// LocalOnly（纯本地）：
10
//   只在客户端执行，不经过服务器
11
//   适用：纯表现技能（如本地特效）——不能修改权威数据
12
//
13
// ServerInitiated（服务器发起）：
14
//   只有服务器能激活这个技能
15
//   适用：AI 技能、环境伤害——客户端不应该主动触发
16
//
17
// ServerOnly（仅服务器）：
18
//   只在服务器上执行，不通知客户端
19
//   适用：纯服务器逻辑——如全局状态检查
20

21
// ===== InstancingPolicy 详解 =====
22
//
23
// InstancedPerActor（每个 Actor 一个实例 —— 推荐）：
24
//   每个 ASC 对此技能只有一个实例
25
//   技能可以保存状态（例如"持续施法"中的进度）
26
//
27
// InstancedPerExecution（每次执行一个新实例）：
28
//   每次激活创建新的技能实例
29
//   适用：无状态的瞬间技能（如瞬发伤害）
30
//
31
// NonInstanced（无实例 —— 不推荐）：
32
//   不创建实例——所有调用共享同一个 CDO
33
//   不能保存任何状态——极易出错

1
// ===== GAS 核心设计：Cost 和 Cooldown 就是普通的 GE =====
2
//
3
// 这体现了 GAS 的设计哲学——"一切皆 GE"
4
// 法力消耗 = 一个 Instant GE —— Attribute: Mana, Op: Add, Magnitude: -50
5
// 冷却时间 = 一个 Duration GE —— 持续 N 秒，添加冷却 Tag 阻止技能激活
6
//
7
// 你不需要为每个技能写"消耗法力 + 检查冷却"代码——
8
// 只需在 Ability 蓝图或 C++ 中配置 Cost GE 和 Cooldown GE 的 Class
9

10
UCLASS()
11
class UFireballAbility : public UGameplayAbility
12
{
13
    GENERATED_BODY()
14

15
public:
16
    UFireballAbility()
17
    {
18
        // ---- Cost（消耗）----
19
        // CostGameplayEffectClass：激活时提交的 GE
20
        // 通常是一个 Instant GE：
21
        //   Modifier: Mana, Op: Add, Magnitude: -50.0
22
        //   含义：消耗 50 点法力
23

24
        // ---- Cooldown（冷却）----
25
        // CooldownGameplayEffectClass：激活时应用的 GE
26
        // 通常是一个 Duration GE：
27
        //   Duration: 5.0 秒
28
        //   GrantedTags: State.Cooldown.Fireball
29
        //   含义：5 秒内无法再次激活（因为 State.Cooldown.Fireball 被标记为
30
        //         ActivationBlockedTags）
31
    }
32

33
    // 通过 FGameplayAbilitySpec 传入动态 Cost 和 Cooldown
34
    // 例如：技能升级后，Cost 降低，Cooldown 缩短
35
};

1
// ===== 策略 1：单独 Cooldown GE（最常用） =====
2
// 每个技能一个独立的 Cooldown GE
3
// 冷却 Tag = State.Cooldown.{AbilityName}
4
// 优点：每个技能的冷却独立——互不影响
5
// 适用：大多数游戏
6

7
// ===== 策略 2：共用冷却组（Cooldown Group） =====
8
// 多个技能共享一个 Cooldown GE
9
// 冷却 Tag = State.Cooldown.Fire（所有火系技能共享）
10
// 优点：火球术进入冷却 → 火焰冲击也进入冷却
11
// 适用：需要 GCD（全局冷却）或技能组冷却的游戏
12

13
// ===== 策略 3：动态冷却时长 =====
14
// 通过 SetByCaller 在运行时决定冷却时长
15
void ApplyDynamicCooldown(float CooldownSeconds)
16
{
17
    FGameplayEffectSpecHandle Spec = ASC->MakeOutgoingSpec(
18
        CooldownGEClass, 1.0f, ASC->MakeEffectContext());
19

20
    Spec.Data->SetSetByCallerMagnitude(
21
        FGameplayTag::RequestGameplayTag(TEXT("Data.CooldownDuration")),
22
        CooldownSeconds);
23

24
    ASC->ApplyGameplayEffectSpecToSelf(*Spec.Data.Get());
25
}

1
// ===== GameplayCue：技能的 VFX/SFX 表现层 =====
2
//
3
// 核心理念：技能逻辑（Ability）不应该知道"火球长什么样"
4
//          — 表现层（Cue）不应该知道"伤害是多少"
5
// 通信方式：技能通过 ASC 发送 GameplayCue 事件，
6
//           GameplayCueManager 将事件路由到对应的 GameplayCue 处理器
7

8
// ---------- 触发 GameplayCue ----------
9
void UFireballAbility::ActivateAbility(...)
10
{
11
    // ... 技能逻辑 ...
12

13
    // 发送 GameplayCue 事件——告知表现层"播放火球施法特效"
14
    FGameplayCueParameters CueParams;
15
    CueParams.Location = GetAvatarActorFromActorInfo()->GetActorLocation();
16
    CueParams.Normal = GetAvatarActorFromActorInfo()->GetActorForwardVector();
17
    CueParams.EffectCauser = Cast<AActor>(GetAvatarActorFromActorInfo());
18

19
    // ⚠️ 不要直接调 K2_ExecuteGameplayCueWithParams —— 那是 UHT 为蓝图生成的胶水层
20
    //    C++ 原生代码应通过 ASC 的标准接口触发 GameplayCue
21
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponentFromActorInfo())
22
    {
23
        ASC->ExecuteGameplayCueLocal(
24
            FGameplayTag::RequestGameplayTag(
25
                TEXT("GameplayCue.Ability.Fire.Fireball.Cast")),
26
            CueParams);
27
    }
28
}
29

30
// ---------- GameplayCue 处理器 ----------
31
UCLASS()
32
class UGameplayCue_FireballCast : public UGameplayCueNotify_Static
33
{
34
    GENERATED_BODY()
35

36
public:
37
    // 立即执行（一次性效果——如施法闪光）
38
    virtual bool OnExecute_Implementation(
39
        AActor* MyTarget,
40
        const FGameplayCueParameters& Parameters) const override
41
    {
42
        // 在 MyTarget 的位置播放施法特效
43
        UGameplayStatics::SpawnEmitterAtLocation(
44
            MyTarget->GetWorld(),
45
            CastVFX,
46
            Parameters.Location,
47
            Parameters.Normal.Rotation());
48

49
        UGameplayStatics::PlaySoundAtLocation(
50
            MyTarget->GetWorld(),
51
            CastSFX,
52
            Parameters.Location);
53

54
        return true;  // 已处理
55
    }
56

57
    UPROPERTY(EditDefaultsOnly)
58
    TObjectPtr<UParticleSystem> CastVFX;
59

60
    UPROPERTY(EditDefaultsOnly)
61
    TObjectPtr<USoundCue> CastSFX;
62
};
63

64
// ---------- 持续性 GameplayCue（如持续燃烧效果） ----------
65
UCLASS()
66
class UGameplayCue_Burning : public UGameplayCueNotify_BurstLatent
67
{
68
    GENERATED_BODY()
69

70
public:
71
    // Burst：立即播放一次（着火瞬间的火焰爆发）
72
    virtual void OnBurst_Implementation(
73
        AActor* MyTarget,
74
        const FGameplayCueParameters& Parameters,
75
        const TArray<TObjectPtr<UParticleSystemComponent>>& ParticleComponents,
76
        const TArray<TObjectPtr<UAudioComponent>>& AudioComponents) const override
77
    {
78
        // 着火爆发特效
79
    }
80

81
    // Latent：持续播放（只要 GE 还在就一直在）
82
    virtual bool OnActive_Implementation(
83
        AActor* MyTarget,
84
        const FGameplayCueParameters& Parameters) const override
85
    {
86
        // 在目标上附加火焰粒子 → 随 GE 持续时间存在
87
        return true;
88
    }
89

90
    // 结束时的清理
91
    virtual bool OnRemove_Implementation(
92
        AActor* MyTarget,
93
        const FGameplayCueParameters& Parameters) const override
94
    {
95
        // 移除火焰粒子
96
        return true;
97
    }
98
};
99

100
// ===== GameplayCue 的触发方式 =====
101
//
102
// 方式 1：通过 GameplayEffect 的 GameplayCue 配置
103
//   在 GE 蓝图中添加 GameplayCue 标签
104
//   GE 应用时自动触发 OnExecute / OnActive
105
//   GE 移除时自动触发 OnRemove
106
//   → 最常用——"中毒效果 → 中毒表现"完全通过 Tag 自动匹配
107
//
108
// 方式 2：在 Ability 中手动触发
109
//   ASC->ExecuteGameplayCueLocal(Tag, Params) / ASC->AddGameplayCue(Tag, Params)
110
//   → 灵活——在技能流程的任意时刻触发特效（注意 C++ 中用原生接口，不要调 K2_ 胶水层）
111
//
112
// 方式 3：通过 ASC 手动触发
113
//   ASC->ExecuteGameplayCueLocal(Tag, Params)

1
// ===== GAS 的本地预测 =====
2
//
3
// 当一个技能设置了 NetExecutionPolicy = LocalPredicted：
4
//
5
// ① 客户端预测执行：
6
//    - 客户端立即激活技能（调用 ActivateAbility）
7
//    - 客户端预测性应用 Cost GE 和 Cooldown GE
8
//    - 玩家看到即时反馈——无延迟感
9
//
10
// ② 服务器权威执行：
11
//    - 服务器收到 RPC → 激活同样的技能
12
//    - 服务器执行相同的 Cost/Cooldown/Effect
13
//    - 如果服务器结果与预测不同 → 发送校正
14
//
15
// ③ 预测键（Prediction Key）：
16
//    - 每次预测生成一个唯一的 Prediction Key
17
//    - 服务器执行时回传同样的 Key
18
//    - 客户端用 Key 匹配"这是哪次预测的结果"
19
//    - 如果服务器拒绝 → 客户端回滚该 Key 对应的所有状态变化
20

21
// ===== 预测窗口（Prediction Window） =====
22
// 客户端在发送 RPC 后等待服务器确认的时间窗口
23
// 窗口内：继续预测（可以连续发送多次预测——如连击）
24
// 窗口外：停止预测（防止服务器拒绝后回滚代价太大）
25
// 默认窗口约等于 RTT × 2

1
// ===== Prediction Key 的生命周期 =====
2
//
3
// ① 生成：客户端调用 TryActivateAbility → ASC 生成 Prediction Key
4
// ② 附加：Key 被附加到所有由此技能产生的 GE Spec 上
5
// ③ 发送：Key 随 Server RPC 发送给服务器
6
// ④ 执行：服务器用同样的 Key 执行技能
7
//         服务器上的 GE 也携带同样的 Key
8
// ⑤ 确认：服务器执行完成后，发送确认给客户端
9
//          确认携带 Key + 服务器执行结果
10
// ⑥ 匹配：客户端用 Key 找到对应的"预测记录"
11
//         如果服务器结果和预测一致 → 预测成功，清除记录
12
//         如果服务器结果和预测不一致 → 回滚该 Key 对应的所有变化
13
//
14
// ===== 什么情况下预测会失败？ =====
15
// 1. 服务器端的条件检查失败（如法力不够——客户端以为够但它算错了）
16
// 2. 服务器端的碰撞检测不同（如技能被墙壁阻挡——客户端没有准确的碰撞体）
17
// 3. 服务器端的属性值不同（如客户端以为攻击力 100，实际因 Debuff 只有 80）
18

19
// ===== 预测失败后的回滚行为 =====
20
// - Cost GE：回滚——法力恢复
21
// - Cooldown GE：回滚——冷却取消
22
// - Modifier GE：回滚——伤害取消
23
// - GameplayCue：客户端立即执行 / 回滚由 Tag 决定
24
//
25
// "可预测的 GameplayCue"用标签 GameplayCue.NotifyPredictionKey
26
// 预测失败时这些 Cue 会被移除

1
// ===== 完整 GAS 架构初始化流程 =====
2
//
3
// 步骤 1：PlayerState 上创建 ASC + AttributeSet
4
// 步骤 2：服务器授予初始技能
5
// 步骤 3：初始化属性默认值
6
// 步骤 4：绑定输入到技能
7
// 步骤 5：绑定 UI 到属性变化的委托
8

9
// ---------- 初始化脚本 ----------
10
UCLASS()
11
class ARPGGameMode : public AGameModeBase
12
{
13
    GENERATED_BODY()
14

15
public:
16
    virtual void OnPostLogin(AController* NewPlayer) override
17
    {
18
        Super::OnPostLogin(NewPlayer);
19

20
        if (AMyPlayerState* PS = NewPlayer->GetPlayerState<AMyPlayerState>())
21
        {
22
            // 授予默认技能
23
            if (UAbilitySystemComponent* ASC = PS->AbilitySystem)
24
            {
25
                // 给所有玩家授予基础攻击技能
26
                ASC->GiveAbility(FGameplayAbilitySpec(
27
                    UBasicAttackAbility::StaticClass(), 1, INDEX_NONE, PS));
28

29
                // 给所有玩家授予火球技能
30
                ASC->GiveAbility(FGameplayAbilitySpec(
31
                    UFireballAbility::StaticClass(), 1, INDEX_NONE, PS));
32

33
                // 初始化属性
34
                if (UMyAttributeSet* AttrSet = ASC->GetAttributeSet<UMyAttributeSet>())
35
                {
36
                    // 应用初始化 GE——设置属性的基础值
37
                    FGameplayEffectContextHandle Context = ASC->MakeEffectContext();
38
                    FGameplayEffectSpecHandle InitSpec = ASC->MakeOutgoingSpec(
39
                        DefaultAttributeGEClass, 1.0f, Context);
40
                    ASC->ApplyGameplayEffectSpecToSelf(*InitSpec.Data.Get());
41
                }
42
            }
43
        }
44
    }
45

46
    UPROPERTY(EditDefaultsOnly)
47
    TSubclassOf<UGameplayEffect> DefaultAttributeGEClass;
48
};
49

50
// ---------- 绑定输入到技能 ----------
51
void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
52
{
53
    Super::SetupPlayerInputComponent(PlayerInputComponent);
54

55
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
56
    {
57
        // Enhanced Input 绑定到 GAS 技能
58
        if (UEnhancedInputComponent* EnhancedInput =
59
            Cast<UEnhancedInputComponent>(PlayerInputComponent))
60
        {
61
            // 左键 → 基础攻击
62
            EnhancedInput->BindAction(AttackAction, ETriggerEvent::Started,
63
                this, &AMyCharacter::OnAttackPressed);
64

65
            // Q 键 → 火球
66
            EnhancedInput->BindAction(FireballAction, ETriggerEvent::Started,
67
                this, &AMyCharacter::OnFireballPressed);
68
        }
69
    }
70
}
71

72
void AMyCharacter::OnAttackPressed()
73
{
74
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
75
    {
76
        ASC->TryActivateAbilityByTag(
77
            FGameplayTagContainer(
78
                FGameplayTag::RequestGameplayTag(
79
                    TEXT("Ability.Skill.Melee.BasicAttack"))));
80
    }
81
}
82

83
void AMyCharacter::OnFireballPressed()
84
{
85
    if (UAbilitySystemComponent* ASC = GetAbilitySystemComponent())
86
    {
87
        ASC->TryActivateAbilityByTag(
88
            FGameplayTagContainer(
89
                FGameplayTag::RequestGameplayTag(
90
                    TEXT("Ability.Skill.Fire.Fireball"))));
91
    }
92
}
93

94
// ---------- UI 绑定属性变化 ----------
95
void UPlayerHUD::NativeConstruct()
96
{
97
    Super::NativeConstruct();
98

99
    if (AMyPlayerState* PS = GetOwningPlayerState<AMyPlayerState>())
100
    {
101
        if (UMyAttributeSet* AttrSet = PS->AbilitySystem->GetAttributeSet<UMyAttributeSet>())
102
        {
103
            // 绑定委托
104
            AttrSet->OnHealthChangedDelegate.AddUObject(
105
                this, &UPlayerHUD::OnHealthChanged);
106
            AttrSet->OnManaChangedDelegate.AddUObject(
107
                this, &UPlayerHUD::OnManaChanged);
108

109
            // ASC 还提供了属性变化的通用委托
110
            PS->AbilitySystem->GetGameplayAttributeValueChangeDelegate(
111
                UMyAttributeSet::GetHealthAttribute())
112
                .AddUObject(this, &UPlayerHUD::OnHealthAttributeChanged);
113
        }
114
    }
115
}