Struct ascii_forge::prelude::KeyEvent

source ·

pub struct KeyEvent {
    pub code: KeyCode,
    pub modifiers: KeyModifiers,
    pub kind: KeyEventKind,
    pub state: KeyEventState,
}

Expand description

Represents a key event.

Fields§

§code: KeyCode

The key itself.

§modifiers: KeyModifiers

Additional key modifiers.

§kind: KeyEventKind

Kind of event.

Only set if:

Unix: KeyboardEnhancementFlags::REPORT_EVENT_TYPES has been enabled with PushKeyboardEnhancementFlags.
Windows: always

§state: KeyEventState

Keyboard state.

Only set if KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES has been enabled with PushKeyboardEnhancementFlags.

Implementations§

source §

impl KeyEvent

source

pub const fn new(code: KeyCode, modifiers: KeyModifiers) -> KeyEvent

Examples found in repository ?

examples/event_visualizer.rs (line 29)

fn main() -> Result<(), Box<dyn Error>> {
    let mut event = Event::FocusGained;
    let mut window = Window::init()?;

    if !window.supports().keyboard() {
        window.restore()?;
        eprintln!("This game does not support this terminal.\nIf Curious, look up terminals that support the kitty keyboard protocol");
        return Err("Terminal Unsupported".into());
    }

    loop {
        window.update(Duration::ZERO)?;

        if let Some(new_event) = window.event() {
            event = new_event.clone();
        }

        render!(
            window, [
                vec2(0, 20) => "To Quit, Press Ctrl + C".red(),
                vec2(0, 0) => format!("{:#?}", event).replace('\t', "   "),
            ]
        );

        if window.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)) {
            break;
        }
    }

    Ok(())
}

More examples

Hide additional examples

examples/inline.rs (line 40)

fn progress_bar() -> io::Result<()> {
    let mut window = Window::init_inline(2)?;

    let timer = SystemTime::now();
    let duration = Duration::from_secs(3);

    // The Inline Render Loop
    loop {
        // Render's the Window and captures events
        window.update(Duration::ZERO)?;

        let amount_done = SystemTime::now().duration_since(timer).unwrap();

        let percent = amount_done.as_secs_f64() / duration.as_secs_f64();

        if percent >= 1.0 {
            break;
        }

        let x = (window.size().x as f64 * percent).round() as u16;

        // Create the progress bar text
        let text_green = "|".repeat(x as usize).green();
        let text_red = "|".repeat((window.size().x - x) as usize).red();

        // Render the Progress Bar
        render!(window, [
            vec2(0, 1) => text_green,
            vec2(x, 1) => text_red,
            vec2(0, 0) => "Progress"
        ]);

        // End the loop if key is pressed early
        if window.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)) {
            break;
        }
    }

    window.restore()
}

examples/space_invaders.rs (line 277)

pub fn app(window: &mut Window) -> io::Result<String> {
    let mut score = 0;
    let mut player = Player::new(window, 'W'.green());

    let mut projectiles = vec![];

    let mut enemies = vec![];

    let mut delta = Duration::ZERO;

    let mut spawner = Duration::from_millis(800);

    let mut move_timer = Duration::from_millis(200);

    let mut shoot_timer = Duration::from_millis(500);

    let info_text = Buffer::sized_element("Press C-q to quit");

    // Main Game Loop
    loop {
        let start = SystemTime::now();
        // update the window, without blocking the screen
        window.update(Duration::from_secs_f64(1.0 / 60.0))?;

        if window.code(KeyCode::Char(' ')) {
            projectiles.push(Projectile::new(
                vec2(player.loc.x - 1, player.loc.y - 1),
                -0.3,
                "|||".green(),
            ))
        }

        // Render and update projectiles
        projectiles.retain(|x| x.alive(window));

        projectiles.iter_mut().for_each(|x| {
            x.update();
            x.draw(window);
        });

        // Render and update the player.
        player.update(window);
        player.draw(window);

        match spawner.checked_sub(delta) {
            Some(s) => spawner = s,
            None => {
                enemies.push(Enemy::new(vec2(0, 3), 'M'.red(), 10));
                spawner = Duration::from_secs(2);
            }
        }

        match move_timer.checked_sub(delta) {
            Some(m) => move_timer = m,
            None => {
                if enemies.iter_mut().any(|x| x.enemy_move(window)) {
                    return Ok(format!("Game Over\nScore was: {}", score));
                }
                move_timer = Duration::from_millis(200);
            }
        }

        if player.hit(&projectiles) {
            return Ok(format!("Game Over\nScore was: {}", score));
        }

        match shoot_timer.checked_sub(delta) {
            Some(s) => shoot_timer = s,
            None => {
                enemies.iter_mut().for_each(|x| {
                    projectiles.push(Projectile::new(vec2(x.loc.x, x.loc.y + 1), 0.3, "|".red()))
                });
                shoot_timer = Duration::from_millis(500);
            }
        }

        enemies.retain_mut(|x| {
            if x.hit(&projectiles) {
                score += x.score;
                false
            } else {
                true
            }
        });

        enemies.iter_mut().for_each(|x| x.draw(window));

        render!(
            window, [
                vec2(0, 0) => format!("Score: {}", score),
                vec2(window.size().x - info_text.size().x, 0) => info_text
            ]
        );

        if window.key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)) {
            break;
        }

        delta = SystemTime::now().duration_since(start).unwrap();
    }

    Ok("Game Exited".to_string())
}

source

pub const fn new_with_kind( code: KeyCode, modifiers: KeyModifiers, kind: KeyEventKind ) -> KeyEvent

Examples found in repository ?

examples/space_invaders.rs (lines 69-73)

    pub fn update(&mut self, window: &mut Window) {
        if window.key(KeyEvent::new_with_kind(
            KeyCode::Right,
            KeyModifiers::NONE,
            KeyEventKind::Press,
        )) {
            self.input = 1;
        } else if window.key(KeyEvent::new_with_kind(
            KeyCode::Right,
            KeyModifiers::NONE,
            KeyEventKind::Release,
        )) {
            self.input = self.input.min(0);
        }
        if window.key(KeyEvent::new_with_kind(
            KeyCode::Left,
            KeyModifiers::NONE,
            KeyEventKind::Press,
        )) {
            self.input = -1;
        } else if window.key(KeyEvent::new_with_kind(
            KeyCode::Left,
            KeyModifiers::NONE,
            KeyEventKind::Release,
        )) {
            self.input = self.input.max(0);
        }

        self.loc.x = (self.loc.x as i32 + self.input).clamp(0, window.size().x as i32) as u16;
    }