Struct QueryInputHandler

pub struct QueryInputHandler<I, C> { /* private fields */ }

Input handler for an query-based game engine.

Use this when your game engine provides inputs via a function you can call to query the state of a given key.

At the top of your game loop, you MUST call QueryInputHandler::update. The general logic should look like this:

// This is predefined by your game engine
#[derive(Clone, Copy, Hash, Eq, PartialEq)]
enum Key {
    Up, Down, Left, Right, Escape,
    // etc ...
}

// You define this!
#[derive(Clone, Copy, Hash, Eq, PartialEq)]
enum Control {
    Up,
    Down,
    Left,
    Right,
    Pause,
}

let mut input_handler = QueryInputHandler::new_with_controls(vec![
    (Key::Up, Control::Up),
    (Key::Down, Control::Down),
    (Key::Left, Control::Left),
    (Key::Right, Control::Right),
    (Key::Escape, Control::Pause),
]);

// Even if your game engine requires the use of a `Context` to query keys
// you can still use `QueryInputHandler`.
let ctx = get_context();

loop {     
    input_handler.update(|input| ctx.is_key_pressed(input));

    // Now do game logic ...
    if input_handler.down(Control::Left) {
        player.x += 1.0;
    } else if input_handler.down(Control::Right) {
        player.x -= 1.0;
    } else if input_handler.clicked(Control::Up) {
        player.jump();
    }

}

I is the type of your inputs, and C is the type of your controls.

Implementations

impl<I: Hash + Eq + Clone, C: Hash + Eq + Clone> QueryInputHandler<I, C>

pub fn new() -> Self

Create a new PollingInputHandler with no control mapping.

pub fn new_with_controls(map: impl IntoIterator<Item = (I, C)>) -> Self

Create a new PollingInputHandler with the given mapping of inputs to controls.

If two entries in the iterator have the same input, the first one will be clobbered and the second one will remain.

pub fn clear_inputs(&mut self)

Manually unpress all inputs.

Note you should not have to call this at the beginning of your loop. (In fact, if you do, your inputs will never be pressed.)

pub fn update(&mut self, is_pressed: impl FnMut(I) -> bool)

Update the input handler. Give it a function that returns true if the given input is pressed this frame, and false if the given input is not pressed.

Depending on your grame engine’s architecture, you might need some kind of Context struct to query the state from. In this case, pass it a closure that borrows the Context.

You MUST CALL THIS FIRST THING in your game loop. Otherwise things won’t get updated correctly.

pub fn press_time(&self, ctrl: C) -> u32

Return the number of frames the given control has been pressed for.

pub fn down(&self, ctrl: C) -> bool

Return if this control is held down (ie, the corresponding input has been pressed for 1 or more frames).

pub fn up(&self, ctrl: C) -> bool

Return if this control is up.

pub fn clicked(&self, ctrl: C) -> bool

Return if this control was clicked down this frame (ie, the corresponding input was just pressed this frame).

Trait Implementations

impl<I: Clone, C: Clone> Clone for QueryInputHandler<I, C>

fn clone(&self) -> QueryInputHandler<I, C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug, C: Debug> Debug for QueryInputHandler<I, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I, C> Default for QueryInputHandler<I, C>

fn default() -> Self

Returns the “default value” for a type.