Bevy Enhanced Input

actions!(Player[
    (
        Action::<Movement>::new(),
        DeadZone::default(),       // ignore small analog values
        SmoothNudge::default(),    // smoothing
        DeltaScale::default(),     // multiply by delta time
        Scale::splat(30.0),        // constant multiplier
        bindings![KeyCode::KeyW, KeyCode::KeyA, KeyCode::KeyS, KeyCode::KeyD],
    ),
]);

use bevy_enhanced_input::preset::*;

actions!(Player[
    (
        Action::<Movement>::new(),
        DeadZone::default(),
        SmoothNudge::default(),
        DeltaScale::default(),
        Scale::splat(30.0),
        Bindings::spawn((
            Cardinal::wasd_keys(),          // WASD
            Axial::left_stick(),            // gamepad left stick
        )),
    ),
    (
        Action::<Zoom>::new(),
        Bindings::spawn((
            Bidirectional::new(GamepadButton::DPadUp, GamepadButton::DPadDown),
            Spawn((Binding::mouse_wheel(), SwizzleAxis::YXZ)),
        )),
    ),
]);

Bindings::spawn((
    Cardinal { north: settings.forward, east: settings.right, south: settings.backward, west: settings.left },
));

#[derive(Component)]
struct OnFoot;

#[derive(Component)]
struct InVehicle;

app.add_input_context::<OnFoot>()
   .add_input_context::<InVehicle>();

commands.spawn((
    Player,
    ContextActivity::<InVehicle>::INACTIVE, // start on foot
    actions!(OnFoot[
        (Action::<Jump>::new(), bindings![KeyCode::Space]),
    ]),
    actions!(InVehicle[
        (Action::<Accelerate>::new(), bindings![GamepadButton::RightTrigger2]),
    ]),
));

fn enter_vehicle(mut q: Query<&mut ContextActivity<OnFoot>, With<Player>>) {
    let mut activity = q.single_mut();
    *activity = ContextActivity::INACTIVE;
}

fn apply_input(
    jumps: Query<&ActionEvents, With<Action<Jump>>>,
    movements: Query<&Action<Movement>>,
    mut players: Query<(&mut Transform, &Actions<Player>)>,
) {
    for (mut transform, actions) in &mut players {
        let Some(jump_events) = jumps.iter_many(actions).next() else {
            continue;
        };
        let Some(movement) = movements.iter_many(actions).next() else {
            continue;
        };

        // Jumped this frame
        if jump_events.contains(ActionEvents::STARTED) {
            // User logic...
        }

        // We defined the output of `Movement` as `Vec2`,
        // but since translation expects `Vec3`, we extend it to 3 axes.
        transform.translation = movement.extend(0.0);
    }
}

commands.spawn((OnFoot, ContextPriority::<OnFoot>(10))); // higher = evaluated first

app.sync_context_to_state::<Player, GameState>();

commands.spawn((
    Player,
    ContextActivity::<Player>::INACTIVE,
    ActiveInStates::<Player, _>::single(GameState::Playing),
    actions!(Player[(Action::<Jump>::new(), bindings![KeyCode::Space])]),
));

commands.spawn((
    Action::<Jump>::new(),
    ActionSettings {
        consume_input: true,        // action consumes binding values, preventing lower-priority actions from receiving them
        accumulate: Accumulation::Sum,  // how multiple bindings combine: Sum, Min, Max, Replace
        reset_to_none_each_frame: true, // reset trigger state each frame
    },
    bindings![KeyCode::Space, KeyCode::KeyJ],
));

// Single update:
commands.mock_once::<Jump, Player>();

// With a specific value and duration:
commands.mock::<Movement, Player>(
    ActionMock::new(ActionValue::Vec2(Vec2::X), MockSpan::Ticks(60)),
);

// Remove mock:
commands.unmock::<Movement, Player>();

commands.spawn((Player, GamepadDevice(Gamepad { id: 0 })));

fn pause_ui_actions(mut sources: ResMut<ActionSources>) {
    sources.block(Entity::PLACEHOLDER); // block actions while UI is focused
}

RUST_LOG=bevy_enhanced_input=debug cargo run

player.remove_with_requires::<OnFoot>()
      .despawn_related::<Actions<OnFoot>>();