1. Epic GamesDeveloper
  3. UAbilitySystemComponent

UAbilitySystemComponent

The core ActorComponent for interfacing with the GameplayAbilities System

API > API/Plugins > API/Plugins/GameplayAbilities

The core ActorComponent for interfacing with the GameplayAbilities System

   
Name UAbilitySystemComponent
Type class
Header File /Engine/Plugins/Runtime/GameplayAbilities/Source/GameplayAbilities/Public/AbilitySystemComponent.h
Include Path #include "AbilitySystemComponent.h"

Syntax

UCLASS (ClassGroup=AbilitySystem,  
       HideCategories=(Object, LOD, Lighting, Transform, Sockets, TextureStreaming),  
       EditInlineNew, Meta=(BlueprintSpawnableComponent), MinimalAPI)  
class UAbilitySystemComponent :  
    public UGameplayTasksComponent ,  
    public IGameplayTagAssetInterface ,  
    public IAbilitySystemReplicationProxyInterface

Inheritance Hierarchy

Implements Interfaces

Constructors

Name Remarks Include Path Unreal Specifiers

UAbilitySystemComponent ( const FObjectInitializer& ObjectInitializer
)

   AbilitySystemComponent.h  

Classes

Name Remarks
FAbilityAbilityKey Used to register callbacks to ability-key input
FAbilityConfirmOrCancel Used to register callbacks to confirm/cancel input

Structs

Name Remarks
FAbilityListLockActiveChange  
FAbilitySystemComponentDebugInfo Debugging
FPendingAbilityInfo A pending activation that cannot be activated yet, will be rechecked at a later point

Typedefs

Name Type Remarks Include Path
FOnGameplayEffectAppliedDelegate TMulticastDelegate_ThreeParams< void, UAbilitySystemComponent *, const FGameplayEffectSpec &, FActiveGameplayEffectHandle > Delegate for when an effect is applied AbilitySystemComponent.h

Variables

Public

Name Type Remarks Include Path Unreal Specifiers
AbilityActivatedCallbacks FGenericAbilityDelegate A generic callback anytime an ability is activated (started) AbilitySystemComponent.h  
AbilityActorInfo TSharedPtr< FGameplayAbilityActorInfo > Cached off data about the owning actor that abilities will need to frequently access (movement component, mesh component, anim instance, etc) AbilitySystemComponent.h  
AbilityCommittedCallbacks FGenericAbilityDelegate A generic callback anytime an ability is committed (cost/cooldown applied) AbilitySystemComponent.h  
AbilityEndedCallbacks FAbilityEnded Callback anytime an ability is ended AbilitySystemComponent.h  
AbilityFailedCallbacks FAbilityFailedDelegate Called with a failure reason when an ability fails to activate AbilitySystemComponent.h  
AbilitySpecDirtiedCallbacks FAbilitySpecDirtied Called when an ability spec's internals have changed AbilitySystemComponent.h  
AffectedAnimInstanceTag FName The linked Anim Instance that this component will play montages in. AbilitySystemComponent.h
  • BlueprintReadWrite
  • EditAnywhere
  • Category="Skills"
bSuppressGameplayCues bool Suppress all GameplayCues on this component AbilitySystemComponent.h  
bSuppressGrantAbility bool Suppress all ability granting through GEs on this component AbilitySystemComponent.h  
ClientDebugStrings TArray< FString >   AbilitySystemComponent.h
  • ReplicatedUsing=OnRep_ClientDebugString
DefaultStartingData TArray< FAttributeDefaults >   AbilitySystemComponent.h
  • EditAnywhere
  • Category="AttributeTest"
GameplayEffectApplicationQueries TArray< FGameplayEffectApplicationQuery > We allow users to setup a series of functions that must be true in order to allow a GameplayEffect to be applied AbilitySystemComponent.h  
GenericCancelInputID int32   AbilitySystemComponent.h  
GenericConfirmInputID int32 InputID for binding GenericConfirm/Cancel events AbilitySystemComponent.h  
GenericGameplayEventCallbacks TMap< FGameplayTag, FGameplayEventMulticastDelegate > Callbacks bound to Gameplay tags, these only activate if the exact tag is used. AbilitySystemComponent.h  
GenericLocalCancelCallbacks FAbilityConfirmOrCancel Generic local callback for generic CancelEvent that any ability can listen to AbilitySystemComponent.h  
GenericLocalConfirmCallbacks FAbilityConfirmOrCancel Generic local callback for generic ConfirmEvent that any ability can listen to AbilitySystemComponent.h  
IncomingDuration float Internal Attribute that modifies the duration of gameplay effects applied to this component AbilitySystemComponent.h
  • Meta=(SystemGameplayAttribute="true")
InternalTryActivateAbilityFailureTags FGameplayTagContainer Failure tags used by InternalTryActivateAbility (E.g., this stores the FailureTags of the last call to InternalTryActivateAbility AbilitySystemComponent.h  
LocalServerAbilityRPCBatchData TArray< FServerAbilityRPCBatch, TInlineAllocator< 1 > > Accumulated client side data that is batched out to server on EndServerAbilityRPCBatch AbilitySystemComponent.h  
OnAbilityEnded FGameplayAbilityEndedDelegate Callback anytime an ability is ended, with extra information AbilitySystemComponent.h  
OnActiveGameplayEffectAddedDelegateToSelf FOnGameplayEffectAppliedDelegate Called on both client and server whenever a duration based GE is added (E.g., instant GEs do not trigger this). AbilitySystemComponent.h  
OnGameplayEffectAppliedDelegateToSelf FOnGameplayEffectAppliedDelegate Called on server whenever a GE is applied to self. This includes instant and duration based GEs. AbilitySystemComponent.h  
OnGameplayEffectAppliedDelegateToTarget FOnGameplayEffectAppliedDelegate Called on server whenever a GE is applied to someone else. AbilitySystemComponent.h  
OnImmunityBlockGameplayEffectDelegate FImmunityBlockGE Immunity notification support AbilitySystemComponent.h  
OnPeriodicGameplayEffectExecuteDelegateOnSelf FOnGameplayEffectAppliedDelegate Called on server whenever a periodic GE executes on self AbilitySystemComponent.h  
OnPeriodicGameplayEffectExecuteDelegateOnTarget FOnGameplayEffectAppliedDelegate Called on server whenever a periodic GE executes on target AbilitySystemComponent.h  
OutgoingDuration float System Attributes AbilitySystemComponent.h
  • Meta=(SystemGameplayAttribute="true")
PendingServerActivatedAbilities TArray< FPendingAbilityInfo > This is a list of GameplayAbilities that were activated on the server and can't yet execute on the client. AbilitySystemComponent.h  
ReplicatedPredictionKeyMap FReplicatedPredictionKeyMap PredictionKeys, see more info in GameplayPrediction.h. AbilitySystemComponent.h
  • Replicated
  • Transient
ReplicationMode EGameplayEffectReplicationMode How gameplay effects are replicated AbilitySystemComponent.h  
ReplicationProxyEnabled bool When enabled GameplayCue RPCs will be routed through the AvatarActor's IAbilitySystemReplicationProxyInterface rather than this component AbilitySystemComponent.h  
ScopedPredictionKey FPredictionKey Current prediction key, set with FScopedPredictionWindow AbilitySystemComponent.h  
ServerDebugStrings TArray< FString >   AbilitySystemComponent.h
  • ReplicatedUsing=OnRep_ServerDebugString
SpawnedTargetActors TArray< TObjectPtr< AGameplayAbilityTargetActor > > List of currently active targeting actors AbilitySystemComponent.h  
UserAbilityActivationInhibited bool Rather activation is currently inhibited AbilitySystemComponent.h  

Protected

Name Type Remarks Include Path Unreal Specifiers
AvatarActor TObjectPtr< AActor > The actor that is the physical representation used for abilities. Can be NULL AbilitySystemComponent.h
  • ReplicatedUsing=OnRep_OwningActor
bDestroyActiveStateInitiated uint8   AbilitySystemComponent.h  
BlockedAbilityBindings TArray< uint8 > Tracks abilities that are blocked based on input binding. AbilitySystemComponent.h
  • Transient
  • Replicated
MinimalReplicationTags FMinimalReplicationTagCountMap   AbilitySystemComponent.h
  • Replicated
MonitoredTagChangedDelegateHandle FDelegateHandle   AbilitySystemComponent.h  
OnRep_ActivateAbilitiesTimerHandle FTimerHandle   AbilitySystemComponent.h  
OwnerActor TObjectPtr< AActor > Actor interaction    

The actor that owns this component logically | AbilitySystemComponent.h |

  • ReplicatedUsing=OnRep_OwningActor
|
ReplicatedLooseTags FMinimalReplicationTagCountMap Container used for replicating loose gameplay tags AbilitySystemComponent.h
  • Replicated
SpawnedAttributes TArray< TObjectPtr< UAttributeSet > > List of attribute sets AbilitySystemComponent.h
  • Replicated
  • ReplicatedUsing=OnRep_SpawnedAttributes
  • Transient

Functions

Public

Name Remarks Include Path Unreal Specifiers

virtual void AbilityLocalInputPressed ( int32 InputID
)

 Called to handle ability bind input AbilitySystemComponent.h  

virtual void AbilityLocalInputReleased ( int32 InputID
)

   AbilitySystemComponent.h  

FSimpleMulticastDelegate & AbilityReplicatedEventDelegate ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Returns Generic Replicated Event for a given Ability/PredictionKey pair AbilitySystemComponent.h  
Called on local player always. AbilitySystemComponent.h  
Called on local player always. AbilitySystemComponent.h  

FSimpleMulticastDelegate & AbilityTargetDataCancelledDelegate ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Returns TargetData Cancelled delegate for a given Ability/PredictionKey pair AbilitySystemComponent.h  

FAbilityTargetDataSetDelegate & AbilityTargetDataSetDelegate ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Returns TargetDataSet delegate for a given Ability/PredictionKey pair AbilitySystemComponent.h  

void AccumulateScreenPos ( FAbilitySystemComponentDebugInfo& Info
)

   AbilitySystemComponent.h  

const T * AddAttributeSetSubobject ( T* Subobject
)

 Manually add a new attribute set that is a subobject of this ability system component. AbilitySystemComponent.h  

void AddGameplayCue ( const FGameplayTag GameplayCueTag,
const FGameplayCueParameters& GameplayCueParameters
)

   AbilitySystemComponent.h  

void AddGameplayCue ( const FGameplayTag GameplayCueTag,
FGameplayEffectContextHandle EffectContext
)

 Add a persistent gameplay cue AbilitySystemComponent.h  

void AddGameplayCue_MinimalReplication ( const FGameplayTag GameplayCueTag,
FGameplayEffectContextHandle EffectContext
)

 Add gameplaycue for minimal replication mode. AbilitySystemComponent.h  

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

 Adds a new delegate to call when gameplay events happen. AbilitySystemComponent.h  

void AddLooseGameplayTag ( const FGameplayTag& GameplayTag,
int32 Count,
EGameplayTagReplicationState TagRepState
)

 Allows GameCode to add loose gameplaytags which are not backed by a GameplayEffect. AbilitySystemComponent.h  

void AddLooseGameplayTags ( const FGameplayTagContainer& GameplayTags,
int32 Count,
EGameplayTagReplicationState TagRepState
)

   AbilitySystemComponent.h  

void AddMinimalReplicationGameplayTag ( const FGameplayTag& GameplayTag
)

 Minimally replicated tags are replicated tags that come from GEs when in bMinimalReplication mode. AbilitySystemComponent.h  

void AddMinimalReplicationGameplayTags ( const FGameplayTagContainer& GameplayTags
)

   AbilitySystemComponent.h  

const T * AddSet()

 Adds a new AttributeSet (initialized to default values) AbilitySystemComponent.h  

void AddSpawnedAttribute ( UAttributeSet* Attribute
)

 Add a new attribute set AbilitySystemComponent.h  

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. AbilitySystemComponent.h  

virtual FActiveGameplayEffectHandle ApplyGameplayEffectSpecToSelf ( const FGameplayEffectSpec& GameplayEffect,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h  

virtual FActiveGameplayEffectHandle ApplyGameplayEffectSpecToTarget ( const FGameplayEffectSpec& GameplayEffect,
UAbilitySystemComponent* Target,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h  

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 AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects
  • Meta=(DisplayName="ApplyGameplayEffectToSelf", ScriptName="ApplyGameplayEffectToSelf")

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 AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects
  • Meta=(DisplayName="ApplyGameplayEffectToTarget", ScriptName="ApplyGameplayEffectToTarget")

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

 Applies an in-place mod to the given attribute. AbilitySystemComponent.h  

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

 Applies an inplace mod to the given attribute. AbilitySystemComponent.h  

virtual bool AreAbilityTagsBlocked ( const FGameplayTagContainer& Tags
) const

 Returns true if any passed in tags are blocked AbilitySystemComponent.h  

virtual void BeginServerAbilityRPCBatch ( FGameplayAbilitySpecHandle AbilityHandle
)

   AbilitySystemComponent.h  

virtual void BindAbilityActivationToInputComponent ( UInputComponent* InputComponent,
FGameplayAbilityInputBinds BindInfo
)

 Bind to an input component with customized bindings AbilitySystemComponent.h  

virtual void BindToInputComponent ( UInputComponent* InputComponent
)

 Bind to an input component with some default action names AbilitySystemComponent.h  

void BlockAbilitiesWithTags ( const FGameplayTagContainer& Tags
)

 Block or cancel blocking for specific ability tags AbilitySystemComponent.h  

void BlockAbilityByInputID ( int32 InputID
)

 Block or cancel blocking for specific input IDs AbilitySystemComponent.h  

FActiveGameplayEffectHandle BP_ApplyGameplayEffectSpecToSelf ( const FGameplayEffectSpecHandle& SpecHandle
)

 Applies a previously created gameplay effect spec to this component AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects
  • Meta=(DisplayName="ApplyGameplayEffectSpecToSelf", ScriptName="ApplyGameplayEffectSpecToSelf")
GameplayEffects: Primary outward facing API for other systems AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects
  • Meta=(DisplayName="ApplyGameplayEffectSpecToTarget", ScriptName="ApplyGameplayEffectSpecToTarget")
Apply a gameplay effect to self AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects
  • Meta=(DisplayName="ApplyGameplayEffectToSelf", ScriptName="ApplyGameplayEffectToSelf")

FActiveGameplayEffectHandle BP_ApplyGameplayEffectToTarget ( TSubclassOf< UGameplayEffect > GameplayEffectClass,
UAbilitySystemComponent* Target,
float Level,
FGameplayEffectContextHandle Context
)

 Additional Helper FunctionsApply a gameplay effect to passed in target AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects
  • Meta=(DisplayName="ApplyGameplayEffectToTarget", ScriptName="ApplyGameplayEffectToTarget")

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

 Build a simple FGameplayAbilitySpec from class, level and optional Input ID AbilitySystemComponent.h  

void CacheIsNetSimulated()

 Caches the flags that indicate whether this component has network authority. AbilitySystemComponent.h  

void CallAllReplicatedDelegatesIfSet ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Calls any Replicated delegates that have been sent (TargetData or Generic Replicated Events). AbilitySystemComponent.h  

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

 Calls passed in delegate if the Client Event has already been sent. AbilitySystemComponent.h  

bool CallReplicatedEventDelegateIfSet ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Calls a given Generic Replicated Event delegate if the event has already been sent AbilitySystemComponent.h  

bool CallReplicatedTargetDataDelegatesIfSet ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Calls the TargetData Confirm/Cancel events if they have been sent. AbilitySystemComponent.h  

void CallServerEndAbility ( FGameplayAbilitySpecHandle AbilityToEnd,
FGameplayAbilityActivationInfo ActivationInfo,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h  

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

   AbilitySystemComponent.h  

void CallServerTryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
bool InputPressed,
FPredictionKey PredictionKey
)

 Batching client->server RPCs This is a WIP feature to batch up client->server communication. AbilitySystemComponent.h  

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

 Tests if all modifiers in this GameplayEffect will leave the attribute > 0.f AbilitySystemComponent.h  

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

 Cancel all abilities with the specified tags. Will not cancel the Ignore instance AbilitySystemComponent.h  

void CancelAbility ( UGameplayAbility* Ability
)

 Ability Cancelling/InterruptsCancels the specified ability CDO. AbilitySystemComponent.h  

void CancelAbilityHandle ( const FGameplayAbilitySpecHandle& AbilityHandle
)

 Cancels the ability indicated by passed in spec handle. AbilitySystemComponent.h  

virtual void CancelAbilityTargetData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Cancels the ability target data and calls callbacks AbilitySystemComponent.h  

void CancelAllAbilities ( UGameplayAbility* Ignore
)

 Cancels all abilities regardless of tags. Will not cancel the ignore instance AbilitySystemComponent.h  

bool CanPredict()

 Do we have a valid prediction key to do more predictive actions with AbilitySystemComponent.h  

void CaptureAttributeForGameplayEffect ( FGameplayEffectAttributeCaptureSpec& OutCaptureSpec
)

 Populate the specified capture spec with the data necessary to capture an attribute from the component AbilitySystemComponent.h  

FString CleanupName ( FString Str
)

   AbilitySystemComponent.h  

void ClearAbility ( const FGameplayAbilitySpecHandle& Handle
)

 Removes the specified ability. This will be ignored if the actor is not authoritative. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Gameplay Abilities"

void ClearAbilityReplicatedDataCache ( FGameplayAbilitySpecHandle Handle,
const FGameplayAbilityActivationInfo& ActivationInfo
)

   AbilitySystemComponent.h  

virtual void ClearActorInfo()

 This is called when the actor that is initialized to this system dies, this will clear that actor from this system and FGameplayAbilityActorInfo AbilitySystemComponent.h  

void ClearAllAbilities()

 Wipes all 'given' abilities. This will be ignored if the actor is not authoritative. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Gameplay Abilities"

void ClearAllAbilitiesWithInputID ( int32 InputID
)

 Clears all abilities bound to a given Input ID This will be ignored if the actor is not authoritative AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Gameplay Abilities"

virtual void ClearAnimatingAbility ( UGameplayAbility* Ability
)

 Clear the animating ability that is passed in, if it's still currently animating AbilitySystemComponent.h  

void ClearDebugInstantEffects()

   AbilitySystemComponent.h  

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

   AbilitySystemComponent.h
  • Client
  • Reliable

void ClientSetReplicatedEvent ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Replicates the Generic Replicated Event to the client. AbilitySystemComponent.h
  • Client
  • Reliable

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

 Sets the current target data and calls applicable callbacks AbilitySystemComponent.h  

void ConsumeAllReplicatedData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Deletes all cached ability client data (Was: ConsumeAbilityTargetData) AbilitySystemComponent.h  

void ConsumeClientReplicatedTargetData ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Consumes cached TargetData from client (only TargetData) AbilitySystemComponent.h  

void ConsumeGenericReplicatedEvent ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Consumes the given Generic Replicated Event (unsets it). AbilitySystemComponent.h  

virtual void CurrentMontageJumpToSection ( FName SectionName
)

 Jumps current montage to given section. AbilitySystemComponent.h  

virtual void CurrentMontageSetNextSectionName ( FName FromSectionName,
FName ToSectionName
)

 Sets current montages next section name. AbilitySystemComponent.h  

virtual void CurrentMontageSetPlayRate ( float InPlayRate
)

 Sets current montage's play rate AbilitySystemComponent.h  

virtual void CurrentMontageStop ( float OverrideBlendOutTime
)

 Stops whatever montage is currently playing. AbilitySystemComponent.h  

virtual void Debug_Internal ( FAbilitySystemComponentDebugInfo& Info
)

   AbilitySystemComponent.h  

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

   AbilitySystemComponent.h  

void DecrementAbilityListLock()

   AbilitySystemComponent.h  

virtual void DestroyActiveState()

 Cancels all abilities and kills any remaining instanced abilities AbilitySystemComponent.h  

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

   AbilitySystemComponent.h  

virtual void EndServerAbilityRPCBatch ( FGameplayAbilitySpecHandle AbilityHandle
)

   AbilitySystemComponent.h  

void ExecuteGameplayCue ( const FGameplayTag GameplayCueTag,
const FGameplayCueParameters& GameplayCueParameters
)

   AbilitySystemComponent.h  

void ExecuteGameplayCue ( const FGameplayTag GameplayCueTag,
FGameplayEffectContextHandle EffectContext
)

 GameplayCues can also come on their own. AbilitySystemComponent.h  
Returns an ability spec corresponding to given ability class. AbilitySystemComponent.h  

FGameplayAbilitySpec * FindAbilitySpecFromGEHandle ( FActiveGameplayEffectHandle Handle
) const

 Returns an ability spec from a GE handle. If modifying call MarkAbilitySpecDirty AbilitySystemComponent.h  
Returns an ability spec from a handle. AbilitySystemComponent.h  

FGameplayAbilitySpec * FindAbilitySpecFromInputID ( int32 InputID
) const

 Returns an ability spec from a handle. If modifying call MarkAbilitySpecDirty AbilitySystemComponent.h  

TArray< const FGameplayAbilitySpec * > FindAbilitySpecsFromGEHandle ( const FScopedAbilityListLock& ScopeLock,
FActiveGameplayEffectHandle Handle,
EConsiderPending ConsiderPending
) const

 Returns all ability spec handles granted from a GE handle. Only the server may call this function. AbilitySystemComponent.h  

FActiveGameplayEffectHandle FindActiveGameplayEffectHandle ( FGameplayAbilitySpecHandle Handle
) const

 Gets the GE Handle of the GE that granted the passed in Ability AbilitySystemComponent.h  

void FindAllAbilitiesMatchingQuery ( TArray< FGameplayAbilitySpecHandle >& OutAbilityHandles,
FGameplayTagQuery Query
) const

 Returns an array with all abilities that match the provided Gameplay Tag Query AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure=false
  • Category="Gameplay Abilities"

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

 Returns an array with all abilities bound to an Input ID value AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure=false
  • Category="Gameplay Abilities"

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

 Returns an array with all abilities that match the provided tags AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure=false
  • Category="Gameplay Abilities"

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

 Returns all abilities with the given InputID AbilitySystemComponent.h  

virtual void ForceAvatarReplication ()

 Replication AbilitySystemComponent.h  
Force cancels the ability and does not replicate this to the other side. AbilitySystemComponent.h  
Returns local world time that an ability was activated. AbilitySystemComponent.h  
Functions meant to be called from GameplayAbility and subclasses, but not meant for general use AbilitySystemComponent.h  
Returns the list of all activatable abilities. AbilitySystemComponent.h  

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

 Gets all Activatable Gameplay Abilities that match all tags in GameplayTagContainer AND for which DoesAbilitySatisfyTagRequirements() is true. AbilitySystemComponent.h  

FActiveGameplayEffectEvents * GetActiveEffectEventSet ( FActiveGameplayEffectHandle Handle
)

 Returns delegate structure that allows binding to several gameplay effect changes AbilitySystemComponent.h  

TArray< FActiveGameplayEffectHandle > GetActiveEffects ( const FGameplayEffectQuery& Query
) const

 Returns list of active effects, for a query AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure=false
  • Category="GameplayEffects"
  • Meta=(DisplayName="Get Active Gameplay Effects for Query")

TArray< float > GetActiveEffectsDuration ( const FGameplayEffectQuery& Query
) const

 Gets total duration for all effects that match query AbilitySystemComponent.h  

float GetActiveEffectsEndTime ( const FGameplayEffectQuery& Query
) const

 This will give the world time that all effects matching this query will be finished. AbilitySystemComponent.h  

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

 Returns end time and total duration AbilitySystemComponent.h  

float GetActiveEffectsEndTimeWithInstigators ( const FGameplayEffectQuery& Query,
TArray< AActor* >& Instigators
) const

   AbilitySystemComponent.h  

TArray< float > GetActiveEffectsTimeRemaining ( const FGameplayEffectQuery& Query
) const

 Gets time remaining for all effects that match query AbilitySystemComponent.h  

TArray< TPair< float, float > > GetActiveEffectsTimeRemainingAndDuration ( const FGameplayEffectQuery& Query
) const

 Gets both time remaining and total duration for all effects that match query AbilitySystemComponent.h  

TArray< FActiveGameplayEffectHandle > GetActiveEffectsWithAllTags ( FGameplayTagContainer Tags
) const

 Returns list of active effects that have all of the passed in tags AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure=false
  • Category="GameplayEffects"

const FActiveGameplayEffect * GetActiveGameplayEffect ( const FActiveGameplayEffectHandle Handle
) const

 Returns const pointer to the actual active gameplay effect structure AbilitySystemComponent.h  

const FActiveGameplayEffectsContainer & GetActiveGameplayEffects()

 Returns all active gameplay effects on this ASC AbilitySystemComponent.h  

FString GetActiveGEDebugString ( FActiveGameplayEffectHandle Handle
) const

 Returns debug string describing active gameplay effect AbilitySystemComponent.h  

int32 GetAggregatedStackCount ( const FGameplayEffectQuery& Query
) const

 Returns the sum of StackCount of all gameplay effects that pass query AbilitySystemComponent.h  

void GetAllAbilities ( TArray< FGameplayAbilitySpecHandle >& OutAbilityHandles
) const

 Returns an array with all granted ability handles NOTE: currently this doesn't include abilities that are mid-activation AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure=false
  • Category="Gameplay Abilities"

void GetAllActiveGameplayEffectSpecs ( TArray< FGameplayEffectSpec >& OutSpecCopies
) const

 Makes a copy of all the active effects on this ability component AbilitySystemComponent.h  

void GetAllAttributes ( TArray< FGameplayAttribute >& OutAttributes
)

 Returns a list of all attributes for this abilty system component AbilitySystemComponent.h
  • BlueprintPure
  • Category="Gameplay Attributes"

UGameplayAbility * GetAnimatingAbility()

 Returns the current animating ability AbilitySystemComponent.h  

const UAttributeSet * GetAttributeSet ( TSubclassOf< UAttributeSet > AttributeSetClass
) const

 Returns a reference to the Attribute Set instance, if one exists in this component AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure=false
  • Category="Gameplay Attributes"
  • Meta=(DeterminesOutputType=AttributeSetClass)

AActor * GetAvatarActor()

 Returns the avatar actor for this component AbilitySystemComponent.h  

AActor * GetAvatarActor_Direct()

   AbilitySystemComponent.h  
  AbilitySystemComponent.h  

void GetBlockedAbilityTags ( FGameplayTagContainer& TagContainer
) const

 Fills TagContainer with BlockedAbilityTags AbilitySystemComponent.h  

const TArray< FString > & GetClientDebugStrings()

   AbilitySystemComponent.h  

TArray< FString > & GetClientDebugStrings_Mutable()

   AbilitySystemComponent.h  

UAnimMontage * GetCurrentMontage()

 Returns montage that is currently playing AbilitySystemComponent.h  

int32 GetCurrentMontageSectionID()

 Get SectionID of currently playing AnimMontage AbilitySystemComponent.h  

float GetCurrentMontageSectionLength()

 Get length in time of current section AbilitySystemComponent.h  

FName GetCurrentMontageSectionName()

 Get SectionName of currently playing AnimMontage AbilitySystemComponent.h  

float GetCurrentMontageSectionTimeLeft()

 Returns amount of time left in current section AbilitySystemComponent.h  
Returns current stack count of an already applied GE AbilitySystemComponent.h  
Returns current stack count of an already applied GE, but given the ability spec handle that was granted by the GE AbilitySystemComponent.h  

FGameplayEffectContextHandle GetEffectContextFromActiveGEHandle ( FActiveGameplayEffectHandle Handle
)

 Retrieves the EffectContext of the GameplayEffect of the active GameplayEffect. AbilitySystemComponent.h  

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

 Returns an attribute value, after applying tag filters AbilitySystemComponent.h  

float GetGameplayAttributeValue ( FGameplayAttribute Attribute,
bool& bFound
) const

 Returns the current value of the given gameplay attribute, or zero if the attribute is not found. AbilitySystemComponent.h
  • BlueprintPure
  • Category="Gameplay Attributes"

FOnGameplayAttributeValueChange & GetGameplayAttributeValueChangeDelegate ( FGameplayAttribute Attribute
)

 Register for when an attribute value changes AbilitySystemComponent.h  

const UGameplayEffect * GetGameplayEffectCDO ( const FActiveGameplayEffectHandle Handle
) const

 Returns a const pointer to the gameplay effect CDO associated with an active handle. AbilitySystemComponent.h  

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

 Get the count of the specified source effect on the ability system component. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure
  • Category=GameplayEffects

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

 Get the count of the specified source effect on the ability system component. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintPure
  • Category=GameplayEffects

const UGameplayEffect * GetGameplayEffectDefForHandle ( FActiveGameplayEffectHandle Handle
)

 Gets the FActiveGameplayEffect based on the passed in Handle AbilitySystemComponent.h  

float GetGameplayEffectDuration ( FActiveGameplayEffectHandle Handle
) const

 Returns the total duration of a gameplay effect AbilitySystemComponent.h  
Raw accessor to ask the magnitude of a gameplay effect, not necessarily always correct. AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects

const FGameplayTagContainer * GetGameplayEffectSourceTagsFromHandle ( FActiveGameplayEffectHandle Handle
) const

 Get the source tags from the gameplay spec represented by the specified handle, if possible AbilitySystemComponent.h  

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

 Return start time and total duration of a gameplay effect AbilitySystemComponent.h  

const FGameplayTagContainer * GetGameplayEffectTargetTagsFromHandle ( FActiveGameplayEffectHandle Handle
) const

 Get the target tags from the gameplay spec represented by the specified handle, if possible AbilitySystemComponent.h  

int32 GetGameplayTagCount ( FGameplayTag GameplayTag
) const

 Returns the current count of the given gameplay tag. AbilitySystemComponent.h
  • BlueprintPure
  • Category="Gameplay Tags"

int32 GetNumActiveGameplayEffects()

 Returns the number of gameplay effects that are currently active on this ability system component AbilitySystemComponent.h  

float GetNumericAttribute ( const FGameplayAttribute& Attribute
) const

 Returns current (final) value of an attribute AbilitySystemComponent.h  

float GetNumericAttributeBase ( const FGameplayAttribute& Attribute
) const

 Gets the base value of an attribute. That is, the value of the attribute with no stateful modifiers AbilitySystemComponent.h  

float GetNumericAttributeChecked ( const FGameplayAttribute& Attribute
) const

   AbilitySystemComponent.h  
  AbilitySystemComponent.h  

void GetOwnedGameplayTags ( FGameplayTagContainer& TagContainer
) const

   AbilitySystemComponent.h  

AActor * GetOwnerActor()

   AbilitySystemComponent.h  

FPredictionKey GetPredictionKeyForNewAction()

 Returns the prediction key that should be used for any actions AbilitySystemComponent.h  

FAbilityReplicatedData GetReplicatedDataOfGenericReplicatedEvent ( EAbilityGenericReplicatedEvent::Type EventType,
FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey
)

 Gets replicated data of the given Generic Replicated Event. AbilitySystemComponent.h  

virtual IAbilitySystemReplicationProxyInterface * GetReplicationInterface()

 Who to route replication through if ReplicationProxyEnabled (if this returns null, when ReplicationProxyEnabled, we wont replicate) AbilitySystemComponent.h  

const TArray< FString > & GetServerDebugStrings()

   AbilitySystemComponent.h  

TArray< FString > & GetServerDebugStrings_Mutable()

   AbilitySystemComponent.h  

const T * GetSet()

 AttributesFinds existing AttributeSet AbilitySystemComponent.h  

const T * GetSetChecked()

 Finds existing AttributeSet. Asserts if it isn't there. AbilitySystemComponent.h  

const TArray< UAttributeSet * > & GetSpawnedAttributes()

 Access the spawned attributes list when you don't intend to modify the list. AbilitySystemComponent.h  

TArray< TObjectPtr< UAttributeSet > > & GetSpawnedAttributes_Mutable()

   AbilitySystemComponent.h  

int32 GetTagCount ( FGameplayTag TagToCheck
) const

 Returns the number of instances of a given tag AbilitySystemComponent.h  
Input handling/targeting AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Abilities"
GameplayAbilities AbilitySystemComponent.h  
Grants an ability and attempts to activate it exactly one time, which will cause it to be removed. AbilitySystemComponent.h  

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

 Called when an ability is cancellable or not. AbilitySystemComponent.h  

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 AbilitySystemComponent.h  

virtual int32 HandleGameplayEvent ( FGameplayTag EventTag,
const FGameplayEventData* Payload
)

 Executes a gameplay event. AbilitySystemComponent.h  

bool HasActivatableTriggeredAbility ( FGameplayTag Tag
)

   AbilitySystemComponent.h  

bool HasAllMatchingGameplayTags ( const FGameplayTagContainer& TagContainer
) const

   AbilitySystemComponent.h  

bool HasAnyMatchingGameplayTags ( const FGameplayTagContainer& TagContainer
) const

   AbilitySystemComponent.h  

bool HasAttributeSetForAttribute ( FGameplayAttribute Attribute
) const

 Does this ability system component have this attribute? AbilitySystemComponent.h  

bool HasAuthorityOrPredictionKey ( const FGameplayAbilityActivationInfo* ActivationInfo
) const

 Returns true if this is running on the server or has a valid prediction key AbilitySystemComponent.h  

bool HasMatchingGameplayTag ( FGameplayTag TagToCheck
) const

 Gameplay tag operations Implements IGameplayTagAssetInterface using the TagCountContainer AbilitySystemComponent.h  

void IncrementAbilityListLock()

 Called from FScopedAbilityListLock AbilitySystemComponent.h  

virtual void InhibitActiveGameplayEffect ( FActiveGameplayEffectHandle ActiveGEHandle,
bool bInhibit,
bool bInvokeGameplayCueEvents
)

 Inhibit an active gameplay effect so that it is disabled, but not removed AbilitySystemComponent.h  

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. AbilitySystemComponent.h  

virtual void InitDefaultGameplayCueParameters ( FGameplayCueParameters& Parameters
)

 Will initialize gameplay cue parameters with this ASC's Owner (Instigator) and AvatarActor (EffectCauser) AbilitySystemComponent.h  

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

 Initializes starting attributes from a data table. AbilitySystemComponent.h  

void InputCancel()

 Sends a local player Input Cancel event, notifying abilities AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Gameplay Abilities"

void InputConfirm()

 Sends a local player Input Confirm event, notifying abilities AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Gameplay Abilities"

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 AbilitySystemComponent.h  

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

   AbilitySystemComponent.h  
Handles gameplay cue events from external sources AbilitySystemComponent.h  

void InvokeGameplayCueEvent ( const FGameplayTag GameplayCueTag,
EGameplayCueEvent::Type EventType,
FGameplayEffectContextHandle EffectContext
)

   AbilitySystemComponent.h  

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

 Calls local callbacks that are registered with the given Generic Replicated Event AbilitySystemComponent.h  

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 AbilitySystemComponent.h  

bool IsAbilityInputBlocked ( int32 InputID
) const

 Checks if the ability system is currently blocking InputID. AbilitySystemComponent.h  

bool IsAnimatingAbility ( UGameplayAbility* Ability
) const

 Returns true if the passed in ability is the current animating ability AbilitySystemComponent.h  

bool IsGameplayCueActive ( const FGameplayTag GameplayCueTag
) const

 Allows polling to see if a GameplayCue is active. AbilitySystemComponent.h
  • BlueprintCallable
  • Category="GameplayCue"
  • Meta=(GameplayTagFilter="GameplayCue")

bool IsGenericCancelInputBound ( int32 InputID
) const

   AbilitySystemComponent.h  

bool IsGenericConfirmInputBound ( int32 InputID
) const

   AbilitySystemComponent.h  

virtual bool IsOwnerActorAuthoritative()

 Returns true if this component's actor has authority AbilitySystemComponent.h  

virtual bool IsReadyForGameplayCues()

 Are we ready to invoke gameplaycues yet? AbilitySystemComponent.h  

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

 Grants a Gameplay Ability and returns its handle. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Gameplay Abilities"
  • Meta=(DisplayName="Give Ability", ScriptName="GiveAbility")
Grants a Gameplay Ability, activates it once, and removes it. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category="Gameplay Abilities"
  • Meta=(DisplayName="Give Ability And Activate Once", ScriptName="GiveAbilityAndActivateOnce")

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

   AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Skills"
  • Meta=(DisplayName="InitStats", ScriptName="InitStats")

virtual void LocalInputCancel()

   AbilitySystemComponent.h  

virtual void LocalInputConfirm()

 Handle confirm/cancel for target actors AbilitySystemComponent.h  

virtual FGameplayEffectContextHandle MakeEffectContext()

 Create an EffectContext for the owner of this AbilitySystemComponent AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects

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

 Get an outgoing GameplayEffectSpec that is ready to be applied to other things. AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects

void MarkAbilitySpecDirty ( FGameplayAbilitySpec& Spec,
bool WasAddOrRemove
)

 Call to mark that an ability spec has been modified AbilitySystemComponent.h  

bool MatchesGameplayTagQuery ( const FGameplayTagQuery& TagQuery
) const

 Checks whether the query matches the owned GameplayTags AbilitySystemComponent.h  

virtual void ModifyActiveEffectStartTime ( FActiveGameplayEffectHandle Handle,
float StartTimeDiff
)

 Modify the start time of a gameplay effect, to deal with timers being out of sync originally AbilitySystemComponent.h  

virtual void NotifyAbilityActivated ( const FGameplayAbilitySpecHandle Handle,
UGameplayAbility* Ability
)

   AbilitySystemComponent.h  

virtual void NotifyAbilityCommit ( UGameplayAbility* Ability
)

 Call notify callbacks above AbilitySystemComponent.h  

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

 Called from the ability to let the component know it is ended AbilitySystemComponent.h  

virtual void NotifyAbilityFailed ( const FGameplayAbilitySpecHandle Handle,
UGameplayAbility* Ability,
const FGameplayTagContainer& FailureReason
)

   AbilitySystemComponent.h  

FOnGivenActiveGameplayEffectRemoved & OnAnyGameplayEffectRemovedDelegate()

 Called when any gameplay effects are removed AbilitySystemComponent.h  

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). AbilitySystemComponent.h  

void OnAvatarActorDestroyed ( AActor* InActor
)

   AbilitySystemComponent.h  

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

   AbilitySystemComponent.h
  • Client
  • Reliable

void OnGameplayEffectAppliedToSelf ( UAbilitySystemComponent* Source,
const FGameplayEffectSpec& SpecApplied,
FActiveGameplayEffectHandle ActiveHandle
)

   AbilitySystemComponent.h  

void OnGameplayEffectAppliedToTarget ( UAbilitySystemComponent* Target,
const FGameplayEffectSpec& SpecApplied,
FActiveGameplayEffectHandle ActiveHandle
)

 This ASC has successfully applied a GE to something (potentially itself) AbilitySystemComponent.h  

virtual void OnGameplayEffectDurationChange ( FActiveGameplayEffect& ActiveEffect
)

 Called when the duration of a gameplay effect has changed AbilitySystemComponent.h  

FOnActiveGameplayEffectInhibitionChanged * OnGameplayEffectInhibitionChangedDelegate ( FActiveGameplayEffectHandle Handle
)

   AbilitySystemComponent.h  

FOnActiveGameplayEffectRemoved_Info * OnGameplayEffectRemoved_InfoDelegate ( FActiveGameplayEffectHandle Handle
)

   AbilitySystemComponent.h  

FOnActiveGameplayEffectStackChange * OnGameplayEffectStackChangeDelegate ( FActiveGameplayEffectHandle Handle
)

   AbilitySystemComponent.h  

FOnActiveGameplayEffectTimeChange * OnGameplayEffectTimeChangeDelegate ( FActiveGameplayEffectHandle Handle
)

   AbilitySystemComponent.h  

void OnMagnitudeDependencyChange ( FActiveGameplayEffectHandle Handle,
const FAggregator* ChangedAggregator
)

 Called when attribute magnitudes change, to forward information to dependent gameplay effects AbilitySystemComponent.h  

void OnOwnerActorDestroyed ( AActor* InActor
)

   AbilitySystemComponent.h  

void OnPeriodicGameplayEffectExecuteOnSelf ( UAbilitySystemComponent* Source,
const FGameplayEffectSpec& SpecExecuted,
FActiveGameplayEffectHandle ActiveHandle
)

   AbilitySystemComponent.h  

void OnPeriodicGameplayEffectExecuteOnTarget ( UAbilitySystemComponent* Target,
const FGameplayEffectSpec& SpecExecuted,
FActiveGameplayEffectHandle ActiveHandle
)

   AbilitySystemComponent.h  

virtual void OnPlayerControllerSet()

 Called when the ASC's AbilityActorInfo has a PlayerController set. AbilitySystemComponent.h  
Called for predictively added gameplay cue. AbilitySystemComponent.h  

virtual void OnRep_ClientDebugString()

   AbilitySystemComponent.h  

void OnRep_OwningActor()

   AbilitySystemComponent.h  

virtual void OnRep_ServerDebugString()

   AbilitySystemComponent.h  

virtual void OnServerPrintDebug_Request()

 Virtual function games can override to do their own stuff when either ServerPrintDebug function runs on the server AbilitySystemComponent.h  

void OnSpawnedAttributesEndPlayed ( AActor* InActor,
EEndPlayReason::Type EndPlayReason
)

   AbilitySystemComponent.h  

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

 AnimMontage Support AbilitySystemComponent.h  

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

 Plays a montage without updating replication/prediction structures. AbilitySystemComponent.h  

virtual UAnimMontage * PlaySlotAnimationAsDynamicMontage ( UGameplayAbility* AnimatingAbility,
FGameplayAbilityActivationInfo ActivationInfo,
UAnimSequenceBase* AnimAsset,
FName SlotName,
float BlendInTime,
float BlendOutTime,
float InPlayRate,
float StartTimeSeconds
)

   AbilitySystemComponent.h  

virtual UAnimMontage * PlaySlotAnimationAsDynamicMontage_WithFractionalLoops ( UGameplayAbility* AnimatingAbility,
FGameplayAbilityActivationInfo ActivationInfo,
UAnimSequenceBase* AnimAsset,
FName SlotName,
float BlendInTime,
float BlendOutTime,
float InPlayRate,
float StartTimeSeconds,
float PlayCount
)

   AbilitySystemComponent.h  

virtual UAnimMontage * PlaySlotAnimationAsDynamicMontage_WithFractionalLoopsSimulated ( UAnimSequenceBase* AnimAsset,
FName SlotName,
float BlendInTime,
float BlendOutTime,
float InPlayRate,
float PlayCount
)

   AbilitySystemComponent.h  

virtual UAnimMontage * PlaySlotAnimationAsDynamicMontageSimulated ( UAnimSequenceBase* AnimAsset,
FName SlotName,
float BlendInTime,
float BlendOutTime,
float InPlayRate
)

   AbilitySystemComponent.h  

void PressInputID ( int32 InputID
)

 Sends a local player Input Pressed event with the provided Input ID, notifying any bound abilities AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Gameplay Abilities"

void PrintAllGameplayEffects()

 Print a debug list of all gameplay effects AbilitySystemComponent.h  

virtual void PrintDebug()

   AbilitySystemComponent.h  

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 AbilitySystemComponent.h  
This will refresh the Ability's ActorInfo structure based on the current ActorInfo. AbilitySystemComponent.h  

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

 Register a tag event and immediately call it AbilitySystemComponent.h  

FOnGameplayAttributeChange & RegisterGameplayAttributeEvent ( FGameplayAttribute Attribute
)

 Register for when an attribute value changes, should be replaced by GetGameplayAttributeValueChangeDelegate AbilitySystemComponent.h  

FOnGameplayEffectTagCountChanged & RegisterGameplayTagEvent ( FGameplayTag Tag,
EGameplayTagEventType::Type EventType
)

 Allow events to be registered for specific gameplay tags being added or removed AbilitySystemComponent.h  

FOnGameplayEffectTagCountChanged & RegisterGenericGameplayTagEvent()

 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) AbilitySystemComponent.h  

virtual void ReinvokeActiveGameplayCues ()

 Invokes the WhileActive event for all GCs on active, non inhibited, GEs. AbilitySystemComponent.h  

void ReleaseInputID ( int32 InputID
)

 Sends a local player Input Released event with the provided Input ID, notifying any bound abilities AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Gameplay Abilities"

virtual int32 RemoveActiveEffects ( const FGameplayEffectQuery& Query,
int32 StacksToRemove
)

 Removes all active effects that match given query. StacksToRemove=-1 will remove all stacks. AbilitySystemComponent.h  

int32 RemoveActiveEffectsWithAppliedTags ( FGameplayTagContainer Tags
)

 Removes all active effects that apply any of the tags in Tags AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects

int32 RemoveActiveEffectsWithGrantedTags ( FGameplayTagContainer Tags
)

 Removes all active effects that grant any of the tags in Tags AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects

int32 RemoveActiveEffectsWithSourceTags ( FGameplayTagContainer Tags
)

 Removes all active effects with captured source tags that contain any of the tags in Tags AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects

int32 RemoveActiveEffectsWithTags ( FGameplayTagContainer Tags
)

 Removes all active effects that contain any of the tags in Tags AbilitySystemComponent.h
  • BlueprintCallable
  • Category=GameplayEffects

virtual bool RemoveActiveGameplayEffect ( FActiveGameplayEffectHandle Handle,
int32 StacksToRemove
)

 Removes the specified GameplayEffect by Handle. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category=GameplayEffects

void RemoveActiveGameplayEffect_NoReturn ( FActiveGameplayEffectHandle Handle,
int32 StacksToRemove
)

 This only exists so it can be hooked up to a multicast delegate AbilitySystemComponent.h  

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

 Remove active gameplay effects whose backing definition are the specified gameplay effect class AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category=GameplayEffects

void RemoveAllGameplayCues()

 Removes any GameplayCue added on its own, i.e. not as part of a GameplayEffect. AbilitySystemComponent.h  

void RemoveAllSpawnedAttributes()

 Remove all attribute sets AbilitySystemComponent.h  

void RemoveGameplayCue ( const FGameplayTag GameplayCueTag
)

 Remove a persistent gameplay cue AbilitySystemComponent.h  

void RemoveGameplayCue_MinimalReplication ( const FGameplayTag GameplayCueTag
)

 Remove gameplaycue for minimal replication mode. AbilitySystemComponent.h  

void RemoveGameplayEventTagContainerDelegate ( const FGameplayTagContainer& TagFilter,
FDelegateHandle DelegateHandle
)

 Remotes previously registered delegate AbilitySystemComponent.h  

void RemoveLooseGameplayTag ( const FGameplayTag& GameplayTag,
int32 Count,
EGameplayTagReplicationState TagRepState
)

   AbilitySystemComponent.h  

void RemoveLooseGameplayTags ( const FGameplayTagContainer& GameplayTags,
int32 Count,
EGameplayTagReplicationState TagRepState
)

   AbilitySystemComponent.h  

void RemoveMinimalReplicationGameplayTag ( const FGameplayTag& GameplayTag
)

   AbilitySystemComponent.h  

void RemoveMinimalReplicationGameplayTags ( const FGameplayTagContainer& GameplayTags
)

   AbilitySystemComponent.h  

void RemoveSpawnedAttribute ( UAttributeSet* Attribute
)

 Remove an existing attribute set AbilitySystemComponent.h  

virtual void ReplicateEndOrCancelAbility ( FGameplayAbilitySpecHandle Handle,
FGameplayAbilityActivationInfo ActivationInfo,
UGameplayAbility* Ability,
bool bWasCanceled
)

 Replicate that an ability has ended/canceled, to the client or server as appropriate AbilitySystemComponent.h  

void ServerAbilityRPCBatch ( FServerAbilityRPCBatch BatchInfo
)

   AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

virtual void ServerAbilityRPCBatch_Internal ( FServerAbilityRPCBatch& BatchInfo
)

 Overridable function for sub classes. AbilitySystemComponent.h  

void ServerPrintDebug_Request()

 Ask the server to send ability system debug information back to the client, via ClientPrintDebug_Response AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

void ServerPrintDebug_RequestWithStrings ( const TArray< FString >& Strings
)

 Same as ServerPrintDebug_Request but this includes the client debug strings so that the server can embed them in replays AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation
Direct Input state replication. AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

void ServerSetInputReleased ( FGameplayAbilitySpecHandle AbilityHandle
)

   AbilitySystemComponent.h
  • 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 AbilitySystemComponent.h
  • 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. AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

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

 Replicates targeting data to the server AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

void ServerSetReplicatedTargetDataCancelled ( FGameplayAbilitySpecHandle AbilityHandle,
FPredictionKey AbilityOriginalPredictionKey,
FPredictionKey CurrentPredictionKey
)

 Replicates to the server that targeting has been cancelled AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

virtual FActiveGameplayEffectHandle SetActiveGameplayEffectInhibit ( FActiveGameplayEffectHandle&& ActiveGEHandle,
bool bInhibit,
bool bInvokeGameplayCueEvents
)

 (Un-)Inhibit an Active Gameplay Effect so it may be disabled (and perform some disabling actions, such as removing tags). AbilitySystemComponent.h  

virtual void SetActiveGameplayEffectLevel ( FActiveGameplayEffectHandle ActiveHandle,
int32 NewLevel
)

 Updates the level of an already applied gameplay effect. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category=GameplayEffects

virtual void SetActiveGameplayEffectLevelUsingQuery ( FGameplayEffectQuery Query,
int32 NewLevel
)

 Updates the level of an already applied gameplay effect. AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category=GameplayEffects

void SetAvatarActor ( AActor* InAvatarActor
)

 Changes the avatar actor, leaves the owner actor the same AbilitySystemComponent.h  

void SetAvatarActor_Direct ( AActor* NewAvatarActor
)

   AbilitySystemComponent.h  
Call from OnRep functions to set the attribute base value on the client AbilitySystemComponent.h  

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

 Call from OnRep functions to set the attribute base value on the client AbilitySystemComponent.h  

virtual void SetBlockAbilityBindingsArray ( FGameplayAbilityInputBinds BindInfo
)

 Initializes BlockedAbilityBindings variable AbilitySystemComponent.h  

void SetClientDebugStrings ( TArray< FString >&& NewClientDebugStrings
)

   AbilitySystemComponent.h  

void SetLooseGameplayTagCount ( const FGameplayTag& GameplayTag,
int32 NewCount,
EGameplayTagReplicationState TagRepState
)

   AbilitySystemComponent.h  

void SetMontageRepAnimPositionMethod ( ERepAnimPositionMethod InMethod
)

 Method to set the replication method for the position in the montage AbilitySystemComponent.h  

void SetNumericAttributeBase ( const FGameplayAttribute& Attribute,
float NewBaseValue
)

 Sets the base value of an attribute. AbilitySystemComponent.h  

void SetOwnerActor ( AActor* NewOwnerActor
)

   AbilitySystemComponent.h  
Sets an ability spec to remove when its finished. AbilitySystemComponent.h  

virtual void SetReplicationMode ( EGameplayEffectReplicationMode NewReplicationMode
)

 When true, we will not replicate active gameplay effects for this ability system component, so attributes and tags AbilitySystemComponent.h  

void SetServerDebugStrings ( TArray< FString >&& NewServerDebugStrings
)

   AbilitySystemComponent.h  

void SetSpawnedAttributes ( const TArray< UAttributeSet* >& NewAttributeSet
)

 Remove all current AttributeSets and register the ones in the passed array. AbilitySystemComponent.h  

void SetTagMapCount ( const FGameplayTag& Tag,
int32 NewCount,
EGameplayTagReplicationState TagRepState
)

 Forcibly sets the number of instances of a given tag AbilitySystemComponent.h  

virtual void SetUserAbilityActivationInhibited ( bool NewInhibit
)

 Disable or Enable a local user from being able to activate abilities. AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Abilities"

virtual bool ShouldDoServerAbilityRPCBatch()

   AbilitySystemComponent.h  

virtual bool ShouldRecordMontageReplication()

 Returns true if this component should record montage replication info. AbilitySystemComponent.h  

virtual bool ShouldSendClientDebugStringsToServer()

 Determines whether to call ServerPrintDebug_Request or ServerPrintDebug_RequestWithStrings. AbilitySystemComponent.h  

virtual void StopMontageIfCurrent ( const UAnimMontage& Montage,
float OverrideBlendOutTime
)

 Stops current montage if it's the one given as the Montage param AbilitySystemComponent.h  

virtual void TargetCancel()

 Any active targeting actors will be stopped and canceled, not returning any targeting data AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Abilities"

virtual void TargetConfirm()

 Any active targeting actors will be told to stop and return current targeting data AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Abilities"

bool TriggerAbilityFromGameplayEvent ( FGameplayAbilitySpecHandle AbilityToTrigger,
FGameplayAbilityActorInfo* ActorInfo,
FGameplayTag Tag,
const FGameplayEventData* Payload,
UAbilitySystemComponent& Component
)

 Triggers an ability from a gameplay event, will only trigger on local/server depending on execution flags AbilitySystemComponent.h  

bool TryActivateAbilitiesByTag ( const FGameplayTagContainer& GameplayTagContainer,
bool bAllowRemoteActivation
)

 Attempts to activate every gameplay ability that matches the given tag and DoesAbilitySatisfyTagRequirements(). AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Abilities"

bool TryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
bool bAllowRemoteActivation
)

 Attempts to activate the given ability, will check costs and requirements before doing so. AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Abilities"

bool TryActivateAbilityByClass ( TSubclassOf< UGameplayAbility > InAbilityToActivate,
bool bAllowRemoteActivation
)

 Attempts to activate the ability that is passed in. AbilitySystemComponent.h
  • BlueprintCallable
  • Category="Abilities"

void UnBlockAbilitiesWithTags ( const FGameplayTagContainer& Tags
)

   AbilitySystemComponent.h  

void UnBlockAbilityByInputID ( int32 InputID
)

   AbilitySystemComponent.h  

bool UnregisterGameplayTagEvent ( FDelegateHandle DelegateHandle,
FGameplayTag Tag,
EGameplayTagEventType::Type EventType
)

 Unregister previously added events AbilitySystemComponent.h  

virtual void UpdateActiveGameplayEffectSetByCallerMagnitude ( FActiveGameplayEffectHandle ActiveHandle,
FGameplayTag SetByCallerTag,
float NewValue
)

 Dynamically update the set-by-caller magnitude for an active gameplay effect AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category=GameplayEffects

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

 Dynamically update multiple set-by-caller magnitudes for an active gameplay effect AbilitySystemComponent.h
  • BlueprintCallable
  • BlueprintAuthorityOnly
  • Category=GameplayEffects

void UpdateTagMap ( const FGameplayTagContainer& Container,
int32 CountDelta,
EGameplayTagReplicationState TagRepState
)

 Update the number of instances of a given tag and calls callback AbilitySystemComponent.h  

void UpdateTagMap ( const FGameplayTag& BaseTag,
int32 CountDelta,
EGameplayTagReplicationState TagRepState
)

 Update the number of instances of a given tag and calls callback AbilitySystemComponent.h  

Overridden from UGameplayTasksComponent

Name Remarks Include Path Unreal Specifiers

virtual bool GetShouldTick()

   AbilitySystemComponent.h  

Overridden from UActorComponent

Name Remarks Include Path Unreal Specifiers

virtual void BeginPlay()

   AbilitySystemComponent.h  

virtual void InitializeComponent()

   AbilitySystemComponent.h  

virtual void OnComponentDestroyed ( bool bDestroyingHierarchy
)

   AbilitySystemComponent.h  

virtual void OnRegister()

   AbilitySystemComponent.h  

virtual void OnUnregister()

   AbilitySystemComponent.h  

virtual void ReadyForReplication()

   AbilitySystemComponent.h  

virtual bool ReplicateSubobjects ( UActorChannel* Channel,
FOutBunch* Bunch,
FReplicationFlags* RepFlags
)

   AbilitySystemComponent.h  

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

   AbilitySystemComponent.h  

virtual void UninitializeComponent()

   AbilitySystemComponent.h  

Overridden from UObject

Name Remarks Include Path Unreal Specifiers

virtual void PostNetReceive()

   AbilitySystemComponent.h  

virtual void PreNetReceive()

   AbilitySystemComponent.h  

Overridden from IGameplayTaskOwnerInterface

Name Remarks Include Path Unreal Specifiers

virtual AActor * GetGameplayTaskAvatar ( const UGameplayTask* Task
) const

 Returns avatar actor to be used for a specific task, normally GetAvatarActor AbilitySystemComponent.h  

Overridden from IVisualLoggerDebugSnapshotInterface

Name Remarks Include Path Unreal Specifiers

virtual void GrabDebugSnapshot ( FVisualLogEntry* Snapshot
) const

   AbilitySystemComponent.h  

Overridden from IAbilitySystemReplicationProxyInterface

Name Remarks Include Path Unreal Specifiers

virtual void ForceReplication ()

 Force owning actor to update it's replication, to make sure that gameplay cues get sent down quickly. AbilitySystemComponent.h  

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

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCueAdded_WithParams ( const FGameplayTag GameplayCueTag,
FPredictionKey PredictionKey,
FGameplayCueParameters Parameters
)

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCueAddedAndWhileActive_FromSpec ( const FGameplayEffectSpecForRPC& Spec,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCueAddedAndWhileActive_WithParams ( const FGameplayTag GameplayCueTag,
FPredictionKey PredictionKey,
FGameplayCueParameters GameplayCueParameters
)

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCueExecuted ( const FGameplayTag GameplayCueTag,
FPredictionKey PredictionKey,
FGameplayEffectContextHandle EffectContext
)

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCueExecuted_FromSpec ( const FGameplayEffectSpecForRPC Spec,
FPredictionKey PredictionKey
)

 Do not call these functions directly, call the wrappers on GameplayCueManager instead. AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

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

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCuesAddedAndWhileActive_WithParams ( const FGameplayTagContainer GameplayCueTags,
FPredictionKey PredictionKey,
FGameplayCueParameters GameplayCueParameters
)

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCuesExecuted ( const FGameplayTagContainer GameplayCueTags,
FPredictionKey PredictionKey,
FGameplayEffectContextHandle EffectContext
)

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

virtual void NetMulticast_InvokeGameplayCuesExecuted_WithParams ( const FGameplayTagContainer GameplayCueTags,
FPredictionKey PredictionKey,
FGameplayCueParameters GameplayCueParameters
)

   AbilitySystemComponent.h
  • NetMulticast
  • Unreliable

Protected

Name Remarks Include Path Unreal Specifiers

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

   AbilitySystemComponent.h  

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

 Internal gameplay cue functions. AbilitySystemComponent.h  

void AddReplicatedInstancedAbility ( UGameplayAbility* GameplayAbility
)

 Add a gameplay ability associated to this component AbilitySystemComponent.h  

void AnimMontage_UpdateForcedPlayFlags ( FGameplayAbilityRepAnimMontage& OutRepAnimMontageInfo
)

 Copy over playing flags for duplicate animation data AbilitySystemComponent.h  
  AbilitySystemComponent.h  
Copy LocalAnimMontageInfo into RepAnimMontageInfo AbilitySystemComponent.h  

virtual void CancelAbilitySpec ( FGameplayAbilitySpec& Spec,
UGameplayAbility* Ignore
)

 Cancel a specific ability spec AbilitySystemComponent.h  

void CheckDurationExpired ( FActiveGameplayEffectHandle Handle
)

   AbilitySystemComponent.h  
Called from ClearAbility, ClearAllAbilities or OnRep. AbilitySystemComponent.h  

void ClientActivateAbilityFailed ( FGameplayAbilitySpecHandle AbilityToActivate,
int16 PredictionKey
)

   AbilitySystemComponent.h
  • Client
  • Reliable

void ClientActivateAbilitySucceed ( FGameplayAbilitySpecHandle AbilityToActivate,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h
  • Client
  • Reliable

void ClientActivateAbilitySucceedWithEventData ( FGameplayAbilitySpecHandle AbilityToActivate,
FPredictionKey PredictionKey,
FGameplayEventData TriggerEventData
)

   AbilitySystemComponent.h
  • Client
  • Reliable

void ClientCancelAbility ( FGameplayAbilitySpecHandle AbilityToCancel,
FGameplayAbilityActivationInfo ActivationInfo
)

   AbilitySystemComponent.h
  • Client
  • Reliable

void ClientEndAbility ( FGameplayAbilitySpecHandle AbilityToEnd,
FGameplayAbilityActivationInfo ActivationInfo
)

   AbilitySystemComponent.h
  • Client
  • Reliable

void ClientTryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate
)

   AbilitySystemComponent.h
  • Client
  • Reliable

virtual UGameplayAbility * CreateNewInstanceOfAbility ( FGameplayAbilitySpec& Spec,
const UGameplayAbility* Ability
)

 Creates a new instance of an ability, storing it in the spec AbilitySystemComponent.h  

void DebugCyclicAggregatorBroadcasts ( FAggregator* Aggregator
)

   AbilitySystemComponent.h  

void ExecuteGameplayEffect ( FGameplayEffectSpec& Spec,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h  

void ExecutePeriodicEffect ( FActiveGameplayEffectHandle Handle
)

   AbilitySystemComponent.h  

TArray< TObjectPtr< UGameplayTask > > & GetAbilityActiveTasks ( UGameplayAbility* Ability
)

   AbilitySystemComponent.h  

const UAttributeSet * GetAttributeSubobject ( const TSubclassOf< UAttributeSet > AttributeClass
) const

   AbilitySystemComponent.h  

const UAttributeSet * GetAttributeSubobjectChecked ( const TSubclassOf< UAttributeSet > AttributeClass
) const

   AbilitySystemComponent.h  

const TArray< uint8 > & GetBlockedAbilityBindings()

   AbilitySystemComponent.h  

TArray< uint8 > & GetBlockedAbilityBindings_Mutable()

   AbilitySystemComponent.h  

const FMinimalReplicationTagCountMap & GetMinimalReplicationTags()

   AbilitySystemComponent.h  

FMinimalReplicationTagCountMap & GetMinimalReplicationTags_Mutable()

   AbilitySystemComponent.h  

const UAttributeSet * GetOrCreateAttributeSubobject ( TSubclassOf< UAttributeSet > AttributeClass
)

   AbilitySystemComponent.h  

const FGameplayAbilityRepAnimMontage & GetRepAnimMontageInfo()

   AbilitySystemComponent.h  

FGameplayAbilityRepAnimMontage & GetRepAnimMontageInfo_Mutable()

   AbilitySystemComponent.h  

PRAGMA_DISABLE_DEPRECATION_WARNINGS const TArray< UGameplayAbility * > & GetReplicatedInstancedAbilities()

 Full list of all instance-per-execution gameplay abilities associated with this component AbilitySystemComponent.h  

const FMinimalReplicationTagCountMap & GetReplicatedLooseTags()

   AbilitySystemComponent.h  

FMinimalReplicationTagCountMap & GetReplicatedLooseTags_Mutable()

   AbilitySystemComponent.h  

bool HasNetworkAuthorityToActivateTriggeredAbility ( const FGameplayAbilitySpec& Spec
) const

 Returns true if the specified ability should be activated from an event in this network mode AbilitySystemComponent.h  

bool HasNetworkAuthorityToApplyGameplayEffect ( FPredictionKey PredictionKey
) const

   AbilitySystemComponent.h  

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

 Implementation of ServerTryActivateAbility AbilitySystemComponent.h  

virtual bool IsReadyForReplicatedMontage()

 Returns true if we are ready to handle replicated montage information AbilitySystemComponent.h  

virtual void MonitoredTagChanged ( const FGameplayTag Tag,
int32 NewCount
)

 Callback that is called when an owned tag bound to an ability changes AbilitySystemComponent.h  

void NotifyTagMap_StackCountChange ( const FGameplayTagContainer& Container
)

   AbilitySystemComponent.h  

void OnCaughtUpActiveGameplayEffect ( FActiveGameplayEffectHandle Handle,
int32 StacksToRemove
)

   AbilitySystemComponent.h  

void OnClientActivateAbilityCaughtUp ( FGameplayAbilitySpecHandle AbilityToActivate,
FPredictionKey::KeyType PredictionKey
)

   AbilitySystemComponent.h  

virtual void OnGiveAbility ( FGameplayAbilitySpec& AbilitySpec
)

 Will be called from GiveAbility or from OnRep. AbilitySystemComponent.h  

virtual void OnImmunityBlockGameplayEffect ( const FGameplayEffectSpec& Spec,
const FActiveGameplayEffect* ImmunityGE
)

   AbilitySystemComponent.h  

void OnPredictiveGameplayEffectStackCaughtUp ( FActiveGameplayEffectHandle Handle
)

   AbilitySystemComponent.h  

void OnPredictiveMontageRejected ( UAnimMontage* PredictiveMontage
)

 Called when a prediction key that played a montage is rejected AbilitySystemComponent.h  

void OnRejectedActiveGameplayEffect ( FActiveGameplayEffectHandle Handle,
int32 StacksToRemove
)

   AbilitySystemComponent.h  

virtual void OnRemoveAbility ( FGameplayAbilitySpec& AbilitySpec
)

 Will be called from RemoveAbility or from OnRep. Unbinds inputs with the given ability AbilitySystemComponent.h  

virtual void OnRep_ActivateAbilities()

   AbilitySystemComponent.h  

virtual void OnRep_ReplicatedAnimMontage()

 Replicated Event for AnimMontages AbilitySystemComponent.h  

virtual void OnTagUpdated ( const FGameplayTag& Tag,
bool TagExists
)

   AbilitySystemComponent.h  

void RemoteEndOrCancelAbility ( FGameplayAbilitySpecHandle AbilityToEnd,
FGameplayAbilityActivationInfo ActivationInfo,
bool bWasCanceled
)

 Called by ServerEndAbility and ClientEndAbility; avoids code duplication. AbilitySystemComponent.h  

void RemoveActiveGameplayEffect_AllowClientRemoval ( FActiveGameplayEffectHandle Handle,
int32 StacksToRemove
)

 A version of RemoveActiveGameplayEffect that allows us to remove it even when we don't have authority AbilitySystemComponent.h  

void RemoveAllReplicatedInstancedAbilities()

 Unregister all the gameplay abilities of this component AbilitySystemComponent.h  

virtual void RemoveGameplayCue_Internal ( const FGameplayTag GameplayCueTag,
FActiveGameplayCueContainer& GameplayCueContainer
)

   AbilitySystemComponent.h  

void RemoveReplicatedInstancedAbility ( UGameplayAbility* GameplayAbility
)

 Remove a gameplay ability associated to this component AbilitySystemComponent.h  

void ResetTagMap()

   AbilitySystemComponent.h  

void ServerCancelAbility ( FGameplayAbilitySpecHandle AbilityToCancel,
FGameplayAbilityActivationInfo ActivationInfo
)

   AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

void ServerCurrentMontageJumpToSectionName ( UAnimSequenceBase* ClientAnimation,
FName SectionName
)

 RPC function called from CurrentMontageJumpToSection, replicates to other clients AbilitySystemComponent.h
  • Reliable
  • Server
  • WithValidation

void ServerCurrentMontageSetNextSectionName ( UAnimSequenceBase* ClientAnimation,
float ClientPosition,
FName SectionName,
FName NextSectionName
)

 RPC function called from CurrentMontageSetNextSectionName, replicates to other clients AbilitySystemComponent.h
  • Reliable
  • Server
  • WithValidation

void ServerCurrentMontageSetPlayRate ( UAnimSequenceBase* ClientAnimation,
float InPlayRate
)

 RPC function called from CurrentMontageSetPlayRate, replicates to other clients AbilitySystemComponent.h
  • Reliable
  • Server
  • WithValidation

void ServerEndAbility ( FGameplayAbilitySpecHandle AbilityToEnd,
FGameplayAbilityActivationInfo ActivationInfo,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

void ServerTryActivateAbility ( FGameplayAbilitySpecHandle AbilityToActivate,
bool InputPressed,
FPredictionKey PredictionKey
)

   AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

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

   AbilitySystemComponent.h
  • Server
  • Reliable
  • WithValidation

void SetBlockedAbilityBindings ( const TArray< uint8 >& NewBlockedAbilityBindings
)

   AbilitySystemComponent.h  

void SetMinimalReplicationTags ( const FMinimalReplicationTagCountMap& NewMinimalReplicationTags
)

   AbilitySystemComponent.h  

void SetNumericAttribute_Internal ( const FGameplayAttribute& Attribute,
float& NewFloatValue
)

 Actually pushes the final attribute value to the attribute set's property. AbilitySystemComponent.h  

void SetRepAnimMontageInfo ( const FGameplayAbilityRepAnimMontage& NewRepAnimMontageInfo
)

   AbilitySystemComponent.h  

void UpdateActiveGameplayEffectsReplicationCondition()

   AbilitySystemComponent.h  

void UpdateMinimalReplicationGameplayCuesCondition()

   AbilitySystemComponent.h  

void UpdateTagMap_Internal ( const FGameplayTagContainer& Container,
int32 CountDelta,
EGameplayTagReplicationState TagRepState
)

   AbilitySystemComponent.h  

void UpdateTagMapSingle_Internal ( const FGameplayTag& Tag,
int32 CountDelta,
EGameplayTagReplicationState TagRepState
)

   AbilitySystemComponent.h  

Overridden from UObject

Name Remarks Include Path Unreal Specifiers

virtual void GetLifetimeReplicatedProps ( TArray< FLifetimeProperty >& OutLifetimeProps
) const

   AbilitySystemComponent.h  

virtual void GetReplicatedCustomConditionState ( FCustomPropertyConditionState& OutActiveState
) const

   AbilitySystemComponent.h  

Static

Name Remarks Include Path Unreal Specifiers

static const FGameplayEffectAttributeCaptureDefinition & GetIncomingDurationCapture()

   AbilitySystemComponent.h  

static FProperty * GetIncomingDurationProperty()

   AbilitySystemComponent.h  

static const FGameplayEffectAttributeCaptureDefinition & GetOutgoingDurationCapture()

   AbilitySystemComponent.h  

static FProperty * GetOutgoingDurationProperty()

   AbilitySystemComponent.h  

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

   AbilitySystemComponent.h  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page