Frequently Asked Questions

Quick answers to common questions.

Compatibility

Q: What Unreal Engine versions are supported?

A: Unreal Engine 5.7.

The plugin uses modern UE5 features and APIs. Earlier versions are not supported.

Q: Does this work in VR?

A: Yes! Use Cone Detection with appropriate angle settings.

VR works great with:

Detection Method: Cone
Interaction Distance: 400
Max Detection Angle: 60

Point your controller at objects and interact!

Q: Can I use this with Enhanced Input?

A: Absolutely! Just bind your Enhanced Input Action:

IA_Interact (Triggered)
└─ Start Interaction

IA_Interact (Completed)
└─ Stop Interaction

Works with both legacy and Enhanced Input systems.

Q: Does it work on mobile/console?

A: Yes! Works on all platforms Unreal Engine supports:

• PC (Windows, Mac, Linux)
• Console (PlayStation, Xbox)
• Mobile (iOS, Android)
• VR (Quest, SteamVR, PSVR)

Note on Nintendo Switch: UE5 supports Switch in principle, but Nintendo requires an approved developer license, and Switch-specific platform SDKs must be obtained separately. The plugin itself has no Switch-specific limitations, but platform access is subject to Nintendo’s developer program.

Usage

Q: Do I need C++ knowledge?

A: No! The plugin is fully usable from Blueprints only.

C++ knowledge is only needed if you want to:

• Extend the system with custom behavior
• Modify core functionality
• Optimize for specific use cases

All common use cases work 100% in Blueprint.

Q: Can I have different widgets for different objects?

A: Yes! Each object’s WidgetComponent can have a different Widget Class assigned.

Example:

Door → WBP_SimplePrompt
NPC → WBP_NPCDialogue
Chest → WBP_LootPrompt

Q: How do I add sounds to interactions?

A: In your Interactable Object’s Event Graph:

Event OnInteract_Multicast (All Clients)
├─ Play Sound at Location (Interaction Sound, Actor Location)
└─ Your visual logic...

Event OnInteract (Server)
└─ Your gameplay logic...

You can also play sounds on:

• OnHoldStarted_Multicast (hold begin)
• OnHoldCompleted_Multicast (success)
• OnHoldCancelled_Multicast (fail)

Use Multicast events for sounds/VFX so all players hear them — not just the server.

Q: Can I change interaction settings at runtime?

A: Yes! InteractionData is a struct you can modify:

Get Interactable Component
└─ Set Interaction Data (New Data)

Or modify individual properties:

Get Interactable Component
├─ Get Interaction Data (Break)
├─ Modify properties
└─ Set Interaction Data (Make)

Q: How do I make an object interactable only once?

A: Set bIsReusable = False in InteractableComponent.

After first interaction, object auto-disables. No Blueprint logic needed.

Q: Can I disable/enable objects at runtime?

A: Yes!

// Disable
Interactable Component → SetEnabled (False)

// Enable
Interactable Component → SetEnabled (True)

Disabled objects won’t be detected or interacted with. Widget hides automatically.

Interaction Types

Q: What are the three interaction types?

A:

Q: How do I know when a Hold interaction is complete?

A: Use the OnHoldCompleted event:

Event OnHoldCompleted (Server — gameplay logic)
└─ Do Success Action (unlock, award XP, etc.)

Event OnHoldCompleted_Multicast (All Clients — visual feedback)
└─ Play Success Sound / Particles

Track progress with:

Event OnHoldProgress (Progress: 0.0 - 1.0)
└─ Update UI / Play Sound

Q: Can I cancel a Hold interaction?

A: Yes! The player releases input → Hold is automatically cancelled.

Event OnHoldCancelled (Server)
└─ Revert any partial changes

Event OnHoldCancelled_Multicast (All Clients)
└─ Play Fail Sound

Q: How does InstantAndHold work?

A: InstantAndHold uses a TapThreshold to decide whether a press was a tap or a hold:

Player presses key
├─ Released before TapThreshold (e.g., 0.3s)? → Tap → OnInteract fires
└─ Still held past TapThreshold?               → Hold begins → OnHoldStarted fires

Example setup:

InteractionData:
├─ Interaction Type = InstantAndHold
├─ TapThreshold = 0.3 (seconds)
└─ HoldDuration = 2.0 (seconds)

Blueprint:

Event OnInteract (Server)       // Tap
└─ Quick action (pick up, toggle, etc.)

Event OnHoldCompleted (Server)  // Hold
└─ Slow action (inspect, charge, etc.)

The decision is made locally on the client for instant response, then sent to the server via RPC.

Q: Can I implement a toggle (on/off) behavior?

A: Yes! Use the Instant type and manage state in your object:

// Add a boolean variable to your object
Variable: bIsPowered (Boolean, Replicated)

Event OnInteract (Server)
├─ Flip Boolean (bIsPowered)
└─ Branch: Is Powered?
   ├─ True  → Turn On Logic
   └─ False → Turn Off Logic

State management belongs in your game object — the interaction system just fires the event.

Multi-Zone and Multi-Option

Q: How do I make an object with multiple interaction zones?

A: Use InteractionPoints — add one entry per zone, each with its own position and interaction settings:

InteractableComponent → Interaction Points:
├─ [0] RelativeLocation: (0, -50, 0)  | Name: "Open Driver Door"    | Type: Instant
├─ [1] RelativeLocation: (0,  50, 0)  | Name: "Open Passenger Door" | Type: Instant
└─ [2] RelativeLocation: (100,  0, 0) | Name: "Open Trunk"          | Type: Hold | HoldDuration: 1.5

The plugin automatically detects which zone the player is aiming at and uses that zone’s InteractionData. Each zone has its own DetectionRadius.

Q: How do I enable or disable individual interaction zones at runtime?

A:

// Disable a point (e.g., driver door already open)
Interactable Component → SetPointEnabled (PointIndex: 0, bEnabled: False)

// Re-enable it
Interactable Component → SetPointEnabled (PointIndex: 0, bEnabled: True)

Disabled points are invisible to detection — the player can’t focus or interact with them.

Q: How do I know which zone the player is looking at?

A: Override OnInteractionPointFocused in your widget Blueprint:

Event OnInteractionPointFocused (PointData, PointIndex)
└─ Update action label to PointData.InteractionName

This fires every time the player’s aim crosses into a different zone.

Q: How do I add multiple options to one interaction (like Take / Inspect / Leave)?

A: Use InteractionOptions — add one FInteractionData entry per choice:

InteractableComponent → Interaction Options:
├─ [0] Name: "Take All"  | Type: Instant
├─ [1] Name: "Inspect"   | Type: Instant
└─ [2] Name: "Leave"     | Type: Instant

Bind scroll wheel in your Character Blueprint:

Mouse Wheel Up   → InteractionComponent → CycleInteractionOption (Direction: +1)
Mouse Wheel Down → InteractionComponent → CycleInteractionOption (Direction: -1)

The active option’s data is used when the player presses the interact key.

Q: How does the widget know which option is currently selected?

A: Override these two events in your widget:

Event OnInteractionOptionsAvailable (Options, ActiveIndex)
└─ Build the option list (show all, highlight ActiveIndex)

Event OnInteractionOptionChanged (ActiveOption, ActiveIndex)
└─ Update the highlighted row

OnInteractionOptionsAvailable fires when the object is first focused. OnInteractionOptionChanged fires each time the player scrolls.

Highlight System

Q: How does the highlight outline work?

A: When an object receives focus, the plugin automatically enables Custom Depth Stencil on the object’s mesh — Unreal’s built-in outline system.

To see the outline you need a Post Process Material in a Post Process Volume that reads the custom depth buffer and draws an outline. The plugin just turns the depth pass on/off — the visual style is controlled entirely by your PP material.

Configuration:

InteractableComponent:
├─ bEnableHighlight = True      (default)
└─ HighlightStencilValue = 1   (0–255)

The plugin handles SetRenderCustomDepth and SetCustomDepthStencilValue automatically — no Blueprint wiring needed.

Q: Can I have different outline colors per object type?

A: Yes! Assign different stencil values and handle them in your Post Process material:

Door:        HighlightStencilValue = 1  → Blue outline
Enemy:       HighlightStencilValue = 2  → Red outline
Collectible: HighlightStencilValue = 3  → Yellow outline

Your PP material reads the stencil value and applies the matching color.

Q: Can I turn off the highlight for specific objects?

A: Two ways:

// Permanently off via property
InteractableComponent → bEnableHighlight = False

// Toggle at runtime
InteractableComponent → SetHighlightEnabled (False)
InteractableComponent → SetHighlightEnabled (True)

Input Device Detection

Q: How do I show different button hints for keyboard vs gamepad?

A: Call SetActiveInputType on the InteractionComponent when the input device changes, then handle it in your widget:

// In Character Blueprint — call when Enhanced Input device changes
InteractionComponent → SetActiveInputType (bIsGamepad: True)

// Widget Blueprint
Event OnInputDeviceChanged (bIsGamepad)
├─ True  → Show gamepad button icon (A / Cross)
└─ False → Show keyboard key icon (E)

Typical Enhanced Input integration:

Event OnInputDeviceChanged (from Enhanced Input Subsystem)
└─ InteractionComponent → SetActiveInputType (bIsGamepad)

Q: Can I check from the widget which device is active without waiting for the event?

A: Yes:

InteractionWidget → IsGamepadActive() → bool

Use this on OnInteractionAvailable to immediately show the correct icon when the widget appears.

Multiplayer

Q: Does this work in multiplayer?

A: Yes! Fully replicated with server authority.

• Client requests → Server validates → Server executes
• State replicates to all clients
• Built-in anti-cheat (distance checks, cooldowns, CanInteract)

Q: Do I need to do anything special for multiplayer?

A: No! It works automatically.

The system:

• Sends RPCs to server automatically
• Validates on server automatically
• Replicates state to clients automatically

Just implement your interaction logic in OnInteract and OnInteract_Multicast.

Q: What is bRequiresServerAuthority?

A: It controls whether interactions go through the server or run locally:

InteractionData:
└─ bRequiresServerAuthority = False

Use false for interactions that have no gameplay impact and you want instant response with zero network overhead.

Q: Can clients cheat?

A: No. Server validates everything:

• Distance (cannot interact from too far)
• Cooldowns (enforced server-side)
• CanInteract state (evaluated server-side)
• Object enabled state (replicated)

Client can request, but server decides.

Detection

Q: Which detection method should I use?

A: Depends on your game type:

Test different methods — they’re easy to switch!

Q: Can I use multiple detection methods?

A: One method at a time per InteractionComponent.

But you can switch dynamically:

InteractionComponent → Set Detection Method (New Method)

Or have different characters use different methods.

Q: How do I prevent detecting objects behind walls?

A: Ensure walls have collision enabled.

Wall:
└─ Collision: BlockAll or BlockAllDynamic

Line Trace method is best for this — it is naturally blocked by geometry. Overlap and Cone are not.

Filtering

Q: How do I make only certain objects interactable?

A: Use Tag Filtering:

1. On Player’s InteractionComponent:

   bUseTagFiltering = True
   Required Tags = ["Interactable"]
   

2. On Objects:

   • Details → Tags → Add “Interactable”

Now only tagged objects are detected.

Q: Can I temporarily disable specific objects?

A: Two approaches:

Via Tags:

InteractionComponent:
└─ Ignored Tags = ["Locked"]

Object:
└─ Add Tag "Locked" (cannot be interacted with)
└─ Remove Tag "Locked" (available again)

Via Component:

Interactable Component → SetEnabled (False)

Q: How does the CanInteract system work?

A: Override CanInteract in your object Blueprint to return false when conditions are not met:

Function CanInteract (Interacting Actor) → bool
├─ Cast to BP_Player
└─ Return: Has Item "Key"

When CanInteract returns false:

• If bHideWidgetWhenUnavailable = true (default) → Widget is hidden
• If bHideWidgetWhenUnavailable = false → Widget is visible but shows “disabled” state

This lets you build locked doors, quest prerequisites, item requirements, etc.

Q: How does the Priority system work?

A: When multiple objects overlap, highest priority is selected.

NPC (Priority 10) + Item (Priority 0) → NPC selected automatically

Higher number = higher priority.

Widgets

Q: Why must widgets inherit from InteractionWidget?

A: The C++ class provides the Blueprint Implementable Events:

• OnInteractionAvailable
• OnInteractionUnavailable
• OnHoldStarted / OnHoldProgressUpdated / OnHoldCompleted / OnHoldCancelled

Without it, these events won’t exist in your widget graph.

Q: How do I show a “locked” or “disabled” state in the widget?

A: Set bHideWidgetWhenUnavailable = false on the InteractableComponent, then handle the state in your widget:

Event OnInteractionAvailable (InteractionData)
├─ Check CanInteract (via interface on actor)
│  ├─ True  → Show active UI ("Open Door")
│  └─ False → Show disabled UI ("Requires Key")

Q: Can widgets have animations?

A: Yes! Create animations in Widget Designer:

Event OnInteractionAvailable
├─ Play Animation (FadeIn)
└─ Update text...

Event OnInteractionUnavailable
└─ Play Animation (FadeOut)

Q: Do I need to set the Widget Component space manually?

A: No! The system automatically sets it to Screen Space at BeginPlay. Your widget will always face the camera without any extra setup.

Advanced

Q: Can I create interaction chains?

A: Yes! Example:

// Lever
Event OnInteract (Server)
├─ Enable Button
└─ SetEnabled (False)

// Button (starts disabled)
Event OnInteract (Server)
└─ Complete Puzzle

Q: Can I require items for interactions?

A: Yes! Use CanInteract:

Function CanInteract (Interacting Actor) → bool
├─ Cast to MyPlayerCharacter
└─ Return: Has Item "Key"

Or check inside the event:

Event OnInteract (Interacting Actor)
├─ Cast to MyPlayerCharacter
├─ Branch: Has Item "Key"?
│  ├─ Yes → Open Door
│  └─ No → Show Message "Locked"

Q: Can I interact with moving objects?

A: Yes! Works with any Actor, including:

• Vehicles
• Moving platforms
• Flying objects
• Animated actors

Q: How do I create timed interactions?

A: Use Hold type with HoldDuration:

InteractionData:
├─ Interaction Type = Hold
└─ Hold Duration = 5.0 (5 seconds)

Or use InstantAndHold if you also want a quick tap action.

Performance

Q: How many interactable objects can I have?

A: Thousands! The system is optimized:

• Detection runs at intervals (not every frame)
• Efficient trace queries
• No per-frame overhead from inactive objects

For very large numbers (10,000+), use distance culling.

Q: Does this impact FPS?

A: Minimal impact (under 0.1ms per frame) with default settings.

If you notice performance issues:

• Increase Detection Interval (0.1 → 0.2)
• Use Tag Filtering
• Implement distance culling
• Use Line Trace (cheapest method)

Q: Should I disable Debug in final build?

A: Always:

Show Debug = False

Debug visualization has a performance cost and looks unprofessional in shipped games.

Integration

Q: Can I use this with my existing systems?

A: Yes! The system is non-invasive:

• Component-based (doesn’t replace your classes)
• Event-driven (integrate via events)
• No dependencies on other systems

Works alongside inventory, dialogue, quest systems, etc.

Q: Can I extend the system in C++?

A: Yes! All classes are designed for extension:

• Inherit from UInteractionComponent
• Inherit from UInteractableComponent
• Override virtual functions
• Add custom detection methods or validation logic

Q: Does this work with AI/NPCs?

A: Yes! Add InteractionComponent to your AI Character and set the target manually — no detection needed:

// AI Controller or Behavior Tree
InteractionComponent → SetInteractionTarget (TargetActor)
InteractionComponent → StartInteraction()

SetInteractionTarget bypasses detection entirely. The AI can directly trigger interactions without aiming or tracing — ideal for Behavior Tree tasks.

Licensing

Q: Can I use this in commercial projects?

A: Yes! Licensed under Unreal Engine Marketplace EULA.

You can:

• Use in commercial games
• Modify the code
• Ship with your game

You cannot:

• Resell the plugin
• Share with other developers (they need to purchase it)

Q: Can I modify the plugin?

A: Yes! You have full source code access.

Modify anything you need for your project.

Support

Q: Where do I get help?

1. Check this documentation
2. Review Troubleshooting
3. Review Getting Started
4. Join the Discord community
5. Contact support via Marketplace

Q: How do I report bugs?

Please provide:

• Unreal Engine version
• Steps to reproduce
• Expected vs actual behavior
• Screenshots or Output Log

Report via the Marketplace support page or Discord.

Q: Will there be updates?

Plugin is actively maintained. Updates will include:

• Bug fixes
• New features
• Compatibility with new UE versions
• Performance improvements

Didn’t find your answer?

• API Reference — Full property and event reference
• Core Concepts — Deep dive into the system
• Troubleshooting — Solutions to common problems

← Back to Index