Combat Abilities System — Расширение Gameplay Ability System в Unreal Engine, Часть 2

DataAbilitySystemComponent.h  #pragma once  #include "CoreMinimal.h" #include "AbilitySystemComponent.h" #include "DataAbilitySystemComponent.generated.h"  class UCombatAbilityBase;  USTRUCT() struct FCombatAttributeData { GENERATED_BODY()  UPROPERTY(EditAnywhere) TSubclassOf<UAttributeSet> AttributeSetType{nullptr};  UPROPERTY(EditAnywhere) TObjectPtr<UDataTable> DataTable{nullptr};  };  UCLASS(meta=(BlueprintSpawnableComponent)) class COMBATABILITIESSYSTEMRUNTIME_API UDataAbilitySystemComponent : public UAbilitySystemComponent { GENERATED_BODY()  public:  virtual void InitAbilityActorInfo(AActor* InOwnerActor, AActor* InAvatarActor) override;  virtual void BeginDestroy() override;  UFUNCTION(BlueprintCallable, Category="CombatAbilities") FGameplayAbilitySpecHandle GrantAbilityOfType(TSubclassOf<UGameplayAbility> InAbilityType, const bool bRemoveAfterActivation);  void SetupAbilities(); void SetupAttributes(); void RemoveAllAbilitiesAndAttributes();  bool IsUsingAbilityByClass(const TSubclassOf<UGameplayAbility> InAbilityClass) const;  TArray<UGameplayAbility*> GetActiveAbilitiesByClass(TSubclassOf<UGameplayAbility> InAbilitySearch) const;  private: void GrantAbilitiesAndAttributes();  UFUNCTION() void OnPawnControllerChanged(APawn* InPawn, AController* InNewController);  private: UPROPERTY(EditDefaultsOnly, Category="Abilities") TArray<TSubclassOf<UCombatAbilityBase>> DefaultAbilities;  UPROPERTY(EditDefaultsOnly, Category="Abilities") TArray<FCombatAttributeData> DefaultAttributes;  TArray<FGameplayAbilitySpecHandle> DefaultAbilityHandle;  UPROPERTY(Transient) TArray<UAttributeSet*> AddedAttributes;  };

DataAbilitySystemComponent.cpp  #include "Components/DataAbilitySystemComponent.h"  #include "CombatAbilitiesSystemRuntimeModule.h" #include "Abilities/CombatAbilityBase.h"  #include UE_INLINE_GENERATED_CPP_BY_NAME(DataAbilitySystemComponent)  void UDataAbilitySystemComponent::InitAbilityActorInfo(AActor* InOwnerActor, AActor* InAvatarActor) { Super::InitAbilityActorInfo(InOwnerActor, InAvatarActor);  if(AbilityActorInfo) { if(UGameInstance* GameInstance{InOwnerActor->GetGameInstance()}; GameInstance) { GameInstance->GetOnPawnControllerChanged().AddDynamic(this, &UDataAbilitySystemComponent::OnPawnControllerChanged); } }  GrantAbilitiesAndAttributes(); }  void UDataAbilitySystemComponent::BeginDestroy() { if(AbilityActorInfo && AbilityActorInfo->OwnerActor.IsValid()) { if(UGameInstance* GameInstance{AbilityActorInfo->OwnerActor->GetGameInstance()}; GameInstance) { GameInstance->GetOnPawnControllerChanged().RemoveAll(this); } } Super::BeginDestroy(); }  FGameplayAbilitySpecHandle UDataAbilitySystemComponent::GrantAbilityOfType(TSubclassOf<UGameplayAbility> InAbilityType, const bool bRemoveAfterActivation) { FGameplayAbilitySpecHandle AbilitySpecHandle; if(InAbilityType) { FGameplayAbilitySpec AbilitySpec(InAbilityType); AbilitySpec.RemoveAfterActivation = bRemoveAfterActivation;  AbilitySpecHandle = GiveAbility(AbilitySpec); }  return AbilitySpecHandle; }  void UDataAbilitySystemComponent::GrantAbilitiesAndAttributes() { RemoveAllAbilitiesAndAttributes();  SetupAbilities();  SetupAttributes(); }  void UDataAbilitySystemComponent::OnPawnControllerChanged(APawn* InPawn, AController* InNewController) { if(AbilityActorInfo && AbilityActorInfo->OwnerActor == InPawn && AbilityActorInfo->PlayerController != InNewController) { AbilityActorInfo->InitFromActor(AbilityActorInfo->OwnerActor.Get(), AbilityActorInfo->AvatarActor.Get(), this); } }  void UDataAbilitySystemComponent::RemoveAllAbilitiesAndAttributes() { for(UAttributeSet* AttributeSet : AddedAttributes) { RemoveSpawnedAttribute(AttributeSet); } for(FGameplayAbilitySpecHandle AbilitySpecHandle : DefaultAbilityHandle) { SetRemoveAbilityOnEnd(AbilitySpecHandle); } AddedAttributes.Empty(DefaultAttributes.Num()); DefaultAbilityHandle.Empty(DefaultAbilities.Num()); }  bool UDataAbilitySystemComponent::IsUsingAbilityByClass(const TSubclassOf<UGameplayAbility> InAbilityClass) const { if(!InAbilityClass) { UE_LOG(LogCombatAbilitySystem, Error, TEXT("IsUsingAbilityByClass() provided AbilityClass is null")) return false; }  return GetActiveAbilitiesByClass(InAbilityClass).Num() > 0; }  TArray<UGameplayAbility*> UDataAbilitySystemComponent::GetActiveAbilitiesByClass(TSubclassOf<UGameplayAbility> InAbilitySearch) const { TArray<FGameplayAbilitySpec> Specs = GetActivatableAbilities(); TArray<FGameplayAbilitySpec*> MatchingGameplayAbilities; TArray<UGameplayAbility*> ActiveAbilities;  for(const FGameplayAbilitySpec& Spec : Specs) { if(Spec.Ability && Spec.Ability.GetClass()->IsChildOf(InAbilitySearch)) { MatchingGameplayAbilities.Add(const_cast<FGameplayAbilitySpec*>(&Spec)); } }  for(const FGameplayAbilitySpec* Spec : MatchingGameplayAbilities) { TArray<UGameplayAbility*> AbilityInstances = Spec->GetAbilityInstances(); for(UGameplayAbility* ActiveAbility : AbilityInstances) { if(ActiveAbility->IsActive()) { ActiveAbilities.Add(ActiveAbility); } } }  return ActiveAbilities; }   void UDataAbilitySystemComponent::SetupAbilities() { DefaultAbilityHandle.Reserve(DefaultAbilities.Num()); for(const TSubclassOf<UCombatAbilityBase>& Ability : DefaultAbilities) { if(*Ability) { DefaultAbilityHandle.Add(GiveAbility(FGameplayAbilitySpec(Ability))); } } }  void UDataAbilitySystemComponent::SetupAttributes() { for(const FCombatAttributeData& AttributeData : DefaultAttributes) { if(AttributeData.AttributeSetType) { UAttributeSet* NewAttributeSet {NewObject<UAttributeSet>(this, AttributeData.AttributeSetType)}; if(AttributeData.DataTable) { NewAttributeSet->InitFromMetaDataTable(AttributeData.DataTable); } AddedAttributes.Add(NewAttributeSet); AddAttributeSetSubobject(NewAttributeSet); } } }

CombatSystemComponent.h  #pragma once  #include "CoreMinimal.h" #include "DataAbilitySystemComponent.h" #include "CombatComponentInterface.h" #include "CombatSystemComponent.generated.h"   UCLASS(meta=(BlueprintSpawnableComponent)) class COMBATABILITIESSYSTEMRUNTIME_API UCombatSystemComponent : public UDataAbilitySystemComponent, public ICombatComponentInterface { GENERATED_BODY()  public:  explicit UCombatSystemComponent(const FObjectInitializer& InInitializer = FObjectInitializer::Get());  virtual void AbilityLocalInputPressed(int32 InputID) override;  // Begin ICombatComponentInterface virtual TArray<FCombatAnimationInfo> GetMontageAction_Implementation(const FGameplayTag& InTagName) const override;  virtual FCombatAnimationInfo GetComboMontageAction_Implementation(const FGameplayTag& InTagName) override;  virtual UGameplayAbility* GetCurrentActiveComboAbility_Implementation() const override;  virtual void IncrementComboIndex_Implementation() override;  virtual void RequestTriggerCombo_Implementation() override;  virtual void ActivateNextCombo_Implementation() override;  virtual void ResetCombo_Implementation() override;  virtual bool IsOpenComboWindow_Implementation() const override;  virtual bool IsActiveNextCombo_Implementation() const override;  virtual bool IsShouldTriggerCombo_Implementation() const override;  virtual bool IsRequestTriggerCombo_Implementation() const override;  virtual void OpenComboWindow_Implementation() override;  virtual void CloseComboWindow_Implementation() override; // End ICombatComponentInterface  private: void ActivateComboAbility(const TSubclassOf<UGameplayAbility> InAbilityClass);  private: UPROPERTY(EditDefaultsOnly, Category="Abilities|Anims") TObjectPtr<UDataTable> CombatActionTable;  UPROPERTY(EditDefaultsOnly, Category="Abilities|Anims") FCombatAnimationInfo DodgeMontage;  UPROPERTY() int32 ComboIndex;  UPROPERTY() bool bWindowComboAttack; UPROPERTY() bool bRequestTriggerCombo; UPROPERTY() bool bNextComboAbilityActivated; UPROPERTY() bool bShouldTriggerCombo;  };

CombatSystemComponent.cpp  #include "Components/CombatSystemComponent.h"  #include "CombatAbilitiesSystemRuntimeModule.h" #include "Abilities/CombatAttackAbility.h" #include "Data/CombatActionData.h"  #include UE_INLINE_GENERATED_CPP_BY_NAME(CombatSystemComponent)  UCombatSystemComponent::UCombatSystemComponent(const FObjectInitializer& InInitializer) : Super(InInitializer), ComboIndex(0), bWindowComboAttack(false), bRequestTriggerCombo(false), bNextComboAbilityActivated(false), bShouldTriggerCombo(false) { }  void UCombatSystemComponent::AbilityLocalInputPressed(const int32 InputID) { if(IsGenericConfirmInputBound(InputID)) { LocalInputConfirm(); return; } if(IsGenericCancelInputBound(InputID)) { LocalInputCancel(); return; }  for(FGameplayAbilitySpec Spec : ActivatableAbilities.Items) { if(Spec.InputID == InputID && Spec.Ability) { Spec.InputPressed = true;  if(Spec.Ability->IsA(UCombatAttackAbility::StaticClass())) { ActivateComboAbility(Spec.Ability.GetClass()); } else { if(Spec.IsActive()) { AbilitySpecInputPressed(Spec); } else { TryActivateAbility(Spec.Handle); } } } } }  TArray<FCombatAnimationInfo> UCombatSystemComponent::GetMontageAction_Implementation(const FGameplayTag& InTagName) const { if(!CombatActionTable) { UE_LOG(LogCombatAbilitySystem, Warning, TEXT("CombatActionTable is nullptr")); return {}; } if(!InTagName.IsValid()) { UE_LOG(LogCombatAbilitySystem, Warning, TEXT("Parramenter InTagName is no valid")); return {}; }  FCombatActionData ActionData = *CombatActionTable->FindRow<FCombatActionData>(InTagName.GetTagName(), "CombatContext");  return ActionData.Animations; }  FCombatAnimationInfo UCombatSystemComponent::GetComboMontageAction_Implementation(const FGameplayTag& InTagName) { TArray<FCombatAnimationInfo> Animations = GetMontageAction_Implementation(InTagName);  if(ComboIndex >= Animations.Num()) { ComboIndex = 0; }  return Animations[ComboIndex]; }  UGameplayAbility* UCombatSystemComponent::GetCurrentActiveComboAbility_Implementation() const { TArray<UGameplayAbility*> Abilities = GetActiveAbilitiesByClass(UComboAbility::StaticClass());  return Abilities.IsValidIndex(0) ? Abilities[0] : nullptr; }  void UCombatSystemComponent::IncrementComboIndex_Implementation() { if(bWindowComboAttack) { ComboIndex += 1; }  }  void UCombatSystemComponent::RequestTriggerCombo_Implementation() { bRequestTriggerCombo = true; }  void UCombatSystemComponent::ActivateNextCombo_Implementation() { bNextComboAbilityActivated = true;  }  bool UCombatSystemComponent::IsActiveNextCombo_Implementation() const { return bNextComboAbilityActivated; }  void UCombatSystemComponent::ResetCombo_Implementation() { ComboIndex = 0; }  bool UCombatSystemComponent::IsShouldTriggerCombo_Implementation() const { return bShouldTriggerCombo; }  bool UCombatSystemComponent::IsRequestTriggerCombo_Implementation() const { return bRequestTriggerCombo; }  void UCombatSystemComponent::OpenComboWindow_Implementation() { bWindowComboAttack = true; }  bool UCombatSystemComponent::IsOpenComboWindow_Implementation() const { return bWindowComboAttack; }  void UCombatSystemComponent::CloseComboWindow_Implementation() { bWindowComboAttack = false; bRequestTriggerCombo = false; bShouldTriggerCombo = false; bNextComboAbilityActivated = false; }  void UCombatSystemComponent::ActivateComboAbility(const TSubclassOf<UGameplayAbility> InAbilityClass) { bShouldTriggerCombo = false;  if(IsUsingAbilityByClass(InAbilityClass)) { bShouldTriggerCombo = bWindowComboAttack; } else { TryActivateAbilityByClass(InAbilityClass); }  }

CombatAbilityBase.h  #pragma once  #include "CoreMinimal.h" #include "Abilities/GameplayAbility.h" #include "CombatAbilityBase.generated.h"   UCLASS(Abstract) class COMBATABILITIESSYSTEMRUNTIME_API UCombatAbilityBase : public UGameplayAbility { GENERATED_BODY()  public: explicit UCombatAbilityBase(const FObjectInitializer& InInitializer = FObjectInitializer::Get());  protected:  UFUNCTION() virtual void OnMontageCompleted(FGameplayTag EventTag, FGameplayEventData EventData);  UFUNCTION() virtual void OnMontageCancelled(FGameplayTag EventTag, FGameplayEventData EventData);  UFUNCTION() virtual void OnEventReceived(FGameplayTag EventTag, FGameplayEventData EventData);  UFUNCTION(BlueprintCallable, Category="CombatAbility") void PlayMontageWaitEvent(UAnimMontage* InMontage, const float InRateMontage = 1.f, const FName& InStartSection = NAME_None, const bool InbStopWhenAbilityEnds = true);  private: UPROPERTY(EditDefaultsOnly, Category="Combat|Events") FGameplayTagContainer WaitMontageEvents;  };

CombatAbilityBase.cpp  #include "Abilities/CombatAbilityBase.h"  #include "Abilities/Tasks/PlayMontageAndWaitForEvent.h"  UCombatAbilityBase::UCombatAbilityBase(const FObjectInitializer& InInitializer) : Super(InInitializer) { }  void UCombatAbilityBase::OnMontageCompleted(FGameplayTag EventTag, FGameplayEventData EventData) { EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, false); }  void UCombatAbilityBase::OnMontageCancelled(FGameplayTag EventTag, FGameplayEventData EventData) { EndAbility(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, true, true); }  void UCombatAbilityBase::OnEventReceived(FGameplayTag EventTag, FGameplayEventData EventData) { }  void UCombatAbilityBase::PlayMontageWaitEvent(UAnimMontage* InMontage, const float InRateMontage, const FName& InStartSection, const bool InbStopWhenAbilityEnds) { auto* MontageTask {UPlayMontageAndWaitForEvent::PlayMontageAndWaitForEvent(this, NAME_None, InMontage, WaitMontageEvents, InRateMontage, InStartSection, InbStopWhenAbilityEnds)}; MontageTask->OnCompleted.AddDynamic(this, &UCombatAbilityBase::OnMontageCompleted); MontageTask->OnBlendOut.AddDynamic(this, &UCombatAbilityBase::OnMontageCompleted); MontageTask->OnCancelled.AddDynamic(this, &UCombatAbilityBase::OnMontageCancelled); MontageTask->OnInterrupted.AddDynamic(this, &UCombatAbilityBase::OnMontageCancelled); MontageTask->EventReceived.AddDynamic(this, &UCombatAbilityBase::OnEventReceived); MontageTask->ReadyForActivation();  }

UCombatAttackAbility.h  #pragma once  #include "CoreMinimal.h" #include "ComboAbility.h" #include "Abilities/CombatAbilityBase.h" #include "Data/CombatActionData.h" #include "CombatAttackAbility.generated.h"   UCLASS(Abstract) class COMBATABILITIESSYSTEMRUNTIME_API UCombatAttackAbility : public UComboAbility { GENERATED_BODY()  protected: virtual void ActivateAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo, const FGameplayEventData* TriggerEventData) override;  virtual void OnEventReceived(FGameplayTag EventTag, FGameplayEventData EventData) override;   private: UPROPERTY(EditDefaultsOnly, Category="Combat") float PauseHitMontage{0.05f};  UPROPERTY(EditDefaultsOnly, Category="Combat") TSubclassOf<UGameplayEffect> DamageEffectClass;  UPROPERTY() FCombatAnimationInfo AttackAnimation;  UPROPERTY() TArray<AActor*> HitActors;  void ResetMontage() const;   };

CombatAttackAbility.cpp  #include "Abilities/CombatAttackAbility.h"  #include "AbilitySystemBlueprintLibrary.h" #include "AbilitySystemComponent.h" #include "CombatComponentInterface.h"  #include UE_INLINE_GENERATED_CPP_BY_NAME(CombatAttackAbility)  void UCombatAttackAbility::ActivateAbility(const FGameplayAbilitySpecHandle Handle,                                            const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo,                                            const FGameplayEventData* TriggerEventData) { Super::ActivateAbility(Handle, ActorInfo, ActivationInfo, TriggerEventData);  if(!CommitAbility(Handle, ActorInfo, ActivationInfo)) { EndAbility(Handle, ActorInfo, ActivationInfo, false, true); return; }   if(auto* AbilityComponent{ActorInfo->AvatarActor.Get()->FindComponentByInterface<UCombatComponentInterface>()}; AbilityComponent) { ICombatComponentInterface::Execute_IncrementComboIndex(AbilityComponent);  AttackAnimation = ICombatComponentInterface::Execute_GetComboMontageAction(AbilityComponent, AbilityTags.First());  PlayMontageWaitEvent(AttackAnimation.Montage, AttackAnimation.Speed); }  }  void UCombatAttackAbility::OnEventReceived(FGameplayTag EventTag, FGameplayEventData EventData) { AActor* HitActor{EventData.Target}; if(HitActors.Contains(HitActor)) return;  HitActors.AddUnique(HitActor);  CurrentActorInfo->AnimInstance.Get()->Montage_Pause(AttackAnimation.Montage.Get()); FTimerHandle TimerHandle; GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &UCombatAttackAbility::ResetMontage, PauseHitMontage); (void)ApplyGameplayEffectToTarget(CurrentSpecHandle, CurrentActorInfo, CurrentActivationInfo, EventData.TargetData, DamageEffectClass, 1);  }  void UCombatAttackAbility::ResetMontage() const { CurrentActorInfo->AnimInstance.Get()->Montage_Resume(AttackAnimation.Montage.Get());  }

ComboWindowAnimNotifyState.h  #pragma once  #include "CoreMinimal.h" #include "Animation/AnimNotifies/AnimNotifyState.h" #include "ComboWindowAnimNotifyState.generated.h"  UCLASS() class COMBATABILITIESSYSTEMRUNTIME_API UComboWindowAnimNotifyState : public UAnimNotifyState { GENERATED_BODY()  public:  explicit UComboWindowAnimNotifyState(const FObjectInitializer& InInitializer = FObjectInitializer::Get());  virtual void NotifyBegin(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float TotalDuration, const FAnimNotifyEventReference& EventReference) override; virtual void NotifyEnd(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference) override; virtual void NotifyTick(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float FrameDeltaTime, const FAnimNotifyEventReference& EventReference) override;  private: UPROPERTY(EditAnywhere, Category="Combo") bool bEndCombo;  UPROPERTY() TObjectPtr<UObject> CombatComponent;  };

ComboWindowAnimNotifyState.cpp  #include "Animation/ComboWindowAnimNotifyState.h"  #include "AbilitySystemComponent.h" #include "CombatAbilitiesSystemRuntimeModule.h" #include "CombatComponentInterface.h"  #include UE_INLINE_GENERATED_CPP_BY_NAME(ComboWindowAnimNotifyState)  UComboWindowAnimNotifyState::UComboWindowAnimNotifyState(const FObjectInitializer& InInitializer) : Super(InInitializer), bEndCombo(false) { }  void UComboWindowAnimNotifyState::NotifyBegin(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation,                                               float TotalDuration, const FAnimNotifyEventReference& EventReference) { Super::NotifyBegin(MeshComp, Animation, TotalDuration, EventReference);  if(!MeshComp) return; if(!MeshComp->GetOwner()) return;;  CombatComponent = MeshComp->GetOwner()->FindComponentByInterface<UCombatComponentInterface>(); if(CombatComponent) { ICombatComponentInterface::Execute_OpenComboWindow(CombatComponent); } }  void UComboWindowAnimNotifyState::NotifyEnd(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference) { Super::NotifyEnd(MeshComp, Animation, EventReference);  if(CombatComponent) { if(!ICombatComponentInterface::Execute_IsActiveNextCombo(CombatComponent) && bEndCombo) { UE_LOG(LogAbilitySystemComponent, Display, TEXT("RESET COMBO"));  ICombatComponentInterface::Execute_ResetCombo(CombatComponent); } ICombatComponentInterface::Execute_CloseComboWindow(CombatComponent); }  }  void UComboWindowAnimNotifyState::NotifyTick(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float FrameDeltaTime, const FAnimNotifyEventReference& EventReference) { if(!CombatComponent) { UE_LOG(LogAbilitySystemComponent, Warning, TEXT("CombatComponent is Null")); return; }  const bool bOpenWindowCombo {ICombatComponentInterface::Execute_IsOpenComboWindow(CombatComponent)}; const bool bShouldTriggerCombo {ICombatComponentInterface::Execute_IsShouldTriggerCombo(CombatComponent)}; const bool bRequestTriggerCombo{ICombatComponentInterface::Execute_IsRequestTriggerCombo(CombatComponent)};  if(bOpenWindowCombo && bShouldTriggerCombo && bRequestTriggerCombo && !bEndCombo) {  if(ICombatComponentInterface::Execute_IsActiveNextCombo(CombatComponent)) { return; }  const UGameplayAbility* ComboAbility {ICombatComponentInterface::Execute_GetCurrentActiveComboAbility(CombatComponent)}; if(!ComboAbility) { UE_LOG(LogAbilitySystemComponent, Warning, TEXT("ComboAbility is Null")); return; }  auto* AbilityComponent {MeshComp->GetOwner()->GetComponentByClass<UAbilitySystemComponent>()}; if(const bool bSuccess {AbilityComponent->TryActivateAbilityByClass(ComboAbility->GetClass())}; bSuccess) { ICombatComponentInterface::Execute_ActivateNextCombo(CombatComponent); } else { UE_LOG(LogCombatAbilitySystem, Verbose, TEXT("CombotNotifyTick Ability %s didn't activate"), *ComboAbility->GetClass()->GetName()); } } }

TriggerComboAnimNotify.сpp  #include "Animation/TriggerComboAnimNotify.h"  #include "CombatComponentInterface.h"  void UTriggerComboAnimNotify::Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation,                                      const FAnimNotifyEventReference& EventReference) { if(auto* CombatComponent{MeshComp->GetOwner()->FindComponentByInterface<UCombatComponentInterface>()}; CombatComponent) { ICombatComponentInterface::Execute_RequestTriggerCombo(CombatComponent); }  }

AddAbilities_GameFeatureAction.h  #pragma once  #include "CoreMinimal.h" #include "GameFeature_WorldActionBase.h" #include "GameplayAbilitySpec.h" #include "Components/GameFrameworkComponentManager.h" #include "AddAbilities_GameFeatureAction.generated.h"  class UInputAction;  USTRUCT(BlueprintType) struct FCombatAbilityMapping { GENERATED_BODY()  UPROPERTY(EditAnywhere, BlueprintReadOnly) TSoftClassPtr<UGameplayAbility> Ability; UPROPERTY(EditAnywhere, BlueprintReadOnly) TSoftObjectPtr<UInputAction> InputAction;  };  USTRUCT(BlueprintType) struct FCombatAttributesMapping { GENERATED_BODY()  UPROPERTY(EditAnywhere, BlueprintReadOnly) TSoftClassPtr<UAttributeSet> Attribute;  UPROPERTY(EditAnywhere, BlueprintReadOnly) TSoftObjectPtr<UDataTable> AttributeData;  };  USTRUCT() struct FGameFeatureAbilitiesEntry { GENERATED_BODY()  UPROPERTY(EditAnywhere, Category="Abilities") TSoftClassPtr<AActor> ActorClass;  UPROPERTY(EditAnywhere, Category="Abilities") TArray<FCombatAbilityMapping> GrantedAbilities;  UPROPERTY(EditAnywhere, Category="Abilities") TArray<FCombatAttributesMapping> GrantedAttributes; };  UCLASS(DisplayName="Add Combat Abilities") class COMBATABILITIESSYSTEMRUNTIME_API UAddAbilities_GameFeatureAction : public UGameFeature_WorldActionBase { GENERATED_BODY()  public: virtual void OnGameFeatureActivating() override; virtual void OnGameFeatureDeactivating(FGameFeatureDeactivatingContext& Context) override; #if WITH_EDITORONLY_DATA virtual void AddAdditionalAssetBundleData(FAssetBundleData& AssetBundleData) override; #endif  #if WITH_EDITOR virtual EDataValidationResult IsDataValid(TArray<FText>& ValidationErrors) override; #endif  private: virtual void AddToWorld(const FWorldContext& InWorldContext) override;  void RemoveActorAbilities(AActor* InActor); void Reset(); void HandleActorExtension(AActor* InActor, FName InEventName, const int32 EntryIndex); void AddActorAbilities(AActor* InActor, const FGameFeatureAbilitiesEntry& AbilitiesEntry);  template<class ComponentType> ComponentType* FindOrAddComponentForActor(const AActor* InActor, const FGameFeatureAbilitiesEntry& InAbilitiesEntry) { return Cast<ComponentType>(FindOrAddComponentForActor(ComponentType::StaticClass(), InActor, InAbilitiesEntry)); }  UActorComponent* FindOrAddComponentForActor(UClass* InComponentType, const AActor* InActor, const FGameFeatureAbilitiesEntry& InAbilitiesEntry);  private: UPROPERTY(EditAnywhere, Category="Abilities", meta=(AllowPrivateAccess="true", TitleProperty="ActorClass", ShowOnlyInnerProperties)) TArray<FGameFeatureAbilitiesEntry> AbilitiesList;  struct FActorExtensions { TArray<FGameplayAbilitySpecHandle> Abilities; TArray<UAttributeSet*> Attributes;  };  TMap<TObjectPtr<AActor>, FActorExtensions> ActiveExtensions;  TArray<TSharedPtr<FComponentRequestHandle>> ComponentRequests;  };

AddAbilities_GameFeatureAction.cpp  #include "GameFeature/AddAbilities_GameFeatureAction.h"  #include "AbilitySystemComponent.h" #include "CombatAbilitiesSystemRuntimeModule.h" #include "Components/GameFrameworkComponentManager.h" #include "GameFeaturesSubsystemSettings.h" #include "Components/CombatSystemComponent.h" #include "Engine/AssetManager.h" #include "Input/AbilityInputBindingComponent.h"   #define LOCTEXT_NAMESPACE "CombatAbilitiesSystemFeatures"  #include UE_INLINE_GENERATED_CPP_BY_NAME(AddAbilities_GameFeatureAction)   void UAddAbilities_GameFeatureAction::OnGameFeatureActivating() { if (!ensureAlways(ActiveExtensions.IsEmpty()) || !ensureAlways(ComponentRequests.IsEmpty())) { Reset(); } Super::OnGameFeatureActivating(); }  void UAddAbilities_GameFeatureAction::OnGameFeatureDeactivating(FGameFeatureDeactivatingContext& Context) { Super::OnGameFeatureDeactivating(Context); Reset(); }  #if WITH_EDITORONLY_DATA void UAddAbilities_GameFeatureAction::AddAdditionalAssetBundleData(FAssetBundleData& AssetBundleData) { if (!UAssetManager::IsValid()) return;  auto AddBundleAsset = [&AssetBundleData](const FTopLevelAssetPath& SoftObjectPath) { AssetBundleData.AddBundleAsset(UGameFeaturesSubsystemSettings::LoadStateClient, SoftObjectPath); AssetBundleData.AddBundleAsset(UGameFeaturesSubsystemSettings::LoadStateServer, SoftObjectPath); };  for (const FGameFeatureAbilitiesEntry& Entry : AbilitiesList) { for (const FCombatAbilityMapping& Ability : Entry.GrantedAbilities) { AddBundleAsset(FTopLevelAssetPath(Ability.Ability->GetPathName())); if (!Ability.InputAction.IsNull()) { AddBundleAsset(FTopLevelAssetPath{Ability.InputAction->GetPathName()}); } }  for (const FCombatAttributesMapping& Attributes : Entry.GrantedAttributes) { AddBundleAsset(FTopLevelAssetPath(Attributes.Attribute->GetPathName())); if (!Attributes.AttributeData.IsNull()) { AddBundleAsset(FTopLevelAssetPath(Attributes.AttributeData->GetPathName())); } } } } #endif  #if WITH_EDITOR EDataValidationResult UAddAbilities_GameFeatureAction::IsDataValid(TArray<FText>& ValidationErrors) { EDataValidationResult Result {CombineDataValidationResults(Super::IsDataValid(ValidationErrors), EDataValidationResult::Valid)};  int32 EntryIndex {0}; for (const FGameFeatureAbilitiesEntry& Entry : AbilitiesList) { if (Entry.ActorClass.IsNull()) { Result = EDataValidationResult::Invalid; ValidationErrors.Add(FText::Format(LOCTEXT("EntryHasNullActor", "Null ActorClass at index {0} in AbilitiesList"), FText::AsNumber(EntryIndex))); }  if (Entry.GrantedAbilities.IsEmpty() && Entry.GrantedAttributes.IsEmpty()) { Result = EDataValidationResult::Invalid; ValidationErrors.Add(FText::Format(LOCTEXT("EntryHasNoAddOns", "Empty GrantedAbilities and GrantedAttributes at index {0} in AbilitiesList"), FText::AsNumber(EntryIndex))); }  int32 AbilityIndex {0}; for (const FCombatAbilityMapping& Ability : Entry.GrantedAbilities) { if (Ability.Ability.IsNull()) { Result = EDataValidationResult::Invalid; ValidationErrors.Add(FText::Format(LOCTEXT("EntryHasNullAbility", "Null AbilityType at index {0} in AbilitiesList[{1}].GrantedAbilities"), FText::AsNumber(AbilityIndex), FText::AsNumber(EntryIndex))); } ++AbilityIndex; }  int32 AttributesIndex {0}; for (const FCombatAttributesMapping& Attributes : Entry.GrantedAttributes) { if (Attributes.Attribute.IsNull()) { Result = EDataValidationResult::Invalid; ValidationErrors.Add(FText::Format(LOCTEXT("EntryHasNullAttributeSet", "Null AttributeSetType at index {0} in AbilitiesList[{1}].GrantedAttributes"), FText::AsNumber(AttributesIndex), FText::AsNumber(EntryIndex))); } ++AttributesIndex; }  ++EntryIndex; }  return Result;  return EDataValidationResult::NotValidated; } #endif  void UAddAbilities_GameFeatureAction::AddToWorld(const FWorldContext& WorldContext) { const UWorld* World {WorldContext.World()}; const UGameInstance* GameInstance {WorldContext.OwningGameInstance}; if(!GameInstance && !World && !World->IsGameWorld()) return;  UGameFrameworkComponentManager* ComponentManager {UGameInstance::GetSubsystem<UGameFrameworkComponentManager>(GameInstance)}; if(!ComponentManager) { UE_LOG(LogCombatAbilitySystem, Warning, TEXT("Failed to get UGameFrameworkComponentManager from %s"), *GameInstance->GetName()) return; }  int32 EntryIndex {0}; for (const FGameFeatureAbilitiesEntry& Entry : AbilitiesList) { if (!Entry.ActorClass.IsNull()) { UGameFrameworkComponentManager::FExtensionHandlerDelegate AddAbilitiesDelegate {UGameFrameworkComponentManager::FExtensionHandlerDelegate::CreateUObject( this, &UAddAbilities_GameFeatureAction::HandleActorExtension, EntryIndex)}; TSharedPtr<FComponentRequestHandle> ExtensionRequestHandle {ComponentManager->AddExtensionHandler(Entry.ActorClass, AddAbilitiesDelegate)};  ComponentRequests.Add(ExtensionRequestHandle); EntryIndex++; } }  }  void UAddAbilities_GameFeatureAction::Reset() { while (!ActiveExtensions.IsEmpty()) { const auto ExtensionIt = ActiveExtensions.CreateIterator(); RemoveActorAbilities(ExtensionIt->Key); }  ComponentRequests.Empty(); }  void UAddAbilities_GameFeatureAction::HandleActorExtension(AActor* Actor, FName EventName, int32 EntryIndex) { if (AbilitiesList.IsValidIndex(EntryIndex)) { const FGameFeatureAbilitiesEntry& Entry {AbilitiesList[EntryIndex]}; if (EventName == UGameFrameworkComponentManager::NAME_ExtensionRemoved || EventName == UGameFrameworkComponentManager::NAME_ReceiverRemoved) { RemoveActorAbilities(Actor); } else if (EventName == UGameFrameworkComponentManager::NAME_ExtensionAdded || EventName == UGameFrameworkComponentManager::NAME_GameActorReady) { AddActorAbilities(Actor, Entry); } } }  void UAddAbilities_GameFeatureAction::AddActorAbilities(AActor* Actor, const FGameFeatureAbilitiesEntry& AbilitiesEntry) { auto* CombatAbilitySystemComponent {FindOrAddComponentForActor<UCombatSystemComponent>(Actor, AbilitiesEntry)}; if(!CombatAbilitySystemComponent) { UE_LOG(LogCombatAbilitySystem, Error, TEXT("Failed to find/add an ability component to '%s'. Abilities will not be granted."), *Actor->GetPathName()); return; }  FActorExtensions AddedExtensions; AddedExtensions.Abilities.Reserve(AbilitiesEntry.GrantedAbilities.Num()); AddedExtensions.Attributes.Reserve(AbilitiesEntry.GrantedAttributes.Num());  for (const FCombatAbilityMapping& Ability : AbilitiesEntry.GrantedAbilities) { if (Ability.Ability.IsNull()) continue;  FGameplayAbilitySpec NewAbilitySpec(Ability.Ability.LoadSynchronous()); FGameplayAbilitySpecHandle AbilityHandle = CombatAbilitySystemComponent->GiveAbility(NewAbilitySpec);  if (!Ability.InputAction.IsNull()) { if (auto* InputComponent = FindOrAddComponentForActor<UAbilityInputBindingComponent>(Actor, AbilitiesEntry); InputComponent) { InputComponent->SetInputBinding(Ability.InputAction.LoadSynchronous(), AbilityHandle); } else { UE_LOG(LogCombatAbilitySystem, Error, TEXT("Failed to find/add an ability input binding component to '%s' -- are you sure it's a pawn class?"), *Actor->GetPathName()); } }  AddedExtensions.Abilities.Add(AbilityHandle); }  for (const FCombatAttributesMapping& Attributes : AbilitiesEntry.GrantedAttributes) { if (Attributes.Attribute.IsNull()) continue;  if (TSubclassOf<UAttributeSet> SetType = Attributes.Attribute.LoadSynchronous(); SetType) { UAttributeSet* NewSet = NewObject<UAttributeSet>(CombatAbilitySystemComponent, SetType); if (!Attributes.AttributeData.IsNull()) { if (UDataTable* InitData = Attributes.AttributeData.LoadSynchronous(); InitData) { NewSet->InitFromMetaDataTable(InitData); } }  AddedExtensions.Attributes.Add(NewSet); CombatAbilitySystemComponent->AddAttributeSetSubobject(NewSet); } }  ActiveExtensions.Add(Actor, AddedExtensions);  }  UActorComponent* UAddAbilities_GameFeatureAction::FindOrAddComponentForActor(UClass* InComponentType, const AActor* InActor, const FGameFeatureAbilitiesEntry& InAbilitiesEntry) { UActorComponent* Component {InActor->FindComponentByClass(InComponentType)};  bool bMakeComponentRequest {Component == nullptr}; if (Component) { if (Component->CreationMethod == EComponentCreationMethod::Native) { const UObject* ComponentArchetype = Component->GetArchetype(); bMakeComponentRequest = ComponentArchetype->HasAnyFlags(RF_ClassDefaultObject); } }  if (bMakeComponentRequest) { const UWorld* World = InActor->GetWorld(); const UGameInstance* GameInstance = World->GetGameInstance();  if (UGameFrameworkComponentManager* ComponentMan = UGameInstance::GetSubsystem<UGameFrameworkComponentManager>(GameInstance)) { TSharedPtr<FComponentRequestHandle> RequestHandle = ComponentMan->AddComponentRequest(InAbilitiesEntry.ActorClass, InComponentType); ComponentRequests.Add(RequestHandle); }  if (!Component) { Component = InActor->FindComponentByClass(InComponentType); ensureAlways(Component); } }  return Component; }  void UAddAbilities_GameFeatureAction::RemoveActorAbilities(AActor* Actor) { FActorExtensions* ActorExtensions {ActiveExtensions.Find(Actor)}; if(!ActorExtensions) return;  if (auto* CombatAbilitySystemComponent {Actor->FindComponentByClass<UCombatSystemComponent>()}) { for (UAttributeSet* AttribSetInstance : ActorExtensions->Attributes) { CombatAbilitySystemComponent->GetSpawnedAttributes_Mutable().Remove(AttribSetInstance); }  auto* InputComponent {Actor->FindComponentByClass<UAbilityInputBindingComponent>()}; for (FGameplayAbilitySpecHandle AbilityHandle : ActorExtensions->Abilities) { if (InputComponent) { InputComponent->ClearInputBinding(AbilityHandle); } CombatAbilitySystemComponent->SetRemoveAbilityOnEnd(AbilityHandle); } }  ActiveExtensions.Remove(Actor);  }  #undef LOCTEXT_NAMESPACE