Netcade Interaction Plugin (Unreal Engine)

Overview

The Netcade Interaction Plugin gives you a complete, multiplayer-ready interaction layer for Unreal Engine: a player-side Interactor, a world-side Interactable, optional outline visuals, and a shared data/delegate layer for Blueprints and C++.

In Blueprint terms:

• NCInteractorComponent lives on your character / pawn and finds things to interact with.
• NCInteractableComponent lives on doors, pickups, terminals, etc.
• NCOutlineComponent lives on the local player and draws outlines on the focused actor.
• NCInteractionTypes defines shared enums, data structs, and event delegates.

Install & files

Requirements

• Unreal Engine 5.x (tested with UE 5.4+)
• C++ project (Blueprint-only projects can still use the plugin once it’s compiled)
• Optional: post-process setup for CustomDepth outlines (if you use stencil highlighting)

Install the plugin

1. Create a folder in your project: Plugins/NetcadeInteraction/
2. Drop the plugin contents into that folder so you have: Plugins/NetcadeInteraction/Source/NetcadeInteraction/...
3. Open your project in Unreal. If prompted, click Yes to build the plugin.
4. Enable Netcade Interaction under Edit → Plugins if it’s not already enabled.

Downloads

Use these links from your video descriptions and social posts. They all point here, then out to the files.

• Example Project (recommended)
  A minimal UE project showing first-person or third-person character, doors, pickups, and UI wired up.
  Download example project
• Plugin-only ZIP
  Just the plugin, for dropping into an existing project.
  Download plugin (.zip)

You can adjust these URLs in the template or wire them to a download manager / page builder if you prefer.

Quickstart

1) Add NCInteractorComponent to your character

1. Open your player character Blueprint or C++ class (e.g., BP_MyCharacter).
2. Add a NCInteractorComponent as a new component.
3. In the details:
   • Set DetectionRadius (e.g., 600).
   • Set DetectionFrequency (e.g., 0.1 seconds).
   • Toggle bStartWithDetectionActive to true so it starts scanning immediately.

2) Add NCInteractableComponent to a door / pickup

1. Open the Blueprint for your interactable actor (e.g., BP_Door).
2. Add a NCInteractableComponent.
3. In the InteractableData section:
   • Set DisplayText to “Press E to Open Door”.
   • Set InteractionType to Press or Hold.
   • Set MaxUseDistance (or leave 0 to only rely on detection radius).
4. Override HandleInteraction (Blueprint) and add your logic: open the door, play animation, etc.

3) Bind input to InteractInputPressed / Released

In your character Blueprint, bind your input action to the Interactor:

// In your Character BP (or C++ tick / setup)

// Example Blueprint flow:
// - Input Action "Interact" (Pressed)  →  Interactor->InteractInputPressed
// - Input Action "Interact" (Released) →  Interactor->InteractInputReleased

// C++ equivalent (inside your character):
void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

    PlayerInputComponent->BindAction(
        "Interact", IE_Pressed, this, &AMyCharacter::OnInteractPressed);
    PlayerInputComponent->BindAction(
        "Interact", IE_Released, this, &AMyCharacter::OnInteractReleased);
}

void AMyCharacter::OnInteractPressed()
{
    if (NCInteractor)
    {
        NCInteractor->InteractInputPressed();
    }
}

void AMyCharacter::OnInteractReleased()
{
    if (NCInteractor)
    {
        NCInteractor->InteractInputReleased();
    }
}

Interaction model

Interactor vs Interactable

• NCInteractorComponent (player side)
  • Runs sphere traces at a fixed frequency.
  • Builds a list of nearby interactables in OverlappingInteractables.
  • Selects the “best” one based on angle + distance (view dot product + distance score).
  • Tracks the current FocusedInteractable and fires focus/prompt events.
  • Sends input to the server via RPCs (Server_InstantInteract, Server_BeginHoldInteract, etc.).
• NCInteractableComponent (world side)
  • Replicates its core config via FNCInteractableData.
  • Implements CanInteract, HandleInteraction, and HandleInteractionCancelled as BlueprintNativeEvents.
  • Owns on-object prompt widgets (world-space) and hover/progress events.

Press vs Hold

Interaction behavior is driven by ENCInteractionType:

• Press – executes immediately when the key is pressed.
• Hold – client fills LocalInteractionProgress from 0→1; server uses a timer based on InteractionDuration.

The Interactor sends client-side progress to:

• OnInteractionProgress (delegate on the Interactor)
• Client_SetProgress on the Interactable (for its own UI)

Prompt modes

Prompt placement is controlled by ENCInteractionPromptMode on the Interactor:

• ScreenFixed – use a HUD/UI widget at the bottom of the screen.
• WorldAttached – use the Interactable’s world-space widget (3D prompt over the object).

Your UI Blueprint can read PromptMode and decide which widget to show.

Detection & distance

The Interactor uses a sphere trace to find nearby interactables:

• DetectionRadius – how far the trace reaches.
• DetectionFrequency – how often the trace runs (seconds between checks).
• DetectionChannel – collision channel used for the trace.
• FNCInteractableData::MaxUseDistance – optional stricter distance per interactable (if set, it can be smaller than DetectionRadius for precision).

NCInteractorComponent

Detection settings

Events & delegates

The Interactor exposes several events for UI:

• OnFocusedInteractableChanged(UNCInteractableComponent* NewInteractable)
• OnPromptChanged(FText NewPrompt)
• OnInteractionProgress(float Percent, UNCInteractableComponent* Target)

In Blueprint, you typically:

• Bind to OnFocusedInteractableChanged to show/hide your main prompt widget.
• Bind to OnPromptChanged to set the label (“Press E to Open”).
• Bind to OnInteractionProgress to drive a radial progress bar for holds.

Rotate to focused interactable

The Interactor includes a convenience Blueprint node:

UFUNCTION(BlueprintCallable, Category = "NC Interaction|Movement")
void RotateToFocusedInteractable(bool bOnlyAffectYaw = true);

• Call this right before InteractInputPressed if you want your character to snap toward the target.
• It rotates the pawn (not the camera), so the player doesn’t lose camera control.
• It applies the rotation locally, then calls Server_SetActorRotation so the new rotation replicates to other clients.

NCInteractableComponent

FNCInteractableData

Every Interactable has a replicated InteractableData struct that defines how it behaves:

Blueprint hooks

These BlueprintNativeEvents are how you customize behavior per object:

• CanInteract(UNCInteractorComponent* Interactor) const – door locked? need key? distance checks.
• HandleInteraction(UNCInteractorComponent* Interactor) – open door, give item, trigger cutscene.
• HandleInteractionCancelled(UNCInteractorComponent* Interactor) – early release of a hold (e.g., abort hacking).
• GetPrompt(UNCInteractorComponent* Interactor) const – override prompt text at runtime.

Sounds, VFX & highlight

Per-object feedback is configured directly on the component:

• InteractSound, HoverSound
• InteractVFX, HoverVFX
• HighlightComponents array + bAutoGatherHighlightComponents
• bUseCustomDepthHighlight + HighlightStencilValue

When the Interactor focuses an object, it calls Client_SetHovered(true) which:

• Applies highlight (custom depth) via ApplyHighlight.
• Optionally plays hover sound / VFX once.
• Updates on-object widget visibility.

NCOutlineComponent

NCOutlineComponent is a helper that lives on the local pawn and applies overlay materials to meshes on the focused actor. It’s an alternative or complement to CustomDepth-based outlines.

• OutlineMaterial – a material like M_NCOutlineOverlay.
• ColorParamName, DefaultColor – sets the outline color.
• LineStrengthParamName, DefaultLineStrength – controls thickness/intensity.

The Interactor calls:

• ApplyOutlineToActor on the newly focused actor.
• ClearOutlineFromActor on the previously focused actor.

The Outline component prefers the Interactable’s HighlightComponents if present, and otherwise falls back to all mesh components on the actor.

NCInteractionTypes

NCInteractionTypes.h holds shared enums, structs, and delegate signatures so both components can talk to each other without circular includes.

• ENCInteractionType – Press vs Hold.
• FNCInteractableData – core replicated config for interactables.
• FNCOnInteract, FNCOnInteractionProgress, FNCOnHoverChanged – shared delegates.

UI & prompts

The plugin doesn’t force a specific widget, but expects a simple pattern:

• An on-screen HUD widget bound to Interactor events for “Press E to Interact”.
• Optional world-space widgets for per-object prompts (via NCInteractableComponent).

Typical Blueprint wiring:

• On OnFocusedInteractableChanged:
  • Show/hide the HUD prompt.
  • Tell the widget which Interactable it’s looking at (so you can show name, icon, etc.).
• On OnPromptChanged:
  • Update the prompt text label.
• On OnInteractionProgress:
  • Drive a progress bar for hold interactions.

Multiplayer behavior

The plugin is built with multiplayer in mind:

• Only the locally controlled pawn runs detection and sets focus.
• Interactions are initiated on the client, executed on the server.
• NCInteractableComponent and FNCInteractableData are replicated to clients.

Server RPCs on the Interactor:

• Server_InstantInteract(UNCInteractableComponent* Interactable)
• Server_BeginHoldInteract(UNCInteractableComponent* Interactable)
• Server_EndHoldInteract(UNCInteractableComponent* Interactable)
• Server_SetActorRotation(FRotator NewRotation)

On the Interactable, Server_PerformInteraction runs game-specific logic and fires:

• OnInteract (server delegate)
• Multicast_PlayInteractEffects (sound/VFX to all clients)

Delegates

// Called on the server when an interaction completes
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FNCOnInteract,
    UNCInteractorComponent*, Interactor,
    UNCInteractableComponent*, Interactable);

// Called on the client when interaction progress changes (for Hold).
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FNCOnInteractionProgress,
    float, Percent,
    UNCInteractableComponent*, Interactable);

// Called on the client when something becomes hovered / unhovered.
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FNCOnHoverChanged,
    bool, bIsHovered,
    UNCInteractableComponent*, Interactable);

Changelog

• v1.0.0 – Initial public release
  • NCInteractorComponent (detection, focus, press/hold, rotation RPC).
  • NCInteractableComponent (config, Blueprint hooks, world-space prompts, highlight, sound/VFX).
  • NCOutlineComponent (overlay outline material on focused actor).
  • NCInteractionTypes (shared data + delegates).

Support

Questions, bugs, or feature ideas for the Netcade Interaction Plugin?

• Email: [email protected]
• Discord: link from the main Netcade site header
• When you report an issue, include: Unreal version, a short repro, and whether you’re using C++ or Blueprint.