Move message processing and chat bubbles to the client

server/src/events/mod.rs

@@ -1,5 +1,8 @@
-use crate::Server;
-use common::event::{EventBus, ServerEvent};
+use crate::{state_ext::StateExt, Server};
+use common::{
+    event::{EventBus, ServerEvent},
+    msg::ServerMsg,
+};
 use entity_creation::{
     handle_create_npc, handle_create_waypoint, handle_initialize_character,
     handle_loaded_character_data, handle_shoot,
@@ -103,6 +106,10 @@ impl Server {
                 ServerEvent::ChatCmd(entity, cmd) => {
                     chat_commands.push((entity, cmd));
                 },
+                ServerEvent::Chat(msg) => {
+                    self.state
+                        .notify_registered_clients(ServerMsg::ChatMsg(msg));
+                },
             }
         }
 

server/src/lib.rs

@@ -114,8 +114,8 @@ impl Server {
         state.ecs_mut().insert(sys::TerrainSyncTimer::default());
         state.ecs_mut().insert(sys::TerrainTimer::default());
         state.ecs_mut().insert(sys::WaypointTimer::default());
-        state.ecs_mut().insert(sys::SpeechBubbleTimer::default());
         state.ecs_mut().insert(sys::PersistenceTimer::default());
+        //state.ecs_mut().insert(sys::StatsPersistenceTimer::default());
 
         // System schedulers to control execution of systems
         state

server/src/sys/message.rs

@@ -464,7 +464,8 @@ impl<'a> System<'a> for Sys {
                             server_emitter.emit(ServerEvent::ChatCmd(entity, argv));
                         }
                     } else {
-                        // TODO FIXME speech bubbles and prefixes are handled by the client now
+                        // Send speech bubble and chat message
+                        // TODO filter group, faction, say, and bubble distance.
                         for client in (&mut clients).join().filter(|c| c.is_registered()) {
                             client.notify(ServerMsg::ChatMsg(msg.clone()));
                         }

server/src/sys/mod.rs

@@ -2,7 +2,6 @@ pub mod entity_sync;
 pub mod message;
 pub mod persistence;
 pub mod sentinel;
-pub mod speech_bubble;
 pub mod subscription;
 pub mod terrain;
 pub mod terrain_sync;
@@ -21,9 +20,10 @@ pub type SubscriptionTimer = SysTimer<subscription::Sys>;
 pub type TerrainTimer = SysTimer<terrain::Sys>;
 pub type TerrainSyncTimer = SysTimer<terrain_sync::Sys>;
 pub type WaypointTimer = SysTimer<waypoint::Sys>;
-pub type SpeechBubbleTimer = SysTimer<speech_bubble::Sys>;
 pub type PersistenceTimer = SysTimer<persistence::Sys>;
 pub type PersistenceScheduler = SysScheduler<persistence::Sys>;
+//pub type StatsPersistenceTimer = SysTimer<persistence::stats::Sys>;
+//pub type StatsPersistenceScheduler = SysScheduler<persistence::stats::Sys>;
 
 // System names
 // Note: commented names may be useful in the future
@@ -33,14 +33,14 @@ pub type PersistenceScheduler = SysScheduler<persistence::Sys>;
 //const TERRAIN_SYNC_SYS: &str = "server_terrain_sync_sys";
 const TERRAIN_SYS: &str = "server_terrain_sys";
 const WAYPOINT_SYS: &str = "waypoint_sys";
-const SPEECH_BUBBLE_SYS: &str = "speech_bubble_sys";
 const PERSISTENCE_SYS: &str = "persistence_sys";
+//const STATS_PERSISTENCE_SYS: &str = "stats_persistence_sys";
 
 pub fn add_server_systems(dispatch_builder: &mut DispatcherBuilder) {
     dispatch_builder.add(terrain::Sys, TERRAIN_SYS, &[]);
     dispatch_builder.add(waypoint::Sys, WAYPOINT_SYS, &[]);
-    dispatch_builder.add(speech_bubble::Sys, SPEECH_BUBBLE_SYS, &[]);
     dispatch_builder.add(persistence::Sys, PERSISTENCE_SYS, &[]);
+    //dispatch_builder.add(persistence::stats::Sys, STATS_PERSISTENCE_SYS, &[]);
 }
 
 pub fn run_sync_systems(ecs: &mut specs::World) {

server/src/sys/sentinel.rs

@@ -2,7 +2,7 @@ use super::SysTimer;
 use common::{
     comp::{
         Body, CanBuild, CharacterState, Collider, Energy, Gravity, Item, LightEmitter, Loadout,
-        Mass, MountState, Mounting, Ori, Player, Pos, Scale, SpeechBubble, Stats, Sticky, Vel,
+        Mass, MountState, Mounting, Ori, Player, Pos, Scale, Stats, Sticky, Vel,
     },
     msg::EcsCompPacket,
     sync::{CompSyncPackage, EntityPackage, EntitySyncPackage, Uid, UpdateTracker, WorldSyncExt},
@@ -54,7 +54,6 @@ pub struct TrackedComps<'a> {
     pub gravity: ReadStorage<'a, Gravity>,
     pub loadout: ReadStorage<'a, Loadout>,
     pub character_state: ReadStorage<'a, CharacterState>,
-    pub speech_bubble: ReadStorage<'a, SpeechBubble>,
 }
 impl<'a> TrackedComps<'a> {
     pub fn create_entity_package(
@@ -126,10 +125,6 @@ impl<'a> TrackedComps<'a> {
             .get(entity)
             .cloned()
             .map(|c| comps.push(c.into()));
-        self.speech_bubble
-            .get(entity)
-            .cloned()
-            .map(|c| comps.push(c.into()));
         // Add untracked comps
         pos.map(|c| comps.push(c.into()));
         vel.map(|c| comps.push(c.into()));
@@ -157,7 +152,6 @@ pub struct ReadTrackers<'a> {
     pub gravity: ReadExpect<'a, UpdateTracker<Gravity>>,
     pub loadout: ReadExpect<'a, UpdateTracker<Loadout>>,
     pub character_state: ReadExpect<'a, UpdateTracker<CharacterState>>,
-    pub speech_bubble: ReadExpect<'a, UpdateTracker<SpeechBubble>>,
 }
 impl<'a> ReadTrackers<'a> {
     pub fn create_sync_packages(
@@ -194,12 +188,6 @@ impl<'a> ReadTrackers<'a> {
                 &*self.character_state,
                 &comps.character_state,
                 filter,
-            )
-            .with_component(
-                &comps.uid,
-                &*self.speech_bubble,
-                &comps.speech_bubble,
-                filter,
             );
 
         (entity_sync_package, comp_sync_package)
@@ -225,7 +213,6 @@ pub struct WriteTrackers<'a> {
     gravity: WriteExpect<'a, UpdateTracker<Gravity>>,
     loadout: WriteExpect<'a, UpdateTracker<Loadout>>,
     character_state: WriteExpect<'a, UpdateTracker<CharacterState>>,
-    speech_bubble: WriteExpect<'a, UpdateTracker<SpeechBubble>>,
 }
 
 fn record_changes(comps: &TrackedComps, trackers: &mut WriteTrackers) {
@@ -249,7 +236,6 @@ fn record_changes(comps: &TrackedComps, trackers: &mut WriteTrackers) {
     trackers
         .character_state
         .record_changes(&comps.character_state);
-    trackers.speech_bubble.record_changes(&comps.speech_bubble);
 }
 
 pub fn register_trackers(world: &mut World) {
@@ -270,7 +256,6 @@ pub fn register_trackers(world: &mut World) {
     world.register_tracker::<Gravity>();
     world.register_tracker::<Loadout>();
     world.register_tracker::<CharacterState>();
-    world.register_tracker::<SpeechBubble>();
 }
 
 /// Deleted entities grouped by region

server/src/sys/speech_bubble.rs

@@ -1,29 +0,0 @@
-use super::SysTimer;
-use common::{comp::SpeechBubble, state::Time};
-use specs::{Entities, Join, Read, System, Write, WriteStorage};
-
-/// This system removes timed-out speech bubbles
-pub struct Sys;
-impl<'a> System<'a> for Sys {
-    type SystemData = (
-        Entities<'a>,
-        Read<'a, Time>,
-        WriteStorage<'a, SpeechBubble>,
-        Write<'a, SysTimer<Self>>,
-    );
-
-    fn run(&mut self, (entities, time, mut speech_bubbles, mut timer): Self::SystemData) {
-        timer.start();
-
-        let expired_ents: Vec<_> = (&entities, &mut speech_bubbles)
-            .join()
-            .filter(|(_, speech_bubble)| speech_bubble.timeout.map_or(true, |t| t.0 < time.0))
-            .map(|(ent, _)| ent)
-            .collect();
-        for ent in expired_ents {
-            speech_bubbles.remove(ent);
-        }
-
-        timer.end();
-    }
-}