API Reference

Every public type this plugin ships. Types owned by another module are marked.

Core types

Type	Kind	Purpose
`UCrimsonAbilitySystemComponent`	Component	The ASC. Cooldowns, modifiers, tag stacks, effect stacks, augment slots, input routing.
`UCrimsonGameplayAbility`	Ability	Base ability with activation policy/group, costs, configurable values, augment broadcast.
`UK2Node_CrimsonGetConfigurableValue`	Blueprint node	Get Configurable Value. Types its Default Value and Return Value pins from the property's definition in the ability's contract, then compiles into `GetConfigurableValue` / `Int` / `Bool` / `Vector`. Falls back to the node's `Value Type` when no contract can answer. Lives in the `CrimsonAbilitySystemNodes` module.
`UCrimsonAbilitySystemGlobals`	Globals	MUST be registered in `DefaultGame.ini`. Allocates `FCrimsonGameplayEffectContext`.
`FCrimsonGameplayEffectContext`	Struct	Effect context carrying ability source and augment provenance.
`UCrimsonAttributeSet`	Attribute set	Base for your attribute sets.
`UCrimsonAbilitySystemSettings`	Settings	Project Settings -> Crimson -> Crimson Ability System.
`UCrimsonAbilitySystemStatics`	Library	`GetSetByCallerMagnitudeFromHandle`, `GetAbilitySystemComponentFromTargetData`, `GetPredictedMontageDuration`.
`UCrimsonGlobalAbilitySystem`	Subsystem	Apply/remove an ability or effect across every ASC.
`UCrimsonAbilityTagRelationshipMapping`	Data asset	Static block/cancel relationships by tag.
`ICrimsonAbilitySourceInterface`	Interface	Lets a damage source describe itself to calculations.
`UCrimsonGameplayAbility::CooldownTags`	Property	Per-ability cooldown identity. Appended to the applied cooldown spec's `DynamicGrantedTags` and to `GetCooldownTags()`, so one shared cooldown effect can serve every ability without them sharing a cooldown. Empty by default; an ability relying on its effect's granted tags is unaffected.

Ability subclasses

Type	Key API
`UCrimsonGameplayAbility_WithCastTime`	`UpdateAbilityCastTime`, `GetCalculatedCastTime` (public), `ECrimsonAbilityCommitTime`. `GetCastSpeedModifier` is a `BlueprintNativeEvent` - override it to divide the cast by a haste stat. Events: `OnCastStarted` / `OnCastCompleted` / `OnCastInterrupted` (both machines) and the `...Authority` variants (server only). Broadcasts `FCrimsonAbilityProgressMessage`.
`UCrimsonGameplayAbility_Toggle`	Activates and deactivates on alternating presses via a replicated `UAbilityTask_WaitInputPress`. Configuration is entirely contract-driven: `BuffEffectClassSlotTag` (a Class Slot) and `ToggleConfigTag` (a Configuration entry holding `FCrimsonToggleConfig`) are the only authored properties. `GetBuffEffectClass`, `GetPeriodicCosts`, `GetTickAbilities` resolve them with augments folded in. `CooldownPolicy` (`ECrimsonToggleCooldownPolicy`) decides when the cooldown lands; `TriggerToggleCooldown` charges it on demand (authority only). Events: `OnToggledOn` / `OnToggledOff` and the `...Authority` variants.
`UCrimsonGameplayAbility_Charges`	`GetMaxCharges`, `GetCurrentCharges`, `OnChargesChanged`. `ChargesUsed` is server-authoritative and pushed to the owning client by the reliable `Client_SetChargesUsed` RPC.
`UCrimsonGameplayAbility_Channeling`	`StartChanneling` (virtual), `StopChanneling`, `GetChannelElapsed`, `SetChannelTickInterval`, `SetMaxChannelTime`, `SetCancelOnMovement`. Events: `OnChannelingStarted` / `OnChannelingTick` / `OnChannelingStopped` and the `...Authority` variants; `NativeOnChannelingStarted` is the C++ hook for the start. Broadcasts `FCrimsonAbilityProgressMessage` with `Kind = Channel`.
`UCrimsonGamePhaseAbility`	A phase modeled as an ability. `GetGamePhaseTag`.

Ability display data

Player-facing presentation authored on the ability itself, so an action bar, a skill tree node and a tooltip read one source instead of three lookup tables that drift when an ability is renamed.

Type or member	Purpose
`UCrimsonAbilityDisplayData`	Instanced `UObject` holding `Icon` (`TSoftObjectPtr<UTexture2D>`), `DisplayName`, `Description` and `Subtitle`. `EditInlineNew` and `Blueprintable` - subclass it in C++ or Blueprint to add your own fields (rarity, school, damage type) without rewriting any lookup logic. Consumers that only know the base class keep working.
`UCrimsonGameplayAbility::DisplayData`	`EditDefaultsOnly, Instanced` slot on every Crimson ability. Null until a designer picks a class - it is deliberately not created with `CreateDefaultSubobject`, which does not survive serialization into an instanced slot reliably. Every consumer must treat null as 'no presentation authored' and degrade gracefully.
`GetAbilityDisplayData()`	`BlueprintPure` accessor. Returns null when nothing is authored.

Ability lifecycle events

Tag containers on every UCrimsonGameplayAbility that send a GAS gameplay event at a fixed lifecycle moment. Authority only. See How-To: Broadcast Ability Lifecycle Events.

Type or member	Purpose
`FCrimsonAbilityEventTags`	The struct behind the ability's `AbilityEventTags` property (`EditDefaultsOnly`, category Crimson > Ability Events). Six `FGameplayTagContainer` fields: `OnActivatedTags`, `OnEndedTags`, `OnApplyCostTags`, `OnApplyCooldownTags`, `OnSucceedTags`, `OnFailedTags`.
`ECrimsonAbilityEventTagType`	`Activated`, `Ended`, `Cost`, `Cooldown`, `Succeed`, `Failed`, `END`. Selector for `GetEventTypeTagsByType`.
`GetEventTypeTagsByType(Type)`	`BlueprintCallable`, protected. Returns the container for one lifecycle moment. Use it in a subclass that needs to send a lifecycle tag from its own code path.
`SendGameplayMessageToOwner(InTags, Payload)`	`BlueprintCallable`, protected. Sends each tag in the container to the owning actor as a gameplay event. Despite the name this is `SendGameplayEventToActor`, not the Gameplay Message Subsystem. Not authority-gated - you decide where it runs.
`MakeGameplayEventDataFromEventPayload()`	`BlueprintCallable`, protected, virtual. Builds the `FGameplayEventData` these events carry: `Instigator` (owning actor), `OptionalObject` (`UCrimsonAbilityEventPayloadBase`), `OptionalObject2` (the sending ability). Override to add your own fields.
`UCrimsonAbilityEventPayloadBase`	`BlueprintType` payload object with `GetOwnerActor`, `GetOwnerPawn`, `GetOwnerPlayerController`, `GetAbilityFamilyTags`, `GetAbilitySpec`. One instance is cached per ability and refilled per event - read it inside the handler, do not store it.

Costs

Type Purpose

UCrimsonAbilityCost Base. Override K2_CheckCost and K2_ApplyCost.

UCrimsonAbilityCost_PlayerTagStack Charges a tag-stack resource. The amount comes from the ability's Ability.Property.Cost configurable value when its contract publishes one, otherwise from the authored Quantity FScalableFloat at the ability's level. Publishing the property is what makes a cost augment-modifiable; a published 0 is honored. CheckCost and ApplyCost share one ResolveStackCount so they cannot disagree on the price.

Type	Purpose
`UCrimsonAbilityCost`	Base. Override `K2_CheckCost` and `K2_ApplyCost`.
`UCrimsonAbilityCost_PlayerTagStack`	Charges a tag-stack resource. The amount comes from the ability's `Ability.Property.Cost` configurable value when its contract publishes one, otherwise from the authored `Quantity` `FScalableFloat` at the ability's level. Publishing the property is what makes a cost augment-modifiable; a published 0 is honored. `CheckCost` and `ApplyCost` share one `ResolveStackCount` so they cannot disagree on the price.

Augments

Type	Purpose
`UCrimsonAbilityAugment`	The augment data asset - mutations, actions, stateful listeners.
`UCrimsonAugmentSubsystem`	Stateless helper library for augment mutation math (static functions; never instantiated per world).
`UCrimsonAugmentAction`	One-shot action base. Override `Execute`.
`UCrimsonAugmentAction_GameplayCue`	Fires a GameplayCue on the caster, each target, or a ground location. The supported way to do sound, VFX and camera shake from an augment - see How-To: Play Sound and VFX from an Augment.
`FCrimsonAugmentActionContext`	The shared context every action in a group runs against. `TargetData`, `OwningAbility`, `EventTags`, `EventMagnitude`, `AugmentLevel`, `OwningAugment`, `PropertyOverrides`, and `bIsAuthority` - guard authoritative work on the last one, since a predicted event runs the action on the server and the owning client both. `AugmentLevel` and `OwningAugment` are rewritten per augment as the dispatcher iterates, so read them during `Execute` rather than caching.
`UCrimsonStatefulAugmentBase`	Stateful listener base. Override `Initialize`, `HandleAbilityEvent`, `OnRemoved`.
`UCrimsonAugmentActor`	Actor spawned by an augment. `GetOwningAbility`, `GetSnapshotedValue`.
`ICrimsonAugmentSpawnedActorInterface`	`InitializeAugmentActor` on spawned actors.
`UCrimsonAbilityContract`	Declares the properties an ability exposes.
`UCrimsonAbilityTask_SpawnAugmentActor`	Ability task for augment-owned actors.
`FCrimsonAugmentBindableFloat`	A designer-authored number. Literal by default; optionally reads an ability property via `SourceProperty`. `Resolve`, `ResolveAsInt`, `ToDisplayText`.
`FCrimsonAugmentActionGate`	Tag query + bindable chance + bindable minimum level. `Pass`, `IsUnconditional`.
`FCrimsonAugmentValueScope`	RAII scope making bound values resolve to real numbers inside generated descriptions.
`CrimsonAugment::ForEachBindableFloat`	Reflective walk over every bindable value an augment holds, including instanced actions and listeners.
`CrimsonAugment::FormatDescriptionTokens`	Substitutes `{PropertyName}` tokens in an authored description, with `:0` / `:spaced` / `:lower` / `:upper` / `:title` format specs.

Shipped actions: _ApplyGameplayEffect, _ConsumeEffectStacks, _FindTargets, _GrantAndActivateAbility, _ModifyContext, _ModifySetByCaller, _ModifySpecAttribute, _ReduceCooldown, _SpawnActor. (_Chance and _Conditional were removed - gating is now an FCrimsonAugmentActionGate on the event group or the action itself.)

Shipped stateful listeners: _ApplyGameplayEffect, _EventTrigger, _HitCounter, _ModifyTags, _ReplaceAbility, _StackConsumer.

Tooltips

Type / function	Purpose
`FCrimsonAbilityTooltip`	Title, description, `Stats`, and one section per equipped augment.
`FCrimsonTooltipStat`	One published property resolved: `Label`, `Description`, `ValueType`, `Categories`, `BaseValue`, `CurrentValue`, the Bool / Vector pairs, `Display`, `bModified`, `bDeclaredByAugment`.
`ECrimsonTooltipStatKind`	A stat's value shape: `Float`, `Int`, `Bool`, `Vector`, or `Attribute` for an ability-scoped attribute adjustment.
`FCrimsonPropertyDisplay`	Authored on a contract property: `Suffix`, `bAsPercent`, `Decimals`, `bHigherIsBetter`, `bHideFromTooltip`. Presentation only - the runtime value is untouched.
`FCrimsonTooltipStatFilter`	Which rows a panel wants: `MatchAnyCategories`, `AllowedKinds`, `Source`, `bOnlyModified`. Default-constructed passes everything.
`FCrimsonAugmentTooltipSection`	One equipped augment: `AugmentTag`, `SlotCategory`, `Title`, `Description`, `Level`, `Augment`, `bIsPreview`.
`FCrimsonAugmentEffectLine`	One thing an augment does, as a row: `Source`, `Text`, `TargetLabel`, `Kind`, `MutationType`, `Value`. Joined, these are the generated description.
`UCrimsonAbilitySystemStatics::BuildAbilityTooltip`	Blueprint-callable. Assembles an ability plus its equipped augments. `OverrideLevel = -1` uses the ability's current level.
`UCrimsonAbilitySystemStatics::BuildAugmentPreviewTooltip`	Editor-side preview for a single augment against its target contract, with no live ability.
`UCrimsonAbilityTooltipStatics`	The a-la-carte half: find / filter / group stats, resolve one stat without the tooltip, discover what an ability publishes, format values and deltas, and preview a candidate augment against the live loadout.
`UCrimsonAbilitySystemComponent::OnAbilityPropertiesChanged`	Blueprint-assignable. Fires on server and clients when an ability's resolved properties change - the refresh signal for anything showing its numbers.

Gameplay Effect components

Type	Purpose
`UCrimsonModifierGameplayEffectComponent`	Applies property modifiers from an effect.
`UCrimsonAccumulateGameplayEffectComponent`	Accumulates a value across applications.
`UCrimsonGameplayEffectComponent_ApplyToInstigator`	Also applies the effect to the instigator.
`UCrimsonGameplayEffectStackingSubsystem`	Stacking bookkeeping.

Combo system

Type	Purpose
`UCrimsonComboController`	The runtime driver. Add to the pawn.
`UCrimsonComboGraphAsset`	The authored graph - handshake, nodes, end points. Those are baked from the editor graph on save and deliberately hidden from details panels (a hand edit would be overwritten by the next bake); only the Defaults section (buffer TTL, reset-on-damage) is editable on the asset.
`UCrimsonInteractionCondition_AttributeCompare`	(CrimsonCore) Interaction condition: `Attribute` compared with `Comparison` (`<`, `<=`, `=`, `>=`, `>`) against `Value` on the instigator's ability system; an instigator without the attribute set fails. Gate a door or a chest on a level or a reputation. Reason "Requires <Attribute> at least <Value>"
`UCrimsonComboTransitionCondition`	Per-step observer gating a transition's augments.
`UCrimsonComboEventBase`	Event base: eight lifecycle hooks selected with `HookMask`, plus `PhaseFilter` to narrow the two phase hooks to one phase. Subclasses `_Augment`, `_GameplayCue`, `_GameplayEvent`, `_GameplayMessage`.
`UCrimsonComboPathLibrary`	`BuildComboPathTree`, `BuildComboPathForestFromGrants` for UI.
`UCrimsonInputTrigger_Combo`	Enhanced Input trigger with correct press/hold/release semantics.
`FCrimsonComboExtension`	UPROPERTY on `UCrimsonGameplayAbility` declaring rooted combos and the cancel window.
`FCrimsonComboTransition`	One edge - input, kind, charge window, fire mode, priority, `EdgeRequiredTagsQuery`, conditional augments. The tag query is evaluated against the owner's ability system tags, which include the live `Combo.Phase.*` tag and the active node's `NodeTags`; an empty query always passes.
`FCrimsonComboInputBinding`	Action + direction + modifier alternatives (`ModifierAlternatives`, `TArray<FCrimsonComboModifierRequirement>`: the press matches when ANY alternative is satisfied); the input half of a handshake or transition. Captured bindings (buffer entries, RPC payloads) carry at most one - the press-time sample (`GetSampledChord`).
`FCrimsonComboModifierRequirement`	One alternative: `RequiredModifierTags` (gameplay tags) and/or `RequiredModifierKeys` (raw `FKey`s) a press must hold, matched exactly. Keys are read from engine key state; tags through `FCrimsonAbilitySystemIntegrationHooks::ResolveHeldComboModifierTags`.
`FCrimsonComboRuntimeNode`	One step - ability class, phase boundaries (`StartupEnd`, `ActiveStart`, `ActiveEnd`, `RecoveryEnd`), transition window, `NodeTags` applied as loose tags while the node is the active step, events.
`ECrimsonComboFireMode`	`IASA`, `PressBuffer`, `HoldBuffer`.
`ECrimsonComboInputKind`	`Tap`, `Hold`, `Release`.
`ECrimsonComboDirection`	`None`, `Forward`, `Back`, `Left`, `Right`, `Up`, `Down`.
`ECrimsonComboResetReason`	Why a combo ended - timeout, damage, death, interruption, and so on.
`ECrimsonComboPhase`	`None`, `Startup`, `Active`, `Recovery`. The timing phase of the active step. `None` means no combo is running, or the active step authored no phase boundaries.
`ECrimsonComboEventHook`	The eight hooks a combo event can subscribe to through `HookMask`: `StepEntered`, `StepExited`, `TransitionWindowOpened`, `TransitionWindowMissed`, `TransitionFired`, `ComboCompleted`, `PhaseEntered`, `PhaseExited`. The mask is a `uint8` and all eight bits are in use.
`FCrimsonComboEventContext`	Payload handed to every hook: controller, ASC, avatar actor, combo, node, step ability class, `TargetNodeID`, `TriggeringInput`, and `Phase` - set on the two phase hooks only, and on `PhaseExited` it is the phase being left.
`FCrimsonComboEventMessage`	Payload broadcast by `UCrimsonComboEvent_GameplayMessage`: `HookTag`, combo, node, step ability class, avatar actor, and `Phase`. The event carries a `ChannelTagOverride_On<Hook>` and a `HookTag_On<Hook>` per hook, including `_OnPhaseEntered` and `_OnPhaseExited`.
`FCrimsonComboUIMessage`	Payload on every `Combo.Message.*` channel: `Event`, `Context`, `Snapshot`, `bWasCanceled`, `ResetReason`, `RejectReason`.
`ECrimsonComboUIEvent`	Which moment an `FCrimsonComboUIMessage` describes - including `PhaseEntered` and `PhaseExited`, whose phase rides on `Context.Phase`.
`FCrimsonComboTelegraphSnapshot`	Frozen timing view of the active step, for telegraph and tutorial HUDs. Phase fields: `CurrentPhase`, `bHasAuthoredPhases`, `StartupEndLocalSeconds`, `ActiveStartLocalSeconds`, `ActiveEndLocalSeconds`, `RecoveryEndLocalSeconds` - offsets from step entry, scaled by the step's play rate, the same convention as `WindowOpenLocalSeconds` and `WindowCloseLocalSeconds`.
`FCrimsonComboAvailableInput`	One press the owner could make now: action, direction, kind, combo, target node, priority, `bWouldFireIfPressedNow`, `bPressWouldBuffer`, `IneligibilityReason` and `IneligibilityCode`. Returned by `GetAvailableComboInputs`.
`ECrimsonComboIneligibilityReason`	Why a candidate press would not fire right now: `None`, `InputActionUnset`, `WindowNotOpenYet`, `WindowClosed`, `WrongDirection`, `EdgeTagsNotSatisfied`.
`ECrimsonComboDriveTiming`	`Immediate` (fail if the transition window is shut) and `WhenWindowOpens` (latch on the active step and fire when it opens). Authority drive only - player presses go through the input buffer instead.
`ECrimsonComboDriveResult`	Outcome of an authority drive request: `Success`, `ComboSystemDisabled`, `NotAuthority`, `OwnerIsPlayerControlled`, `NoASC`, `ComboNotGranted`, `ComboNotActive`, `NoMatchingTransition`, `TargetNotReachable`, `WindowNotOpen`, `WindowClosed`, `EdgeTagsNotSatisfied`, `Latched`. See How-To: Drive Combos from AI.

Combo controller functions

Function	Purpose
`HandleInputActionPressed` / `Released`	Route input. Presses for actions outside the combo catalog are ignored; the third parameter marks a press defensive.
`IsComboActive` / `IsInCancelWindow`	State queries.
`GetCurrentCombo` / `GetCurrentNodeID` / `GetCurrentStepHandle`	What is running now.
`GrantDynamicCombo` / `RevokeComboGrant` / `UnlockComboGrant` / `LockComboGrant`	Runtime grant management. Server only.
`IsComboGranted` / `GetGrantedCombosFor`	Grant queries.
`GrantAugmentWithLifetime` / `RemoveAugmentFromCurrentStep` / `RemoveAllAugmentsFromCurrentStep`	Step-scoped augment control.
`AddDynamicEventToNode` / `RemoveDynamicEvent` / `RemoveDynamicEventsBySource`	Runtime event overlay.
`ResetCombo`	End the current combo with a reason.
`GetActiveHolds` / `GetAvailableComboInputs`	UI-facing state - charge bars, input prompts.
`GetSaveData` / `ApplySaveData`	Persist dynamic grants and events.
`SetMoveInputProvider`	C++ only. Supplies directional intent.
`SetModifierStateProvider`	C++ only, optional. Overrides how held modifiers are read (both tags and keys); left unset the controller reads keys from engine key state and tags through `FCrimsonAbilitySystemIntegrationHooks::ResolveHeldComboModifierTags`.
`GetCurrentPhase`	The active step's timing phase. `None` when no combo is running, and for the whole life of a step that authored no phase boundaries.
`GetTelegraphSnapshot`	Frozen timing view of the active step for HUDs, carrying the live phase and the four play-rate-scaled phase boundaries.
`OnPhaseEnteredDelegate` / `OnPhaseExitedDelegate`	Blueprint-assignable multicast delegates, `(Context, Phase)`. Server and owning client only. `OnPhaseExitedDelegate` fires before `OnStepExitedDelegate` on every teardown path, including a prediction rollback.
`StartComboByAsset` / `RequestTransitionToNode` / `CancelPendingDriveRequest`	The authority drive API for AI and scripted sequences. Authority only, and refused when the owning pawn is player-controlled. See How-To: Drive Combos from AI.
`GetCompletionCounter`	Bumped each time an End node is reached. Snapshot it before a driven combo and compare for inequality once the combo is no longer active, to tell a clean finish from a reset. The underlying value is a byte and wraps, so never compare for ordering.
`GetUngrantedStepAbilities` / `PreloadComboAbilities`	Pre-flight for a driven combo: which of the combo's step abilities are not granted on the bound ASC, and warming their classes so the first step does not blocking-load.

Persistence

Type	Purpose
`UCrimsonAbilityStateCarrierSubsystem`	Game instance subsystem holding a snapshot across travel.
`UCrimsonEffectPersistenceComponent`	Per-effect persistence bookkeeping.
`UCrimsonAbilityStatePersistenceSettings`	Project Settings -> Crimson -> Ability State Persistence.
`FCrimsonAbilitySystemStateSnapshot`	The captured state.
`FCrimsonAttributePoolPair`	One pool and the attribute that caps it, listed under Pool Attributes in the settings. A listed pool is captured as a fraction of its own maximum and restored against whatever that maximum reads on the way back in, so a buff that was absent at capture time cannot shrink it.

Base actors

Type	Derives from	Purpose
`ACrimsonAbilityCharacter`	`ACharacter` (+ ModularGameplay receiver)	Character with ASC access and init callbacks.
`ACrimsonAbilityPlayerState`	`APlayerState` (+ ModularGameplay receiver)	Owns the ASC - the recommended pattern.
`ACrimsonAbilityPlayerController`	`APlayerController` (+ ModularGameplay receiver)	Typed ASC accessor.
`ACrimsonTaggedActor`	`AActor`	Actor carrying gameplay tags.

Settings

Setting	Default	Purpose
`bEnableComboSystem`	`false`	Master switch. Editor restart to apply.
`ComboInputMappingContext`	unset	The IMC catalog the combo input picker reads. At runtime the controller ignores presses for actions not in it (`IsComboInputAction`); unset disables the gate.
`ModifierInputMappingContext`	unset	Declares which actions are chord modifiers (`IsModifierInputAction`) - never treated as combo inputs in their own right. Unset is valid.
`MoveInputAction`	unset	Sampled at press time for `ECrimsonComboDirection`.
`DefaultInputBufferTTL`	`0.1`	Last resort in the buffer TTL chain.
`DefaultInputBufferCapacity`	`8`	Ring buffer size.
`MoveInputDeadZone`	`0.3`	Below this, direction resolves to `None`.
`ServerPingLeniencyCapSeconds`	`0.08`	Cap on server window tolerance.
`bDefaultResetOnDamageTaken`	`true`	Seeded into new combo assets.
`TapMaxHoldDuration`	`0.18`	Tap/Hold disambiguation threshold.
`RecentlyEndedBannerSeconds`	`1.5`	Dev-tools cosmetic only.

Gameplay tags this plugin defines

These are native tags declared by this plugin - you can rely on them existing.

Group	Tags
Activation failure	`Ability.ActivateFail.Cooldown`, `.Silenced`, `.IsDead`, `.ActivationGroup`, `.Charge.OutOfCharges`
Ability state	`Ability.State.Casting`, `.Channeling`, `.Interrupted`, `.Stunned`, `.Silenced`, `.Changed`, `.AbilityHandleChanged`
Ability properties	`Ability.Property.Cooldown`, `Ability.Property.PrimaryTargetCount`, `Ability.Property.Cost`
Ability behavior	`Ability.Behavior.SurvivesDeath`
Augment events	`Augment.Event.OnActivate`, `.OnEffectApplying`, `.OnEffectResolved`, `.OnEnd`, `.OnGranted`, `.OnRemoved`
Augment categories	`Augment.Category.Default`, `.Stat`, `.Behavior`, `.Defensive`, `.Trigger`, `.Visual`
Combo step phases	`Combo.Phase`, `Combo.Phase.Startup`, `Combo.Phase.Active`, `Combo.Phase.Recovery`. Applied as loose, non-replicated tags on the owner's ability system while a phase-authored step is running - on the server and the owning client, never on a simulated proxy. `Combo.Phase` is the parent and is never applied on its own.
Combo phase messages	`Combo.Message.PhaseEntered`, `Combo.Message.PhaseExited`. Channels carrying an `FCrimsonComboUIMessage` whose `Context.Phase` is the phase entered, or the phase left.
Persistence	`Crimson.Persistence.Persist`, `Crimson.Persistence.DoNotPersist`
Status	`Status.Death`, `Status.Cheat.Invulnerable`, `Gameplay.AbilityInputBlocked`

Augment.Event.OnActivate does not reach combo conditions

It is broadcast during the step ability's activation, before the combo controller has registered that step - so the spec filter drops it. Use OnObservationBegin instead. How-To: Gate Combo Branches with Conditions documents the full reasoning and the workarounds.

Cast and channel progress

Broadcast by UCrimsonGameplayAbility_WithCastTime and UCrimsonGameplayAbility_Channeling when a timed segment starts and again when it ends. See How-To: Make a Cast-Time Ability -> 5. Drive a cast bar.

Type / event	Home	Purpose
`FCrimsonAbilityProgressMessage`	This plugin (`AbilitySystem/`)	Instigator, ability handle and identity tag, `StartWorldTime`, `Duration`, `Phase`, `Kind`.
`ECrimsonAbilityProgressPhase`	This plugin	`Started` / `Completed` / `Interrupted`.
`ECrimsonAbilityProgressKind`	This plugin	`Cast` / `Channel`.
`OnAbilityProgress` / `OnAbilityProgressNative`	`UCrimsonAbilitySystemComponent`	The event (channel `Message.Ability.Progress`). Siblings: `OnAbilitySimpleFailure`, `OnAbilityMontageFailure`, `OnAbilityStateChanged`.

Local broadcast

Reaches the server and the predicting client only - it never crosses the wire, so it cannot drive a bar for another player or an NPC. The gap is invisible on a listen-server host; verify from a remote client.

Ability extensions

UCrimsonGameplayAbility::Extensions holds instanced UCrimsonGameplayAbilityExtension objects (Extensions/CrimsonGameplayAbilityExtension.h). The ability calls each one's OnPawnAvatarSet, OnAbilityActivated, OnAbilityEnded and OnAbilityRemoved, so per-ability add-ons need no ability subclass. FindExtension<T>() returns one by class.

Member	Purpose
`Extensions`	Instanced array on `UCrimsonGameplayAbility` (Category Crimson / Extensions).
`UCrimsonGameplayAbilityExtension`	Abstract, `EditInlineNew`. Override the four hooks; runs where the ability runs.
`FindExtension<T>()`	C++ lookup of the first extension of a class.
(CrimsonCore) `UCrimsonCoreAbilityExtension_FixedSlotUI`, `UCrimsonCoreAbilityExtension_PawnFacing`	Ready-made extensions for a HUD slot and pawn facing.
(CrimsonCore) `UCrimsonCoreAbilityCameraStatics`	`PushOverrideCameraMode`, `PopOverrideCameraMode`, `GetCurrentLockOnTarget` for abilities.

Camera and HUD are integrations

This plugin has no camera, lock-on or HUD code. Those features come from extensions and statics you write, or from CrimsonCore (requires all Crimson plugins) - see Overview -> Optional integrations.

Ability identity for UI

What a HUD or action bar reads off an ability. (The per-ability HUD slot is CrimsonCore's UCrimsonCoreAbilityExtension_FixedSlotUI.)

Member	Purpose
`GetPrimaryTriggerTag()`	The ability's trigger tag - its stable identity.
`AbilityIdentifierTag`	Optional explicit identity tag.
`GetAbilityDisplayData()` / `GetAbilityDisplayName()`	Name, description and icon for UI.
`BroadcastAbilityState`	Fires the ASC's `OnAbilityStateChanged` for UI.

Contract types in this plugin, and CrimsonCore types

The first rows ship with this plugin (AbilitySystem/). CrimsonCore rows are listed for orientation only - CrimsonCore is free to download, but compiles only with all Crimson plugins installed.

Type	Home	Note
`UCrimsonAbilitySet`	This plugin	The data asset used to grant abilities, effects and attribute sets.
`FCrimsonAbilitySet_GrantedHandles`	This plugin	Revoke handle returned by a grant.
`ICrimsonAbilitySystemOwner`	This plugin	Interface the PlayerState implements.
`ICrimsonAbilityInputRouter`	This plugin	Implemented by the ASC; lets other systems route slot input, charges, global cooldown and cost checks.
`FCrimsonAbilitySystemIntegrationHooks`	This plugin	Static hooks another system binds (`ResolveHeldComboModifierTags`).
`UCrimsonHeroComponent`	CrimsonCore (requires all Crimson plugins)	Turnkey input routing including the defensive-input entry points. How-To: Tune Combo Input Feel shows the standalone equivalent.
`UCrimsonCoreAbilityExtension_FixedSlotUI`, `UCrimsonFixedAbilitySlotContext`	CrimsonCore (requires all Crimson plugins)	Per-ability HUD slot.
`UCrimsonCoreAbilityCameraStatics`, `UCrimsonCoreAbilityExtension_PawnFacing`	CrimsonCore (requires all Crimson plugins)	Camera mode, lock-on target and pawn facing for abilities.
`UCrimsonCoreComboModifierBridge`	CrimsonCore (requires all Crimson plugins)	Resolves combo modifier tags through the input plugin's registry.
`UCrimsonGameplayAbility_UseObject`	CrimsonCore (requires all Crimson plugins)	The shared use-item ability.
`UCrimsonInteractionCondition_AttributeCompare`	CrimsonCore (requires all Crimson plugins)	Attribute requirement for interactions.

System readiness

ACrimsonAbilityPlayerState announces a ModularGameplay feature state in PostInitializeComponents: ChangeFeatureInitState(PlayerState, CrimsonAbilitySystem::SystemReadyFeatureName, ASC, SystemReady_AbilitySystem). Wait on it rather than polling: UGameFrameworkComponentManager::RegisterAndCallForActorInitState(PlayerState, CrimsonAbilitySystem::SystemReadyFeatureName, FGameplayTag(), Delegate, true); the implementer is the ASC. A player state of your own that owns an ASC should announce the same state.

Tag constant	Tag	Announced when
`CrimsonAbilitySystem::SystemReadyFeatureName` (state tag `CrimsonGameplayTags::SystemReady_AbilitySystem`)	`Crimson.SystemReady.AbilitySystem`	Announced once the ability system component is initialized and default abilities are granted.