init

src/app/app.rs

@@ -0,0 +1,66 @@
+use std::time::Duration;
+use tokio::sync::mpsc;
+use tokio::time::interval;
+use crate::domain::client::ClientManager;
+use crate::domain::event::{Event, EventBus};
+use crate::network::udp::UdpServer;
+use crate::runtime::dispatcher::Dispatcher;
+
+pub struct App {
+    // Communication inter-components
+    event_bus: EventBus,
+    dispatcher: Dispatcher,
+    event_rx: Option<mpsc::Receiver<Event>>,
+
+    // Network
+    udp_server: UdpServer,
+
+    // Clients
+    client_manager: ClientManager,
+
+}
+
+impl App {
+    pub async fn new() -> Self {
+        let (event_bus, event_rx) = EventBus::new();
+
+        let udp_server = UdpServer::new(event_bus.clone(), "127.0.0.1:5000").await;
+        let client_manager = ClientManager::new();
+        let dispatcher = Dispatcher::new(event_bus.clone(), udp_server.clone(), client_manager.clone()).await;
+
+
+        Self {
+            event_bus,
+            dispatcher,
+            event_rx: Some(event_rx),
+            udp_server,
+            client_manager
+        }
+    }
+
+    pub async fn start(&mut self) {
+        if let Some(event_rx) = self.event_rx.take() {
+            let dispatcher = self.dispatcher.clone();
+            tokio::spawn(async move {
+                dispatcher.start(event_rx).await;
+            });
+        }
+
+        let _ = self.udp_server.start().await;
+        let _ = self.tick_tasks().await;
+        println!("App started");
+    }
+
+    async fn tick_tasks(&self) {
+        let event_bus = self.event_bus.clone();
+        tokio::spawn(async move {
+            let mut interval = interval(Duration::from_secs(1));
+            loop {
+                // println!("Tick");
+                interval.tick().await;
+                let _ = event_bus.emit(Event::TickSeconds).await;
+            }
+        });
+    }
+
+}

src/app/mod.rs

@@ -0,0 +1 @@
+pub mod app;