few bug fixes

src/main.rs

@@ -25,25 +25,30 @@ fn main() -> std::io::Result<()> {
                 let mut reader = BufReader::new(stream.try_clone().unwrap());
 
                 match methods::Session::new(&mut reader, database) {
-                    Ok(session) => loop {
+                    Ok((session, res)) => {
-                        let mut request_string = String::new();
+                        writeln!(stream, "{res}").unwrap();
-                        match reader.read_line(&mut request_string).unwrap() {
+                        stream.flush().unwrap();
-                            0 => break,
+
-                            _ => {
+                        loop {
-                                let (method, params) = parser::parse(&request_string).unwrap();
+                            let mut request_string = String::new();
-                                let response = session.handle_request(&method, &params);
+                            match reader.read_line(&mut request_string).unwrap() {
-                                stream
+                                0 => break,
-                                    .write_all(
+                                _ => {
+                                    let (method, params) = parser::parse(&request_string).unwrap();
+                                    let response = session.handle_request(&method, &params);
+                                    writeln!(
+                                        stream,
+                                        "{}",
                                         match response {
                                             Ok(response) => response.to_string(),
                                             Err(e) => format!("!{e}"),
                                         }
-                                        .as_bytes(),
                                     )
                                     .unwrap();
-                            }
+                                }
-                        };
+                            };
-                    },
+                        }
+                    }
                     Err(e) => {
                         stream.write_all(format!("!{e}").as_bytes()).unwrap();
                         stream

src/methods/mod.rs

@@ -24,14 +24,14 @@ pub struct LocalPlayer {
 pub struct Session {
     pub session_token: String,
     pub database: Arc<crate::database::Database>,
-    pub player: LocalPlayer,
+    pub local_player: LocalPlayer,
 }
 
 impl Session {
     pub fn new(
         reader: &mut BufReader<TcpStream>,
         database: Arc<crate::database::Database>,
-    ) -> Result<Self> {
+    ) -> Result<(Self, Response)> {
         // Read the session token
         let mut session_token = String::new();
         reader
@@ -50,15 +50,21 @@ impl Session {
         }
 
         // Parse the player data
-        let player: LocalPlayer = response
+        let local_player: LocalPlayer = response
             .json()
             .map_err(|_| crate::response::Error::InvalidSession)?;
 
-        Ok(Self {
+        let uuid = local_player.id.clone();
+
+        let session = Self {
             session_token,
             database,
-            player,
+            local_player,
-        })
+        };
+
+        let player = player::player(&session, uuid)?;
+
+        Ok((session, player))
     }
 
     pub fn handle_request(&self, method: &str, params: &HashMap<String, String>) -> Result {

src/methods/player.rs

@@ -17,5 +17,6 @@ pub fn player(session: &Session, uuid: String) -> Result {
 
     Ok(Response::Player {
         cloak: player.cloak,
+        uuid,
     })
 }

src/methods/set_cloak.rs

@@ -5,16 +5,20 @@ use crate::response::{Response, Result};
 use super::Session;
 
 pub fn set_cloak(session: &Session, cloak: String) -> Result {
-    session.database.players.update_one(
+    session
-        doc! {
+        .database
-            "uuid": session.player.id.clone(),
+        .players
-        },
+        .update_one(
-        doc! {
+            doc! {
-            "$set": {
+                "uuid": session.local_player.id.clone(),
-                "cloak": cloak,
             },
-        },
+            doc! {
-    ).run()?;
+                "$set": {
+                    "cloak": cloak,
+                },
+            },
+        )
+        .run()?;
 
     Ok(Response::Success)
 }

src/response.rs

@@ -4,7 +4,7 @@ pub type Result<T = Response> = std::result::Result<T, Error>;
 pub enum Response {
     Pong,
     Success,
-    Player { cloak: String },
+    Player { cloak: String, uuid: String },
 }
 
 impl std::fmt::Display for Response {
@@ -12,7 +12,7 @@ impl std::fmt::Display for Response {
         match self {
             Response::Pong => write!(f, "Pong"),
             Response::Success => write!(f, "Success"),
-            Response::Player { cloak } => write!(f, "@cloak={cloak}"),
+            Response::Player { cloak, uuid } => write!(f, "@cloak={cloak}@uuid={uuid}"),
         }
     }
 }