Input combination / modifier keys abstraction

[alice-i-cecile]

What problem does this solve or what need does it fill?

Modifier keys are very commonly used in both games and applications. The existing approach to this is very manual, and heavy on boilerplate. See the cheatbook page for a good overview of how to work with input right now.

What solution would you like?

Expose a first-class solution for modifier keys in bevy_input. I'm not immediately sure what this would look like, so suggestions are very welcome.

What alternative(s) have you considered?

Use match statements everywhere, repeatedly. Iterate through eventreader (because that says it is in order) and maintain my own modifier key state as a local resource (credit to @mattdm on Discord.

Additional context

None.

[mattdm]

Yeah, thanks. My current sample code looks like this:

struct KeyboardModifierState {
    shift: ElementState,
    alt: ElementState,
    control: ElementState,
}

impl Default for KeyboardModifierState {
    fn default() -> Self {
        Self {
            shift: ElementState::Released,
            alt: ElementState::Released,
            control: ElementState::Released,
        }
    }
}

fn keyboard_input_system(
    mut modifier_state: Local<KeyboardModifierState>,
    mut eventreader_keyboard: Local<EventReader<KeyboardInput>>,
    keyboard_input_events: Res<Events<KeyboardInput>>,
) {
    for keyevent in eventreader_keyboard.iter(&keyboard_input_events) {
        //println!("{:?}", keyevent);
        match keyevent {
            KeyboardInput {
                key_code: Some(KeyCode::LShift),
                state,
                ..
            }
            | KeyboardInput {
                key_code: Some(KeyCode::RShift),
                state,
                ..
            } => modifier_state.shift = state.clone(),
            KeyboardInput {
                key_code: Some(KeyCode::LAlt),
                state,
                ..
            }
            | KeyboardInput {
                key_code: Some(KeyCode::RAlt),
                state,
                ..
            } => modifier_state.alt = state.clone(),
            KeyboardInput {
                key_code: Some(KeyCode::LControl),
                state,
                ..
            }
            | KeyboardInput {
                key_code: Some(KeyCode::RControl),
                state,
                ..
            } => modifier_state.control = state.clone(),
            KeyboardInput {
                key_code: Some(KeyCode::A),
                state: ElementState::Pressed,
                ..
            } => println!(
                "A with Shift {:?} Alt {:?} Control {:?}",
                modifier_state.shift, modifier_state.alt, modifier_state.control
            ),
            _ => {
                // ignore all else
            }
        }
    }
}

[cart]

This has come up previously (#989 (comment)). Unless I'm missing a use case, I think Bevy Input<KeyCode> already handles this reasonably nicely?

fn process_input(input: Res<Input<KeyCode>>) {
    let shift = input.pressed(KeyCode::LShift) || input.pressed(KeyCode::RShift);
    let ctrl = input.pressed(KeyCode::LControl) || input.pressed(KeyCode::RControl);
    if ctrl && shift && input.pressed(KeyCode::A) {
       println!("ctrl + shift + a");
    }
}

[alice-i-cecile]

Ah, I missed it! Thanks; I'll close this out.

[mattdm]

This has come up previously (#989 (comment)). Unless I'm missing a use case, I think Bevy Input<KeyCode> already handles this reasonably nicely?

@cart I don't think this is quite the same ... your code is "A and Shift are both pressed right now". But that doesn't handle "Shift was down and A was pressed at that time", which is significant because 1) in normal typing usage, holding Shift and then pressing A gives different results from holding A and pressing Shift, and 2) with my code, I get A presses registered when I first hit it and then if I hold I get repeats at the rate the OS is sending them. With your code, I get repeats as fast as the framerate.

I thought about using a FixedTimestep so I only get repeats every 0.1 seconds or whatever, but that doesn't work because it only fires if the keys are pressed on that time through. So with the "is currently pressed" approach, I'm moving from the ugly key match thing to a different complicated thing where I check what's pressed constantly but only actually do something about it 20 times a second (or whatever).

(My specific use case is WASD movement with shift to slow down and ctrl to speed up.)

The nicest would be to have the KeyboardInput event show the state of the modifiers at the time they were pressed. (See for example rust-sdl2.

[alice-i-cecile]

This example only works if you care about instantaneous key combinations. It doesn't work quite like the keyboard does at a text input window. Fine for games in many cases, maybe not in others.

Reopening to see if we can address this more fully.

[RustyStriker]

@mattdm what are you trying to achieve? You have the just_pressed and just_released calls on the input, so you can do shift && input.just_pressed(key_code) to act once on the input, or hold it until input.just_released(key_code). As i think i understand what you eventually want is a bit wasteful(at least in my opinion) as you can easily work around this limitation rather easily.