Unreal Key Detection BP

2026-01-15 11:04 UTC gpt-5-2-thinking Open in ChatGPT ↗

In Unreal Blueprints you usually do this through Input events (recommended) or by polling a key state.

Option A (recommended): Input Action mapping

Go to Edit → Project Settings → Input
Under Action Mappings, click +
- Name it e.g. Interact
- Assign the key you want (e.g. E)
In the Blueprint where you want to detect it (often your Character or Player Controller):
- Right-click in the Event Graph and search for InputAction Interact
- Use Pressed / Released pins

This is best because you can remap keys easily later and support controllers.

Option B: Direct key event (quick and simple)

In your Blueprint Event Graph:

Right-click and type the key name, e.g. “E”
Add Keyboard E event (Pressed/Released)

Works fine for quick tests, but it’s less flexible than Action Mappings.

Option C: Check if a key is down (polling)

If you need to check continuously (like “is Shift held while moving”):

Use Is Input Key Down (usually in Player Controller) or
Use an Event Tick + Is Input Key Down (use sparingly)

Common “it doesn’t fire” fixes

Make sure the Blueprint is actually receiving input:
- Put the input in your Character / Pawn that’s possessed, or Player Controller
- Or call Enable Input (and pass the Player Controller) for an Actor
Ensure you’re in Play and the game viewport has focus.

If you tell me which Blueprint you’re doing this in (Character? Actor in the level? Widget?), I can point you to the exact setup that will work there.

Cool — for a Pawn BP, key events will only fire if the pawn is possessed (or you manually enable input). Here are the two common setups.

1) If this Pawn is the player-controlled pawn (best)

Open your Pawn Blueprint → Event Graph
Add either:
- Project Settings → Input Action (recommended): InputAction YourAction
- or direct: Keyboard E (or whatever key)

If nothing fires, make sure the pawn is actually possessed:

In the Pawn instance (in the level) set Auto Possess Player = Player 0
- Details panel → Pawn → Auto Possess Player
Or in your GameMode, set your Pawn as the Default Pawn Class

2) If this Pawn is NOT possessed (AI / placed actor you still want to listen)

In the Pawn BP:

Add Event BeginPlay
Add Get Player Controller (0) → Enable Input
- Plug the controller into Player Controller pin

Now Keyboard E / InputAction events should fire while the game is focused.

Quick tip

If you’re using Action Mappings, prefer them over raw key events. You can still bind “E” today, but later swap it without touching Blueprints.

If you want, tell me whether your pawn is actually the player pawn or just a pawn placed in the level, and I’ll point to the exact “possession” setting you need.

From your screenshot, the key thing is this:

✅ Auto Possess Player = Player 0 (good)
⚠️ Auto Possess AI = Placed in World (this can steal possession with an AIController, so your Pawn won’t receive player key input)

Fix (most likely what you need)

Select your Pawn instance (Mover) in the level
In Details → Pawn
- Set Auto Possess AI → Disabled
- (Optional) Set AI Controller Class → None (or leave, but disabling Auto Possess AI is the big one)

Now your Pawn should be possessed by PlayerController, and Blueprint key events will fire.

Then detect the key in the Pawn Blueprint

In Mover Pawn BP → Event Graph:

Right-click → type your key (example E) → add Keyboard E event
or (better)
Use an Action Mapping (InputAction Interact) and use its Pressed pin.

Quick debug check (to confirm possession)

In the Pawn BP:

Event BeginPlay → Get Controller → Get Class → Print String
- If it prints AIController, input won’t fire from keyboard.
- You want it to be PlayerController.

If you’re using Enhanced Input (UE5)

Even when possessed, you must add the Mapping Context on BeginPlay (in Pawn or PlayerController):

Get Player Controller → Get Local Player → Enhanced Input Local Player Subsystem → Add Mapping Context

If you tell me whether you’re using legacy input or Enhanced Input, I can give you the exact node chain.

Got it — you’re on Enhanced Input (UE5), so you should not use the old Action/Axis mappings.

Here’s the clean Enhanced Input setup to detect a key press inside your Pawn BP.

1) Create the Enhanced Input assets

In Content Browser:

A) Input Action

Add → Input → Input Action
Name: IA_Interact
Open it:
- Value Type: Boolean (or “Digital” depending on UE version)

B) Input Mapping Context

Add → Input → Input Mapping Context
Name: IMC_Player
Open it, add a mapping:
- IA_Interact → Key: E (or whatever key)

2) Add the Mapping Context at runtime (required)

In your Pawn Blueprint (Mover) → Event BeginPlay:

Blueprint node chain:

Get Player Controller (0)
Get Local Player
Get Subsystem (Enhanced Input Local Player Subsystem)
Add Mapping Context
- Mapping Context: IMC_Player
- Priority: 0 (or higher if you have multiple contexts)

This is the step most people miss — without it, your IA events won’t fire.

3) Listen for the Input Action in the Pawn

In the Pawn BP Event Graph:

Right-click → search IA_Interact
Add the event “Input Action IA_Interact” (wording varies slightly)
Use the Triggered pin (or Started if you want only the initial press)

Which pin to use?

Started = fires once when you press
Triggered = fires while held (often every frame depending on triggers)
Completed = fires on release

For a simple “I pressed E” use Started.

4) Two critical gotchas for Pawns

A) Ensure the Pawn is possessed by Player 0

From your earlier screenshot, fix this so the player actually possesses it:

Auto Possess Player = Player 0 ✅
Auto Possess AI = Disabled ✅ (important, otherwise AIController may possess it)

B) Make sure the plugin is enabled

Check Edit → Plugins → Enhanced Input is enabled (usually is by default in UE5 templates).

Quick sanity test (recommended)

On your IA_Interact event:

Started → Print String (“Pressed!”)

If it prints, you’re done.

If you tell me your UE version (5.0/5.1/5.2/5.3/5.4+), I can name the exact node labels (they changed slightly), but the flow above is the correct Enhanced Input solution.

You’re currently looking at the Input Action asset (KeyDown). Mappings are not added inside the Input Action — they’re added in an Input Mapping Context (IMC).

1) Create an Input Mapping Context

In the Content Browser:

Right-click → Input → Input Mapping Context
Name it something like IMC_Player

2) Add a mapping inside the IMC

Double-click IMC_Player to open it
In the IMC editor, you’ll see a Mappings list/table
Click + (Add Mapping)
Set:
- Input Action = your action (e.g. KeyDown)
- Key = the keyboard key you want (e.g. E, Spacebar, etc.)

That’s the mapping.

3) Make sure the IMC is applied at runtime (or it won’t work)

In your Pawn BP → BeginPlay:

Get Player Controller (0)
Get Local Player
Get Subsystem (Enhanced Input Local Player Subsystem)
Add Mapping Context
- Context: IMC_Player
- Priority: 0

Quick gotcha

If you don’t see the “Input Mapping Context” option when right-clicking:

Edit → Plugins → Enhanced Input (enable), then restart.

If you want, show me the IMC window after you open it and I’ll point to exactly where the + button is in your UE version.

In Blueprints, use the Local Player object that comes from the Player Controller.

In your Pawn BP, do it like this:

Get Player Controller (0)
Drag off the return value → search “Get Local Player”
- Pick Get Local Player (Target is Player Controller)
Drag off that return value → search “Get Subsystem”
- Pick Get Subsystem (Enhanced Input Local Player Subsystem)
Call Add Mapping Context

So the chain is:

Get Player Controller (0) → Get Local Player → Get Subsystem (Enhanced Input Local Player Subsystem) → Add Mapping Context

If you can’t find “Get Local Player”

Use this equivalent route (same result):

Get Player Controller (0) → Get Local Player Subsystem (or Get Subsystem) → choose Enhanced Input Local Player Subsystem

In some UE versions the node name/search result differs slightly, but the key is: you want the subsystem Enhanced Input Local Player Subsystem, and it’s fetched from a Local Player (not from the Pawn).

Those three nodes you’re seeing (GetLocalPlayerControllerId / FromId / FromPlatformUser) are not the one you want — they return a PlayerController, not a Local Player.

Use this instead (works with Enhanced Input)

✅ Best way (most UE5 versions)

In your Pawn BP BeginPlay
Add Get Player Controller (0)
Right-click and search for:

Get Enhanced Input Local Player Subsystem

Plug your Player Controller into it (it has a PlayerController input)

From the subsystem output, call Add Mapping Context

This avoids needing a “Get Local Player” node entirely.

If you don’t see “Get Enhanced Input Local Player Subsystem”

Do this:

Get Player Controller (0)
Drag off it and search Get Local Player BUT:
- Make sure Context Sensitive is ON
- And drag from the Player Controller pin first, then search

If it still doesn’t show up, tell me your UE version (5.3/5.4/5.5 etc.) and I’ll point you to the exact node name in that version (Epic renamed some Local Player / Platform User nodes recently).

You’re right to be annoyed — it should be simple. The part that’s biting you is: Enhanced Input key detection only works if an Input Mapping Context is applied to the player’s Local Player/SubSystem. Depending on UE version, the “Get Enhanced Input Local Player Subsystem” helper node may not exist (or won’t show in a Pawn graph search).

Here are 3 reliable ways that work in UE5 with Enhanced Input.

Option 1 (fastest, no “Local Player” nodes): Set a Default Mapping Context in Project Settings

This completely avoids the subsystem nodes.

Edit → Project Settings
Search: Enhanced Input
Find Default Mapping Contexts (or similar section)
Add your IMC_Player to the list (priority 0)

Now the mapping context is automatically applied at runtime.

✅ Then in your Pawn BP, you can add the event:

Right-click in Event Graph → search your Input Action name (e.g. KeyDown)
Add Input Action: KeyDown event
Use Started (press) / Completed (release)

Option 2 (recommended structure): Add Mapping Context in a PlayerController BP

Enhanced Input is “player-side”, so this is the cleanest.

Create a PlayerController Blueprint
In BeginPlay of the PlayerController, add:
- Get Local Player Subsystem (class = EnhancedInputLocalPlayerSubsystem)
- Add Mapping Context (IMC_Player, priority 0)

The node name you want in most versions is Get Local Player Subsystem (not “Get Enhanced Input…”).
When you place it, you choose the subsystem class: EnhancedInputLocalPlayerSubsystem.

Set this PlayerController in GameMode (Project Settings → Maps & Modes)

✅ Your Pawn will now receive the Input Action events (as long as it’s possessed by Player 0).

Option 3 (stay in Pawn): Get Controller → Local Player Subsystem → Add Mapping Context

In Pawn BeginPlay:

Get Controller
Cast to PlayerController
From the cast output, search for Get Local Player Subsystem
- Pick Get Local Player Subsystem
- Set class to EnhancedInputLocalPlayerSubsystem
From that output: Add Mapping Context

If you can’t find Get Local Player Subsystem:

Make sure Context Sensitive is ON
Drag a wire from the PlayerController pin first, then search “subsystem”

One more thing (from your earlier screenshot)

Make sure your pawn isn’t being taken over by AI:

Auto Possess Player = Player 0
Auto Possess AI = Disabled ✅

If AI possesses it, your player input won’t fire.

If you tell me your exact UE version (5.1 / 5.2 / 5.3 / 5.4 / 5.5), I’ll tell you the exact node name as it appears in that version’s Blueprint menu (Epic renamed a bunch of these around the “Platform User” changes).

Fair — if the subsystem getter node isn’t showing in 5.5.4, the simplest 100% Blueprint way to get “key down” working with Enhanced Input is: set your IMC as a Default Mapping Context (so you don’t need any subsystem nodes at all).

Do this (UE 5.5.4, no subsystem nodes)

1) Add the key mapping in an IMC (that’s where mappings live)

Create/open your Input Mapping Context (IMC)
Click + Mapping
Set:
- Input Action = your KeyDown (Digital/bool) action
- Key = the keyboard key you want (E, Space, etc.)

2) Make that IMC apply automatically (the missing piece)

Go to: Edit → Project Settings → Engine → Enhanced Input

Find Default Mapping Contexts and:

Add your IMC (e.g. IMC_Player)
Priority: 0 (or higher if you have multiple)

This is the “set it and forget it” approach and avoids the LocalPlayer subsystem entirely. (Enhanced Input is designed around Mapping Contexts being applied to the player.) citeturn2search13turn1view0

3) Detect the press in your Pawn BP

In your Pawn BP → Event Graph:

Right-click → search your action name (e.g. KeyDown)
Add Input Action: KeyDown event
Use:
- Started = pressed (one time)
- Completed = released

Put a Print String on Started to verify.

If it still doesn’t fire (2 quick checks)

Your Pawn must be player-possessed

Auto Possess Player = Player 0
Auto Possess AI = Disabled (AI possession will break player input)

Debug what Enhanced Input thinks is happening
Open console and run:

ShowDebug EnhancedInput
It will show whether your IMC is active and whether your action is triggering. citeturn2search2

If you want, tell me the exact key and the name of your IMC/IA, and I’ll tell you exactly what the event should look like (Started vs Triggered, etc.).

I can see 2 things in your screenshots that commonly make this “never fires” in UE5.5:

1) Make sure your Pawn is actually the one being possessed

Even if Auto Possess Player = Player 0, your GameMode can still spawn/possess a different Default Pawn at BeginPlay (PlayerStart), which steals input.

Quick check (do this in Mover Pawn BP):

Event BeginPlay
- Print String → Is Player Controlled (node exists)
- also: Get Controller → Get Display Name → Print String

If Is Player Controlled = false or controller is not your PlayerController, then this Pawn will never get input events.

Fix options:

In GameMode (Project Settings → Maps & Modes):
- Set Default Pawn Class = Mover (or None and only use the placed pawn)
Or remove/avoid spawning another pawn at PlayerStart.

2) In UE5.5 you must use Enhanced Input default classes

Go to Edit → Project Settings → Engine → Input (NOT Enhanced Input) and set:

Default Player Input Class = EnhancedPlayerInput
Default Input Component Class = EnhancedInputComponent

If these are still the legacy classes, Enhanced Input Actions often won’t trigger in your Pawn.

3) Your IMC in settings must be the one that actually contains the key mapping

In your Project Settings screenshot, you’re using NewInputMappingContext. Open that IMC and confirm it has:

KeyDown action mapped to your keyboard key (E / whatever)

(If you made a different IMC, pick that one in Default Mapping Contexts.)

4) Test with the correct pin

For a “pressed” test, wire:

Started → Print String("Pressed") And for release:
Completed → Print String("Released")

The fastest “what’s wrong” debug

In Play, open console and run:

ShowDebug EnhancedInput

If your IMC isn’t listed as active, the mapping context isn’t being applied (wrong IMC / defaults disabled). If it is active but your pawn isn’t player controlled, possession is the issue.

If you paste a screenshot of your GameMode Maps & Modes (Default Pawn Class) + the IMC mapping screen, I can tell you exactly which of the above is the blocker.

Your IMC mapping looks fine except I can’t see what key you mapped — it looks like the “keyboard” icon row, but the actual key field isn’t obvious in the screenshot. Make sure that row is set to something like E (it should literally show E, Space Bar, etc. in that little box).

Open the console (UE5.5)

While playing (PIE):

Press ~ (tilde) (on US keyboards, the key under Esc)
On many layouts it’s ` (backtick) / ¬ / ² depending on keyboard language
If it won’t open: Edit → Project Settings → Engine → Input → Console Keys and add a key (e.g. F1)

Then type:

ShowDebug EnhancedInput

That will show whether your mapping context is active and whether your action is triggering.

The #1 reason it still doesn’t work in your setup

Even with correct IMC + event node, it won’t fire if the Pawn isn’t actually getting player input.

Do this quick test in your Mover Pawn BP:

Event BeginPlay → Print String

Is Player Controlled (bool) → print it
Get Controller → Get Display Name → print it

What you want to see

Is Player Controlled = true
Controller name looks like a PlayerController, not AIController, not “None”.

If it prints false or controller is wrong, your GameMode is possessing a different pawn.

Fix: Project Settings → Maps & Modes

Set Default Pawn Class = Mover (or make sure you’re not spawning another pawn at PlayerStart)

Also check one UE5.5 setting that can block Enhanced Input events

Project Settings → Engine → Input

Default Player Input Class = EnhancedPlayerInput
Default Input Component Class = EnhancedInputComponent

If those are legacy, your EnhancedInputAction KeyDown event may never fire.

If you post a screenshot of Maps & Modes (Default Pawn Class / Player Controller Class) and your Engine → Input defaults, I can point to the exact one that’s wrong.

Perfect — that debug text is the smoking gun:

“No enhanced player input action mappings have been applied to this input.”

So your Pawn is possessed (it shows PlayerController_0 Pawn Mover_C_4), but no Mapping Context is actually being applied to the player at runtime.

Fix this in UE5.5.4 (works even if those subsystem nodes don’t show)

1) Project Settings: Enhanced Input

Go to Edit → Project Settings → Engine → Enhanced Input and check both:

✅ Enable Default Mapping Contexts = ON
In Default Mapping Contexts, set Input Mapping Context to your actual IMC asset (the one in your screenshot, e.g. NewInputMappingContext)
✅ Add Immediately = ON
Priority = 0 is fine

Then save and restart PIE.

In your earlier screenshot it looked like you had a default IMC set, but this debug proves it’s not being applied (either defaults aren’t enabled, wrong IMC asset picked, or not saving).

2) Make sure you’re not running without EnhancedPlayerInput / EnhancedInputComponent

Go to Edit → Project Settings → Engine → Input and set:

Default Player Input Class = EnhancedPlayerInput
Default Input Component Class = EnhancedInputComponent

(If these are still legacy, mapping contexts won’t apply correctly.)

3) Double-check the IMC really maps a key

In your IMC, that little key field must show an actual key name (like E). If it’s blank or set to “None”, you’ve mapped the action but not the key.

4) Re-test

Open console and run:

ShowDebug EnhancedInput

Now you should see your Mapping Context listed (and your action firing).

If it STILL says “no mappings applied”

That usually means you’re editing a different IMC than the one assigned in Project Settings.

Quick way to verify:

In Project Settings → Enhanced Input, click the magnifying glass next to the Mapping Context field to browse to the exact asset in the Content Browser. Make sure it highlights the same IMC you edited.

If you share a screenshot of Project Settings → Engine → Input (the one with Default Player Input Class / Default Input Component Class), I can tell you immediately if that’s the remaining blocker.

That debug overlay is super useful. It confirms:

✅ Your Pawn is possessed (PlayerController_0 Pawn Mover_C_4)
❌ But no Enhanced Input mapping contexts are actually applied (so your KeyDown action will never fire)

So we stop chasing the event node and fix why the context isn’t being applied.

1) Save everything (this bites a LOT)

In your earlier screenshots I can see “Unsaved” indicators.

Do:

File → Save All (or Ctrl+Shift+S)
Close editor and reopen the project (seriously)

If the IMC or Project Settings weren’t saved, the default context list can “look” set but won’t actually apply at runtime.

2) Verify you’re truly using Enhanced input classes at runtime

Even if you changed Project Settings, your running PIE may still be using legacy input classes (or something overrides them).

In Mover Pawn BP → BeginPlay, add these prints:

Get Controller → (Cast to PlayerController)
From PlayerController:

Get Player Input → Get Class → Get Display Name → Print String
✅ You want it to print something like EnhancedPlayerInput

Also:

Get Input Component → Get Class → Get Display Name → Print String
✅ You want EnhancedInputComponent

If either one prints the non-enhanced class:

Go to Project Settings → Engine → Input

Default Player Input Class = EnhancedPlayerInput
Default Input Component Class = EnhancedInputComponent

Then Save All + restart editor.

In UE, it’s common for this to not “take” until after a restart, and/or if a class overrides it.

3) Make sure the IMC you applied in settings is the same IMC you edited

In Project Settings → Engine → Enhanced Input → Default Mapping Contexts:

Click the magnifying glass next to the IMC field
That should highlight the IMC asset in the Content Browser.

Open that exact asset and confirm it contains your mapping.

4) One more gotcha: your IMC mapping row must show an actual key name

In your IMC screenshot I see the keyboard icon row, but I don’t see a key label like E / Space Bar.

Click that key field and pick a specific key. It should visibly read something like:

E
Left Mouse Button
Space Bar

(If it’s “None” or blank, you effectively mapped nothing.)

5) If you still get “No mappings applied” after all that

Then your “Default Mapping Contexts” simply aren’t being pushed to the player for some reason in your project.

At that point, the guaranteed fix is to apply the context yourself at BeginPlay — but you said those subsystem getter nodes don’t exist in your menu, so here’s the trick that usually makes them appear in 5.5:

The “nodes don’t exist” trick (works in 5.5)

In the graph, place Get Player Controller
Drag a wire from its output pin, then search Subsystem / Mapping Context.

When you search from the pin (with Context Sensitive on), UE shows functions it hides from global search.

You’re looking for a node that lets you call Add Mapping Context. (In 5.5 it often only appears when searching from the correct pin type.)

Why I’m confident it’s one of the above

Because ShowDebug EnhancedInput is telling you the system is running, but the applied contexts list is empty. That only happens when:

settings/assets weren’t saved / not loaded,
wrong IMC asset is assigned,
not using EnhancedPlayerInput / EnhancedInputComponent,
or defaults aren’t being applied in your runtime path.

If you do Step 2 and tell me what the two printed class names are (PlayerInput class + InputComponent class), I can tell you immediately which bucket you’re in and the exact fix.

Nice — that screen means you’ve crossed the big hurdle:

✅ Your Mapping Context is now applied (Context: NewInputMappingContext shows up)

Now the reason your action still isn’t firing is shown here:

Action: KeyDown - None - 0.000s (false)
and it even prints E - below, which usually means the key is being seen, but it’s not matching your action mapping (or it’s being blocked/consumed).

Here are the fixes in order of likelihood:

1) Your IMC mapping might not actually be set to the “E” key

Open NewInputMappingContext and click the mapping row for KeyDown.

Make sure the key field literally reads E (not blank / not “Any Key” / not something else).

If it’s correct, delete that mapping row and re-add it:

+ Mapping → Action KeyDown → Key E

(UE sometimes keeps a “None” key in there without it being obvious.)

2) You’re using the wrong event pin in the Blueprint

For a Digital(bool) action with no triggers:

Use Started → fires once on press
Use Completed → fires on release

Triggered can be finicky depending on triggers/settings.

So wire:

EnhancedInputAction KeyDown Started → Print String("E pressed")

3) Input is being consumed by something else (very common)

If you have a Widget focused (UI), or another actor/controller consuming the input, your pawn may not get it.

Quick tests:

Click the viewport to ensure game has focus (you already see “Click for Mouse Control”)
Temporarily disable UI input:
- In PlayerController BeginPlay: Set Input Mode Game Only

Also: in the Input Action asset (KeyDown) you have “Consume Lower Priority…” checked (I saw that earlier). That only affects priority order, but still—keep it simple:

In the Input Action asset, set Consume options OFF for testing.

4) Your Pawn’s input component isn’t an EnhancedInputComponent

Even though the context is applied, the Pawn needs the enhanced input component to fire that “EnhancedInputAction …” event node.

In your Pawn BeginPlay, print:

Get Input Component → Get Class → Print

You want it to be EnhancedInputComponent.

If it’s not: Project Settings → Engine → Input

Default Input Component Class = EnhancedInputComponent
Default Player Input Class = EnhancedPlayerInput Save All + restart editor.

Quick “bulletproof” validation

In the Pawn BP, add BOTH:

EnhancedInputAction KeyDown Started → Print
AND a plain Keyboard E event → Print

If Keyboard E prints but the Enhanced one doesn’t:

it’s 100% a mapping/action/EnhancedInputComponent issue. If neither prints:
focus/possession/input mode issue.

If you show me (1) your IMC row where the key label is visible and (2) your Pawn BeginPlay mapping-context node chain, I can point to the exact mismatch in one glance.

You should be seeing the “started” print when you press E — your graph is almost right. The reason you’re not is in your screenshot:

You’re running in SIMULATING mode (and the graph is READ-ONLY)

Enhanced input won’t reliably route to your pawn in Simulate, and the viewport focus/input capture is different. Use Play, not Simulate.

✅ Fix:

Click the dropdown next to the Play button and choose Selected Viewport (regular Play)
Or hit the normal Play button (not Simulate)
Then click in the viewport to capture input, press E

That alone usually makes it work.

Two more issues to fix in your BP

1) Your “Is Player Controlled” Print is never executed

You wired the bool into the Print String text pin, but you didn’t execute Print String.

Do:

Event BeginPlay → Print String
For the string, use Is Player Controlled → Select String (“true/false”) or just convert bool to string.

2) Make sure “Add Mapping Context” actually runs

Right now your Add Mapping Context exec pin is not connected to BeginPlay (in the screenshot). It needs an execution wire.

Do:

Event BeginPlay → Add Mapping Context (exec in)
Optionally after that → Print “Context added”

(Your context is showing in debug now, so you probably did run it earlier — but wire it cleanly anyway.)

After switching to PLAY, if it still doesn’t fire

The debug you showed earlier said: Action: KeyDown - None (false) and displayed E -

That often means the IMC action mapping isn’t actually set to E (or it’s set but not saved).

In the IMC:

Delete the mapping row
Re-add: Action = KeyDown, Key = E
Save the IMC

Do this exact test sequence

Save All
Run Play (Selected Viewport) (not Simulate)
Click viewport
Press E

If you still don’t get “started”, tell me what ShowDebug EnhancedInput shows for the line under your context (it should list your action bound to E).

Yep — with Context showing up but the action line still saying:

Action: KeyDown - None ... (false)

that means your action currently has no key bound to it at runtime.

So the Mapping Context is applied ✅, but the mapping entry itself is effectively “None” ❌.

Fix: actually set the Key in the IMC (the “keyboard icon” isn’t the key)

In your IMC screenshot, that little keyboard icon row is just the device category. You still need to pick the actual key (E).

Do this:

Open NewInputMappingContext
Under Mappings, expand your KeyDown entry
Click the empty key field (the small box/dropdown on that row — it should show something like None / blank)
Choose E from the list
Save the IMC

After saving, when you run ShowDebug EnhancedInput, the action line should show E instead of None.

Quick sanity test

Map it temporarily to something obvious like:

Space Bar or Left Mouse Button

If that fires, you know input is fine and it was just the key field not actually set.

Your BP is fine (one minor wiring tip)

Make sure Event BeginPlay is actually executing Add Mapping Context via the white exec wire (looks like it might not be in the screenshot), but since your debug shows the context, you’re probably executing it already.

If you paste a zoomed-in screenshot of the exact mapping row (where the key name would appear), I can point to the exact click target—UE’s IMC UI is annoyingly subtle.

Here’s a dead-simple “Mover” Pawn that you can drop in a level and move with WASD (UE5.5 + Enhanced Input), no fancy setup.

1) Create the Pawn

Blueprint Class → Pawn → name it BP_Mover
Open it, add components:
- StaticMesh (or Capsule) as the visible body (make it the Root if you want)
- FloatingPawnMovement (this is the important part)

If your mesh has Simulate Physics ON, turn it OFF or FloatingPawnMovement won’t move it.

In the Pawn instance (placed in level):
- Auto Possess Player = Player 0

2) Create Enhanced Input Actions

Create these Input Actions:

`IA_MoveForward`

Value Type: Axis1D

`IA_MoveRight`

Value Type: Axis1D

Create an Input Mapping Context:

`IMC_Mover`

Add mappings:

IA_MoveForward → W (Scale +1)
IA_MoveForward → S (Scale -1)
IA_MoveRight → D (Scale +1)
IA_MoveRight → A (Scale -1)

(In the IMC row, the key must literally show W/A/S/D — not “None”)

3) Apply the IMC on BeginPlay (in your Pawn)

In BP_Mover Event Graph:

Event BeginPlay →

Get Player Controller (0)
Enhanced Input Local Player Subsystem (the node you already found)
Add Mapping Context
- Mapping Context = IMC_Mover
- Priority = 0

4) Move the Pawn (Blueprint)

Add these two events in the Pawn:

Event: `EnhancedInputAction IA_MoveForward`

Use Triggered →

Add Movement Input
- World Direction = Get Actor Forward Vector
- Scale Value = Action Value (float)

Event: `EnhancedInputAction IA_MoveRight`

Use Triggered →

Add Movement Input
- World Direction = Get Actor Right Vector
- Scale Value = Action Value (float)

That’s it. Press WASD → it moves.

If it still doesn’t move

Ensure your Pawn has FloatingPawnMovement component
Ensure mesh isn’t Simulating Physics
Play in Play mode (not Simulate)
Run ShowDebug EnhancedInput and confirm your IMC shows up

If you want, tell me whether you want top-down (X/Y only) or free-fly (WASD + Space/Ctrl up/down) and I’ll add the extra two inputs cleanly.

In UE5.5’s Input Mapping Context (IMC), the “scale” isn’t a separate obvious field until you expand the key mapping.

How to set W = +1 and S = −1 (Axis1D)

Open your IMC (e.g. IMC_Mover)
Under Mappings, add IA_MoveForward twice:
- one mapping with key W
- one mapping with key S
For the S mapping:
- Expand the mapping row (click the little triangle/chevron on the left of that key mapping row)
- Expand Modifiers
- Click + and add Negate (this is the UE5.5 way to do “scale -1”)

✅ Result:

W has no modifier → +1
S has Negate modifier → -1

Same for A/D (Axis1D)

IA_MoveRight mapped to D (no modifier)
IA_MoveRight mapped to A with Negate modifier

Alternative: Scalar modifier (if you want custom scaling)

If you want something like 0.5 speed:

Modifiers → + → Scalar
Set Scalar = 0.5 For negative: Scalar = -1 (or just use Negate)

If you show me a zoomed-in screenshot of one mapping row expanded, I can tell you exactly which dropdown to click (UE’s IMC UI hides this stuff behind the tiny expand arrow).