claude-code-arcane 2.2.0 → 2.4.0

package/skills/ue-gameplay-framework/references/framework-class-map.md

@@ -0,0 +1,243 @@
+# Gameplay Framework Class Map
+
+Reference table showing where each class lives, who owns it, what it stores, and
+the exact lifecycle hook order. Cross-reference with SKILL.md for code examples.
+
+---
+
+## Authority and Presence Matrix
+
+| Class | Dedicated Server | Listen Server (Host) | Listen Server (Remote Client) | Standalone |
+|---|---|---|---|---|
+| AGameModeBase / AGameMode | YES (authority) | YES (authority) | NO — null | YES (authority) |
+| AGameStateBase / AGameState | YES | YES | YES (replicated) | YES |
+| APlayerController (local player) | N/A | YES (server+client role) | YES (own only) | YES |
+| APlayerController (remote player) | YES (all players) | YES (all players) | NO — not present | N/A |
+| APlayerState (all players) | YES (all) | YES (all) | YES (all, replicated) | YES |
+| APawn / ACharacter (possessed by local) | YES (auth) | YES (auth+local) | YES (local proxy) | YES |
+| APawn / ACharacter (possessed by remote) | YES (auth) | YES (auth) | YES (simulated proxy) | N/A |
+| UGameInstance | YES | YES | YES | YES |
+| AHUD | NO | YES (host player only) | YES (own only) | YES |
+| APlayerCameraManager | NO | YES (host player only) | YES (own only) | YES |
+
+**Key:** "YES (auth)" = exists with `ROLE_Authority`. "YES (simulated proxy)" = exists with `ROLE_SimulatedProxy`, position interpolated from server updates.
+
+---
+
+## Class Ownership Chain
+
+```
+UGameInstance  [persists across all level loads]
+  |
+  +-- UWorld
+        |
+        +-- AGameMode           [server only]
+        |     |
+        |     +-- AGameState    [server + all clients]
+        |           |
+        |           +-- PlayerArray[]  --> APlayerState per player
+        |
+        +-- APlayerController   [server: all; client: own only]
+              |
+              +-- APlayerState  [server + all clients]
+              |
+              +-- AHUD          [local client only]
+              |
+              +-- APlayerCameraManager  [local client only]
+              |
+              +-- (possesses) --> APawn / ACharacter
+                                    |
+                                    +-- UCharacterMovementComponent
+                                    +-- UCapsuleComponent  (root)
+                                    +-- USkeletalMeshComponent
+```
+
+---
+
+## Responsibility Summary
+
+| Class | Primary Responsibility | Do NOT put here |
+|---|---|---|
+| AGameModeBase | Game rules, join approval, player spawn points, match initialization | Any data clients need to read |
+| AGameMode | AGameModeBase + match state machine (WaitingToStart, InProgress, etc.) | Per-player data |
+| AGameStateBase | Global replicated state: server clock, player array, has match started | Server-only logic |
+| AGameState | AGameStateBase + match elapsed time | Client-only UI state |
+| APlayerController | Input, camera, HUD management, possess/unpossess, client↔server RPC bridge | Cross-session data (may be replaced during seamless travel if PC class changes) |
+| APlayerState | Replicated per-player data: name, score, team, ping | Input processing, UI |
+| APawn | Minimal possessable actor, custom movement | Anything requiring capsule/mesh/built-in movement |
+| ACharacter | Humanoid movement with capsule, skeletal mesh, and CMC prediction | Game rules, scoring |
+| UGameInstance | Cross-level persistence: sessions, save game refs, analytics | Per-match state |
+| AHUD | Local-only 2D overlay rendering | Any replicated data |
+
+---
+
+## Player Join Sequence (Server Side)
+
+```
+1. PreLogin(Options, Address, UniqueId, ErrorMessage)
+      Set ErrorMessage != "" to reject.
+
+2. Login(NewPlayer, RemoteRole, Portal, Options, UniqueId, ErrorMessage)
+      Creates APlayerController via SpawnPlayerController().
+      Creates APlayerState, assigns UniqueId and name.
+      Returns new PC (or null on failure).
+
+3. PostLogin(NewPlayer)
+      First point where server-to-client RPCs are safe.
+      GameState->PlayerArray is populated.
+      Override to assign teams, send initial data.
+
+4. HandleStartingNewPlayer(NewPlayer)
+      Calls RestartPlayer() if not spectator.
+
+5. RestartPlayer(NewPlayer)
+      Calls FindPlayerStart() -> ChoosePlayerStart()
+      Calls SpawnDefaultPawnFor()
+      Calls NewPlayer->Possess(Pawn)
+```
+
+---
+
+## Player Logout Sequence
+
+```
+1. Logout(Exiting)            -- GameMode notified (server only)
+2. GameState->RemovePlayerState(PS)  -- PlayerArray updated
+3. PlayerController destroyed
+4. PlayerState destroyed (after ReplicationTimeout or immediately if non-seamless)
+```
+
+---
+
+## Seamless Travel Actor Survival
+
+When `bUseSeamlessTravel = true`, the travel happens in two legs:
+- **Leg 1:** Current map → Transition map
+- **Leg 2:** Transition map → Destination map
+
+`GetSeamlessTravelActorList` is called for BOTH legs.
+
+| Object | Survives Seamless Travel | Notes |
+|---|---|---|
+| UGameInstance | YES | Never dies |
+| APlayerController | YES (transferred) | Engine handles this automatically |
+| APlayerState | YES (transferred with PC) | Engine handles this automatically |
+| AGameMode | NO | New one spawned in destination map |
+| AGameState | NO | New one spawned in destination map |
+| APawn / ACharacter | NO (by default) | Destroyed; new one spawned by RestartPlayer |
+| Custom actors | Optional | Add in GetSeamlessTravelActorList() |
+
+---
+
+## Movement Mode Reference (UCharacterMovementComponent)
+
+| EMovementMode | Description | Typical Use |
+|---|---|---|
+| MOVE_None | No movement processed | Ragdoll, dead state |
+| MOVE_Walking | On ground, uses NavMesh | Default walking/running |
+| MOVE_NavWalking | On NavMesh surface (AI) | AI characters on nav mesh |
+| MOVE_Falling | In air, gravity applied | After jump, falling off ledge |
+| MOVE_Swimming | In fluid volume | Water traversal |
+| MOVE_Flying | No gravity, full air control | Spectator, flying character |
+| MOVE_Custom | User-defined (CustomMovementMode byte) | Wall running, zero-G, grapple |
+
+---
+
+## Key Properties Quick Reference
+
+### AGameModeBase Classes
+
+```cpp
+TSubclassOf<APawn>              DefaultPawnClass;
+TSubclassOf<AGameStateBase>     GameStateClass;
+TSubclassOf<APlayerController>  PlayerControllerClass;
+TSubclassOf<APlayerState>       PlayerStateClass;
+TSubclassOf<AHUD>               HUDClass;
+TSubclassOf<ASpectatorPawn>     SpectatorClass;
+TSubclassOf<AGameSession>       GameSessionClass;
+uint32                          bUseSeamlessTravel : 1;
+uint32                          bStartPlayersAsSpectators : 1;
+uint32                          bPauseable : 1;
+```
+
+### AGameStateBase Replicated Properties
+
+```cpp
+TSubclassOf<AGameModeBase>   GameModeClass;       // ReplicatedUsing=OnRep_GameModeClass
+TSubclassOf<ASpectatorPawn>  SpectatorClass;      // ReplicatedUsing=OnRep_SpectatorClass
+TArray<APlayerState*>        PlayerArray;         // Always relevant
+bool                         bReplicatedHasBegunPlay; // ReplicatedUsing=OnRep_ReplicatedHasBegunPlay
+double                       ReplicatedWorldTimeSecondsDouble; // server clock sync
+```
+
+### APlayerController Notable Members
+
+```cpp
+TObjectPtr<APawn>                 AcknowledgedPawn;        // server-confirmed possession
+TObjectPtr<APlayerCameraManager>  PlayerCameraManager;
+TObjectPtr<AHUD>                  MyHUD;
+TObjectPtr<UPlayerInput>          PlayerInput;             // only valid locally
+uint32                            bShowMouseCursor : 1;
+uint32                            bEnableClickEvents : 1;
+uint32                            bEnableStreamingSource : 1;
+uint16                            SeamlessTravelCount;
+```
+
+### ACharacter Notable Members
+
+```cpp
+// Components (access via getters)
+USkeletalMeshComponent*        GetMesh()
+UCharacterMovementComponent*   GetCharacterMovement()
+UCapsuleComponent*             GetCapsuleComponent()
+
+// Replicated state
+uint8   bIsCrouched : 1;       // ReplicatedUsing=OnRep_IsCrouched
+uint8   bProxyIsJumpForceApplied : 1;
+float   JumpMaxHoldTime;       // Replicated — variable jump height
+int32   JumpMaxCount;          // Replicated — multi-jump count
+int32   JumpCurrentCount;      // current jump count this airtime
+uint8   ReplicatedMovementMode; // Replicated — movement mode for simulated proxies
+```
+
+---
+
+## NetMode Cheat Sheet
+
+```cpp
+GetNetMode() == NM_Standalone      // single player, no network
+GetNetMode() == NM_DedicatedServer // server process, no local player
+GetNetMode() == NM_ListenServer    // server + local player (host)
+GetNetMode() == NM_Client          // remote client
+
+HasAuthority()  // true on server (NM_Standalone, NM_DedicatedServer, NM_ListenServer)
+IsLocalController()  // true if this PlayerController belongs to the local machine's player
+IsLocallyControlled()  // true on Pawn if its controller is a local player
+```
+
+---
+
+## Class Selection Decision Tree
+
+```
+Need to store game-wide rules or control who can join?
+  --> AGameMode (server-only, authoritative)
+
+Need global data visible to ALL clients (scores, match timer)?
+  --> AGameState (replicated everywhere)
+
+Need per-player data visible to ALL clients (kills, team, name)?
+  --> APlayerState (always relevant, replicated everywhere)
+
+Need to handle input, camera, or UI for ONE player?
+  --> APlayerController (exists on server + owning client only)
+
+Need a player body that walks/jumps/crouches with built-in prediction?
+  --> ACharacter (with UCharacterMovementComponent)
+
+Need a custom vehicle, drone, or non-humanoid body?
+  --> APawn (with a custom UPawnMovementComponent or manual physics)
+
+Need data that survives level transitions?
+  --> UGameInstance (singleton per process, never destroyed)
+```

package/skills/ue-input-system/SKILL.md

@@ -0,0 +1,394 @@
+---
+name: ue-input-system
+description: "Enhanced Input system — Input Actions, Input Mapping Contexts, modifiers, triggers"
+category: "gamedev"
+argument-hint: "[action o input scheme]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit
+---
+
+# UE Enhanced Input System
+
+You are an expert in Unreal Engine's Enhanced Input system.
+
+Ask before writing: this skill edits Input Action and Mapping Context assets plus binding code. Propose the change and get approval before using Write or Edit.
+
+## Context Check
+
+Read `docs/unreal/project-context.md` before proceeding. Confirm:
+
+- `EnhancedInput` plugin is listed as enabled
+- Target platforms (affects which modifiers are needed per platform)
+- Whether CommonUI is in use (it manages input mode switching automatically)
+- Whether the project still uses legacy input (migration may be needed)
+
+## Information Gathering
+
+Ask the developer: what actions are needed and their value types (Bool/Axis1D/Axis2D/Axis3D), which platforms, any complex input requirements (hold-to-charge, double-tap, combos, chord shortcuts), and whether multiple input modes are required (gameplay vs UI vs vehicle).
+
+---
+
+## Enhanced Input Setup
+
+### Plugin and Module
+
+`.uproject`: add `{ "Name": "EnhancedInput", "Enabled": true }` to Plugins.
+
+`Build.cs`: add `"EnhancedInput"` to `PublicDependencyModuleNames`.
+
+`DefaultInput.ini`:
+```ini
+[/Script/Engine.InputSettings]
+DefaultPlayerInputClass=/Script/EnhancedInput.EnhancedPlayerInput
+DefaultInputComponentClass=/Script/EnhancedInput.EnhancedInputComponent
+```
+
+### UInputAction Asset
+
+`UInputAction : UDataAsset`. Create one per logical player action. Key properties (from `InputAction.h`):
+
+```cpp
+EInputActionValueType ValueType = EInputActionValueType::Boolean;
+// Boolean | Axis1D (float) | Axis2D (FVector2D) | Axis3D (FVector)
+
+EInputActionAccumulationBehavior AccumulationBehavior
+    = EInputActionAccumulationBehavior::TakeHighestAbsoluteValue;
+// TakeHighestAbsoluteValue — highest magnitude wins across all mappings to this action
+// Cumulative — all mapping values sum (W + S cancel each other for WASD)
+
+bool bConsumeInput = true;  // blocks lower-priority Enhanced Input mappings to same keys
+
+TArray<TObjectPtr<UInputTrigger>> Triggers;   // applied AFTER per-mapping triggers
+TArray<TObjectPtr<UInputModifier>> Modifiers; // applied AFTER per-mapping modifiers
+```
+
+### UInputMappingContext Asset
+
+`UInputMappingContext : UDataAsset`. Maps physical keys to actions.
+
+- `DefaultKeyMappings.Mappings` — `TArray<FEnhancedActionKeyMapping>` of key-to-action entries
+- `MappingProfileOverrides` — per-profile key overrides for player remapping support
+- `RegistrationTrackingMode`: `Untracked` (default, first Remove wins) or `CountRegistrations` (IMC stays until Remove called N times, safe when multiple systems share it)
+
+---
+
+## Binding Actions in C++
+
+### SetupPlayerInputComponent
+
+```cpp
+// MyCharacter.h — declare assets and handlers
+UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
+TObjectPtr<UInputMappingContext> DefaultMappingContext;
+UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
+TObjectPtr<UInputAction> MoveAction;
+UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
+TObjectPtr<UInputAction> JumpAction;
+
+void Move(const FInputActionValue& Value);
+void StartJump();
+void StopJump();
+```
+
+```cpp
+// MyCharacter.cpp
+#include "EnhancedInputComponent.h"
+#include "EnhancedInputSubsystems.h"
+
+void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
+{
+    Super::SetupPlayerInputComponent(PlayerInputComponent);
+    UEnhancedInputComponent* EIC = Cast<UEnhancedInputComponent>(PlayerInputComponent);
+    if (!EIC) { return; }
+
+    EIC->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AMyCharacter::Move);
+    EIC->BindAction(JumpAction, ETriggerEvent::Started,   this, &AMyCharacter::StartJump);
+    EIC->BindAction(JumpAction, ETriggerEvent::Completed, this, &AMyCharacter::StopJump);
+}
+
+void AMyCharacter::BeginPlay()
+{
+    Super::BeginPlay();
+    if (APlayerController* PC = Cast<APlayerController>(GetController()))
+    {
+        if (auto* Sub = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(
+                PC->GetLocalPlayer()))
+        {
+            Sub->AddMappingContext(DefaultMappingContext, 0); // priority 0 = lowest
+        }
+    }
+}
+```
+
+### Callback Signatures
+
+`BindAction` accepts four delegate signatures:
+
+```cpp
+// No params — press/release without value needed
+void AMyCharacter::StartJump() { Jump(); }
+
+// FInputActionValue — for axis values
+void AMyCharacter::Move(const FInputActionValue& Value)
+{
+    const FVector2D Input = Value.Get<FVector2D>();
+    AddMovementInput(GetActorForwardVector(), Input.Y);
+    AddMovementInput(GetActorRightVector(),   Input.X);
+}
+
+// FInputActionInstance — when elapsed/triggered time is needed
+void AMyCharacter::OnChargeAttack(const FInputActionInstance& Instance)
+{
+    const float HeldFor = Instance.GetElapsedTime();    // Started + Ongoing + Triggered
+    const float ActiveFor = Instance.GetTriggeredTime(); // Triggered only
+}
+
+// Lambda variant
+EIC->BindActionValueLambda(InteractAction, ETriggerEvent::Triggered,
+    [this](const FInputActionValue& Value) { TryInteract(); });
+```
+
+Storing and removing a binding:
+```cpp
+FEnhancedInputActionEventBinding& B =
+    EIC->BindAction(DebugAction, ETriggerEvent::Started, this, &AMyCharacter::DebugToggle);
+uint32 Handle = B.GetHandle();
+// ...
+EIC->RemoveBindingByHandle(Handle);        // remove one binding
+EIC->ClearBindingsForObject(this);         // remove all bindings for an object
+```
+
+---
+
+## Trigger Events (ETriggerEvent)
+
+Bitmask enum from `InputTriggers.h`:
+
+| Event | State Transition | Use for |
+|---|---|---|
+| `Started` | None -> Ongoing/Triggered | First frame of input; press-once actions |
+| `Triggered` | *->Triggered, Triggered->Triggered | Every active frame; continuous movement |
+| `Ongoing` | Ongoing->Ongoing | Held but not yet triggered (charge build-up) |
+| `Canceled` | Ongoing->None | Released before trigger threshold |
+| `Completed` | Triggered->None | Input released after triggering; stop continuous actions |
+
+Note: `Completed` does not fire if any trigger on the same action reports `Ongoing` that frame.
+
+---
+
+## Built-in Triggers
+
+Full parameter listings in `references/input-action-reference.md`.
+
+| Class | Name | Behavior |
+|---|---|---|
+| `UInputTriggerDown` | Down | Every frame input exceeds threshold (implicit default) |
+| `UInputTriggerPressed` | Pressed | Once on first actuation; holding does not repeat |
+| `UInputTriggerReleased` | Released | Once when input drops below threshold after actuation |
+| `UInputTriggerHold` | Hold | After `HoldTimeThreshold` s; `bIsOneShot=false` repeats every frame |
+| `UInputTriggerHoldAndRelease` | Hold And Release | On release after holding `HoldTimeThreshold` s |
+| `UInputTriggerTap` | Tap | Released within `TapReleaseTimeThreshold` s |
+| `UInputTriggerRepeatedTap` | Repeated Tap | N taps within `RepeatDelay` (`NumberOfTapsWhichTriggerRepeat=2` for double-tap) |
+| `UInputTriggerPulse` | Pulse | Repeatedly at `Interval` s while held; optional `TriggerLimit` |
+| `UInputTriggerChordAction` | Chorded Action | Only fires while `ChordAction` is active (Implicit type; auto-blocks solo key) |
+| `UInputTriggerCombo` | Combo (Beta) | All `ComboActions` completed in order within `TimeToPressKey` windows |
+
+Trigger type rules for multi-trigger evaluation: `Explicit` (default, at least one must fire), `Implicit` (all must fire), `Blocker` (blocks everything if active).
+
+---
+
+## Built-in Modifiers
+
+Applied in array order. Mapping-level modifiers run before action-level modifiers.
+
+| Class | Name | Effect |
+|---|---|---|
+| `UInputModifierDeadZone` | Dead Zone | Zero input below `LowerThreshold`; remap to 1 at `UpperThreshold`. Types: Axial, Radial, UnscaledRadial |
+| `UInputModifierScalar` | Scalar | Multiply per axis by `FVector Scalar` |
+| `UInputModifierScaleByDeltaTime` | Scale By Delta Time | Multiply by frame DeltaTime |
+| `UInputModifierNegate` | Negate | Invert selected axes (`bX`, `bY`, `bZ`) |
+| `UInputModifierSwizzleAxis` | Swizzle Input Axis Values | Reorder axes; `YXZ` (default) swaps X/Y — maps 1D key onto Y of Axis2D action |
+| `UInputModifierSmooth` | Smooth | Rolling average over recent samples |
+| `UInputModifierSmoothDelta` | Smooth Delta | Smoothed normalized delta; configurable interpolation (`Lerp`, `Interp_To`, ease curves) |
+| `UInputModifierResponseCurveExponential` | Response Curve - Exponential | `sign(x)*|x|^CurveExponent` per axis |
+| `UInputModifierResponseCurveUser` | Response Curve - User Defined | Separate `UCurveFloat` per axis |
+| `UInputModifierFOVScaling` | FOV Scaling | Scale by camera FOV for consistent angular speed across zoom levels |
+| `UInputModifierToWorldSpace` | To World Space | 2D axis -> world space (up/down = world X, left/right = world Y) |
+
+**WASD -> Axis2D recipe** (`AccumulationBehavior = Cumulative`):
+- `W`: `SwizzleAxis(YXZ)` → Y=+1
+- `S`: `SwizzleAxis(YXZ)` + `Negate(bY)` → Y=-1
+- `D`: none → X=+1
+- `A`: `Negate(bX)` → X=-1
+
+**Gamepad stick**: `DeadZone(Radial, LowerThreshold=0.2)` per stick mapping.
+
+**Mouse look**: `[Scalar(0.4,0.4,1), Smooth, FOVScaling]` per mapping.
+
+---
+
+## Mapping Context Priority
+
+```cpp
+// Higher integer = higher priority; wins key conflicts
+Subsystem->AddMappingContext(GameplayIMC, 0);
+Subsystem->AddMappingContext(VehicleIMC,  1);
+
+// FModifyContextOptions — prevent ghost inputs on switch
+FModifyContextOptions Opts;
+Opts.bIgnoreAllPressedKeysUntilRelease = true;
+Subsystem->AddMappingContext(UIIMC, 2, Opts);
+
+// Remove on mode exit
+Subsystem->RemoveMappingContext(VehicleIMC);
+```
+
+When `bConsumeInput = true` on a `UInputAction` (the default), a higher-priority context that maps the same physical key will consume it, blocking all lower-priority bindings to that key from firing. This is intentional: use priority layering and `bConsumeInput` together to prevent input conflicts between modes (e.g., a vehicle context consuming Spacebar so the character's Jump action never fires while driving).
+
+### Split-Screen / Multiple Local Players
+
+In split-screen, each local player has their own `UEnhancedInputLocalPlayerSubsystem`. Mapping contexts are per-player — adding a context to one player's subsystem does not affect others. To target a specific player, retrieve their subsystem directly from their `ULocalPlayer`:
+
+```cpp
+// Access subsystem for a specific local player (e.g., player 2)
+if (ULocalPlayer* LP = PlayerController->GetLocalPlayer())
+{
+    if (auto* Sub = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(LP))
+    {
+        Sub->AddMappingContext(PlayerTwoIMC, 0);
+    }
+}
+```
+
+---
+
+## Custom Triggers
+
+Subclass `UInputTrigger`; override `UpdateState_Implementation` returning `ETriggerState::None / Ongoing / Triggered`:
+
+```cpp
+UCLASS(EditInlineNew, meta=(DisplayName="Double Click"))
+class MYGAME_API UDoubleClickTrigger : public UInputTrigger
+{
+    GENERATED_BODY()
+public:
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Trigger Settings")
+    float DoubleClickThreshold = 0.3f;
+protected:
+    virtual ETriggerType GetTriggerType_Implementation() const override
+        { return ETriggerType::Explicit; }
+    virtual ETriggerState UpdateState_Implementation(
+        const UEnhancedPlayerInput* PlayerInput, FInputActionValue ModifiedValue, float DeltaTime) override;
+private:
+    float LastPressTime = 0.f;
+    bool bWasActuated = false;
+};
+
+ETriggerState UDoubleClickTrigger::UpdateState_Implementation(
+    const UEnhancedPlayerInput* PlayerInput, FInputActionValue ModifiedValue, float DeltaTime)
+{
+    const bool bActuated = IsActuated(ModifiedValue); // helper: magnitude >= ActuationThreshold
+    const float Now = PlayerInput->GetWorld()->GetTimeSeconds();
+    if (bActuated && !bWasActuated)
+    {
+        if ((Now - LastPressTime) <= DoubleClickThreshold)
+            { LastPressTime = 0.f; bWasActuated = bActuated; return ETriggerState::Triggered; }
+        LastPressTime = Now;
+    }
+    bWasActuated = bActuated;
+    return ETriggerState::None;
+}
+```
+
+`UInputTriggerTimedBase` provides `HeldDuration` and `CalculateHeldDuration` for time-based triggers.
+
+---
+
+## Custom Modifiers
+
+Subclass `UInputModifier`; override `ModifyRaw_Implementation`:
+
+```cpp
+UCLASS(EditInlineNew, meta=(DisplayName="Clamp Magnitude"))
+class MYGAME_API UClampMagnitudeModifier : public UInputModifier
+{
+    GENERATED_BODY()
+public:
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Settings)
+    float MaxMagnitude = 1.0f;
+protected:
+    virtual FInputActionValue ModifyRaw_Implementation(
+        const UEnhancedPlayerInput* PlayerInput, FInputActionValue CurrentValue, float DeltaTime) override
+    {
+        FVector V = CurrentValue.Get<FVector>();
+        if (V.SizeSquared() > MaxMagnitude * MaxMagnitude)
+            V = V.GetSafeNormal() * MaxMagnitude;
+        return FInputActionValue(CurrentValue.GetValueType(), V);
+    }
+};
+```
+
+---
+
+## Common Mistakes
+
+- **Mapping context not added**: Add via subsystem in `BeginPlay`/after `Possess`, not in `SetupPlayerInputComponent` (called earlier on some paths).
+- **Legacy binding on UEnhancedInputComponent**: `BindAction(FName,...)` and `BindAxis` are `= delete`. Compile error. Set `DefaultInputComponentClass` in `DefaultInput.ini`.
+- **Triggered for a button press**: `Triggered` fires every active frame. Use `Started` for press-once, `Completed` for release.
+- **Completed not firing with Ongoing**: If any trigger reports `Ongoing` that frame, `Completed` is suppressed. Use separate actions for clean press/release events.
+- **No dead zone on gamepad sticks**: Sticks produce non-zero resting values. Always add `DeadZone(Radial)` per stick mapping.
+- **Missing SwizzleAxis for WASD-to-2D**: Keyboard produces 1D. Without `SwizzleAxis(YXZ)` on W/S, forward/backward stays on X and is ignored by Axis2D forward movement.
+- **Replicating input actions**: Input is client-local. Replicate results (movement, ability activation), not trigger events.
+- **MapKey/UnmapKey at runtime for rebinding**: These are editor/config-screen helpers. Use subsystem player mappable key APIs or swap contexts instead.
+- **Wrong trigger type for intent**: Using `Down` when `Hold` is needed, or `Triggered` when `Started` is needed. Match trigger type to the interaction pattern: `Started` for single press, `Triggered` for continuous, `Hold` for delayed activation.
+
+---
+
+## Legacy Input Migration
+
+To migrate from the legacy input system to Enhanced Input: search for `InputComponent->BindAction` and `InputComponent->BindAxis` calls and replace each with `UEnhancedInputComponent::BindAction`. Create a `UInputAction` data asset for every old action name, choosing the appropriate `ValueType` (Boolean for buttons, Axis1D for single-axis, Axis2D for stick/WASD). Create a `UInputMappingContext` asset and add key mappings corresponding to the old `DefaultInput.ini` `ActionMappings`/`AxisMappings` entries. Set `DefaultInputComponentClass` in `DefaultInput.ini` and enable the EnhancedInput plugin.
+
+## UI Input Mode
+
+Without CommonUI, manage input modes manually via `APlayerController::SetInputMode()`:
+```cpp
+PC->SetInputMode(FInputModeUIOnly());          // cursor captured by UI, no game input
+PC->SetInputMode(FInputModeGameAndUI());       // both UI and game receive input
+PC->SetInputMode(FInputModeGameOnly());        // full game input, UI events suppressed
+```
+CommonUI automates input routing through `UCommonActivatableWidget` stacks and eliminates most manual `SetInputMode` calls — see `/ue-ui-umg-slate`.
+
+---
+
+## Related Skills
+
+- `/ue-gameplay-framework` — PlayerController input lifecycle, `Possess`/`UnPossess`, `SetupPlayerInputComponent`
+- `/ue-ui-umg-slate` — `SetInputMode(FInputModeUIOnly())`/`FInputModeGameAndUI()`, cursor visibility, CommonUI `UCommonActivatableWidget` stacks
+- `/ue-gameplay-abilities` — binding Enhanced Input actions to GAS ability activation via input ID tags
+- `/ue-naming-conventions` — asset prefixes and Content folder layout for these assets
+
+## Reference Files
+
+- `references/input-action-reference.md` — full trigger and modifier catalogue with parameters
+- `references/enhanced-input-workflow.md` — editor-side authoring flow for actions and mapping contexts
+- `references/cpp-setup.md` — C++ setup: subsystem access, context priorities, binding callbacks
+
+---
+
+## Checklist
+
+Validate before considering the work done:
+
+- [ ] Mapping contexts are added and removed with explicit priorities per game state
+- [ ] Input Action value types match how the action is consumed
+- [ ] No legacy `BindAction`/`BindAxis` or direct key polling remains
+- [ ] Conventions in `docs/unreal/project-context.md` were read and followed
+- [ ] The Common Mistakes section of this skill was reviewed against the change
+
+**PASS** — every item holds. **CONCERNS** — the work stands but at least one item is unresolved and worth flagging to the user. **FAIL** — an item is violated in a way that breaks correctness, replication or the frame budget; fix it before handing the work over.
+
+## Next Steps
+
+- `/ue-ui-umg-slate` — verify input mode switching between game and UI
+- `/code-review` — architectural and quality review of the change
+- `/commit` — conventional commit once the change is verified