basic movement

1 files changed, 48 insertions, 31 deletions

diff --git a/server/src/main.rs b/server/src/main.rs
index 763ff03b..477595d0 100644
--- a/server/src/main.rs
+++ b/server/src/main.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
 use futures_util::{SinkExt, StreamExt};
-use log::{debug, info};
+use log::{debug, info, warn};
 use std::{sync::Arc, time::Duration};
 use tokio::{
     io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
@@ -32,14 +32,16 @@ async fn main() -> Result<()> {
     {
         let game = game.clone();
         spawn(async move {
-            {
-                let mut g = game.write().await;
-                while let Some(p) = g.packet_out() {
-                    debug!("-> {p:?}");
-                    let _ = tx.send(p);
+            loop {
+                {
+                    let mut g = game.write().await;
+                    while let Some(p) = g.packet_out() {
+                        debug!("-> {p:?}");
+                        let _ = tx.send(p);
+                    }
                 }
+                sleep(Duration::from_millis(20)).await;
             }
-            sleep(Duration::from_millis(10)).await;
         });
     }
 
@@ -54,23 +56,27 @@ async fn main() -> Result<()> {
                 spawn(async move {
                     write
                         .write_all(serde_json::to_string(&PacketC::Joined { id }).unwrap().as_bytes())
-                        .await
-                        .unwrap();
-                    write.write_all(b"\n").await.unwrap();
+                        .await?;
+                    write.write_all(b"\n").await?;
                     while let Ok(packet) = rx.recv().await {
                         write
                             .write_all(serde_json::to_string(&packet).unwrap().as_bytes())
-                            .await
-                            .unwrap();
-                        write.write_all(b"\n").await.unwrap();
+                            .await?;
+                        write.write_all(b"\n").await?;
                     }
+                    Ok::<_, anyhow::Error>(())
                 });
                 spawn(async move {
                     let mut read = BufReader::new(read).lines();
                     while let Ok(Some(line)) = read.next_line().await {
-                        let packet: PacketS = serde_json::from_str(&line).unwrap();
+                        let Ok(packet): Result<PacketS, _> = serde_json::from_str(&line) else {
+                            warn!("invalid json over tcp");
+                            break
+                        };
                         debug!("<- {id} {packet:?}");
-                        game.write().await.packet_in(id, packet).unwrap();
+                        if let Err(e) = game.write().await.packet_in(id, packet) {
+                            warn!("client error: {e}");
+                        }
                     }
                 });
             }
@@ -82,26 +88,37 @@ async fn main() -> Result<()> {
                 let mut rx = rx.resubscribe();
                 info!("{addr} connected via ws");
                 spawn(async move {
-                    write
-                        .send(tokio_tungstenite::tungstenite::Message::Text(
-                            serde_json::to_string(&PacketC::Joined { id }).unwrap(),
-                        ))
-                        .await
-                        .unwrap();
+                    if let Err(e) = write.send(tokio_tungstenite::tungstenite::Message::Text(
+                        serde_json::to_string(&PacketC::Joined { id }).unwrap(),
+                    )).await {
+                        warn!("ws error on init: {e}");
+                        return;
+                    }
                     while let Ok(packet) = rx.recv().await {
-                        write
-                            .send(tokio_tungstenite::tungstenite::Message::Text(
-                                serde_json::to_string(&packet).unwrap(),
-                            ))
-                            .await
-                            .unwrap();
+                        if let Err(e) = write.send(tokio_tungstenite::tungstenite::Message::Text(
+                            serde_json::to_string(&packet).unwrap(),
+                        )).await {
+                            warn!("ws error: {e}");
+                            break;
+                        }
                     }
                 });
                 spawn(async move {
-                    while let Some(Ok(Message::Text(message))) = read.next().await {
-                        let packet: PacketS = serde_json::from_str(&message).unwrap();
-                        debug!("<- {id} {packet:?}");
-                        game.write().await.packet_in(id, packet).unwrap();
+                    while let Some(Ok(message)) = read.next().await {
+                        match message {
+                            Message::Text(line) => {
+                                let Ok(packet): Result<PacketS, _> = serde_json::from_str(&line) else {
+                                    warn!("invalid json over ws");
+                                    break
+                                };
+                                debug!("<- {id} {packet:?}");
+                                if let Err(e) = game.write().await.packet_in(id, packet) {
+                                    warn!("client error: {e}");
+                                }
+                            },
+                            Message::Close(_) => break,
+                            _ => (),
+                        }
                     }
                 });
             }