code: void SetReplicatedLooseGameplayTagCount ( const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) & GameplayTag, int32 NewCount )


description: When true, we will not replicate active gameplay effects for this ability system component, so attributes and tags

module: GameplayAbilities

code: virtual void SetReplicationMode ( [EGameplayEffectReplicationMode](API\Plugins\GameplayAbilities\EGameplayEffectReplicationMode) NewReplicationMode )


description: Remove all current AttributeSets and register the ones in the passed array. Note that it's better to call Add/Remove directly when possible.

code: void SetSpawnedAttributes ( const [TArray](API\Runtime\Core\Containers\TArray)< [UAttributeSet](API\Plugins\GameplayAbilities\UAttributeSet) * > & NewAttributeSet )


code: void SetServerDebugStrings ( [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > && NewServerDebugStrings )


description: Forcibly sets the number of instances of a given tag

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


description: Disable or Enable a local user from being able to activate abilities. This should only be used for input/UI etc related inhibition. Do not use for game mechanics.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Abilities") virtual void SetUserAbilityActivationInhibited ( bool NewInhibit )


code: virtual bool ShouldDoServerAbilityRPCBatch() const


description: Determines whether to call ServerPrintDebug_Request or ServerPrintDebug_RequestWithStrings.

code: virtual bool ShouldSendClientDebugStringsToServer() const


description: Returns true if this component should record montage replication info.

code: virtual bool ShouldRecordMontageReplication() const


description: Stops current montage if it's the one given as the Montage param

code: virtual void StopMontageIfCurrent ( const [UAnimMontage](API\Runtime\Engine\Animation\UAnimMontage) & Montage, float OverrideBlendOutTime )


description: Any active targeting actors will be stopped and canceled, not returning any targeting data

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Abilities") virtual void TargetCancel()


description: Any active targeting actors will be told to stop and return current targeting data

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Abilities") virtual void TargetConfirm()


description: Function called every frame on this ActorComponent. Override this function to implement custom logic to be executed every frame. Only executes if the component is registered, and also PrimaryComponentTick.bCanEverTick must be set to true.

code: virtual void TickComponent ( float DeltaTime, enum ELevelTick TickType, [FActorComponentTickFunction](API\Runtime\Engine\Engine\FActorComponentTickFunction) * ThisTickFunction )


description: Triggers an ability from a gameplay event, will only trigger on local/server depending on execution flags

code: bool TriggerAbilityFromGameplayEvent ( [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) AbilityToTrigger, [FGameplayAbilityActorInfo](API\Plugins\GameplayAbilities\Abilities\FGameplayAbilityActorInfo) * ActorInfo, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, const [FGameplayEventData](API\Plugins\GameplayAbilities\Abilities\FGameplayEventData) * Payload, [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) & Component )


description: Attempts to activate every gameplay ability that matches the given tag and DoesAbilitySatisfyTagRequirements(). Returns true if anything attempts to activate. Can activate more than one ability and the ability may fail later. If bAllowRemoteActivation is true, it will remotely activate local/server abilities, if false it will only try to locally activate abilities.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Abilities") bool TryActivateAbilitiesByTag ( const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GameplayTagContainer, bool bAllowRemoteActivation )


description: Attempts to activate the given ability, will check costs and requirements before doing so. Returns true if it thinks it activated, but it may return false positives due to failure later in activation. If bAllowRemoteActivation is true, it will remotely activate local/server abilities, if false it will only try to locally activate the ability

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Abilities") bool TryActivateAbility ( [FGameplayAbilitySpecHandle](API\Plugins\GameplayAbilities\FGameplayAbilitySpecHandle) AbilityToActivate, bool bAllowRemoteActivation )


description: Attempts to activate the ability that is passed in. This will check costs and requirements before doing so. Returns true if it thinks it activated, but it may return false positives due to failure later in activation. If bAllowRemoteActivation is true, it will remotely activate local/server abilities, if false it will only try to locally activate the ability

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Abilities") bool TryActivateAbilityByClass ( [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UGameplayAbility](API\Plugins\GameplayAbilities\Abilities\UGameplayAbility) > InAbilityToActivate, bool bAllowRemoteActivation )


description: Block or cancel blocking for specific ability tags

code: void UnBlockAbilitiesWithTags ( const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & Tags )


description: Handle this component being Uninitialized. Called fromAActor::EndPlayonly if bHasBeenInitialized is true

code: virtual void UninitializeComponent()


description: Unregister previously added events

code: bool UnregisterGameplayTagEvent ( [FDelegateHandle](API\Runtime\Core\Delegates\FDelegateHandle) DelegateHandle, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, [EGameplayTagEventType::Type](API\Plugins\GameplayAbilities\EGameplayTagEventType__Type) EventType )


description: Block or cancel blocking for specific input IDs

code: void UnBlockAbilityByInputID ( int32 InputID )


description: Dynamically update the set-by-caller magnitude for an active gameplay effect

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintAuthorityOnly, Category=GameplayEffects) virtual void UpdateActiveGameplayEffectSetByCallerMagnitude ( [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) ActiveHandle, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) SetByCallerTag, float NewValue )


description: Dynamically update multiple set-by-caller magnitudes for an active gameplay effect

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintAuthorityOnly, Category=GameplayEffects) virtual void UpdateActiveGameplayEffectSetByCallerMagnitudes ( [FActiveGameplayEffectHandle](API\Plugins\GameplayAbilities\FActiveGameplayEffectHandle) ActiveHandle, const [TMap](API\Runtime\Core\Containers\TMap)< [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag), float > & NewSetByCallerValues )


description: Update the number of instances of a given tag and calls callback

code: void UpdateTagMap ( const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) & BaseTag, int32 CountDelta )


code: void UpdateTagMap ( const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & Container, int32 CountDelta )


code: void UpdateTagMap_Internal ( const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & Container, int32 CountDelta )


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


description: Builds an array of strings to render for Ability System actor

code: virtual void GetDebugStrings ( const [AActor](API\Runtime\Engine\GameFramework\AActor) * Actor, const [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * Comp, [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & OutDebugStrings ) const


description: Returns whether this extension should be rendered for each actor

code: virtual bool IsEnabled() const


className: UAbilitySystemDebugHUDExtension

description: An extension for the Ability System debug HUD Extensions should be used for displaying information on screen for each Ability System Actor

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract) class UAbilitySystemDebugHUDExtension : public [UObject](API\Runtime\CoreUObject\UObject\UObject)


className: UAbilitySystemComponent

description: The core ActorComponent for interfacing with the GameplayAbilities System

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(ClassGroup=AbilitySystem, HideCategories=(Object, LOD, Lighting, Transform, Sockets, TextureStreaming), EditInlineNew, Meta=(BlueprintSpawnableComponent)) class UAbilitySystemComponent : public [UGameplayTasksComponent](API\Runtime\GameplayTasks\UGameplayTasksComponent), public [IGameplayTagAssetInterface](API\Runtime\GameplayTags\IGameplayTagAssetInterface), public [IAbilitySystemReplicationProxyInterface](API\Plugins\GameplayAbilities\IAbilitySystemReplicationProxyIn-)

AbilityActivatedCallbacks

type: FGenericAbility...

description: A generic callback anytime an ability is activated (started)

AbilityActorInfo

type: TSharedPtr<FGa...

description: Cached off data about the owning actor that abilities will need to frequently access (movement component, mesh component, anim instance, etc)

AbilityCommittedCallbacks

description: A generic callback anytime an ability is committed (cost/cooldown applied)

AbilityEndedCallbacks

type: FAbilityEnded

description: Callback anytime an ability is ended

AbilityFailedCallbacks

type: FAbilityFailedD...

description: Called with a failure reason when an ability fails to activate

AbilityLastActivatedTime

type: float

description: Local World time of the last ability activation. This is used for AFK/idle detection

AbilityListLockActiveChanges

type: TArray<FAbilit...

AbilityPendingAdds

type: TArray<FGamepl...

AbilitySpecDirtiedCallbacks

type: FAbilitySpecDir...

description: Called when an ability spec's internals have changed

AbilityTargetDataMap

type: FGameplayAbilit...

description: Maps from an ability spec to the target data. Used to track replicated data and callbacks

ActivatableAbilities

description: The abilities we can activate.

ActiveGameplayCues

type: FActiveGameplay...

description: List of all active gameplay cues, including ones applied manually

ActiveGameplayEffects

description: Contains all of the gameplay effects that are currently active on this component

AffectedAnimInstanceTag

type: FName

description: The linked Anim Instance that this component will play montages in.

bCachedIsNetSimulated

type: bool

description: Cached value of rather this is a simulated actor

BlockedAbilityTags

type: FGameplayTagCou...

description: Abilities with these tags are not able to be activated

bPendingMontageRep

description: Set if montage rep happens while we don't have the animinstance associated with us yet

bSuppressGameplayCues

description: Suppress all GameplayCues on this component

bSuppressGrantAbility

description: Suppress all ability granting through GEs on this component

DefaultStartingData

type: TArray<FAttrib...

GameplayEffectApplicationQueries

description: We allow users to setup a series of functions that must be true in order to allow a GameplayEffect to be applied

GameplayEventTagContainerDelegates

type: TArray< TPair< ...

description: List of gameplay tag container filters, and the delegates they call

GameplayEventTriggeredAbilities

type: TMap<FGameplay...

description: Abilities that are triggered from a gameplay event

GameplayTagCountContainer

description: Acceleration map for all gameplay tags (OwnedGameplayTags from GEs and explicit GameplayCueTags)

GenericConfirmInputID

description: InputID for binding GenericConfirm/Cancel events

GenericGameplayEventCallbacks

description: Callbacks bound to Gameplay tags, these only activate if the exact tag is used.

GenericLocalCancelCallbacks

type: FAbilityConfirm...

description: Generic local callback for generic CancelEvent that any ability can listen to

GenericLocalConfirmCallbacks

description: Generic local callback for generic ConfirmEvent that any ability can listen to

IncomingDuration

description: Internal Attribute that modifies the duration of gameplay effects applied to this component

InternalTryActivateAbilityFailureTags

type: FGameplayTagCon...

description: Failure tags used by InternalTryActivateAbility (E.g., this stores the FailureTags of the last call to InternalTryActivateAbility

LocalAnimMontageInfo

description: Data structure for montages that were instigated locally (everything if server, predictive if client. replicated if simulated proxy)

LocalServerAbilityRPCBatchData

type: TArray<FServer...

description: Accumulated client side data that is batched out to server on EndServerAbilityRPCBatch

MinimalReplicationGameplayCues

description: Replicated gameplaycues when in minimal replication mode.

OnAbilityEnded

description: Callback anytime an ability is ended, with extra information

type: FOnGameplayEffe...

description: Called on both client and server whenever a duraton based GE is added (E.g., instant GEs do not trigger this).

OnGameplayEffectAppliedDelegateToSelf

description: Called on server whenever a GE is applied to self. This includes instant and duration based GEs.

OnGameplayEffectAppliedDelegateToTarget

description: Called on server whenever a GE is applied to someone else.

OnImmunityBlockGameplayEffectDelegate

type: FImmunityBlockG...

description: Immunity notification support

description: Called on server whenever a periodic GE executes on self

description: Called on server whenever a periodic GE executes on target

OutgoingDuration

description: System Attributes

OwnedTagTriggeredAbilities

description: Abilities that are triggered from a tag being added to the owner

PendingServerActivatedAbilities

type: TArray<FPendin...

description: This is a list of GameplayAbilities that were activated on the server and can't yet execute on the client.

ReplicatedPredictionKeyMap

type: FReplicatedPred...

description: PredictionKeys, see more info in GameplayPrediction.h.

ReplicationMode

type: EGameplayEffect...

description: How gameplay effects are replicated

ReplicationProxyEnabled

description: When enabled GameplayCue RPCs will be routed through the AvatarActor'sIAbilitySystemReplicationProxyInterfacerather than this component

ScopedPredictionKey

type: FPredictionKey

description: Current prediction key, set withFScopedPredictionWindow

SpawnedTargetActors

type: TArray<TObject...

description: List of currently active targeting actors

UserAbilityActivationInhibited

description: Rather activation is currently inhibited


code: static void ClearDisplayedAttributes ( const [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & Args, [UWorld](API\Runtime\Engine\Engine\UWorld) * World )


code: static void ToggleExtension ( const [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & Args, [UWorld](API\Runtime\Engine\Engine\UWorld) * World )


code: static void ToggleIncludeModifiers()


description: Ability System Debug HUD extension for drawing attributes of an actor


description: Ability System Debug HUD extension for drawing all blocked ability tags on an actor


description: Ability System Debug HUD extension for drawing all owned tags by an actor


code: void AddAttributeDefaultTables ( const [TArray](API\Runtime\Core\Containers\TArray)< [FSoftObjectPath](API\Runtime\CoreUObject\UObject\FSoftObjectPath) > & AttribDefaultTableNames )


description: Add a path to the GameplayCueNotifyPaths array.

code: virtual void AddGameplayCueNotifyPath ( const [FString](API\Runtime\Core\Containers\FString) & InPath )


description: Should allocate a project specific AbilityActorInfo struct. Caller is responsible for deallocation

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


description: InitializeFAttributeSetInitter. This is virtual so projects can override what class they use

code: virtual void AllocAttributeSetInitter()


description: Should allocate a project specific GameplayEffectContext struct. Caller is responsible for deallocation

code: virtual [FGameplayEffectContext](API\Plugins\GameplayAbilities\FGameplayEffectContext) * AllocGameplayEffectContext() const


code: void AutomationTestOnly_SetGlobalAttributeDataTable ( [UDataTable](API\Runtime\Engine\Engine\UDataTable) * InTable )


description: Sets a default gameplay cue tag using the asset's name. Returns true if it changed the tag.

code: static bool DeriveGameplayCueTagFromAssetName ( [FString](API\Runtime\Core\Containers\FString) AssetName, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) & GameplayCueTag, [FName](API\Runtime\Core\UObject\FName) & GameplayCueName )


description: Builds an array of strings to render for Ability System actor


description: Sets a default gameplay cue tag using the asset's class

code: template<class T> static void DeriveGameplayCueTagFromClass ( T * CDO )


className: FOnClientServerDebugAvailable

description: Called when debug strings are available, to write them to the display

code: typedef TMulticastDelegate_NoParams< void > FOnClientServerDebugAvailable


description: Allows projects to override PostEditChangeProeprty on GEs without having to subclass Gameplayeffect. Intended for validation/auto populating based on changed data.

code: virtual void GameplayEffectPostEditChangeProperty ( class [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) * GE, [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: Gets the single instance of the globals object, will create it as necessary

code: static [UAbilitySystemGlobals](API\Plugins\GameplayAbilities\UAbilitySystemGlobals) & Get()


description: Helping function to avoid having to manually cast

code: static [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * GetAbilitySystemComponentFromActor ( const [AActor](API\Runtime\Engine\GameFramework\AActor) * Actor, bool LookForComponent )


description: Returns data used to initialize attributes to their default values

code: [FAttributeSetInitter](API\Plugins\GameplayAbilities\FAttributeSetInitter) * GetAttributeSetInitter() const


description: Searches the passed in class to look for aUFunctionimplementing the gameplay cue tag, sets MatchedTag to the exact tag found

code: [UFunction](API\Runtime\CoreUObject\UObject\UFunction) * GetGameplayCueFunction ( const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) & Tag, [UClass](API\Runtime\CoreUObject\UObject\UClass) * Class, [FName](API\Runtime\Core\UObject\FName) & MatchedTag )


description: Returns the gameplay cue manager singleton object, creating if necessary

code: virtual [UGameplayCueManager](API\Plugins\GameplayAbilities\UGameplayCueManager) * GetGameplayCueManager()


description: Path where the engine will load gameplay cue notifies from

code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > GetGameplayCueNotifyPaths()


description: Simple channel-based accessor to the alias name for the specified gameplay mod evaluation channel, if any

code: const [FName](API\Runtime\Core\UObject\FName) & GetGameplayModEvaluationChannelAlias ( [EGameplayModEvaluationChannel](API\Plugins\GameplayAbilities\EGameplayModEvaluationChannel) Channel ) const


description: Simple index-based accessor to the alias name for the specified gameplay mod evaluation channel, if any

code: const [FName](API\Runtime\Core\UObject\FName) & GetGameplayModEvaluationChannelAlias ( int32 Index ) const


description: Returns the gameplay tag response object, creating if necessary


description: Returns the data table defining attribute metadata (NOTE: Currently not in use)


description: Returns the globally registered curve table


description: Global callback that can handle game-specific code that needs to run before applying a gameplay effect spec

code: virtual void GlobalPreGameplayEffectSpecApply ( [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec, [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * AbilitySystemComponent )


code: void HandlePreLoadMap ( const [FWorldContext](API\Runtime\Engine\Engine\FWorldContext) & WorldContext, const [FString](API\Runtime\Core\Containers\FString) & MapName )


code: virtual void InitAttributeDefaults()


description: Initialize GameplayCue Parameters

code: virtual void InitGameplayCueParameters ( [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & CueParameters, const [FGameplayEffectSpecForRPC](API\Plugins\GameplayAbilities\FGameplayEffectSpecForRPC) & Spec )


description: Initialize GameplayCue Parameters

code: virtual void InitGameplayCueParameters_GESpec ( [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & CueParameters, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec )


description: Initialize GameplayCue Parameters

code: virtual void InitGameplayCueParameters ( [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & CueParameters, const [FGameplayEffectContextHandle](API\Plugins\GameplayAbilities\FGameplayEffectContextHandle) & EffectContext )


description: Will be called once on first use to load global data tables and tags (see FGameplayAbilitiesModule::GetAbilitySystemGlobals)

code: virtual void InitGlobalData()


description: Initialize global tags by reading from config using the names and creating tags for use at runtime

code: virtual void InitGlobalTags()


code: void InitTargetDataScriptStructCache()


code: template<class T> T * InternalGetLoadTable ( T *& Table, [FString](API\Runtime\Core\Containers\FString) TableName )


description: Returns true if InitGlobalData has been called


description: Returns whether the specified gameplay mod evaluation channel is valid for use or not. Considers whether channel usage is allowed at all, as well as if the specified channel has a valid alias for the game.

code: bool IsGameplayModEvaluationChannelValid ( [EGameplayModEvaluationChannel](API\Plugins\GameplayAbilities\EGameplayModEvaluationChannel) Channel ) const


description: Show all abilities currently assigned to the local player

code: void ListPlayerAbilities()


description: Helper functions for applying global scaling to various ability system tasks. This isn't meant to be a shipping feature, but to help with debugging and interation via cvar AbilitySystem.GlobalAbilityScale

code: static void NonShipping_ApplyGlobalAbilityScaler_Rate ( float & Rate )


code: static void NonShipping_ApplyGlobalAbilityScaler_Duration ( float & Duration )


code: void Notify_FindAssetInEditor ( [FString](API\Runtime\Core\Containers\FString) AssetName, int AssetType )


code: void OnPreBeginPIE ( const bool bIsSimulatingInEditor )


description: To add functionality for opening assets directly from the game.

code: void Notify_OpenAssetInEditor ( [FString](API\Runtime\Core\Containers\FString) AssetName, int AssetType )


code: void OnTableReimported ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * InObject )


code: virtual void PopCurrentAppliedGE()


description: Override to handle global state when gameplay effects are being applied

code: virtual void PushCurrentAppliedGE ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) * Spec, [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * AbilitySystemComponent )


code: virtual void ReloadAttributeDefaults()


description:
Remove the given gameplay cue notify path from the GameplayCueNotifyPaths array.
Number of paths removed.

code: virtual int32 RemoveGameplayCueNotifyPath ( const [FString](API\Runtime\Core\Containers\FString) & InPath )


description: Force server cancellation of a specific player ability (useful for cheat testing)

code: void ServerCancelPlayerAbility ( [FString](API\Runtime\Core\Containers\FString) AbilityNameMatch )


description: Force server activation of a specific player ability (useful for cheat testing)

code: void ServerActivatePlayerAbility ( [FString](API\Runtime\Core\Containers\FString) AbilityNameMatch )


description: Force server deactivation of a specific player ability (useful for cheat testing)

code: void ServerEndPlayerAbility ( [FString](API\Runtime\Core\Containers\FString) AbilityNameMatch )


code: virtual void SetCurrentAppliedGE ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) * Spec )


description: Simple accessor to whether gameplay modifier evaluation channels should be allowed or not


description: Returns true if ability cooldowns are ignored, returns false otherwise. Always returns false in shipping builds.

code: bool ShouldIgnoreCooldowns() const


description: Returns true if ability costs are ignored, returns false otherwise. Always returns false in shipping builds.

code: bool ShouldIgnoreCosts() const


description: Returns true if the ability system should try to predict gameplay effects applied to non local targets


description: Returns true if tags granted to owners from ability activations should be replicated


description: Trigger async loading of the gameplay cue object libraries.Bydefault, the manager will do this on creation, but that behavior can be changed by a derived class overriding ShouldAsyncLoadObjectLibrariesAtStart and returning false. In that case, this function must be called to begin the load


description: Toggles whether we should ignore ability cooldowns. Does nothing in shipping builds


description: Toggles whether we should ignore ability costs. Does nothing in shipping builds


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


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


className: UAbilitySystemInterface

description: Interface for actors that expose access to an ability system component

code: class UAbilitySystemInterface : public [UInterface](API\Runtime\CoreUObject\UObject\UInterface)


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


className: UAbilitySystemReplicationProxyInterface

description: Interface for actors that act like an ability system component for replication. This can be used to group together different components for replication

code: class UAbilitySystemReplicationProxyInterface : public [UInterface](API\Runtime\CoreUObject\UObject\UInterface)


description: Called just before a GameplayEffect is executed to modify the base value of an attribute. No more changes can be made. Note this is only called during an 'execute'. E.g., a modification to the 'base value' of an attribute. It is not called during an application of a GameplayEffect, such as a 5 ssecond +10 movement speed buff.

code: virtual void PostGameplayEffectExecute ( const struct [FGameplayEffectModCallbackData](API\Plugins\GameplayAbilities\FGameplayEffectModCallbackData) & Data )


description: Called just before modifying the value of an attribute. AttributeSet can make additional modifications here. Return true to continue, or false to throw out the modification. Note this is only called during an 'execute'. E.g., a modification to the 'base value' of an attribute. It is not called during an application of a GameplayEffect, such as a 5 ssecond +10 movement speed buff.

code: virtual bool PreGameplayEffectExecute ( struct [FGameplayEffectModCallbackData](API\Plugins\GameplayAbilities\FGameplayEffectModCallbackData) & Data )


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


code: virtual bool CanBePlaced ( [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation ) const


description: Deprecated* Please use the other Notify function instead

code: virtual void Notify ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation, const [FAnimNotifyEventReference](API\Runtime\Engine\Animation\FAnimNotifyEventReference) & EventReference )


className: UAbilitySystemTestAttributeSet

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, BlueprintType, Meta=(HideInDetailsView)) class UAbilitySystemTestAttributeSet : public [UAttributeSet](API\Plugins\GameplayAbilities\UAttributeSet)

ArmorDamageReduction

type: float

Damage

description: This Damage is just used for applying negative health mods. Its not a 'persistent' attribute.

MaxHealth

description: NOTE ON MUTABLE: This is only done so thatUAbilitySystemTestAttributeSetcan be initialized directly in GameplayEffectsTest.cpp without doing a const_cast in 100+ places.

PhysicalDamage

description: This Attribute is the actual physical damage for this actor.

SpellDamage

description: This Attribute is the actual spell damage for this actor. It will power spell based GameplayEffects


description: An animation notify used for instantaneous gameplay cues (Burst/Latent).

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(EditInlineNew, Const, HideCategories=Object, CollapseCategories, MinimalAPI, Meta=(DisplayName="GameplayCue (Burst)")) class UAnimNotify_GameplayCue : public [UAnimNotify](API\Runtime\Engine\Animation\AnimNotifies\UAnimNotify)

GameplayCue

type: FGameplayCueTag

description: GameplayCue tag to invoke.


description: Deprecated* Please use the other NotifyBegin function instead

code: virtual void NotifyBegin ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation, float TotalDuration )


code: virtual void NotifyBegin ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation, float TotalDuration, const [FAnimNotifyEventReference](API\Runtime\Engine\Animation\FAnimNotifyEventReference) & EventReference )


code: virtual void Notify ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation )


description: Deprecated* Please use the other NotifyEnd function instead

code: virtual void NotifyEnd ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation )


code: virtual void NotifyEnd ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation, const [FAnimNotifyEventReference](API\Runtime\Engine\Animation\FAnimNotifyEventReference) & EventReference )


description: Deprecated* Please use the other NotifyTick function instead

code: virtual void NotifyTick ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation, float FrameDeltaTime )


code: virtual void NotifyTick ( [USkeletalMeshComponent](API\Runtime\Engine\Components\USkeletalMeshComponent) * MeshComp, [UAnimSequenceBase](API\Runtime\Engine\Animation\UAnimSequenceBase) * Animation, float FrameDeltaTime, const [FAnimNotifyEventReference](API\Runtime\Engine\Animation\FAnimNotifyEventReference) & EventReference )


description: An animation notify state used for duration based gameplay cues (Looping).

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(EditInlineNew, Const, HideCategories=Object, CollapseCategories, MinimalAPI, Meta=(DisplayName="GameplayCue (Looping)")) class UAnimNotify_GameplayCueState : public [UAnimNotifyState](API\Runtime\Engine\Animation\AnimNotifies\UAnimNotifyState)

description: GameplayCue tag to invoke.

PreviewProxyTick

type: FGameplayCuePro...


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


description: Gets information about owning actor

code: [AActor](API\Runtime\Engine\GameFramework\AActor) * GetOwningActor() const


description: Initializes attribute data from a meta DataTable

code: virtual void InitFromMetaDataTable ( const [UDataTable](API\Runtime\Engine\Engine\UDataTable) * DataTable )


description: IsNameStableForNetworking means an object can be referred to its path name (relative to outer) over the network

code: virtual bool IsNameStableForNetworking() const


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

code: virtual bool IsSupportedForNetworking() const


description: Callback for when anFAggregatoris created for an attribute in this set. Allows custom setup ofFAggregator::EvaluationMetaData

code: virtual void OnAttributeAggregatorCreated ( const [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) & Attribute, [FAggregator](API\Plugins\GameplayAbilities\FAggregator) * NewAggregator ) const


description: Called just after any modification happens to an attribute's base value when an attribute aggregator exists.

code: virtual void PostAttributeBaseChange ( const [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) & Attribute, float OldValue, float NewValue ) const


description: Called just after any modification happens to an attribute.

code: virtual void PostAttributeChange ( const [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) & Attribute, float OldValue, float NewValue )


description: Called just before a GameplayEffect is executed to modify the base value of an attribute. No more changes can be made. Note this is only called during an 'execute'. E.g., a modification to the 'base value' of an attribute. It is not called during an application of a GameplayEffect, such as a 5 ssecond +10 movement speed buff.

code: virtual void PostGameplayEffectExecute ( const struct [FGameplayEffectModCallbackData](API\Plugins\GameplayAbilities\FGameplayEffectModCallbackData) & Data )


description: Called right after receiving a bunch

code: virtual void PostNetReceive()


description: NewValue is a mutable reference so you are able to clamp the newly applied value as well.

code: virtual void PreAttributeChange ( const [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) & Attribute, float & NewValue )


description: This is called just before any modification happens to an attribute's base value when an attribute aggregator exists. This function should enforce clamping (presuming you wish to clamp the base value along with the final value in PreAttributeChange) This function should NOT invoke gameplay related events or callbacks. Do those inPreAttributeChange()which will be called prior to the final value of the attribute actually changing.

code: virtual void PreAttributeBaseChange ( const [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) & Attribute, float & NewValue ) const


description: Called right before receiving a bunch

code: virtual void PreNetReceive()


description: Called just before modifying the value of an attribute. AttributeSet can make additional modifications here. Return true to continue, or false to throw out the modification. Note this is only called during an 'execute'. E.g., a modification to the 'base value' of an attribute. It is not called during an application of a GameplayEffect, such as a 5 ssecond +10 movement speed buff.

code: virtual bool PreGameplayEffectExecute ( struct [FGameplayEffectModCallbackData](API\Plugins\GameplayAbilities\FGameplayEffectModCallbackData) & Data )


description: Print debug information to the log

code: virtual void PrintDebug()


description: This signifies the attribute set can be ID'd by name over the network.

code: void SetNetAddressable()


description: Override to disable initialization for specific properties

code: virtual bool ShouldInitProperty ( bool FirstInit, [FProperty](API\Runtime\CoreUObject\UObject\FProperty) * PropertyToInit ) const


className: UAttributeSet

description: Defines the set of all GameplayAttributes for your game Games should subclass this and addFGameplayAttributeDataproperties to represent attributes like health, damage, etc AttributeSets are added to the actors as subobjects, and then registered with the AbilitySystemComponent It often desired to have several sets per project that inherit from each other You could make a base health set, then have a player set that inherits from it and adds more attributes

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

bNetAddressable

type: uint32:  1

description: Is this attribute set safe to ID over the network by name?


description: Returns the most base gameplay ability blueprint for a given blueprint (if it is inherited from another ability blueprint, returning null if only native / non-ability BP classes are it's parent)

code: static [UGameplayAbilityBlueprint](API\Plugins\GameplayAbilities\UGameplayAbilityBlueprint) * FindRootGameplayAbilityBlueprint ( [UGameplayAbilityBlueprint](API\Plugins\GameplayAbilities\UGameplayAbilityBlueprint) * DerivedBlueprint )


description: Should the generic blueprint factory work for this blueprint?

code: virtual bool SupportedByDefaultBlueprintFactory() const


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


className: UGameplayAbilityBlueprint

description: A Gameplay Ability Blueprint is essentially a specialized Blueprint whose graphs control a gameplay ability The ability factory should pick this for you automatically

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType) class UGameplayAbilityBlueprint : public [UBlueprint](API\Runtime\Engine\Engine\UBlueprint)


code: void GiveAbilities ( [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * AbilitySystemComponent ) const


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


className: UGameplayAbilitySet

description: This is an example DataAsset that could be used for defining a set of abilities to give to an AbilitySystemComponent and bind to an input command. Your project is free to implement this however it wants!

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UGameplayAbilitySet : public [UDataAsset](API\Runtime\Engine\Engine\UDataAsset)

Abilities

type: TArray<FGamepl...


description: Invoke the added event for a gameplay cue on the target actor. This should be paired with a RemoveGameplayCueOnActor call.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="GameplayCue", Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Add GameplayCue On Actor (Looping)") static void AddGameplayCueOnActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


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


description: Builds gameplay cue parameters using data from a hit result.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintPure, Category="GameplayCue") static [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) MakeGameplayCueParametersFromHitResult ( const [FHitResult](API\Runtime\Engine\Engine\FHitResult) & HitResult )


description: Invoke a one time "instant" execute event for a gameplay cue on the target actor.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="GameplayCue", Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Execute GameplayCue On Actor (Burst)") static void ExecuteGameplayCueOnActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


className: UGameplayCueFunctionLibrary

description: Helpful utility function for working with gameplay cues.


description: Invoke the removed event for a gameplay cue on the target actor. This should be paired with an AddGameplayCueOnActor call.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="GameplayCue", Meta=(GameplayTagFilter="GameplayCue"), DisplayName="Remove GameplayCue On Actor (Looping)") static void RemoveGameplayCueOnActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


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


className: UGameplayCueInterface

description: Interface for actors that wish to handle GameplayCue events from GameplayEffects. Native only because blueprints can't implement interfaces with native functions

code: class UGameplayCueInterface : public [UInterface](API\Runtime\CoreUObject\UObject\UInterface)


description: Add a path to the GameplayCueNotifyPaths array. Re-initalizes RuntimeObjectLibrary based on the new paths

code: virtual void AddGameplayCueNotifyPath ( const [FString](API\Runtime\Core\Containers\FString) & InPath, const bool bShouldRescanCueAssets )


description: Sometimes it will be useful to give designers both options: in actor classes where there are many possible use cases. Still, we should keep the choice confined to the actor class, and not globally. E.g., Don't add both choices to the function library since they would appear everywhere. Add the choices to the actor class so they only appear there.

code: static void AddGameplayCue_NonReplicated ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


code: void BuildCuesToAddToGlobalSet ( const [TArray](API\Runtime\Core\Containers\TArray)< [FAssetData](API\Runtime\CoreUObject\AssetRegistry\FAssetData) > & AssetDataList, [FName](API\Runtime\Core\UObject\FName) TagPropertyName, [TArray](API\Runtime\Core\Containers\TArray)< struct [FGameplayCueReferencePair](API\Plugins\GameplayAbilities\FGameplayCueReferencePair) > & OutCuesToAdd, [TArray](API\Runtime\Core\Containers\TArray)< [FSoftObjectPath](API\Runtime\CoreUObject\UObject\FSoftObjectPath) > & OutAssetsToLoad, [FShouldLoadGCNotifyDelegate](API\Plugins\GameplayAbilities\FShouldLoadGCNotifyDelegate) )


code: void CheckForPreallocation ( [UClass](API\Runtime\CoreUObject\UObject\UClass) * GCClass )


description: The cue manager has a tendency to produce a lot of RPCs. This logs out when we are attempting to fire more RPCs than will actually go off

code: void CheckForTooManyRPCs ( [FName](API\Runtime\Core\UObject\FName) FuncName, const [FGameplayCuePendingExecute](API\Plugins\GameplayAbilities\FGameplayCuePendingExecute) & PendingCue, const [FString](API\Runtime\Core\Containers\FString) & CueID, const [FGameplayEffectContext](API\Plugins\GameplayAbilities\FGameplayEffectContext) * EffectContext )


className: CurrentWorld

description: Cached world we are currently handling cues for. Used for non instanced GC Notifies that need world.

code: static [UWorld](API\Runtime\Engine\Engine\UWorld) * CurrentWorld = nullptr;


description: Returns true if two pending cues match, can be overridden in game

code: virtual bool DoesPendingCueExecuteMatch ( [FGameplayCuePendingExecute](API\Plugins\GameplayAbilities\FGameplayCuePendingExecute) & PendingCue, [FGameplayCuePendingExecute](API\Plugins\GameplayAbilities\FGameplayCuePendingExecute) & ExistingCue )


description: Prints what classes exceeded their preallocation sizes during runtime

code: void DumpPreallocationStats ( const [FPreallocationInfo](API\Plugins\GameplayAbilities\FPreallocationInfo) & PreallocationInfo, bool bWarnOnActiveActors )


code: void EndGameplayCueSendContext()


description: Force any instanced GameplayCueNotifies to stop

code: virtual void EndGameplayCuesFor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor )


code: static void ExecuteGameplayCue_NonReplicated ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


description: Given a TargetActor and a CueClass, find an existing instance of the CueNotify Actor that we can reuse

code: [AGameplayCueNotify_Actor](API\Plugins\GameplayAbilities\AGameplayCueNotify_Actor) * FindExistingCueOnActor ( const [AActor](API\Runtime\Engine\GameFramework\AActor) & TargetActor, const [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [AGameplayCueNotify_Actor](API\Plugins\GameplayAbilities\AGameplayCueNotify_Actor) > & CueClass, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


description: Given a CueClass, find an already spawned (but currently unused) recycled instance that exists in FindInWorld so that we may reuse it. Note: This function also compacts the recycled instances, removing stale ones.

code: [AGameplayCueNotify_Actor](API\Plugins\GameplayAbilities\AGameplayCueNotify_Actor) * FindRecycledCue ( const [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [AGameplayCueNotify_Actor](API\Plugins\GameplayAbilities\AGameplayCueNotify_Actor) > & CueClass, const [UWorld](API\Runtime\Engine\Engine\UWorld) & FindInWorld )


description: Send out any pending cues

code: virtual void FlushPendingCues()


className: FOnRouteGameplayCue

code: class FOnRouteGameplayCue : public TBaseMulticastDelegate_FiveParams< void, AActor *, FGameplayTag, EGameplayCueEvent::Type, const FGameplayCueParameters &, EGameplayCueExecutionOptions >


code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > GetAlwaysLoadedGameplayCuePaths()


code: static [UWorld](API\Runtime\Engine\Engine\UWorld) * GetCachedWorldForGameplayCueNotifies()


description: Get filenames of all GC notifies we know about (loaded or not). Useful for cooking

code: void GetEditorObjectLibraryGameplayCueNotifyFilenames ( [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & Filenames ) const


description: Will return the Runtime cue set and the EditorCueSet, if the EditorCueSet is available. This is used mainly for handling asset created/deleted in the editor.

code: [TArray](API\Runtime\Core\Containers\TArray)< [UGameplayCueSet](API\Plugins\GameplayAbilities\UGameplayCueSet) * > GetGlobalCueSets()


description: Returns the cached instance cue. Creates it if it doesn't exist.

code: virtual [AGameplayCueNotify_Actor](API\Plugins\GameplayAbilities\AGameplayCueNotify_Actor) * GetInstancedCueActor ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, [UClass](API\Runtime\CoreUObject\UObject\UClass) * GameplayCueNotifyActorClass, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


code: [FPreallocationInfo](API\Plugins\GameplayAbilities\FPreallocationInfo) & GetPreallocationInfo ( const [UWorld](API\Runtime\Engine\Engine\UWorld) * World )


description:
The Editor object library, which is initialized with the "all valid" paths, viaUGameplayCueManager::GetValidGameplayCuePaths()-Only used in the editor. -Never loads clases or scans directly itself. -Just reflect asset registry to show about "all gameplay cue notifies the game could know about"
 Returns the Ryntime cueset, which is the global cueset used in runtime, as opposed to the editor cue set which is used only when running the editor


description: Returns list of valid gameplay cue paths. Subclasses may override this to specify locations that aren't part of the "always loaded" LoadedPaths array

code: virtual [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > GetValidGameplayCuePaths()


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


description: Handles updating an object library when a new asset is created

code: void HandleAssetAdded ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * Object )


description: Handles cleaning up an object library if it matches the passed in object

code: void HandleAssetDeleted ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * Object )


code: void HandleAssetRenamed ( const [FAssetData](API\Runtime\CoreUObject\AssetRegistry\FAssetData) & Data, const [FString](API\Runtime\Core\Containers\FString) & String )


description: Main entry point for handling a gameplaycue event. These functions will call the 3 functions below to handle gameplay cues

code: virtual void HandleGameplayCue ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters, [EGameplayCueExecutionOptions](API\Plugins\GameplayAbilities\EGameplayCueExecutionOptions) Options )


code: virtual void HandleGameplayCues ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GameplayCueTags, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters, [EGameplayCueExecutionOptions](API\Plugins\GameplayAbilities\EGameplayCueExecutionOptions) Options )


description: Handles what to do if a missing cue is requested. If return true, this was loaded and execution should continue

code: virtual bool HandleMissingGameplayCue ( [UGameplayCueSet](API\Plugins\GameplayAbilities\UGameplayCueSet) * OwningSet, struct [FGameplayCueNotifyData](API\Plugins\GameplayAbilities\FGameplayCueNotifyData) & CueData, [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


description: Called from editor to soft load all gameplay cue notifies for the GameplayCueEditor

code: void InitializeEditorObjectLibrary()


description: Called to setup and initialize the runtime library. The passed in paths will be scanned and added to the global gameplay cue set where appropriate

code: void InitializeRuntimeObjectLibrary()


description: Internal function to actually init theFGameplayCueObjectLibrary. Returns StreamableHandle when asset async loading is requested.

code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [FStreamableHandle](API\Runtime\Engine\Engine\FStreamableHandle) > InitObjectLibrary ( [FGameplayCueObjectLibrary](API\Plugins\GameplayAbilities\FGameplayCueObjectLibrary) & Library )


description: Wrappers to handle replicating executed cues

code: virtual void InvokeGameplayCueExecuted_FromSpec ( [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * OwningComponent, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec, [FPredictionKey](API\Plugins\GameplayAbilities\FPredictionKey) PredictionKey )


code: virtual void InvokeGameplayCueAddedAndWhileActive_FromSpec ( [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * OwningComponent, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec, [FPredictionKey](API\Plugins\GameplayAbilities\FPredictionKey) PredictionKey )


code: virtual void InvokeGameplayCueExecuted_WithParams ( [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * OwningComponent, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [FPredictionKey](API\Plugins\GameplayAbilities\FPredictionKey) PredictionKey, [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) GameplayCueParameters )


code: virtual void InvokeGameplayCueExecuted ( [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * OwningComponent, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [FPredictionKey](API\Plugins\GameplayAbilities\FPredictionKey) PredictionKey, [FGameplayEffectContextHandle](API\Plugins\GameplayAbilities\FGameplayEffectContextHandle) EffectContext )


description: Looks in the EditorObjectLibrary for a notify for this tag, if it finds it, it loads it and puts it in the RuntimeObjectLibrary so that it can be previewed in the editor

code: void LoadNotifyForEditorPreview ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag )


description: Notify to say the actor is about to be destroyed and the GC manager needs to remove references to it. This should not happen in normal play with recycling enabled, but could happen in replays.

code: virtual void NotifyGameplayCueActorEndPlay ( [AGameplayCueNotify_Actor](API\Plugins\GameplayAbilities\AGameplayCueNotify_Actor) * Actor )


description: Called when manager is first created

code: virtual void OnCreated()


description: Called when engine has completely loaded, this is a good time to finalize things

code: virtual void OnEngineInitComplete()


description: Notify that this actor is finished and should be destroyed or recycled

code: virtual void NotifyGameplayCueActorFinished ( [AGameplayCueNotify_Actor](API\Plugins\GameplayAbilities\AGameplayCueNotify_Actor) * Actor )


code: void OnGameplayCueNotifyAsyncLoadComplete ( [TArray](API\Runtime\Core\Containers\TArray)< [FSoftObjectPath](API\Runtime\CoreUObject\UObject\FSoftObjectPath) > StringRef )


code: void OnMissingCueAsyncLoadComplete ( [FSoftObjectPath](API\Runtime\CoreUObject\UObject\FSoftObjectPath) LoadedObject, [TWeakObjectPtr](API\Runtime\Core\UObject\TWeakObjectPtr)< [UGameplayCueSet](API\Plugins\GameplayAbilities\UGameplayCueSet) > OwningSet, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [TWeakObjectPtr](API\Runtime\Core\UObject\TWeakObjectPtr)< [AActor](API\Runtime\Engine\GameFramework\AActor) > TargetActor, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) Parameters )


code: void OnPostWorldCleanup ( [UWorld](API\Runtime\Engine\Engine\UWorld) * World, bool bSessionEnded, bool bCleanupResources )


code: void OnPreReplayScrub ( [UWorld](API\Runtime\Engine\Engine\UWorld) * World )


className: PreviewComponent

description: Animation Preview Hacks

code: static class [USceneComponent](API\Runtime\Engine\Components\USceneComponent) * PreviewComponent = nullptr;


className: PreviewWorld

code: static [UWorld](API\Runtime\Engine\Engine\UWorld) * PreviewWorld = nullptr;


code: void PrintGameplayCueNotifyMap()


description: Process a pending cue, return false if the cue should be rejected.

code: virtual bool ProcessPendingCueExecute ( [FGameplayCuePendingExecute](API\Plugins\GameplayAbilities\FGameplayCuePendingExecute) & PendingCue )


description: Refreshes the existing, already initialized, object libraries.

code: void RefreshObjectLibraries()


description: This handles the case where GameplayCueNotifications have changed between sessions, which is possible in editor.

code: virtual void ReloadObjectLibrary ( [UWorld](API\Runtime\Engine\Engine\UWorld) * World, const [UWorld::InitializationValues](API\Runtime\Engine\Engine\UWorld\InitializationValues) IVS )


description:
Remove the given gameplay cue notify path from the GameplayCueNotifyPaths array. Re-initalizes RuntimeObjectLibrary based on the new paths
Number of paths removed.

code: virtual int32 RemoveGameplayCueNotifyPath ( const [FString](API\Runtime\Core\Containers\FString) & InPath, const bool bShouldRescanCueAssets )


code: static void RemoveGameplayCue_NonReplicated ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


description: Calling this will make the GC manager periodically refresh the EditorObjectLibrary until the asset registry is finished scanning


description: Resets preallocation for a given world

code: void ResetPreallocation ( [UWorld](API\Runtime\Engine\Engine\UWorld) * World )


description: Actually routes the gameplaycue event to the right place.

code: virtual void RouteGameplayCue ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters, [EGameplayCueExecutionOptions](API\Plugins\GameplayAbilities\EGameplayCueExecutionOptions) Options )


description: If true, this will asynchronously load missing gameplay cues, and execute cue when the load finishes

code: virtual bool ShouldAsyncLoadMissingGameplayCues() const


code: virtual bool ShouldAsyncLoadObjectLibrariesAtStart() const


code: virtual bool ShouldAsyncLoadRuntimeObjectLibraries() const


description: Called before loading any gameplay cue notifies from object libraries. Allows subclasses to skip notifies.

code: virtual bool ShouldLoadGameplayCueAssetData ( const [FAssetData](API\Runtime\CoreUObject\AssetRegistry\FAssetData) & Data ) const


description: Returns true to ignore gameplay cues

code: virtual bool ShouldSuppressGameplayCues ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor )


description: If true, this will synchronously load missing gameplay cues

code: virtual bool ShouldSyncLoadMissingGameplayCues() const


code: virtual bool ShouldSyncLoadRuntimeObjectLibraries() const


code: virtual bool ShouldSyncScanRuntimeObjectLibraries() const


description: Allows Tag to be translated in place to a different Tag. See FGameplayCueTranslorManager

code: void TranslateGameplayCue ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) & Tag, [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


description: Start or stop a gameplay cue send context. Used byFScopedGameplayCueSendContextabove, when all contexts are removed the cues are flushed

code: void StartGameplayCueSendContext()


description: Prespawns a single actor for gameplaycue notify actor classes that need prespawning (should be called by outside gamecode, such as gamestate)

code: void UpdatePreallocation ( [UWorld](API\Runtime\Engine\Engine\UWorld) * World )


code: bool VerifyNotifyAssetIsInValidPath ( [FString](API\Runtime\Core\Containers\FString) Path )


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


className: UGameplayCueManager

description: Singleton manager object that handles dispatching gameplay cues and spawning GameplayCueNotify actors as needed

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UGameplayCueManager : public [UDataAsset](API\Runtime\Engine\Engine\UDataAsset)

bAccelerationMapOutdated

type: bool

EditorGameplayCueObjectLibrary

type: FGameplayCueObj...

EditorPeriodicUpdateHandle

type: FTimerHandle

GameplayCueAssetHandle

type: TSharedPtr<FSt...

description: Handle to maintain ownership of gameplay cue assets.

GameplayCueClassesForPreallocation

type: TArray<TSubcla...

description: Classes that we need to preallocate instances for

GameplayCueSendContextCount

description: Number of active gameplay cue send contexts, when it goes to 0 cues are flushed

LoadedGameplayCueNotifyClasses

description: Hardref to the gameplaycue notify classes we have async loaded

OnEditorObjectLibraryUpdated

type: FSimpleMulticas...

OnFlushPendingCues

description: Broadcasted when ::FlushPendingCues runs: useful for custom batching/gameplay cue handling

OnGameplayCueNotifyAddOrRemove

type: FOnGameplayCueN...

OnRouteGameplayCue

type: FOnRouteGamepla...

PendingExecuteCues

description: List of gameplay cue executes that haven't been processed yet

type: TArray<FPreall...

StreamableManager

type: FStreamableMana...

TranslationManager

type: FGameplayCueTra...


description:
Generic function to validate objects during changelist validations, etc.
Valid if this object has data validation rules set up for it and the data for this object is valid. Returns Invalid if it does not pass the rules. Returns NotValidated if no rules are set for this object.

code: virtual EDataValidationResult IsDataValid ( class [FDataValidationContext](API\Runtime\CoreUObject\Misc\FDataValidationContext) & Context ) const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintImplementableEvent) void OnBurst ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters, const [FGameplayCueNotify_SpawnResult](API\Plugins\GameplayAbilities\FGameplayCueNotify_SpawnResult) & SpawnResults ) const


code: virtual bool OnExecute_Implementation ( [AActor](API\Runtime\Engine\GameFramework\AActor) * Target, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


description: This is a non-instanced gameplay cue notify for effects that are one-offs. Since it is not instanced, it cannot do latent actions such as delays and time lines.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, Category="GameplayCueNotify", Meta=(ShowWorldContextPin, DisplayName="GCN Burst", ShortTooltip="A one-off GameplayCueNotify that is never spawned into the world.")) class UGameplayCueNotify_Burst : public [UGameplayCueNotify_Static](API\Plugins\GameplayAbilities\UGameplayCueNotify_Static)

BurstEffects

type: FGameplayCueNot...

description: List of effects to spawn on burst.

DefaultPlacementInfo

description: Default placement rules. Applies for all spawns unless overridden.

DefaultSpawnCondition

description: Default condition to check before spawning anything. Applies for all spawns unless overridden.


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


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


description: Non instanced GameplayCueNotify for spawning particle and sound FX. Still WIP - needs to be fleshed out more.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, Meta=(DisplayName="GCN Hit Impact (Deprecated)", Category="GameplayCue", ShortTooltip="This class is deprecated. Use UFortGameplayCueNotify_Burst (GCN Burst) instead.")) class UGameplayCueNotify_HitImpact : public [UGameplayCueNotify_Static](API\Plugins\GameplayAbilities\UGameplayCueNotify_Static)

ParticleSystem

type: TObjectPtr<UPa...

description: Effects to play for weapon attacks against specific surfaces

Sound

type: TObjectPtr<USo...


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


description: Generic Event Graph event that will get called for every event type

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintImplementableEvent, Category="GameplayCueNotify", DisplayName="HandleGameplayCue", Meta=(ScriptName="HandleGameplayCue")) void K2_HandleGameplayCue ( [AActor](API\Runtime\Engine\GameFramework\AActor) * MyTarget, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


description: Called when a GameplayCue with duration is first activated, this will only be called if the client witnessed the activation

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, BlueprintPure, Category="GameplayCueNotify") bool OnActive ( [AActor](API\Runtime\Engine\GameFramework\AActor) * MyTarget, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


description: Called when a GameplayCue is executed, this is used for instant effects or periodic ticks

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, BlueprintPure, Category="GameplayCueNotify") bool OnExecute ( [AActor](API\Runtime\Engine\GameFramework\AActor) * MyTarget, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


code: virtual void OnOwnerDestroyed()


description: Called when a property on this object has been modified externally

code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: Called when a GameplayCue with duration is removed

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, BlueprintPure, Category="GameplayCueNotify") bool OnRemove ( [AActor](API\Runtime\Engine\GameFramework\AActor) * MyTarget, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


description: Called after the C++ constructor and after the properties have been initialized, including those loaded from config. This is called before any serialization or other setup has happened.

code: virtual void PostInitProperties()


description: Handles reading, writing, and reference collecting usingFArchive. This implementation handles allFPropertyserialization, but can be overridden for native variables.

code: virtual void Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar )


description: Called when a GameplayCue with duration is first seen as active, even if it wasn't actually just applied (Join in progress, etc)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, BlueprintPure, Category="GameplayCueNotify") bool WhileActive ( [AActor](API\Runtime\Engine\GameFramework\AActor) * MyTarget, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


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


description: A non instantiatedUObjectthat acts as a handler for a GameplayCue. These are useful for one-off "burst" effects.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, Meta=(ShowWorldContextPin), HideCategories=(Replication)) class UGameplayCueNotify_Static : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

GameplayCueName

type: FName

description: Mirrors GameplayCueTag in order to be asset registry searchable

GameplayCueTag

type: FGameplayTag

description: Tag this notify is activated by

IsOverride

description: Does this Cue override other cues, or is it called in addition to them? E.g., If this is Damage.Physical.Slash, we wont call Damage.Physical afer we run this cue.


description: Adds a list of cues to the set

code: virtual void AddCues ( const [TArray](API\Runtime\Core\Containers\TArray)< [FGameplayCueReferencePair](API\Plugins\GameplayAbilities\FGameplayCueReferencePair) > & CuesToAdd )


description: Returns filenames of everything we know about (loaded or not)

code: virtual void GetFilenames ( [TArray](API\Runtime\Core\Containers\TArray)< [FString](API\Runtime\Core\Containers\FString) > & Filenames ) const


description: Removes all cues from the set

code: virtual void Empty()


code: void CopyCueDataToSetForEditorPreview ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) Tag, [UGameplayCueSet](API\Plugins\GameplayAbilities\UGameplayCueSet) * DestinationSet )


description: Extracts all soft object paths pointing to Cues

code: virtual void GetSoftObjectPaths ( [TArray](API\Runtime\Core\Containers\TArray)< [FSoftObjectPath](API\Runtime\CoreUObject\UObject\FSoftObjectPath) > & List ) const


description: Handles the cue event by spawning the cue actor. Returns true if the event was handled.

code: virtual bool HandleGameplayCue ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) GameplayCueTag, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


code: virtual bool HandleGameplayCueNotify_Internal ( [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, int32 DataIdx, [EGameplayCueEvent::Type](API\Plugins\GameplayAbilities\EGameplayCueEvent__Type) EventType, [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters )


code: virtual void PrintCues() const


description: Removes all cues from the set matching the supplied string refs

code: virtual void RemoveCuesByStringRefs ( const [TArray](API\Runtime\Core\Containers\TArray)< [FSoftObjectPath](API\Runtime\CoreUObject\UObject\FSoftObjectPath) > & CuesToRemove )


description: Removes all cues from the set matching any of the supplied tags

code: virtual void RemoveCuesByTags ( const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & TagsToRemove )


description: Nulls reference to the loaded class. Note this doesn't remove the entire cue from the internal data structure, just the hard ref to the loaded class

code: virtual void RemoveLoadedClass ( [UClass](API\Runtime\CoreUObject\UObject\UClass) * Class )


description: Updates an existing cue

code: virtual void UpdateCueByStringRefs ( const [FSoftObjectPath](API\Runtime\CoreUObject\UObject\FSoftObjectPath) & CueToRemove, [FString](API\Runtime\Core\Containers\FString) NewPath )


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


description: Runtime function to mapping Tag/Actor/Parameters to a translation index. The returned index here maps to the array was modified in ::GetTranslationNameSpawns

code: virtual int32 GameplayCueToTranslationIndex ( const [FName](API\Runtime\Core\UObject\FName) & TagName, [AActor](API\Runtime\Engine\GameFramework\AActor) * TargetActor, const [FGameplayCueParameters](API\Plugins\GameplayAbilities\FGameplayCueParameters) & Parameters ) const


description: Sorting priority. Higher number = first chance to translate a tag.

code: virtual int32 GetPriority() const


description: Return (via out param) list of tag swaps you will do. This should be deterministic/order matters for later!

code: virtual void GetTranslationNameSpawns ( [TArray](API\Runtime\Core\Containers\TArray)< [FGameplayCueTranslationNameSwap](API\Plugins\GameplayAbilities\FGameplayCueTranslationNameSwap) > & SwapList ) const


description: Whether this translator class should be enabled. Useful for disabling WIP translators.

code: virtual bool IsEnabled() const


description: Whether this translator should be shown in the top level view of the filter tree in the gameplaycue editor. If false, we will only add this as children of top level translators.

code: virtual bool ShouldShowInTopLevelFilterList() const


className: UGameplayCueTranslator

description: A runtime function to actually do the translation, based on the actors and parameters involved in the gameplay cue event. (GameplayCueToTranslationIndex)

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract) class UGameplayCueTranslator : public [UObject](API\Runtime\CoreUObject\UObject\UObject)


description: Important thing to understand: the int32 returned is the index into the SwapList that we created in ::GetTranslationNameSpawns()!


description: This adds the name swaps. We create 3 rules, Hero->Steel, Hero->Rampage, Hero->Kurohane. All this says is, "thiscan translate tags like this".


description: We never actually want to use this in production, so return false.


description: This is an example translator class.

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


description:
Add a GameplayEffectComponent to the GameplayEffect. This does not check for duplicates and is guaranteed to return a new instance.
The newly added instanced GameplayEffectComponent.

code: template<typename GEComponentClass> GEComponentClass & AddComponent()


description: Can we Apply this Gameplay Effect? Note: Apply is the generic term for adding to the active container or executing it.

code: bool CanApply ( const [FActiveGameplayEffectsContainer](API\Plugins\GameplayAbilities\FActiveGameplayEffectsContainer) & ActiveGEContainer, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & GESpec ) const


description: the first component that derives from the passed-in ClassToFind, if one exists.

code: const [UGameplayEffectComponent](API\Plugins\GameplayAbilities\UGameplayEffectComponent) * FindComponent ( [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UGameplayEffectComponent](API\Plugins\GameplayAbilities\UGameplayEffectComponent) > ClassToFind ) const


description: FindOrAddComponent.

code: template<typename GEComponentClass> const GEComponentClass * FindComponent() const


className: UGameplayCueSet

description: A set of gameplay cue actors to handle gameplay cue events

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class UGameplayCueSet : public [UDataAsset](API\Runtime\Engine\Engine\UDataAsset)

GameplayCueData

type: TArray<FGamepl...

GameplayCueDataMap

type: TMap<FGameplay...

description: Maps GameplayCue Tag to index into above GameplayCues array.


description:
Find an existing GameplayEffectComponent of the requested class, or add one if none are found.
The existing instance of GEComponentClass, or a newly added one.

code: template<typename GEComponentClass> GEComponentClass & FindOrAddComponent()


description: Returns all tags that this GEhasanddoes notgrant to any Actor.

code: const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetAssetTags() const


description: Returns all blocking ability tags granted by this gameplay effect definition. Blocking tags means the target will not be able to execute an ability with this asset tag.

code: const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetBlockedAbilityTags() const


code: virtual void GetBlockedAbilityTags ( [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & OutTagContainer ) const


description: Returns all tags granted to the Target Actor of this gameplay effect. That is to say: If this GE is applied to an Actor, they get these tags.

code: const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetGrantedTags() const


description: Get any owned gameplay tags on the asset

code: virtual void GetOwnedGameplayTags ( [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & TagContainer ) const


description: Returns the stack expiration policy for this gameplay effect


description: Returns the maximum stack size for this gameplay effect

code: int32 GetStackLimitCount() const


description: Let's keep track of the version so that we can upgrade the Components properly. This will be set properly in PostLoad after upgrades.


description: Check if the asset has gameplay tags that matches against all of the specified tags (expands to include parents of asset tags)

code: virtual bool HasAllMatchingGameplayTags ( const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & TagContainer ) const


description: Check if the asset has gameplay tags that matches against any of the specified tags (expands to include parents of asset tags)

code: virtual bool HasAnyMatchingGameplayTags ( const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & TagContainer ) const


description: Check if the asset has a gameplay tag that matches against the specified tag (expands to include parents of asset tags)

code: virtual bool HasMatchingGameplayTag ( [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) TagToCheck ) const


description: These are deprecated but remain for backwards compat, please useFGameplayEffectConstants:: instead.

code: static const float INFINITE_DURATION = FGameplayEffectConstants::INFINITE_DURATION;


code: static const float INSTANT_APPLICATION =FGameplayEffectConstants::INSTANT_APPLICATION;


code: static const float INVALID_LEVEL = FGameplayEffectConstants::INVALID_LEVEL;


description: Receive a notify that this GameplayEffect has been added to an Active Container. ActiveGE will be the Active version of this GameplayEffect. Returns true if this GameplayEffect should be active (or false to inhibit).

code: bool OnAddedToActiveContainer ( [FActiveGameplayEffectsContainer](API\Plugins\GameplayAbilities\FActiveGameplayEffectsContainer) & ActiveGEContainer, [FActiveGameplayEffect](API\Plugins\GameplayAbilities\FActiveGameplayEffect) & ActiveGE ) const


description: Allow each Gameplay Effect Component to validate its own data. Call this version (Super::IsDataValid)afteryour overridden version to update EditorStatusText.

code: virtual EDataValidationResult IsDataValid ( class [FDataValidationContext](API\Runtime\CoreUObject\Misc\FDataValidationContext) & Context ) const


code: static const float NO_PERIOD = FGameplayEffectConstants::NO_PERIOD;


description: Receive a notify that this GameplayEffect has been executed (it must be instant, as it is not added to the Container). Since it is not added to the container, it will not have an associatedFActiveGameplayEffect, just theFGameplayEffectSpec.

code: void OnExecuted ( [FActiveGameplayEffectsContainer](API\Plugins\GameplayAbilities\FActiveGameplayEffectsContainer) & ActiveGEContainer, [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & GESpec, [FPredictionKey](API\Plugins\GameplayAbilities\FPredictionKey) & PredictionKey ) const


description: Called when the Gameplay Effect has finished loading. This is used to catch both PostLoad (the initial load) and PostCDOCompiled (any subsequent changes)

code: virtual void OnGameplayEffectChanged()


description: Do our upgrades in PostCDOCompiled

code: virtual void PostCDOCompiled ( const [FPostCDOCompiledContext](API\Runtime\CoreUObject\UObject\UObject\FPostCDOCompiledContext) & Context )


description: If you remove a Subobject from the Parent, the Child will continue to own it and it will be delta serializedfrom the Grandparent

code: void PostCDOCompiledFixupSubobjects()


description: Called when a property on this object has been modified externally

code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: Needed to properly disable inheriting the version value from its parent.

code: virtual void PostInitProperties()


description: PostCDOCompiled)

code: virtual void PostLoad()


description: Sets the Version of the class to denote it's been upgraded

code: void SetVersion ( [EGameplayEffectVersion](API\Plugins\GameplayAbilities\EGameplayEffectVersion) Version )


description: Check for any errors

code: void ValidateGameplayEffect()


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


className: UGameplayEffect

description: How this GameplayEffect stacks with other instances of this same GameplayEffect |

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, prioritizeCategories="Status Duration GameplayEffect GameplayCues Stacking", Meta=(ShortTooltip="A GameplayEffect modifies attributes and tags.")) class UGameplayEffect : public [UObject](API\Runtime\CoreUObject\UObject\UObject), public [IGameplayTagAssetInterface](API\Runtime\GameplayTags\IGameplayTagAssetInterface)

bClearStackOnOverflow

type: bool

description: If true, the entire stack of the effect will be cleared once it overflows

bDenyOverflowApplication

description: If true, stacking attempts made while at the stack count will fail, resulting in the duration and context not being refreshed

bExecutePeriodicEffectOnApplication

description: If true, the effect executes on application and then at every period interval.

bRequireModifierSuccessToTriggerCues

description: If true, cues will only trigger when GE modifiers succeed being applied (whether through modifiers or executions)

bSuppressStackingCues

description: If true, GameplayCues will only be triggered for the first instance in a stacking GameplayEffect.

CachedAssetTags

type: FGameplayTagCon...

description: Cached Component Data - Do not modify these at runtime! If you want to manipulate these, write your own GameplayEffectComponent set the data during PostLoad.

CachedBlockedAbilityTags

description: Cached copy of all the tags this GE applies to its target to block Gameplay Abilities.

CachedGrantedTags

description: Cached copy of all the tags this GE grants to its target. Data populated during PostLoad.

DurationMagnitude

type: FGameplayEffect...

description: Duration in seconds. 0.0 for instantaneous effects; -1.0 for infinite duration.

DurationPolicy

type: EGameplayEffect...

description: Properties


description: Simple accessor to capture definitions for attributes

code: virtual const [TArray](API\Runtime\Core\Containers\TArray)< [FGameplayEffectAttributeCaptureDefinition](API\Plugins\GameplayAbilities\FGameplayEffectAttributeCaptureD-) > & GetAttributeCaptureDefinitions() const


className: UGameplayEffectCalculation

description: Abstract base for specialized gameplay effect calculations; Capable of specifing attribute captures

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType, Blueprintable, Abstract) class UGameplayEffectCalculation : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

RelevantAttributesToCapture

description: Attributes to capture that are relevant to the calculation


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


description: Returns the GameplayEffect that owns this Component (the Outer)

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


description: Can the GameplayEffectSpec apply to the passed-in ASC? All Components of the GE must return true, or a single one can return false to prohibit the application. Note: Application and Inhibition are two separate things. If a GE can apply, we then either Add it (if it has duration/prediction) or Execute it (if it's instant).

code: virtual bool CanGameplayEffectApply ( const [FActiveGameplayEffectsContainer](API\Plugins\GameplayAbilities\FActiveGameplayEffectsContainer) & ActiveGEContainer, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & GESpec ) const


description: Allow each Gameplay Effect Component to validate its own data. Any warnings/errors will immediately show up in the Gameplay Effect when in Editor. The default implementation ensures we only have a single type of any given class. Override this function to change that functionality and useSuper::Super::IsDataValidif needed.

code: virtual EDataValidationResult IsDataValid ( class [FDataValidationContext](API\Runtime\CoreUObject\Misc\FDataValidationContext) & Context ) const


description: Called when a Gameplay Effect is Added to the ActiveGameplayEffectsContainer. GE's are added to that container when they have duration (or are predicting locally) Return if the effect should remain active, or false to inhibit. Note: Inhibit does not remove the effect (it remains added but dormant, waiting to unhibit).

code: virtual bool OnActiveGameplayEffectAdded ( [FActiveGameplayEffectsContainer](API\Plugins\GameplayAbilities\FActiveGameplayEffectsContainer) & ActiveGEContainer, [FActiveGameplayEffect](API\Plugins\GameplayAbilities\FActiveGameplayEffect) & ActiveGE ) const


description: Let us know that the owning GameplayEffect has been modified, thus apply an asset-related changes to the owning GameplayEffect (e.g. any of its fields)

code: virtual void OnGameplayEffectChanged() const


description: Called when a Gameplay Effect is executed. GE's can only Execute on ROLE_Authority. GE's only Execute when they're applying an instant effect (otherwise they're added to the ActiveGameplayEffectsContainer). Note: Periodic effects Execute every period (and are also added to ActiveGameplayEffectsContainer).

code: virtual void OnGameplayEffectExecuted ( [FActiveGameplayEffectsContainer](API\Plugins\GameplayAbilities\FActiveGameplayEffectsContainer) & ActiveGEContainer, [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & GESpec, [FPredictionKey](API\Plugins\GameplayAbilities\FPredictionKey) & PredictionKey ) const


description: Constructor

code: UGameplayEffectComponent()


className: UGameplayEffectComponent

description: especially on the terminology used (Added vs. Executed vs.Apply).

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract, Const, DefaultToInstanced, EditInlineNew, CollapseCategories, Within=GameplayEffect) class UGameplayEffectComponent : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

EditorFriendlyName

type: FString

description: Friendly name for displaying in the Editor's Gameplay Effect ComponentIndex(


description: Return whether the gameplay effect should be applied or not

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, Category="Calculation") bool CanApplyGameplayEffect ( const [UGameplayEffect](API\Plugins\GameplayAbilities\UGameplayEffect) * GameplayEffect, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec, [UAbilitySystemComponent](API\Plugins\GameplayAbilities\UAbilitySystemComponent) * ASC ) const


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


description: Class used to perform custom gameplay effect modifier calculations, either via blueprint or native code

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType, Blueprintable, Abstract) class UGameplayEffectCustomApplicationRequirement : public [UObject](API\Runtime\CoreUObject\UObject\UObject)


description: Returns if this execution requires passed in tags

code: virtual bool DoesRequirePassedInTags() const


description: Native subclasses should override the auto-generated Execute_Implementation function and NOT this one.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, Category="Calculation") void Execute ( const [FGameplayEffectCustomExecutionParameters](API\Plugins\GameplayAbilities\FGameplayEffectCustomExecutionPa-) & ExecutionParams, [FGameplayEffectCustomExecutionOutput](API\Plugins\GameplayAbilities\FGameplayEffectCustomExecutionOu-) & OutExecutionOutput ) const


description: Gets the collection of capture attribute definitions that the calculation class will accept as valid scoped modifiers

code: virtual void GetValidScopedModifierAttributeCaptureDefinitions ( [TArray](API\Runtime\Core\Containers\TArray)< [FGameplayEffectAttributeCaptureDefinition](API\Plugins\GameplayAbilities\FGameplayEffectAttributeCaptureD-) > & OutScopableModifiers ) const


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


description:
Gets the collection of identifiers of valid transient aggregators ("temporary variable aggregators")
Array of valid transient aggregator identifiers

code: virtual const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetValidTransientAggregatorIdentifiers() const


className: UGameplayEffectExecutionCalculation

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(BlueprintType, Blueprintable, Abstract) class UGameplayEffectExecutionCalculation : public [UGameplayEffectCalculation](API\Plugins\GameplayAbilities\UGameplayEffectCalculation)

bRequiresPassedInTags

description: Used to indicate if this execution uses Passed In Tags

InvalidScopedModifierAttributes

description: Any attribute in this list will not show up as a valid option for scoped modifiers; Used to allow attribute capture for internal calculation while preventing modification

ValidTransientAggregatorIdentifiers

description: Any tag in this container will show up as a valid "temporary variable" for scoped modifiers; Used to allow for data-driven variable support that doesn't rely on scoped modifiers


className: UGameplayEffectUIData

description: UGameplayEffectUIDataBase class to provide game-specific data about how to describe a Gameplay Effect in the UI. Subclass with data to use in your game. In Unreal Engine 5.3, this now derives fromUGameplayEffectComponentso you can use it directly as a GameplayEffectComponent.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, Abstract, EditInlineNew, CollapseCategories) class UGameplayEffectUIData : public [UGameplayEffectComponent](API\Plugins\GameplayAbilities\UGameplayEffectComponent)


description: UI data that contains only text. This is mostly used as an example of a subclass ofUGameplayEffectUIData. If your game needs only text, this is a reasonable class to use. To include more data, make a custom subclass ofUGameplayEffectUIData.

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

Description

type: FText


description:
Calculate the base magnitude of the gameplay effect modifier, given the specified spec. Note that the owning spec def can still modify this base value with a coeffecient and pre/post multiply adds. seeFCustomCalculationBasedFloat::CalculateMagnitudefor details.
Computed magnitude of the modifier

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintNativeEvent, Category="Calculation") float CalculateBaseMagnitude ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec ) const


description: Convenience method to get attribute magnitude during a CalculateMagnitude call

code: bool GetCapturedAttributeMagnitude ( const [FGameplayEffectAttributeCaptureDefinition](API\Plugins\GameplayAbilities\FGameplayEffectAttributeCaptureD-) & Def, const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec, const [FAggregatorEvaluateParameters](API\Plugins\GameplayAbilities\FAggregatorEvaluateParameters) & EvaluationParameters, float & Magnitude ) const


description:
If the magnitude resultant from the custom calculation depends on game code-specific conditions that are not under the purview of the ability system, this method should be overridden to provide a multicast delegate that will fire when the reliant conditions change, so that the magnitude can be recalculated and updated.
Multicast delegate that will fire when this calculation's external dependencies change, if any

code: virtual [FOnExternalGameplayModifierDependencyChange](API\Plugins\GameplayAbilities\FOnExternalGameplayModifierDepen-) * GetExternalModifierDependencyMulticast ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & Spec, [UWorld](API\Runtime\Engine\Engine\UWorld) * World ) const


description:
Extracts the Set by Caller Magnitude from a Gameplay Effect Spec
The magnitude value if found, zero otherwise

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintPure=false, Category="Ability|GameplayEffect") float GetSetByCallerMagnitudeByTag ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec, const [FGameplayTag](API\Runtime\GameplayTags\FGameplayTag) & Tag ) const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintPure=false, Category="Ability|GameplayEffect") float GetSetByCallerMagnitudeByName ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec, const [FName](API\Runtime\Core\UObject\FName) & MagnitudeName ) const


description:
Copies and returns the source aggregated tags from a Gameplay Effect Spec
Gameplay Tag Container with the copied tags. The container will be empty if no captured source tags exist.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintPure=false, Category="Ability|GameplayEffect") [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) GetSourceAggregatedTags ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec ) const


description:
Returns the source actor tags from a Gameplay Effect Spec
Gameplay Tag Container with the copied tags. The container will be empty if no captured source tags exist.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|GameplayEffect") const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetSourceActorTags ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec ) const


description:
Returns the source spec tags from a Gameplay Effect Spec
Gameplay Tag Container with the copied tags. The container will be empty if no captured source tags exist.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|GameplayEffect") const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetSourceSpecTags ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec ) const


description:
Returns the target actor tags from a Gameplay Effect Spec Useful for Modifier Magnitude Calculations
Gameplay Tag Container with the copied tags. The container will be empty if no captured source tags exist.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|GameplayEffect") const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetTargetActorTags ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec ) const


description:
Copies and returns the target aggregated tags from a Gameplay Effect Spec
Gameplay Tag Container with the copied tags. The container will be empty if no captured source tags exist.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintPure=false, Category="Ability|GameplayEffect") [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) GetTargetAggregatedTags ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec ) const


description:
Returns the target spec tags from a Gameplay Effect Spec Useful for Modifier Magnitude Calculations
Gameplay Tag Container with the copied tags. The container will be empty if no captured source tags exist.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="Ability|GameplayEffect") const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & GetTargetSpecTags ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec ) const


description:
Gets the captured magnitude value for the given Attribute For this to work correctly, the Attribute needs to be added to the Relevant Attributes to Capture array
The magnitude value if found, zero otherwise

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, BlueprintPure=false, Category="Ability|GameplayEffect", Meta=(DisplayName="Get Captured Attribute Magnitude", ScriptName="GetCapturedAttributeMagnitude")) float K2_GetCapturedAttributeMagnitude ( const [FGameplayEffectSpec](API\Plugins\GameplayAbilities\FGameplayEffectSpec) & EffectSpec, [FGameplayAttribute](API\Plugins\GameplayAbilities\FGameplayAttribute) Attribute, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & SourceTags, const [FGameplayTagContainer](API\Runtime\GameplayTags\FGameplayTagContainer) & TargetTags ) const