diff --git a/rust/src/game_manager.rs b/rust/src/game_manager.rs
index c23efaf..ad63616 100644
--- a/rust/src/game_manager.rs
+++ b/rust/src/game_manager.rs
@@ -124,7 +124,7 @@ impl INode for Game {
                             if let Some(player) = self
                                 .players
                                 .iter()
-                                .find(|p| p.id == self.self_id.unwrap_or(0))
+                                .find(|p| p.id() == self.self_id.unwrap_or(0))
                             {
                                 if let Some(data) = &player.get_self_sync() {
                                     peer.send_unreliable(socket_addr, SelfSync(data.clone()));
@@ -145,7 +145,7 @@ impl INode for Game {
                                     player.get_transform(),
                                 ) {
                                     sync_data.insert(
-                                        player.id,
+                                        player.id(),
                                         SyncPackage {
                                             movement_direction: dir,
                                             look_up,
@@ -167,13 +167,14 @@ impl INode for Game {
         if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
             if let PeerKind::Server(peer, _) = peer {
                 for player in self.players.clone() {
+                    let player_id = player.id();
                     if let Some(character) = player.character {
                         if character.dyn_bind().dead_for() > self.respawn_timer {
-                            let character = self.spawn_player_server(player.id);
+                            let character = self.spawn_player_server(player_id);
 
                             if let Some(character) = character {
                                 peer.broadcast_reliable(SpawnPlayer(
-                                    player.id,
+                                    player_id,
                                     character.dyn_bind().get_transform(),
                                 ));
                             }
@@ -251,10 +252,13 @@ impl Game {
             id
         };
         self.players.push(Player {
-            id,
             connection_addr: addr,
-            name,
-            ping: 0,
+            data: NetPlayer {
+                id,
+                name,
+                ping: 0,
+                team: 0,
+            },
             ready: false,
             character: None,
         });
@@ -265,7 +269,7 @@ impl Game {
     pub fn set_players(&mut self, players: Vec<Player>) {
         self.players = players;
         for player in self.players.clone() {
-            self.run_deferred(move |s| s.signals().on_new_player().emit(player.id));
+            self.run_deferred(move |s| s.signals().on_new_player().emit(player.id()));
         }
     }
 
@@ -278,34 +282,34 @@ impl Game {
     }
 
     pub fn find_player(&self, player_id: u16) -> Option<&Player> {
-        self.players.iter().find(|p| p.id == player_id)
+        self.players.iter().find(|p| p.id() == player_id)
     }
 
     pub fn find_player_mut(&mut self, player_id: u16) -> Option<&mut Player> {
-        self.players.iter_mut().find(|p| p.id == player_id)
+        self.players.iter_mut().find(|p| p.id() == player_id)
     }
 
     pub fn remove_player(&mut self, id: u16) {
-        self.players.retain(|p| p.id != id);
+        self.players.retain(|p| p.id() != id);
         self.run_deferred(move |s| s.signals().on_player_disconnected().emit(id));
     }
 
     pub fn update_player_nick(&mut self, player_id: u16, nick: String) {
-        if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) {
-            player.name = nick;
+        if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
+            player.data.name = nick;
         }
         self.run_deferred(|s| s.signals().on_players_updated().emit());
     }
 
     pub fn update_player_ping(&mut self, player_id: u16, ping: u128) {
-        if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) {
-            player.ping = ping;
+        if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
+            player.data.ping = ping;
         }
         self.run_deferred(|s| s.signals().on_players_updated().emit());
     }
 
     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) {
+        if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
             player.ready = ready;
         }
         self.run_deferred(|s| s.signals().on_players_updated().emit());
@@ -319,7 +323,7 @@ impl Game {
             } else {
                 self.run_deferred(|s| {
                     for player in s.players.clone() {
-                        s.spawn_player_server(player.id);
+                        s.spawn_player_server(player.id());
                     }
                     s.spawn_ball(None, None, None);
                 });
@@ -396,7 +400,7 @@ impl Game {
             && let Some(character) = &mut player.character
         {
             character.dyn_bind_mut().swap_weapon(weapon_type);
-            let player_id = player.id;
+            let player_id = player.id();
             self.run_deferred(move |_| {
                 if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
                     && let PeerKind::Server(peer, _) = peer
@@ -464,15 +468,15 @@ 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 let Some(map) = &mut self.current_map {
-            if let Some(player) = self.players.iter_mut().find(|p| p.id == id) {
+            if let Some(player) = self.players.iter_mut().find(|p| p.id() == id) {
                 if let Some(character) = &mut player.character {
                     // This is a respawn, delete old character
                     character.queue_free();
                 }
 
                 let character = map.bind_mut().spawn_player(
-                    player.id,
-                    player.id == self.self_id.unwrap_or(0),
+                    player.id(),
+                    player.id() == self.self_id.unwrap_or(0),
                     Some(transform),
                 );
                 player.character = character;
@@ -495,8 +499,8 @@ impl Game {
             },
         ) in sync_data
         {
-            if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) {
-                if player.id != self.self_id.unwrap_or(0) {
+            if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
+                if player.id() != self.self_id.unwrap_or(0) {
                     // Sync remote players always
                     player.set_transform(transform);
                     player.set_move_dir(movement_direction);
@@ -541,7 +545,7 @@ impl Game {
     ) -> bool {
         let self_id = self.self_id.clone().unwrap_or(0);
         if let Some(player) = self.find_player_mut(player_id) {
-            if player.id != self_id {
+            if player.id() != self_id {
                 player.try_shoot(to, transform, look_up, deal_damage)
             } else {
                 false
@@ -590,10 +594,8 @@ impl Game {
 
 #[derive(Clone, Debug)]
 pub struct Player {
-    pub id: u16,
     pub connection_addr: SocketAddr,
-    pub name: String,
-    pub ping: u128,
+    pub data: NetPlayer,
     pub ready: bool,
     pub character: Option<DynGd<CharacterBody3D, dyn IPlayer + 'static>>,
 }
@@ -688,6 +690,10 @@ impl Player {
             false
         }
     }
+
+    pub fn id(&self) -> u16 {
+        self.data.id
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -695,15 +701,14 @@ pub struct NetPlayer {
     pub id: u16,
     pub name: String,
     pub ping: u128,
+    pub team: u8,
 }
 
 impl From<NetPlayer> for Player {
     fn from(value: NetPlayer) -> Self {
         Player {
-            id: value.id,
             connection_addr: SocketAddr::from(([0, 0, 0, 0], 0)),
-            name: value.name,
-            ping: value.ping,
+            data: value,
             ready: false,
             character: None,
         }
@@ -712,10 +717,6 @@ impl From<NetPlayer> for Player {
 
 impl From<Player> for NetPlayer {
     fn from(value: Player) -> Self {
-        NetPlayer {
-            id: value.id,
-            name: value.name,
-            ping: value.ping,
-        }
+        value.data
     }
 }
diff --git a/rust/src/net/network_manager.rs b/rust/src/net/network_manager.rs
index 477ca36..229c2aa 100644
--- a/rust/src/net/network_manager.rs
+++ b/rust/src/net/network_manager.rs
@@ -90,8 +90,8 @@ impl INode for NetworkManager {
                                 .cloned();
                             if let Some(player) = player {
                                 game.bind_mut()
-                                    .update_player_ping(player.id, connection.ping.as_millis());
-                                pings.insert(player.id, connection.ping.as_millis());
+                                    .update_player_ping(player.id(), connection.ping.as_millis());
+                                pings.insert(player.id(), connection.ping.as_millis());
                             }
                         }
                     }
diff --git a/rust/src/net/protocol.rs b/rust/src/net/protocol.rs
index bd27ef3..0d48fce 100644
--- a/rust/src/net/protocol.rs
+++ b/rust/src/net/protocol.rs
@@ -212,7 +212,7 @@ impl NetworkManager {
                             let player_id = game
                                 .bind()
                                 .find_player_by_addr(&connection.address)
-                                .map(|p| p.id);
+                                .map(|p| p.id());
                             if let Some(player_id) = player_id {
                                 peer.broadcast_reliable(Package::PlayerLeft(
                                     game.bind().find_player(player_id).unwrap().clone().into(),
@@ -234,10 +234,10 @@ impl NetworkManager {
                                     game.bind().find_player_by_addr(&conn.address).cloned();
                                 if let Some(player) = player {
                                     peer.broadcast_reliable(Package::SetNick(
-                                        player.id,
+                                        player.id(),
                                         nick.clone(),
                                     ));
-                                    game.bind_mut().update_player_nick(player.id, nick);
+                                    game.bind_mut().update_player_nick(player.id(), nick);
                                 }
                             }
                         }
@@ -246,8 +246,11 @@ impl NetworkManager {
                                 let player =
                                     game.bind().find_player_by_addr(&conn.address).cloned();
                                 if let Some(player) = player {
-                                    game.bind_mut().update_player_ready(player.id, is_ready);
-                                    peer.broadcast_reliable(Package::SetReady(player.id, is_ready));
+                                    game.bind_mut().update_player_ready(player.id(), is_ready);
+                                    peer.broadcast_reliable(Package::SetReady(
+                                        player.id(),
+                                        is_ready,
+                                    ));
                                 }
                             }
                         }
@@ -257,7 +260,7 @@ impl NetworkManager {
                                     if let Some(transform) = player.get_transform() {
                                         peer.send_reliable(
                                             &conn.address,
-                                            Package::SpawnPlayer(player.id, transform),
+                                            Package::SpawnPlayer(player.id(), transform),
                                         );
                                     }
                                 }
@@ -277,8 +280,8 @@ impl NetworkManager {
                                 let player =
                                     game.bind().find_player_by_addr(&conn.address).cloned();
                                 if let Some(player) = player {
-                                    game.bind_mut().handle_jump(player.id);
-                                    peer.broadcast_reliable(Package::Jump(player.id));
+                                    game.bind_mut().handle_jump(player.id());
+                                    peer.broadcast_reliable(Package::Jump(player.id()));
                                 }
                             }
                         }
@@ -288,14 +291,17 @@ impl NetworkManager {
                                     game.bind().find_player_by_addr(&conn.address).cloned();
                                 if let Some(player) = player {
                                     if game.bind_mut().handle_shoot(
-                                        player.id,
+                                        player.id(),
                                         to.into(),
                                         transform,
                                         look_up,
                                         true,
                                     ) {
                                         peer.broadcast_reliable(Package::Shoot(
-                                            player.id, to, transform, look_up,
+                                            player.id(),
+                                            to,
+                                            transform,
+                                            look_up,
                                         ));
                                     }
                                 }
diff --git a/rust/src/ui/lobby.rs b/rust/src/ui/lobby.rs
index ef0e3c1..50908fb 100644
--- a/rust/src/ui/lobby.rs
+++ b/rust/src/ui/lobby.rs
@@ -143,7 +143,7 @@ impl LobbyPanel {
                         for player in &game.bind().players {
                             if let Some(node) = prefab.instantiate() {
                                 let mut listing = node.cast::<PlayerListing>();
-                                listing.bind_mut().player_id = Some(player.id);
+                                listing.bind_mut().player_id = Some(player.id());
                                 listing.bind_mut().update_teams(game.bind().get_teams());
                                 listing.bind_mut().update();
                                 list.add_child(&listing);
diff --git a/rust/src/ui/player_listing.rs b/rust/src/ui/player_listing.rs
index 59397ef..f6f1506 100644
--- a/rust/src/ui/player_listing.rs
+++ b/rust/src/ui/player_listing.rs
@@ -29,7 +29,10 @@ impl PlayerListing {
             && let Some(player) = game.bind().find_player(*player_id)
         {
             if let Some(player_label) = &mut self.name_label {
-                player_label.set_text(&format!("{} ({})", player.name, player.connection_addr));
+                player_label.set_text(&format!(
+                    "{} ({})",
+                    player.data.name, player.connection_addr
+                ));
             }
 
             if let Some(ready_label) = &mut self.ready_label {
@@ -41,7 +44,7 @@ impl PlayerListing {
             }
 
             if let Some(ping_label) = &mut self.ping_label {
-                ping_label.set_text(&format!("({}ms)", player.ping));
+                ping_label.set_text(&format!("({}ms)", player.data.ping));
             }
         }
     }
@@ -53,7 +56,13 @@ impl PlayerListing {
             for team in teams.iter_shared() {
                 dropdown.add_item(&team.bind().name);
             }
-            dropdown.select(prev_selection);
+            dropdown.select(prev_selection.min((teams.len() - 1) as i32));
+        }
+    }
+
+    pub fn select_team(&mut self, team: u8) {
+        if let Some(dropdown) = &mut self.team_dropdown {
+            dropdown.select(team as i32);
         }
     }
 }