1. Epic GamesDeveloper
  3. UAbilitySystemComponent

UAbilitySystemComponent

The core ActorComponent for interfacing with the GameplayAbilities System

API > API/Plugins > API/Plugins/GameplayAbilities

Inheritance Hierarchy

References

   
Module GameplayAbilities
Header /Engine/Plugins/Runtime/GameplayAbilities/Source/GameplayAbilities/Public/AbilitySystemComponent.h
Include #include "AbilitySystemComponent.h"

Syntax

UCLASS&40;ClassGroup&61;AbilitySystem,  
       HideCategories&61;&40;Object, LOD, Lighting, Transform, Sockets, TextureStreaming&41;,  
       EditInlineNew, Meta&61;&40;BlueprintSpawnableComponent&41;&41;  
class UAbilitySystemComponent :  
    public UGameplayTasksComponent,  
    public IGameplayTagAssetInterface,  
    public IAbilitySystemReplicationProxyInterface

Remarks

The core ActorComponent for interfacing with the GameplayAbilities System

Variables

  Type Name Description
Public variable FGenericAbilityDelegate AbilityActivatedCallbacks A generic callback anytime an ability is activated (started)
Public variable TSharedPtr< FGameplayAbilityActorInfo > AbilityActorInfo Cached off data about the owning actor that abilities will need to frequently access (movement component, mesh component, anim instance, etc)
Public variable FGenericAbilityDelegate AbilityCommittedCallbacks A generic callback anytime an ability is committed (cost/cooldown applied)
Public variable FAbilityEnded AbilityEndedCallbacks Callback anytime an ability is ended
Public variable FAbilityFailedDelegate AbilityFailedCallbacks Called with a failure reason when an ability fails to activate
Protected variable float AbilityLastActivatedTime Local World time of the last ability activation. This is used for AFK/idle detection
Protected variable TArray< FAbilityListLockActiveChange * > AbilityListLockActiveChanges  
Protected variable TArray< FGameplayAbilitySpec, TInlineAllocator< 2 > > AbilityPendingAdds  
Protected variable TArray< FGameplayAbilitySpecHandle, TInlineAllocator< 2 > > AbilityPendingRemoves  
Protected variable int32 AbilityScopeLockCount  
Public variable FAbilitySpecDirtied AbilitySpecDirtiedCallbacks Called when an ability spec's internals have changed
Protected variable FGameplayAbilityReplicatedDataContainer AbilityTargetDataMap Maps from an ability spec to the target data. Used to track replicated data and callbacks
Protected variable UProperty Category BlueprintReadOnly Transient replicatedusing FGameplayAbilitySpecContainer ActivatableAbilities The abilities we can activate.
Protected variable UProperty Replicated FActiveGameplayCueContainer ActiveGameplayCues List of all active gameplay cues, including ones applied manually
Protected variable UProperty Replicated FActiveGameplayEffectsContainer ActiveGameplayEffects Contains all of the gameplay effects that are currently active on this component
Public variable UProperty Category, EditAnywhere BlueprintReadWrite FName AffectedAnimInstanceTag The linked Anim Instance that this component will play montages in.
Protected variable UProperty bool bCachedIsNetSimulated Cached value of rather this is a simulated actor
Protected variable FGameplayTagCountContainer BlockedAbilityTags Abilities with these tags are not able to be activated
Protected variable UProperty bool bPendingMontageRep Set if montage rep happens while we don't have the animinstance associated with us yet
Public variable UProperty bool bSuppressGameplayCues Suppress all GameplayCues on this component
Public variable UProperty bool bSuppressGrantAbility Suppress all ability granting through GEs on this component
Protected variable int32 ClientActivateAbilityFailedCountRecent  
Protected variable float ClientActivateAbilityFailedStartTime  
Public variable UProperty Category, EditAnywhere TArray< FAttributeDefaults > DefaultStartingData  
Public variable TArray< FGameplayEffectApplicationQuery > GameplayEffectApplicationQueries We allow users to setup a series of functions that must be true in order to allow a GameplayEffect to be applied
Protected variable TArray< TPair< FGameplayTagContainer, FGameplayEventTagMulticastDelegate > > GameplayEventTagContainerDelegates List of gameplay tag container filters, and the delegates they call
Protected variable TMap< FGameplayTag, TArray< FGameplayAbilitySpecHandle > > GameplayEventTriggeredAbilities Abilities that are triggered from a gameplay event
Protected variable FGameplayTagCountContainer GameplayTagCountContainer Acceleration map for all gameplay tags (OwnedGameplayTags from GEs and explicit GameplayCueTags)
Public variable int32 GenericCancelInputID  
Public variable int32 GenericConfirmInputID InputID for binding GenericConfirm/Cancel events
Public variable TMap< FGameplayTag, FGameplayEventMulticastDelegate > GenericGameplayEventCallbacks Callbacks bound to Gameplay tags, these only activate if the exact tag is used.
Public variable FAbilityConfirmOrCancel GenericLocalCancelCallbacks Generic local callback for generic CancelEvent that any ability can listen to
Public variable FAbilityConfirmOrCancel GenericLocalConfirmCallbacks Generic local callback for generic ConfirmEvent that any ability can listen to
Public variable UProperty Meta float IncomingDuration Internal Attribute that modifies the duration of gameplay effects applied to this component
Public variable   InputID  
Public variable * int32  
Public variable FGameplayTagContainer InternalTryActivateAbilityFailureTags Failure tags used by InternalTryActivateAbility (E.g., this stores the FailureTags of the last call to InternalTryActivateAbility
Protected variable UProperty FGameplayAbilityLocalAnimMontage LocalAnimMontageInfo Data structure for montages that were instigated locally (everything if server, predictive if client. replicated if simulated proxy)
Public variable TArray< FServerAbilityRPCBatch, TInlineAllocator< 1 > > LocalServerAbilityRPCBatchData Accumulated client side data that is batched out to server on EndServerAbilityRPCBatch
Protected variable UProperty Replicated FActiveGameplayCueContainer MinimalReplicationGameplayCues Replicated gameplaycues when in minimal replication mode.
Public variable FGameplayAbilityEndedDelegate OnAbilityEnded Callback anytime an ability is ended, with extra information
Public variable FOnGameplayEffectAppliedDelegate OnActiveGameplayEffectAddedDelegateToSelf Called on both client and server whenever a duraton based GE is added (E.g., instant GEs do not trigger this).
Public variable FOnGameplayEffectAppliedDelegate OnGameplayEffectAppliedDelegateToSelf Called on server whenever a GE is applied to self. This includes instant and duration based GEs.
Public variable FOnGameplayEffectAppliedDelegate OnGameplayEffectAppliedDelegateToTarget Called on server whenever a GE is applied to someone else.
Public variable FImmunityBlockGE OnImmunityBlockGameplayEffectDelegate Immunity notification support
Public variable FOnGameplayEffectAppliedDelegate OnPeriodicGameplayEffectExecuteDelegateOnSelf Called on server whenever a periodic GE executes on self
Public variable FOnGameplayEffectAppliedDelegate OnPeriodicGameplayEffectExecuteDelegateOnTarget Called on server whenever a periodic GE executes on target
Public variable UProperty Meta float OutgoingDuration System Attributes
Protected variable TMap< FGameplayTag, TArray< FGameplayAbilitySpecHandle > > OwnedTagTriggeredAbilities Abilities that are triggered from a tag being added to the owner
Public variable TArray< FPendingAbilityInfo > PendingServerActivatedAbilities This is a list of GameplayAbilities that were activated on the server and can't yet execute on the client.
Public variable UProperty Transient, Replicated FReplicatedPredictionKeyMap ReplicatedPredictionKeyMap PredictionKeys, see more info in GameplayPrediction.h.
Public variable EGameplayEffectReplicationMode ReplicationMode How gameplay effects are replicated
Public variable UProperty bool ReplicationProxyEnabled When enabled GameplayCue RPCs will be routed through the AvatarActor's IAbilitySystemReplicationProxyInterface rather than this component
Public variable FPredictionKey ScopedPredictionKey Current prediction key, set with FScopedPredictionWindow
Public variable UProperty TArray< TObjectPtr< AGameplayAbilityTargetActor > > SpawnedTargetActors List of currently active targeting actors
Public variable UProperty bool UserAbilityActivationInhibited Rather activation is currently inhibited

Constructors

  Type Name Description
Public function  

UAbilitySystemComponent ( const FObjectInitializer& ObjectInitializer
)

  

Functions

  Type Name Description
Public function Virtual void

AbilityLocalInputPressed ( int32 InputID
)

 Called to handle ability bind input
Public function Virtual void

AbilityLocalInputReleased ( int32 InputID
)

  
Public function FSimpleMulticastDelegate & Returns Generic Replicated Event for a given Ability/PredictionKey pair
Public function Virtual void Called on local player always.
Public function Virtual void Called on local player always.
Public function FSimpleMulticastDelegate &

AbilityTargetDataCancelledDelegate ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Returns TargetData Cancelled delegate for a given Ability/PredictionKey pair
Public function FAbilityTargetDataSetDelegate &

AbilityTargetDataSetDelegate ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Returns TargetDataSet delegate for a given Ability/PredictionKey pair
Public function void  
Public function const T *

AddAttributeSetSubobject ( T* Subobject
)

 Manually add a new attribute set that is a subobject of this ability system component.
Public function void

AddGameplayCue ( const FGameplayTag GameplayCueTag,
const FGameplayCueParameters& GameplayCueParameters
)

  
Public function void

AddGameplayCue ( const FGameplayTag GameplayCueTag,
FGameplayEffectContextHandle EffectContext
)

 Add a persistent gameplay cue
Protected function Virtual void

AddGameplayCue_Internal ( const FGameplayTag GameplayCueTag,
const FGameplayCueParameters& GameplayCueParameters,
FActiveGameplayCueContainer& GameplayCueContainer
)

 Internal gameplay cue functions.
Protected function Virtual void

AddGameplayCue_Internal ( const FGameplayTag GameplayCueTag,
FGameplayEffectContextHandle& EffectContext,
FActiveGameplayCueContainer& GameplayCueContainer
)

 Internal gameplay cue functions.
Public function void Add gameplaycue for minimal replication mode.
Public function FDelegateHandle

AddGameplayEventTagContainerDelegate ( const FGameplayTagContainer& TagFilter,
const FGameplayEventTagMulticastDelegate::FDelegate& Delegate
)

 Adds a new delegate to call when gameplay events happen.
Public function void

AddLooseGameplayTag ( const FGameplayTag& GameplayTag,
int32 Count
)

 Allows GameCode to add loose gameplaytags which are not backed by a GameplayEffect.
Public function void

AddLooseGameplayTags ( const FGameplayTagContainer& GameplayTags,
int32 Count
)

  
Public function void Minimally replicated tags are replicated tags that come from GEs when in bMinimalReplication mode.
Public function void  
Protected function void Add a gameplay ability associated to this component
Public function void Allows GameCode to add loose gameplaytags which are not backed by a GameplayEffect.
Public function void  
Public function const T *

AddSet ()

 Adds a new AttributeSet (initialized to default values)
Public function void Add a new attribute set
Protected function void Copy over playing flags for duplicate animation data
Protected function void Copy LocalAnimMontageInfo into RepAnimMontageInfo
Protected function void Copy LocalAnimMontageInfo into RepAnimMontageInfo
Public function Virtual void

ApplyAbilityBlockAndCancelTags ( const FGameplayTagContainer& AbilityTags,
UGameplayAbility* RequestingAbility,
bool bEnableBlockTags,
const FGameplayTagContainer& BlockTags,
bool bExecuteCancelTags,
const FGameplayTagContainer& CancelTags
)

 Called from ability activation or native code, will apply the correct ability blocking tags and cancel existing abilities.
Public function Virtual FActiveGameplayEffectHandle

ApplyGameplayEffectSpecToSelf ( const FGameplayEffectSpec& GameplayEffect,
FPredictionKey PredictionKey
)

  
Public function Virtual FActiveGameplayEffectHandle  
Public function FActiveGameplayEffectHandle

ApplyGameplayEffectToSelf ( const UGameplayEffect* GameplayEffect,
float Level,
const FGameplayEffectContextHandle& EffectContext,
FPredictionKey PredictionKey
)

 This is a helper function - it seems like this will be useful as a blueprint interface at the least, but Level parameter may need to be expanded
Public function FActiveGameplayEffectHandle

ApplyGameplayEffectToTarget ( UGameplayEffect* GameplayEffect,
UAbilitySystemComponent* Target,
float Level,
FGameplayEffectContextHandle Context,
FPredictionKey PredictionKey
)

 This is a helper function used in automated testing, I'm not sure how useful it will be to gamecode or blueprints
Public function void

ApplyModToAttribute ( const FGameplayAttribute& Attribute,
TEnumAsByte< EGameplayModOp::Type > ModifierOp,
float ModifierMagnitude
)

 Applies an in-place mod to the given attribute.
Public function void

ApplyModToAttributeUnsafe ( const FGameplayAttribute& Attribute,
TEnumAsByte< EGameplayModOp::Type > ModifierOp,
float ModifierMagnitude
)

 Applies an inplace mod to the given attribute.
Public function Virtual Const bool Returns true if any passed in tags are blocked
Public function Virtual void  
Public function Virtual void Bind to an input component with customized bindings
Public function Virtual void Bind to an input component with some default action names
Public function void Block or cancel blocking for specific ability tags
Public function void

BlockAbilityByInputID ( int32 InputID
)

 Block or cancel blocking for specific input IDs
Public function UFunction BlueprintCallable, Category, Meta FActiveGameplayEffectHandle Applies a previously created gameplay effect spec to this component
Public function UFunction BlueprintCallable, Category, Meta FActiveGameplayEffectHandle GameplayEffects: Primary outward facing API for other systems
Public function UFunction BlueprintCallable, Category, Meta FActiveGameplayEffectHandle

BP_ApplyGameplayEffectToSelf ( TSubclassOf< UGameplayEffect > GameplayEffectClass,
float Level,
FGameplayEffectContextHandle EffectContext
)

 Apply a gameplay effect to self
Public function UFunction BlueprintCallable, Category, Meta FActiveGameplayEffectHandle Additional Helper Functions Apply a gameplay effect to passed in target
Public function Virtual FGameplayAbilitySpec

BuildAbilitySpecFromClass ( TSubclassOf< UGameplayAbility > AbilityClass,
int32 Level,
int32 InputID
)

 Build a simple FGameplayAbilitySpec from class, level and optional Input ID
Public function void Caches the flags that indicate whether this component has network authority.
Public function void

CallAllReplicatedDelegatesIfSet ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Calls any Replicated delegates that have been sent (TargetData or Generic Replicated Events).
Public function bool

CallOrAddReplicatedDelegate ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
FSimpleMulticastDelegate::FDelegate Delegate
)

 Calls passed in delegate if the Client Event has already been sent.
Public function bool Calls a given Generic Replicated Event delegate if the event has already been sent
Public function bool

CallReplicatedTargetDataDelegatesIfSet ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Calls the TargetData Confirm/Cancel events if they have been sent.
Public function void  
Public function void

CallServerSetReplicatedTargetData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
const FGameplayAbilityTargetDataHandle& ReplicatedTargetDataHandle,
FGameplayTag ApplicationTag,
FPredictionKey CurrentPredictionKey
)

  
Public function void

CallServerTryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
bool InputPressed,
FPredictionKey PredictionKey
)

 Batching client->server RPCs This is a WIP feature to batch up client->server communication.
Public function bool

CanApplyAttributeModifiers ( const UGameplayEffect* GameplayEffect,
float Level,
const FGameplayEffectContextHandle& EffectContext
)

 Tests if all modifiers in this GameplayEffect will leave the attribute > 0.f
Public function void

CancelAbilities ( const FGameplayTagContainer* WithTags,
const FGameplayTagContainer* WithoutTags,
UGameplayAbility* Ignore
)

 Cancel all abilities with the specified tags. Will not cancel the Ignore instance
Public function void Ability Cancelling/Interrupts Cancels the specified ability CDO.
Public function void Cancels the ability indicated by passed in spec handle.
Protected function Virtual void Cancel a specific ability spec
Public function Virtual void

CancelAbilityTargetData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Cancels the ability target data and calls callbacks
Public function void Cancels all abilities regardless of tags. Will not cancel the ignore instance
Public function Const bool Do we have a valid prediction key to do more predictive actions with
Public function void Populate the specified capture spec with the data necessary to capture an attribute from the component
Protected function void  
Protected function void Called from ClearAbility, ClearAllAbilities or OnRep.
Public function FString  
Public function UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void Removes the specified ability. This will be ignored if the actor is not authoritative.
Public function void  
Public function Virtual void This is called when the actor that is initialized to this system dies, this will clear that actor from this system and FGameplayAbilityActorInfo
Public function UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void Wipes all 'given' abilities. This will be ignored if the actor is not authoritative.
Public function UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void

ClearAllAbilitiesWithInputID ( int32 InputID
)

 Clears all abilities bound to a given Input ID This will be ignored if the actor is not authoritative
Public function Virtual void Clear the animating ability that is passed in, if it's still currently animating
Public function void  
Protected function UFunction Client, Reliable void

ClientActivateAbilityFailed ( FGameplayAbilitySpecHandle AbilityToActivate,
int16 PredictionKey
)

  
Protected function UFunction Client, Reliable void  
Protected function UFunction Client, Reliable void  
Protected function UFunction Client, Reliable void  
Protected function UFunction Client, Reliable void  
Public function UFunction Client, Reliable void

ClientPrintDebug_Response ( const TArray< FString >& Strings,
int32 GameFlags
)

  
Public function UFunction Client, Reliable void Replicates the Generic Replicated Event to the client.
Protected function UFunction Client, Reliable void  
Public function Virtual void

ConfirmAbilityTargetData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
const FGameplayAbilityTargetDataHandle& TargetData,
const FGameplayTag& ApplicationTag
)

 Sets the current target data and calls applicable callbacks
Public function void

ConsumeAllReplicatedData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Deletes all cached ability client data (Was: ConsumeAbilityTargetData)
Public function void

ConsumeClientReplicatedTargetData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Consumes cached TargetData from client (only TargetData)
Public function void Consumes the given Generic Replicated Event (unsets it).
Protected function Virtual UGameplayAbility * Creates a new instance of an ability, storing it in the spec
Public function Virtual void Jumps current montage to given section.
Public function Virtual void

CurrentMontageSetNextSectionName ( FName FromSectionName,
FName ToSectionName
)

 Sets current montages next section name.
Public function Virtual void

CurrentMontageSetPlayRate ( float InPlayRate
)

 Sets current montage's play rate
Public function Virtual void

CurrentMontageStop ( float OverrideBlendOutTime
)

 Stops whatever montage is currently playing.
Public function Virtual void  
Protected function void  
Public function void

DebugLine ( FAbilitySystemComponentDebugInfo& Info,
FString Str,
float XOffset,
float YOffset,
int32 MinTextRowsToAdvance
)

  
Public function void  
Public function Virtual void Cancels all abilities and kills any remaining instanced abilities
Public function Virtual void

DisplayDebug ( UCanvas* Canvas,
const FDebugDisplayInfo& DebugDisplay,
float& YL,
float& YPos
)

  
Public function Virtual void  
Public function void

ExecuteGameplayCue ( const FGameplayTag GameplayCueTag,
FGameplayEffectContextHandle EffectContext
)

 GameplayCues can also come on their own.
Public function void

ExecuteGameplayCue ( const FGameplayTag GameplayCueTag,
const FGameplayCueParameters& GameplayCueParameters
)

  
Protected function void  
Protected function void  
Public function Const FGameplayAbilitySpec * Returns an ability spec corresponding to given ability class.
Public function Const FGameplayAbilitySpec * Returns an ability spec from a handle. If modifying call MarkAbilitySpecDirty
Public function Const FGameplayAbilitySpec *

FindAbilitySpecFromInputID ( int32 InputID
)

 Returns an ability spec from a handle. If modifying call MarkAbilitySpecDirty
Public function Const FActiveGameplayEffectHandle Gets the GE Handle of the GE that granted the passed in Ability
Public function Const UFunction BlueprintCallable, BlueprintPure, Category void Returns an array with all abilities that match the provided Gameplay Tag Query
Public function Const UFunction BlueprintCallable, BlueprintPure, Category void

FindAllAbilitiesWithInputID ( TArray< FGameplayAbilitySpecHandle >& OutAbilityHandles,
int32 InputID
)

 Returns an array with all abilities bound to an Input ID value
Public function Const UFunction BlueprintCallable, BlueprintPure, Category void

FindAllAbilitiesWithTags ( TArray< FGameplayAbilitySpecHandle >& OutAbilityHandles,
FGameplayTagContainer Tags,
bool bExactMatch
)

 Returns an array with all abilities that match the provided tags
Public function Virtual Const void

FindAllAbilitySpecsFromInputID ( int32 InputID,
TArray< const FGameplayAbilitySpec* >& OutAbilitySpecs
)

 Returns all abilities with the given InputID
Public function Virtual void Replication
Public function Virtual void Force cancels the ability and does not replicate this to the other side.
Protected function TArray< TObjectPtr< UGameplayTask > > &  
Public function Const float Returns local world time that an ability was activated.
Public function Const const TArray< FGameplayAbilitySpec > & Functions meant to be called from GameplayAbility and subclasses, but not meant for general use
Public function TArray< FGameplayAbilitySpec > & Returns the list of all activatable abilities.
Public function Const void

GetActivatableGameplayAbilitySpecsByAllMatchingTags ( const FGameplayTagContainer& GameplayTagContainer,
TArray< struct FGameplayAbilitySpec* >& MatchingGameplayAbilities,
bool bOnlyAbilitiesThatSatisfyTagRequirements
)

 Gets all Activatable Gameplay Abilities that match all tags in GameplayTagContainer AND for which DoesAbilitySatisfyTagRequirements() is true.
Public function FActiveGameplayEffectEvents * Returns delegate structure that allows binding to several gameplay effect changes
Public function Const UFunction BlueprintCallable, BlueprintPure, Category, Meta TArray< FActiveGameplayEffectHandle > Returns list of active effects, for a query
Public function Const TArray< float > Gets total duration for all effects that match query
Public function Const float This will give the world time that all effects matching this query will be finished.
Public function Const bool

GetActiveEffectsEndTimeAndDuration ( const FGameplayEffectQuery& Query,
float& EndTime,
float& Duration
)

 Returns end time and total duration
Public function Const float This will give the world time that all effects matching this query will be finished.
Public function Const TArray< float > Gets time remaining for all effects that match query
Public function Const TArray< TPair< float, float > > Gets both time remaining and total duration for all effects that match query
Public function Const UFunction BlueprintCallable, BlueprintPure, Category TArray< FActiveGameplayEffectHandle > Returns list of active effects that have all of the passed in tags
Public function Const const FActiveGameplayEffect * Returns const pointer to the actual active gameplay effect structure
Public function Const const FActiveGameplayEffectsContainer & Returns all active gameplay effects on this ASC
Public function Const FString Returns debug string describing active gameplay effect
Public function Const int32 Returns the sum of StackCount of all gameplay effects that pass query
Public function Const UFunction BlueprintCallable, BlueprintPure, Category void Returns an array with all granted ability handles NOTE: currently this doesn't include abilities that are mid-activation
Public function Const void Makes a copy of all the active effects on this ability component
Public function UFunction BlueprintPure, Category void Returns a list of all attributes for this abilty system component
Public function UGameplayAbility * Returns the current animating ability
Public function Const UFunction BlueprintCallable, BlueprintPure, Category const UAttributeSet *

GetAttributeSet ( TSubclassOf< UAttributeSet > AttributeSetClass
)

 Returns a reference to the Attribute Set instance, if one exists in this component
Protected function Const const UAttributeSet *

GetAttributeSubobject ( const TSubclassOf< UAttributeSet > AttributeClass
)

  
Protected function Const const UAttributeSet *  
Public function Const AActor * Returns the avatar actor for this component
Public function Const AActor *  
Protected function Const const TArray< uint8 > &  
Protected function TArray< uint8 > &  
Public function Const void Fills TagContainer with BlockedAbilityTags
Public function Const const TArray< FString > &  
Public function TArray< FString > &  
Public function Const UAnimMontage * Returns montage that is currently playing
Public function Const int32 Get SectionID of currently playing AnimMontage
Public function Const float Get length in time of current section
Public function Const FName Get SectionName of currently playing AnimMontage
Public function Const float Returns amount of time left in current section
Public function Const int32 Returns current stack count of an already applied GE, but given the ability spec handle that was granted by the GE
Public function Const int32 Returns current stack count of an already applied GE
Public function FGameplayEffectContextHandle Retrieves the EffectContext of the GameplayEffect of the active GameplayEffect.
Public function float

GetFilteredAttributeValue ( const FGameplayAttribute& Attribute,
const FGameplayTagRequirements& SourceTags,
const FGameplayTagContainer& TargetTags,
const TArray< FActiveGameplayEffectHandle >& HandlesToIgnore
)

 Returns an attribute value, after applying tag filters
Public function Const UFunction BlueprintPure, Category float

GetGameplayAttributeValue ( FGameplayAttribute Attribute,
bool& bFound
)

 Returns the current value of the given gameplay attribute, or zero if the attribute is not found.
Public function FOnGameplayAttributeValueChange & Register for when an attribute value changes
Public function Const const UGameplayEffect * Returns a const pointer to the gameplay effect CDO associated with an active handle.
Public function Const UFunction BlueprintCallable, BlueprintPure, Category int32

GetGameplayEffectCount ( TSubclassOf< UGameplayEffect > SourceGameplayEffect,
UAbilitySystemComponent* OptionalInstigatorFilterComponent,
bool bEnforceOnGoingCheck
)

 Get the count of the specified source effect on the ability system component.
Public function Const UFunction BlueprintCallable, BlueprintPure, Category int32

GetGameplayEffectCount_IfLoaded ( TSoftClassPtr< UGameplayEffect > SoftSourceGameplayEffect,
UAbilitySystemComponent* OptionalInstigatorFilterComponent,
bool bEnforceOnGoingCheck
)

 Get the count of the specified source effect on the ability system component.
Public function const UGameplayEffect * Gets the FActiveGameplayEffect based on the passed in Handle
Public function Const float Returns the total duration of a gameplay effect
Public function Const UFunction BlueprintCallable, Category float Raw accessor to ask the magnitude of a gameplay effect, not necessarily always correct.
Public function Const const FGameplayTagContainer * Get the source tags from the gameplay spec represented by the specified handle, if possible
Public function Const void

GetGameplayEffectStartTimeAndDuration ( FActiveGameplayEffectHandle Handle,
float& StartEffectTime,
float& Duration
)

 Return start time and total duration of a gameplay effect
Public function Const const FGameplayTagContainer * Get the target tags from the gameplay spec represented by the specified handle, if possible
Public function Const UFunction BlueprintPure, Category int32 Returns the current count of the given gameplay tag.
Public function Static const FGameplayEffectAttributeCaptureDefinition &  
Public function Static FProperty *  
Protected function Const const FMinimalReplicationTagCountMap &  
Protected function FMinimalReplicationTagCountMap &  
Public function Const int32 Returns the number of gameplay effects that are currently active on this ability system component
Public function Const float Returns current (final) value of an attribute
Public function Const float Gets the base value of an attribute. That is, the value of the attribute with no stateful modifiers
Public function Const float Returns current (final) value of an attribute
Protected function const UAttributeSet *  
Public function Static const FGameplayEffectAttributeCaptureDefinition &  
Public function Static FProperty *  
Public function Const AActor *  
Public function Const FPredictionKey Returns the prediction key that should be used for any actions
Protected function Const const FGameplayAbilityRepAnimMontage &  
Protected function FGameplayAbilityRepAnimMontage &  
Public function FAbilityReplicatedData Gets replicated data of the given Generic Replicated Event.
Protected function Const PRAGMA_DISABLE_DEPRECATION_WARNINGS const TArray< UGameplayAbility * > & Full list of all instance-per-execution gameplay abilities associated with this component
Protected function Const const FMinimalReplicationTagCountMap &  
Protected function FMinimalReplicationTagCountMap &  
Public function Virtual IAbilitySystemReplicationProxyInterface * Who to route replication through if ReplicationProxyEnabled (if this returns null, when ReplicationProxyEnabled, we wont replicate)
Public function Const const TArray< FString > &  
Public function TArray< FString > &  
Public function Const const T *

GetSet ()

 AttributesFinds existing AttributeSet
Public function Const const T * Finds existing AttributeSet. Asserts if it isn't there.
Public function Const const TArray< UAttributeSet * > & Access the spawned attributes list when you don't intend to modify the list.
Public function Const int32

GetTagCount ( FGameplayTag TagToCheck
)

 Returns the number of instances of a given tag
Public function Const UFunction BlueprintCallable, Category bool Input handling/targeting
Public function FGameplayAbilitySpecHandle

GiveAbility ( const FGameplayAbilitySpec& AbilitySpec
)

 GameplayAbilities
Public function FGameplayAbilitySpecHandle

GiveAbilityAndActivateOnce ( FGameplayAbilitySpec& AbilitySpec,
const FGameplayEventData* GameplayEventData
)

 Grants an ability and attempts to activate it exactly one time, which will cause it to be removed.
Public function Virtual void

HandleChangeAbilityCanBeCanceled ( const FGameplayTagContainer& AbilityTags,
UGameplayAbility* RequestingAbility,
bool bCanBeCanceled
)

 Called when an ability is cancellable or not.
Public function Virtual void

HandleDeferredGameplayCues ( const FActiveGameplayEffectsContainer* GameplayEffectsContainer
)

 Handle GameplayCues that may have been deferred while doing the NetDeltaSerialize and waiting for the avatar actor to get loaded
Public function Virtual int32

HandleGameplayEvent ( FGameplayTag EventTag,
const FGameplayEventData* Payload
)

 Executes a gameplay event.
Public function bool  
Public function Const bool Does this ability system component have this attribute?
Public function Const bool Returns true if this is running on the server or has a valid prediciton key
Protected function Const bool Returns true if the specified ability should be activated from an event in this network mode
Protected function Const bool  
Public function void Called from FScopedAbilityListLock
Public function Virtual void

InhibitActiveGameplayEffect ( FActiveGameplayEffectHandle ActiveGEHandle,
bool bInhibit,
bool bInvokeGameplayCueEvents
)

 Inhibit an active gameplay effect so that it is disabled, but not removed
Public function Virtual void

InitAbilityActorInfo ( AActor* InOwnerActor,
AActor* InAvatarActor
)

 Initialized the Abilities' ActorInfo - the structure that holds information about who we are acting on and who controls us.
Public function Virtual void Will initialize gameplay cue parameters with this ASC's Owner (Instigator) and AvatarActor (EffectCauser)
Public function const UAttributeSet *

InitStats ( TSubclassOf< class UAttributeSet > Attributes,
const UDataTable* DataTable
)

 Initializes starting attributes from a data table.
Public function UFunction BlueprintCallable, Category void Sends a local player Input Cancel event, notifying abilities
Public function UFunction BlueprintCallable, Category void Sends a local player Input Confirm event, notifying abilities
Protected function Virtual void

InternalServerTryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
bool InputPressed,
const FPredictionKey& PredictionKey,
const FGameplayEventData* TriggerEventData
)

 Implementation of ServerTryActivateAbility
Public function bool

InternalTryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
FPredictionKey InPredictionKey,
UGameplayAbility** OutInstancedAbility,
FOnGameplayAbilityEnded::FDelegate* OnGameplayAbilityEndedDelegate,
const FGameplayEventData* TriggerEventData
)

 Attempts to activate the given ability, will only work if called from the correct client/server context
Public function void Handles gameplay cue events from external sources
Public function void  
Public function void

InvokeGameplayCueEvent ( const FGameplayTag GameplayCueTag,
EGameplayCueEvent::Type EventType,
const FGameplayCueParameters& GameplayCueParameters
)

  
Public function bool

InvokeReplicatedEvent ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
FPredictionKey CurrentPredictionKey
)

 Calls local callbacks that are registered with the given Generic Replicated Event
Public function bool

InvokeReplicatedEventWithPayload ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
FPredictionKey CurrentPredictionKey,
FVector_NetQuantize100 VectorPayload
)

 Calls local callbacks that are registered with the given Generic Replicated Event
Public function Const bool

IsAbilityInputBlocked ( int32 InputID
)

 Checks if the ability system is currently blocking InputID.
Public function Const bool Returns true if the passed in ability is the current animating ability
Public function Const UFunction BlueprintCallable, Category, Meta bool

IsGameplayCueActive ( const FGameplayTag GameplayCueTag
)

 Allows polling to see if a GameplayCue is active.
Public function Const bool

IsGenericCancelInputBound ( int32 InputID
)

  
Public function Const bool

IsGenericConfirmInputBound ( int32 InputID
)

  
Public function Virtual Const bool Returns true if this component's actor has authority
Public function Virtual bool Are we ready to invoke gameplaycues yet?
Protected function Virtual bool Returns true if we are ready to handle replicated montage information
Public function UFunction BlueprintCallable, BlueprintAuthorityOnly, Category, Meta FGameplayAbilitySpecHandle

K2_GiveAbility ( TSubclassOf< UGameplayAbility > AbilityClass,
int32 Level,
int32 InputID
)

 Grants a Gameplay Ability and returns its handle.
Public function UFunction BlueprintCallable, BlueprintAuthorityOnly, Category, Meta FGameplayAbilitySpecHandle

K2_GiveAbilityAndActivateOnce ( TSubclassOf< UGameplayAbility > AbilityClass,
int32 Level,
int32 InputID
)

 Grants a Gameplay Ability, activates it once, and removes it.
Public function UFunction BlueprintCallable, Category, Meta void

K2_InitStats ( TSubclassOf< class UAttributeSet > Attributes,
const UDataTable* DataTable
)

  
Public function Virtual void  
Public function Virtual void Handle confirm/cancel for target actors
Public function Virtual Const UFunction BlueprintCallable, Category FGameplayEffectContextHandle Create an EffectContext for the owner of this AbilitySystemComponent
Public function Virtual Const UFunction BlueprintCallable, Category FGameplayEffectSpecHandle

MakeOutgoingSpec ( TSubclassOf< UGameplayEffect > GameplayEffectClass,
float Level,
FGameplayEffectContextHandle Context
)

 Get an outgoing GameplayEffectSpec that is ready to be applied to other things.
Public function void

MarkAbilitySpecDirty ( FGameplayAbilitySpec& Spec,
bool WasAddOrRemove
)

 Call to mark that an ability spec has been modified
Public function Virtual void Modify the start time of a gameplay effect, to deal with timers being out of sync originally
Protected function Virtual void

MonitoredTagChanged ( const FGameplayTag Tag,
int32 NewCount
)

 Callback that is called when an owned tag bound to an ability changes
Public function Virtual void  
Public function Virtual void Call notify callbacks above
Public function Virtual void

NotifyAbilityEnded ( FGameplayAbilitySpecHandle Handle,
UGameplayAbility* Ability,
bool bWasCancelled
)

 Called from the ability to let the component know it is ended
Public function Virtual void  
Protected function void  
Public function FOnGivenActiveGameplayEffectRemoved & Called when any gameplay effects are removed
Public function void

OnAttributeAggregatorDirty ( FAggregator* Aggregator,
FGameplayAttribute Attribute,
bool FromRecursiveCall
)

 Callbacks / Notifies (these need to be at the UObject level so we can safely bind, rather than binding to raw at the ActiveGameplayEffect/Container level which is unsafe if the AbilitySystemComponent were killed).
Public function UFunction void  
Protected function void  
Public function Virtual void

OnClientPrintDebug_Response ( const TArray< FString >& Strings,
int32 GameFlags
)

  
Public function void  
Public function void This ASC has successfully applied a GE to something (potentially itself)
Public function Virtual void Called when the duration of a gamepaly effect has changed
Public function FOnActiveGameplayEffectRemoved_Info *  
Public function FOnActiveGameplayEffectStackChange *  
Public function FOnActiveGameplayEffectTimeChange *  
Protected function Virtual void Will be called from GiveAbility or from OnRep.
Public function void Called when attribute magnitudes change, to forward information to dependent gameplay effects
Public function UFunction void  
Public function void  
Public function void  
Public function Virtual void Called when the ASC's AbilityActorInfo has a PlayerController set.
Public function Virtual void Called for predictively added gameplay cue.
Protected function void

OnPredictiveMontageRejected ( UAnimMontage* PredictiveMontage
)

 Called when a prediction key that played a montage is rejected
Protected function Virtual void Will be called from RemoveAbility or from OnRep. Unbinds inputs with the given ability
Protected function Virtual UFunction void  
Public function Virtual UFunction void  
Public function UFunction void  
Protected function Virtual UFunction void Replicated Event for AnimMontages
Public function Virtual UFunction void  
Public function Virtual void Virtual function games can override to do their own stuff when either ServerPrintDebug function runs on the server
Public function Static void

OnShowDebugInfo ( AHUD* HUD,
UCanvas* Canvas,
const FDebugDisplayInfo& DisplayInfo,
float& YL,
float& YPos
)

  
Public function UFunction void  
Protected function Virtual void

OnTagUpdated ( const FGameplayTag& Tag,
bool TagExists
)

  
Public function Virtual float

PlayMontage ( UGameplayAbility* AnimatingAbility,
FGameplayAbilityActivationInfo ActivationInfo,
UAnimMontage* Montage,
float InPlayRate,
FName StartSectionName,
float StartTimeSeconds
)

 AnimMontage Support
Public function Virtual float

PlayMontageSimulated ( UAnimMontage* Montage,
float InPlayRate,
FName StartSectionName
)

 Plays a montage without updating replication/prediction structures.
Public function UFunction BlueprintCallable, Category void

PressInputID ( int32 InputID
)

 Sends a local player Input Pressed event with the provided Input ID, notifying any bound abilities
Public function Const void Print a debug list of all gameplay effects
Public function Virtual void  
Public function Virtual void

RecomputeGameplayEffectStartTimes ( const float WorldTime,
const float ServerWorldTime
)

 Called whenever the server time replicates via the game state to keep our cooldown timers in sync with the server
Public function void This will refresh the Ability's ActorInfo structure based on the current ActorInfo.
Public function FDelegateHandle

RegisterAndCallGameplayTagEvent ( FGameplayTag Tag,
FOnGameplayEffectTagCountChanged::FDelegate Delegate,
EGameplayTagEventType::Type EventType
)

 Register a tag event and immediately call it
Public function FOnGameplayAttributeChange & Register for when an attribute value changes, should be replaced by GetGameplayAttributeValueChangeDelegate
Public function FOnGameplayEffectTagCountChanged & Allow events to be registered for specific gameplay tags being added or removed
Public function FOnGameplayEffectTagCountChanged & Returns multicast delegate that is invoked whenever a tag is added or removed (but not if just count is increased. Only for 'new' and 'removed' events)
Public function Virtual void Invokes the WhileActive event for all GCs on active, non inhibited, GEs.
Public function UFunction BlueprintCallable, Category void

ReleaseInputID ( int32 InputID
)

 Sends a local player Input Released event with the provided Input ID, notifying any bound abilities
Protected function void

RemoteEndOrCancelAbility ( FGameplayAbilitySpecHandle AbilityToEnd,
FGameplayAbilityActivationInfo ActivationInfo,
bool bWasCanceled
)

 Called by ServerEndAbility and ClientEndAbility; avoids code duplication.
Public function Virtual int32

RemoveActiveEffects ( const FGameplayEffectQuery& Query,
int32 StacksToRemove
)

 Removes all active effects that match given query. StacksToRemove=-1 will remove all stacks.
Public function UFunction BlueprintCallable, Category int32 Removes all active effects that apply any of the tags in Tags
Public function UFunction BlueprintCallable, Category int32 Removes all active effects that grant any of the tags in Tags
Public function UFunction BlueprintCallable, Category int32 Removes all active effects with captured source tags that contain any of the tags in Tags
Public function UFunction BlueprintCallable, Category int32 Removes all active effects that contain any of the tags in Tags
Public function Virtual UFunction BlueprintCallable, BlueprintAuthorityOnly, Category bool

RemoveActiveGameplayEffect ( FActiveGameplayEffectHandle Handle,
int32 StacksToRemove
)

 Removes GameplayEffect by Handle. StacksToRemove=-1 will remove all stacks.
Public function void This only exists so it can be hooked up to a multicast delegate
Public function Virtual UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void

RemoveActiveGameplayEffectBySourceEffect ( TSubclassOf< UGameplayEffect > GameplayEffect,
UAbilitySystemComponent* InstigatorAbilitySystemComponent,
int32 StacksToRemove
)

 Remove active gameplay effects whose backing definition are the specified gameplay effect class
Public function void Removes any GameplayCue added on its own, i.e. not as part of a GameplayEffect.
Protected function void Unregister all the gameplay abilities of this component
Public function void Remove all attribute sets
Public function void

RemoveGameplayCue ( const FGameplayTag GameplayCueTag
)

 Remove a persistent gameplay cue
Protected function Virtual void

RemoveGameplayCue_Internal ( const FGameplayTag GameplayCueTag,
FActiveGameplayCueContainer& GameplayCueContainer
)

  
Public function void Remove gameplaycue for minimal replication mode.
Public function void Remotes previously registered delegate
Public function void

RemoveLooseGameplayTag ( const FGameplayTag& GameplayTag,
int32 Count
)

  
Public function void

RemoveLooseGameplayTags ( const FGameplayTagContainer& GameplayTags,
int32 Count
)

  
Public function void  
Public function void  
Protected function void Remove a gameplay ability associated to this component
Public function void  
Public function void  
Public function void Remove an existing attribute set
Public function Virtual void Replicate that an ability has ended/canceled, to the client or server as appropriate
Protected function void  
Public function UFunction Server, Reliable withvalidation void  
Public function Virtual void Overridable function for sub classes.
Protected function UFunction Server, Reliable withvalidation void  
Protected function UFunction Server, Reliable withvalidation void

ServerCurrentMontageJumpToSectionName ( UAnimMontage* ClientAnimMontage,
FName SectionName
)

 RPC function called from CurrentMontageJumpToSection, replicates to other clients
Protected function UFunction Server, Reliable withvalidation void

ServerCurrentMontageSetNextSectionName ( UAnimMontage* ClientAnimMontage,
float ClientPosition,
FName SectionName,
FName NextSectionName
)

 RPC function called from CurrentMontageSetNextSectopnName, replicates to other clients
Protected function UFunction Server, Reliable withvalidation void

ServerCurrentMontageSetPlayRate ( UAnimMontage* ClientAnimMontage,
float InPlayRate
)

 RPC function called from CurrentMontageSetPlayRate, replicates to other clients
Protected function UFunction Server, Reliable withvalidation void  
Public function UFunction Server, Reliable withvalidation void Ask the server to send ability system debug information back to the client, via ClientPrintDebug_Response
Public function UFunction Server, Reliable withvalidation void Same as ServerPrintDebug_Request but this includes the client debug strings so that the server can embed them in replays
Public function UFunction Server, Reliable withvalidation void Direct Input state replication.
Public function UFunction Server, Reliable withvalidation void  
Public function UFunction Server, Reliable withvalidation void

ServerSetReplicatedEvent ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
FPredictionKey CurrentPredictionKey
)

 Synchronization RPCs While these appear to be state, these are actually synchronization events w/ some payload data
Public function UFunction Server, Reliable withvalidation void

ServerSetReplicatedEventWithPayload ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
FPredictionKey CurrentPredictionKey,
FVector_NetQuantize100 VectorPayload
)

 Replicates the Generic Replicated Event to the server with payload.
Public function UFunction Server, Reliable withvalidation void

ServerSetReplicatedTargetData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
const FGameplayAbilityTargetDataHandle& ReplicatedTargetDataHandle,
FGameplayTag ApplicationTag,
FPredictionKey CurrentPredictionKey
)

 Replicates targeting data to the server
Public function UFunction Server, Reliable withvalidation void

ServerSetReplicatedTargetDataCancelled ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
FPredictionKey CurrentPredictionKey
)

 Replicates to the server that targeting has been cancelled
Protected function UFunction Server, Reliable withvalidation void

ServerTryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
bool InputPressed,
FPredictionKey PredictionKey
)

  
Protected function UFunction Server, Reliable withvalidation void

ServerTryActivateAbilityWithEventData ( FGameplayAbilitySpecHandle AbilityToActivate,
bool InputPressed,
FPredictionKey PredictionKey,
FGameplayEventData TriggerEventData
)

  
Public function Virtual UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void Updates the level of an already applied gameplay effect.
Public function Virtual UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void Updates the level of an already applied gameplay effect.
Public function void

SetAvatarActor ( AActor* InAvatarActor
)

 Changes the avatar actor, leaves the owner actor the same
Public function void

SetAvatarActor_Direct ( AActor* NewAvatarActor
)

  
Public function void Call from OnRep functions to set the attribute base value on the client
Public function void

SetBaseAttributeValueFromReplication ( const FGameplayAttribute& Attribute,
float NewValue,
float OldValue
)

 Call from OnRep functions to set the attribute base value on the client
Public function Virtual void Initializes BlockedAbilityBindings variable
Protected function void

SetBlockedAbilityBindings ( const TArray< uint8 >& NewBlockedAbilityBindings
)

  
Public function void

SetClientDebugStrings ( TArray< FString >&& NewClientDebugStrings
)

  
Public function void

SetLooseGameplayTagCount ( const FGameplayTag& GameplayTag,
int32 NewCount
)

  
Protected function void

SetMinimalReplicationTags ( const FMinimalReplicationTagCountMap& NewMinimalReplicationTags
)

  
Public function void Method to set the replication method for the position in the montage
Protected function void

SetNumericAttribute_Internal ( const FGameplayAttribute& Attribute,
float& NewFloatValue
)

 Actually pushes the final attribute value to the attribute set's property.
Public function void

SetNumericAttributeBase ( const FGameplayAttribute& Attribute,
float NewBaseValue
)

 Sets the base value of an attribute.
Public function void

SetOwnerActor ( AActor* NewOwnerActor
)

  
Public function void Sets an ability spec to remove when its finished.
Protected function void

SetRepAnimMontageInfo ( const FGameplayAbilityRepAnimMontage& NewRepAnimMontageInfo
)

  
Public function void

SetReplicatedLooseGameplayTagCount ( const FGameplayTag& GameplayTag,
int32 NewCount
)

  
Public function Virtual void When true, we will not replicate active gameplay effects for this ability system component, so attributes and tags
Public function void

SetServerDebugStrings ( TArray< FString >&& NewServerDebugStrings
)

  
Public function void

SetSpawnedAttributes ( const TArray< UAttributeSet* >& NewAttributeSet
)

 Remove all current AttributeSets and register the ones in the passed array.
Public function void

SetTagMapCount ( const FGameplayTag& Tag,
int32 NewCount
)

 Forcibly sets the number of instances of a given tag
Public function Virtual UFunction BlueprintCallable, Category void

SetUserAbilityActivationInhibited ( bool NewInhibit
)

 Disable or Enable a local user from being able to activate abilities.
Public function Virtual Const bool  
Public function Virtual Const bool Returns true if this component should record montage replication info.
Public function Virtual Const bool Determines whether to call ServerPrintDebug_Request or ServerPrintDebug_RequestWithStrings.
Public function Virtual void

StopMontageIfCurrent ( const UAnimMontage& Montage,
float OverrideBlendOutTime
)

 Stops current montage if it's the one given as the Montage param
Public function Virtual UFunction BlueprintCallable, Category void Any active targeting actors will be stopped and canceled, not returning any targeting data
Public function Virtual UFunction BlueprintCallable, Category void Any active targeting actors will be told to stop and return current targeting data
Public function bool Triggers an ability from a gameplay event, will only trigger on local/server depending on execution flags
Public function UFunction BlueprintCallable, Category bool

TryActivateAbilitiesByTag ( const FGameplayTagContainer& GameplayTagContainer,
bool bAllowRemoteActivation
)

 Attempts to activate every gameplay ability that matches the given tag and DoesAbilitySatisfyTagRequirements().
Public function UFunction BlueprintCallable, Category bool

TryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
bool bAllowRemoteActivation
)

 Attempts to activate the given ability, will check costs and requirements before doing so.
Public function UFunction BlueprintCallable, Category bool

TryActivateAbilityByClass ( TSubclassOf< UGameplayAbility > InAbilityToActivate,
bool bAllowRemoteActivation
)

 Attempts to activate the ability that is passed in.
Public function void Block or cancel blocking for specific ability tags
Public function void

UnBlockAbilityByInputID ( int32 InputID
)

 Block or cancel blocking for specific input IDs
Public function bool Unregister previously added events
Public function Virtual UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void Dynamically update the set-by-caller magnitude for an active gameplay effect
Public function Virtual UFunction BlueprintCallable, BlueprintAuthorityOnly, Category void

UpdateActiveGameplayEffectSetByCallerMagnitudes ( FActiveGameplayEffectHandle ActiveHandle,
const TMap< FGameplayTag, float >& NewSetByCallerValues
)

 Dynamically update multiple set-by-caller magnitudes for an active gameplay effect
Protected function void  
Protected function void  
Public function void

UpdateTagMap ( const FGameplayTag& BaseTag,
int32 CountDelta
)

 Update the number of instances of a given tag and calls callback
Public function void

UpdateTagMap ( const FGameplayTagContainer& Container,
int32 CountDelta
)

 Update the number of instances of a given tag and calls callback
Protected function void

UpdateTagMap_Internal ( const FGameplayTagContainer& Container,
int32 CountDelta
)

  

Overridden from UGameplayTasksComponent

  Type Name Description
Public function Virtual Const bool Retrieves information whether this component should be ticking taken current activity into consideration

Overridden from UActorComponent

  Type Name Description
Public function Virtual void Begins Play for the component.
Public function Virtual void Initializes the component.
Public function Virtual void

OnComponentDestroyed ( bool bDestroyingHierarchy
)

 Called when a component is destroyed
Public function Virtual void Called when a component is registered, after Scene is set, but before CreateRenderState_Concurrent or OnCreatePhysicsState are called.
Public function Virtual void Called when a component is unregistered.
Public function Virtual void ReadyForReplication gets called on replicated components when their owning actor is officially ready for replication.
Public function Virtual bool Allows a component to replicate other subobject on the actor.
Public function Virtual void

TickComponent ( float DeltaTime,
enum ELevelTick TickType,
FActorComponentTickFunction* ThisTickFunction
)

 Function called every frame on this ActorComponent.
Public function Virtual void Handle this component being Uninitialized.

Overridden from UObject

  Type Name Description
Protected function Virtual Const void Returns properties that are replicated for the lifetime of the actor channel
Protected function Virtual Const void Called when this object begins replicating to initialize the state of custom property conditions
Public function Virtual void Returns a list of sub-objects that have stable names for networking
Public function Virtual void Called right after receiving a bunch
Public function Virtual void Called right before receiving a bunch

Overridden from IGameplayTaskOwnerInterface

  Type Name Description
Public function Virtual Const AActor * Returns avatar actor to be used for a specific task, normally GetAvatarActor

Overridden from IGameplayTagAssetInterface

  Type Name Description
Public function Virtual Const void Get any owned gameplay tags on the asset
Public function Virtual Const bool Check if the asset has gameplay tags that matches against all of the specified tags (expands to include parents of asset tags)
Public function Virtual Const bool Check if the asset has gameplay tags that matches against any of the specified tags (expands to include parents of asset tags)
Public function Virtual Const bool Gameplay tag operations Implements IGameplayTagAssetInterface using the TagCountContainer

Overridden from IAbilitySystemReplicationProxyInterface

  Type Name Description
Public function Virtual void Force owning actor to update it's replication, to make sure that gameplay cues get sent down quickly.
Public function Virtual UFunction Unreliable, NetMulticast void

NetMulticast_InvokeGameplayCueAdded ( const FGameplayTag GameplayCueTag,
FPredictionKey PredictionKey,
FGameplayEffectContextHandle EffectContext
)

  
Public function Virtual UFunction Unreliable, NetMulticast void  
Public function Virtual UFunction Unreliable, NetMulticast void  
Public function Virtual UFunction Unreliable, NetMulticast void  
Public function Virtual UFunction Unreliable, NetMulticast void  
Public function Virtual UFunction Unreliable, NetMulticast void Do not call these functions directly, call the wrappers on GameplayCueManager instead.
Public function Virtual UFunction Unreliable, NetMulticast void

NetMulticast_InvokeGameplayCueExecuted_WithParams ( const FGameplayTag GameplayCueTag,
FPredictionKey PredictionKey,
FGameplayCueParameters GameplayCueParameters
)

  
Public function Virtual UFunction Unreliable, NetMulticast void  
Public function Virtual UFunction Unreliable, NetMulticast void  
Public function Virtual UFunction Unreliable, NetMulticast void  

Classes

  Type Name Description
Public class FAbilityAbilityKey Used to register callbacks to ability-key input  
Public class FAbilityConfirmOrCancel Used to register callbacks to confirm/cancel input  
Protected struct FAbilityListLockActiveChange    
Public struct FAbilitySystemComponentDebugInfo Debugging  
Public struct FPendingAbilityInfo A pending activation that cannot be activated yet, will be rechecked at a later point  

Typedefs

Name Description
FOnGameplayEffectAppliedDelegate Delegate for when an effect is applied

Deprecated Variables

  Type Name Description
Protected variable UProperty TArray< TObjectPtr< UGameplayAbility > > AllReplicatedInstancedAbilities This array will be made private. Use GetReplicatedInstancedAbilities, AddReplicatedInstancedAbility or RemoveReplicatedInstancedAbility instead.
Protected variable UProperty Transient, Replicated TArray< uint8 > BlockedAbilityBindings This will be made private in future engine versions. Use SetBlockedAbilityBindings, GetBlockedAbilityBindings, or GetBlockedAbilityBindings_Mutable instead.
Public variable UProperty replicatedusing TArray< FString > ClientDebugStrings This will be made private in future engine versions. Use SetClientDebugStrings, GetClientDebugStrings, or GetClientDebugStrings_Mutable instead.
Protected variable UProperty Replicated FMinimalReplicationTagCountMap MinimalReplicationTags This will be made private in future engine versions. Use SetMinimalReplicationTags, GetMinimalReplicationTags, or GetMinimalReplicationTags_Mutable instead.
Protected variable UProperty replicatedusing FGameplayAbilityRepAnimMontage RepAnimMontageInfo This will be made private in future engine versions. Use SetRepAnimMontageInfo, GetRepAnimMontageInfo, or GetRepAnimMontageInfo_Mutable instead.
Public variable UProperty replicatedusing TArray< FString > ServerDebugStrings This will be made private in future engine versions. Use SetServerDebugStrings, GetServerDebugStrings, or GetServerDebugStrings_Mutable instead.

Deprecated Functions

  Type Name Description
Public function Const FGameplayAbilitySpec * FindAbilitySpecFromGEHandle was never accurate because a GameplayEffect can grant multiple GameplayAbilities. It now returns nullptr.
Public function TArray< TObjectPtr< UAttributeSet > > & This function will be made private. Use Add/Remove SpawnedAttributes instead
Protected function Virtual void Use OnImmunityBlockGameplayEffectDelegate directly. It is trigger from a UImmunityGameplayEffectComponent. You can create your own GameplayEffectComponent if you need different functionality.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page