Struct Input

pub struct Input { /* private fields */ }

Provides access to the input events handled by the Doryen engine. See the documentation for the InputApi type for details on what values should be used with the various key methods.

Implementations

impl Input

pub fn key(&self, key: &str) -> bool

Returns the current status of the given key (true if currently pressed).

Examples found in repository

examples/exit.rs (line 34)

fn process_input(
    input: Res<Input>,
    mut close_requested: ResMut<CloseRequested>,
    mut app_exit: EventWriter<AppExit>,
) {
    if close_requested.0 {
        if input.key("KeyY") {
            app_exit.send(AppExit::Success);
        } else if input.key("KeyN") {
            close_requested.0 = false;
        }
    } else if input.key("Escape") || input.close_requested() {
        close_requested.0 = true;
    }
}

examples/demo/player.rs (line 59)

fn move_player(
    input: Res<Input>,
    mut query: Query<(&mut Position, &Speed), With<Player>>,
    walls: Res<Walls>,
) {
    let mut movement = (0, 0);
    if input.key("ArrowLeft") || input.key("KeyA") {
        movement.0 = -2;
    } else if input.key("ArrowRight") || input.key("KeyD") {
        movement.0 = 2;
    }
    if input.key("ArrowUp") || input.key("KeyW") {
        movement.1 = -2;
    } else if input.key("ArrowDown") || input.key("KeyS") {
        movement.1 = 2;
    }
    if movement == (0, 0) {
        return;
    }

    let mut coef = DEFAULT_COEFFICIENT;
    let (mut player_position, player_speed) = query.single_mut();

    let next_x_pos = player_position.next_pos((movement.0 as f32, 0.));

    if walls.is_wall(next_x_pos) {
        movement.0 = 0;
        coef = 1.0;
    }
    let next_y_pos = player_position.next_pos((0., movement.1 as f32));

    if walls.is_wall(next_y_pos) {
        movement.1 = 0;
        coef = 1.0;
    }
    player_position.move_by(movement, *player_speed, coef);
}

examples/basic.rs (line 110)

fn input(
    input: Res<Input>,
    entities: Res<Entities>,
    mut player_query: Query<(&mut Position<i32>, &Player)>,
    mut mouse_query: Query<(&mut Position<f32>, &Mouse)>,
    mut screenshot_index: ResMut<ScreenshotIndex>,
    mut capture_events: EventWriter<Capture>,
) {
    let (mut player_position, _) = player_query.get_mut(entities.player).unwrap();

    if input.key("ArrowLeft") {
        player_position.x = (player_position.x - 1).max(1);
    } else if input.key("ArrowRight") {
        player_position.x = (player_position.x + 1).min(CONSOLE_WIDTH as i32 - 2);
    }
    if input.key("ArrowUp") {
        player_position.y = (player_position.y - 1).max(1);
    } else if input.key("ArrowDown") {
        player_position.y = (player_position.y + 1).min(CONSOLE_HEIGHT as i32 - 2);
    }

    let (mut mouse_position, _) = mouse_query.get_mut(entities.mouse).unwrap();

    let new_mouse_position = input.mouse_pos();
    mouse_position.x = new_mouse_position.0;
    mouse_position.y = new_mouse_position.1;

    if input.key("ControlLeft") && input.key_pressed("KeyS") {
        screenshot_index.0 += 1;
        capture_events.send(Capture::new(format!(
            "screenshot_{:03}.png",
            screenshot_index.0
        )));
    }
}

pub fn key_pressed(&self, key: &str) -> bool

Returns true if the given key was pressed since the last update.

Examples found in repository

examples/basic.rs (line 127)

fn input(
    input: Res<Input>,
    entities: Res<Entities>,
    mut player_query: Query<(&mut Position<i32>, &Player)>,
    mut mouse_query: Query<(&mut Position<f32>, &Mouse)>,
    mut screenshot_index: ResMut<ScreenshotIndex>,
    mut capture_events: EventWriter<Capture>,
) {
    let (mut player_position, _) = player_query.get_mut(entities.player).unwrap();

    if input.key("ArrowLeft") {
        player_position.x = (player_position.x - 1).max(1);
    } else if input.key("ArrowRight") {
        player_position.x = (player_position.x + 1).min(CONSOLE_WIDTH as i32 - 2);
    }
    if input.key("ArrowUp") {
        player_position.y = (player_position.y - 1).max(1);
    } else if input.key("ArrowDown") {
        player_position.y = (player_position.y + 1).min(CONSOLE_HEIGHT as i32 - 2);
    }

    let (mut mouse_position, _) = mouse_query.get_mut(entities.mouse).unwrap();

    let new_mouse_position = input.mouse_pos();
    mouse_position.x = new_mouse_position.0;
    mouse_position.y = new_mouse_position.1;

    if input.key("ControlLeft") && input.key_pressed("KeyS") {
        screenshot_index.0 += 1;
        capture_events.send(Capture::new(format!(
            "screenshot_{:03}.png",
            screenshot_index.0
        )));
    }
}

pub fn keys_pressed(&self) -> Keys<'_>

Returns an iterator over all the keys that were pressed since the last update in no particular order.

pub fn key_released(&self, key: &str) -> bool

Returns true if the given key was released since the last update.

Examples found in repository

examples/fonts.rs (line 70)

fn update(mut font: ResMut<Font>, input: Res<Input>, mut set_font_path: EventWriter<SetFontPath>) {
    let mut font_path = None;
    if input.key_released("PageDown") {
        font.current_font = (font.current_font + 1) % FONTS.len();
        font_path = Some(FONTS[font.current_font]);
    } else if input.key_released("PageUp") {
        font.current_font = (font.current_font + FONTS.len() - 1) % FONTS.len();
        font_path = Some(FONTS[font.current_font]);
    }

    if let Some(font_path) = font_path {
        font.current_font_name = font_path;
        set_font_path.send(SetFontPath(String::from(font_path).into()));
    }
}

examples/text_input.rs (line 38)

fn update(input: Res<Input>, mut text_input: ResMut<TextInput>) {
    // input.text returns the characters typed by the player since last update
    let text = input.text();
    if !text.is_empty() {
        text_input.text.push_str(text);
    }
    // handle backspace
    if input.key_released("Backspace") && !text_input.text.is_empty() {
        // convoluted way to remove the last character of the string
        // in a way that also works with utf-8 graphemes
        // where one character != one byte
        let mut graphemes = text_input.text.graphemes(true).rev();
        graphemes.next();
        text_input.text = graphemes.rev().collect();
    }
    // handle tab
    if input.key_released("Tab") {
        text_input.text.push_str("   ");
    }
    text_input.cursor += 1;
}

pub fn keys_released(&self) -> Keys<'_>

Returns an iterator over all the keys that were released since the last update in no particular order.

pub fn text(&self) -> &str

Characters typed since last update.

Examples found in repository

examples/text_input.rs (line 33)

fn update(input: Res<Input>, mut text_input: ResMut<TextInput>) {
    // input.text returns the characters typed by the player since last update
    let text = input.text();
    if !text.is_empty() {
        text_input.text.push_str(text);
    }
    // handle backspace
    if input.key_released("Backspace") && !text_input.text.is_empty() {
        // convoluted way to remove the last character of the string
        // in a way that also works with utf-8 graphemes
        // where one character != one byte
        let mut graphemes = text_input.text.graphemes(true).rev();
        graphemes.next();
        text_input.text = graphemes.rev().collect();
    }
    // handle tab
    if input.key_released("Tab") {
        text_input.text.push_str("   ");
    }
    text_input.cursor += 1;
}

pub fn mouse_button(&self, mouse_button: MouseButton) -> bool

Returns the current status of the given mouse button (true if currently pressed).

pub fn mouse_button_pressed(&self, mouse_button: MouseButton) -> bool

Returns true if the given mouse button was pressed since the last update.

pub fn mouse_button_released(&self, mouse_button: MouseButton) -> bool

Returns true if the given mouse button was released since the last update.

pub fn mouse_pos(&self) -> (f32, f32)

Returns the current mouse position in console cells coordinates. The decimal part of the value indicates sub-cell location.

Examples found in repository

examples/resize.rs (line 38)

fn update_mouse_position(mut resize_data: ResMut<ResizeData>, input: Res<Input>) {
    resize_data.mouse_pos = input.mouse_pos();
}

examples/basic.rs (line 123)

fn input(
    input: Res<Input>,
    entities: Res<Entities>,
    mut player_query: Query<(&mut Position<i32>, &Player)>,
    mut mouse_query: Query<(&mut Position<f32>, &Mouse)>,
    mut screenshot_index: ResMut<ScreenshotIndex>,
    mut capture_events: EventWriter<Capture>,
) {
    let (mut player_position, _) = player_query.get_mut(entities.player).unwrap();

    if input.key("ArrowLeft") {
        player_position.x = (player_position.x - 1).max(1);
    } else if input.key("ArrowRight") {
        player_position.x = (player_position.x + 1).min(CONSOLE_WIDTH as i32 - 2);
    }
    if input.key("ArrowUp") {
        player_position.y = (player_position.y - 1).max(1);
    } else if input.key("ArrowDown") {
        player_position.y = (player_position.y + 1).min(CONSOLE_HEIGHT as i32 - 2);
    }

    let (mut mouse_position, _) = mouse_query.get_mut(entities.mouse).unwrap();

    let new_mouse_position = input.mouse_pos();
    mouse_position.x = new_mouse_position.0;
    mouse_position.y = new_mouse_position.1;

    if input.key("ControlLeft") && input.key_pressed("KeyS") {
        screenshot_index.0 += 1;
        capture_events.send(Capture::new(format!(
            "screenshot_{:03}.png",
            screenshot_index.0
        )));
    }
}

pub fn close_requested(&self) -> bool

Whether the window close button has been activated.

Examples found in repository

examples/exit.rs (line 39)

fn process_input(
    input: Res<Input>,
    mut close_requested: ResMut<CloseRequested>,
    mut app_exit: EventWriter<AppExit>,
) {
    if close_requested.0 {
        if input.key("KeyY") {
            app_exit.send(AppExit::Success);
        } else if input.key("KeyN") {
            close_requested.0 = false;
        }
    } else if input.key("Escape") || input.close_requested() {
        close_requested.0 = true;
    }
}

Trait Implementations

impl Debug for Input

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

Formats the value using the given formatter.

impl Default for Input

fn default() -> Input

Returns the “default value” for a type.

impl Resource for Input

where Self: Send + Sync + 'static,