UAbilitySystemComponent

A generic callback anytime an ability is activated (started)

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

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

Callback anytime an ability is ended

Called with a failure reason when an ability fails to execute

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

Called when an ability spec's internals have changed

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

The abilities we can activate.

List of all active gameplay cues, including ones applied manually

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

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

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

Cached value of rather this is a simulated actor

Abilities with these tags are not able to be activated

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

Suppress all GameplayCues on this component

Suppress all ability granting through GEs on this component

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

Abilities that are triggered from a gameplay event

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

InputID for binding GenericConfirm/Cancel events

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

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

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

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

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

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

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

Replicated gameplaycues when in minimal replication mode.

Callback anytime an ability is ended, with extra information

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

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

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

Immunity notification support

Called on server whenever a periodic GE executes on self

Called on server whenever a periodic GE executes on target

System Attributes

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

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

PredictionKeys, see more info in GameplayPrediction.h.

How gameplay effects are replicated

When enabled GameplayCue RPCs will be routed through the AvatarActor's IAbilitySystemReplicationProxyInterface rather than this component

Current prediction key, set with FScopedPredictionWindow

List of currently active targeting actors

Rather activation is currently inhibited

Called to handle ability bind input

Returns Generic Replicated Event for a given Ability/PredictionKey pair

Called on local player always.

Called on local player always.

Returns TargetData Cancelled delegate for a given Ability/PredictionKey pair

Returns TargetDataSet delegate for a given Ability/PredictionKey pair

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

Add a persistent gameplay cue

Internal gameplay cue functions.

Internal gameplay cue functions.

Add gameplaycue for minimal replication mode.

Adds a new delegate to call when gameplay events happen.

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

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

Adds a new AttributeSet (initialized to default values)

Copy over playing flags for duplicate animation data

Copy LocalAnimMontageInfo into RepAnimMontageInfo

Copy LocalAnimMontageInfo into RepAnimMontageInfo

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

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

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

Applies an in-place mod to the given attribute.

Applies an inplace mod to the given attribute.

Returns true if any passed in tags are blocked

Bind to an input component with customized bindings

Bind to an input component with some default action names

Block or cancel blocking for specific ability tags

Block or cancel blocking for specific input IDs

Applies a previously created gameplay effect spec to this component

GameplayEffects: Primary outward facing API for other systems

Apply a gameplay effect to self

Additional Helper Functions

Apply a gameplay effect to passed in target

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

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

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

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

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

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

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

Ability Cancelling/Interrupts

Cancels the specified ability CDO.

Cancels the ability indicated by passed in spec handle.

Cancel a specific ability spec

Cancels the ability target data and calls callbacks

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

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

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

Called from ClearAbility, ClearAllAbilities or OnRep.

Removes the specified ability

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

Wipes all 'given' abilities.

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

Replicates the Generic Replicated Event to the client.

Sets the current target data and calls applicable callbacks

Deletes all cached ability client data (Was: ConsumeAbilityTargetData)

Consumes cached TargetData from client (only TargetData)

Consumes the given Generic Replicated Event (unsets it).

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

Jumps current montage to given section.

Sets current montages next section name.

Sets current montage's play rate

Stops whatever montage is currently playing.

Cancels all abilities and kills any remaining instanced abilities

GameplayCues can also come on their own.

Returns an ability spec corresponding to given ability class.

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

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

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

Gets the GE Handle of the GE that granted the passed in Ability

Replication

Force cancels the ability and does not replicate this to the other side.

Returns local world time that an ability was activated.

Functions meant to be called from GameplayAbility and subclasses, but not meant for general use

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

Returns delegate structure that allows binding to several gameplay effect changes

Returns list of active effects, for a query

Gets total duration for all effects that match query

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

Returns end time and total duration

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

Gets time remaining for all effects that match query

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

Returns list of active effects that have all of the passed in tags

Returns const pointer to the actual active gamepay effect structure

Returns debug string describing active gameplay effect

Returns the sum of StackCount of all gameplay effects that pass query

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

Returns a list of all attributes for this abiltiy system component

Returns the current animating ability

Returns the avatar actor for this component

Fills TagContainer with BlockedAbilityTags

Returns montage that is currently playing

Get SectionID of currently playing AnimMontage

Get length in time of current section

Get SectionName of currently playing AnimMontage

Returns amount of time left in current section

Returns current stack count of an already applied GE, but given the ability spec handle that was granted by the GE

Returns current stack count of an already applied GE

Retrieves the EffectContext of the GameplayEffect of the active GameplayEffect.

Returns an attribute value, after applying tag filters

Register for when an attribute value changes

Get the count of the specified source effect on the ability system component.

Gets the FActiveGameplayEffect based on the passed in Handle

Returns the total duration of a gameplay effect

Raw accessor to ask the magnitude of a gameplay effect, not necessarily always correct.

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

Return start time and total duration of a gameplay effect

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

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

Returns current (final) value of an attribute

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

Returns current (final) value of an attribute

Returns the prediction key that should be used for any actions

Gets replicated data of the given Generic Replicated Event.

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

Attributes

Finds existing AttributeSet

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

Returns the number of instances of a given tag

Input handling/targeting

GameplayAbilities

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

Called when an ability is cancellable or not.

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

Executes a gameplay event.

Does this ability system component have this attribute?

Returns true if this is running on the server or has a valid prediciton key

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

Called from FScopedAbilityListLock

Initialized the Abilities' ActorInfo - the structure that holds information about who we are acting on and who controls us.

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

Initializes starting attributes from a data table.

Implementation of ServerTryActivateAbility

Attempts to activate the given ability, will only work if called from the correct client/server context

Handles gameplay cue events from external sources

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

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

Checks if the ability system is currently blocking InputID.

Returns true if the passed in ability is the current animating ability

Allows polling to see if a GameplayCue is active.

Returns true if this component's actor has authority

Are we ready to invoke gameplaycues yet?

Returns true if we are ready to handle replicated montage information

Handle confirm/cancel for target actors

Create an EffectContext for the owner of this AbilitySystemComponent

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

Call to mark that an ability spec has been modified

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

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

Call notify callbacks above

Called from the ability to let the component know it is ended

Called when any gameplay effects are removed

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

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

Called when the duration of a gamepaly effect has changed

Will be called from GiveAbility or from OnRep.

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

Called when the ASC's AbilityActorInfo has a PlayerController set.

Called for predictively added gameplay cue.

Called when a prediction key that played a montage is rejected

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

Replicated Event for AnimMontages

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

AnimMontage Support

Plays a montage without updating replication/prediction structures.

Print a debug list of all gameplay effects

Called whenever the server time replicates via the game state to keep our cooldown timers in sync with the server

This will refresh the Ability's ActorInfo structure based on the current ActorInfo.

Register a tag event and immediately call it

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

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

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)

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

Called by ServerEndAbility and ClientEndAbility; avoids code duplication.

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

Removes all active effects that apply any of the tags in Tags

Removes all active effects that grant any of the tags in Tags

Removes all active effects with captured source tags that contain any of the tags in Tags

Removes all active effects that contain any of the tags in Tags

Removes GameplayEffect by Handle. StacksToRemove=-1 will remove all stacks.

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

Remove active gameplay effects whose backing definition are the specified gameplay effect class

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

Remove a persistent gameplay cue

Remove gameplaycue for minimal replication mode.

Remotes previously registered delegate

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

Overridable function for sub classes.

RPC function called from CurrentMontageJumpToSection, replicates to other clients

RPC function called from CurrentMontageSetNextSectopnName, replicates to other clients

RPC function called from CurrentMontageSetPlayRate, replicates to other clients

Ask the server to send ability system debug information back to the client, via ClientPrintDebug_Response

Same as ServerPrintDebug_Request but this includes the client debug strings so that the server can embed them in replays

Direct Input state replication.

Synchronization RPCs While these appear to be state, these are actually synchronization events w/ some payload data

Replicates the Generic Replicated Event to the server with payload.

Replicates targeting data to the server

Replicates to the server that targeting has been cancelled

Updates the level of an already applied gameplay effect.

Updates the level of an already applied gameplay effect.

Changes the avatar actor, leaves the owner actor the same

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

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

Initializes BlockedAbilityBindings variable

Method to set the replication method for the position in the montage

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

Sets the base value of an attribute.

Sets an ability spec to remove when its finished.

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

Forcibly sets the number of instances of a given tag

Disable or Enable a local user from being able to activate abilities.

Determines whether to call ServerPrintDebug_Request or ServerPrintDebug_RequestWithStrings.