GameplayAbilities

An instantiated Actor that acts as a handler of a GameplayCue.

AGameplayCueNotify_BurstLatent

AGameplayCueNotify_Looping

Active GameplayEffect instance -What GameplayEffect Spec -Start time -When to execute next -Replication callbacks

Callback struct for different types of gameplay effect changes

This handle is required for things outside of FActiveGameplayEffectsContainer to refer to a specific active GameplayEffect For example if a skill needs to create an active effect and then destroy that specific effect that it created, it has to do so through a handle.

Generic querying data structure for active GameplayEffects.

Active GameplayEffects Container -Bucket of ActiveGameplayEffects -Needed for FFastArraySerialization

Data that is used in aggregator evaluation that is intrinsic to the aggregator itself.

Data that is used in aggregator evaluation that is passed from the caller/game code

Struct representing an individual aggregation channel/depth. Contains mods of all mod op types.

Struct representing a container of modifier channels

Struct representing a float whose magnitude is dictated by a backing attribute and a calculation policy, follows basic form of: (Coefficient * (PreMultiplyAdditiveValue + [Eval'd Attribute Value According to Policy])) + PostMultiplyAdditiveValue

DataTable that allows us to define meta data about attributes. Still a work in progress.

Helper struct that facilitates initializing attribute set default values from spread sheets (UCurveTable).

Explicit implementation of attribute set initter, relying on the existence and usage of discrete levels for data look-up (that is, CurveTable->Eval is not possible)

Struct for gameplay effects that apply only if another gameplay effect (or execution) was successfully applied.

Structure to encapsulate magnitudes that are calculated via custom calculation

Helper struct to hold data about external dependencies for custom modifiers

FGameplayAbilityActivationInfo

Example struct that pairs a enum input command to a GameplayAbilityClass.6

An activatable ability spec, hosted on the ability system component.

Fast serializer wrapper for above struct

This is data that can be used to create an FGameplayAbilitySpec.

This file exists in addition so that GameplayEffect.h can use FGameplayAbilitySpec without having to include GameplayAbilityTypes.h which has depancies on GameplayEffect.hHandle that points to a specific granted ability.

Describes a FGameplayAttributeData or float property inside an attribute set.

Place in an AttributeSet to create an attribute that can be accesed using FGameplayAttribute.

FGameplayCueNotify_BurstEffects

FGameplayCueNotify_CameraAnimInfo

FGameplayCueNotify_CameraLensEffectInfo

FGameplayCueNotify_CameraShakeInfo

FGameplayCueNotify_DecalInfo

FGameplayCueNotify_ForceFeedbackInfo

FGameplayCueNotify_LoopingEffects

FGameplayCueNotify_ParticleInfo

FGameplayCueNotify_PlacementInfo

FGameplayCueNotify_SoundInfo

FGameplayCueNotify_SoundParameterInterfaceInfo

FGameplayCueNotify_SpawnCondition

FGameplayCueNotify_SpawnContext

FGameplayCueNotify_SpawnResult

An ObjectLibrary for the GameplayCue Notifies.

Metadata about a gameplay cue execution

Structure to keep track of pending gameplay cues that haven't been applied yet.

Wrapper struct around a gameplaytag with the GameplayCue category.

Overview of the GameplayCueTranslator system

Represents a translation from one FGameplayCueTranslatorNode to many others.

This is the struct that does the actual translation.

Basis for name swaps. This swaps FromName to ToName

A node in our translation table/graph.

Simple index/handle for referencing items in FGameplayCueTranslationManager::TranslationLUT

Struct defining gameplay attribute capture options for gameplay effects

Struct used to hold the result of a gameplay attribute capture; Initially seeded by definition data, but then populated by ability system component when appropriate

Struct used to handle a collection of captured source and target attributes

Data structure that stores an instigator and related data, such as positions and targets Games can subclass this structure and add game-specific information It is passed throughout effect execution so it is a great place to track transient information about an execution

Handle that wraps a FGameplayEffectContext or subclass, to allow it to be polymorphic and replicate properly

FGameplayEffectCue This is a cosmetic cue that can be tied to a UGameplayEffect.

Struct representing the output of a custom gameplay effect execution.

Struct representing parameters for a custom gameplay effect execution.

Struct representing the definition of a custom execution for a gameplay effect.

Struct representing modifier info used exclusively for "scoped" executions that happen instantaneously.

Saves list of modified attributes, to use for gameplay cues or later processing

Struct representing the magnitude of a gameplay effect modifier, potentially calculated in numerous different ways

Every set condition within this query must match in order for the query to match.

Data struct for containing information pertinent to GameplayEffects as they are removed

GameplayEffect Specification.

This is a cut down version of the gameplay effect spec used for RPCs.

Allows blueprints to generate a GameplayEffectSpec once and then reference it by handle, to apply it multiple times/multiple targets.

Struct representing evaluation channel settings for a gameplay modifier

Data that describes what happened in an attribute modification.

FGameplayModifierInfo Tells us "Who/What we" modify Does not tell us how exactly

Struct used to manage gameplay tag blueprint property mappings.

Struct used to update a blueprint property with a gameplay tag count.

Struct that tracks the number/count of tag applications within it.

Encapsulate require and ignore tags

Struct that is used by the gameplaycue manager to tie an instanced gameplaycue to the calling gamecode.

Structure that is used to combine tags from parent and child blueprints in a safe way

An alternative way to replicating gameplay cues.

Map that stores count of tags, in a form that is optimized for replication

Holds evaluated magnitude from a GameplayEffect modifier

Container for safely replicating script struct references (constrained to a specified parent struct)

Temporary parameter struct used when an attribute has changed

Struct for pooling and preallocating gameplaycuenotify_actor classes.

Overview of Gameplay Ability Prediction

This is a data structure for registering delegates associated with prediction key rejection and replicated state 'catching up'.

Generic numerical value in the form Value * Curve[Level]

Scope object that indicates when a gameplay effect is being applied

Used to stop us from removing abilities from an ability system component while we're iterating through the abilities

FScopedActiveGameplayEffectLock Provides a mechanism for locking the active gameplay effect list while possibly invoking callbacks into gamecode.

Allows us to batch all aggregator OnDirty calls within a scope.

FScopedGameplayCueSendContext Add this around code that sends multiple gameplay cues to allow grouping them into a smalkler number of cues for more efficient networking

A structure for allowing scoped prediction windows.

Used to stop us from canceling or ending an ability while we're iterating through its gameplay targets

Struct for holding SetBytCaller data

Structure used to combine tags from different sources during effect execution

The public interface to this module

Blueprint library for ability system.

The core ActorComponent for interfacing with the GameplayAbilities System

Holds global data for the ability system. Can be configured per project via config file

Interface for actors that expose access to an ability system component

Interface for actors that act like an ability system component for replication.

UAnimNotify_GameplayCue

UAnimNotify_GameplayCueState

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

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

This is an example DataAsset that could be used for defining a set of abilities to give to an AbilitySystemComponent and bind to an input command.

UGameplayCueFunctionLibrary

Interface for actors that wish to handle GameplayCue events from GameplayEffects.

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

UGameplayCueNotify_Burst

Non instanced GameplayCueNotify for spawning particle and sound FX.

A non instantiated UObject that acts as a handler for a GameplayCue.

A set of gameplay cue actors to handle gameplay cue events

This is the base class for GameplayCue Translators.

This is an example translator class.

UGameplayEffect The GameplayEffect definition.

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

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

UGameplayEffectUIData Base class to provide game-specific data about how to describe a Gameplay Effect in the UI.

UI data that contains only text.

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

A data driven table for applying gameplay effects based on tag count.

Interface for attribute sets that need to tick to update state. These can be expensive

Called when ability ends

Called when ability fails to activate, passes along the failed ability and a tag explaining why

Notify interested parties that ability spec has been modified

Notifies when GameplayEffectSpec is blocked by an ActiveGameplayEffect due to immunity

Called when ability fails to activate, passes along the failed ability and a tag explaining why

This is deprecated, use FOnGameplayAttributeValueChange.

Delegate for when GC notifies are added or removed from manager

UAbilitySystemComponent

Enumeration outlining the possible attribute based float calculation policies.

Describes the status of activating this ability, this is updated as prediction is handled

This is an example input binding enum for GameplayAbilities.

Indicates what type of action happened to a specific gameplay cue tag.

Options to specify what parts of gameplay cue execution should be skipped

EGameplayCueNotify_AttachPolicy

EGameplayCueNotify_EffectPlaySpace

EGameplayCueNotify_LocallyControlledPolicy

EGameplayCueNotify_LocallyControlledSource

Describes what type of payload is attached to a cue execution, we only replicate what is needed

Enumeration for options of where to capture gameplay attributes from for gameplay effects.

Gameplay effect duration policies

Describes what happens when a GameplayEffect, that is granting an active ability, is removed from its owner.

Enumeration outlining the possible gameplay effect magnitude calculation policies.

Enumeration of policies for dealing with the period of a gameplay effect when inhibition is removed

How gameplay effects will be replicated to clients

Enumeration representing the types of scoped modifier aggregator usages available

Enumeration of policies for dealing with duration of a gameplay effect while stacking

Enumeration of policies for dealing gameplay effect stacks that expire (in duration based effects).

Enumeration of policies for dealing with the period of a gameplay effect while stacking

Enumeration for ways a single GameplayEffect asset can stack.

Valid gameplay modifier evaluation channels; Displayed and renamed via game-specific aliases and options

Defines the ways that mods will modify attributes.

Rather a tag was added or removed, used in callbacks

Wrappers to convert enum to string. These are fairly slow

Helper function to compute the stacked modifier magnitude from a base magnitude, given a stack count and modifier operation

Helper function to retrieve the modifier bias based upon modifier operation