Radial Menu

CrimsonCore turns CrimsonUI's radial wheel into a working gameplay feature: an action that activates gameplay abilities, and an ability that holds the wheel open while an input is held.

Where the wheel itself lives

The wheel, the slice widget, the action base and the definition asset are all CrimsonUI. See CrimsonUI -> How-To: Build a Radial Menu for building one standalone, with no ability system involved.

What CrimsonCore adds

Type	Purpose
`UCrimsonCoreRadialAction_GameplayAbility`	A radial action that fires a gameplay event and reports the ability's cooldown.
`UCrimsonCoreGameplayAbility_ShowWidgetWhileInputHeld`	Pushes a widget for as long as an input is held.

Activating abilities from a slice

Set a slice's Action to Activate Gameplay Ability and give it a TriggerTag. On confirm it sends a gameplay event with that tag and the ASC dispatches it - whichever ability declares the matching Triggers -> On Gameplay Event entry answers.

A trigger tag, not an asset tag

The wheel never looks an ability up and never chooses between candidates. That matters: an asset tag like Ability.Combat is shared by every combat ability, so "activate the one with this tag" has no single answer. A trigger tag identifies exactly one contract.

Property	Default	Effect
`TriggerTag`	(none)	Gameplay event sent on confirm. Must match the ability's trigger.
`bDisableWhenUnavailable`	`true`	Grays the slice out while the ability is cooling down.
`bShowCooldown`	`true`	Reports remaining cooldown as the slice's sweep.
`UnavailableReason`	(empty)	Shown in the hub while unavailable.

The ability must be granted

Cooldown and display data are read from the live ability spec, so an ungranted ability reports nothing and - with bDisableWhenUnavailable set - reads as unavailable. That is correct, but it looks identical to a wrong tag, so check the grant first.

Because activation goes through the event, an ability authored with an On Gameplay Event trigger receives the payload as its TriggerEventData exactly as it expects. Activating it by class reference instead would pass null there.

Inheriting the ability's icon and text

Set the slice's ContentSource to Action and the action supplies the icon, name and description from the ability's own UCrimsonAbilityDisplayData - the same data the action bar, skill tree and tooltips read, so the wheel cannot drift out of sync with them. Description falls back to Subtitle when empty.

Holding the wheel open

UCrimsonCoreGameplayAbility_ShowWidgetWhileInputHeld is the hold-open half: press and hold to bring the wheel up, flick to an option, release to choose and dismiss. It is WhileInputActive and LocalOnly - it is UI, and there is nothing for the server to do.

Property	Purpose
`WidgetClass`	Widget pushed while the input is held.
`LayerTag`	UI layer to push onto - must be one the layout registered.
`bEndWhenWidgetDeactivates`	Ends the ability when the widget closes itself.

The widget comes down two ways

The input is released, which ends the ability, which pops the widget - or the widget deactivates itself because an option was chosen, which ends the ability. Both directions are wired, so a wheel that closes on confirm never leaves the ability running.

That second path is also what makes the menu's bConfirmOnRelease work: releasing ends the ability, which pops the widget, whose deactivation the menu turns into the choice.

Override On Widget Pushed to populate the widget before the player can interact with it, or point the menu Blueprint at a DefaultDefinition and it fills itself in with no graph at all.

Shipped example content

Free to download, but compiles only with all Crimson plugins installed

These are CrimsonCore assets. Study them, then build the equivalent in your own project.

Asset	Path	Demonstrates
`GA_ShowRadialMenu_WhileHeld`	`/CrimsonCore/Input/Abilities/`	Hold-to-open ability, wired to the test menu on `UI.Layer.GameMenu`.
`W_CrimsonCoreRadialMenu_Test`	`/CrimsonCore/UserInterface/Radial/`	A menu subclass pointed at a definition asset.
`DA_RadialMenu_Test`	`/CrimsonCore/UserInterface/Radial/`	Three options, each with an ability action and a trigger tag.

Why the subclass exists

DefaultDefinition is set on the CrimsonCore subclass, not on CrimsonUI's W_CrimsonRadialMenu. A plugin asset may not reference content from a plugin that depends on it - CrimsonCore depends on CrimsonUI, never the reverse - so the wiring lives downstream and the base widget stays content-clean.

Multiplayer

The wheel and the hold-open ability are owning-client only. The gameplay event is sent on the client; the ability that answers it decides what replicates through its own net execution policy, prediction, cost and cooldown. The wheel makes no authority claims.