unreal.AbilitySystemComponent

class unreal.AbilitySystemComponent(outer=None, name='None')

Bases: unreal.GameplayTasksComponent

The core ActorComponent for interfacing with the GameplayAbilities System

C++ Source:

  • Plugin: GameplayAbilities
  • Module: GameplayAbilities
  • File: AbilitySystemComponent.h

Editor Properties: (see get_editor_property/set_editor_property)

  • activatable_abilities (GameplayAbilitySpecContainer): [Read-Write] The abilities we can activate.

    -This will include CDOs for non instanced abilities and per-execution instanced abilities. -Actor-instanced abilities will be the actual instance (not CDO)

    This array is not vital for things to work. It is a convenience thing for ‘giving abilities to the actor’. But abilities could also work on things without an AbilitySystemComponent. For example an ability could be written to execute on a StaticMeshActor. As long as the ability doesn’t require instancing or anything else that the AbilitySystemComponent would provide, then it doesn’t need the component to function.

  • asset_user_data (Array(AssetUserData)): [Read-Write] Array of user data stored with the component

  • auto_activate (bool): [Read-Write] Whether the component is activated at creation or must be explicitly activated.

  • can_ever_affect_navigation (bool): [Read-Write] Whether this component can potentially influence navigation

  • component_tags (Array(Name)): [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.

  • default_starting_data (Array(AttributeDefaults)): [Read-Write] Default Starting Data

  • editable_when_inherited (bool): [Read-Write] True if this component can be modified when it was inherited from a parent actor class

  • is_editor_only (bool): [Read-Write] If true, the component will be excluded from non-editor builds

  • on_claimed_resources_change (OnClaimedResourcesChangeSignature): [Read-Write] On Claimed Resources Change

  • on_component_activated (ActorComponentActivatedSignature): [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset

  • on_component_deactivated (ActorComponentDeactivateSignature): [Read-Write] Called when the component has been deactivated

  • primary_component_tick (ActorComponentTickFunction): [Read-Write] Main tick function for the Component

  • replicates (bool): [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!

activatable_abilities

(GameplayAbilitySpecContainer)

[Read-Only] The abilities we can activate.
-This will include CDOs for non instanced abilities and per-execution instanced abilities. -Actor-instanced abilities will be the actual instance (not CDO)

This array is not vital for things to work. It is a convenience thing for ‘giving abilities to the actor’. But abilities could also work on things without an AbilitySystemComponent. For example an ability could be written to execute on a StaticMeshActor. As long as the ability doesn’t require instancing or anything else that the AbilitySystemComponent would provide, then it doesn’t need the component to function.

apply_gameplay_effect_spec_to_self(spec_handle) → ActiveGameplayEffectHandle

Applies a previously created gameplay effect spec to this component

Parameters:spec_handle (GameplayEffectSpecHandle) –
Returns:
Return type:ActiveGameplayEffectHandle
apply_gameplay_effect_spec_to_target(spec_handle, target) → ActiveGameplayEffectHandle

Applies a previously created gameplay effect spec to a target

Parameters:
Returns:

Return type:

ActiveGameplayEffectHandle

apply_gameplay_effect_to_self(gameplay_effect_class, level, effect_context) → ActiveGameplayEffectHandle

Apply a gameplay effect to self

Parameters:
Returns:

Return type:

ActiveGameplayEffectHandle

apply_gameplay_effect_to_target(gameplay_effect_class, target, level, context) → ActiveGameplayEffectHandle

Apply a gameplay effect to passed in target

Parameters:
Returns:

Return type:

ActiveGameplayEffectHandle

get_active_effects(query) -> Array(ActiveGameplayEffectHandle)

Returns list of active effects, for a query

Parameters:query (GameplayEffectQuery) –
Returns:
Return type:Array(ActiveGameplayEffectHandle)
get_effect_context()

deprecated: ‘get_effect_context’ was renamed to ‘make_effect_context’.

get_gameplay_effect_count(source_gameplay_effect, optional_instigator_filter_component, enforce_on_going_check=True) → int32

Get the count of the specified source effect on the ability system component. For non-stacking effects, this is the sum of all active instances. For stacking effects, this is the sum of all valid stack counts. If an instigator is specified, only effects from that instigator are counted.

Parameters:
  • source_gameplay_effect (type(Class)) – Effect to get the count of
  • optional_instigator_filter_component (AbilitySystemComponent) – If specified, only count effects applied by this ability system component
  • enforce_on_going_check (bool) –
Returns:

Count of the specified source effect

Return type:

int32

get_gameplay_effect_magnitude(handle, attribute) → float

Raw accessor to ask the magnitude of a gameplay effect, not necessarily always correct. How should outside code (UI, etc) ask things like ‘how much is this gameplay effect modifying my damage by’ (most likely we want to catch this on the backend - when damage is applied we can get a full dump/history of how the number got to where it is. But still we may need polling methods like below (how much would my damage be)

Parameters:
Returns:

Return type:

float

get_user_ability_activation_inhibited() → bool

This is meant to be used to inhibit activating an ability from an input perspective. (E.g., the menu is pulled up, another game mechanism is consuming all input, etc) This should only be called on locally owned players. This should not be used to game mechanics like silences or disables. Those should be done through gameplay effects.

Returns:
Return type:bool
init_stats(attributes, data_table) → None

K2 Init Stats

Parameters:
is_gameplay_cue_active(gameplay_cue_tag) → bool

Allows polling to see if a GameplayCue is active. We expect most GameplayCue handling to be event based, but some cases we may need to check if a GamepalyCue is active (Animation Blueprint for example)

Parameters:gameplay_cue_tag (GameplayTag) –
Returns:
Return type:bool
make_effect_context() → GameplayEffectContextHandle

Create an EffectContext for the owner of this AbilitySystemComponent

Returns:
Return type:GameplayEffectContextHandle
make_outgoing_spec(gameplay_effect_class, level, context) → GameplayEffectSpecHandle

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

Parameters:
Returns:

Return type:

GameplayEffectSpecHandle

remove_active_effects_with_applied_tags(tags) → int32

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

Parameters:tags (GameplayTagContainer) –
Returns:
Return type:int32
remove_active_effects_with_granted_tags(tags) → int32

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

Parameters:tags (GameplayTagContainer) –
Returns:
Return type:int32
remove_active_effects_with_source_tags(tags) → int32

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

Parameters:tags (GameplayTagContainer) –
Returns:
Return type:int32
remove_active_effects_with_tags(tags) → int32

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

Parameters:tags (GameplayTagContainer) –
Returns:
Return type:int32
remove_active_gameplay_effect(handle, stacks_to_remove=-1) → bool

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

Parameters:
Returns:

Return type:

bool

remove_active_gameplay_effect_by_source_effect(gameplay_effect, instigator_ability_system_component, stacks_to_remove=-1) → None

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

Parameters:
  • gameplay_effect (type(Class)) – Class of gameplay effect to remove; Does nothing if left null
  • instigator_ability_system_component (AbilitySystemComponent) – If specified, will only remove gameplay effects applied from this instigator ability system component
  • stacks_to_remove (int32) – Number of stacks to remove, -1 means remove all
set_active_gameplay_effect_level(active_handle, new_level) → None

Updates the level of an already applied gameplay effect. The intention is that this is ‘seemless’ and doesnt behave like removing/reapplying

Parameters:
set_active_gameplay_effect_level_using_query(query, new_level) → None

Updates the level of an already applied gameplay effect. The intention is that this is ‘seemless’ and doesnt behave like removing/reapplying

Parameters:
set_user_ability_activation_inhibited(new_inhibit) → None

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

Parameters:new_inhibit (bool) –
target_cancel() → None

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

target_confirm() → None

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

try_activate_abilities_by_tag(gameplay_tag_container, allow_remote_activation=True) → bool

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

Parameters:
Returns:

Return type:

bool

try_activate_ability_by_class(ability_to_activate, allow_remote_activation=True) → bool

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

Parameters:
  • ability_to_activate (type(Class)) –
  • allow_remote_activation (bool) –
Returns:

Return type:

bool

try_activate_ability_by_tag(gameplay_tag_container, allow_remote_activation=True)

deprecated: ‘try_activate_ability_by_tag’ was renamed to ‘try_activate_abilities_by_tag’.