How-To: Author a Combo

Goal: chain three abilities into a light-light-heavy string that a player drives with two input actions, authored in a graph rather than in code.

Prerequisites
How-To: Get the Building Blocks step 7 (the combo system must be enabled), and at least three UCrimsonGameplayAbility subclasses to use as steps - see Quick Start.

1. Configure the input catalog

Two settings under Project Settings -> Crimson -> Crimson Ability System are required before the graph editor can offer you anything.

SettingWhat it does
Combo Input Mapping ContextThe UInputMappingContext whose mappings define every UInputAction a combo may reference. The graph's input picker reads its catalog from here, so designers cannot pick an action that does not exist.
Move Input ActionYour IA_Move. The controller samples its raw axis at press time to fill in ECrimsonComboDirection. Leave it unset and every input resolves to None, so only direction-agnostic transitions can fire.
Use the right Enhanced Input trigger
Every action a combo uses must report "still held" truthfully. Use Crimson Combo (Press + Hold + Release) (UCrimsonInputTrigger_Combo, shipped here) or the stock Down trigger.

Do NOT use Pressed. It emits Triggered on the actuation edge then falls to None the next frame while the button is still down, so Enhanced Input fires Completed, the controller sees a phantom release, and Hold transitions can never mature.
Verify
The two settings are populated and your attack actions use a Down-style trigger.

2. Create the combo graph asset

Content Browser -> right-click -> Crimson -> Ability System -> Crimson Combo Graph Asset. Double-click to open the graph editor.

The combo graph editor with the entry node, three step nodes and their transitions.
  • The Entry node is the starting handshake. Set its Input.Action, Direction and Kind - this is what starts the combo from a rooting ability.
  • Add Step nodes (right-click -> Combo Step Node) and point each StepAbilityClass at one of your abilities.
  • Drag a wire between two steps; the schema inserts a Transition edge node. Click it to set its input, fire mode, priority and conditional augments.
  • Each step shows five tracks: Startup, Active, Recovery, Transition Window, and a read-only Input Buffer look-back band. Drag the bars or type exact values.
  • The asset compiles on save. IsDataValid catches missing targets, ambiguous transitions and inputs that are not in the catalog.
Retiming an animation is safe
Phase and window values are authored in seconds against a specific montage. If that montage's length changes, the plugin rescales every boundary proportionally so they stay on the poses you tuned them against - whether the retime happens with the combo editor open or closed.
Verify
Save. The asset reports no validation errors and each step node draws its montage timeline.

3. Root the combo on an ability

The graph describes what comes after the entry. A rooting ability declares which combos it can start and when its own cancel window is open.

Open the ability that should start the combo. In Class Defaults, find the Crimson | Combo category and expand Combo Extension:

  • Add an entry to Default Combos and set Combo to your graph asset. Leave Start Unlocked ticked unless the combo is progression-gated.
  • Transition Open / Transition Close are the seconds within this ability during which the combo's starting handshake can fire.
No Combo category?
The whole category is hidden until the combo system is enabled. See How-To: Get the Building Blocks step 7.
Verify
Select the rooting ability. Default Combos lists your graph asset.

4. Add the controller and route input

The controller lives on the pawn and must see input before the ASC does, so it can consume a press that drives a transition.

Add the component: pawn Blueprint -> Add Component -> Crimson Combo Controller.

Then route each combo-capable action through it: Handle Input Action Pressed (on the controller, passing the UInputAction) -> read the bOut Handled pin -> Branch. If handled, stop. If not, call Ability Input Tag Pressed on the ASC as usual. Mirror the same chain for Handle Input Action Released.

Finally give the controller directional intent: call Set Move Input Provider is C++ only, so in a Blueprint-only project leave it unset and use direction-agnostic transitions, or set the pawn's class to a C++ base that wires it.

Set Move Input Provider is C++ only
It takes a TFunction, which has no Blueprint representation. A Blueprint-only project can still use combos - direction-agnostic transitions (Direction = None) work fine. For directional handshakes the pawn needs a small C++ base class that installs the provider.
Verify
Play In Editor. Press the rooting ability's input, then the transition input inside the window - the second ability activates and the first is cancelled.

Then Play As Client with 2 players and repeat on the client. The chain must run there too: the client predicts each step and the server confirms it.

See also

  • How-To: Gate Combo Branches with Conditions - only chain if the player actually connected.
  • How-To: Tune Combo Input Feel - fire modes, tap/hold, buffering.
  • How-To: React to Combo Events - cues, messages and gameplay events per step.
  • Concept: Combo System - the model behind the graph.