refactor: move game snapshot logic

Author: jacobtread

src/routes/games.rs

@@ -2,7 +2,7 @@ use crate::{
     config::Config,
     database::entities::players::PlayerRole,
     middleware::auth::MaybeAuth,
-    services::game::{store::Games, GameSnapshot},
+    services::game::{snapshot::GameSnapshot, store::Games},
     utils::types::GameID,
 };
 use axum::{
@@ -110,7 +110,7 @@ pub async fn get_game(
     let include_players = auth.is_some() || !config.api.public_games_hide_players;
 
     let game = games.get_by_id(game_id).ok_or(GamesError::NotFound)?;
-    let snapshot = game.read().snapshot(include_net, include_players);
+    let snapshot = GameSnapshot::new(&game.read(), include_net, include_players);
 
     Ok(Json(snapshot))
 }

src/services/game/mod.rs

@@ -27,7 +27,6 @@ use crate::{
 use chrono::{DateTime, Utc};
 use log::{debug, warn};
 use parking_lot::RwLock;
-use serde::Serialize;
 use std::sync::{Arc, Weak};
 use store::Games;
 use tdf::{ObjectId, TdfMap, TdfSerializer};
@@ -36,6 +35,7 @@ use super::tunnel::TunnelService;
 
 pub mod matchmaking;
 pub mod rules;
+pub mod snapshot;
 pub mod store;
 
 pub type GameRef = Arc<RwLock<Game>>;
@@ -101,25 +101,6 @@ pub struct Game {
     pub tunnel_service: Arc<TunnelService>,
 }
 
-/// Snapshot of the current game state and players
-#[derive(Serialize)]
-pub struct GameSnapshot {
-    /// The ID of the game the snapshot is for
-    pub id: GameID,
-    /// The current game state
-    pub state: GameState,
-    /// The current game setting
-    pub setting: u16,
-    /// The game attributes
-    pub attributes: AttrMap,
-    /// Snapshots of the game players
-    pub players: Option<Box<[GamePlayerSnapshot]>>,
-    /// The total number of players in the game
-    pub total_players: usize,
-    /// When the game was created
-    pub created_at: DateTime<Utc>,
-}
-
 /// Attributes map type
 pub type AttrMap = TdfMap<String, String>;
 
@@ -134,18 +115,6 @@ pub struct GamePlayer {
     pub state: PlayerState,
 }
 
-/// Structure for taking a snapshot of the players current
-/// state.
-#[derive(Serialize)]
-pub struct GamePlayerSnapshot {
-    /// The player ID of the snapshot
-    pub player_id: PlayerID,
-    /// The player name of the snapshot
-    pub display_name: Box<str>,
-    /// The player net data of the snapshot if collected
-    pub net: Option<Arc<NetData>>,
-}
-
 impl GamePlayer {
     /// Creates a new game player structure with the provided player
     /// details
@@ -202,16 +171,6 @@ impl GamePlayer {
         session.tx.notify(packet)
     }
 
-    /// Takes a snapshot of the current player state
-    /// for serialization
-    pub fn snapshot(&self, include_net: bool) -> GamePlayerSnapshot {
-        GamePlayerSnapshot {
-            player_id: self.player.id,
-            display_name: Box::from(self.player.display_name.as_ref()),
-            net: if include_net { self.net() } else { None },
-        }
-    }
-
     pub fn encode<S: TdfSerializer>(&self, game_id: GameID, slot: usize, w: &mut S) {
         w.group_body(|w| {
             // Custom data
@@ -467,30 +426,6 @@ impl Game {
         GameJoinableState::Joinable
     }
 
-    pub fn snapshot(&self, include_net: bool, include_players: bool) -> GameSnapshot {
-        let total_players: usize = self.players.len();
-        let players = if include_players {
-            let players = self
-                .players
-                .iter()
-                .map(|value| value.snapshot(include_net))
-                .collect();
-            Some(players)
-        } else {
-            None
-        };
-
-        GameSnapshot {
-            id: self.id,
-            state: self.state,
-            setting: self.settings.bits(),
-            attributes: self.attributes.clone(),
-            players,
-            total_players,
-            created_at: self.created_at,
-        }
-    }
-
     /// Writes the provided packet to all connected sessions.
     /// Does not wait for the write to complete just waits for
     /// it to be placed into each sessions write buffers.

src/services/game/snapshot.rs

@@ -0,0 +1,78 @@
+use std::sync::Arc;
+
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+
+use crate::{
+    session::{data::NetData, models::game_manager::GameState},
+    utils::types::{GameID, PlayerID},
+};
+
+use super::{AttrMap, Game, GamePlayer};
+
+/// Snapshot of the current game state and players
+#[derive(Serialize)]
+pub struct GameSnapshot {
+    /// The ID of the game the snapshot is for
+    pub id: GameID,
+    /// The current game state
+    pub state: GameState,
+    /// The current game setting
+    pub setting: u16,
+    /// The game attributes
+    pub attributes: AttrMap,
+    /// Snapshots of the game players
+    pub players: Option<Box<[GamePlayerSnapshot]>>,
+    /// The total number of players in the game
+    pub total_players: usize,
+    /// When the game was created
+    pub created_at: DateTime<Utc>,
+}
+
+impl GameSnapshot {
+    pub fn new(game: &Game, include_net: bool, include_players: bool) -> Self {
+        let total_players: usize = game.players.len();
+        let players = if include_players {
+            let players = game
+                .players
+                .iter()
+                .map(|value| GamePlayerSnapshot::new(value, include_net))
+                .collect();
+            Some(players)
+        } else {
+            None
+        };
+
+        Self {
+            id: game.id,
+            state: game.state,
+            setting: game.settings.bits(),
+            attributes: game.attributes.clone(),
+            players,
+            total_players,
+            created_at: game.created_at,
+        }
+    }
+}
+
+/// Structure for taking a snapshot of the players current
+/// state.
+#[derive(Serialize)]
+pub struct GamePlayerSnapshot {
+    /// The player ID of the snapshot
+    pub player_id: PlayerID,
+    /// The player name of the snapshot
+    pub display_name: Box<str>,
+    /// The player net data of the snapshot if collected
+    pub net: Option<Arc<NetData>>,
+}
+
+impl GamePlayerSnapshot {
+    pub fn new(player: &GamePlayer, include_net: bool) -> Self {
+        Self {
+            player_id: player.player.id,
+            display_name: Box::from(player.player.display_name.as_ref()),
+            net: if include_net { player.net() } else { None },
+        }
+    }
+}

src/services/game/store.rs

@@ -1,4 +1,4 @@
-use super::{rules::RuleSet, Game, GameJoinableState, GameRef, GameSnapshot};
+use super::{rules::RuleSet, snapshot::GameSnapshot, Game, GameJoinableState, GameRef};
 use crate::utils::{hashing::IntHashMap, types::GameID};
 use parking_lot::RwLock;
 use std::sync::{
@@ -87,7 +87,7 @@ impl Games {
             // Iterate over the game links
             .map(|(_, value)| value.clone())
             // Spawn the snapshot tasks
-            .map(|game| game.read().snapshot(include_net, include_players))
+            .map(|game| GameSnapshot::new(&game.read(), include_net, include_players))
             .collect();
 
         (snapshots, more)