增强输入与GAS

字数统计: 1.8k字   |   阅读时长≈ 7分

前言

前文介绍了GAS与增强输入的基本使用，本文将介绍如何将输入与GA进行绑定来完成解耦和扩展。

前置准备

绑定方法

技能与输入的绑定方法，查看BindAction的函数声明，可以看到在后面有一次额外的参数包，在绑定时可以将Tag做为参数在绑定时传入：

1
BindAction(IA, TriggerEvent, UserObject, BindFunc, Tag);

在触发影响的IA时就可以获取到对应的Tag:

1
2
3
4
void BindFunc(FGameplayTag Tag)
{
    //...
}

在初始化时可以通过将Tag和GA进行绑定，在触发输入时通过Tag来查找对应的GA。

技能的初始化

初始化时需要将GA和Tag进行绑定，所以考虑将对应关系放入一张数据表中，在玩家进行初始化时读入这张表完成绑定。

其基本的数据结构应包含一个GA和一个TagContainer，一个技能可能会有几种触发方式，所以提供Container来存储多个Tag。

1
2
3
4
5
6
7
8
9
10
11
12
USTRUCT(BlueprintType)
struct FAbilityAction
{
    GENERATED_BODY()

    // 使用Ability的CDO进行初始化
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSubclassOf<FGameplayAbility> Ability;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    FGameplayTagContainer Tags;
};

同时提供基本的表结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
UCLASS()
class PROJECTE_API UAbilityAsset : public UDataAsset
{
    GENERATED_BODY()

public:
    UAbilityAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TArray<FAbilityAction> Abilities;
};

输入的初始化

同样使用数据表来存储输入关系，基本应该包含一个Tag和一个IA，其中Tag用于查找对应的GA。

所以输入的基本数据结构为：

1
2
3
4
5
6
7
8
9
10
11
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;
};

输入的表结构，其中提供查找方法和一个映射上下文：

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
UCLASS()
class PROJECTE_API UInputAsset : public UDataAsset
{
    GENERATED_BODY()
public:
    UInputAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    const UInputAction* FindInputActionByTag(FGameplayTag Tag) const
    {
        UInputAction* InputAction = nullptr;
        if(Tag.IsValid())
        {
            for(const FInputAction& IA: Actions)
            {
                if(IA.Action.Get() && IA.Tag == Tag)
                {
                    InputAction = IA.Action;
                    break;
                }
            }
        }

        return InputAction;
    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TArray<FInputAction> Actions;

    UPROPERTY(EdtiAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputMappingContext> InputMappingContext;
};

实现输入与GA的绑定

准备好两张表后就可以准备完成初始化与绑定了！

GA的初始化

在GameplayAbility的实例GameplayAbilitySpec中包含一个DynamicAbilityTag的TagContainer，使用其来查找对应的GA。

绑定函数：

1
2
3
4
5
6
7
8
9
10
void InitializeAbility()
{
    // 假设已经读取到了UAbilityAsset--->AbilityAsset
    for(FAbilityAction& GameplayAbilityAction: AbilityAsset->Abilities)
    {
        FGameplayAbilitySpec GameplayAbilitySpec = FGameplayAbilitySpec(GameplayAbilityAction.Ability);
        GameplayAbilitySpec.DynamicAbilityTags = GameplayAbilityAction.Tags;
        GiveAbility(GameplayAbilitySpec);
    }
}

输入的初始化

在绑定中，将输入分为两种，一种为GA输入；另一种为本地输入，包括玩家的基本移动等，所以在绑定时要对其进行区分，所以输入表中需要对结构进行改进，增加一个用于区分是否为技能的bool值；此外技能同样有长按与单次触发的类型，所以再增加一个bool值进行区分。

改进后的结构应为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bAbilityInput;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bTriggerEvent;
};

为了确保绑定可以通用，考虑将其作为增强输入组件的模板成员函数。对于本地输入的初始化只要从输入表中拿到对应的IA完成绑定即可；对于技能输入则需要增加一个扩展参数包。

所以玩家的本地输入绑定函数应为：

1
2
3
4
5
6
7
8
9
template<class UserClass, typename FuncType>
void BindNativeAction(const UInputAsset* InputAsset, const FGameplayTag& InputTag, ETriggerEvent TriggerEvent, UserClass* UserObject, FuncType InputFunc)
{
    check(InputAsset);
    if(const UInputAction* IA = InputAsset->FindInputActionByTag(InputTag))
    {
        BindAction(IA, TriggerEvent, UserObject, InputFunc);
    }
}

绑定技能的输入为：

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
template<class UserClass, typename Press, typename Release>
void BindAbilityAction(const UInputAsset* InputAsset, UserClass* UserObject, Press PressFunc, Relase ReleaseFunc, TArray<uint32>& BindHandles)
{
    check(InputAsset);
    for(const FInputAction& IA: InputAsset->Actions)
    {
        if(IA.Action.Get() && IA.bAbilityInput)
        {
            if(PressFunc)
            {
                if(IA.bTriggerEvent)
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Triggered, PressFunc, PressFunc, IA.Tag).GetHandle());
                }
                else
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Started, PressFunc, ReleaseFunc, IA.Tag).GetHandle());
                }
            }
            
            if(ReleaseFunc)
            {
                BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Completed, ReleaseFUnc, IA.Tag).GetHandle());
            }
        }
    }
}

触发IA与GA

对于玩家的本地输入，可以直接调用BindNativeAction进行绑定，有多少绑定多少，对于GA的绑定则只需要一次。

当IA触发以后则需要根据对应的Tag去寻找对应的GA，提供两个函数用来处理技能输入的按下与抬起：

在GAS中的处理

首先在ASC中提供两个函数用来处理技能输入的按下与抬起：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void ProcessAbilityPressInput(FGameplayTag InputTag)
{
    if(FGameplayAbilitySpec& AbilitySpec:GetActivatableAbilities())
    {
        if(AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpec.Ability->ActivateAbility(AbilitySpec);
        }
    }
}

void ProcessAbilityReleaseInput(FGameplayTag InputTag)
{
    for (FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
    {
        if (AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpecInputRelease(AbilitySpec);
        }
    }
}

在输入组件中的处理

随后可以在玩家的输入组件中调用这两个函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void OnAbilityPressd(FGameplayTag InputTag)
{
    // 认为已经提供了相应的获取ASC的方法
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityPressInput(InputTag);
    }
}

void OnAbilityReleased(FGameplayTag InputTag)
{
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityReleaseInput(InputTag);
    }
}

最终绑定

最终在增强输入中提供初始化函数SetPlayerInput:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void SetPlayerInput()
{
    ACharacter* OwnerCharacter = Cast<ACharacter>(GetOwner());
    if(!IsValid(OwnerCharacter))
    {
        return;
    }

    if (APlayerController* LocalPC = Cast<APlayerController>(OwnerCharacter->Controller))
    {
        if (UEnhancedInputLocalPlayerSubsystem* LPSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(LocalPC->GetLocalPlayer()))
        {
            if (InputAsset->InputMappingContext.Get())
            {
                LPSubsystem->ClearAllMappings();
                LPSubsystem->AddMappingContext(InputAsset->InputMappingContext,0);
            }
        }

        //BindNativeAction完成本地输入绑定

        BindAbilityAction(InputAsset, this, &ThisClass::OnAbilityPressd, &ThisClass::OnAbilityReleased, AbilityInputHandles);
    }
}

最终完成了IA与GA的绑定

管理GameplayTag

参考lyra工程使用namespace作为Tag管理，同样我们也提供一个名为GameplayTags的namespace：

1
2
3
4
5
6
7
8
namespace GameplayTags
{
    // 在头文件中这样声明
	PROJECTET_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(CharacterInputTag_Move);

    // 在cpp文件中这样定义，可以编辑器中外部使用
	UE_DEFINE_GAMEPLAY_TAG_COMMENT(CharacterInputTag_Move, "CharacterInput.Move", "Character Movement Input Tag");
}

使用ini管理资产文件

以上是直接将资产挂载在玩家身上，并不方便管理，所以可以考虑使用全局配置项来进行管理。

用UDeveloperSettings作为父类创建名为ProjectAssetSettings的子类，注意需要在uproject文件中新加一条”DeveloperSettings”的配置。

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
UCLASS(config = Game, defaultconfig, meta = (DisplayName = "Game Asset Config"))
class PROJECTET_API UProjectAssetSettings : public UDeveloperSettings
{
	GENERATED_BODY()
public:
	virtual FName GetCategoryName() const
    {
        return FName{ TEXT("Game Asset Config") };
    }

	virtual FName GetContainerName() const
    {
        return FName{ TEXT("Project") };
    }

    // 用于获取读取配置的方法，一般在游戏运行时不修改游戏配置，所以返回const
	UFUNCTION(BlueprintPure)
	static const UProjectAssetSettings* GetProjectAssetSettings()
    {
        const UProjectAssetSettings* Settings = GetDefault<UProjectAssetSettings>();
        return Settings;
    }

    //如果想要修改的话可以使用GetMutableDefault<UProjectAssetSettings>()来返回一个可修改的配置文件

    // 将输入资产与技能资产迁至这里，这里一般不会使用硬引用，ini文件加载时机很早，使用硬引用会导致读入的类为空
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TSoftObjectPtr<UInputAsset> InputAsset;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSoftObjectPtr<UAbilitAsset> AbilityAsset;
};

总结

通过以上步骤，我们将输入与技能进行了绑定，并且通过namespace管理Tag和ini文件管理了输入与技能的资产。

扫一扫，分享到微信

tag:

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

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

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


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

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