Iron out some bugs

rust/src/game_manager.rs

@@ -287,12 +287,46 @@ impl Game {
             && let PeerKind::Server(peer, _) = peer
             && let Some(player) = self.find_player_mut(self.self_id.unwrap_or(0))
         {
-            player.ready = true;
+            player.data.ready = true;
             peer.broadcast_reliable(Package::SetReady(player.id(), true));
         }
         self.goals.clear();
     }
 
+    pub fn finish_game(&mut self) {
+        for player in &mut self.players {
+            if let Some(mut character) = player.character.take() {
+                character.queue_free();
+            }
+            player.data.ready = false;
+        }
+
+        self.run_deferred(|s| {
+            if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
+                && let PeerKind::Server(peer, _) = peer
+            {
+                for player in &s.players {
+                    peer.broadcast_reliable(Package::SetReady(player.id(), false));
+                }
+            }
+        });
+
+        if let Some(mut ball) = self.world_ball.take() {
+            ball.queue_free();
+        }
+        self.current_map.take();
+        self.game_started = false;
+
+        self.run_deferred(|s| {
+            if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
+                && let PeerKind::Server(peer, _) = peer
+            {
+                peer.broadcast_reliable(Package::FinishGame);
+            }
+            s.signals().on_game_finished().emit()
+        });
+    }
+
     pub fn change_option(&mut self, opt: GameOption, value: GameOptionValue) {
         self.opts.values.insert(opt, value);
         self.run_deferred(move |s| {
@@ -409,8 +443,8 @@ impl Game {
                 name: name.unwrap_or(format!("Player {}", id)),
                 ping: 0,
                 team: 0,
+                ready: false,
             },
-            ready: false,
             character: None,
         });
         self.run_deferred(move |s| s.signals().on_new_player().emit(id));
@@ -483,7 +517,7 @@ impl Game {
 
     pub fn update_player_ready(&mut self, player_id: u16, ready: bool) {
         if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
-            player.ready = ready;
+            player.data.ready = ready;
         }
         self.run_deferred(|s| s.signals().on_players_updated().emit());
     }
@@ -563,26 +597,13 @@ impl Game {
                     peer.broadcast_reliable(Package::Goal(teams));
                 }
             }
-        });
-        let max_goals = self.goals.values().max().copied().unwrap_or(0);
-        if max_goals >= 1 {
-            self.finish_game();
-        }
-    }
-
-    pub fn finish_game(&mut self) {
-        for player in &mut self.players {
-            if let Some(mut character) = player.character.take() {
-                character.queue_free();
+            if NetworkManager::singleton().bind().is_host() {
+                let max_goals = s.goals.values().max().copied().unwrap_or(0);
+                if max_goals >= 1 {
+                    s.finish_game();
+                }
             }
-            player.ready = false;
-        }
-        if let Some(mut ball) = self.world_ball.take() {
-            ball.queue_free();
-        }
-        self.current_map.take();
-        self.game_started = false;
-        self.run_deferred(|s| s.signals().on_game_finished().emit());
+        });
     }
 
     pub fn handle_ball_pickup(&mut self, player_id: u16) {
@@ -805,7 +826,6 @@ impl Game {
 pub struct Player {
     pub connection_addr: SocketAddr,
     pub data: NetPlayer,
-    pub ready: bool,
     pub character: Option<DynGd<CharacterBody3D, dyn IPlayer + 'static>>,
 }
 
@@ -908,6 +928,7 @@ impl Player {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct NetPlayer {
     pub id: u16,
+    pub ready: bool,
     pub name: String,
     pub ping: u128,
     pub team: u8,
@@ -918,7 +939,6 @@ impl From<NetPlayer> for Player {
         Player {
             connection_addr: SocketAddr::from(([0, 0, 0, 0], 0)),
             data: value,
-            ready: false,
             character: None,
         }
     }

rust/src/net/network_manager.rs

@@ -269,6 +269,9 @@ pub enum Package {
     DespawnBall,
     SwapWeapon(u16, WeaponType),
     Goal(Vec<u8>),
+
+    // End-of-Game packages
+    FinishGame,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

rust/src/net/protocol.rs

@@ -176,6 +176,11 @@ impl NetworkManager {
                                 game.bind_mut().handle_goal(teams);
                             }
                         }
+                        Package::FinishGame => {
+                            if let Some(game) = &mut Game::singleton() {
+                                game.bind_mut().finish_game();
+                            }
+                        }
                         _ => {}
                     },
                 },

rust/src/ui/lobby.rs

@@ -221,7 +221,7 @@ impl LobbyPanel {
             if let PeerKind::Server(_, _) = peer
                 && let Some(button) = &mut self.ready_button
             {
-                let all_ready = game.bind().players.iter().all(|p| p.ready);
+                let all_ready = game.bind().players.iter().all(|p| p.data.ready);
                 button.set_disabled(!all_ready);
             }
         }

rust/src/ui/lobby_player_listing.rs

@@ -93,7 +93,7 @@ impl LobbyPlayerListing {
             }
 
             if let Some(ready_label) = &mut self.ready_label {
-                if player.ready {
+                if player.data.ready {
                     ready_label.set_text("Ready");
                 } else {
                     ready_label.set_text("Not Ready");