Redesigned Game, Arena, Frame messages

docs/design/common.md

@@ -0,0 +1,11 @@
+# Common
+
+## Log levels
+From high to low importance:
+
+- `error`: Some problem happened. The game experience could be affected.
+- `warning`: Some unexpected thing happened. The game will not be affected.
+- `info`: Relative inportant event that should be notified.
+- `debug`: Debugging purpose (used for debug something).
+- `trace`: Not inportant information that notifies that the code performs some expected thing.
+- `dev`: Enabled the internal thirdparties logs.

src/client/server_proxy.rs

@@ -1,5 +1,5 @@
-pub use crate::message::{LoginStatus, ServerInfo};
-use crate::message::{ClientMessage, ServerMessage, LoggedKind, EntityData};
+use crate::message::{LoginStatus, ServerInfo, ClientMessage, ServerMessage,
+    LoggedKind, GameInfo, ArenaInfo, Frame};
 use crate::version::{self, Compatibility};
 use crate::util::{self};
 
@@ -39,12 +39,12 @@ pub enum ServerEvent {
     PlayerListUpdated(Vec<char>),
     LoginStatus(LoginStatus),
     UdpReachable(bool),
-    StartGame,
+    StartGame(GameInfo),
     FinishGame,
     WaitArena(Duration),
-    StartArena(usize),
+    StartArena(ArenaInfo),
     FinishArena,
-    ArenaStep(Vec<EntityData>),
+    ArenaStep(Frame),
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -264,23 +264,23 @@ where C: Fn(ServerEvent) {
                     ServerMessage::UdpConnected => {
                         self.process_udp_connected();
                     },
-                    ServerMessage::StartGame => {
-                        self.process_start_game();
+                    ServerMessage::StartGame(game_info) => {
+                        self.process_start_game(game_info);
                     },
                     ServerMessage::FinishGame => {
                         self.process_finish_game();
                     },
                     ServerMessage::WaitArena(duration) => {
                         self.process_wait_arena(duration);
                     },
-                    ServerMessage::StartArena(number) => {
-                        self.process_start_arena(number);
+                    ServerMessage::StartArena(arena_info) => {
+                        self.process_start_arena(arena_info);
                     },
                     ServerMessage::FinishArena => {
                         self.process_finish_arena();
                     },
-                    ServerMessage::Step(entities) => {
-                        self.process_arena_step(entities);
+                    ServerMessage::Step(frame) => {
+                        self.process_arena_step(frame);
                     },
                 },
                 NetEvent::AddedEndpoint(_) => unreachable!(),
@@ -320,7 +320,7 @@ where C: Fn(ServerEvent) {
     }
 
     fn process_dynamic_server_info(&mut self, players: Vec<char>) {
-        log::info!("Player list updated: {}", util::format::character_list(&players));
+        log::info!("Player list updated: {}", util::format::symbol_list(&players));
         (self.event_callback)(ServerEvent::PlayerListUpdated(players));
     }
 
@@ -383,9 +383,9 @@ where C: Fn(ServerEvent) {
         (self.event_callback)(ServerEvent::UdpReachable(true));
     }
 
-    fn process_start_game(&mut self) {
+    fn process_start_game(&mut self, game_info: GameInfo) {
         log::info!("Start game");
-        (self.event_callback)(ServerEvent::StartGame);
+        (self.event_callback)(ServerEvent::StartGame(game_info));
     }
 
     fn process_finish_game(&mut self) {
@@ -399,19 +399,19 @@ where C: Fn(ServerEvent) {
         (self.event_callback)(ServerEvent::WaitArena(duration));
     }
 
-    fn process_start_arena(&mut self, number: usize) {
+    fn process_start_arena(&mut self, arena_info: ArenaInfo) {
         log::info!("Start arena");
-        (self.event_callback)(ServerEvent::StartArena(number));
+        (self.event_callback)(ServerEvent::StartArena(arena_info));
     }
 
     fn process_finish_arena(&mut self) {
         log::info!("Finish arena");
         (self.event_callback)(ServerEvent::FinishArena);
     }
 
-    fn process_arena_step(&mut self, entities: Vec<EntityData>) {
+    fn process_arena_step(&mut self, frame: Frame) {
         log::info!("Process arena step");
-        (self.event_callback)(ServerEvent::ArenaStep(entities));
+        (self.event_callback)(ServerEvent::ArenaStep(frame));
     }
 }
 

src/client/state.rs

@@ -1,11 +1,15 @@
-use crate::version::{Compatibility};
-use crate::message::{LoginStatus, EntityData};
-
 use super::server_proxy::{ConnectionStatus};
 use super::configuration::{Config};
 
+use crate::version::{Compatibility};
+use crate::message::{LoginStatus, EntityData};
+use crate::character::{CharacterId, Character};
+
 use std::net::{SocketAddr};
 use std::time::{Instant};
+use std::collections::{HashMap};
+
+pub type EntityId = usize;
 
 pub struct User {
     pub character: Option<char>,
@@ -40,7 +44,7 @@ pub enum ArenaStatus {
 
 pub struct Arena {
     pub status: ArenaStatus,
-    pub entities: Vec<EntityData>,
+    pub entities: HashMap<EntityId, EntityData>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -55,6 +59,8 @@ pub struct Game {
     pub next_arena_timestamp: Option<Instant>,
     pub arena_number: usize,
     pub arena: Option<Arena>,
+    pub characters: HashMap<CharacterId, Character>,
+    pub players: HashMap<CharacterId, Option<EntityId>>,
 }
 
 impl Game {
@@ -128,6 +134,8 @@ impl State {
                     arena_number: 0,
                     next_arena_timestamp: None,
                     arena: None,
+                    characters: HashMap::new(),
+                    players: HashMap::new()
                 },
             },
         }

src/client/store.rs

@@ -5,6 +5,7 @@ use crate::version::{self};
 
 use std::net::{SocketAddr};
 use std::time::{Instant};
+use std::collections::{HashMap};
 
 /// Action API
 #[derive(Debug)]
@@ -135,8 +136,12 @@ impl Store {
                     self.state.server.udp_confirmed = Some(value);
                 },
 
-                ServerEvent::StartGame => {
+                ServerEvent::StartGame(game_info) => {
                     self.state.server.game.status = GameStatus::Started;
+                    self.state.server.game.characters = game_info.characters
+                        .into_iter()
+                        .map(|character| (character.id(), character))
+                        .collect();
                 },
 
                 ServerEvent::FinishGame => {
@@ -152,22 +157,39 @@ impl Store {
                     );
                 },
 
-                ServerEvent::StartArena(number) => {
+                ServerEvent::StartArena(arena_info) => {
                     self.state.server.game.next_arena_timestamp = None;
-                    self.state.server.game.arena_number = number;
+                    self.state.server.game.arena_number = arena_info.number;
+                    self.state.server.game.players = arena_info.players
+                        .into_iter()
+                        .collect();
+
                     self.state.server.game.arena = Some(Arena {
                         status: ArenaStatus::Playing,
-                        entities: Vec::new(),
+                        entities: HashMap::new(),
                     });
                 },
 
                 ServerEvent::FinishArena => {
-                    let arena = self.state.server.game.arena.as_mut().unwrap();
-                    arena.status = ArenaStatus::Finished;
+                    self.state.server.game.arena_mut().status = ArenaStatus::Finished;
                 },
 
-                ServerEvent::ArenaStep(entities) => {
-                    self.state.server.game.arena_mut().entities = entities
+                ServerEvent::ArenaStep(frame) => {
+                    let entities_map = frame.entities
+                        .into_iter()
+                        .map(|entity| (entity.id, entity))
+                        .collect::<HashMap<_, _>>();
+
+                    // If the entity no longer exists, remove it from players
+                    for (_, mut possible_entity_id) in &mut self.state.server.game.players {
+                        if let Some(id) = &mut possible_entity_id {
+                            if !entities_map.contains_key(&id) {
+                                *possible_entity_id = None;
+                            }
+                        }
+                    }
+
+                    self.state.server.game.arena_mut().entities = entities_map;
                 },
             },
         }

src/client/terminal/renderer.rs

@@ -20,7 +20,7 @@ impl Renderer {
         io::stdout().execute(terminal::EnterAlternateScreen).unwrap();
 
         Renderer {
-            terminal: Terminal::new(CrosstermBackend::new(io::stdout())).unwrap();
+            terminal: Terminal::new(CrosstermBackend::new(io::stdout())).unwrap()
         }
     }
 

src/main.rs

@@ -4,7 +4,7 @@ extern crate derive_new;
 #[macro_use]
 extern crate derive_builder;
 
-//mod client;
+mod client;
 mod server;
 
 mod logger;
@@ -23,12 +23,12 @@ fn main() {
         .author(clap::crate_authors!())
         .about(clap::crate_description!())
         .setting(AppSettings::ArgRequiredElseHelp)
- //       .subcommand(client::configure_cli())
+        .subcommand(client::configure_cli())
         .subcommand(server::configure_cli())
         .get_matches();
 
     match matches.subcommand() {
- //       ("client", Some(matches)) => client::run(matches),
+        ("client", Some(matches)) => client::run(matches),
         ("server", Some(matches)) => server::run(matches),
         _ => unreachable!(),
     }

src/message.rs

@@ -1,5 +1,5 @@
 use crate::version::{Compatibility};
-use crate::character::{CharacterId};
+use crate::character::{CharacterId, Character};
 use crate::vec2::{Vec2};
 use crate::direction::{Direction};
 
@@ -50,20 +50,21 @@ pub enum ServerMessage {
     UdpConnected,
 
     // Game level messages
-    StartGame,
+    StartGame(GameInfo),
     FinishGame, //points
 
     // Arena level messages
     WaitArena(Duration),
-    StartArena(usize), // number
+    StartArena(ArenaInfo), // number
     FinishArena, // winners
-    Step(Vec<EntityData>), //arena state
+    Step(Frame), //arena state
 }
 
 // ===================================================
 //     Composable message pieces
 // ===================================================
 pub type SessionToken = usize;
+pub type EntityId = usize;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub enum LoggedKind {
@@ -90,9 +91,25 @@ pub struct ServerInfo {
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct EntityData {
-    pub id: usize,
+    pub id: EntityId,
     pub character_id: CharacterId,
     pub position: Vec2,
     pub live: usize,
     pub energy: usize,
 }
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct GameInfo {
+    pub characters: Vec<Character>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ArenaInfo {
+    pub number: usize,
+    pub players: Vec<(CharacterId, Option<EntityId>)>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Frame {
+    pub entities: Vec<EntityData>,
+}

src/server/game.rs

@@ -77,6 +77,10 @@ impl Game {
         self.arena.as_mut()
     }
 
+    pub fn characters(&self) -> &HashMap<CharacterId, Rc<Character>> {
+        &self.characters
+    }
+
     pub fn player(&self, character_symbol: char) -> Option<&Player> {
         self.players.get(&character_symbol)
     }
@@ -85,6 +89,10 @@ impl Game {
         self.players.get_mut(&character_symbol)
     }
 
+    pub fn players(&self) -> &HashMap<char, Player> {
+        &self.players
+    }
+
     pub fn arena_number(&self) -> usize {
         self.arena_number
     }

src/server/game/arena.rs

@@ -1,8 +1,9 @@
 use super::map::{Map};
-use super::entity::{Entity, EntityId};
+use super::entity::{Entity};
 use super::control::{EntityControl, EntityAction};
 
 use crate::character::{Character};
+use crate::message::{EntityId};
 use crate::vec2::Vec2;
 
 use std::collections::{HashMap};
@@ -32,8 +33,8 @@ impl Arena {
         &self.map
     }
 
-    pub fn entities(&self) -> impl Iterator<Item = &Entity> {
-        self.entities.values()
+    pub fn entities(&self) -> &HashMap<EntityId, Entity> {
+        &self.entities
     }
 
     pub fn create_entity(