Multiplayer: better open-game join-game errors

crates/connector/src/game/greceiver.rs

@@ -167,7 +167,9 @@ impl GameProcessor {
     /// Process connect message.
     async fn process_join(&mut self, meta: MessageMeta) {
         if let Err(err) = self.clients.reserve(meta.source).await {
-            warn!("Ignoring Join request: {err}");
+            warn!("Join request error: {err}");
+            self.send(&FromGame::JoinError(JoinError::DifferentGame), meta.source)
+                .await;
             return;
         }
 
@@ -184,6 +186,9 @@ impl GameProcessor {
                             "Player {:?} has already joined game on port {}.",
                             meta.source, self.port
                         );
+
+                        self.send(&FromGame::JoinError(JoinError::AlreadyJoined), meta.source)
+                            .await;
                     }
                     JoinErrorInner::GameFull => {
                         warn!(

crates/connector/src/server.rs

@@ -3,8 +3,8 @@ use std::net::SocketAddr;
 use anyhow::Context;
 use async_std::task;
 use de_net::{
-    self, FromServer, MessageDecoder, OutPackage, PackageReceiver, PackageSender, Peers, Socket,
-    ToServer,
+    self, FromServer, GameOpenError, MessageDecoder, OutPackage, PackageReceiver, PackageSender,
+    Peers, Socket, ToServer,
 };
 use tracing::{error, info, warn};
 
@@ -75,7 +75,12 @@ impl MainServer {
 
     async fn open_game(&mut self, source: SocketAddr, max_players: u8) -> anyhow::Result<()> {
         if let Err(err) = self.clients.reserve(source).await {
-            warn!("Ignoring OpenGame request: {err}");
+            warn!("OpenGame request error: {err}");
+            self.reply(
+                &FromServer::GameOpenError(GameOpenError::DifferentGame),
+                source,
+            )
+            .await?;
             return Ok(());
         }
 

crates/multiplayer/src/game.rs

@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 use de_core::{baseset::GameSet, player::Player};
-use de_net::{FromGame, FromServer, JoinError, ToGame, ToServer};
+use de_net::{FromGame, FromServer, GameOpenError, JoinError, ToGame, ToServer};
 
 use crate::{
     lifecycle::{FatalErrorEvent, NetGameConfRes},
@@ -20,7 +20,7 @@ impl Plugin for GamePlugin {
             .add_system(cleanup.in_schedule(OnEnter(NetState::None)))
             .add_system(open_or_join.in_schedule(OnEnter(NetState::Connected)))
             .add_system(
-                process_game_opened
+                process_from_server
                     .in_base_set(GameSet::PreMovement)
                     .run_if(on_event::<FromMainServerEvent>())
                     .after(MessagesSet::RecvMessages),
@@ -70,21 +70,31 @@ fn open_or_join(
     }
 }
 
-fn process_game_opened(
+fn process_from_server(
     mut ports: ResMut<Ports>,
     mut events: EventReader<FromMainServerEvent>,
     mut fatals: EventWriter<FatalErrorEvent>,
 ) {
     for event in events.iter() {
-        if let FromServer::GameOpened { port } = event.message() {
-            match ports.init_game_port(*port) {
+        match event.message() {
+            FromServer::Pong(id) => {
+                info!("Pong {} received from server.", *id);
+            }
+            FromServer::GameOpened { port } => match ports.init_game_port(*port) {
                 Ok(_) => {
                     info!("Game on port {} opened.", *port);
                 }
                 Err(err) => {
                     fatals.send(FatalErrorEvent::new(format!("Invalid GameOpened: {err:?}")));
                 }
-            }
+            },
+            FromServer::GameOpenError(err) => match err {
+                GameOpenError::DifferentGame => {
+                    fatals.send(FatalErrorEvent::new(
+                        "Cannot open game, the player already joined a game.",
+                    ));
+                }
+            },
         }
     }
 }
@@ -122,6 +132,16 @@ fn process_from_game(
                 JoinError::GameFull => {
                     fatals.send(FatalErrorEvent::new("Game is full, cannot join."));
                 }
+                JoinError::AlreadyJoined => {
+                    fatals.send(FatalErrorEvent::new(
+                        "Already joined the game, cannot re-join.",
+                    ));
+                }
+                JoinError::DifferentGame => {
+                    fatals.send(FatalErrorEvent::new(
+                        "Player already joined a different game.",
+                    ));
+                }
             },
             FromGame::Left => {
                 if state.0 < NetState::ShuttingDown {

crates/net/src/lib.rs

@@ -1,5 +1,5 @@
 pub use header::Peers;
-pub use messages::{FromGame, FromServer, JoinError, ToGame, ToServer};
+pub use messages::{FromGame, FromServer, GameOpenError, JoinError, ToGame, ToServer};
 pub use protocol::{Targets, MAX_PACKAGE_SIZE};
 pub use socket::{RecvError, SendError, Socket, MAX_DATAGRAM_SIZE};
 pub use tasks::{

crates/net/src/messages.rs

@@ -22,6 +22,13 @@ pub enum FromServer {
         /// Port at which players may connect to join the game.
         port: u16,
     },
+    GameOpenError(GameOpenError),
+}
+
+#[derive(Encode, Decode)]
+pub enum GameOpenError {
+    /// The player opening the game has already joined a different game.
+    DifferentGame,
 }
 
 /// Message to be sent from a player/client to a game server (inside of a
@@ -71,4 +78,8 @@ pub enum FromGame {
 #[derive(Encode, Decode)]
 pub enum JoinError {
     GameFull,
+    /// The player has already joined the game.
+    AlreadyJoined,
+    /// The player already participates on a different game.
+    DifferentGame,
 }