Fix all self_id uses for headless server

rust/src/game/mod.rs

@@ -442,7 +442,8 @@ impl Game {
 
         if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
             && let PeerKind::Server(peer, _) = peer
-            && let Some(player) = self.find_player_mut(self.self_id.unwrap_or(0))
+            && let Some(self_id) = self.self_id
+            && let Some(player) = self.find_player_mut(self_id)
         {
             player.data.ready = true;
             peer.broadcast_reliable(Package::SetReady(player.id(), true));
@@ -901,7 +902,9 @@ impl Game {
     }
 
     pub fn spawn_player_server(&mut self, id: u16) -> Option<DynGd<CharacterBody3D, dyn IPlayer>> {
-        if id == self.self_id.unwrap_or(0) {
+        if let Some(self_id) = self.self_id
+            && id == self_id
+        {
             self.stop_playback();
         }
 
@@ -921,9 +924,13 @@ impl Game {
 
         if let Some(mut map) = self.current_map.clone() {
             let team = self.find_player(id).map(|p| p.data.team).unwrap_or(0);
-            let mut character =
+            let mut character = map.bind_mut().spawn_player(
-                map.bind_mut()
+                id,
-                    .spawn_player(id, team, id == self.self_id.unwrap_or(0), None, true);
+                team,
+                self.self_id.map(|self_id| self_id == id).unwrap_or(false),
+                None,
+                true,
+            );
 
             if let Some(character) = &character
                 && let Some(player) = self.find_player_mut(id)
@@ -995,7 +1002,9 @@ impl Game {
 
     // Method called on the client-side whenever a player has spawned
     pub fn spawn_player_client(&mut self, id: u16, transform: NetTransform) {
-        if id == self.self_id.unwrap_or(0) {
+        if let Some(self_id) = self.self_id
+            && id == self_id
+        {
             self.stop_playback();
         }
 
@@ -1014,10 +1023,13 @@ impl Game {
                     character.queue_free();
                 }
 
+                let player_id = player.id();
                 let mut character = map.bind_mut().spawn_player(
                     player.id(),
                     player.data.team,
-                    player.id() == self.self_id.unwrap_or(0),
+                    self.self_id
+                        .map(|self_id| self_id == player_id)
+                        .unwrap_or(false),
                     Some(transform),
                     true,
                 );
@@ -1071,7 +1083,8 @@ impl Game {
                     telegrenade.set_linear_velocity(telegrenade_sync.velocity.into());
                 }
 
-                if player.id() != self.self_id.unwrap_or(0) {
+                let player_id = player.id();
+                if self.self_id.map(|id| id != player_id).unwrap_or(true) {
                     // Sync remote players always
                     player.set_transform(transform);
                     player.set_move_dir(movement_direction);
@@ -1103,7 +1116,11 @@ impl Game {
 
     // Handle a jump, either from the server or from a client
     pub fn handle_jump(&mut self, player_id: u16) {
-        if player_id != self.self_id.unwrap_or(0) {
+        if self
+            .self_id
+            .map(|self_id| self_id != player_id)
+            .unwrap_or(true)
+        {
             if let Some(recorder) = &mut self.replay_recorder {
                 recorder
                     .bind_mut()
@@ -1143,8 +1160,11 @@ impl Game {
         look_up: f32,
         deal_damage: bool,
     ) -> bool {
-        let self_id = self.self_id.clone().unwrap_or(0);
+        if self
-        if player_id != self_id {
+            .self_id
+            .map(|self_id| self_id != player_id)
+            .unwrap_or(true)
+        {
             if let Some(recorder) = &mut self.replay_recorder {
                 recorder
                     .bind_mut()
@@ -1170,8 +1190,11 @@ impl Game {
         look_up: f32,
         deal_damage: bool,
     ) -> bool {
-        let self_id = self.self_id.clone().unwrap_or(0);
+        if self
-        if player_id != self_id {
+            .self_id
+            .map(|self_id| self_id != player_id)
+            .unwrap_or(true)
+        {
             if let Some(recorder) = &mut self.replay_recorder {
                 recorder
                     .bind_mut()

rust/src/map/goal.rs

@@ -85,7 +85,8 @@ impl Goal {
             if let Some(game) = Game::singleton()
                 && let Some(ball_holder) = game.bind().ball_holder
                 && let Some(player) = game.bind().find_player(ball_holder)
-                && ball_holder == game.bind().self_id.unwrap_or(0)
+                && let Some(self_id) = game.bind().self_id
+                && ball_holder == self_id
                 && player.data.team != self.team
             {
                 icon.set_visible(true);

rust/src/net/network_manager.rs

@@ -313,15 +313,17 @@ impl NetworkManager {
                 }
                 PeerKind::Server(peer, ..) => {
                     let player_id = if let Some(game) = Game::singleton() {
-                        game.bind().self_id.unwrap_or(0)
+                        game.bind().self_id
                     } else {
-                        0
+                        None
                     };
+                    if let Some(player_id) = player_id {
                         peer.broadcast_reliable(Package::SetNick(player_id, nick));
                     }
                 }
             }
         }
+    }
 
     pub fn kick(&mut self, socket_addr: &SocketAddr) {
         if let Some(peer) = &mut self.peer {

rust/src/net/protocol.rs

@@ -119,7 +119,12 @@ impl NetworkManager {
                         }
                         Package::NewPlayer(player) => {
                             if let Some(game) = &mut Game::singleton() {
-                                if player.id != game.bind().self_id.unwrap_or(u16::MAX) {
+                                if game
+                                    .bind()
+                                    .self_id
+                                    .map(|id| player.id != id)
+                                    .unwrap_or(true)
+                                {
                                     game.bind_mut().new_player(
                                         SocketAddr::from(([0, 0, 0, 0], 0)),
                                         Some(player.name),
@@ -130,7 +135,12 @@ impl NetworkManager {
                         }
                         Package::PlayerLeft(player) => {
                             if let Some(game) = &mut Game::singleton() {
-                                if player.id != game.bind().self_id.unwrap_or(u16::MAX) {
+                                if game
+                                    .bind()
+                                    .self_id
+                                    .map(|id| player.id != id)
+                                    .unwrap_or(true)
+                                {
                                     game.bind_mut().remove_player(player.id);
                                 }
                             }
@@ -264,7 +274,12 @@ impl NetworkManager {
                         }
                         Package::ThrowTelegrenade(player_id, to) => {
                             if let Some(game) = &mut Game::singleton() {
-                                if player_id != game.bind().self_id.unwrap_or(0) {
+                                if game
+                                    .bind()
+                                    .self_id
+                                    .map(|id| player_id != id)
+                                    .unwrap_or(true)
+                                {
                                     game.bind_mut().on_throw_telegrenade(player_id, to);
                                 }
                             }

rust/src/player/remote_player.rs

@@ -426,7 +426,8 @@ impl ICharacterBody3D for RemotePlayer {
 
         self.run_deferred(|s| {
             if let Some(game) = Game::singleton()
-                && let Some(self_player) = game.bind().find_player(game.bind().self_id.unwrap_or(0))
+                && let Some(self_id) = game.bind().self_id
+                && let Some(self_player) = game.bind().find_player(self_id)
                 && let Some(remote_player) = game.bind().find_player(s.player_id.unwrap_or(0))
                 && self_player.data.team == remote_player.data.team
                 && let Some(sprite) = &mut s.shield_sprite

rust/src/ui/chatbox.rs

@@ -145,9 +145,11 @@ impl ChatBox {
                 PeerKind::Server(..) => {
                     self.run_deferred(move |_| {
                         if let Some(game) = &mut Game::singleton() {
-                            let self_id = game.bind().self_id;
+                            let self_id = game.bind().self_id.clone();
+                            if let Some(self_id) = self_id {
                                 game.bind_mut()
-                                .on_chat_message(self_id.unwrap_or(0), message.to_string());
+                                    .on_chat_message(self_id, message.to_string());
+                            }
                         }
                     });
                 }

rust/src/ui/lobby.rs

@@ -346,7 +346,8 @@ impl LobbyPanel {
 
     pub fn update_players(&mut self, replace: bool) {
         if let Some(game) = &Game::singleton()
-            && let Some(player) = game.bind().find_player(game.bind().self_id.unwrap_or(0))
+            && let Some(self_id) = game.bind().self_id
+            && let Some(player) = game.bind().find_player(self_id)
             && let Some(name_label) = &mut self.name_field
         {
             if player.data.name != name_label.get_text().to_string() {

rust/src/ui/lobby_player_listing.rs

@@ -75,9 +75,10 @@ impl IGridContainer for LobbyPlayerListing {
                     PeerKind::Server(..) => {
                         if let Some(player_id) = self.player_id
                             && let Some(game) = Game::singleton()
+                            && let Some(self_id) = game.bind().self_id
                         {
                             // Hide kick button for self even if host
-                            if player_id == game.bind().self_id.unwrap_or(0) {
+                            if player_id == self_id {
                                 kick_btn.hide();
                             }
                         }

rust/src/ui/player_listing.rs

@@ -89,7 +89,7 @@ impl PlayerListing {
     pub fn update(&mut self) {
         if let Some(player_id) = self.player_id {
             if let Some(game) = Game::singleton() {
-                let is_self = player_id == game.bind().self_id.unwrap_or(0);
+                let is_self = game.bind().self_id.map(|s| s == player_id).unwrap_or(false);
                 if let Some(player) = game.bind().find_player(player_id) {
                     if let Some(name_label) = &mut self.name_label {
                         name_label.set_text(&player.data.name);