fixed handling of key release

Author: sinon

src/lib.rs

@@ -116,6 +116,10 @@ impl Chip8Emulator {
         self.keyboard[idx] = pressed;
     }
 
+    pub fn clear_keys(&mut self) {
+        self.keyboard = [false; NUM_KEYS];
+    }
+
     const fn read_opcode(&mut self) -> u16 {
         let op_byte_1 = self.memory[self.program_counter as usize] as u16;
         let op_byte_2 = self.memory[(self.program_counter + 1) as usize] as u16;

src/main.rs

@@ -4,6 +4,8 @@ use chip8::{Chip8Emulator, SCREEN_WIDTH};
 use clap::Parser;
 use clap::Subcommand;
 use itertools::Itertools;
+use ratatui::crossterm::event::KeyboardEnhancementFlags;
+use ratatui::crossterm::event::PushKeyboardEnhancementFlags;
 use ratatui::{
     crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind},
     layout::{Constraint, Layout, Position, Rect},
@@ -39,6 +41,10 @@ pub struct App {
 fn main() -> io::Result<()> {
     let command = Args::parse().commands;
     let mut terminal = ratatui::init();
+    ratatui::crossterm::execute!(
+        io::stderr(),
+        PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::REPORT_EVENT_TYPES)
+    )?;
     let app_result = App::new(command).run(&mut terminal);
     ratatui::restore();
     app_result
@@ -64,11 +70,13 @@ impl App {
 
     pub fn run(&mut self, terminal: &mut DefaultTerminal) -> io::Result<()> {
         while !self.exit {
-            self.emulator.tick();
+            for _ in 0..10 {
+                self.emulator.tick();
+            }
             self.emulator.tick_timers();
             self.calculate_points();
-            terminal.draw(|frame| self.draw(frame))?;
             self.handle_events()?;
+            terminal.draw(|frame| self.draw(frame))?;
         }
         Ok(())
     }
@@ -80,35 +88,47 @@ impl App {
     }
 
     fn handle_events(&mut self) -> io::Result<()> {
-        if event::poll(Duration::from_micros(10))? {
+        if event::poll(Duration::from_millis(10))? {
             match event::read()? {
-                Event::Key(key_event) if key_event.kind == KeyEventKind::Press => {
-                    self.handle_key_event(key_event)
+                Event::Key(key_event) => {
+                    let pressed = if key_event.kind == KeyEventKind::Press {
+                        true
+                    } else {
+                        false
+                    };
+                    self.handle_key_event(key_event, pressed)
                 }
                 _ => {}
             };
         }
         Ok(())
     }
-    fn handle_key_event(&mut self, key_event: KeyEvent) {
-        match key_event.code {
-            KeyCode::Char('q') => self.exit(),
-            KeyCode::Char(c) => match c {
-                '0'..='9' => {
-                    let idx = c as usize - '0' as usize;
-                    self.emulator.keypress(idx, true);
-                }
-                'a'..='f' => {
-                    let idx = c as usize - 'a' as usize;
-                    self.emulator.keypress(idx, true);
-                }
-                'A'..='F' => {
-                    let idx = c as usize - 'A' as usize;
-                    self.emulator.keypress(idx, true);
-                }
-                _ => {}
-            },
-            _ => {}
+    fn handle_key_event(&mut self, key_event: KeyEvent, pressed: bool) {
+        if key_event.code == KeyCode::Esc {
+            self.exit();
+        }
+        let x = match key_event.code {
+            KeyCode::Char('1') => Some(0x1),
+            KeyCode::Char('2') => Some(0x2),
+            KeyCode::Char('3') => Some(0x3),
+            KeyCode::Char('4') => Some(0xC),
+            KeyCode::Char('q') | KeyCode::Char('Q') => Some(0x4),
+            KeyCode::Char('w') | KeyCode::Char('W') => Some(0x5),
+            KeyCode::Char('e') | KeyCode::Char('E') => Some(0x6),
+            KeyCode::Char('r') | KeyCode::Char('R') => Some(0xD),
+            KeyCode::Char('a') | KeyCode::Char('A') => Some(0x7),
+            KeyCode::Char('s') | KeyCode::Char('S') => Some(0x8),
+            KeyCode::Char('d') | KeyCode::Char('D') => Some(0x9),
+            KeyCode::Char('f') | KeyCode::Char('F') => Some(0xE),
+            KeyCode::Char('z') | KeyCode::Char('Z') => Some(0xA),
+            KeyCode::Char('x') | KeyCode::Char('X') => Some(0x0),
+            KeyCode::Char('c') | KeyCode::Char('C') => Some(0xB),
+            KeyCode::Char('v') | KeyCode::Char('V') => Some(0xB),
+            _ => None,
+        };
+
+        if let Some(idx) = x {
+            self.emulator.keypress(idx, pressed);
         }
     }