1
// 玩家按下键盘 "A" 键 → 角色向左移动的完整路径：
2

3
// ① 硬件输入 → 操作系统 → UE 消息循环
4
//       ↓
5
// ② InputMappingContext 查询：FKey("A") 绑定了哪个 InputAction？
6
//       ↓  发现绑定到 IA_Move（InputAction 资产）
7
// ③ Modifier 链：对原始值 (1.0, 0.0) 进行变换
8
//       ↓  SwizzleInputAxis 修饰器 → 将 X 轴映射为 Y 轴
9
// ④ Trigger 链：判断是否满足触发条件
10
//       ↓  Down Trigger → 按下即触发
11
// ⑤ UEnhancedInputComponent 将处理后的值分发给回调
12
//       ↓  C++ Bound Function: MovementInput(FVector2D(1.0, 0.0))
13
// ⑥ PlayerController → Pawn → UCharacterMovementComponent
14
//       ↓  实际移动角色
15

16
// 核心优势：这个流程中，InputAction 只有一个（IA_Move），
17
// 但键盘 / 手柄 / 触屏都可以通过各自的 MappingContext 映射到它——
18
// C++ 回调只需绑定一次，完全不关心"按了什么设备"。

1
// ===== 面试深水区：增强输入系统每帧是怎么运转的？ =====
2

3
// 在 APlayerController 诞生时，引擎会创建 UPlayerInput 的子类——
4
// UEnhancedPlayerInput（它继承并重写了原生 UPlayerInput）。
5
// 每帧游戏线程执行 APlayerController::PlayerTick 时，底层调用链为：
6

7
// PlayerTick() → PlayerInput->TickInput(DeltaTime) → 增强输入接管流程：
8
//   ① 捕获硬件 FKey 的物理状态（键盘扫描码、手柄摇杆值、触屏坐标）
9
//   ② 按优先级降序遍历当前激活的 InputMappingContext 链表
10
//   ③ 匹配到 InputAction 后，对其原始值依次应用 UInputModifier 管道变换
11
//      （死区 → 平滑 → 缩放 → 坐标变换 → 曲线映射……）
12
//   ④ 将变换后的值送入 UInputTrigger 状态机，判定 ETriggerState
13
//   ⑤ 根据状态转移结果，通过 UEnhancedInputComponent 内部注册的委托
14
//      将 FInputActionValue 分发到 C++ / 蓝图的回调函数
15

16
// 关键点总结：
17
// - UEnhancedPlayerInput 是 UPlayerInput 的子类，不是替代品——旧版 Axis 仍可用
18
// - 整个管道在 GameThread 上同步执行，没有异步开销
19
// - Tick 开销与当前激活的 IMC 数量和绑定的 Action 数量成正比
20
//   （通常 < 0.1ms，除非挂了几十个 IMC 同时轮询）

1
// InputAction 是一个 UDataAsset，在编辑器中创建。
2
// 它不包含任何按键信息——只定义"这是一个什么动作"和"它产生什么类型的值"。
3

4
// ===== InputAction 的值类型（ValueType）=====
5
// EInputActionValueType 枚举决定了回调函数接收的参数类型：
6

7
// Digital (bool)  — 只有按下/松开两个状态
8
//   例：跳跃、射击、交互
9
//   回调签名：void(const FInputActionValue& Value)
10
//   bool bPressed = Value.Get<bool>();
11

12
// Axis1D (float)  — 单轴数值（0.0 ~ 1.0）
13
//   例：油门、扳机键
14
//   回调签名：void(const FInputActionValue& Value)
15
//   float AxisValue = Value.Get<float>();
16

17
// Axis2D (FVector2D) — 二维轴（±1.0）
18
//   例：WASD 移动、鼠标视角
19
//   回调签名：void(const FInputActionValue& Value)
20
//   FVector2D Vec = Value.Get<FVector2D>();
21

22
// Axis3D (FVector)  — 三维轴
23
//   例：3D 空间中的移动（如 6-DOF 控制器）
24
//   回调签名：void(const FInputActionValue& Value)
25
//   FVector Vec = Value.Get<FVector>();

1
// InputAction 是资产（UInputAction），不能 new——必须在编辑器中创建，
2
// 然后在 C++ 中用指针引用，从蓝图中赋值。
3

4
UCLASS()
5
class AMyPlayerController : public APlayerController
6
{
7
    GENERATED_BODY()
8

9
public:
10
    // ★ 标准模式：用 TObjectPtr 引用资产，在蓝图中选择
11
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
12
    TObjectPtr<UInputAction> MoveAction;     // 移动
13

14
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
15
    TObjectPtr<UInputAction> LookAction;     // 视角
16

17
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
18
    TObjectPtr<UInputAction> JumpAction;     // 跳跃
19

20
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
21
    TObjectPtr<UInputAction> InteractAction; // 交互
22
};
23
// ↑ 蓝图子类中把这些属性指向具体的 InputAction 资产

1
// InputMappingContext（IMC）决定"在什么场景下，哪些按键触发哪些动作"。
2
// 同一时刻可以加载多个 IMC，优先级高的先处理。
3

4
// ===== IMC 的优先级机制 =====
5
// 典型场景：你的游戏需要三套输入——
6
//
7
// IMC_Default (Priority = 0)
8
//   WASD → Move, Mouse → Look, Space → Jump
9
//
10
// IMC_Vehicle (Priority = 1)  ← 更高优先级，覆盖默认
11
//   WASD → DriveVehicle, Space → HandBrake
12
//   （载具中不需要 Look 和 Jump，但 Move 被 Vehicle 覆盖）
13
//
14
// IMC_UI (Priority = 2)  ← 最高优先级，覆盖一切
15
//   MouseClick → UINavigate, Escape → CloseMenu
16
//   （打开菜单时所有游戏输入被拦截）
17

18
// 原理：引擎从高优先级 IMC 开始匹配按键。如果高优先级的 IMC
19
// 处理了这个按键，默认情况下低优先级的 IMC 就不会再收到。

1
#include "EnhancedInputSubsystems.h"
2
#include "EnhancedInputComponent.h"
3

4
void AMyPlayerController::BeginPlay()
5
{
6
    Super::BeginPlay();
7

8
    if (ULocalPlayer* LocalPlayer = GetLocalPlayer())
9
    {
10
        // 获取 Enhanced Input 子系统
11
        if (UEnhancedInputLocalPlayerSubsystem* InputSubsystem =
12
            LocalPlayer->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
13
        {
14
            // 加载默认 IMC
15
            InputSubsystem->AddMappingContext(DefaultMappingContext, 0);
16
            //                                         ↑ Priority = 0
17

18
            // 场景切换时：
19
            // InputSubsystem->RemoveMappingContext(DefaultMappingContext);
20
            // InputSubsystem->AddMappingContext(VehicleMappingContext, 1);
21
        }
22
    }
23
}
24

25
// ===== 动态切换 IMC 的完整模式 =====
26
void AMyPlayerController::EnterVehicleMode()
27
{
28
    if (auto* InputSub = GetLocalPlayer()->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
29
    {
30
        // 移除默认 IMC，加载载具 IMC
31
        InputSub->RemoveMappingContext(DefaultMappingContext);
32
        InputSub->AddMappingContext(VehicleMappingContext, 1);
33

34
        // 也可以同时加载多个——引擎按优先级链式处理
35
    }
36
}

1
// Modifier 在 Trigger 之前执行——先变换原始输入值，再判断是否触发。
2
// 多个 Modifier 组成一条管道：原始值 → Modifier1 → Modifier2 → ... → 输出值
3

4
// ===== 工程中必知的 Modifier =====
5

6
// UInputModifierDeadZone —— 死区（摇杆漂移克星）
7
// 参数：LowerThreshold(0.0~1.0), UpperThreshold(0.0~1.0), Type
8
// 摇杆在中心位置会有微小抖动（0.001~0.01），死区将这些值归零
9
// EDeadZoneType::Axial  —— 每个轴独立应用（适合 WASD）
10
// EDeadZoneType::Radial —— 到圆心的距离（适合摇杆）
11

12
// UInputModifierSmooth —— 平滑过渡
13
// 参数：SmoothingTime（秒）
14
// 避免 0 → 1 的突变——输入值会在指定时间内平滑渐变
15

16
// UInputModifierSwizzleInputAxis —— 坐标轴交换
17
// 参数：Order（如 YXZ、ZYX 等）
18
// 例：鼠标横移默认是 X 轴，但你可能想让它控制 Y 轴
19

20
// UInputModifierNegate —— 取反
21
// 参数：bX, bY, bZ （每个轴是否取反）
22
// 例：飞机游戏中"拉杆抬头"需要反转 Y 轴
23

24
// UInputModifierScalar —— 缩放
25
// 参数：Scalar（0.0~N）
26
// 例：Shift 加速 → 在 Modifier 链中加 Scalar(2.0)
27

28
// UInputModifierResponseCurveExponential / User —— 曲线映射
29
// 将线性输入映射为曲线（如 FPS 瞄准时摇杆需要指数响应）

1
// 场景：手柄摇杆控制角色移动——需要哪些 Modifier？
2

3
// 摇杆原始输入值：
4
// X: -0.0013  Y: 0.0021  （静止时抖动）
5
// X: -0.8500  Y: 0.3200  （推摇杆向左上）
6

7
// Modifier 管道配置：
8
// 1. DeadZone(Radial, Lower=0.15) → 消除抖动，X: 0.0  Y: 0.0
9
// 2. Scalar(600.0)                 → 映射到角色速度量级
10
// 3. Smooth(0.05s)                 → 消除突变，平滑过渡
11

12
// 管道后的输出：
13
// 静止时：(0.0, 0.0)     → 角色不动
14
// 推杆时：(510.0, 192.0) → 角色平滑加速到目标方向
15

16
// ★ 关键理念：Modifier 配置在 InputAction 资产的编辑器面板中！
17
// C++ 代码不需要关心这些——它只接收经过管道变换后的最终值。

1
// Trigger 决定了 Modifier 管道输出后，"这个值应不应该视为一次动作触发"。
2

3
// ===== Engineer 必学的 Trigger =====
4

5
// UInputTriggerDown —— 按下触发（最常用）
6
// 输入值从 0 变为非 0 时触发一次
7
// 参数：ActuationThreshold（触发阈值，默认 0.5）
8
// 场景：跳跃、射击、技能
9

10
// UInputTriggerPressed —— 按下持续触发
11
// 按下期间每帧都触发（未经 ActuationThreshold 的原始按压状态）
12
// 场景：按住 Shift 加速、按住鼠标拖拽
13

14
// UInputTriggerReleased —— 松开触发
15
// 输入值从非 0 变为 0 时触发一次
16
// 场景：蓄力释放、松开拉弓
17

18
// UInputTriggerHold —— 按住 N 秒后触发
19
// 参数：HoldTimeThreshold
20
// 场景：长按换弹、长按交互
21

22
// UInputTriggerTap —— 快速点击
23
// 参数：TapReleaseTimeThreshold
24
// 场景：双击闪避、快速连击
25

26
// UInputTriggerChordedAction —— 和弦触发（组合键）
27
// 必须同时按下另一个 InputAction 才触发
28
// 参数：ChordAction（另一个 InputAction 资产）
29
// 场景：Ctrl+C、Shift+Click
30

31
// UInputTriggerCombo —— 连招序列
32
// 需要按顺序在一段时间内触发一组动作
33
// 参数：ComboActions（InputAction 数组）
34
// 场景：格斗游戏招式输入（↓↘→ + 攻击）
35

36
// UInputTriggerPulse —— 脉冲触发
37
// 按住期间以固定间隔持续触发
38
// 参数：TriggerInterval（脉冲间隔秒数）
39
// 场景：按住连续射击（如 AK47 的自动连发）

1
// 一个 InputAction 可以挂载多个 Trigger——
2
// 它们之间是 OR 关系（任何一个满足就触发）
3

4
// 例：IA_Attack 同时配置了：
5
//   1. Down Trigger   → 单击攻击
6
//   2. Hold Trigger (0.5s) → 长按蓄力攻击
7
//
8
// ★ Enhanced Input 提供两种回调签名选择：
9
//    ① void(const FInputActionValue& Value)  → 只拿输入值，每个 Trigger 事件各自绑定
10
//    ② void(const FInputActionInstance& Instance) → 可透过 Instance.GetTriggerEvent()
11
//       在一个回调里拿到 Started/Triggered/Completed 等全部 ETriggerEvent + 激活时长等上下文
12

13
// ✓ 方案 A：每个 Trigger 事件单独绑定（推荐——逻辑清晰、易调试）
14
void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override
15
{
16
    // ...
17
    // 单击 → 普通攻击
18
    EnhancedInput->BindAction(AttackAction, ETriggerEvent::Triggered,  this, &AMyCharacter::OnNormalAttack);
19
    // 长按开始 → 开始蓄力
20
    EnhancedInput->BindAction(AttackAction, ETriggerEvent::Started,    this, &AMyCharacter::OnChargeStart);
21
    // 长按释放 → 发射蓄力攻击
22
    EnhancedInput->BindAction(AttackAction, ETriggerEvent::Completed,  this, &AMyCharacter::OnChargeFire);
23
    // ⚠️ 必须绑定 Canceled——防御蓄力被中断
24
    EnhancedInput->BindAction(AttackAction, ETriggerEvent::Canceled,   this, &AMyCharacter::OnChargeCanceled);
25
}
26

27
void OnNormalAttack(const FInputActionValue& Value)  { /* 单击 */ }
28
void OnChargeStart(const FInputActionValue& Value)   { bIsCharging = true; }
29
void OnChargeFire(const FInputActionValue& Value)    { FireChargedAttack(); bIsCharging = false; }
30
void OnChargeCanceled(const FInputActionValue& Value) { bIsCharging = false; }
31

32
// ✓ 方案 B：单回调 + FInputActionInstance（适合需要上下文信息的场景）
33
void SetupSingleCallback()
34
{
35
    // 不再需要写 4 个绑定——一个 FInputActionInstance 回调搞定所有 Trigger
36
    EnhancedInput->BindAction(AttackAction, ETriggerEvent::Triggered, this,
37
        [](const FInputActionInstance& Instance)
38
        {
39
            ETriggerEvent Event = Instance.GetTriggerEvent();
40
            float HeldDuration = Instance.GetElapsedTime();
41

42
            if (Event == ETriggerEvent::Started)
43
            {
44
                // 开始蓄力
45
            }
46
            else if (Event == ETriggerEvent::Completed)
47
            {
48
                // 发射蓄力攻击（伤害由 HeldDuration 决定）
49
            }
50
        });
51
}

1
// ===== 面试深水区：Trigger 在底层到底怎么判断"该触发了"？ =====
2

3
// 每一个 UInputTrigger 资产在底层都是一个微型时间片状态机。
4
// 引擎每帧调用其 UpdateState()，返回 ETriggerState：
5

6
// ETriggerState 枚举：
7
//   None       — 没有输入，状态机空闲
8
//   Ongoing    — 输入持续中，但尚未满足 Trigger 条件
9
//   Triggered  — 满足 Trigger 条件！C++ 侧收到 ETriggerEvent::Triggered
10

11
// ===== 以 Hold Trigger（长按）为例的完整状态转移 =====
12
// 帧 0：玩家按下 Space → UpdateState() → Ongoing
13
//         （未达到 HoldTimeThreshold，C++ 收到 Started + Ongoing）
14
// 帧 1~N：持续按下 → 每帧 Ongoing
15
// 帧 K：按下时间 ≥ HoldTimeThreshold → UpdateState() → Triggered
16
//         （C++ 收到 Triggered！）
17
// 帧 K+1：玩家松开 → UpdateState() → None
18
//         （C++ 收到 Completed）
19

20
// ===== 以 Tap Trigger（快速点击）为例 =====
21
// 帧 0：按下 → Ongoing
22
// 帧 1：松开 → 检查按下时长 ≤ TapReleaseTimeThreshold → Triggered
23
// 帧 2：如果在 TapReleaseTimeThreshold 内再次按下 → Triggered（双击）
24

25
// 关键认知：
26
// - Ongoing 是 Triggered 的"前置等待区"
27
// - C++ 的 ETriggerEvent::Triggered 对应状态机的 ETriggerState::Triggered
28
// - C++ 的 Started/Ongoing/Completed/Canceled 是"输入生命周期事件"，
29
//   独立于 Trigger 条件——即使没有任何 Trigger 配置，Started/Completed 仍会触发

1
#include "EnhancedInputComponent.h"
2
#include "EnhancedInputSubsystems.h"
3
#include "InputActionValue.h"
4

5
// ===== 第一步：PlayerController 负责加载 IMC =====
6
UCLASS()
7
class AMyPlayerController : public APlayerController
8
{
9
    GENERATED_BODY()
10

11
public:
12
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
13
    TObjectPtr<UInputMappingContext> DefaultMappingContext;
14

15
protected:
16
    virtual void BeginPlay() override
17
    {
18
        Super::BeginPlay();
19

20
        if (IsLocalPlayerController())
21
        {
22
            if (ULocalPlayer* LocalPlayer = GetLocalPlayer())
23
            {
24
                if (UEnhancedInputLocalPlayerSubsystem* InputSub =
25
                    LocalPlayer->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
26
                {
27
                    InputSub->AddMappingContext(DefaultMappingContext, 0);
28
                }
29
            }
30
        }
31
    }
32
};
33

34
// ===== 第二步：Character 负责绑定 InputAction → 回调 =====
35
UCLASS()
36
class AMyCharacter : public ACharacter
37
{
38
    GENERATED_BODY()
39

40
public:
41
    // InputAction 资产引用
42
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
43
    TObjectPtr<UInputAction> MoveAction;
44

45
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
46
    TObjectPtr<UInputAction> LookAction;
47

48
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input")
49
    TObjectPtr<UInputAction> JumpAction;
50

51
protected:
52
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override
53
    {
54
        Super::SetupPlayerInputComponent(PlayerInputComponent);
55

56
        if (UEnhancedInputComponent* EnhancedInput =
57
            Cast<UEnhancedInputComponent>(PlayerInputComponent))
58
        {
59
            // 持续型输入
60
            EnhancedInput->BindAction(MoveAction, ETriggerEvent::Triggered,
61
                this, &AMyCharacter::Move);
62
            EnhancedInput->BindAction(LookAction, ETriggerEvent::Triggered,
63
                this, &AMyCharacter::Look);
64

65
            // 状态型输入（Started + Completed + Canceled 闭环）
66
            EnhancedInput->BindAction(JumpAction, ETriggerEvent::Started,
67
                this, &AMyCharacter::JumpStarted);
68
            EnhancedInput->BindAction(JumpAction, ETriggerEvent::Completed,
69
                this, &AMyCharacter::JumpEnded);
70
            // ⚠️ 必须同时绑定 Canceled！否则玩家按住跳跃键时打开菜单/切换关卡
71
            //    输入生命周期被 Cancel，角色永远卡在"按住跳跃"的状态
72
            EnhancedInput->BindAction(JumpAction, ETriggerEvent::Canceled,
73
                this, &AMyCharacter::JumpEnded);
74
        }
75
    }
76

77
    void Move(const FInputActionValue& Value)
78
    {
79
        const FVector2D MovementVector = Value.Get<FVector2D>();
80

81
        const FRotator YawRotation(0.0f, GetController()->GetControlRotation().Yaw, 0.0f);
82
        const FVector Forward = FRotationMatrix(YawRotation).GetScaledAxis(EAxis::X);
83
        const FVector Right   = FRotationMatrix(YawRotation).GetScaledAxis(EAxis::Y);
84

85
        AddMovementInput(Forward, MovementVector.Y);
86
        AddMovementInput(Right,   MovementVector.X);
87
    }
88

89
    void Look(const FInputActionValue& Value)
90
    {
91
        const FVector2D LookAxis = Value.Get<FVector2D>();
92
        AddControllerYawInput(LookAxis.X);
93
        AddControllerPitchInput(LookAxis.Y);
94
    }
95

96
    void JumpStarted(const FInputActionValue&)  { Jump(); }
97
    void JumpEnded(const FInputActionValue&)    { StopJumping(); }
98
};

1
void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
2
{
3
    Super::SetupPlayerInputComponent(PlayerInputComponent);
4

5
    if (UEnhancedInputComponent* EnhancedInput = Cast<UEnhancedInputComponent>(PlayerInputComponent))
6
    {
7
        // 方式一：绑定到成员函数（推荐——可被蓝图重写）
8
        EnhancedInput->BindAction(MoveAction, ETriggerEvent::Triggered,
9
            this, &AMyCharacter::Move);
10

11
        // 方式二：绑定到 Lambda——必须将 this 作为第三个参数传入
12
        // ✓ 传入 this 的作用：① 为编译器模板推导提供上下文
13
        //                    ② 保障 GC 生命周期安全（Lambda 内部走 UObject 弱引用追踪）
14
        EnhancedInput->BindAction(InteractAction, ETriggerEvent::Triggered,
15
            this, [](const FInputActionValue& Value)
16
            {
17
                bool bPressed = Value.Get<bool>();
18
                // Lambda 业务逻辑
19
            });
20

21
        // ⚠️ 不传 this 的裸 Lambda 会导致编译器模板推导模糊（Ambiguous template instantiation）
22
        //    同时失去了 GC 生命周期安全保护
23
    }
24
}

1
// ===== 面试深水区：怎么在测试/回放中注入输入，复用玩家的 InputAction 代码？ =====
2

3
// ⚠️ 关键前提：UEnhancedInputLocalPlayerSubsystem 是纯客户端子系统——
4
//    只存在于本地玩家的客户端进程，Dedicated Server 和 AIController 上完全不存在！
5
//    因此 AI 绝对不能通过 GetLocalPlayer() 来注入输入。
6

7
// ✓ AI 的正确复用方式：直接调用输入触发的 Gameplay 核心函数
8
//    （如 Attack()、Jump()），这些函数本身就是"输入→行为"的公共接口。
9
//    AI 不需要"模拟按键"——它直接执行按键产生的逻辑结果。
10

11
// ✓ 输入注入的合法使用场景：自动化测试、回放系统、本地教学关卡
12
//    （仅限本地客户端环境，有 LocalPlayer 存在时）
13

14
#include "EnhancedInputSubsystems.h"
15

16
// 仅在 LOCAL CLIENT 环境中使用：
17
void UMyTestHelper::SimulateAttackInput()
18
{
19
    // 前提：调用方必须是本地客户端上的 PlayerController
20
    if (APlayerController* PC = GetWorld()->GetFirstPlayerController())
21
    {
22
        if (ULocalPlayer* LP = PC->GetLocalPlayer())
23
        {
24
            if (UEnhancedInputLocalPlayerSubsystem* InputSub =
25
                LP->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
26
            {
27
                FInputActionValue InjectionValue(true);
28
                InputSub->InjectInputForAction(
29
                    AttackAction, InjectionValue, nullptr, nullptr);
30
            }
31
        }
32
    }
33
}
34

35
// ===== Application Scenarios =====
36
// ① 自动化测试（本地客户端）——不依赖物理输入设备，精确重复测试场景
37
// ② 回放系统（本地客户端）——录制玩家的输入序列，精确重现
38
// ③ 教学关卡（本地客户端）——预置的"虚拟输入"引导玩家操作
39
// ✗ ④ AI Bot（服务器端）——不可用！AI 直接调用 Gameplay 核心函数即可
40

41
// ⚠️ InjectInputForAction 同样必须在 GameThread 上调用
42
//    （它内部会触发完整的 Enhanced Input 管道）

1
// 当一个输入被高优先级的 IMC 处理后，默认会"消费"掉它——
2
// 低优先级的 IMC 不再收到。
3

4
// ⚠️ 关键澄清：输入消费不是"无条件霸占"——它有两层精细控制：
5

6
// 第一层：UInputAction 资产上的 bConsumeInput 属性
7
//   · true（默认）：该 Action 触发后，消费此输入，阻止向后传递
8
//   · false：该 Action 触发后，输入仍然继续向后传递
9
//   → 场景：战斗系统响应了左键射击，同时数据埋点系统也需要监听左键点击
10
//            → 两个 Action 共用同一个按键，埋点系统的 Action 设 bConsumeInput=false
11

12
// 第二层：IMC 内特定按键映射的高级设置
13
//   · 每个键→Action 的映射条目上都有独立的消费开关
14
//   → 场景：同一个 IMC 内，WASD 移动消费输入（阻止同时触发其他），
15
//           但 Tab 键不消费（允许计分板同时打开）
16

17
// 场景：打开背包菜单时，玩家的移动输入不应该同时控制角色
18

19
void AMyPlayerController::OpenInventory()
20
{
21
    // 加载 UI 输入上下文（Priority = 10，高于游戏 IMC 的 0）
22
    if (auto* InputSub = GetLocalPlayer()->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
23
    {
24
        InputSub->AddMappingContext(UIMappingContext, 10);
25
        // ↑ 高优先级：UI 操作（bConsumeInput=true）会消费输入，游戏逻辑不再收到
26
    }
27

28
    bShowMouseCursor = true;
29
    SetInputMode(FInputModeGameAndUI());
30
}
31

32
void AMyPlayerController::CloseInventory()
33
{
34
    if (auto* InputSub = GetLocalPlayer()->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
35
    {
36
        InputSub->RemoveMappingContext(UIMappingContext);
37
    }
38

39
    bShowMouseCursor = false;
40
    SetInputMode(FInputModeGameOnly());
41
}
42

43
// ===== 消费行为的微调 =====
44
// UInputMappingContext 上有一个属性：bIgnoreAllPressedKeysUntilRelease
45
// 设为 true 时，加载该 IMC 的瞬间不会触发任何"当前正按着"的键——
46
// 直到所有键松开再重新按下。
47
// 场景：打开菜单的瞬间，不会因为"正按着 W"而让角色移动

1
// ===== 旧版输入系统 —— 如果你在维护 UE4 迁移项目 =====
2
// 不推荐在新代码中使用，但面试和遗留项目中很常见
3

4
void AOldPlayerController::SetupInputComponent()
5
{
6
    Super::SetupInputComponent();
7

8
    // 旧版 Axis 绑定——通过 FName 字符串匹配
9
    InputComponent->BindAxis("MoveForward", this, &AOldPlayerController::MoveForward);
10
    InputComponent->BindAxis("MoveRight",   this, &AOldPlayerController::MoveRight);
11
    InputComponent->BindAxis("LookUp",      this, &AOldPlayerController::LookUp);
12
    InputComponent->BindAxis("Turn",        this, &AOldPlayerController::Turn);
13

14
    // 旧版 Action 绑定——通过 FName 字符串匹配
15
    InputComponent->BindAction("Jump", IE_Pressed,  this, &AOldPlayerController::Jump);
16
    InputComponent->BindAction("Jump", IE_Released, this, &AOldPlayerController::StopJump);
17
}
18

19
// 旧版的致命缺陷：
20
// 1. Axis/Action 名称是硬编码字符串——拼写错误编译期无法发现
21
// 2. 绑定写在 Project Settings → Input 中，团队协作容易冲突
22
// 3. 手柄/键盘适配需要在代码里写死
23
// 4. 无法做高级 Trigger（长按/双击/和弦）
24
// 5. 输入值无法复用——死区/平滑每个绑定都要重写一遍

1
// Enhanced Input 的手柄适配极其简单——在编辑器中完成，不需要写代码：
2

3
// 步骤 1：创建手柄专用的 IMC（IMC_Gamepad）
4
// 步骤 2：在 IMC_Gamepad 中将手柄按键映射到相同的 InputAction
5
//     LeftThumbstick → IA_Move（Axis2D）
6
//     RightThumbstick → IA_Look（Axis2D）
7
//     Gamepad_FaceButton_Bottom → IA_Jump
8
//
9
// 步骤 3：在 C++ 中检测连接设备，加载对应 IMC
10

11
void AMyPlayerController::OnInputDeviceChanged()
12
{
13
    if (auto* InputSub = GetLocalPlayer()->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
14
    {
15
        if (HasConnectedGamepad())
16
        {
17
            InputSub->RemoveMappingContext(KBM_MappingContext);
18
            InputSub->AddMappingContext(GamepadMappingContext, 0);
19
        }
20
        else
21
        {
22
            InputSub->RemoveMappingContext(GamepadMappingContext);
23
            InputSub->AddMappingContext(KBM_MappingContext, 0);
24
        }
25
    }
26
}
27

28
// ★ 关键：MoveAction / LookAction / JumpAction 本身不需要任何修改！
29
// C++ 中的绑定和回调完全不变——只切换 IMC 即可。
30
// 这就是解耦的真正威力。

1
// Enhanced Input 原生支持触屏——通过特殊的 InputTrigger
2

3
// 触屏常用 Trigger：
4
// UInputTriggerPressed —— 手指放下
5
// UInputTriggerReleased —— 手指抬起
6
// UInputTriggerHold —— 长按
7
// 配合 Touch 类型的 InputAction ValueType（Axis2D 获得触摸坐标）
8

9
// 在 IMC 中绑定：
10
// Touch 1 → IA_TouchMove（Axis2D，跟踪手指滑动）
11
// Touch 1 → IA_TouchTap  （Digital，Tap 触发）
12
//
13
// C++ 回调示例：
14
void OnTouchMove(const FInputActionValue& Value)
15
{
16
    FVector2D TouchDelta = Value.Get<FVector2D>();
17
    // TouchDelta：本帧手指移动的像素偏移
18
    // 可用于旋转视角、拖动物体等
19
}
20

21
void OnTouchTap(const FInputActionValue& Value)
22
{
23
    // 点击——获取点击位置
24
    FVector2D ScreenPosition = Value.Get<FVector2D>();
25
    // 从屏幕坐标做射线检测……
26
}

1
// ===== 场景：构建一个 FPS 角色的完整输入系统 =====
2
// 需求：WASD+鼠标+跳跃+冲刺+射击+瞄准+换弹+交互+蹲伏+菜单拦截+手柄适配
3
// 架构：Controller 管 IMC 加载/切换，Character 管 InputAction 绑定
4

5
// ---------- 第一步：Controller —— 只负责加载和切换 IMC ----------
6
UCLASS()
7
class AFPSPlayerController : public APlayerController
8
{
9
    GENERATED_BODY()
10

11
public:
12
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input|Mappings")
13
    TObjectPtr<UInputMappingContext> DefaultMappingContext;
14

15
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input|Mappings")
16
    TObjectPtr<UInputMappingContext> UIMappingContext;
17

18
protected:
19
    virtual void BeginPlay() override
20
    {
21
        Super::BeginPlay();
22
        if (IsLocalPlayerController())
23
        {
24
            if (auto* InputSub = GetLocalPlayer()->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
25
            {
26
                InputSub->AddMappingContext(DefaultMappingContext, 0);
27
            }
28
        }
29
    }
30

31
public:
32
    // 菜单切换——IMC 管理层
33
    void OpenPauseMenu()
34
    {
35
        if (auto* InputSub = GetLocalPlayer()->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
36
        {
37
            InputSub->RemoveMappingContext(DefaultMappingContext);
38
            InputSub->AddMappingContext(UIMappingContext, 10);
39
        }
40
        bShowMouseCursor = true;
41
        SetInputMode(FInputModeGameAndUI());
42
    }
43

44
    void ClosePauseMenu()
45
    {
46
        if (auto* InputSub = GetLocalPlayer()->GetSubsystem<UEnhancedInputLocalPlayerSubsystem>())
47
        {
48
            InputSub->RemoveMappingContext(UIMappingContext);
49
            InputSub->AddMappingContext(DefaultMappingContext, 0);
50
        }
51
        bShowMouseCursor = false;
52
        SetInputMode(FInputModeGameOnly());
53
    }
54
};
55

56
// ---------- 第二步：Character —— 绑定 InputAction → 回调 ----------
57
UCLASS()
58
class AFPSCharacter : public ACharacter
59
{
60
    GENERATED_BODY()
61

62
public:
63
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input|Actions")
64
    TObjectPtr<UInputAction> MoveAction, LookAction, JumpAction;
65
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input|Actions")
66
    TObjectPtr<UInputAction> SprintAction, ShootAction, AimAction;
67
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Input|Actions")
68
    TObjectPtr<UInputAction> ReloadAction, InteractAction, CrouchAction;
69

70
protected:
71
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override
72
    {
73
        Super::SetupPlayerInputComponent(PlayerInputComponent);
74

75
        UEnhancedInputComponent* Input = Cast<UEnhancedInputComponent>(PlayerInputComponent);
76
        if (!Input) return;
77

78
        // 持续型（Triggered 每帧）
79
        Input->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AFPSCharacter::Move);
80
        Input->BindAction(LookAction, ETriggerEvent::Triggered, this, &AFPSCharacter::Look);
81

82
        // 状态型（Started + Completed + Canceled 闭环）
83
        Input->BindAction(JumpAction,   ETriggerEvent::Started,   this, &AFPSCharacter::JumpStart);
84
        Input->BindAction(JumpAction,   ETriggerEvent::Completed, this, &AFPSCharacter::JumpEnd);
85
        Input->BindAction(JumpAction,   ETriggerEvent::Canceled,  this, &AFPSCharacter::JumpEnd);
86
        Input->BindAction(SprintAction, ETriggerEvent::Started,   this, &AFPSCharacter::SprintStart);
87
        Input->BindAction(SprintAction, ETriggerEvent::Completed, this, &AFPSCharacter::SprintEnd);
88
        Input->BindAction(SprintAction, ETriggerEvent::Canceled,  this, &AFPSCharacter::SprintEnd);
89
        Input->BindAction(AimAction,    ETriggerEvent::Started,   this, &AFPSCharacter::AimStart);
90
        Input->BindAction(AimAction,    ETriggerEvent::Completed, this, &AFPSCharacter::AimEnd);
91
        Input->BindAction(AimAction,    ETriggerEvent::Canceled,  this, &AFPSCharacter::AimEnd);
92

93
        // 瞬时型（Started 即可）
94
        Input->BindAction(ShootAction,   ETriggerEvent::Started, this, &AFPSCharacter::Shoot);
95
        Input->BindAction(ReloadAction,  ETriggerEvent::Started, this, &AFPSCharacter::Reload);
96
        Input->BindAction(InteractAction,ETriggerEvent::Started, this, &AFPSCharacter::Interact);
97

98
        // Toggle 型（Started 切换）
99
        Input->BindAction(CrouchAction,  ETriggerEvent::Started, this, &AFPSCharacter::CrouchToggle);
100
    }
101

102
    // ===== 输入处理 =====
103
    void Move(const FInputActionValue& Value)
104
    {
105
        FVector2D Vec = Value.Get<FVector2D>();
106
        const FRotator Yaw(0.0f, GetController()->GetControlRotation().Yaw, 0.0f);
107
        AddMovementInput(FRotationMatrix(Yaw).GetScaledAxis(EAxis::X), Vec.Y);
108
        AddMovementInput(FRotationMatrix(Yaw).GetScaledAxis(EAxis::Y), Vec.X);
109
    }
110

111
    void Look(const FInputActionValue& Value)
112
    {
113
        FVector2D Vec = Value.Get<FVector2D>();
114
        AddControllerYawInput(Vec.X);
115
        AddControllerPitchInput(Vec.Y);
116
        // ⚠️ Y 轴反转不在 C++ 中硬编码！交由 IMC 中的 UInputModifierNegate 处理——
117
        //    策划/玩家在存档中配置 Y 轴是否反转，C++ 代码永远只做加法
118
    }
119

120
    void JumpStart(const FInputActionValue&)  { Jump(); }
121
    void JumpEnd(const FInputActionValue&)    { StopJumping(); }
122

123
    void SprintStart(const FInputActionValue&) { bIsSprinting = true; ApplySpeedMod(); }
124
    void SprintEnd(const FInputActionValue&)   { bIsSprinting = false; ApplySpeedMod(); }
125

126
    void AimStart(const FInputActionValue&)    { bIsAiming = true; OnAimStateChanged(); }
127
    void AimEnd(const FInputActionValue&)      { bIsAiming = false; OnAimStateChanged(); }
128

129
    void Shoot(const FInputActionValue&)       { /* → WeaponComponent */ }
130
    void Reload(const FInputActionValue&)      { /* → WeaponComponent */ }
131
    void Interact(const FInputActionValue&)    { /* → InteractionSystem */ }
132

133
    void CrouchToggle(const FInputActionValue&) { bIsCrouched ? UnCrouch() : Crouch(); }
134

135
private:
136
    bool bIsSprinting = false;
137
    bool bIsAiming = false;
138

139
    void ApplySpeedMod()
140
    {
141
        if (auto* MC = GetCharacterMovement())
142
            MC->MaxWalkSpeed = bIsSprinting ? 1200.0f : 600.0f;
143
    }
144
    void OnAimStateChanged() { /* FOV / 准星 / 灵敏度 */ }
145
};

1
// ===== Lyra 解法：用 DataAsset + GameplayTag 彻底解耦 =====
2

3
// ---------- 数据结构定义 ----------
4
USTRUCT(BlueprintType)
5
struct FInputActionTagBinding
6
{
7
    GENERATED_BODY()
8

9
    // GameplayTag —— C++ 只认这个 Tag，不认具体的 InputAction
10
    // 例：InputTag.Ability.Shoot, InputTag.Move.Forward
11
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
12
    FGameplayTag InputTag;
13

14
    // InputAction 资产 —— 策划在编辑器中任意更换
15
    // Tag 不变，换 Action 不影响任何 C++ 代码
16
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
17
    TObjectPtr<UInputAction> InputAction;
18
};
19

20
// ---------- InputConfig DataAsset ----------
21
UCLASS(BlueprintType)
22
class UInputConfigData : public UDataAsset
23
{
24
    GENERATED_BODY()
25

26
public:
27
    // 原生输入动作绑定 —— 移动/视角这类必须硬代码处理
28
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
29
    TArray<FInputActionTagBinding> NativeInputActions;
30

31
    // 能力输入动作绑定 —— 技能/攻击等由 GAS 驱动的动作
32
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
33
    TArray<FInputActionTagBinding> AbilityInputActions;
34

35
    // 查找函数
36
    const UInputAction* FindInputAction(const FGameplayTag& Tag) const
37
    {
38
        for (const auto& Binding : NativeInputActions)
39
            if (Binding.InputTag == Tag) return Binding.InputAction;
40
        for (const auto& Binding : AbilityInputActions)
41
            if (Binding.InputTag == Tag) return Binding.InputAction;
42
        return nullptr;
43
    }
44
};
45

46
// ---------- 增强的 InputComponent（扩展 BindAction） ----------
47
UCLASS()
48
class ULyraInputComponent : public UEnhancedInputComponent
49
{
50
    GENERATED_BODY()
51

52
public:
53
    // 用 DataAsset 中的 Tag→Action 映射 + ETriggerEvent 自动绑定
54
    template<class UserClass>
55
    void BindTaggedAction(const UInputConfigData* Config, const FGameplayTag& Tag,
56
                          ETriggerEvent TriggerEvent, UserClass* Object,
57
                          typename FEnhancedInputActionHandlerValueSignature::template
58
                              TMethodPtr<UserClass>::Type Func)
59
    {
60
        if (const UInputAction* Action = Config->FindInputAction(Tag))
61
        {
62
            BindAction(Action, TriggerEvent, Object, Func);
63
        }
64
    }
65
};
66

67
// ---------- Character 中的使用 ----------
68
void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
69
{
70
    Super::SetupPlayerInputComponent(PlayerInputComponent);
71

72
    ULyraInputComponent* Input = Cast<ULyraInputComponent>(PlayerInputComponent);
73
    if (!Input || !InputConfig) return;
74

75
    // C++ 只认 Tag —— 策划在 InputConfig DataAsset 中更换 Action 不需要改代码
76
    Input->BindTaggedAction(InputConfig, TAG_Input_Move,     ETriggerEvent::Triggered,
77
                            this, &AFPSCharacter::Move);
78
    Input->BindTaggedAction(InputConfig, TAG_Input_Jump,     ETriggerEvent::Started,
79
                            this, &AFPSCharacter::JumpStart);
80
    Input->BindTaggedAction(InputConfig, TAG_Input_Shoot,    ETriggerEvent::Started,
81
                            this, &AFPSCharacter::Shoot);
82
    // ... 所有绑定都通过 Tag，而非直接引用 UInputAction*
83
}
84

85
// ===== 架构收益 =====
86
// ① 策划在编辑器中增删 InputAction、改变按键映射 → C++ 无需重编译
87
// ② GameplayTags 天然分层：InputTag.Move / InputTag.Combat.Shoot / InputTag.UI.Pause
88
// ③ 同一个 InputConfig DataAsset 可被多个 Character 复用
89
// ④ GAS（Gameplay Ability System）直接通过 Tag 激活对应 Ability——参见 Ch14

1
// 陷阱 #1：忘记 Cast 到 UEnhancedInputComponent
2
void BadSetup(UInputComponent* PlayerInputComponent)
3
{
4
    // ✗ UInputComponent 是基类——没有 BindAction(InputAction*, ...) 方法
5
    // PlayerInputComponent->BindAction(MoveAction, ...);  // 编译错误！
6

7
    // ✓ 必须先 Cast
8
    if (UEnhancedInputComponent* Input = Cast<UEnhancedInputComponent>(PlayerInputComponent))
9
    {
10
        Input->BindAction(MoveAction, ETriggerEvent::Triggered, this, &ThisClass::Move);
11
    }
12
}
13

14
// 陷阱 #2：在 Dedicated Server 上加载 IMC
15
void AMyPlayerController::BadBeginPlay()
16
{
17
    // ✗ DS 上没有 LocalPlayer！GetLocalPlayer() 返回 nullptr
18
    // ✗ UEnhancedInputLocalPlayerSubsystem 也不存在（参见 Ch9 的 ULocalPlayerSubsystem 警告）
19

20
    // ✓ 检查是否是本地玩家控制器
21
    if (IsLocalPlayerController())
22
    {
23
        if (ULocalPlayer* LP = GetLocalPlayer())
24
        {
25
            // 加载 IMC……
26
        }
27
    }
28
}
29

30
// 陷阱 #3：混淆 Triggered 和 Started
31
EnhancedInput->BindAction(JumpAction, ETriggerEvent::Triggered, this, &ThisClass::Jump);
32
// ✗ 用 Triggered 绑定跳跃——每帧都触发！角色会连续跳
33
// ✓ 跳跃应该用 Started（按下瞬间触发一次）
34

35
// 陷阱 #4：漏绑 Canceled——"按住不放+打开菜单"导致状态永久卡死
36
EnhancedInput->BindAction(JumpAction, ETriggerEvent::Started,   this, &ThisClass::JumpStart);
37
EnhancedInput->BindAction(JumpAction, ETriggerEvent::Completed, this, &ThisClass::JumpEnd);
38
// ✗ 只绑了 Completed！如果玩家按住跳跃键时打开菜单/切换关卡，
39
//    输入生命周期被 Cancel，JumpEnd 永远不会触发——角色永远"按住跳跃"
40
// ✓ 必须同时绑定 Canceled：
41
EnhancedInput->BindAction(JumpAction, ETriggerEvent::Canceled,  this, &ThisClass::JumpEnd);
42

43
// 陷阱 #5：Axis2D 动作绑定了 Digital 回调
44
// ✗ InputAction 的 ValueType 设为 Axis2D，但回调里用 Value.Get<float>()
45
// → 获取到的永远是 0.0f——类型不匹配
46
// ✓ 检查 InputAction 资产的 ValueType，回调中用对应的 Get<T>()
47

48
// 陷阱 #6：IMC 优先级冲突导致输入"失灵"
49
// 两个 IMC 都绑定了 Space 键——高优先级 IMC 消费后，低优先级永远收不到
50
// ✓ 排查：用 ShowDebug EnhancedInput 控制台命令查看当前活动的 IMC 和绑定
51

52
// 陷阱 #7：在 APlayerController 中写 SetupPlayerInputComponent
53
// ✗ SetupPlayerInputComponent 是 APawn/ACharacter 的虚函数——Controller 没有！
54
//    APlayerController 的输入初始化函数是 SetupInputComponent()（无参数）
55
// ✓ 输入绑定写在 Character 中，IMC 管理写在 Controller 中（见 10.10.1）