Refactor App to use unified AppChannels for events

App now receives an AppChannels struct; AppEvent enum removed.

Event handling, tick generation, and audio communication are now
performed through dedicated channels.

src/app/app.rs

@@ -1,17 +1,13 @@
 use crate::{
     app::{
         GameStates, handle_keybindings,
-        threads::{AppEvent, AudioCmd},
+        threads::{AppChannels, AudioCmd},
         view::View,
     },
     cli::Cli,
 };
 use ratatui::{DefaultTerminal, Frame, crossterm::event::KeyEvent, layout::Rect};
-use std::{
-    io::Result,
-    sync::mpsc::{Receiver, RecvTimeoutError, Sender},
-    time::Duration,
-};
+use std::{io::Result, sync::mpsc::Sender, thread::sleep, time::Duration};
 
 pub struct App {
     pub exit: bool,
@@ -42,31 +38,29 @@ impl App {
         self.states.as_mut()
     }
 
-    pub fn run(&mut self, terminal: &mut DefaultTerminal, rx: Receiver<AppEvent>) -> Result<()> {
+    pub fn run(&mut self, terminal: &mut DefaultTerminal, channels: AppChannels) -> Result<()> {
         while !self.exit {
             terminal.draw(|frame: &mut Frame<'_>| self.draw(frame))?;
 
-            let event = match rx.recv_timeout(Duration::from_millis(100)) {
-                Ok(ev) => ev,
-                Err(RecvTimeoutError::Timeout) => {
-                    continue;
-                }
-                Err(_) => break,
-            };
-            match event {
-                AppEvent::Input(key_event) => self.handle_key_event(key_event)?,
-                AppEvent::Resize(_, _) => {
-                    let window_area: Rect = self.window_area;
-                    let Some(state) = self.states_mut() else {
-                        panic!("State issue")
-                    };
+            if let Ok(key) = channels.input_rx.try_recv() {
+                self.handle_key_event(key)?;
+            }
+
+            if let Ok((_, _)) = channels.resize_rx.try_recv() {
+                let window_area: Rect = self.window_area;
+                if let Some(state) = self.states_mut() {
                     state
                         .skirmish
                         .board
                         .change_resize(&window_area, state.skirmish.side_panel);
                 }
-                AppEvent::Tick => self.update()?,
             }
+
+            if let Ok(()) = channels.tick_rx.try_recv() {
+                self.update()?;
+            }
+
+            sleep(Duration::from_millis(10));
         }
 
         Ok(())
@@ -94,8 +88,9 @@ impl App {
 
     fn update(&mut self) -> Result<()> {
         if let Some(state) = self.states_mut() {
-            state.skirmish.update(&self.args);
+            state.skirmish.tick_update();
         }
+
         Ok(())
     }
 }

src/app/states/skirmish.rs

@@ -1,4 +1,4 @@
-use crate::{app::states::skirmish_states::BoardState, cli::Cli};
+use crate::app::states::skirmish_states::BoardState;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SkirmishState {
@@ -10,8 +10,8 @@ pub struct SkirmishState {
 }
 
 impl SkirmishState {
-    pub fn update(&mut self, cli: &Cli) {
-        self.board.advance_turn();
+    pub fn tick_update(&mut self) {
+        // self.board.advance_turn();
 
         // if self.board.is_victory() {}
 

src/app/threads/app_channels.rs

@@ -0,0 +1,37 @@
+use crate::app::threads::AudioCmd;
+use ratatui::crossterm::event::KeyEvent;
+use std::sync::mpsc::{Receiver, Sender, channel};
+
+pub struct AppChannels {
+    pub input_tx: Sender<KeyEvent>,
+    pub input_rx: Receiver<KeyEvent>,
+
+    pub resize_tx: Sender<(u16, u16)>,
+    pub resize_rx: Receiver<(u16, u16)>,
+
+    pub tick_tx: Sender<()>,
+    pub tick_rx: Receiver<()>,
+
+    pub audio_tx: Sender<AudioCmd>,
+    pub audio_rx: Receiver<AudioCmd>,
+}
+
+impl AppChannels {
+    pub fn new() -> Self {
+        let (input_tx, input_rx) = channel::<KeyEvent>();
+        let (resize_tx, resize_rx) = channel::<(u16, u16)>();
+        let (tick_tx, tick_rx) = channel::<()>();
+        let (audio_tx, audio_rx) = channel::<AudioCmd>();
+
+        Self {
+            input_tx,
+            input_rx,
+            resize_tx,
+            resize_rx,
+            tick_tx,
+            tick_rx,
+            audio_tx,
+            audio_rx,
+        }
+    }
+}

src/app/threads/events.rs

@@ -1,30 +1,20 @@
-use ratatui::crossterm::event::KeyEvent;
-use ratatui::crossterm::event::{Event, read};
+use ratatui::crossterm::event::{Event, KeyEvent, read};
 use std::sync::mpsc::Sender;
 
-pub enum AppEvent {
-    Input(KeyEvent),
-    Resize(u16, u16),
-    Tick,
-}
-
-/// Reads *all* crossterm events and forwards the ones we care about.
-pub fn handle_events(tx: Sender<AppEvent>) {
+pub fn handle_ct_events(input_tx: Sender<KeyEvent>, resize_tx: Sender<(u16, u16)>) {
     loop {
         match read() {
-            Ok(ev) => match ev {
-                Event::Key(key) => {
-                    if tx.send(AppEvent::Input(key)).is_err() {
-                        break;
-                    }
+            Ok(Event::Key(k)) => {
+                if input_tx.send(k).is_err() {
+                    break;
                 }
-                Event::Resize(cols, rows) => {
-                    if tx.send(AppEvent::Resize(cols, rows)).is_err() {
-                        break;
-                    }
+            }
+            Ok(Event::Resize(cols, rows)) => {
+                if resize_tx.send((cols, rows)).is_err() {
+                    break;
                 }
-                _ => {}
-            },
+            }
+            Ok(_) => {}
             Err(_) => continue,
         }
     }

src/app/threads/mod.rs

@@ -1,7 +1,9 @@
+mod app_channels;
 mod audio;
 mod events;
 mod tick;
 
+pub use app_channels::AppChannels;
 pub use audio::{AudioCmd, SoundrackParts, Soundtrack, handle_audio};
-pub use events::{AppEvent, handle_events};
-pub use tick::spawn_tick_thread;
+pub use events::handle_ct_events;
+pub use tick::handle_tick_event;

src/app/threads/tick.rs

@@ -1,22 +1,19 @@
-use crate::app::threads::AppEvent;
 use std::{
     sync::mpsc::Sender,
     thread,
     time::{Duration, Instant},
 };
 
-pub fn spawn_tick_thread(tx: Sender<AppEvent>, interval_ms: u64) {
-    thread::spawn(move || {
-        let interval: Duration = Duration::from_millis(interval_ms);
-        loop {
-            if tx.send(AppEvent::Tick).is_err() {
-                break;
-            }
-
-            let elapsed: Duration = Instant::now().elapsed();
-            if interval > elapsed {
-                thread::sleep(interval - elapsed);
-            }
+pub fn handle_tick_event(tx: Sender<()>, interval_ms: u8) {
+    let interval: Duration = Duration::from_millis(interval_ms as u64);
+    loop {
+        if tx.send(()).is_err() {
+            break;
         }
-    });
+
+        let elapsed: Duration = Instant::now().elapsed();
+        if interval > elapsed {
+            thread::sleep(interval - elapsed);
+        }
+    }
 }

src/app/views/skirmish.rs

@@ -72,7 +72,8 @@ pub fn skirmish_view(app: &App, area: Rect, buf: &mut Buffer) {
                     "Skills points: {} ({}/{}) | ",
                     1, 20, states.settings.skill_points_limit
                 ),
-                format!("Perk Deck: {}/9", 5),
+                format!("Perk Deck: {}/9 | ", 5),
+                format!("Tick: {}", states.skirmish.turn_counter),
             ]),
         ]);