Adding update methods to the map

src/main.rs

@@ -6,6 +6,7 @@ mod io;
 mod map;
 mod stats;
 mod wire;
+mod server;
 
 use ggez::{
     self, conf,

src/map.rs

@@ -1,6 +1,10 @@
 //! Implements a map graph and world logic
 
-use crate::data::{Link, Node};
+use crate::{
+    data::{Link, Node},
+    server::{Result, ServerErr},
+    wire::Response
+};
 use async_std::sync::Arc;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -11,7 +15,7 @@ use std::collections::BTreeMap;
 /// the map nodes are placed, how much spacing there is, etc.  All
 /// this information is encoded in the same structs because it's
 /// static, and just more convenient.
-#[derive(Serialize, Deserialize)]
+#[derive(Default, Serialize, Deserialize)]
 pub struct Map {
     /// Node IDs mapped to node objects
     nodes: BTreeMap<u16, Arc<Node>>,
@@ -19,4 +23,15 @@ pub struct Map {
     links: BTreeMap<u16, Arc<Link>>,
 }
 
-impl Map {}
+impl Map {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self::default())
+    }
+
+    pub fn update<F>(&mut self, cb: F) -> Result<Response>
+    where
+        F: Fn(&mut Map) -> Result<Response>,
+    {
+        unimplemented!()
+    }
+}

src/wire/mod.rs

@@ -1,9 +1,16 @@
 //! Network formats and container messages
 
 mod action;
+pub use action::*;
+
 mod req;
+pub use req::*;
+
 mod resp;
+pub use resp::*;
+
 mod update;
+pub use update::*;
 
 use crate::{
     data::{Color, Player},
@@ -27,7 +34,7 @@ pub struct User {
 
 /// A more lobby specific abstraction for a user
 #[derive(Serialize, Deserialize)]
-struct LobbyUser {
+pub struct LobbyUser {
     /// The user ID
     id: UserId,
     /// Their nick name
@@ -45,13 +52,13 @@ pub type LobbyId = usize;
 #[derive(Serialize, Deserialize)]
 pub struct Lobby {
     /// The ID of the lobby
-    id: LobbyId,
+    pub id: LobbyId,
     /// A set of user IDs
-    players: Vec<LobbyUser>,
+    pub players: Vec<LobbyUser>,
     /// The name of the map
-    map: String,
+    pub map: String,
     /// Settings
-    settings: Vec<String>,
+    pub settings: Vec<String>,
 }
 
 /// An alias for a match ID
@@ -60,16 +67,16 @@ pub type MatchId = usize;
 /// Mapping users to a player in game
 #[derive(Serialize, Deserialize)]
 pub struct MatchUser {
-    user: User,
-    player: Player,
+    pub user: User,
+    pub player: Player,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Match {
     /// The match id
-    id: MatchId,
+    pub id: MatchId,
     /// The list of active players
-    players: Vec<MatchUser>,
+    pub players: Vec<MatchUser>,
     /// The active game map
-    map: Map,
+    pub map: Map,
 }

src/wire/update.rs

@@ -1,6 +1,7 @@
 //! Update to the game state
 
 use super::UserId;
+use crate::data::{NodeId, PacketId, Player, Upgrade};
 use serde::{Deserialize, Serialize};
 
 /// An update provided by the game server
@@ -20,15 +21,34 @@ pub enum Update {
 
 /// Update made to a node
 #[derive(Serialize, Deserialize)]
-pub enum NodeUpdate {}
+pub enum NodeUpdate {
+    /// The node owner changed
+    Owner(Player),
+    /// Represent a new upgrade state
+    Level { node: NodeId, new: Upgrade },
+    /// A new packet was consumed from a link
+    NewPacket(PacketId),
+    /// Remove a packet from the node buffer
+    SentPacket(PacketId),
+    /// Dropped a packet
+    DropPacket(PacketId),
+}
 
 /// Update made to a link
 #[derive(Serialize, Deserialize)]
-pub enum LinkUpdate {}
+pub enum LinkUpdate {
+    /// Take a packet from a node's buffer
+    TakePacket(PacketId),
+    /// Give a packet to a node's buffer
+    GivePacket(PacketId),
+}
 
 /// Update made to a packet
 #[derive(Serialize, Deserialize)]
-pub enum PacketUpdate {}
+pub enum PacketUpdate {
+    /// Advance a packet along one step along the link
+    Increment(PacketId),
+}
 
 /// Update made to the user set
 #[derive(Serialize, Deserialize)]
@@ -41,4 +61,12 @@ pub enum UserUpdate {
 pub enum UpdateError {
     /// You are the last user in the match
     LastUser,
+    /// The game crashed, so kick all
+    GameCrashed,
+    /// The server's time was behind the client time
+    ///
+    /// This means that newer events will be dropped from the map
+    /// state.  This should prompt the client to warn the user this
+    /// has happened, then resync the time of the game states.
+    TimeAheadServer,
 }