refactor: move player networking obtain out of game player data

Author: jacobtread

src/services/game/mod.rs

@@ -13,6 +13,7 @@ use crate::{
                 RemoveReason, SettingChange, SlotType, StateChange, UNSPECIFIED_TEAM_INDEX,
             },
             util::LOCALE_NZ,
+            NetworkAddress,
         },
         packet::Packet,
         router::RawBlaze,
@@ -129,8 +130,6 @@ pub struct GamePlayer {
     pub player: Arc<Player>,
     /// Weak reference to the associated session
     pub link: WeakSessionLink,
-    /// Networking information for the player
-    pub net: Arc<NetData>,
     /// The mesh state of the player
     pub state: PlayerState,
 }
@@ -154,15 +153,26 @@ impl GamePlayer {
     /// `player` The session player
     /// `net`    The player networking details
     /// `addr`   The session address
-    pub fn new(player: Arc<Player>, net: Arc<NetData>, link: WeakSessionLink) -> Self {
+    pub fn new(player: Arc<Player>, link: WeakSessionLink) -> Self {
         Self {
             player,
             link,
-            net,
             state: PlayerState::ActiveConnecting,
         }
     }
 
+    pub fn net(&self) -> Option<Arc<NetData>> {
+        let session = self.link.upgrade()?;
+        session.data.net()
+    }
+
+    pub fn network_address(&self) -> NetworkAddress {
+        match self.net() {
+            Some(net) => net.addr.clone(),
+            None => NetworkAddress::Unset,
+        }
+    }
+
     pub fn try_clear_game(&self) {
         if let Some(link) = self.link.upgrade() {
             link.data.clear_game_gm();
@@ -198,11 +208,7 @@ impl GamePlayer {
         GamePlayerSnapshot {
             player_id: self.player.id,
             display_name: Box::from(self.player.display_name.as_ref()),
-            net: if include_net {
-                Some(self.net.clone())
-            } else {
-                None
-            },
+            net: if include_net { self.net() } else { None },
         }
     }
 
@@ -221,7 +227,7 @@ impl GamePlayer {
             // Player ID
             w.tag_u32(b"PID", self.player.id);
             // Player network data
-            w.tag_ref(b"PNET", &self.net.addr);
+            w.tag_ref(b"PNET", &self.network_address());
             // Slot ID
             w.tag_owned(b"SID", slot);
             // Slot type

src/session/data.rs

@@ -218,14 +218,6 @@ impl SessionData {
             .map(|value| value.player_assoc.player.clone())
     }
 
-    /// Obtains the parts required to create a game player
-    pub fn get_game_player_data(&self) -> Option<(Arc<Player>, Arc<NetData>)> {
-        self.read()
-            .auth
-            .as_ref()
-            .map(|value| (value.player_assoc.player.clone(), value.net.clone()))
-    }
-
     /// Updates the session hardware flags
     pub fn set_hardware_flags(&self, value: HardwareFlags) {
         self.write_publish(|data| data.net = Arc::new(data.net.with_hardware_flags(value)));
@@ -318,6 +310,12 @@ impl SessionData {
     pub fn remove_subscriber(&self, player_id: PlayerID) {
         self.write_silent(|data| data.remove_subscriber(player_id));
     }
+
+    pub fn net(&self) -> Option<Arc<NetData>> {
+        let ext = self.read();
+        let auth = ext.auth.as_ref()?;
+        Some(auth.net.clone())
+    }
 }
 
 /// Extended session data, present when the user is authenticated

src/session/models/game_manager.rs

@@ -804,9 +804,11 @@ impl TdfSerialize for GameSetupResponse<'_> {
             // Game Type used for game reporting as passed up in the request.
             w.tag_str_empty(b"GTYP");
 
+            let host_net = host.net().unwrap_or_default();
+
             // Whether to tunnel the connection
             let tunnel = match &self.config.tunnel {
-                TunnelConfig::Stricter => !matches!(host.net.qos.natt, NatType::Open),
+                TunnelConfig::Stricter => !matches!(host_net.qos.natt, NatType::Open),
                 TunnelConfig::Always => true,
                 TunnelConfig::Disabled => false,
             };
@@ -828,7 +830,7 @@ impl TdfSerialize for GameSetupResponse<'_> {
                     );
                 } else {
                     // Open NATs can directly have players connect normally
-                    if let NetworkAddress::AddressPair(pair) = &host.net.addr {
+                    if let NetworkAddress::AddressPair(pair) = &host_net.addr {
                         w.write_byte(2 /* Address pair type */);
                         TdfSerialize::serialize(pair, w)
                     } else {
@@ -847,7 +849,7 @@ impl TdfSerialize for GameSetupResponse<'_> {
             w.tag_usize(b"MCAP", Game::MAX_PLAYERS);
 
             // Host network qos data
-            w.tag_ref(b"NQOS", &host.net.qos);
+            w.tag_ref(b"NQOS", &host_net.qos);
 
             // Flag to indicate that this game is not resettable. This applies only to the CLIENT_SERVER_DEDICATED topology.
             // The game will be prevented from ever going into the RESETTABlE state.
@@ -952,9 +954,9 @@ impl TdfSerialize for GetGameDetails<'_> {
                 // Topology host network list (The heat bug is present so this encoded as a group even though its a union)
                 w.tag_list_start(b"HNET", TdfType::Group, 1);
 
-                if let NetworkAddress::AddressPair(pair) = &host.net.addr {
+                if let NetworkAddress::AddressPair(pair) = host.network_address() {
                     w.write_byte(2 /* Address pair type */);
-                    TdfSerialize::serialize(pair, w)
+                    TdfSerialize::serialize(&pair, w)
                 } else {
                     // Uh oh.. host networking is missing...?
                     w.write_byte(TAGGED_UNSET_KEY);

src/session/router.rs

@@ -226,17 +226,13 @@ impl FromPacketRequest for GamePlayer {
         Self: 'a,
     {
         Box::pin(async move {
-            let (player, net_data) = req
+            let player = req
                 .state
                 .data
-                .get_game_player_data()
+                .get_player()
                 .ok_or(GlobalError::AuthenticationRequired)?;
 
-            Ok(GamePlayer::new(
-                player,
-                net_data,
-                Arc::downgrade(&req.state),
-            ))
+            Ok(GamePlayer::new(player, Arc::downgrade(&req.state)))
         })
     }
 }

src/session/routes/game_manager.rs

@@ -536,8 +536,7 @@ pub async fn handle_cancel_matchmaking(
 
 /// Handles preparing a game for being replayed
 ///
-/// Occurs when a game is finished successfully, is not sent if a game
-/// is failed
+/// Occurs when a game finishes
 ///
 /// ```
 /// Route: GameManager(ReplayGame)