fix: clean code (just a little)

client/src/image.rs

@@ -53,7 +53,7 @@ impl From<&TileState> for Sprite {
                 TileContent::Number(7) => Sprite::Seven,
                 TileContent::Number(8) => Sprite::Eight,
                 TileContent::Bomb => Sprite::Bomb,
-                TileContent::Number(_) => todo!(),
+                TileContent::Number(_) => panic!(),
             },
         }
     }

client/src/lib.rs

@@ -3,5 +3,4 @@ pub mod components;
 pub mod contexts;
 pub mod image;
 pub mod pages;
-pub mod renderer;
 pub mod utils;

core/src/game/mod.rs

@@ -1,7 +1,9 @@
 use std::collections::HashMap;
 use std::fmt::Debug;
+use std::mem::swap;
 use std::sync::mpsc::{Receiver, Sender};
 use std::thread::spawn;
+use std::vec;
 
 use serde::{Deserialize, Serialize};
 
@@ -30,31 +32,30 @@ use crate::tile::{Tile, TileContent, TileState};
 #[cfg(feature = "server")]
 pub struct Game {
     grid: VecGrid<Tile>,
-    sender: Sender<GameEvent>,
-    receiver: Receiver<GameInput>,
     populated: bool,
     cursors: HashMap<String, CursorPosition>,
+    events: Vec<GameEvent>,
 }
 #[cfg(feature = "server")]
 impl Game {
-    pub fn new(
-        grid: VecGrid<Tile>,
-        sender: Sender<GameEvent>,
-        receiver: Receiver<GameInput>,
-    ) -> Self {
+    pub fn new(grid: VecGrid<Tile>) -> Self {
         Self {
             grid,
-            sender,
-            receiver,
             populated: false,
             cursors: HashMap::new(),
+            events: vec![],
         }
     }
-    pub fn start(mut self) {
-        spawn(move || loop {
-            let input = self.receiver.recv().unwrap();
-            self.play(input)
-        });
+    pub fn get_start_event(&self) -> GameEvent {
+        GameEvent::GameStart {
+            grid: VecGrid::<TileState>::from(&self.grid),
+            cursors: self.cursors.clone(),
+        }
+    }
+    pub fn buffered_events(&mut self) -> Vec<GameEvent> {
+        let mut events: Vec<GameEvent> = vec![];
+        swap(&mut self.events, &mut events);
+        return events;
     }
     pub fn play(&mut self, play: GameInput) {
         let GameInput { action, username } = play;
@@ -96,21 +97,14 @@ impl Game {
                     }
                 }
             }
-            GameAction::RedrawRequest => self.emit_event(GameEvent::GameStart {
-                grid: VecGrid::<TileState>::from(&self.grid),
-                cursors: self.cursors.clone(),
-            }),
             GameAction::CursorMoved(cursor_position) => {
                 self.cursors.insert(username.clone(), cursor_position);
                 self.emit_event(GameEvent::CursorMoved(username, cursor_position));
             }
         }
     }
     fn emit_event(&mut self, event: GameEvent) {
-        self.sender.send(event).unwrap();
-        // self.listeners
-        //     .iter_mut()
-        //     .for_each(|listener| listener.notify(event.clone()));
+        self.events.push(event);
     }
     fn discover_tile(&mut self, x: i32, y: i32) {
         let Some(tile) = self.grid.get_mut(x, y) else { return };
@@ -152,7 +146,6 @@ pub enum GameAction {
     Discover { x: i32, y: i32 },
     PlaceFlag { x: i32, y: i32 },
     RemoveFlag { x: i32, y: i32 },
-    RedrawRequest,
     CursorMoved(CursorPosition),
 }
 

server/src/api/lobby.rs

@@ -1,12 +1,9 @@
-use minesweeper_core::{game::Game, grid::vec_grid::VecGrid, tile::Tile};
-use std::sync::{Arc, Mutex};
-
 use actix_web::{get, post, web, Error, HttpMessage, HttpRequest, HttpResponse, Responder};
 use actix_web_actors::ws;
 use nanoid::nanoid;
 
 use crate::{
-    lobby::{Lobbies, Lobby, WsActor},
+    lobby::{facade::LobbyFacade, Lobbies},
     middleware::auth::User,
 };
 
@@ -22,10 +19,7 @@ pub async fn create(
     body: web::Json<model::CreateLobbyBody>,
 ) -> impl Responder {
     let id = nanoid!();
-    let new_lobby = Arc::new(Mutex::new(Lobby::new(VecGrid::<Tile>::new(
-        body.grid_width,
-        body.grid_height,
-    ))));
+    let new_lobby = LobbyFacade::new(body.into_inner());
     lobbies.lock().unwrap().insert(id.clone(), new_lobby);
     web::Json(model::Lobby { id })
 }
@@ -51,12 +45,5 @@ pub async fn lobby_ws(
     let lobbies = lobbies.lock().unwrap();
     let Some(lobby) = lobbies.get(lobby_id.as_str()) else {return Ok(HttpResponse::BadRequest().finish())};
     let user: User = req.extensions().get::<User>().unwrap().clone();
-    return ws::start(
-        WsActor {
-            user,
-            lobby: Arc::clone(lobby),
-        },
-        &req,
-        stream,
-    );
+    return ws::start(lobby.create_handle(user), &req, stream);
 }

server/src/lobby/actor.rs

@@ -0,0 +1,61 @@
+use actix::{Actor, AsyncContext, Handler, Message, StreamHandler};
+use actix_web_actors::ws;
+use minesweeper_core::messages::{GenericClientMessage, GenericServerMessage};
+
+use super::{handle::LobbyHandle, lobby::LobbyMessageContent};
+
+impl Actor for LobbyHandle {
+    type Context = ws::WebsocketContext<Self>;
+    fn started(&mut self, ctx: &mut Self::Context) {
+        let address = ctx.address().clone();
+        let mut lobby_event_receiver = self.lobby_event_receiver.take().unwrap();
+        tokio::spawn(async move {
+            loop {
+                let task = tokio::task::spawn_blocking(move || {
+                    (lobby_event_receiver.recv(), lobby_event_receiver)
+                })
+                .await
+                .unwrap();
+                lobby_event_receiver = task.1;
+                address
+                    .send(GenericServerMessageWrapper(task.0.unwrap()))
+                    .await
+                    .unwrap();
+            }
+        });
+    }
+}
+
+impl Handler<GenericServerMessageWrapper> for LobbyHandle {
+    type Result = ();
+    fn handle(&mut self, item: GenericServerMessageWrapper, ctx: &mut Self::Context) {
+        #[cfg(debug_assertions)]
+        ctx.text(serde_json::to_string(&item.0).unwrap());
+
+        #[cfg(not(debug_assertions))]
+        ctx.binary(bitcode::serialize(&item.0).unwrap());
+    }
+}
+
+impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for LobbyHandle {
+    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, _: &mut Self::Context) {
+        // let Ok(msg) = msg else { return };
+        if let Some(client_message) = match msg.unwrap() {
+            #[cfg(debug_assertions)]
+            ws::Message::Text(text) => {
+                Some(serde_json::from_str(text.to_string().as_str()).unwrap())
+            }
+            #[cfg(not(debug_assertions))]
+            ws::Message::Binary(binary) => Some(bitcode::deserialize(binary.as_ref()).unwrap()),
+            _ => Option::<GenericClientMessage>::None,
+        } {
+            self.lobby_message_sender
+                .send(self.lobby_message(LobbyMessageContent::GenericClientMessage(client_message)))
+                .unwrap();
+        }
+    }
+}
+
+#[derive(Message)]
+#[rtype(result = "()")]
+struct GenericServerMessageWrapper(pub GenericServerMessage);