leafwing-input-manager 0.20.0

A powerful, flexible and ergonomic way to manage action-input keybindings for the Bevy game engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#![cfg(feature = "mouse")]

use bevy::input::InputPlugin;
use bevy::input::mouse::MouseWheel;
use bevy::prelude::*;
use leafwing_input_manager::prelude::*;

#[derive(Actionlike, Clone, Copy, Debug, Reflect, PartialEq, Eq, Hash)]
enum ButtonlikeTestAction {
    Up,
    Down,
    Left,
    Right,
}

impl ButtonlikeTestAction {
    fn variants() -> &'static [ButtonlikeTestAction] {
        &[Self::Up, Self::Down, Self::Left, Self::Right]
    }
}

#[derive(Actionlike, Clone, Copy, Debug, Reflect, PartialEq, Eq, Hash)]
#[actionlike(Axis)]
enum AxislikeTestAction {
    X,
    Y,
    #[actionlike(DualAxis)]
    XY,
}

fn test_app() -> App {
    let mut app = App::new();
    app.add_plugins(MinimalPlugins)
        .add_plugins(InputPlugin)
        .add_plugins(InputManagerPlugin::<ButtonlikeTestAction>::default())
        .add_plugins(InputManagerPlugin::<AxislikeTestAction>::default())
        .init_resource::<ActionState<ButtonlikeTestAction>>()
        .init_resource::<ActionState<AxislikeTestAction>>();

    app
}

#[test]
fn mouse_scroll_discrete_mocking() {
    let mut app = test_app();
    let mut messages = app.world_mut().resource_mut::<Messages<MouseWheel>>();
    assert_eq!(messages.drain().count(), 0);

    MouseScrollDirection::UP.press(app.world_mut());

    let mut messages = app.world_mut().resource_mut::<Messages<MouseWheel>>();

    assert_eq!(messages.drain().count(), 1);
}

#[test]
fn mouse_scroll_single_axis_mocking() {
    let mut app = test_app();
    let mut messages = app.world_mut().resource_mut::<Messages<MouseWheel>>();
    assert_eq!(messages.drain().count(), 0);

    let input = MouseScrollAxis::X;
    input.set_value(app.world_mut(), -1.0);

    let mut messages = app.world_mut().resource_mut::<Messages<MouseWheel>>();
    assert_eq!(messages.drain().count(), 1);
}

#[test]
fn mouse_scroll_buttonlike() {
    let mut app = test_app();
    app.insert_resource(InputMap::new([
        (ButtonlikeTestAction::Up, MouseScrollDirection::UP),
        (ButtonlikeTestAction::Down, MouseScrollDirection::DOWN),
        (ButtonlikeTestAction::Left, MouseScrollDirection::LEFT),
        (ButtonlikeTestAction::Right, MouseScrollDirection::RIGHT),
    ]));

    for action in ButtonlikeTestAction::variants() {
        let input_map = app.world().resource::<InputMap<ButtonlikeTestAction>>();
        // Get the first associated input
        let input = input_map
            .get_buttonlike(action)
            .unwrap()
            .first()
            .unwrap()
            .clone();
        let direction = Reflect::as_any(input.as_ref())
            .downcast_ref::<MouseScrollDirection>()
            .unwrap();

        direction.press(app.world_mut());
        app.update();

        let action_state = app.world().resource::<ActionState<ButtonlikeTestAction>>();
        assert!(action_state.pressed(action), "failed for {input:?}");
    }
}

#[test]
fn mouse_scroll_buttonlike_cancels() {
    let mut app = test_app();
    app.insert_resource(InputMap::new([
        (ButtonlikeTestAction::Up, MouseScrollDirection::UP),
        (ButtonlikeTestAction::Down, MouseScrollDirection::DOWN),
        (ButtonlikeTestAction::Left, MouseScrollDirection::LEFT),
        (ButtonlikeTestAction::Right, MouseScrollDirection::RIGHT),
    ]));

    MouseScrollDirection::UP.press(app.world_mut());
    MouseScrollDirection::DOWN.press(app.world_mut());

    // Correctly flushes the world
    app.update();

    let action_state = app.world().resource::<ActionState<ButtonlikeTestAction>>();

    assert!(!action_state.pressed(&ButtonlikeTestAction::Up));
    assert!(!action_state.pressed(&ButtonlikeTestAction::Down));
}

#[test]
fn mouse_scroll_dual_axis() {
    let mut app = test_app();
    app.insert_resource(
        InputMap::default().with_dual_axis(AxislikeTestAction::XY, MouseScroll::default()),
    );

    let input = MouseScroll::default();
    input.set_axis_pair(app.world_mut(), Vec2::new(5.0, 0.0));
    app.update();

    let action_state = app.world().resource::<ActionState<AxislikeTestAction>>();

    assert_eq!(
        action_state.axis_pair(&AxislikeTestAction::XY),
        Vec2::new(5.0, 0.0)
    );
}