Fix player creation for 3 players

rust/src/game_manager.rs

@@ -82,9 +82,14 @@ impl Game {
         self.self_id = Some(id);
     }
 
-    pub fn new_player(&mut self, addr: SocketAddr, name: String) -> u16 {
+    pub fn new_player(&mut self, addr: SocketAddr, name: String, id: Option<u16>) -> u16 {
-        let id = self.player_counter;
+        let id = if let Some(id) = id {
-        self.player_counter += 1;
+            id
+        } else {
+            let id = self.player_counter;
+            self.player_counter += 1;
+            id
+        };
         self.players.push(Player {
             id,
             connection_addr: addr,
@@ -106,7 +111,7 @@ impl Game {
         self.players.iter().find(|p| p.connection_addr == *addr)
     }
 
-    pub fn get_player(&self, player_id: u16) -> Option<&Player> {
+    pub fn find_player(&self, player_id: u16) -> Option<&Player> {
         self.players.iter().find(|p| p.id == player_id)
     }
 

rust/src/net/network_manager.rs

@@ -170,6 +170,26 @@ impl INode for NetworkManager {
                                             }
                                         }
                                     }
+                                    Package::NewPlayer(player) => {
+                                        if let Some(game) = &mut Game::singleton() {
+                                            if player.id != game.bind().self_id.unwrap_or(u16::MAX)
+                                            {
+                                                game.bind_mut().new_player(
+                                                    SocketAddr::from(([0, 0, 0, 0], 0)),
+                                                    player.name,
+                                                    Some(player.id),
+                                                );
+                                            }
+                                        }
+                                    }
+                                    Package::PlayerLeft(player) => {
+                                        if let Some(game) = &mut Game::singleton() {
+                                            if player.id != game.bind().self_id.unwrap_or(u16::MAX)
+                                            {
+                                                game.bind_mut().remove_player(player.id);
+                                            }
+                                        }
+                                    }
                                     _ => {}
                                 },
                             }
@@ -191,13 +211,23 @@ impl INode for NetworkManager {
                                     );
 
                                     if let Some(game) = &mut Game::singleton() {
-                                        let self_id = game
+                                        let self_id = game.bind_mut().new_player(
-                                            .bind_mut()
+                                            connection.address,
-                                            .new_player(connection.address, String::new());
+                                            String::new(),
+                                            None,
+                                        );
+                                        let mut sent_players = game.bind().players.clone();
+                                        for player in &mut sent_players {
+                                            player.connection_addr =
+                                                SocketAddr::from(([0, 0, 0, 0], 0))
+                                        }
                                         peer.send_reliable(
                                             &connection.address,
-                                            Package::Players(game.bind().players.clone(), self_id),
+                                            Package::Players(sent_players, self_id),
                                         );
+                                        peer.broadcast_reliable(Package::NewPlayer(
+                                            game.bind().find_player(self_id).unwrap().clone(),
+                                        ));
                                     }
                                 }
                                 teanet::PeerMessage::Disconnected(connection, connection_error) => {
@@ -217,6 +247,9 @@ impl INode for NetworkManager {
                                             .find_player_by_addr(&connection.address)
                                             .map(|p| p.id);
                                         if let Some(player_id) = player_id {
+                                            peer.broadcast_reliable(Package::PlayerLeft(
+                                                game.bind().find_player(player_id).unwrap().clone(),
+                                            ));
                                             game.bind_mut().remove_player(player_id);
                                         }
                                     }
@@ -279,9 +312,11 @@ impl NetworkManager {
                     self.swap_to_lobby(true);
 
                     if let Some(game) = &mut Game::singleton() {
-                        let id = game
+                        let id = game.bind_mut().new_player(
-                            .bind_mut()
+                            SocketAddr::from(([0, 0, 0, 0], 0)),
-                            .new_player(SocketAddr::from(([0, 0, 0, 0], 0)), "Host".to_owned());
+                            "Host".to_owned(),
+                            None,
+                        );
                         game.bind_mut().set_self(id);
                     }
                 }
@@ -354,6 +389,8 @@ pub enum Package {
     SetNick(u16, String),
     SetSelfNick(String),
     UpdatePings(HashMap<u16, u128>),
+    NewPlayer(Player),
+    PlayerLeft(Player),
 }
 
 pub enum PeerKind {

rust/src/ui/player_listing.rs

@@ -25,10 +25,10 @@ impl PlayerListing {
     pub fn update(&mut self) {
         if let Some(player_id) = &self.player_id
             && let Some(game) = Game::singleton()
-            && let Some(player) = game.bind().get_player(*player_id)
+            && let Some(player) = game.bind().find_player(*player_id)
         {
             if let Some(player_label) = &mut self.name_label {
-                player_label.set_text(&player.name);
+                player_label.set_text(&format!("{} ({})", player.name, player.connection_addr));
             }
 
             if let Some(ping_label) = &mut self.ping_label {