description: Wait on attribute ratio change meeting a comparison threshold.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitAttributeChangeRatioThreshold](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-) * WaitForAttributeChangeRatioThreshold ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) AttributeNumerator, [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) AttributeDenominator, [TEnumAsByte](API\Runtime\Core\Containers\TEnumAsByte)< [EWaitAttributeChangeComparison::Type](API\Plugins\GameplayAbilities\Abilities\Tasks\EWaitAttributeCh-) > ComparisonType, float ComparisonValue, bool bTriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner )


module: GameplayAbilities

code: UAbilityTask_WaitAttributeChangeRatioThreshold ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Waits for the ratio between two attributes to match a threshold

AttributeDenominator

type: FGameplayAttrib...

bMatchedComparisonLastAttributeChange

type: bool

CheckAttributeTimer

type: FTimerHandle

description: Timer used when either numerator or denominator attribute is changed to delay checking of ratio to avoid false positives (MaxHealth changed before Health updates accordingly)

ComparisonType

type: TEnumAsByte<EW...

ComparisonValue

type: float

ExternalOwner

type: TObjectPtr<UAb...

OnChange

type: FWaitAttributeC...

type: FDelegateHandle


description: Called to trigger the actual task once the delegates have been set up Note that the default implementation does nothing and you don't have to call it

code: virtual void Activate()


code: bool DoesValuePassComparison ( float Value ) const


code: void OnAttributeChange ( const [FOnAttributeChangeData](API\Plugins\GameplayAbilities\FOnAttributeChangeData) & CallbackData )


description: End and CleanUp the task - may be called by the task itself or by the task owner if the owner is ending. IMPORTANT! Do NOT call directly! CallEndTask()orTaskOwnerEnded()IMPORTANT! When overriding this function make sure to call Super::OnDestroy(bOwnerFinished) as the last thing, since the function internally marks the task as "Pending Kill", and this may interfere with internal BP mechanics

code: virtual void OnDestroy ( bool bInOwnerFinished )


description: Wait on attribute change meeting a comparison threshold.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitAttributeChangeThreshold](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_1) * WaitForAttributeChangeThreshold ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) Attribute, [TEnumAsByte](API\Runtime\Core\Containers\TEnumAsByte)< [EWaitAttributeChangeComparison::Type](API\Plugins\GameplayAbilities\Abilities\Tasks\EWaitAttributeCh-) > ComparisonType, float ComparisonValue, bool bTriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner )


code: UAbilityTask_WaitAttributeChangeThreshold ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Waits for an attribute to match a threshold


code: virtual void BroadcastDelegate ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Avatar, [FGameplayEffectSpecHandle](API\Plugins\GameplayAbilities\FGameplayEffectSpecHandle) SpecHandle, [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) ActiveHandle )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnApplyGameplayEffectCallback ( [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * Target, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & SpecApplied, [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) ActiveHandle )


code: virtual void RegisterDelegate()


code: virtual void RemoveDelegate()


code: UAbilityTask_WaitGameplayEffectApplied ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


Filter

type: FGameplayTarget...

Locked

description: If we are in the process of broadcasting and should not accept additional GE callbacks.

SourceTagQuery

type: FGameplayTagQue...

SourceTagRequirements

type: FGameplayTagReq...


code: void SetExternalActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * InActor )


code: UAbilityTask_WaitGameplayEffectApplied_Self ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Wait until the ownerreceivesa GameplayEffect from a given source (the source may be the owner too!). If TriggerOnce is true, this task will only return one time. Otherwise it will return everytime a GE is applied that meets the requirements over the life of the ability Optional External Owner can be used to run this task on someone else (not the owner of the ability).Bydefault you can leave this empty.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEffectApplied_Self](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_3) * WaitGameplayEffectAppliedToSelf ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, const [FGameplayTargetDataFilterHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayTargetDataFilterHandle) SourceFilter, [FGameplayTagRequirements](API\Plugins\GameplayAbilities\FGameplayTagRequirements) SourceTagRequirements, [FGameplayTagRequirements](API\Plugins\GameplayAbilities\FGameplayTagRequirements) TargetTagRequirements, bool TriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner, bool ListenForPeriodicEffect )


description: This version usesFGameplayTagQuery(more power) instead ofFGameplayTagRequirements(faster)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEffectApplied_Self](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_3) * WaitGameplayEffectAppliedToSelf_Query ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, const [FGameplayTargetDataFilterHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayTargetDataFilterHandle) SourceFilter, [FGameplayTagQuery](API\Runtime\GameplayTags\FGameplayTagQuery) SourceTagQuery, [FGameplayTagQuery](API\Runtime\GameplayTags\FGameplayTagQuery) TargetTagQuery, bool TriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner, bool ListenForPeriodicEffect )


description: Wait until the owner (or External Owner) applies a GameplayEffect to a Target (the target may be the owner too!). If TriggerOnce is true, this task will only return one time. Otherwise it will return everytime a GE is applied that meets the requirements over the life of the ability Optional External Owner can be used to run this task on someone else (not the owner of the ability).Bydefault you can leave this empty.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEffectApplied_Target](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_4) * WaitGameplayEffectAppliedToTarget ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, const [FGameplayTargetDataFilterHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayTargetDataFilterHandle) TargetFilter, [FGameplayTagRequirements](API\Plugins\GameplayAbilities\FGameplayTagRequirements) SourceTagRequirements, [FGameplayTagRequirements](API\Plugins\GameplayAbilities\FGameplayTagRequirements) TargetTagRequirements, bool TriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner, bool ListenForPeriodicEffects )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEffectApplied_Target](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_4) * WaitGameplayEffectAppliedToTarget_Query ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, const [FGameplayTargetDataFilterHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayTargetDataFilterHandle) SourceFilter, [FGameplayTagQuery](API\Runtime\GameplayTags\FGameplayTagQuery) SourceTagQuery, [FGameplayTagQuery](API\Runtime\GameplayTags\FGameplayTagQuery) TargetTagQuery, bool TriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner, bool ListenForPeriodicEffect )


code: UAbilityTask_WaitGameplayEffectApplied_Target ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: virtual void Activate()


code: virtual void ImmunityCallback ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & BlockedSpec, const [FActiveGameplayEffect](API\Plugins\GameplayAbilities\FActiveGameplayEffect) * ImmunityGE )


code: virtual void OnDestroy ( bool bInOwnerFinished )


code: void RegisterDelegate()


description: Listens for GE immunity.Bydefault this means "this hero blocked a GE due to immunity". Setting OptionalExternalTarget will listen for a GE being blocked on an external target. Note this only works on the server.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEffectBlockedImmunity](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_5) * WaitGameplayEffectBlockedByImmunity ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTagRequirements](API\Plugins\GameplayAbilities\FGameplayTagRequirements) SourceTagRequirements, [FGameplayTagRequirements](API\Plugins\GameplayAbilities\FGameplayTagRequirements) TargetTagRequirements, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalTarget, bool OnlyTriggerOnce )


code: UAbilityTask_WaitGameplayEffectBlockedImmunity ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


Blocked

type: FGameplayEffect...


code: UAbilityTask_WaitGameplayEffectRemoved ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Wait until the specified gameplay effect is removed.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEffectRemoved](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_6) * WaitForGameplayEffectRemoved ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) Handle )


description: Waits for the actor to activate another ability

Handle

type: FActiveGameplay...

InvalidHandle

type: FWaitGameplayEf...


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnGameplayEffectRemoved ( const [FGameplayEffectRemovalInfo](API\Plugins\GameplayAbilities\FGameplayEffectRemovalInfo) & InGameplayEffectRemovalInfo )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnGameplayEffectStackChange ( [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) Handle, int32 NewCount, int32 OldCount )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEffectStackChange](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_Wai-_7) * WaitForGameplayEffectStackChange ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) Handle )


code: UAbilityTask_WaitGameplayEffectStackChange ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnAbilityActivate ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * ActivatedAbility )


description: Wait until a new ability (of the same or different type) is activated. Only input based abilities will be counted unless IncludeTriggeredAbilities is true.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitAbilityActivate](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitAbilityActivate) * WaitForAbilityActivate ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) WithTag, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) WithoutTag, bool IncludeTriggeredAbilities, bool TriggerOnce )


description: Wait until a new ability (of the same or different type) is activated. Only input based abilities will be counted unless IncludeTriggeredAbilities is true. Uses a tag requirements structure to filter abilities.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitAbilityActivate](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitAbilityActivate) * WaitForAbilityActivateWithTagRequirements ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTagRequirements](API\Plugins\GameplayAbilities\FGameplayTagRequirements) TagRequirements, bool IncludeTriggeredAbilities, bool TriggerOnce )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitAbilityActivate](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitAbilityActivate) * WaitForAbilityActivate_Query ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTagQuery](API\Runtime\GameplayTags\FGameplayTagQuery) Query, bool IncludeTriggeredAbilities, bool TriggerOnce )


code: UAbilityTask_WaitAbilityActivate ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitAbilityActivate : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnActivate

type: FWaitAbilityAct...

WithoutTag

type: FGameplayTag


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnAbilityCommit ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * ActivatedAbility )


code: virtual void Activate()


code: virtual void OnDestroy ( bool bInOwnerFinished )


description: Wait until a new ability (of the same or different type) is commited.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE", DisplayName="Wait For New Ability Commit")) static [UAbilityTask_WaitAbilityCommit](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitAbilityCommit) * WaitForAbilityCommit ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) WithTag, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) WithoutTage, bool TriggerOnce )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE", DisplayName="Wait For New Ability Commit Query")) static [UAbilityTask_WaitAbilityCommit](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitAbilityCommit) * WaitForAbilityCommit_Query ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTagQuery](API\Runtime\GameplayTags\FGameplayTagQuery) Query, bool TriggerOnce )


code: UAbilityTask_WaitAbilityCommit ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitAbilityCommit : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnCommit

type: FWaitAbilityCom...


code: void OnAttributeChange ( const [FOnAttributeChangeData](API\Plugins\GameplayAbilities\FOnAttributeChangeData) & CallbackData )


description: Wait until an attribute changes.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitAttributeChange](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitAttributeChange) * WaitForAttributeChange ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) Attribute, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) WithSrcTag, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) WithoutSrcTag, bool TriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner )


code: UAbilityTask_WaitAttributeChange ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitAttributeChange : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

Attribute

type: FGameplayAttrib...


description: Wait until an attribute changes to pass a given test.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitAttributeChange](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitAttributeChange) * WaitForAttributeChangeWithComparison ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) InAttribute, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) InWithTag, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) InWithoutTag, [TEnumAsByte](API\Runtime\Core\Containers\TEnumAsByte)< [EWaitAttributeChangeComparison::Type](API\Plugins\GameplayAbilities\Abilities\Tasks\EWaitAttributeCh-) > InComparisonType, float InComparisonValue, bool TriggerOnce, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalOwner )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="true", DisplayName="Wait for Cancel Input"), Category="Ability|Tasks") static [UAbilityTask_WaitCancel](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitCancel) * WaitCancel ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility )


code: UAbilityTask_WaitCancel ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnConfirmCallback ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * InAbility )


description: Wait until the server confirms the use of this ability. This is used to gate predictive portions of the ability

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitConfirm](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitConfirm) * WaitConfirm ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility )


code: UAbilityTask_WaitConfirm ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitConfirm : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnConfirm

type: FGenericGamepla...

RegisteredCallback

type: bool


code: virtual void Activate()


code: virtual void OnDestroy ( bool bInOwnerFinished )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitCancel : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnCancel

type: FWaitCancelDele...


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="true", DisplayName="Wait for Confirm Input"), Category="Ability|Tasks") static [UAbilityTask_WaitConfirmCancel](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitConfirmCancel) * WaitConfirmCancel ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility )


code: UAbilityTask_WaitConfirmCancel ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Fixme: this name is conflicting with AbilityTask_WaitConfirmUAbilityTask_WaitConfirmCancel= Wait for Targeting confirm/cancelUAbilityTask_WaitConfirm= Wait for server to confirm ability activation

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitConfirmCancel : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

type: FWaitConfirmCan...


description: Return debug string describing task

code: virtual [FString](API\Runtime\Core\Containers\FString) GetDebugString() const


description: Wait specified time. This is functionally the same as a standard Delay node.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitDelay](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitDelay) * WaitDelay ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, float Time )


code: UAbilityTask_WaitDelay ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitDelay : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnFinish

type: FWaitDelayDeleg...


code: virtual void GameplayEventCallback ( const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * Payload )


code: virtual void GameplayEventContainerCallback ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) MatchingTag, const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * Payload )


code: void SetExternalTarget ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Actor )


description: Wait until the specified gameplay tag event is triggered.Bydefault this will look at the owner of this ability. OptionalExternalTarget can be set to make this look at another actor's tags for changes It will keep listening as long as OnlyTriggerOnce = false If OnlyMatchExact = false it will trigger for nested tags

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayEvent](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitGameplayEvent) * WaitGameplayEvent ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) EventTag, [AActor](API\Runtime\Engine\GameFramework\AActor) * OptionalExternalTarget, bool OnlyTriggerOnce, bool OnlyMatchExact )


code: UAbilityTask_WaitGameplayEvent ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() virtual void GameplayTagCallback ( const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, int32 NewCount )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitGameplayEvent : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

EventReceived

type: FWaitGameplayEv...

OptionalExternalTarget

type: TObjectPtr<UAb...


code: UAbilityTask_WaitGameplayTag ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitGameplayTag : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

DelegateHandle

type: FDelegateHandle


description: Called to trigger the actual task once the delegates have been set up Note that the default implementation does nothing and you don't have to call it

code: virtual void Activate()


code: virtual void GameplayTagCallback ( const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, int32 NewCount )


code: UAbilityTask_WaitGameplayTagAdded ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Wait until the specified gameplay tag is Added.Bydefault this will look at the owner of this ability. OptionalExternalTarget can be set to make this look at another actor's tags for changes. If the tag is already present when this task is started, it will immediately broadcast the Added event. It will keep listening as long as OnlyTriggerOnce = false.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayTagAdded](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitGameplayTagAdde-) * WaitGameplayTagAdd ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, [AActor](API\Runtime\Engine\GameFramework\AActor) * InOptionalExternalTarget, bool OnlyTriggerOnce )


description: Activates this AbilityTask.


description: This will evaluate the TargetTags using the given TagQuery, executing the Trigger delegate if needed.

code: void EvaluateTagQuery()


description: This gets the ASC to use to listen to tag changed events.


description: Sets the external target that this node whould use for checking tags.

code: void SetExternalTarget ( const [AActor](API\Runtime\Engine\GameFramework\AActor) * Actor )


description: This will handle cleaning up any registered delegates.

code: virtual void OnDestroy ( bool AbilityIsEnding )


description: This will update the tags in the TargetTags container to reflect that tags that are on the target ASC.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void UpdateTargetTags ( const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, int32 NewCount )


description: Wait until the given gameplay tag query has become true or false, based on TriggerCondition.Bydefault this will look at the owner of this ability. OptionalExternalTarget can be set to make this look at another actor's tags for changes. If the the tag query already satisfies the TriggerCondition when this task is started, it will immediately broadcast the Triggered event. It will keep listening as long as bOnlyTriggerOnce = false.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayTagQuery](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitGameplayTagQuer-) * WaitGameplayTagQuery ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, const [FGameplayTagQuery](API\Runtime\GameplayTags\FGameplayTagQuery) TagQuery, const [AActor](API\Runtime\Engine\GameFramework\AActor) * InOptionalExternalTarget, const [EWaitGameplayTagQueryTriggerCondition](API\Plugins\GameplayAbilities\Abilities\Tasks\EWaitGameplayTag-) TriggerCondition, const bool bOnlyTriggerOnce )


description: This class defines a node to wait on a gameplay tag query.

bOnlyTriggerOnce

description: This indicates if this node should only trigger once, or any number of times.

bQueryState

description: This was the last result of evaluating the TagQuery.

bRegisteredCallbacks

description: Indicates if the callbacks for tag changes have been registered.

bUseExternalTarget

description: This indicates if we should use the external target.

OptionalExternalTarget

description: This is the optional external target to use when getting the ASC to get tags from.

TagHandleMap

type: TMap<FGameplay...

description: This is the handles to the tag changed delegate for each gameplay tag in the TagQuery.

TagQuery

type: FGameplayTagQue...

description: This is the tag query to evaluate for triggering this node.

TargetTags

type: FGameplayTagCon...

description: This is the tag container of the targets the target ASC currently has.

TriggerCondition

type: EWaitGameplayTa...

description: This indicates when to Trigger the Triggered output for this node.

Triggered

type: FWaitGameplayTa...

description: This delegate will be triggered when the trigger condition has been met.


description: Wait until the specified gameplay tag is Removed.Bydefault this will look at the owner of this ability. OptionalExternalTarget can be set to make this look at another actor's tags for changes. If the tag is not present when this task is started, it will immediately broadcast the Removed event. It will keep listening as long as OnlyTriggerOnce = false.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitGameplayTagRemoved](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitGameplayTagRemo-) * WaitGameplayTagRemove ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, [AActor](API\Runtime\Engine\GameFramework\AActor) * InOptionalExternalTarget, bool OnlyTriggerOnce )


code: UAbilityTask_WaitGameplayTagRemoved ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Wait until the user presses the input button for this ability's activation. Returns time this node spent waiting for the press. Will return 0 if input was already down.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitInputPress](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitInputPress) * WaitInputPress ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, bool bTestAlreadyPressed )


code: UAbilityTask_WaitInputPress ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Waits until the input is pressed from activating an ability. This should be true immediately upon starting the ability, since the key was pressed to activate it. We expect server to execute this task in parallel and keep its own time. We do not keep track of

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitInputPress : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnPress

type: FInputPressDele...

StartTime

type: float


description: Wait until the user releases the input button for this ability's activation. Returns time from hitting this node, till release. Will return 0 if input was already released.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitInputRelease](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitInputRelease) * WaitInputRelease ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, bool bTestAlreadyReleased )


code: UAbilityTask_WaitInputRelease ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: Waits until the input is released from activating an ability. Clients will replicate a 'release input' event to the server, but not the exact time it was held locally. We expect server to execute this task in parallel and keep its own time.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitInputRelease : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnRelease

type: FInputReleaseDe...


description: Called to trigger the actual task once the delegates have been set up Note that the default implementation does nothing and you don't have to call it

code: virtual void Activate()


description: Wait until movement mode changes (E.g., landing)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE", DisplayName="WaitMovementModeChange")) static [UAbilityTask_WaitMovementModeChange](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitMovementModeCha-) * CreateWaitMovementModeChange ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, EMovementMode NewMode )


code: UAbilityTask_WaitMovementModeChange ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnMovementModeChange ( [ACharacter](API\Runtime\Engine\GameFramework\ACharacter) * Character, EMovementMode PrevMovementMode, uint8 PreviousCustomMode )


OnChange

type: FMovementModeCh...

RequiredMode

type: EMovementMode


description: Need: -Easy way to specify which primitive components should be used for this overlap test -Easy way to specify which types of actors/collision overlaps that we care about/want to block on

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitOverlap](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitOverlap) * WaitForOverlap ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility )


code: UAbilityTask_WaitOverlap ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() void OnHitCallback ( [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) * HitComp, [AActor](API\Runtime\Engine\GameFramework\AActor) * OtherActor, [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) * OtherComp, FVector NormalImpulse, const [FHitResult](API\Runtime\Engine\Engine\FHitResult) & Hit )


description: Fixme: this is still incomplete and probablyh not what most games want for melee systems. -Only actually activates on Blocking hits -Uses first PrimitiveComponent instead of being able to specify arbitrary component.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitOverlap : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

OnOverlap

type: FWaitOverlapDel...


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="true"), Category="Abilities") virtual bool BeginSpawningActor ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [AGameplayAbilityTargetActor](API\Plugins\GameplayAbilities\Abilities\AGameplayAbilityTargetActor) > Class, [AGameplayAbilityTargetActor](API\Plugins\GameplayAbilities\Abilities\AGameplayAbilityTargetActor) *& SpawnedActor )


description: Called when the ability is asked to confirm from an outside node. What this means depends on the individual task.Bydefault, this does nothing other than ending if bEndTask is true.

code: virtual void ExternalCancel()


code: virtual void ExternalConfirm ( bool bEndTask )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="true"), Category="Abilities") virtual void FinishSpawningActor ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [AGameplayAbilityTargetActor](API\Plugins\GameplayAbilities\Abilities\AGameplayAbilityTargetActor) * SpawnedActor )


code: virtual void FinalizeTargetActor ( [AGameplayAbilityTargetActor](API\Plugins\GameplayAbilities\Abilities\AGameplayAbilityTargetActor) * SpawnedActor ) const


code: virtual void InitializeTargetActor ( [AGameplayAbilityTargetActor](API\Plugins\GameplayAbilities\Abilities\AGameplayAbilityTargetActor) * SpawnedActor ) const


description: End and CleanUp the task - may be called by the task itself or by the task owner if the owner is ending. IMPORTANT! Do NOT call directly! CallEndTask()orTaskOwnerEnded()IMPORTANT! When overriding this function make sure to call Super::OnDestroy(bOwnerFinished) as the last thing, since the function internally marks the task as "Pending Kill", and this may interfere with internal BP mechanics

code: virtual void OnDestroy ( bool bInOwnerFinished )


description: The TargetActor we spawned locally has called back with a cancel event (they still include the 'last/best' targetdata but the consumer of this may want to discard it)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() virtual void OnTargetDataCancelledCallback ( const [FGameplayAbilityTargetDataHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityTargetDataHandle) & Data )


description: The TargetActor we spawned locally has called back with valid target data

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() virtual void OnTargetDataReadyCallback ( const [FGameplayAbilityTargetDataHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityTargetDataHandle) & Data )


description: Valid TargetData was replicated to use (we are server, was sent from client)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() virtual void OnTargetDataReplicatedCallback ( const [FGameplayAbilityTargetDataHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityTargetDataHandle) & Data, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) ActivationTag )


description: Client canceled this Targeting Task (we are the server)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)() virtual void OnTargetDataReplicatedCancelledCallback()


code: virtual bool ShouldReplicateDataToServer() const


code: virtual bool ShouldSpawnTargetActor() const


description: Spawns target actor and waits for it to return valid data or to be canceled.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="true", HideSpawnParms="Instigator"), Category="Ability|Tasks") static [UAbilityTask_WaitTargetData](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitTargetData) * WaitTargetData ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FName](API\Runtime\Core\UObject\FName) TaskInstanceName, [TEnumAsByte](API\Runtime\Core\Containers\TEnumAsByte)< [EGameplayTargetingConfirmation::Type](API\Plugins\GameplayAbilities\Abilities\EGameplayTargetingConfirmation__-) > ConfirmationType, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [AGameplayAbilityTargetActor](API\Plugins\GameplayAbilities\Abilities\AGameplayAbilityTargetActor) > Class )


description: Uses specified target actor and waits for it to return valid data or to be canceled.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Meta=(HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="true", HideSpawnParms="Instigator"), Category="Ability|Tasks") static [UAbilityTask_WaitTargetData](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitTargetData) * WaitTargetDataUsingActor ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, [FName](API\Runtime\Core\UObject\FName) TaskInstanceName, [TEnumAsByte](API\Runtime\Core\Containers\TEnumAsByte)< [EGameplayTargetingConfirmation::Type](API\Plugins\GameplayAbilities\Abilities\EGameplayTargetingConfirmation__-) > ConfirmationType, [AGameplayAbilityTargetActor](API\Plugins\GameplayAbilities\Abilities\AGameplayAbilityTargetActor) * TargetActor )


code: UAbilityTask_WaitTargetData ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: WARNING: These actors are spawned once per ability activation and in their default form are not very efficient For most games you will need to subclass and heavily modify this actor, or you will want to implement similar functions in a game-specific actor or blueprint to avoid actor spawn costs This task is not well tested by internal games, but it is a useful class to look at to learn how target replication occurs

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitTargetData : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

Cancelled

type: FWaitTargetData...

ConfirmationType

type: TEnumAsByte<EG...

TargetActor

type: TObjectPtr<AGa...

description: The TargetActor that we spawned

TargetClass

type: TSubclassOf<AG...


code: virtual void Activate()


description: Tick function for this task, if bTickingTask == true

code: virtual void TickTask ( float DeltaTime )


description: Wait for the actor's movement component velocity to be of minimum magnitude when projected along given direction

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Tasks", Meta=(DisplayName="WaitVelocityChange", HidePin="OwningAbility", DefaultToSelf="OwningAbility", BlueprintInternalUseOnly="TRUE")) static [UAbilityTask_WaitVelocityChange](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask_WaitVelocityChange) * CreateWaitVelocityChange ( [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) * OwningAbility, FVector Direction, float MinimumMagnitude )


code: UAbilityTask_WaitVelocityChange ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UAbilityTask_WaitVelocityChange : public [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask)

CachedMovementComponent

type: TObjectPtr<UMo...

Direction

type: FVector

OnVelocityChage

type: FWaitVelocityCh...

description: Delegate called when velocity requirements are met


className: WithNetSerializer

code: enum &123; WithNetSerializer = true &125;


code: template<> struct TStructOpsTypeTraits< FGameplayAbilityRepAnimMontage > : public [TStructOpsTypeTraitsBase2< FGameplayAbilityRepAnimMontage >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


code: template<> struct TStructOpsTypeTraits< FGameplayAbilityTargetData_ActorArray > : public [TStructOpsTypeTraitsBase2< FGameplayAbilityTargetData_ActorArray >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


code: template<> struct TStructOpsTypeTraits< FGameplayAbilityTargetData_LocationInfo > : public [TStructOpsTypeTraitsBase2< FGameplayAbilityTargetData_LocationInfo >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


code: template<> struct TStructOpsTypeTraits< FGameplayAbilityTargetData_SingleTargetHit > : public [TStructOpsTypeTraitsBase2< FGameplayAbilityTargetData_SingleTargetHit >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


className: WithCopy

code: enum &123; WithCopy = true &125;


code: template<> struct TStructOpsTypeTraits< FGameplayAbilityTargetDataHandle > : public [TStructOpsTypeTraitsBase2< FGameplayAbilityTargetDataHandle >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


className: WithIdenticalViaEquality

code: enum &123; WithIdenticalViaEquality = true &125;


code: template<> struct TStructOpsTypeTraits< FGameplayAbilityTargetingLocationInfo > : public [TStructOpsTypeTraitsBase2< FGameplayAbilityTargetingLocationInfo >](API\Runtime\CoreUObject\UObject\TStructOpsTypeTraitsBase2)


description: Actually activate ability, do not call this directly

code: virtual void ActivateAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * TriggerEventData )


description: Add the Ability's tags to the given GameplayEffectSpec. This is likely to be overridden per project.

code: virtual void ApplyAbilityTagsToGameplayEffectSpec ( [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec, [FGameplayAbilitySpec](API\Plugins\GameplayAbilities\FGameplayAbilitySpec) * AbilitySpec ) const


description: Adds a debug message to display to the user

code: void AddAbilityTaskDebugMessage ( [UGameplayTask](API\Runtime\GameplayTasks\UGameplayTask) * AbilityTask, [FString](API\Runtime\Core\Containers\FString) DebugMessage )


description: Applies CooldownGameplayEffect to the target

code: virtual void ApplyCooldown ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo ) const


description: Applies the ability's cost to the target

code: virtual void ApplyCost ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo ) const


description: Non blueprintcallable, safe to call on CDO/NonInstance abilities

code: [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) ApplyGameplayEffectToOwner ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, const [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) * GameplayEffect, float GameplayEffectLevel, int32 Stacks ) const


code: [TArray](API\Runtime\Core\Containers\TArray)< [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) > ApplyGameplayEffectToTarget ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, const [FGameplayAbilityTargetDataHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityTargetDataHandle) & Target, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) > GameplayEffectClass, float GameplayEffectLevel, int32 Stacks ) const


code: [TArray](API\Runtime\Core\Containers\TArray)< [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) > ApplyGameplayEffectSpecToTarget ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) AbilityHandle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, const [FGameplayEffectSpecHandle](API\Plugins\GameplayAbilities\FGameplayEffectSpecHandle) SpecHandle, const [FGameplayAbilityTargetDataHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityTargetDataHandle) & TargetData ) const


description: Apply a gameplay effect to a Target

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="ApplyGameplayEffectToTarget", Meta=(ScriptName="ApplyGameplayEffectToTarget")) [TArray](API\Runtime\Core\Containers\TArray)< [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) > BP_ApplyGameplayEffectToTarget ( [FGameplayAbilityTargetDataHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityTargetDataHandle) TargetData, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) > GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks )


description: Apply a gameplay effect to the owner of this ability

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="ApplyGameplayEffectToOwner", Meta=(ScriptName="ApplyGameplayEffectToOwner")) [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) BP_ApplyGameplayEffectToOwner ( [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) > GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks )


description: Removes GameplayEffects from owner which match the given asset level tags

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="RemoveGameplayEffectFromOwnerWithAssetTags", Meta=(ScriptName="RemoveGameplayEffectFromOwnerWithAssetTags")) void BP_RemoveGameplayEffectFromOwnerWithAssetTags ( [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) WithAssetTags, int32 StacksToRemove )


description: Removes GameplayEffects from owner which grant the given tags

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="RemoveGameplayEffectFromOwnerWithGrantedTags", Meta=(ScriptName="RemoveGameplayEffectFromOwnerWithGrantedTags")) void BP_RemoveGameplayEffectFromOwnerWithGrantedTags ( [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) WithGrantedTags, int32 StacksToRemove )


code: [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) ApplyGameplayEffectSpecToOwner ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) AbilityHandle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, const [FGameplayEffectSpecHandle](API\Plugins\GameplayAbilities\FGameplayEffectSpecHandle) SpecHandle ) const


description: Executes PreActivate and ActivateAbility

code: void CallActivateAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, FOnGameplayAbilityEnded::FDelegate * OnGameplayAbilityEndedDelegate, const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * TriggerEventData )


description: Removes GameplayEffect from owner that match the given handle

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="RemoveGameplayEffectFromOwnerWithHandle", Meta=(ScriptName="RemoveGameplayEffectFromOwnerWithHandle")) void BP_RemoveGameplayEffectFromOwnerWithHandle ( [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) Handle, int32 StacksToRemove )


description: Call the actor's function remotely

code: virtual bool CallRemoteFunction ( [UFunction](API\Runtime\CoreUObject\UObject\UFunction) * Function, void * Parms, [FOutParmRec](API\Runtime\CoreUObject\UObject\FOutParmRec) * OutParms, [FFrame](API\Runtime\CoreUObject\UObject\FFrame) * Stack )


description: Returns true if this ability can be activated right now. Has no side effects

code: virtual bool CanActivateAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * SourceTags, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * TargetTags, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags ) const


description: Returns true if this ability can be canceled

code: virtual bool CanBeCanceled() const


description: Destroys instanced-per-execution abilities. Instance-per-actor abilities should 'reset'. Any active ability state tasks receive the 'OnAbilityStateInterrupted' event. Non instance abilities - what can we do?

code: virtual void CancelAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, bool bReplicateCancelAbility )


description: Add any task with this instance name to a list to be canceled (not ended) next frame. See also EndTaskByInstanceName.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) void CancelTaskByInstanceName ( [FName](API\Runtime\Core\UObject\FName) InstanceName )


description: Checks cooldown. returns true if we can be used again. False if not

code: virtual bool CheckCooldown ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags ) const


description: Checks cost. returns true if we can pay for the ability. False if not

code: virtual bool CheckCost ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags ) const


code: virtual bool CommitAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags )


code: virtual bool CommitAbilityCooldown ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, const bool ForceCooldown, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags )


code: virtual bool CommitAbilityCost ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags )


description: The last chance to fail before committing, this will usually be the same as CanActivateAbility. Some abilities may need to do extra checks here if they are consuming extra stuff in CommitExecute

code: virtual bool CommitCheck ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags )


description: Does the commit atomically (consume resources, do cooldowns, etc)

code: virtual void CommitExecute ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo )


description: Called on a predictive ability when the server confirms its execution

code: virtual void ConfirmActivateSucceed()


description: Finds all currently active tasks named InstanceName and confirms them. What this means depends on the individual task.Bydefault, this does nothing other than ending if bEndTask is true.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) void ConfirmTaskByInstanceName ( [FName](API\Runtime\Core\UObject\FName) InstanceName, bool bEndTask )


description: Decreases the scope lock count. Runs the waiting to execute delegates if the count drops to zero.

code: void DecrementListLock() const


description: Returns true if none of the ability's tags are blocked and if it doesn't have a "Blocking" tag and has all "Required" tags.

code: virtual bool DoesAbilitySatisfyTagRequirements ( const [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) & AbilitySystemComponent, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * SourceTags, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * TargetTags, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags ) const


description: Ends any active ability state task with the given name. If name is 'None' all active states will be ended (in an arbitrary order).

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) void EndAbilityState ( [FName](API\Runtime\Core\UObject\FName) OptionalStateNameToEnd )


description: Native function, called if an ability ends normally or abnormally. If bReplicate is set to true, try to replicate the ending to the client/server

code: virtual void EndAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, bool bReplicateEndAbility, bool bWasCancelled )


description: Internal function, cancels all the tasks we asked to cancel last frame (by instance name).

code: void EndOrCancelTasksByInstanceName()


description: Add any task with this instance name to a list to be ended (not canceled) next frame. See also CancelTaskByInstanceName.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) void EndTaskByInstanceName ( [FName](API\Runtime\Core\UObject\FName) InstanceName )


description: Returns current level of the Ability

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) int32 GetAbilityLevel() const


description: Returns current ability level for non instanced abilities. You must call this version in these contexts!

code: int32 GetAbilityLevel ( [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo ) const


description: Returns the AbilitySystemComponent that is activating this ability


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, Meta=(DisplayName="GetAbilityLevelNonInstanced", ReturnDisplayName="AbilityLevel")) int32 GetAbilityLevel_BP ( [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) & ActorInfo ) const


description: Returns the actor info associated with this ability, has cached pointers to useful objects


description: Returns the physical actor that is executing this ability. May be null

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) [AActor](API\Runtime\Engine\GameFramework\AActor) * GetAvatarActorFromActorInfo() const


description: Generates a GameplayEffectContextHandle from our owner and an optional TargetData.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) virtual [FGameplayEffectContextHandle](API\Plugins\GameplayAbilities\FGameplayEffectContextHandle) GetContextFromOwner ( [FGameplayAbilityTargetDataHandle](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityTargetDataHandle) OptionalTargetData ) const


description: Returns the gameplay effect used to determine cooldown

code: virtual [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) * GetCooldownGameplayEffect() const


description: Returns the time in seconds remaining on the currently active cooldown and the original duration for this cooldown.

code: virtual void GetCooldownTimeRemainingAndDuration ( [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, float & TimeRemaining, float & CooldownDuration ) const


description: Returns all tags that can put this ability into cooldown

code: virtual const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * GetCooldownTags() const


description: Returns the time in seconds remaining on the currently active cooldown.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) float GetCooldownTimeRemaining() const


code: virtual float GetCooldownTimeRemaining ( const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo ) const


description: Returns the gameplay effect used to apply cost

code: virtual [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) * GetCostGameplayEffect() const


description: Gets the current AbilitySpecHandle- can only be called on instanced abilities.


description: Retrieves the actual AbilitySpec for this ability. Can only be called on instanced abilities.

code: [FGameplayAbilitySpec](API\Plugins\GameplayAbilities\FGameplayAbilitySpec) * GetCurrentAbilitySpec() const


description: Gets the current activation info bound to this ability - can only be called on instanced abilities.


description: Gets the current actor info bound to this ability - can only be called on instanced abilities.

code: const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * GetCurrentActorInfo() const


description: Retrieves the SourceObject associated with this ability. Can only be called on instanced abilities.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) [UObject](API\Runtime\CoreUObject\UObject\UObject) * GetCurrentSourceObject() const


description: Returns the currently playing montage for this ability, if any

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Animation) [UAnimMontage](API\Runtime\Engine\Animation\UAnimMontage) * GetCurrentMontage() const


description:
Return the space this function should be called. Checks to see if this function should be called locally, remotely, or simply absorbed under the given conditions
bitmask representing all callspaces that apply to thisUFunctionin the given context

code: virtual int32 GetFunctionCallspace ( [UFunction](API\Runtime\CoreUObject\UObject\UFunction) * Function, [FFrame](API\Runtime\CoreUObject\UObject\FFrame) * Stack )


description: Get owner of a task or default one when task is null

code: virtual [AActor](API\Runtime\Engine\GameFramework\AActor) * GetGameplayTaskOwner ( const [UGameplayTask](API\Runtime\GameplayTasks\UGameplayTask) * Task ) const


description: Get "body" of task's owner / default, having location in world (e.g. Owner = AIController, Avatar = Pawn)

code: virtual [AActor](API\Runtime\Engine\GameFramework\AActor) * GetGameplayTaskAvatar ( const [UGameplayTask](API\Runtime\GameplayTasks\UGameplayTask) * Task ) const


description: Finds tasks component for given GameplayTask, Task.GetGameplayTasksComponent() may not be initialized at this point!

code: virtual [UGameplayTasksComponent](API\Runtime\GameplayTasks\UGameplayTasksComponent) * GetGameplayTasksComponent ( const [UGameplayTask](API\Runtime\GameplayTasks\UGameplayTask) & Task ) const


description: Retrieves the EffectContext of the GameplayEffect that granted this ability. Can only be called on instanced abilities.


description: Where does an ability execute on the network? Does a client "ask and predict", "ask and wait", "don't ask (just do it)"


description: Returns how the ability is instanced when executed. This limits what an ability can do in its implementation.


description: Where should an ability execute on the network? Provides protection from clients attempting to execute restricted abilities.


description: Returns the actor that owns this ability, which may not have a physical location

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) [AActor](API\Runtime\Engine\GameFramework\AActor) * GetOwningActorFromActorInfo() const


description: How an ability replicates state/events to everyone on the network


description: Retrieves the SourceObject associated with this ability. Callable on non instanced

code: [UObject](API\Runtime\CoreUObject\UObject\UObject) * GetSourceObject ( [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo ) const


description: Convenience method for abilities to get skeletal mesh component - useful for aiming abilities


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, Meta=(DisplayName="GetSourceObjectNonInstanced", ReturnDisplayName="SourceObject")) [UObject](API\Runtime\CoreUObject\UObject\UObject) * GetSourceObject_BP ( [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) & ActorInfo ) const


code: virtual [UWorld](API\Runtime\Engine\Engine\UWorld) * GetWorld() const


description: True if this is the server or single player

code: bool HasAuthority ( const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) * ActivationInfo ) const


description: True if we are authority or we have a valid prediciton key that is expected to work

code: bool HasAuthorityOrPredictionKey ( const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) * ActivationInfo ) const


description: Increases the scope lock count.

code: void IncrementListLock() const


description: Input binding stub.

code: virtual void InputPressed ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo )


description: Input binding stub.

code: virtual void InputReleased ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo )


description: Invalidates the current prediction key. This should be used in cases where there is a valid prediction window, but the server is doing logic that only it can do, and afterwards performs an action that the client could predict (had the client been able to run the server-only code prior). This returns instantly and has no other side effects other than clearing the current prediction key.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) void InvalidateClientPredictionKey() const


description: Returns true if the ability is currently active

code: bool IsActive() const


description: Returns true if this ability is blocking other abilities

code: virtual bool IsBlockingOtherAbilities() const


description: Check if the ability can be ended

code: bool IsEndAbilityValid ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo ) const


description: True if this is on the server and is being executed for a non-local player, false in single player

code: bool IsForRemoteClient() const


description: True if this has been instanced, always true for blueprints

code: bool IsInstantiated() const


description: True if the owning actor is locally controlled, true in single player

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintPure=false, Category=Ability, Meta=(ExpandBoolAsExecs="ReturnValue")) bool IsLocallyControlled() const


description: Is bMarkPendingKillOnAbilityEnd set


description: Is this ability running on a a predicting client, this is false in single player

code: bool IsPredictingClient() const


description: IsSupportedForNetworking means an object can be referenced over the network

code: virtual bool IsSupportedForNetworking() const


description: Is this ability triggered from TriggerData (or is it triggered explicitly through input/game code)

code: bool IsTriggered() const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintImplementableEvent, Category=Ability, DisplayName="ActivateAbilityFromEvent", Meta=(ScriptName="ActivateAbilityFromEvent")) void K2_ActivateAbilityFromEvent ( const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) & EventData )


description: Latent/async actions are ok in this graph. Note that Commit and EndAbility calling requirements speak to the K2_ActivateAbility graph. In C++, the call toK2_ActivateAbility()may return without CommitAbility or EndAbility having been called. But it is expected that this will only occur when latent/async actions are pending. When K2_ActivateAbility logically finishes, then we will expect Commit/End to have been called.


description: Adds a persistent gameplay cue to the ability owner. Optionally will remove if ability ends

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Add GameplayCueWithParams To Owner", Meta=(ScriptName="AddGameplayCueWithParams")) virtual void K2_AddGameplayCueWithParams ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & GameplayCueParameter, bool bRemoveOnAbilityEnd )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Add GameplayCue To Owner", Meta=(ScriptName="AddGameplayCue")) virtual void K2_AddGameplayCue ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [FGameplayEffectContextHandle](API\Plugins\GameplayAbilities\FGameplayEffectContextHandle) Context, bool bRemoveOnAbilityEnd )


description: Apply a previously created gameplay effect spec to the owner of this ability


description: Call from Blueprint to cancel the ability naturally

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="CancelAbility", Meta=(ScriptName="CancelAbility")) void K2_CancelAbility()


description: Returns true if this ability can be activated right now. Has no side effects

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintImplementableEvent, Category=Ability, DisplayName="CanActivateAbility", Meta=(ScriptName="CanActivateAbility")) bool K2_CanActivateAbility ( [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) ActorInfo, const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & RelevantTags ) const


description: Apply a previously created gameplay effect spec to a target


description: Checks the ability's cost, but does not apply it.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="CheckAbilityCost", Meta=(ScriptName="CheckAbilityCost")) virtual bool K2_CheckAbilityCost()


description: Checks the ability's cooldown, but does not apply it.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="CheckAbilityCooldown", Meta=(ScriptName="CheckAbilityCooldown")) virtual bool K2_CheckAbilityCooldown()


description: Fixme: Naming is confusing here

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="CommitAbility", Meta=(ScriptName="CommitAbility")) virtual bool K2_CommitAbility()


description: BP event called from CommitAbility

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintImplementableEvent, Category=Ability, DisplayName="CommitExecute", Meta=(ScriptName="CommitExecute")) void K2_CommitExecute()


description: Attempts to commit the ability's cooldown only. If BroadcastCommitEvent is true, it will broadcast the commit event that tasks like WaitAbilityCommit are listening for.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="CommitAbilityCooldown", Meta=(ScriptName="CommitAbilityCooldown")) virtual bool K2_CommitAbilityCooldown ( bool BroadcastCommitEvent, bool ForceCooldown )


description: Attempts to commit the ability's cost only. If BroadcastCommitEvent is true, it will broadcast the commit event that tasks like WaitAbilityCommit are listening for.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="CommitAbilityCost", Meta=(ScriptName="CommitAbilityCost")) virtual bool K2_CommitAbilityCost ( bool BroadcastCommitEvent )


description: Call from blueprints to forcibly end the ability without canceling it. This will replicate the end ability to the client or server which can interrupt tasks

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="End Ability", Meta=(ScriptName="EndAbility")) virtual void K2_EndAbility()


description: Call from blueprints to end the ability naturally. This will only end predicted abilities locally, allowing it end naturally on the client or server

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, DisplayName="End Ability Locally", Meta=(ScriptName="EndAbilityLocally")) virtual void K2_EndAbilityLocally()


description: Invoke a gameplay cue on the ability owner, with extra parameters

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Execute GameplayCueWithParams On Owner", Meta=(ScriptName="ExecuteGameplayCueWithParams")) virtual void K2_ExecuteGameplayCueWithParams ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & GameplayCueParameters )


description: Helper methods for adding GaAmeplayCues without having to go through GameplayEffects. For now, none of these will happen predictively. We can eventually build this out more to work with the PredictionKey system.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Execute GameplayCue On Owner", Meta=(ScriptName="ExecuteGameplayCue")) virtual void K2_ExecuteGameplayCue ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [FGameplayEffectContextHandle](API\Plugins\GameplayAbilities\FGameplayEffectContextHandle) Context )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintPure=false, Category=Ability, DisplayName="HasAuthority", Meta=(ExpandBoolAsExecs="ReturnValue")) bool K2_HasAuthority() const


description: Blueprint event, will be called if an ability ends normally or abnormally

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintImplementableEvent, Category=Ability, DisplayName="OnEndAbility", Meta=(ScriptName="OnEndAbility")) void K2_OnEndAbility ( bool bWasCancelled )


description: Removes a persistent gameplay cue from the ability owner

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability, Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Remove GameplayCue From Owner", Meta=(ScriptName="RemoveGameplayCue")) virtual void K2_RemoveGameplayCue ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintImplementableEvent, Category=Ability, DisplayName="ShouldAbilityRespondToEvent", Meta=(ScriptName="ShouldAbilityRespondToEvent")) bool K2_ShouldAbilityRespondToEvent ( [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) ActorInfo, [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) Payload ) const


description: Returns an effect context, given a specified actor info

code: virtual [FGameplayEffectContextHandle](API\Plugins\GameplayAbilities\FGameplayEffectContextHandle) MakeEffectContext ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo ) const


description: Convenience method for abilities to get outgoing gameplay effect specs (for example, to pass on to projectiles to apply to whoever they hit)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) [FGameplayEffectSpecHandle](API\Plugins\GameplayAbilities\FGameplayEffectSpecHandle) MakeOutgoingGameplayEffectSpec ( [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) > GameplayEffectClass, float Level ) const


description: Native version of above function

code: virtual [FGameplayEffectSpecHandle](API\Plugins\GameplayAbilities\FGameplayEffectSpecHandle) MakeOutgoingGameplayEffectSpec ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) > GameplayEffectClass, float Level ) const


description: Creates a target location from where the owner avatar is


description: Creates a target location from a socket on the owner avatar's skeletal mesh


description: Immediately jumps the active montage to a section

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Animation") void MontageJumpToSection ( [FName](API\Runtime\Core\UObject\FName) SectionName )


description: Stops the current animation montage.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Animation", Meta=(AdvancedDisplay="OverrideBlendOutTime")) void MontageStop ( float OverrideBlendOutTime )


description: Sets pending section on active montage

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|Animation") void MontageSetNextSectionName ( [FName](API\Runtime\Core\UObject\FName) FromSectionName, [FName](API\Runtime\Core\UObject\FName) ToSectionName )


description: Called to inform the ability that a task is waiting for the player to do something

code: virtual void NotifyAbilityTaskWaitingOnPlayerData ( class [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask) * AbilityTask )


description: Called to inform the ability that a task is waiting for the player's avatar to do something in world

code: virtual void NotifyAbilityTaskWaitingOnAvatar ( class [UAbilityTask](API\Plugins\GameplayAbilities\Abilities\Tasks\UAbilityTask) * AbilityTask )


description: Called to inform the ability that the AvatarActor has been replaced. If the ability is dependent on avatar state, it may want to end itself.

code: virtual void NotifyAvatarDestroyed()


description: Notify called after GameplayTask changes state to Active (initial activation or resuming)

code: virtual void OnGameplayTaskActivated ( [UGameplayTask](API\Runtime\GameplayTasks\UGameplayTask) & Task )


description: Called when the avatar actor is set/changes

code: virtual void OnAvatarSet ( const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilitySpec](API\Plugins\GameplayAbilities\FGameplayAbilitySpec) & Spec )


description: Notify called after GameplayTask finishes initialization (not active yet)

code: virtual void OnGameplayTaskInitialized ( [UGameplayTask](API\Runtime\GameplayTasks\UGameplayTask) & Task )


description: Notify called after GameplayTask changes state from Active (finishing or pausing)

code: virtual void OnGameplayTaskDeactivated ( [UGameplayTask](API\Runtime\GameplayTasks\UGameplayTask) & Task )


description: Called when the ability is given to an AbilitySystemComponent

code: virtual void OnGiveAbility ( const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilitySpec](API\Plugins\GameplayAbilities\FGameplayAbilitySpec) & Spec )


description: Called when the ability is removed from an AbilitySystemComponent

code: virtual void OnRemoveAbility ( const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilitySpec](API\Plugins\GameplayAbilities\FGameplayAbilitySpec) & Spec )


description: Called from AbilityTask_WaitConfirmCancel to handle input confirming


description: Called to initialize after being created due to replication

code: virtual void PostNetInit()


description: Do boilerplate init stuff and then call ActivateAbility

code: virtual void PreActivate ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, FOnGameplayAbilityEnded::FDelegate * OnGameplayAbilityEndedDelegate, const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * TriggerEventData )


description: Sends a gameplay event, also creates a prediction window

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) virtual void SendGameplayEvent ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) EventTag, [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) Payload )


description: Sets whether the ability should ignore cancel requests. Only valid on instanced abilities

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) virtual void SetCanBeCanceled ( bool bCanBeCanceled )


description: Modifies activation info, only safe on instanced abilities

code: virtual void SetCurrentActivationInfo ( const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo )


description: Modifies actor info, only safe on instanced abilities

code: virtual void SetCurrentActorInfo ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo ) const


description: Sets both actor and activation info

code: void SetCurrentInfo ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo )


description: Call to set/get the current montage from a montage task. Set to allow hooking up montage events to ability events

code: virtual void SetCurrentMontage ( class [UAnimMontage](API\Runtime\Engine\Animation\UAnimMontage) * InCurrentMontage )


description: Setter for the bMarkPendingKillOnAbilityEnd

code: void SetMarkPendingKillOnAbilityEnd ( bool bInMarkPendingKillOnAbilityEnd )


description: Movement Sync

code: virtual void SetMovementSyncPoint ( [FName](API\Runtime\Core\UObject\FName) SyncName )


description: Sets rather ability block flags are enabled or disabled. Only valid on instanced abilities

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) virtual void SetShouldBlockOtherAbilities ( bool bShouldBlockAbilities )


description: Called by ability system component to inform this ability instance the remote instance was ended


description: Returns true if this ability can be triggered right now. Has no side effects

code: virtual bool ShouldAbilityRespondToEvent ( const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * Payload ) const


description: Removes the GameplayEffect that granted this ability. Can only be called on instanced abilities.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=Ability) virtual void RemoveGrantedByEffect()


description: Returns true if an an ability should be activated

code: virtual bool ShouldActivateAbility ( ENetRole Role ) const


description: Takes in the ability spec and checks if we should allow replication on the ability spec, this will NOT stop replication of the abilityUObjectjust the spec inside the UAbilitySystemComponenet ActivatableAbilities for this ability

code: virtual bool ShouldReplicateAbilitySpec ( const [FGameplayAbilitySpec](API\Plugins\GameplayAbilities\FGameplayAbilitySpec) & AbilitySpec ) const


code: UGameplayAbility ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UGameplayAbility

description: This ability has these tags |

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable) class UGameplayAbility : public [UObject](API\Runtime\CoreUObject\UObject\UObject), public [IGameplayTaskOwnerInterface](API\Runtime\GameplayTasks\IGameplayTaskOwnerInterface)

AbilityTags

description: Public variables, exposed for backwards compatibility


description: Actually activate ability, do not call this directly

code: virtual void ActivateAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * TriggerEventData )


description: Returns true if this ability can be activated right now. Has no side effects

code: virtual bool CanActivateAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * SourceTags, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * TargetTags, [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) * OptionalRelevantTags ) const


description: Canceling an non instanced ability is tricky. Right now this works for Jump since there is nothing that can go wrong by calling StopJumping() if you aren't already jumping. If we had a montage playing non instanced ability, it would need to make sure the Montage thatitplayed was still playing, and if so, to cancel it. If this is something we need to support, we may need some light weight data structure to represent 'non intanced abilities in action' with a way to cancel/end them.

code: virtual void CancelAbility ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo, bool bReplicateCancelAbility )


description: Input binding stub.

code: virtual void InputReleased ( const [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) Handle, const [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, const [FGameplayAbilityActivationInfo](API\Plugins\GameplayAbilities\FGameplayAbilityActivationInfo) ActivationInfo )


description: Ability that jumps with a character.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UGameplayAbility_CharacterJump : public [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility)


code: UGameplayAbility_CharacterJump ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


code: void GetGameplayEffectsWhileAnimating ( [TArray](API\Runtime\Core\Containers\TArray)< const [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) * > & OutEffects ) const


code: void OnMontageEnded ( [UAnimMontage](API\Runtime\Engine\Animation\UAnimMontage) * Montage, bool bInterrupted, [TWeakObjectPtr](API\Runtime\Core\UObject\TWeakObjectPtr)< [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) > AbilitySystemComponent, [TArray](API\Runtime\Core\Containers\TArray)< struct [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) > AppliedEffects )


code: UGameplayAbility_Montage ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


description: A gameplay ability that plays a single montage and applies a GameplayEffect

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UGameplayAbility_Montage : public [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility)

GameplayEffectClassesWhileAnimating

type: TArray<TSubcla...

description: GameplayEffects to apply and then remove while the animation is playing

GameplayEffectsWhileAnimating

type: TArray<TObject...

description: Deprecated. Use GameplayEffectClassesWhileAnimating instead.

MontageToPlay

type: TObjectPtr<UAn...

SectionName

type: FName


description: Overridable native event for when play begins for this actor.

code: virtual void BeginPlay()


code: void ClearOwnerDestroyedDelegate()


description: Called when this actor is explicitly being destroyed during gameplay or in the editor, not called during level streaming or gameplay ending

code: virtual void Destroyed()


description: Overridable function called whenever this actor is being removed from a level

code: virtual void EndPlay ( const [EEndPlayReason::Type](API\Runtime\Engine\Engine\EEndPlayReason__Type) EndPlayReason )


description: Called when the GC is finished. It may be about to go back to the recyle pool, or it may be about to be destroyed.


code: virtual bool GameplayCuePendingRemove()


code: virtual void HandleGameplayCue ( [AActor](API\Runtime\Engine\GameFramework\AActor) * MyTarget, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


description: Does this GameplayCueNotify handle this type of GameplayCueEvent?

code: virtual bool HandlesEvent ( [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType ) const


description: Destroy the actor

code: virtual void K2_DestroyActor()