API reference - the Simple tier

Assumes you have finished quick-start.

The kit's Simple tier is 26 members. They resolve to 22 distinct anchors: 16 here, and 6 on events.md - the four On Interaction ... display names exist on both components and would collide as anchors on one page, which is why the events live there and each is documented once for both.

One entry per Simple member of the kit whose docs_link names this page. Every entry opens with its machine phrase - the one sentence that says where the node actually runs. The two kinds of Simple member that are events (On Interaction ..., On Phase Changed, On Behavior Value Changed) are documented in events.md instead, because four of their display names occur on both components and would collide as anchors here.

Which machine? On Behavior Value Changed — Every machine. Which machine? On Phase Changed — Every machine.

On Focus Changed

Local machine.

UKInteractorComponent::OnFocusChanged - BlueprintAssignable, category UK Interaction.

Raised on the owning client whenever the published focus changes - a new target, a different target, or nothing at all. It carries the old Focus and the new one, so a prompt widget can hide the previous target's affordance and show the next one from a single handler.

Detection runs on the owning client and nowhere else, so this delegate never crosses a connection: on a dedicated server and on every remote client it is silent. Bind it for prompt visibility, outlines and hover audio - anything that is a presentation decision.

A focus is not permission. Focus.Target being set says the interactor is looking at something, not that pressing use will be accepted; the authority still decides. See On Interact Denied for the local half of that answer and events.md > On Interaction Rejected for the remote half.

Which machine? On Interact Denied — Local machine. Which machine? On Interaction Rejected — Authority and owning client. (interactor) / Authority only. (interactable)

On Interact Denied

Local machine.

UKInteractorComponent::OnInteractDenied - BlueprintAssignable, category UK Interaction.

Raised on the owning client when Begin Interact was refused before anything went on the wire - no focus, a target that is not usable, a request already in flight. It carries the Reason and the target's Usability at that moment.

This is not a rejection. A rejection is the authority's answer to a request it received; a denial means no request was ever sent. That distinction is why the two are separate nodes: a denial costs nothing, happens instantly, and is safe to drive UI feedback from every frame a player mashes the key.

Feed Reason to Get Reason Text for the sentence to show. The equivalent rejection payload carries b Local == true for the same class of refusal, and Is Local Rejection is the node that tells them apart from a payload alone.

Begin Interact

Owning client only.

UKInteractorComponent::BeginInteract - BlueprintCallable, category UK Interaction.

Call this on the owning client to ask to interact with the current focus. It is the whole input surface of the kit: one call, no parameters, no target argument - the target is whatever detection has published.

What happens next is either a denial (see On Interact Denied) or a request that leaves for the authority, with a predicted On Interaction Started raised locally in the same frame so an animation can begin before the round trip completes. The authority answers with an acceptance or a rejection.

Calling it on a machine that does not own the interactor does nothing useful - there is no request to make on someone else's behalf. Calling it while an interaction is already in flight is refused rather than queued.

Which machine? On Interact Denied — Local machine. Which machine? On Interaction Started — Authority and owning client. (interactor) / Authority only. (interactable)

End Interact

Owning client only.

UKInteractorComponent::EndInteract - BlueprintCallable, category UK Interaction.

Call this on the owning client to end the interaction in flight. For a hold preset this is the key release; for an instant preset there is normally nothing in flight to end.

The interaction ends as a cancellation, not a completion, unless the hold had already reached its duration - which is the difference between letting go early and finishing. The reason on the resulting payload is Released.

Like Begin Interact it takes no target: the interactor knows what it is doing. Calling it with nothing in flight is harmless.

Get Focus

Owning client only.

UKInteractorComponent::GetFocus - BlueprintPure, category UK Interaction.

Returns the Focus published by the last detection tick on the owning client: the target component, and the supporting fields the prompt layer needs.

It is a snapshot of a local decision, refreshed at the detection interval rather than every frame, so polling it faster than detection runs returns the same value repeatedly. Prefer On Focus Changed for anything event-shaped; use this getter when you need the current value at an arbitrary moment - for example, when a widget is constructed.

On a machine that does not own the interactor it returns an empty focus. That is not an error state to branch on; it is the honest answer that detection did not run here.

Which machine? On Focus Changed — Local machine.

Get Interactor State

Owning client only.

UKInteractorComponent::GetInteractorState - BlueprintPure, category UK Interaction.

Returns the interactor's own state on the owning client: Inert when detection is not running, Idle when it is and nothing is in flight, and the in-flight states while a request or an interaction is live.

Inert is the state to check first when nothing seems to work: it means detection is switched off (the component's own flag, or Set Detection Enabled), so there is no focus to interact with and no denial to report either.

This is the interactor's state, not the target's. The target's is Get State on the interactable, and it is a different question with a different answer on every machine.

Get Hold Progress

Owning client only.

UKInteractorComponent::GetHoldProgress - BlueprintPure, category UK Interaction.

Returns the hold gauge as a value in [0, 1] on the owning client - the node to drop into a progress bar and nothing else.

It reads 0 whenever no presentation should be shown, including immediately after a release and after a retraction, which is what stops a gauge from climbing over an interaction that is no longer happening. You do not need to reset it yourself, and you should not hold on to the last non-zero value.

The clock behind it belongs to the authority; this is the client's mirror of it, which is what makes the gauge smooth rather than stepped. For an instant preset it stays 0.

Get Usability

Every machine.

UKInteractableComponent::GetUsability - BlueprintPure, category UK Interaction.

Returns whether this interactable can be used right now: Usable, or the specific way it cannot be. It is the single predicate the whole kit asks - detection, the protocol and the prompt layer all call this one node rather than each deciding for themselves.

It answers on every machine, and it answers about this machine's view of the state. On a client that means the replicated state, which may be one update behind the authority; the authority's answer is the one that decides whether a request is accepted.

After Begin Play it is integer work - a mask test and a switch, with no owner traversal, no allocation and no world access - so it is safe to call from a widget tick.

Get Preset

Every machine.

UKInteractableComponent::GetPreset - BlueprintPure, category UK Interaction.

Returns the effective preset: the one assigned on the component, or the project's default preset class if none is assigned, or null if neither exists. Every machine sees the same answer, because the preset is part of what replicates.

The returned object may be a class default object and must never be written through. Every preset field is read-only to Blueprint precisely so this cannot happen by accident; C++ callers are on notice. Writing to it would change the defaults for every interactable of that class in the process, with no diagnostic at all.

To vary behaviour per instance, use the component's overrides rather than mutating a preset.

Get Resolved Prompt Text

Every machine.

UKInteractableComponent::GetResolvedPromptText - BlueprintPure, category UK Interaction.

Returns the prompt text a player should see for this interactable, after the component's override has been applied over the preset's value. Every machine resolves it locally from replicated state, so it is correct on clients without anything extra being sent.

"Resolved" is the important word: it is the final answer, not the preset's raw value. If a door and its preset disagree, this node returns what the door says.

It is display text. It is not an identifier, and it must not be compared against to make gameplay decisions - use the interactable's identity tag for that.

Get Resolved Priority

Every machine.

UKInteractableComponent::GetResolvedPriority - BlueprintPure, category UK Interaction.

Returns the interactable's priority after overrides, as an integer. Detection uses it to choose between two candidates that are otherwise equally good, with a higher value winning.

Every machine can read it, but only the owning client's detection actually consults it. Reading it in UI is fine; branching gameplay on it is a sign the decision belongs in the behavior or the arbiter instead.

As with the prompt text, this is the resolved value - the component's override where one is set, the preset's otherwise.

Get Cooldown Remaining

Every machine.

UKInteractableComponent::GetCooldownRemaining - BlueprintPure, category UK Interaction.

Returns the seconds of cooldown left on this interactable, on this machine, for display only.

A client's value can lag by one round trip, and before its first replicated time sample it reads the full cooldown length rather than a partial one. The authority's timer - never this getter - is what actually moves the interactable out of Cooldown, so a client that shows 0.0 for a frame while the server still says Cooldown is behaving correctly.

Bind On Phase Changed if you need to know when the cooldown ends; poll this if you need to draw how much of it is left.

Which machine? On Phase Changed — Every machine.

Get State

Every machine.

UKInteractableComponent::GetState - BlueprintPure, category UK Interaction.

Returns this interactable's replicated state as one struct: its phase, its behavior value, and the supporting fields the kit replicates as a unit. It is the same value on every machine, modulo the update that has not arrived yet.

It is the only replicated unit in the kit, which is why so many of the other nodes on this page are derived from it rather than sent separately. Reading it is free; it is already here.

Writing it is a different matter: Apply State is an authority-only Advanced node, and the whole point of the tiering is that a Simple graph reads state and reacts to events without ever writing one.

Get Reason Text

Every machine.

UKInteractionFunctionLibrary::GetReasonText - static_BlueprintPure, category UK Interaction.

Returns the player-facing text for an Interaction Reason - the node to wire from a rejection or a cancellation straight into a prompt. It is static, so it needs no component.

Three rules worth knowing. None returns empty text: it is the reason a completion carries, and a prompt should show nothing for it rather than the word "None". Custom returns the last segment of the Custom Reason Tag you pass alongside it, so a project's own reasons need no change to the kit. Everything else comes from the shipped string table, which is what makes the strings localizable.

If the string table is missing or has no row for a key, the kit falls back to a compiled English default and logs UK-VAL-052 once per process - so a packaging mistake is visible in the log without flooding it, and the node never returns empty text by accident. The full reason list is in events.md > Reasons.

Get Prompt State

Owning client only.

UKPromptSubsystem::GetPromptState - BlueprintPure, category UK Interaction.

Returns the prompt view-model most recently broadcast - the one your widget already saw. Call it once when your HUD is built so it shows the right thing before the next change arrives, then let On Prompt State Changed keep it current.

The subsystem is a Local Player Subsystem: get it from the local player, not from the world, and expect it to be absent on a dedicated server - the whole module it lives in is ClientOnly and is never compiled into one. There is one per split-screen player, each following its own controller and pawn.

The struct it returns is never stale in the sense that matters - the kit publishes only when a field changed, so the value here is exactly what the last broadcast carried. Serial tells you which broadcast that was; compare it for equality only, because it wraps.

Target may be a destroyed component by the time you read it. Run it through Is Valid before you dereference it. The full field list is in prompt.md > Replace the widget.

Which machine? On Prompt State Changed — Owning client only.

On Prompt State Changed

Owning client only.

UKPromptSubsystem::OnPromptStateChanged - BlueprintAssignable, category UK Interaction.

Fires when the prompt changes - and only then. One struct carries everything the prompt shows: the target, the text, the glyph, the hold gauge and the "why not" line. Bind this one event and you have replaced the kit's sample widget entirely.

Only on change. The kit compares every published field before it broadcasts, so this event does not fire on a frame where nothing moved - an idle prompt is silent and costs nothing. Two consecutive "hidden" states cannot happen, because hidden carries pinned values that are equal to each other.

Re-entrancy is safe. A handler that changes the world - starting an interaction, moving focus - gets at most one further broadcast for the work it caused, never a recursive chain, and none at all if nothing actually changed. Calling Set Prompt Widget Enabled from inside a handler is deferred until the broadcast finishes rather than tearing the widget out from under it.

If you would rather subclass than bind, UK Prompt Widget Base does this for you: it binds in Native On Initialized and replays the last published state immediately, so a widget created mid-game draws the right thing on its first frame. That replay is the only push the kit ever makes.