diff --git a/Cargo.lock b/Cargo.lock
index 0a4aa514c9..272df33c8d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3626,7 +3626,6 @@ dependencies = [
  "crossbeam 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "hashbrown 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "hibitset 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "indexmap 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "portpicker 0.1.0 (git+https://github.com/wusyong/portpicker-rs?branch=fix_ipv6)",
diff --git a/client/src/lib.rs b/client/src/lib.rs
index 73350e9bf2..1aeb7c7b31 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -8,7 +8,7 @@ pub use crate::error::Error;
 pub use specs::{join::Join, saveload::Marker, Entity as EcsEntity, ReadStorage};
 
 use common::{
-    comp,
+    comp::{self, ControlEvent, Controller, ControllerInputs, InventoryManip},
     msg::{
         validate_chat_msg, ChatMsgValidationError, ClientMsg, ClientState, RequestStateError,
         ServerError, ServerInfo, ServerMsg, MAX_BYTES_CHAT_MSG,
@@ -201,22 +201,33 @@ impl Client {
         // Can't fail
     }
 
-    pub fn use_inventory_slot(&mut self, x: usize) {
-        self.postbox.send_message(ClientMsg::UseInventorySlot(x))
+    pub fn use_inventory_slot(&mut self, slot: usize) {
+        self.postbox
+            .send_message(ClientMsg::ControlEvent(ControlEvent::InventoryManip(
+                InventoryManip::Use(slot),
+            )));
     }
 
     pub fn swap_inventory_slots(&mut self, a: usize, b: usize) {
         self.postbox
-            .send_message(ClientMsg::SwapInventorySlots(a, b))
+            .send_message(ClientMsg::ControlEvent(ControlEvent::InventoryManip(
+                InventoryManip::Swap(a, b),
+            )));
     }
 
-    pub fn drop_inventory_slot(&mut self, x: usize) {
-        self.postbox.send_message(ClientMsg::DropInventorySlot(x))
+    pub fn drop_inventory_slot(&mut self, slot: usize) {
+        self.postbox
+            .send_message(ClientMsg::ControlEvent(ControlEvent::InventoryManip(
+                InventoryManip::Drop(slot),
+            )));
     }
 
     pub fn pick_up(&mut self, entity: EcsEntity) {
         if let Some(uid) = self.state.ecs().read_storage::<Uid>().get(entity).copied() {
-            self.postbox.send_message(ClientMsg::PickUp(uid.id()));
+            self.postbox
+                .send_message(ClientMsg::ControlEvent(ControlEvent::InventoryManip(
+                    InventoryManip::Pickup(uid),
+                )));
         }
     }
 
@@ -228,6 +239,18 @@ impl Client {
             .is_some()
     }
 
+    pub fn mount(&mut self, entity: EcsEntity) {
+        if let Some(uid) = self.state.ecs().read_storage::<Uid>().get(entity).copied() {
+            self.postbox
+                .send_message(ClientMsg::ControlEvent(ControlEvent::Mount(uid)));
+        }
+    }
+
+    pub fn unmount(&mut self) {
+        self.postbox
+            .send_message(ClientMsg::ControlEvent(ControlEvent::Unmount));
+    }
+
     pub fn view_distance(&self) -> Option<u32> {
         self.view_distance
     }
@@ -283,16 +306,15 @@ impl Client {
     }
 
     pub fn collect_block(&mut self, pos: Vec3<i32>) {
-        self.postbox.send_message(ClientMsg::CollectBlock(pos));
+        self.postbox
+            .send_message(ClientMsg::ControlEvent(ControlEvent::InventoryManip(
+                InventoryManip::Collect(pos),
+            )));
     }
 
     /// Execute a single client tick, handle input and update the game state by the given duration.
     #[allow(dead_code)]
-    pub fn tick(
-        &mut self,
-        controller: comp::Controller,
-        dt: Duration,
-    ) -> Result<Vec<Event>, Error> {
+    pub fn tick(&mut self, inputs: ControllerInputs, dt: Duration) -> Result<Vec<Event>, Error> {
         // This tick function is the centre of the Veloren universe. Most client-side things are
         // managed from here, and as such it's important that it stays organised. Please consult
         // the core developers before making significant changes to this code. Here is the
@@ -310,8 +332,15 @@ impl Client {
         // 1) Handle input from frontend.
         // Pass character actions from frontend input to the player's entity.
         if let ClientState::Character | ClientState::Dead = self.client_state {
-            self.state.write_component(self.entity, controller.clone());
-            self.postbox.send_message(ClientMsg::Controller(controller));
+            self.state.write_component(
+                self.entity,
+                Controller {
+                    inputs: inputs.clone(),
+                    events: Vec::new(),
+                },
+            );
+            self.postbox
+                .send_message(ClientMsg::ControllerInputs(inputs));
         }
 
         // 2) Build up a list of events for this frame, to be passed to the frontend.
@@ -319,7 +348,7 @@ impl Client {
 
         // Prepare for new events
         {
-            let ecs = self.state.ecs_mut();
+            let ecs = self.state.ecs();
             for (entity, _) in (&ecs.entities(), &ecs.read_storage::<comp::Body>()).join() {
                 let mut last_character_states =
                     ecs.write_storage::<comp::Last<comp::CharacterState>>();
@@ -343,7 +372,7 @@ impl Client {
         // 3) Update client local data
 
         // 4) Tick the client's LocalState
-        self.state.tick(dt);
+        self.state.tick(dt, |_| {});
 
         // 5) Terrain
         let pos = self
diff --git a/common/src/comp/controller.rs b/common/src/comp/controller.rs
index 178e5a628e..79de5e1d8f 100644
--- a/common/src/comp/controller.rs
+++ b/common/src/comp/controller.rs
@@ -7,14 +7,14 @@ use vek::*;
 pub enum ControlEvent {
     Mount(Uid),
     Unmount,
+    InventoryManip(InventoryManip),
+    //Respawn,
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct Controller {
+pub struct ControllerInputs {
     pub primary: bool,
     pub secondary: bool,
-    pub move_dir: Vec2<f32>,
-    pub look_dir: Vec3<f32>,
     pub sit: bool,
     pub jump: bool,
     pub roll: bool,
@@ -23,6 +23,13 @@ pub struct Controller {
     pub climb_down: bool,
     pub wall_leap: bool,
     pub respawn: bool,
+    pub move_dir: Vec2<f32>,
+    pub look_dir: Vec3<f32>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct Controller {
+    pub inputs: ControllerInputs,
     pub events: Vec<ControlEvent>,
 }
 
@@ -60,3 +67,12 @@ pub struct Mounting(pub Uid);
 impl Component for Mounting {
     type Storage = FlaggedStorage<Self, IDVStorage<Self>>;
 }
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum InventoryManip {
+    Pickup(Uid),
+    Collect(Vec3<i32>),
+    Use(usize),
+    Swap(usize, usize),
+    Drop(usize),
+}
diff --git a/common/src/comp/mod.rs b/common/src/comp/mod.rs
index 438da87db6..5df88295b5 100644
--- a/common/src/comp/mod.rs
+++ b/common/src/comp/mod.rs
@@ -18,7 +18,9 @@ pub use admin::Admin;
 pub use agent::Agent;
 pub use body::{humanoid, object, quadruped, quadruped_medium, Body};
 pub use character_state::{ActionState, CharacterState, MovementState};
-pub use controller::{ControlEvent, Controller, MountState, Mounting};
+pub use controller::{
+    ControlEvent, Controller, ControllerInputs, InventoryManip, MountState, Mounting,
+};
 pub use inputs::CanBuild;
 pub use inventory::{item, Inventory, InventoryUpdate, Item};
 pub use last::Last;
diff --git a/common/src/event.rs b/common/src/event.rs
index b2c771ab8a..8bc938d5e0 100644
--- a/common/src/event.rs
+++ b/common/src/event.rs
@@ -30,6 +30,7 @@ pub enum ServerEvent {
         entity: EcsEntity,
         cause: comp::HealthSource,
     },
+    InventoryManip(EcsEntity, comp::InventoryManip),
     Respawn(EcsEntity),
     Shoot {
         entity: EcsEntity,
@@ -46,6 +47,15 @@ pub enum ServerEvent {
     Mount(EcsEntity, EcsEntity),
     Unmount(EcsEntity),
     Possess(Uid, Uid),
+    CreatePlayer {
+        entity: EcsEntity,
+        name: String,
+        body: comp::Body,
+        main: Option<comp::Item>,
+    },
+    ClientDisconnect(EcsEntity),
+    ChunkRequest(EcsEntity, Vec2<i32>),
+    ChatCmd(EcsEntity, String),
 }
 
 pub struct EventBus<E> {
diff --git a/common/src/msg/client.rs b/common/src/msg/client.rs
index 1e98732283..c699db93d1 100644
--- a/common/src/msg/client.rs
+++ b/common/src/msg/client.rs
@@ -14,12 +14,12 @@ pub enum ClientMsg {
         body: comp::Body,
         main: Option<comp::item::Tool>,
     },
-    Controller(comp::Controller),
+    ControllerInputs(comp::ControllerInputs),
+    ControlEvent(comp::ControlEvent),
     RequestState(ClientState),
     SetViewDistance(u32),
     BreakBlock(Vec3<i32>),
     PlaceBlock(Vec3<i32>, Block),
-    CollectBlock(Vec3<i32>),
     Ping,
     Pong,
     ChatMsg {
@@ -31,10 +31,6 @@ pub enum ClientMsg {
         vel: comp::Vel,
         ori: comp::Ori,
     },
-    UseInventorySlot(usize),
-    SwapInventorySlots(usize, usize),
-    DropInventorySlot(usize),
-    PickUp(u64),
     TerrainChunkRequest {
         key: Vec2<i32>,
     },
diff --git a/common/src/region.rs b/common/src/region.rs
index da8b2fa90a..1bbcc72eeb 100644
--- a/common/src/region.rs
+++ b/common/src/region.rs
@@ -195,9 +195,6 @@ impl RegionMap {
             }
         }
     }
-    pub fn add(&mut self, entity: EcsEntity, pos: Vec3<f32>) {
-        self.add_entity(entity.id(), pos.map(|e| e as i32), None);
-    }
     fn add_entity(&mut self, id: u32, pos: Vec3<i32>, from: Option<Vec2<i32>>) {
         let key = Self::pos_key(pos);
         if let Some(region) = self.regions.get_mut(&key) {
diff --git a/common/src/state.rs b/common/src/state.rs
index 0859323d4d..640b283520 100644
--- a/common/src/state.rs
+++ b/common/src/state.rs
@@ -309,7 +309,7 @@ impl State {
     }
 
     /// Execute a single tick, simulating the game state by the given duration.
-    pub fn tick(&mut self, dt: Duration) {
+    pub fn tick(&mut self, dt: Duration, add_foreign_systems: impl Fn(&mut DispatcherBuilder)) {
         // Change the time accordingly.
         self.ecs.write_resource::<TimeOfDay>().0 += dt.as_secs_f64() * DAY_CYCLE_FACTOR;
         self.ecs.write_resource::<Time>().0 += dt.as_secs_f64();
@@ -380,22 +380,24 @@ impl State {
             self.ecs.write_storage::<comp::Mounting>().remove(entity);
         }
 
-        // Run systems to update the world.
-        // Create and run a dispatcher for ecs systems.
-        let mut dispatch_builder = DispatcherBuilder::new().with_pool(self.thread_pool.clone());
-        sys::add_local_systems(&mut dispatch_builder);
-        // This dispatches all the systems in parallel.
-        dispatch_builder.build().dispatch(&self.ecs.res);
-
-        self.ecs.maintain();
-
-        // Run RegionMap tick to update enitity region occupancy
+        // Run RegionMap tick to update entity region occupancy
         self.ecs.write_resource::<RegionMap>().tick(
             self.ecs.read_storage::<comp::Pos>(),
             self.ecs.read_storage::<comp::Vel>(),
             self.ecs.entities(),
         );
 
+        // Run systems to update the world.
+        // Create and run a dispatcher for ecs systems.
+        let mut dispatch_builder = DispatcherBuilder::new().with_pool(self.thread_pool.clone());
+        sys::add_local_systems(&mut dispatch_builder);
+        // TODO: Consider alternative ways to do this
+        add_foreign_systems(&mut dispatch_builder);
+        // This dispatches all the systems in parallel.
+        dispatch_builder.build().dispatch(&self.ecs.res);
+
+        self.ecs.maintain();
+
         // Apply terrain changes
         let mut terrain = self.ecs.write_resource::<TerrainGrid>();
         self.ecs
diff --git a/common/src/sys/agent.rs b/common/src/sys/agent.rs
index 1d36365708..67d3025286 100644
--- a/common/src/sys/agent.rs
+++ b/common/src/sys/agent.rs
@@ -47,6 +47,8 @@ impl<'a> System<'a> for Sys {
 
             controller.reset();
 
+            let mut inputs = &mut controller.inputs;
+
             match agent {
                 Agent::Wanderer(bearing) => {
                     *bearing += Vec2::new(rand::random::<f32>() - 0.5, rand::random::<f32>() - 0.5)
@@ -55,7 +57,7 @@ impl<'a> System<'a> for Sys {
                         - pos.0 * 0.0002;
 
                     if bearing.magnitude_squared() > 0.001 {
-                        controller.move_dir = bearing.normalized();
+                        inputs.move_dir = bearing.normalized();
                     }
                 }
                 Agent::Pet { target, offset } => {
@@ -65,12 +67,12 @@ impl<'a> System<'a> for Sys {
                             let tgt_pos = tgt_pos.0 + *offset;
 
                             if tgt_pos.z > pos.0.z + 1.0 {
-                                controller.jump = true;
+                                inputs.jump = true;
                             }
 
                             // Move towards the target.
                             let dist: f32 = Vec2::from(tgt_pos - pos.0).magnitude();
-                            controller.move_dir = if dist > 5.0 {
+                            inputs.move_dir = if dist > 5.0 {
                                 Vec2::from(tgt_pos - pos.0).normalized()
                             } else if dist < 1.5 && dist > 0.001 {
                                 Vec2::from(pos.0 - tgt_pos).normalized()
@@ -78,7 +80,7 @@ impl<'a> System<'a> for Sys {
                                 Vec2::zero()
                             };
                         }
-                        _ => controller.move_dir = Vec2::zero(),
+                        _ => inputs.move_dir = Vec2::zero(),
                     }
 
                     // Change offset occasionally.
@@ -102,28 +104,28 @@ impl<'a> System<'a> for Sys {
                             )
                         })
                     {
-                        controller.look_dir = target_pos.0 - pos.0;
+                        inputs.look_dir = target_pos.0 - pos.0;
 
                         let dist = Vec2::<f32>::from(target_pos.0 - pos.0).magnitude();
                         if target_stats.is_dead {
                             choose_new = true;
                         } else if dist < MIN_ATTACK_DIST && dist > 0.001 {
                             // Fight (and slowly move closer)
-                            controller.move_dir =
+                            inputs.move_dir =
                                 Vec2::<f32>::from(target_pos.0 - pos.0).normalized() * 0.01;
-                            controller.primary = true;
+                            inputs.primary = true;
                         } else if dist < SIGHT_DIST {
-                            controller.move_dir =
+                            inputs.move_dir =
                                 Vec2::<f32>::from(target_pos.0 - pos.0).normalized() * 0.96;
 
                             if rand::random::<f32>() < 0.02 {
-                                controller.roll = true;
+                                inputs.roll = true;
                             }
 
                             if target_character.movement == Glide && target_pos.0.z > pos.0.z + 5.0
                             {
-                                controller.glide = true;
-                                controller.jump = true;
+                                inputs.glide = true;
+                                inputs.jump = true;
                             }
                         } else {
                             choose_new = true;
@@ -134,7 +136,7 @@ impl<'a> System<'a> for Sys {
                                 * 0.1
                                 - *bearing * 0.005;
 
-                        controller.move_dir = if bearing.magnitude_squared() > 0.001 {
+                        inputs.move_dir = if bearing.magnitude_squared() > 0.001 {
                             bearing.normalized()
                         } else {
                             Vec2::zero()
diff --git a/common/src/sys/controller.rs b/common/src/sys/controller.rs
index a4a8e11257..6e5a759ba6 100644
--- a/common/src/sys/controller.rs
+++ b/common/src/sys/controller.rs
@@ -65,48 +65,50 @@ impl<'a> System<'a> for Sys {
         )
             .join()
         {
+            let mut inputs = &mut controller.inputs;
+
             if stats.is_dead {
                 // Respawn
-                if controller.respawn {
+                if inputs.respawn {
                     server_emitter.emit(ServerEvent::Respawn(entity));
                 }
                 continue;
             }
 
             // Move
-            controller.move_dir = if controller.move_dir.magnitude_squared() > 1.0 {
-                controller.move_dir.normalized()
+            inputs.move_dir = if inputs.move_dir.magnitude_squared() > 1.0 {
+                inputs.move_dir.normalized()
             } else {
-                controller.move_dir
+                inputs.move_dir
             };
 
-            if character.movement == Stand && controller.move_dir.magnitude_squared() > 0.0 {
+            if character.movement == Stand && inputs.move_dir.magnitude_squared() > 0.0 {
                 character.movement = Run;
-            } else if character.movement == Run && controller.move_dir.magnitude_squared() == 0.0 {
+            } else if character.movement == Run && inputs.move_dir.magnitude_squared() == 0.0 {
                 character.movement = Stand;
             }
 
             // Look
-            controller.look_dir = controller
+            inputs.look_dir = inputs
                 .look_dir
                 .try_normalized()
-                .unwrap_or(controller.move_dir.into());
+                .unwrap_or(inputs.move_dir.into());
 
             // Glide
             // TODO: Check for glide ability/item
-            if controller.glide
+            if inputs.glide
                 && !physics.on_ground
                 && (character.action == Idle || character.action.is_wield())
                 && character.movement == Jump
                 && body.is_humanoid()
             {
                 character.movement = Glide;
-            } else if !controller.glide && character.movement == Glide {
+            } else if !inputs.glide && character.movement == Glide {
                 character.movement = Jump;
             }
 
             // Sit
-            if controller.sit
+            if inputs.sit
                 && physics.on_ground
                 && character.action == Idle
                 && character.movement != Sit
@@ -114,13 +116,13 @@ impl<'a> System<'a> for Sys {
             {
                 character.movement = Sit;
             } else if character.movement == Sit
-                && (controller.move_dir.magnitude_squared() > 0.0 || !physics.on_ground)
+                && (inputs.move_dir.magnitude_squared() > 0.0 || !physics.on_ground)
             {
                 character.movement = Run;
             }
 
             // Wield
-            if controller.primary
+            if inputs.primary
                 && character.action == Idle
                 && (character.movement == Stand || character.movement == Run)
             {
@@ -135,7 +137,7 @@ impl<'a> System<'a> for Sys {
                     power,
                     ..
                 }) => {
-                    if controller.primary
+                    if inputs.primary
                         && (character.movement == Stand
                             || character.movement == Run
                             || character.movement == Jump)
@@ -146,7 +148,7 @@ impl<'a> System<'a> for Sys {
                                 character.action = Idle;
                                 server_emitter.emit(ServerEvent::Shoot {
                                     entity,
-                                    dir: controller.look_dir,
+                                    dir: inputs.look_dir,
                                     body: comp::Body::Object(comp::object::Body::Arrow),
                                     light: None,
                                     gravity: Some(comp::Gravity(0.3)),
@@ -174,7 +176,7 @@ impl<'a> System<'a> for Sys {
                     ..
                 }) => {
                     // Melee Attack
-                    if controller.primary
+                    if inputs.primary
                         && (character.movement == Stand
                             || character.movement == Run
                             || character.movement == Jump)
@@ -189,7 +191,7 @@ impl<'a> System<'a> for Sys {
                         }
                     }
                     // Magical Bolt
-                    if controller.secondary
+                    if inputs.secondary
                         && (
                             character.movement == Stand
                             //|| character.movement == Run
@@ -204,7 +206,7 @@ impl<'a> System<'a> for Sys {
                                 };
                                 server_emitter.emit(ServerEvent::Shoot {
                                     entity,
-                                    dir: controller.look_dir,
+                                    dir: inputs.look_dir,
                                     body: comp::Body::Object(comp::object::Body::BoltFire),
                                     gravity: Some(comp::Gravity(0.0)),
                                     light: Some(comp::LightEmitter {
@@ -232,7 +234,7 @@ impl<'a> System<'a> for Sys {
                 }
                 Some(Item::Tool { .. }) => {
                     // Melee Attack
-                    if controller.primary
+                    if inputs.primary
                         && (character.movement == Stand
                             || character.movement == Run
                             || character.movement == Jump)
@@ -248,27 +250,27 @@ impl<'a> System<'a> for Sys {
                     }
 
                     // Block
-                    if controller.secondary
+                    if inputs.secondary
                         && (character.movement == Stand || character.movement == Run)
                         && character.action.is_wield()
                     {
                         character.action = Block {
                             time_left: Duration::from_secs(5),
                         };
-                    } else if !controller.secondary && character.action.is_block() {
+                    } else if !inputs.secondary && character.action.is_block() {
                         character.action = Wield {
                             time_left: Duration::default(),
                         };
                     }
                 }
                 Some(Item::Debug(item::Debug::Boost)) => {
-                    if controller.primary {
+                    if inputs.primary {
                         local_emitter.emit(LocalEvent::Boost {
                             entity,
-                            vel: controller.look_dir * 7.0,
+                            vel: inputs.look_dir * 7.0,
                         });
                     }
-                    if controller.secondary {
+                    if inputs.secondary {
                         // Go upward
                         local_emitter.emit(LocalEvent::Boost {
                             entity,
@@ -277,7 +279,7 @@ impl<'a> System<'a> for Sys {
                     }
                 }
                 Some(Item::Debug(item::Debug::Possess)) => {
-                    if controller.primary
+                    if inputs.primary
                         && (character.movement == Stand
                             || character.movement == Run
                             || character.movement == Jump)
@@ -289,7 +291,7 @@ impl<'a> System<'a> for Sys {
                                 server_emitter.emit(ServerEvent::Shoot {
                                     entity,
                                     gravity: Some(comp::Gravity(0.1)),
-                                    dir: controller.look_dir,
+                                    dir: inputs.look_dir,
                                     body: comp::Body::Object(comp::object::Body::ArrowSnake),
                                     light: Some(comp::LightEmitter {
                                         col: (0.0, 1.0, 0.3).into(),
@@ -310,14 +312,14 @@ impl<'a> System<'a> for Sys {
                         }
                     }
                     // Block
-                    if controller.secondary
+                    if inputs.secondary
                         && (character.movement == Stand || character.movement == Run)
                         && character.action.is_wield()
                     {
                         character.action = Block {
                             time_left: Duration::from_secs(5),
                         };
-                    } else if !controller.secondary && character.action.is_block() {
+                    } else if !inputs.secondary && character.action.is_block() {
                         character.action = Wield {
                             time_left: Duration::default(),
                         };
@@ -325,7 +327,7 @@ impl<'a> System<'a> for Sys {
                 }
                 None => {
                     // Attack
-                    if controller.primary
+                    if inputs.primary
                         && (character.movement == Stand
                             || character.movement == Run
                             || character.movement == Jump)
@@ -341,7 +343,7 @@ impl<'a> System<'a> for Sys {
             }
 
             // Roll
-            if controller.roll
+            if inputs.roll
                 && (character.action == Idle || character.action.is_wield())
                 && character.movement == Run
                 && physics.on_ground
@@ -352,16 +354,12 @@ impl<'a> System<'a> for Sys {
             }
 
             // Jump
-            if controller.jump
-                && physics.on_ground
-                && vel.0.z <= 0.0
-                && !character.movement.is_roll()
-            {
+            if inputs.jump && physics.on_ground && vel.0.z <= 0.0 && !character.movement.is_roll() {
                 local_emitter.emit(LocalEvent::Jump(entity));
             }
 
             // Wall leap
-            if controller.wall_leap {
+            if inputs.wall_leap {
                 if let (Some(_wall_dir), Climb) = (physics.on_wall, character.movement) {
                     //local_emitter.emit(LocalEvent::WallLeap { entity, wall_dir });
                 }
@@ -378,6 +376,9 @@ impl<'a> System<'a> for Sys {
                         }
                     }
                     ControlEvent::Unmount => server_emitter.emit(ServerEvent::Unmount(entity)),
+                    ControlEvent::InventoryManip(manip) => {
+                        server_emitter.emit(ServerEvent::InventoryManip(entity, manip))
+                    } //ControlEvent::Respawn => server_emitter.emit(ServerEvent::Unmount(entity)),
                 }
             }
         }
diff --git a/common/src/sys/movement.rs b/common/src/sys/movement.rs
index aa871ce973..d530a89e82 100644
--- a/common/src/sys/movement.rs
+++ b/common/src/sys/movement.rs
@@ -97,11 +97,13 @@ impl<'a> System<'a> for Sys {
                 continue;
             }
 
+            let inputs = &controller.inputs;
+
             if character.movement.is_roll() {
                 vel.0 = Vec3::new(0.0, 0.0, vel.0.z)
                     + (vel.0 * Vec3::new(1.0, 1.0, 0.0)
                         + 1.5
-                            * controller
+                            * inputs
                                 .move_dir
                                 .try_normalized()
                                 .unwrap_or(Vec2::from(vel.0).try_normalized().unwrap_or_default()))
@@ -110,7 +112,7 @@ impl<'a> System<'a> for Sys {
             }
             if character.action.is_block() || character.action.is_attack() {
                 vel.0 += Vec2::broadcast(dt.0)
-                    * controller.move_dir
+                    * inputs.move_dir
                     * match physics.on_ground {
                         true if vel.0.magnitude_squared() < BLOCK_SPEED.powf(2.0) => BLOCK_ACCEL,
                         _ => 0.0,
@@ -118,7 +120,7 @@ impl<'a> System<'a> for Sys {
             } else {
                 // Move player according to move_dir
                 vel.0 += Vec2::broadcast(dt.0)
-                    * controller.move_dir
+                    * inputs.move_dir
                     * match (physics.on_ground, &character.movement) {
                         (true, Run) if vel.0.magnitude_squared() < HUMANOID_SPEED.powf(2.0) => {
                             HUMANOID_ACCEL
@@ -148,7 +150,7 @@ impl<'a> System<'a> for Sys {
                 || character.action.is_attack()
                 || character.action.is_block()
             {
-                Vec2::from(controller.look_dir).normalized()
+                Vec2::from(inputs.look_dir).normalized()
             } else if let (Climb, Some(wall_dir)) = (character.movement, physics.on_wall) {
                 if Vec2::<f32>::from(wall_dir).magnitude_squared() > 0.001 {
                     Vec2::from(wall_dir).normalized()
@@ -198,12 +200,12 @@ impl<'a> System<'a> for Sys {
 
             // Climb
             if let (true, Some(_wall_dir)) = (
-                (controller.climb | controller.climb_down) && vel.0.z <= CLIMB_SPEED,
+                (inputs.climb | inputs.climb_down) && vel.0.z <= CLIMB_SPEED,
                 physics.on_wall,
             ) {
-                if controller.climb_down && !controller.climb {
+                if inputs.climb_down && !inputs.climb {
                     vel.0 -= dt.0 * vel.0.map(|e| e.abs().powf(1.5) * e.signum() * 6.0);
-                } else if controller.climb && !controller.climb_down {
+                } else if inputs.climb && !inputs.climb_down {
                     vel.0.z = (vel.0.z + dt.0 * GRAVITY * 1.25).min(CLIMB_SPEED);
                 } else {
                     vel.0.z = vel.0.z + dt.0 * GRAVITY * 1.5;
diff --git a/server/Cargo.toml b/server/Cargo.toml
index 6505d76458..adfe105ec4 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -27,6 +27,5 @@ prometheus = "0.7"
 prometheus-static-metric = "0.2"
 rouille = "3.0.0"
 portpicker = { git = "https://github.com/wusyong/portpicker-rs", branch = "fix_ipv6" }
-indexmap = "1.2.0"
 # TODO: remove when upgrading to specs 0.15
 hibitset = "0.5.3"
diff --git a/server/src/client.rs b/server/src/client.rs
index b0e02112ba..6d15deae2a 100644
--- a/server/src/client.rs
+++ b/server/src/client.rs
@@ -2,9 +2,7 @@ use common::{
     msg::{ClientMsg, ClientState, RequestStateError, ServerMsg},
     net::PostBox,
 };
-use hashbrown::{hash_map::DefaultHashBuilder, HashSet};
-use indexmap::IndexMap;
-use specs::Entity as EcsEntity;
+use hashbrown::HashSet;
 use specs::{Component, FlaggedStorage};
 use specs_idvs::IDVStorage;
 use vek::*;
@@ -15,10 +13,29 @@ pub struct Client {
     pub last_ping: f64,
 }
 
+impl Component for Client {
+    type Storage = FlaggedStorage<Self, IDVStorage<Self>>;
+}
+
 impl Client {
     pub fn notify(&mut self, msg: ServerMsg) {
         self.postbox.send_message(msg);
     }
+    pub fn is_registered(&self) -> bool {
+        match self.client_state {
+            ClientState::Registered
+            | ClientState::Spectator
+            | ClientState::Dead
+            | ClientState::Character => true,
+            _ => false,
+        }
+    }
+    pub fn is_ingame(&self) -> bool {
+        match self.client_state {
+            ClientState::Spectator | ClientState::Character | ClientState::Dead => true,
+            _ => false,
+        }
+    }
     pub fn allow_state(&mut self, new_state: ClientState) {
         self.client_state = new_state;
         self.postbox
@@ -34,134 +51,6 @@ impl Client {
     }
 }
 
-pub struct Clients {
-    clients: IndexMap<EcsEntity, Client, DefaultHashBuilder>,
-}
-
-impl Clients {
-    pub fn empty() -> Self {
-        Self {
-            clients: IndexMap::default(),
-        }
-    }
-
-    pub fn len(&mut self) -> usize {
-        self.clients.len()
-    }
-
-    pub fn add(&mut self, entity: EcsEntity, client: Client) {
-        self.clients.insert(entity, client);
-    }
-
-    pub fn get<'a>(&'a self, entity: &EcsEntity) -> Option<&'a Client> {
-        self.clients.get(entity)
-    }
-
-    pub fn get_mut<'a>(&'a mut self, entity: &EcsEntity) -> Option<&'a mut Client> {
-        self.clients.get_mut(entit:y)
-    }
-
-    pub fn remove<'a>(&'a mut self, entity: &EcsEntity) -> Option<Client> {
-        self.clients.remove(entity)
-    }
-
-    pub fn get_client_index_ingame<'a>(&'a mut self, entity: &EcsEntity) -> Option<usize> {
-        self.clients.get_full(entity).and_then(|(i, _, c)| {
-            if c.client_state == ClientState::Spectator
-                || c.client_state == ClientState::Character
-                || c.client_state == ClientState::Dead
-            {
-                Some(i)
-            } else {
-                None
-            }
-        })
-    }
-
-    pub fn remove_if<F: FnMut(EcsEntity, &mut Client) -> bool>(&mut self, mut f: F) {
-        self.clients.retain(|entity, client| !f(*entity, client));
-    }
-
-    pub fn notify_index(&mut self, index: usize, msg: ServerMsg) {
-        if let Some((_, client)) = self.clients.get_index_mut(index) {
-            client.notify(msg);
-        }
-    }
-
-    pub fn notify(&mut self, entity: EcsEntity, msg: ServerMsg) {
-        if let Some(client) = self.clients.get_mut(&entity) {
-            client.notify(msg);
-        }
-    }
-
-    pub fn notify_registered(&mut self, msg: ServerMsg) {
-        for client in self.clients.values_mut() {
-            if client.client_state != ClientState::Connected {
-                client.notify(msg.clone());
-            }
-        }
-    }
-
-    pub fn notify_ingame(&mut self, msg: ServerMsg) {
-        for client in self.clients.values_mut() {
-            if client.client_state == ClientState::Spectator
-                || client.client_state == ClientState::Character
-                || client.client_state == ClientState::Dead
-            {
-                client.notify(msg.clone());
-            }
-        }
-    }
-
-    pub fn notify_ingame_if<F: FnMut(EcsEntity) -> bool>(&mut self, msg: ServerMsg, mut f: F) {
-        for (_entity, client) in self.clients.iter_mut().filter(|(e, _)| f(**e)) {
-            if client.client_state == ClientState::Spectator
-                || client.client_state == ClientState::Character
-                || client.client_state == ClientState::Dead
-            {
-                client.notify(msg.clone());
-            }
-        }
-    }
-
-    pub fn notify_registered_except(&mut self, except_entity: EcsEntity, msg: ServerMsg) {
-        for (entity, client) in self.clients.iter_mut() {
-            if client.client_state != ClientState::Connected && *entity != except_entity {
-                client.notify(msg.clone());
-            }
-        }
-    }
-
-    pub fn notify_ingame_except(&mut self, except_entity: EcsEntity, msg: ServerMsg) {
-        for (entity, client) in self.clients.iter_mut() {
-            if (client.client_state == ClientState::Spectator
-                || client.client_state == ClientState::Character
-                || client.client_state == ClientState::Dead)
-                && *entity != except_entity
-            {
-                client.notify(msg.clone());
-            }
-        }
-    }
-
-    pub fn notify_ingame_if_except<F: FnMut(EcsEntity) -> bool>(
-        &mut self,
-        except_entity: EcsEntity,
-        msg: ServerMsg,
-        mut f: F,
-    ) {
-        for (entity, client) in self.clients.iter_mut().filter(|(e, _)| f(**e)) {
-            if (client.client_state == ClientState::Spectator
-                || client.client_state == ClientState::Character
-                || client.client_state == ClientState::Dead)
-                && *entity != except_entity
-            {
-                client.notify(msg.clone());
-            }
-        }
-    }
-}
-
 // Distance from fuzzy_chunk before snapping to current chunk
 pub const CHUNK_FUZZ: u32 = 2;
 // Distance out of the range of a region before removing it from subscriptions
diff --git a/server/src/cmd.rs b/server/src/cmd.rs
index 39586624bf..c77d64417b 100644
--- a/server/src/cmd.rs
+++ b/server/src/cmd.rs
@@ -62,7 +62,7 @@ impl ChatCommand {
     pub fn execute(&self, server: &mut Server, entity: EcsEntity, args: String) {
         if self.needs_admin {
             if !server.entity_is_admin(entity) {
-                server.clients.notify(
+                server.notify_client(
                     entity,
                     ServerMsg::private(format!(
                         "You don't have permission to use '/{}'.",
@@ -243,7 +243,7 @@ fn handle_jump(server: &mut Server, entity: EcsEntity, args: String, action: &Ch
                     .write_component(entity, comp::Pos(current_pos.0 + Vec3::new(x, y, z)));
                 server.state.write_component(entity, comp::ForceUpdate);
             }
-            None => server.clients.notify(
+            None => server.notify_client(
                 entity,
                 ServerMsg::private(String::from("You have no position.")),
             ),
@@ -263,15 +263,13 @@ fn handle_goto(server: &mut Server, entity: EcsEntity, args: String, action: &Ch
                 .write_component(entity, comp::Pos(Vec3::new(x, y, z)));
             server.state.write_component(entity, comp::ForceUpdate);
         } else {
-            server.clients.notify(
+            server.notify_client(
                 entity,
                 ServerMsg::private(String::from("You have no position.")),
             );
         }
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(String::from(action.help_string)));
+        server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
     }
 }
 
@@ -299,7 +297,7 @@ fn handle_time(server: &mut Server, entity: EcsEntity, args: String, action: &Ch
             Err(_) => match NaiveTime::parse_from_str(n, "%H:%M") {
                 Ok(time) => time,
                 Err(_) => {
-                    server.clients.notify(
+                    server.notify_client(
                         entity,
                         ServerMsg::private(format!("'{}' is not a valid time.", n)),
                     );
@@ -319,7 +317,7 @@ fn handle_time(server: &mut Server, entity: EcsEntity, args: String, action: &Ch
                 Some(time) => format!("It is {}", time.format("%H:%M").to_string()),
                 None => String::from("Unknown Time"),
             };
-            server.clients.notify(entity, ServerMsg::private(msg));
+            server.notify_client(entity, ServerMsg::private(msg));
             return;
         }
     };
@@ -327,7 +325,7 @@ fn handle_time(server: &mut Server, entity: EcsEntity, args: String, action: &Ch
     server.state.ecs_mut().write_resource::<TimeOfDay>().0 =
         new_time.num_seconds_from_midnight() as f64;
 
-    server.clients.notify(
+    server.notify_client(
         entity,
         ServerMsg::private(format!(
             "Time changed to: {}",
@@ -340,19 +338,19 @@ fn handle_health(server: &mut Server, entity: EcsEntity, args: String, action: &
     if let Ok(hp) = scan_fmt!(&args, action.arg_fmt, u32) {
         if let Some(stats) = server
             .state
-            .ecs_mut()
+            .ecs()
             .write_storage::<comp::Stats>()
             .get_mut(entity)
         {
             stats.health.set_to(hp, comp::HealthSource::Command);
         } else {
-            server.clients.notify(
+            server.notify_client(
                 entity,
                 ServerMsg::private(String::from("You have no health.")),
             );
         }
     } else {
-        server.clients.notify(
+        server.notify_client(
             entity,
             ServerMsg::private(String::from("You must specify health amount!")),
         );
@@ -368,9 +366,7 @@ fn handle_alias(server: &mut Server, entity: EcsEntity, args: String, action: &C
             .get_mut(entity)
             .map(|player| player.alias = alias);
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(String::from(action.help_string)));
+        server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
     }
 }
 
@@ -388,31 +384,28 @@ fn handle_tp(server: &mut Server, entity: EcsEntity, args: String, action: &Chat
                         server.state.write_component(entity, pos);
                         server.state.write_component(entity, comp::ForceUpdate);
                     }
-                    None => server.clients.notify(
+                    None => server.notify_client(
                         entity,
                         ServerMsg::private(format!("Unable to teleport to player '{}'!", alias)),
                     ),
                 },
                 None => {
-                    server.clients.notify(
+                    server.notify_client(
                         entity,
                         ServerMsg::private(format!("Player '{}' not found!", alias)),
                     );
-                    server
-                        .clients
-                        .notify(entity, ServerMsg::private(String::from(action.help_string)));
+                    server.notify_client(
+                        entity,
+                        ServerMsg::private(String::from(action.help_string)),
+                    );
                 }
             },
             None => {
-                server
-                    .clients
-                    .notify(entity, ServerMsg::private(format!("You have no position!")));
+                server.notify_client(entity, ServerMsg::private(format!("You have no position!")));
             }
         }
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(String::from(action.help_string)));
+        server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
     }
 }
 
@@ -443,12 +436,12 @@ fn handle_spawn(server: &mut Server, entity: EcsEntity, args: String, action: &C
                                 .with(agent)
                                 .build();
                         }
-                        server.clients.notify(
+                        server.notify_client(
                             entity,
                             ServerMsg::private(format!("Spawned {} entities", amount).to_owned()),
                         );
                     }
-                    None => server.clients.notify(
+                    None => server.notify_client(
                         entity,
                         ServerMsg::private("You have no position!".to_owned()),
                     ),
@@ -456,9 +449,7 @@ fn handle_spawn(server: &mut Server, entity: EcsEntity, args: String, action: &C
             }
         }
         _ => {
-            server
-                .clients
-                .notify(entity, ServerMsg::private(String::from(action.help_string)));
+            server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
         }
     }
 }
@@ -481,13 +472,9 @@ fn handle_players(server: &mut Server, entity: EcsEntity, _args: String, _action
             s
         });
 
-        server
-            .clients
-            .notify(entity, ServerMsg::private(header_message + &player_list));
+        server.notify_client(entity, ServerMsg::private(header_message + &player_list));
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(header_message));
+        server.notify_client(entity, ServerMsg::private(header_message));
     }
 }
 
@@ -503,7 +490,7 @@ fn handle_build(server: &mut Server, entity: EcsEntity, _args: String, _action:
             .ecs()
             .write_storage::<comp::CanBuild>()
             .remove(entity);
-        server.clients.notify(
+        server.notify_client(
             entity,
             ServerMsg::private(String::from("Toggled off build mode!")),
         );
@@ -513,7 +500,7 @@ fn handle_build(server: &mut Server, entity: EcsEntity, _args: String, _action:
             .ecs()
             .write_storage::<comp::CanBuild>()
             .insert(entity, comp::CanBuild);
-        server.clients.notify(
+        server.notify_client(
             entity,
             ServerMsg::private(String::from("Toggled on build mode!")),
         );
@@ -523,9 +510,7 @@ fn handle_build(server: &mut Server, entity: EcsEntity, _args: String, _action:
 fn handle_help(server: &mut Server, entity: EcsEntity, _args: String, _action: &ChatCommand) {
     for cmd in CHAT_COMMANDS.iter() {
         if !cmd.needs_admin || server.entity_is_admin(entity) {
-            server
-                .clients
-                .notify(entity, ServerMsg::private(String::from(cmd.help_string)));
+            server.notify_client(entity, ServerMsg::private(String::from(cmd.help_string)));
         }
     }
 }
@@ -564,7 +549,7 @@ fn handle_killnpcs(server: &mut Server, entity: EcsEntity, _args: String, _actio
     } else {
         "No NPCs on server.".to_string()
     };
-    server.clients.notify(entity, ServerMsg::private(text));
+    server.notify_client(entity, ServerMsg::private(text));
 }
 
 fn handle_object(server: &mut Server, entity: EcsEntity, args: String, _action: &ChatCommand) {
@@ -636,7 +621,7 @@ fn handle_object(server: &mut Server, entity: EcsEntity, args: String, _action:
             Ok("carpet_human_squircle") => comp::object::Body::CarpetHumanSquircle,
             Ok("crafting_bench") => comp::object::Body::CraftingBench,
             _ => {
-                return server.clients.notify(
+                return server.notify_client(
                     entity,
                     ServerMsg::private(String::from("Object not found!")),
                 );
@@ -657,7 +642,7 @@ fn handle_object(server: &mut Server, entity: EcsEntity, args: String, _action:
                     .normalized(),
             ))
             .build();
-        server.clients.notify(
+        server.notify_client(
             entity,
             ServerMsg::private(format!(
                 "Spawned: {}",
@@ -665,9 +650,7 @@ fn handle_object(server: &mut Server, entity: EcsEntity, args: String, _action:
             )),
         );
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(format!("You have no position!")));
+        server.notify_client(entity, ServerMsg::private(format!("You have no position!")));
     }
 }
 
@@ -704,13 +687,9 @@ fn handle_light(server: &mut Server, entity: EcsEntity, args: String, action: &C
             .with(comp::ForceUpdate)
             .with(light_emitter)
             .build();
-        server
-            .clients
-            .notify(entity, ServerMsg::private(format!("Spawned object.")));
+        server.notify_client(entity, ServerMsg::private(format!("Spawned object.")));
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(format!("You have no position!")));
+        server.notify_client(entity, ServerMsg::private(format!("You have no position!")));
     }
 }
 
@@ -731,7 +710,7 @@ fn handle_lantern(server: &mut Server, entity: EcsEntity, args: String, action:
                 .get_mut(entity)
             {
                 light.strength = s.max(0.1).min(10.0);
-                server.clients.notify(
+                server.notify_client(
                     entity,
                     ServerMsg::private(String::from("You adjusted flame strength.")),
                 );
@@ -742,7 +721,7 @@ fn handle_lantern(server: &mut Server, entity: EcsEntity, args: String, action:
                 .ecs()
                 .write_storage::<comp::LightEmitter>()
                 .remove(entity);
-            server.clients.notify(
+            server.notify_client(
                 entity,
                 ServerMsg::private(String::from("You put out the lantern.")),
             );
@@ -765,7 +744,7 @@ fn handle_lantern(server: &mut Server, entity: EcsEntity, args: String, action:
                 },
             );
 
-        server.clients.notify(
+        server.notify_client(
             entity,
             ServerMsg::private(String::from("You lit your lantern.")),
         );
@@ -781,7 +760,7 @@ fn handle_explosion(server: &mut Server, entity: EcsEntity, args: String, action
             .ecs()
             .read_resource::<EventBus<ServerEvent>>()
             .emit(ServerEvent::Explosion { pos: pos.0, radius }),
-        None => server.clients.notify(
+        None => server.notify_client(
             entity,
             ServerMsg::private(String::from("You have no position!")),
         ),
@@ -796,11 +775,9 @@ fn handle_waypoint(server: &mut Server, entity: EcsEntity, _args: String, _actio
                 .ecs()
                 .write_storage::<comp::Waypoint>()
                 .insert(entity, comp::Waypoint::new(pos.0));
-            server
-                .clients
-                .notify(entity, ServerMsg::private(String::from("Waypoint set!")));
+            server.notify_client(entity, ServerMsg::private(String::from("Waypoint set!")));
         }
-        None => server.clients.notify(
+        None => server.notify_client(
             entity,
             ServerMsg::private(String::from("You have no position!")),
         ),
@@ -824,19 +801,15 @@ fn handle_adminify(server: &mut Server, entity: EcsEntity, args: String, action:
                 }
             },
             None => {
-                server.clients.notify(
+                server.notify_client(
                     entity,
                     ServerMsg::private(format!("Player '{}' not found!", alias)),
                 );
-                server
-                    .clients
-                    .notify(entity, ServerMsg::private(String::from(action.help_string)));
+                server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
             }
         }
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(String::from(action.help_string)));
+        server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
     }
 }
 
@@ -856,40 +829,40 @@ fn handle_tell(server: &mut Server, entity: EcsEntity, args: String, action: &Ch
                         .get(entity)
                         .map(|s| s.alias.clone())
                     {
-                        server
-                            .clients
-                            .notify(player, ServerMsg::tell(format!("[{}] tells:{}", name, msg)));
-                        server
-                            .clients
-                            .notify(entity, ServerMsg::tell(format!("To [{}]:{}", alias, msg)));
+                        server.notify_client(
+                            player,
+                            ServerMsg::tell(format!("[{}] tells:{}", name, msg)),
+                        );
+                        server.notify_client(
+                            entity,
+                            ServerMsg::tell(format!("To [{}]:{}", alias, msg)),
+                        );
                     } else {
-                        server.clients.notify(
+                        server.notify_client(
                             entity,
                             ServerMsg::private(String::from("Failed to send message.")),
                         );
                     }
                 } else {
-                    server.clients.notify(
+                    server.notify_client(
                         entity,
                         ServerMsg::private(format!("[{}] wants to talk to you.", alias)),
                     );
                 }
             } else {
-                server.clients.notify(
+                server.notify_client(
                     entity,
                     ServerMsg::private(format!("You can't /tell yourself.")),
                 );
             }
         } else {
-            server.clients.notify(
+            server.notify_client(
                 entity,
                 ServerMsg::private(format!("Player '{}' not found!", alias)),
             );
         }
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(String::from(action.help_string)));
+        server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
     }
 }
 
@@ -949,17 +922,15 @@ spawn_rate {:?} "#,
             ))
         };
         if let Some(s) = foo() {
-            server.clients.notify(entity, ServerMsg::private(s));
+            server.notify_client(entity, ServerMsg::private(s));
         } else {
-            server.clients.notify(
+            server.notify_client(
                 entity,
                 ServerMsg::private(String::from("Not a pregenerated chunk.")),
             );
         }
     } else {
-        server
-            .clients
-            .notify(entity, ServerMsg::private(String::from(action.help_string)));
+        server.notify_client(entity, ServerMsg::private(String::from(action.help_string)));
     }
 }
 
@@ -972,24 +943,24 @@ fn handle_exp(server: &mut Server, entity: EcsEntity, args: String, action: &Cha
             .find(|(_, player)| player.alias == alias)
             .map(|(entity, _)| entity);
 
+        let mut error_msg = None;
+
         match opt_player {
             Some(_alias) => {
                 if let Some(stats) = ecs.write_storage::<comp::Stats>().get_mut(entity) {
                     stats.exp.change_by(exp);
                 } else {
-                    server.clients.notify(
-                        entity,
-                        ServerMsg::private(String::from("Player has no stats!")),
-                    );
+                    error_msg = Some(ServerMsg::private(String::from("Player has no stats!")));
                 }
             }
             _ => {
-                server.clients.notify(
-                    entity,
-                    ServerMsg::private(format!("Player '{}' not found!", alias)),
-                );
+                error_msg = Some(ServerMsg::private(format!("Player '{}' not found!", alias)));
             }
         }
+
+        if let Some(msg) = error_msg {
+            server.notify_client(entity, msg);
+        }
     }
 }
 
@@ -1022,7 +993,7 @@ fn handle_remove_lights(
                 }
             }
         }
-        None => server.clients.notify(
+        None => server.notify_client(
             entity,
             ServerMsg::private(String::from("You have no position.")),
         ),
@@ -1034,7 +1005,7 @@ fn handle_remove_lights(
         let _ = server.state.ecs_mut().delete_entity_synced(entity);
     }
 
-    server.clients.notify(
+    server.notify_client(
         entity,
         ServerMsg::private(String::from(format!("Removed {} lights!", size))),
     );
diff --git a/server/src/lib.rs b/server/src/lib.rs
index c7c0e40851..3fe9088795 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -8,21 +8,21 @@ pub mod error;
 pub mod input;
 pub mod metrics;
 pub mod settings;
+pub mod sys;
 
 // Reexports
 pub use crate::{error::Error, input::Input, settings::ServerSettings};
 
 use crate::{
     auth_provider::AuthProvider,
-    client::{Client, Clients, RegionSubscription},
+    client::{Client, RegionSubscription},
     cmd::CHAT_COMMANDS,
 };
 use common::{
     comp,
     effect::Effect,
     event::{EventBus, ServerEvent},
-    msg::{validate_chat_msg, ChatMsgValidationError, MAX_BYTES_CHAT_MSG},
-    msg::{ClientMsg, ClientState, RequestStateError, ServerError, ServerInfo, ServerMsg},
+    msg::{ClientMsg, ClientState, ServerError, ServerInfo, ServerMsg},
     net::PostOffice,
     state::{BlockChange, State, TimeOfDay, Uid},
     terrain::{block::Block, TerrainChunk, TerrainChunkSize, TerrainGrid},
@@ -64,12 +64,16 @@ pub enum Event {
 #[derive(Copy, Clone)]
 struct SpawnPoint(Vec3<f32>);
 
+// Tick count used for throttling network updates
+// Note this doesn't account for dt (so update rate changes with tick rate)
+#[derive(Copy, Clone, Default)]
+pub struct Tick(u64);
+
 pub struct Server {
     state: State,
     world: Arc<World>,
 
     postoffice: PostOffice<ServerMsg, ClientMsg>,
-    clients: Clients,
 
     thread_pool: ThreadPool,
     chunk_tx: channel::Sender<(
@@ -82,16 +86,10 @@ pub struct Server {
     )>,
     pending_chunks: HashMap<Vec2<i32>, Arc<AtomicBool>>,
 
-    server_settings: ServerSettings,
     server_info: ServerInfo,
     metrics: ServerMetrics,
 
-    // Tick count used for throttling network updates
-    // Note this doesn't account for dt (so update rate changes with tick rate)
-    tick: u64,
-
-    // TODO: anything but this
-    accounts: AuthProvider,
+    server_settings: ServerSettings,
 }
 
 impl Server {
@@ -106,7 +104,11 @@ impl Server {
         state
             .ecs_mut()
             .add_resource(EventBus::<ServerEvent>::default());
+        // TODO: anything but this
+        state.ecs_mut().add_resource(AuthProvider::new());
+        state.ecs_mut().add_resource(Tick(0));
         state.ecs_mut().register::<RegionSubscription>();
+        state.ecs_mut().register::<Client>();
 
         // Set starting time for the server.
         state.ecs_mut().write_resource::<TimeOfDay>().0 = settings.start_time;
@@ -116,7 +118,6 @@ impl Server {
             world: Arc::new(World::generate(settings.world_seed)),
 
             postoffice: PostOffice::bind(settings.gameserver_address)?,
-            clients: Clients::empty(),
 
             thread_pool: ThreadPoolBuilder::new()
                 .name("veloren-worker".into())
@@ -133,8 +134,6 @@ impl Server {
             },
             metrics: ServerMetrics::new(settings.metrics_address)
                 .expect("Failed to initialize server metrics submodule."),
-            tick: 0,
-            accounts: AuthProvider::new(),
             server_settings: settings.clone(),
         };
         debug!("created veloren server");
@@ -223,7 +222,6 @@ impl Server {
     pub fn create_player_character(
         state: &mut State,
         entity: EcsEntity,
-        client: &mut Client,
         name: String,
         body: comp::Body,
         main: Option<comp::Item>,
@@ -256,11 +254,19 @@ impl Server {
             state.write_component(entity, comp::Admin);
         }
         // Tell the client its request was successful.
-        client.allow_state(ClientState::Character);
+        if let Some(client) = state.ecs().write_storage::<Client>().get_mut(entity) {
+            client.allow_state(ClientState::Character);
+        }
     }
 
     /// Handle events coming through via the event bus
-    fn handle_events(&mut self) {
+    fn handle_events(&mut self) -> Vec<Event> {
+        let mut frontend_events = Vec::new();
+
+        let mut requested_chunks = Vec::new();
+        let mut dropped_items = Vec::new();
+        let mut chat_commands = Vec::new();
+
         let events = self
             .state
             .ecs()
@@ -268,7 +274,8 @@ impl Server {
             .recv_all();
         for event in events {
             let state = &mut self.state;
-            let clients = &mut self.clients;
+
+            let server_settings = &self.server_settings;
 
             let mut todo_remove = None;
 
@@ -284,7 +291,7 @@ impl Server {
                         )
                         .normalized();
 
-                        let ecs = state.ecs_mut();
+                        let ecs = state.ecs();
                         let mut block_change = ecs.write_resource::<BlockChange>();
 
                         let _ = ecs
@@ -332,7 +339,7 @@ impl Server {
                 }
 
                 ServerEvent::Damage { uid, change } => {
-                    let ecs = state.ecs_mut();
+                    let ecs = state.ecs();
                     if let Some(entity) = ecs.entity_from_uid(uid.into()) {
                         if let Some(stats) = ecs.write_storage::<comp::Stats>().get_mut(entity) {
                             stats.health.change_by(change);
@@ -341,7 +348,7 @@ impl Server {
                 }
 
                 ServerEvent::Destroy { entity, cause } => {
-                    let ecs = state.ecs_mut();
+                    let ecs = state.ecs();
                     // Chat message
                     if let Some(player) = ecs.read_storage::<comp::Player>().get(entity) {
                         let msg = if let comp::HealthSource::Attack { by } = cause {
@@ -360,7 +367,7 @@ impl Server {
                         }
                         .unwrap_or(format!("{} died", &player.alias));
 
-                        clients.notify_registered(ServerMsg::kill(msg));
+                        state.notify_registered_clients(ServerMsg::kill(msg));
                     }
 
                     // Give EXP to the killer if entity had stats
@@ -379,7 +386,7 @@ impl Server {
                         }
                     }
 
-                    if let Some(client) = clients.get_mut(&entity) {
+                    if let Some(client) = ecs.write_storage::<Client>().get_mut(entity) {
                         let _ = ecs.write_storage().insert(entity, comp::Vel(Vec3::zero()));
                         let _ = ecs.write_storage().insert(entity, comp::ForceUpdate);
                         client.force_state(ClientState::Dead);
@@ -388,9 +395,140 @@ impl Server {
                     }
                 }
 
+                ServerEvent::InventoryManip(entity, manip) => {
+                    match manip {
+                        comp::InventoryManip::Pickup(uid) => {
+                            // TODO: enforce max pickup range
+                            let item_entity = if let (Some((item, item_entity)), Some(inv)) = (
+                                state
+                                    .ecs()
+                                    .entity_from_uid(uid.into())
+                                    .and_then(|item_entity| {
+                                        state
+                                            .ecs()
+                                            .write_storage::<comp::Item>()
+                                            .get_mut(item_entity)
+                                            .map(|item| (item.clone(), item_entity))
+                                    }),
+                                state
+                                    .ecs()
+                                    .write_storage::<comp::Inventory>()
+                                    .get_mut(entity),
+                            ) {
+                                if inv.push(item).is_none() {
+                                    Some(item_entity)
+                                } else {
+                                    None
+                                }
+                            } else {
+                                None
+                            };
+
+                            if let Some(item_entity) = item_entity {
+                                let _ = state.ecs_mut().delete_entity_synced(item_entity);
+                            }
+
+                            state.write_component(entity, comp::InventoryUpdate);
+                        }
+
+                        comp::InventoryManip::Collect(pos) => {
+                            let block = state.terrain().get(pos).ok().copied();
+                            if let Some(block) = block {
+                                if block.is_collectible()
+                                    && state
+                                        .ecs()
+                                        .read_storage::<comp::Inventory>()
+                                        .get(entity)
+                                        .map(|inv| !inv.is_full())
+                                        .unwrap_or(false)
+                                {
+                                    if state.try_set_block(pos, Block::empty()).is_some() {
+                                        comp::Item::try_reclaim_from_block(block)
+                                            .map(|item| state.give_item(entity, item));
+                                    }
+                                }
+                            }
+                        }
+
+                        comp::InventoryManip::Use(slot) => {
+                            let item = state
+                                .ecs()
+                                .write_storage::<comp::Inventory>()
+                                .get_mut(entity)
+                                .and_then(|inv| inv.remove(slot));
+
+                            match item {
+                                Some(comp::Item::Tool { .. }) | Some(comp::Item::Debug(_)) => {
+                                    if let Some(stats) =
+                                        state.ecs().write_storage::<comp::Stats>().get_mut(entity)
+                                    {
+                                        // Insert old item into inventory
+                                        if let Some(old_item) = stats.equipment.main.take() {
+                                            state
+                                                .ecs()
+                                                .write_storage::<comp::Inventory>()
+                                                .get_mut(entity)
+                                                .map(|inv| inv.insert(slot, old_item));
+                                        }
+
+                                        stats.equipment.main = item;
+                                    }
+                                }
+                                Some(comp::Item::Consumable { effect, .. }) => {
+                                    state.apply_effect(entity, effect);
+                                }
+                                Some(item) => {
+                                    // Re-insert it if unused
+                                    let _ = state
+                                        .ecs()
+                                        .write_storage::<comp::Inventory>()
+                                        .get_mut(entity)
+                                        .map(|inv| inv.insert(slot, item));
+                                }
+                                _ => {}
+                            }
+
+                            state.write_component(entity, comp::InventoryUpdate);
+                        }
+
+                        comp::InventoryManip::Swap(a, b) => {
+                            state
+                                .ecs()
+                                .write_storage::<comp::Inventory>()
+                                .get_mut(entity)
+                                .map(|inv| inv.swap_slots(a, b));
+                            state.write_component(entity, comp::InventoryUpdate);
+                        }
+
+                        comp::InventoryManip::Drop(slot) => {
+                            let item = state
+                                .ecs()
+                                .write_storage::<comp::Inventory>()
+                                .get_mut(entity)
+                                .and_then(|inv| inv.remove(slot));
+
+                            if let (Some(item), Some(pos)) =
+                                (item, state.ecs().read_storage::<comp::Pos>().get(entity))
+                            {
+                                dropped_items.push((
+                                    *pos,
+                                    state
+                                        .ecs()
+                                        .read_storage::<comp::Ori>()
+                                        .get(entity)
+                                        .copied()
+                                        .unwrap_or(comp::Ori(Vec3::unit_y())),
+                                    item,
+                                ));
+                            }
+                            state.write_component(entity, comp::InventoryUpdate);
+                        }
+                    }
+                }
+
                 ServerEvent::Respawn(entity) => {
                     // Only clients can respawn
-                    if let Some(client) = clients.get_mut(&entity) {
+                    if let Some(client) = state.ecs().write_storage::<Client>().get_mut(entity) {
                         let respawn_point = state
                             .read_component_cloned::<comp::Waypoint>(entity)
                             .map(|wp| wp.get_pos())
@@ -398,17 +536,17 @@ impl Server {
 
                         client.allow_state(ClientState::Character);
                         state
-                            .ecs_mut()
+                            .ecs()
                             .write_storage::<comp::Stats>()
                             .get_mut(entity)
                             .map(|stats| stats.revive());
                         state
-                            .ecs_mut()
+                            .ecs()
                             .write_storage::<comp::Pos>()
                             .get_mut(entity)
                             .map(|pos| pos.0 = respawn_point);
                         let _ = state
-                            .ecs_mut()
+                            .ecs()
                             .write_storage()
                             .insert(entity, comp::ForceUpdate);
                     }
@@ -416,10 +554,8 @@ impl Server {
 
                 ServerEvent::LandOnGround { entity, vel } => {
                     if vel.z <= -25.0 {
-                        if let Some(stats) = state
-                            .ecs_mut()
-                            .write_storage::<comp::Stats>()
-                            .get_mut(entity)
+                        if let Some(stats) =
+                            state.ecs().write_storage::<comp::Stats>().get_mut(entity)
                         {
                             let falldmg = (vel.z / 5.0) as i32;
                             if falldmg < 0 {
@@ -464,6 +600,7 @@ impl Server {
                         }
                     }
                 }
+
                 ServerEvent::Unmount(mounter) => {
                     let mountee_entity = state
                         .ecs()
@@ -472,27 +609,29 @@ impl Server {
                         .and_then(|mountee| state.ecs().entity_from_uid(mountee.0.into()));
                     if let Some(mountee_entity) = mountee_entity {
                         state
-                            .ecs_mut()
+                            .ecs()
                             .write_storage::<comp::MountState>()
                             .get_mut(mountee_entity)
                             .map(|ms| *ms = comp::MountState::Unmounted);
                     }
                     state.delete_component::<comp::Mounting>(mounter);
                 }
+
                 ServerEvent::Possess(possessor_uid, possesse_uid) => {
+                    let ecs = state.ecs();
                     if let (Some(possessor), Some(possesse)) = (
-                        state.ecs().entity_from_uid(possessor_uid.into()),
-                        state.ecs().entity_from_uid(possesse_uid.into()),
+                        ecs.entity_from_uid(possessor_uid.into()),
+                        ecs.entity_from_uid(possesse_uid.into()),
                     ) {
                         // You can't possess other players
-                        if clients.get(&possesse).is_none() {
-                            if let Some(mut client) = clients.remove(&possessor) {
+                        let mut clients = ecs.write_storage::<Client>();
+                        if clients.get_mut(possesse).is_none() {
+                            if let Some(mut client) = clients.remove(possessor) {
                                 client.notify(ServerMsg::SetPlayerEntity(possesse_uid.into()));
-                                clients.add(possesse, client);
+                                let _ = clients.insert(possesse, client);
                                 // Create inventory if it doesn't exist
                                 {
-                                    let mut inventories =
-                                        state.ecs_mut().write_storage::<comp::Inventory>();
+                                    let mut inventories = ecs.write_storage::<comp::Inventory>();
                                     if let Some(inventory) = inventories.get_mut(possesse) {
                                         inventory
                                             .push(comp::Item::Debug(comp::item::Debug::Possess));
@@ -507,34 +646,28 @@ impl Server {
                                         );
                                     }
                                 }
-                                let _ = state
-                                    .ecs_mut()
+                                let _ = ecs
                                     .write_storage::<comp::InventoryUpdate>()
                                     .insert(possesse, comp::InventoryUpdate);
                                 // Move player component
                                 {
-                                    let mut players =
-                                        state.ecs_mut().write_storage::<comp::Player>();
+                                    let mut players = ecs.write_storage::<comp::Player>();
                                     if let Some(player) = players.get(possessor).cloned() {
                                         let _ = players.insert(possesse, player);
                                     }
                                 }
                                 // Remove will of the entity
-                                let _ = state
-                                    .ecs_mut()
-                                    .write_storage::<comp::Agent>()
-                                    .remove(possesse);
+                                let _ = ecs.write_storage::<comp::Agent>().remove(possesse);
                                 // Transfer admin powers
                                 {
-                                    let mut admins = state.ecs_mut().write_storage::<comp::Admin>();
+                                    let mut admins = ecs.write_storage::<comp::Admin>();
                                     if let Some(admin) = admins.remove(possessor) {
                                         let _ = admins.insert(possesse, admin);
                                     }
                                 }
                                 // Transfer waypoint
                                 {
-                                    let mut waypoints =
-                                        state.ecs_mut().write_storage::<comp::Waypoint>();
+                                    let mut waypoints = ecs.write_storage::<comp::Waypoint>();
                                     if let Some(waypoint) = waypoints.remove(possessor) {
                                         let _ = waypoints.insert(possesse, waypoint);
                                     }
@@ -543,17 +676,74 @@ impl Server {
                         }
                     }
                 }
+
+                ServerEvent::CreatePlayer {
+                    entity,
+                    name,
+                    body,
+                    main,
+                } => {
+                    Self::create_player_character(
+                        state,
+                        entity,
+                        name,
+                        body,
+                        main,
+                        &server_settings,
+                    );
+                    Self::initialize_region_subscription(state, entity);
+                }
+
+                ServerEvent::ClientDisconnect(entity) => {
+                    if let Err(err) = state.ecs_mut().delete_entity_synced(entity) {
+                        debug!("Failed to delete disconnected client: {:?}", err);
+                    }
+
+                    frontend_events.push(Event::ClientDisconnected { entity });
+                }
+
+                ServerEvent::ChunkRequest(entity, key) => {
+                    requested_chunks.push((entity, key));
+                }
+
+                ServerEvent::ChatCmd(entity, cmd) => {
+                    chat_commands.push((entity, cmd));
+                }
             }
 
+            // TODO: is this needed?
             if let Some(entity) = todo_remove {
                 let _ = state.ecs_mut().delete_entity_synced(entity);
             }
         }
+
+        // Generate requested chunks.
+        for (entity, key) in requested_chunks {
+            self.generate_chunk(entity, key);
+        }
+
+        // Drop items
+        for (pos, ori, item) in dropped_items {
+            let vel = ori.0.normalized() * 5.0
+                + Vec3::unit_z() * 10.0
+                + Vec3::<f32>::zero().map(|_| rand::thread_rng().gen::<f32>() - 0.5) * 4.0;
+            self.create_object(Default::default(), comp::object::Body::Pouch)
+                .with(comp::Pos(pos.0 + Vec3::unit_z() * 0.25))
+                .with(item)
+                .with(comp::Vel(vel))
+                .build();
+        }
+
+        for (entity, cmd) in chat_commands {
+            self.process_chat_cmd(entity, cmd);
+        }
+
+        frontend_events
     }
 
     /// Execute a single server tick, handle input and update the game state by the given duration.
     pub fn tick(&mut self, _input: Input, dt: Duration) -> Result<Vec<Event>, Error> {
-        self.tick += 1;
+        self.state.ecs().write_resource::<Tick>().0 += 1;
         // This tick function is the centre of the Veloren universe. Most server-side things are
         // managed from here, and as such it's important that it stays organised. Please consult
         // the core developers before making significant changes to this code. Here is the
@@ -582,14 +772,13 @@ impl Server {
 
         // 3) Handle inputs from clients
         frontend_events.append(&mut self.handle_new_connections()?);
-        frontend_events.append(&mut self.handle_new_messages()?);
 
         // Handle game events
-        self.handle_events();
+        frontend_events.append(&mut self.handle_events());
 
         let before_tick_4 = Instant::now();
         // 4) Tick the client's LocalState.
-        self.state.tick(dt);
+        self.state.tick(dt, sys::add_server_systems);
 
         // Tick the world
         self.world.tick(dt);
@@ -601,7 +790,7 @@ impl Server {
             let (chunk, supplement) = match res {
                 Ok((chunk, supplement)) => (chunk, supplement),
                 Err(entity) => {
-                    self.clients.notify(
+                    self.notify_client(
                         entity,
                         ServerMsg::TerrainChunkUpdate {
                             key,
@@ -612,14 +801,14 @@ impl Server {
                 }
             };
             // Send the chunk to all nearby players.
-            for (entity, view_distance, pos) in (
-                &self.state.ecs().entities(),
+            for (view_distance, pos, client) in (
                 &self.state.ecs().read_storage::<comp::Player>(),
                 &self.state.ecs().read_storage::<comp::Pos>(),
+                &mut self.state.ecs().write_storage::<Client>(),
             )
                 .join()
-                .filter_map(|(entity, player, pos)| {
-                    player.view_distance.map(|vd| (entity, vd, pos))
+                .filter_map(|(player, pos, client)| {
+                    player.view_distance.map(|vd| (vd, pos, client))
                 })
             {
                 let chunk_pos = self.state.terrain().pos_key(pos.0.map(|e| e as i32));
@@ -628,13 +817,10 @@ impl Server {
                     .magnitude_squared();
 
                 if adjusted_dist_sqr <= view_distance.pow(2) {
-                    self.clients.notify(
-                        entity,
-                        ServerMsg::TerrainChunkUpdate {
-                            key,
-                            chunk: Ok(Box::new(chunk.clone())),
-                        },
-                    );
+                    client.notify(ServerMsg::TerrainChunkUpdate {
+                        key,
+                        chunk: Ok(Box::new(chunk.clone())),
+                    });
                 }
             }
 
@@ -758,10 +944,10 @@ impl Server {
         'chunk: for chunk_key in &self.state.terrain_changes().modified_chunks {
             let terrain = self.state.terrain();
 
-            for (entity, player, pos) in (
-                &self.state.ecs().entities(),
+            for (player, pos, client) in (
                 &self.state.ecs().read_storage::<comp::Player>(),
                 &self.state.ecs().read_storage::<comp::Pos>(),
+                &mut self.state.ecs().write_storage::<Client>(),
             )
                 .join()
             {
@@ -770,16 +956,13 @@ impl Server {
                     .map(|vd| chunk_in_vd(pos.0, *chunk_key, &terrain, vd))
                     .unwrap_or(false)
                 {
-                    self.clients.notify(
-                        entity,
-                        ServerMsg::TerrainChunkUpdate {
-                            key: *chunk_key,
-                            chunk: Ok(Box::new(match self.state.terrain().get_key(*chunk_key) {
-                                Some(chunk) => chunk.clone(),
-                                None => break 'chunk,
-                            })),
-                        },
-                    );
+                    client.notify(ServerMsg::TerrainChunkUpdate {
+                        key: *chunk_key,
+                        chunk: Ok(Box::new(match self.state.terrain().get_key(*chunk_key) {
+                            Some(chunk) => chunk.clone(),
+                            None => break 'chunk,
+                        })),
+                    });
                 }
             }
         }
@@ -787,14 +970,15 @@ impl Server {
         // Sync changed blocks
         let msg =
             ServerMsg::TerrainBlockUpdates(self.state.terrain_changes().modified_blocks.clone());
-        for (entity, player) in (
-            &self.state.ecs().entities(),
+        for (player, client) in (
             &self.state.ecs().read_storage::<comp::Player>(),
+            &mut self.state.ecs().write_storage::<Client>(),
         )
             .join()
         {
+            // TODO: Don't send all changed blocks to all clients
             if player.view_distance.is_some() {
-                self.clients.notify(entity, msg.clone());
+                client.notify(msg.clone());
             }
         }
 
@@ -813,7 +997,7 @@ impl Server {
                 .collect::<Vec<_>>()
         };
         for entity in to_delete {
-            let _ = self.state.ecs_mut().delete_entity_synced(entity);
+            let _ = self.state.ecs_mut().delete_entity(entity);
         }
 
         let before_tick_7 = Instant::now();
@@ -834,7 +1018,9 @@ impl Server {
             .tick_time
             .with_label_values(&["sync"])
             .set((before_tick_7 - before_tick_6).as_nanos() as i64);
-        self.metrics.player_online.set(self.clients.len() as i64);
+        self.metrics
+            .player_online
+            .set(self.state.ecs().read_storage::<Client>().join().count() as i64);
         self.metrics
             .time_of_day
             .set(self.state.ecs().read_resource::<TimeOfDay>().0);
@@ -869,488 +1055,51 @@ impl Server {
         let mut frontend_events = Vec::new();
 
         for postbox in self.postoffice.new_postboxes() {
-            let entity = self.state.ecs_mut().create_entity_synced().build();
             let mut client = Client {
                 client_state: ClientState::Connected,
                 postbox,
                 last_ping: self.state.get_time(),
             };
 
-            if self.server_settings.max_players <= self.clients.len() {
+            if self.server_settings.max_players
+                <= self.state.ecs().read_storage::<Client>().join().count()
+            {
+                // Note: in this case the client is dropped
                 client.notify(ServerMsg::Error(ServerError::TooManyPlayers));
             } else {
+                let entity = self
+                    .state
+                    .ecs_mut()
+                    .create_entity_synced()
+                    .with(client)
+                    .build();
                 // Return the state of the current world (all of the components that Sphynx tracks).
                 log::info!("Starting initial sync with client.");
-                client.notify(ServerMsg::InitialSync {
-                    ecs_state: self.state.ecs().gen_state_package(),
-                    entity_uid: self.state.ecs().uid_from_entity(entity).unwrap().into(), // Can't fail.
-                    server_info: self.server_info.clone(),
-                    // world_map: (WORLD_SIZE/*, self.world.sim().get_map()*/),
-                });
+                self.state
+                    .ecs()
+                    .write_storage::<Client>()
+                    .get_mut(entity)
+                    .unwrap()
+                    .notify(ServerMsg::InitialSync {
+                        ecs_state: self.state.ecs().gen_state_package(),
+                        entity_uid: self.state.ecs().uid_from_entity(entity).unwrap().into(), // Can't fail.
+                        server_info: self.server_info.clone(),
+                        // world_map: (WORLD_SIZE/*, self.world.sim().get_map()*/),
+                    });
                 log::info!("Done initial sync with client.");
 
                 frontend_events.push(Event::ClientConnected { entity });
             }
-
-            self.clients.add(entity, client);
         }
 
         Ok(frontend_events)
     }
 
-    /// Handle new client messages.
-    fn handle_new_messages(&mut self) -> Result<Vec<Event>, Error> {
-        let mut frontend_events = Vec::new();
-
-        let accounts = &mut self.accounts;
-        let server_settings = &self.server_settings;
-
-        let state = &mut self.state;
-        let mut new_chat_msgs = Vec::new();
-        let mut disconnected_clients = Vec::new();
-        let mut requested_chunks = Vec::new();
-        let mut dropped_items = Vec::new();
-
-        self.clients.remove_if(|entity, client| {
-            let mut disconnect = false;
-            let new_msgs = client.postbox.new_messages();
-
-            // Update client ping.
-            if new_msgs.len() > 0 {
-                client.last_ping = state.get_time();
-
-                // Process incoming messages.
-                for msg in new_msgs {
-                    match msg {
-                        ClientMsg::RequestState(requested_state) => match requested_state {
-                            ClientState::Connected => disconnect = true, // Default state
-                            ClientState::Registered => match client.client_state {
-                                // Use ClientMsg::Register instead.
-                                ClientState::Connected => {
-                                    client.error_state(RequestStateError::WrongMessage)
-                                }
-                                ClientState::Registered => {
-                                    client.error_state(RequestStateError::Already)
-                                }
-                                ClientState::Spectator
-                                | ClientState::Character
-                                | ClientState::Dead => client.allow_state(ClientState::Registered),
-                                ClientState::Pending => {}
-                            },
-                            ClientState::Spectator => match requested_state {
-                                // Become Registered first.
-                                ClientState::Connected => {
-                                    client.error_state(RequestStateError::Impossible)
-                                }
-                                ClientState::Spectator => {
-                                    client.error_state(RequestStateError::Already)
-                                }
-                                ClientState::Registered
-                                | ClientState::Character
-                                | ClientState::Dead => client.allow_state(ClientState::Spectator),
-                                ClientState::Pending => {}
-                            },
-                            // Use ClientMsg::Character instead.
-                            ClientState::Character => {
-                                client.error_state(RequestStateError::WrongMessage)
-                            }
-                            ClientState::Dead => client.error_state(RequestStateError::Impossible),
-                            ClientState::Pending => {}
-                        },
-                        // Valid player
-                        ClientMsg::Register { player, password } if player.is_valid() => {
-                            if !accounts.query(player.alias.clone(), password) {
-                                client.error_state(RequestStateError::Denied);
-                                break;
-                            }
-                            match client.client_state {
-                                ClientState::Connected => {
-                                    Self::initialize_player(state, entity, client, player);
-                                }
-                                // Use RequestState instead (No need to send `player` again).
-                                _ => client.error_state(RequestStateError::Impossible),
-                            }
-                            //client.allow_state(ClientState::Registered);
-                        }
-                        // Invalid player
-                        ClientMsg::Register { .. } => {
-                            client.error_state(RequestStateError::Impossible)
-                        }
-                        ClientMsg::SetViewDistance(view_distance) => match client.client_state {
-                            ClientState::Character { .. } => {
-                                state
-                                    .ecs_mut()
-                                    .write_storage::<comp::Player>()
-                                    .get_mut(entity)
-                                    .map(|player| player.view_distance = Some(view_distance));
-                            }
-                            _ => {}
-                        },
-                        ClientMsg::UseInventorySlot(x) => {
-                            let item = state
-                                .ecs()
-                                .write_storage::<comp::Inventory>()
-                                .get_mut(entity)
-                                .and_then(|inv| inv.remove(x));
-
-                            match item {
-                                Some(comp::Item::Tool { .. }) | Some(comp::Item::Debug(_)) => {
-                                    if let Some(stats) =
-                                        state.ecs().write_storage::<comp::Stats>().get_mut(entity)
-                                    {
-                                        // Insert old item into inventory
-                                        if let Some(old_item) = stats.equipment.main.take() {
-                                            state
-                                                .ecs()
-                                                .write_storage::<comp::Inventory>()
-                                                .get_mut(entity)
-                                                .map(|inv| inv.insert(x, old_item));
-                                        }
-
-                                        stats.equipment.main = item;
-                                    }
-                                }
-                                Some(comp::Item::Consumable { effect, .. }) => {
-                                    state.apply_effect(entity, effect);
-                                }
-                                Some(item) => {
-                                    // Re-insert it if unused
-                                    let _ = state
-                                        .ecs()
-                                        .write_storage::<comp::Inventory>()
-                                        .get_mut(entity)
-                                        .map(|inv| inv.insert(x, item));
-                                }
-                                _ => {}
-                            }
-                            state.write_component(entity, comp::InventoryUpdate);
-                        }
-                        ClientMsg::SwapInventorySlots(a, b) => {
-                            state
-                                .ecs()
-                                .write_storage::<comp::Inventory>()
-                                .get_mut(entity)
-                                .map(|inv| inv.swap_slots(a, b));
-                            state.write_component(entity, comp::InventoryUpdate);
-                        }
-                        ClientMsg::DropInventorySlot(x) => {
-                            let item = state
-                                .ecs()
-                                .write_storage::<comp::Inventory>()
-                                .get_mut(entity)
-                                .and_then(|inv| inv.remove(x));
-
-                            state.write_component(entity, comp::InventoryUpdate);
-
-                            if let (Some(item), Some(pos)) =
-                                (item, state.ecs().read_storage::<comp::Pos>().get(entity))
-                            {
-                                dropped_items.push((
-                                    *pos,
-                                    state
-                                        .ecs()
-                                        .read_storage::<comp::Ori>()
-                                        .get(entity)
-                                        .copied()
-                                        .unwrap_or(comp::Ori(Vec3::unit_y())),
-                                    item,
-                                ));
-                            }
-                        }
-                        ClientMsg::PickUp(uid) => {
-                            let item_entity = state.ecs_mut().entity_from_uid(uid);
-
-                            let ecs = state.ecs_mut();
-
-                            let item_entity = if let (Some((item, item_entity)), Some(inv)) = (
-                                item_entity.and_then(|item_entity| {
-                                    ecs.write_storage::<comp::Item>()
-                                        .get_mut(item_entity)
-                                        .map(|item| (item.clone(), item_entity))
-                                }),
-                                ecs.write_storage::<comp::Inventory>().get_mut(entity),
-                            ) {
-                                if inv.push(item).is_none() {
-                                    Some(item_entity)
-                                } else {
-                                    None
-                                }
-                            } else {
-                                None
-                            };
-
-                            if let Some(item_entity) = item_entity {
-                                let _ = ecs.delete_entity_synced(item_entity);
-                            }
-
-                            state.write_component(entity, comp::InventoryUpdate);
-                        }
-                        ClientMsg::Character { name, body, main } => match client.client_state {
-                            // Become Registered first.
-                            ClientState::Connected => {
-                                client.error_state(RequestStateError::Impossible)
-                            }
-                            ClientState::Registered
-                            | ClientState::Spectator
-                            | ClientState::Dead => {
-                                if let (Some(player), None) = (
-                                    state.ecs().read_storage::<comp::Player>().get(entity),
-                                    // Only send login message if the player didn't have a body
-                                    // previously
-                                    state.ecs().read_storage::<comp::Body>().get(entity),
-                                ) {
-                                    new_chat_msgs.push((
-                                        None,
-                                        ServerMsg::broadcast(format!(
-                                            "[{}] is now online.",
-                                            &player.alias
-                                        )),
-                                    ));
-                                }
-
-                                Self::create_player_character(
-                                    state,
-                                    entity,
-                                    client,
-                                    name,
-                                    body,
-                                    main.map(|t| comp::Item::Tool {
-                                        kind: t,
-                                        power: 10,
-                                        stamina: 0,
-                                        strength: 0,
-                                        dexterity: 0,
-                                        intelligence: 0,
-                                    }),
-                                    &server_settings,
-                                );
-                                Self::initialize_region_subscription(state, client, entity);
-                            }
-                            ClientState::Character => {
-                                client.error_state(RequestStateError::Already)
-                            }
-                            ClientState::Pending => {}
-                        },
-                        ClientMsg::Controller(controller) => match client.client_state {
-                            ClientState::Connected
-                            | ClientState::Registered
-                            | ClientState::Spectator => {
-                                client.error_state(RequestStateError::Impossible)
-                            }
-                            ClientState::Dead | ClientState::Character => {
-                                state.write_component(entity, controller);
-                            }
-                            ClientState::Pending => {}
-                        },
-                        ClientMsg::ChatMsg { chat_type, message } => match client.client_state {
-                            ClientState::Connected => {
-                                client.error_state(RequestStateError::Impossible)
-                            }
-                            ClientState::Registered
-                            | ClientState::Spectator
-                            | ClientState::Dead
-                            | ClientState::Character => match validate_chat_msg(&message) {
-                                Ok(()) => new_chat_msgs.push((
-                                    Some(entity),
-                                    ServerMsg::ChatMsg { chat_type, message },
-                                )),
-                                Err(ChatMsgValidationError::TooLong) => log::warn!(
-                                    "Recieved a chat message that's too long (max:{} len:{})",
-                                    MAX_BYTES_CHAT_MSG,
-                                    message.len()
-                                ),
-                            },
-                            ClientState::Pending => {}
-                        },
-                        ClientMsg::PlayerPhysics { pos, vel, ori } => match client.client_state {
-                            ClientState::Character => {
-                                state.write_component(entity, pos);
-                                state.write_component(entity, vel);
-                                state.write_component(entity, ori);
-                            }
-                            // Only characters can send positions.
-                            _ => client.error_state(RequestStateError::Impossible),
-                        },
-                        ClientMsg::BreakBlock(pos) => {
-                            if state
-                                .ecs_mut()
-                                .read_storage::<comp::CanBuild>()
-                                .get(entity)
-                                .is_some()
-                            {
-                                state.set_block(pos, Block::empty());
-                            }
-                        }
-                        ClientMsg::PlaceBlock(pos, block) => {
-                            if state
-                                .ecs_mut()
-                                .read_storage::<comp::CanBuild>()
-                                .get(entity)
-                                .is_some()
-                            {
-                                state.try_set_block(pos, block);
-                            }
-                        }
-                        ClientMsg::CollectBlock(pos) => {
-                            let block = state.terrain().get(pos).ok().copied();
-                            if let Some(block) = block {
-                                if block.is_collectible()
-                                    && state
-                                        .ecs()
-                                        .read_storage::<comp::Inventory>()
-                                        .get(entity)
-                                        .map(|inv| !inv.is_full())
-                                        .unwrap_or(false)
-                                {
-                                    if state.try_set_block(pos, Block::empty()).is_some() {
-                                        comp::Item::try_reclaim_from_block(block)
-                                            .map(|item| state.give_item(entity, item));
-                                    }
-                                }
-                            }
-                        }
-                        ClientMsg::TerrainChunkRequest { key } => match client.client_state {
-                            ClientState::Connected
-                            | ClientState::Registered
-                            | ClientState::Dead => {
-                                client.error_state(RequestStateError::Impossible);
-                            }
-                            ClientState::Spectator | ClientState::Character => {
-                                match state.terrain().get_key(key) {
-                                    Some(chunk) => {
-                                        client.postbox.send_message(ServerMsg::TerrainChunkUpdate {
-                                            key,
-                                            chunk: Ok(Box::new(chunk.clone())),
-                                        })
-                                    }
-                                    None => requested_chunks.push((entity, key)),
-                                }
-                            }
-                            ClientState::Pending => {}
-                        },
-                        // Always possible.
-                        ClientMsg::Ping => client.postbox.send_message(ServerMsg::Pong),
-                        ClientMsg::Pong => {}
-                        ClientMsg::Disconnect => {
-                            disconnect = true;
-                        }
-                    }
-                }
-            } else if state.get_time() - client.last_ping > CLIENT_TIMEOUT || // Timeout
-                client.postbox.error().is_some()
-            // Postbox error
-            {
-                disconnect = true;
-            } else if state.get_time() - client.last_ping > CLIENT_TIMEOUT * 0.5 {
-                // Try pinging the client if the timeout is nearing.
-                client.postbox.send_message(ServerMsg::Ping);
-            }
-
-            if disconnect {
-                if let (Some(player), Some(_)) = (
-                    state.ecs().read_storage::<comp::Player>().get(entity),
-                    // It only shows a message if you had a body (not in char selection)
-                    state.ecs().read_storage::<comp::Body>().get(entity),
-                ) {
-                    new_chat_msgs.push((
-                        None,
-                        ServerMsg::broadcast(format!("{} went offline.", &player.alias)),
-                    ));
-                }
-                disconnected_clients.push(entity);
-                client.postbox.send_message(ServerMsg::Disconnect);
-                true
-            } else {
-                false
-            }
-        });
-
-        // Handle new chat messages.
-        for (entity, msg) in new_chat_msgs {
-            match msg {
-                ServerMsg::ChatMsg { chat_type, message } => {
-                    if let Some(entity) = entity {
-                        // Handle chat commands.
-                        if message.starts_with("/") && message.len() > 1 {
-                            let argv = String::from(&message[1..]);
-                            self.process_chat_cmd(entity, argv);
-                        } else {
-                            let message =
-                                match self.state.ecs().read_storage::<comp::Player>().get(entity) {
-                                    Some(player) => {
-                                        if self.entity_is_admin(entity) {
-                                            format!("[ADMIN][{}] {}", &player.alias, message)
-                                        } else {
-                                            format!("[{}] {}", &player.alias, message)
-                                        }
-                                    }
-                                    None => format!("[<Unknown>] {}", message),
-                                };
-                            self.clients
-                                .notify_registered(ServerMsg::ChatMsg { chat_type, message });
-                        }
-                    } else {
-                        self.clients
-                            .notify_registered(ServerMsg::ChatMsg { chat_type, message });
-                    }
-                }
-                _ => {
-                    panic!("Invalid message type.");
-                }
-            }
-        }
-
-        // Handle client disconnects.
-        for entity in disconnected_clients {
-            if let Err(err) = self.state.ecs_mut().delete_entity_synced(entity) {
-                debug!("Failed to delete disconnected client: {:?}", err);
-            }
-
-            frontend_events.push(Event::ClientDisconnected { entity });
-        }
-
-        // Generate requested chunks.
-        for (entity, key) in requested_chunks {
-            self.generate_chunk(entity, key);
-        }
-
-        for (pos, ori, item) in dropped_items {
-            let vel = ori.0.normalized() * 5.0
-                + Vec3::unit_z() * 10.0
-                + Vec3::<f32>::zero().map(|_| rand::thread_rng().gen::<f32>() - 0.5) * 4.0;
-            self.create_object(Default::default(), comp::object::Body::Pouch)
-                .with(comp::Pos(pos.0 + Vec3::unit_z() * 0.25))
-                .with(item)
-                .with(comp::Vel(vel))
-                .build();
-        }
-
-        Ok(frontend_events)
-    }
-
-    /// Initialize a new client states with important information.
-    fn initialize_player(
-        state: &mut State,
-        entity: specs::Entity,
-        client: &mut Client,
-        player: comp::Player,
-    ) {
-        // Save player metadata (for example the username).
-        state.write_component(entity, player);
-
-        // Tell the client its request was successful.
-        client.allow_state(ClientState::Registered);
-    }
-
-    /// Initialize region subscription, entity should be the client's entity
-    fn initialize_region_subscription(
-        state: &mut State,
-        client: &mut Client,
-        entity: specs::Entity,
-    ) {
+    /// Initialize region subscription
+    fn initialize_region_subscription(state: &mut State, entity: specs::Entity) {
         let mut subscription = None;
 
-        if let (Some(client_pos), Some(client_vd)) = (
+        if let (Some(client_pos), Some(client_vd), Some(client)) = (
             state.ecs().read_storage::<comp::Pos>().get(entity),
             state
                 .ecs()
@@ -1358,6 +1107,7 @@ impl Server {
                 .get(entity)
                 .map(|pl| pl.view_distance)
                 .and_then(|v| v),
+            state.ecs().write_storage::<Client>().get_mut(entity),
         ) {
             use common::region::RegionMap;
 
@@ -1424,323 +1174,16 @@ impl Server {
 
     /// Sync client states with the most up to date information.
     fn sync_clients(&mut self) {
-        use common::region::{region_in_vd, regions_in_vd, Event as RegionEvent, RegionMap};
-        //use hibitset::BitSetLike;
-
-        let ecs = self.state.ecs_mut();
-        let clients = &mut self.clients;
-
+        let sync_package = self.state.ecs_mut().next_sync_package();
         // Sync 'logical' state using Sphynx.
-        clients.notify_registered(ServerMsg::EcsSync(ecs.next_sync_package()));
-
-        // To update subscriptions
-        // 1. Iterate through clients
-        // 2. Calculate current chunk position
-        // 3. If chunk is the same return, otherwise continue (use fuzzyiness)
-        // 4. Iterate through subscribed regions
-        // 5. Check if region is still in range (use fuzzyiness)
-        // 6. If not in range
-        //     - remove from hashset
-        //     - inform client of which entities to remove
-        // 7. Determine list of regions that are in range and iterate through it
-        //    - check if in hashset (hash calc) if not add it
-        let mut regions_to_remove = Vec::new();
-        for (entity, subscription, pos, vd) in (
-            &ecs.entities(),
-            &mut ecs.write_storage::<RegionSubscription>(),
-            &ecs.read_storage::<comp::Pos>(),
-            &ecs.read_storage::<comp::Player>(),
-        )
-            .join()
-            .filter_map(|(e, s, pos, player)| player.view_distance.map(|v| (e, s, pos, v)))
-        {
-            let chunk = (Vec2::<f32>::from(pos.0))
-                .map2(TerrainChunkSize::RECT_SIZE, |e, sz| e as i32 / sz as i32);
-            // Only update regions when moving to a new chunk
-            // uses a fuzzy border to prevent rapid triggering when moving along chunk boundaries
-            if chunk != subscription.fuzzy_chunk
-                && (subscription
-                    .fuzzy_chunk
-                    .map2(TerrainChunkSize::RECT_SIZE, |e, sz| {
-                        (e as f32 + 0.5) * sz as f32
-                    })
-                    - Vec2::from(pos.0))
-                .map2(TerrainChunkSize::RECT_SIZE, |e, sz| {
-                    e.abs() > (sz / 2 + client::CHUNK_FUZZ) as f32
-                })
-                .reduce_or()
-            {
-                // Update current chunk
-                subscription.fuzzy_chunk = (Vec2::<f32>::from(pos.0))
-                    .map2(TerrainChunkSize::RECT_SIZE, |e, sz| e as i32 / sz as i32);
-                // Use the largest side length as our chunk size
-                let chunk_size = TerrainChunkSize::RECT_SIZE.reduce_max() as f32;
-                // Iterate through currently subscribed regions
-                for key in &subscription.regions {
-                    // Check if the region is not within range anymore
-                    if !region_in_vd(
-                        *key,
-                        pos.0,
-                        (vd as f32 * chunk_size)
-                            + (client::CHUNK_FUZZ as f32 + client::REGION_FUZZ as f32 + chunk_size)
-                                * 2.0f32.sqrt(),
-                    ) {
-                        // Add to the list of regions to remove
-                        regions_to_remove.push(*key);
-                    }
-                }
-
-                let mut client = clients.get_mut(&entity);
-                // Iterate through regions to remove
-                for key in regions_to_remove.drain(..) {
-                    // Remove region from this clients set of subscribed regions
-                    subscription.regions.remove(&key);
-                    // Tell the client to delete the entities in that region if it exists in the RegionMap
-                    if let (Some(ref mut client), Some(region)) =
-                        (&mut client, ecs.read_resource::<RegionMap>().get(key))
-                    {
-                        // Process entity left events since they won't be processed below because this region is no longer subscribed to
-                        for event in region.events() {
-                            match event {
-                                RegionEvent::Entered(_, _) => {} // These don't need to be processed because this region is being thrown out anyway
-                                RegionEvent::Left(id, maybe_key) => {
-                                    // Lookup UID for entity
-                                    if let Some(&uid) =
-                                        ecs.read_storage::<Uid>().get(ecs.entities().entity(*id))
-                                    {
-                                        if !maybe_key
-                                            .as_ref()
-                                            .map(|key| subscription.regions.contains(key))
-                                            .unwrap_or(false)
-                                        {
-                                            client.notify(ServerMsg::DeleteEntity(uid.into()));
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        for (&uid, _) in (&ecs.read_storage::<Uid>(), region.entities()).join() {
-                            client.notify(ServerMsg::DeleteEntity(uid.into()))
-                        }
-                    }
-                }
-
-                for key in regions_in_vd(
-                    pos.0,
-                    (vd as f32 * chunk_size)
-                        + (client::CHUNK_FUZZ as f32 + chunk_size) * 2.0f32.sqrt(),
-                ) {
-                    if subscription.regions.insert(key) {
-                        // TODO: send the client initial infromation for all the entities in this region
-                    }
-                }
-            }
-        }
-
-        // To send entity updates
-        // 1. Iterate through regions
-        // 2. Iterate through region subscribers (ie clients)
-        //     - Collect a list of entity ids for clients who are subscribed to this region (hash calc to check each)
-        // 3. Iterate through events from that region
-        //     - For each entity left event, iterate through the client list and check if they are subscribed to the destination (hash calc per subscribed client per entity left event)
-        //     - Do something with entity entered events when sphynx is removed??
-        // 4. Iterate through entities in that region
-        // 5. Inform clients of the component changes for that entity
-        //     - Throttle update rate base on distance to each client
-
-        // Sync physics
-        // via iterating through regions
-        for (key, region) in ecs.read_resource::<RegionMap>().iter() {
-            let subscriptions = ecs.read_storage::<RegionSubscription>();
-            let subscribers = (
-                &ecs.entities(),
-                &subscriptions,
-                &ecs.read_storage::<comp::Pos>(),
-            )
-                .join()
-                .filter_map(|(entity, subscription, pos)| {
-                    if subscription.regions.contains(&key) {
-                        clients
-                            .get_client_index_ingame(&entity)
-                            .map(|index| (index, &subscription.regions, entity, *pos))
-                    } else {
-                        None
-                    }
-                })
-                .collect::<Vec<_>>();
-
-            for event in region.events() {
-                match event {
-                    RegionEvent::Entered(_, _) => {} // TODO use this
-                    RegionEvent::Left(id, maybe_key) => {
-                        // Lookup UID for entity
-                        if let Some(&uid) =
-                            ecs.read_storage::<Uid>().get(ecs.entities().entity(*id))
-                        {
-                            for (client_index, regions, _, _) in &subscribers {
-                                if !maybe_key
-                                    .as_ref()
-                                    .map(|key| regions.contains(key))
-                                    .unwrap_or(false)
-                                {
-                                    clients.notify_index(
-                                        *client_index,
-                                        ServerMsg::DeleteEntity(uid.into()),
-                                    );
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            let tick = self.tick;
-            let send_msg = |msg: ServerMsg,
-                            entity: EcsEntity,
-                            pos: comp::Pos,
-                            force_update,
-                            clients: &mut Clients,
-                            throttle: bool| {
-                for (index, _, client_entity, client_pos) in &subscribers {
-                    match force_update {
-                        None if client_entity == &entity => {}
-                        _ => {
-                            let distance_sq = client_pos.0.distance_squared(pos.0);
-
-                            // Throttle update rate based on distance to player
-                            let update = if !throttle || distance_sq < 100.0f32.powi(2) {
-                                true // Closer than 100.0 blocks
-                            } else if distance_sq < 150.0f32.powi(2) {
-                                (tick + entity.id() as u64) % 2 == 0
-                            } else if distance_sq < 200.0f32.powi(2) {
-                                (tick + entity.id() as u64) % 4 == 0
-                            } else if distance_sq < 250.0f32.powi(2) {
-                                (tick + entity.id() as u64) % 8 == 0
-                            } else if distance_sq < 300.0f32.powi(2) {
-                                (tick + entity.id() as u64) % 16 == 0
-                            } else {
-                                (tick + entity.id() as u64) % 32 == 0
-                            };
-
-                            if update {
-                                clients.notify_index(*index, msg.clone());
-                            }
-                        }
-                    }
-                }
-            };
-
-            for (_, entity, &uid, &pos, maybe_vel, maybe_ori, character_state, force_update) in (
-                region.entities(),
-                &ecs.entities(),
-                &ecs.read_storage::<Uid>(),
-                &ecs.read_storage::<comp::Pos>(),
-                ecs.read_storage::<comp::Vel>().maybe(),
-                ecs.read_storage::<comp::Ori>().maybe(),
-                ecs.read_storage::<comp::CharacterState>().maybe(),
-                ecs.read_storage::<comp::ForceUpdate>().maybe(),
-            )
-                .join()
-            {
-                let mut last_pos = ecs.write_storage::<comp::Last<comp::Pos>>();
-                let mut last_vel = ecs.write_storage::<comp::Last<comp::Vel>>();
-                let mut last_ori = ecs.write_storage::<comp::Last<comp::Ori>>();
-                let mut last_character_state =
-                    ecs.write_storage::<comp::Last<comp::CharacterState>>();
-
-                if last_pos.get(entity).map(|&l| l.0 != pos).unwrap_or(true) {
-                    let _ = last_pos.insert(entity, comp::Last(pos));
-                    send_msg(
-                        ServerMsg::EntityPos {
-                            entity: uid.into(),
-                            pos,
-                        },
-                        entity,
-                        pos,
-                        force_update,
-                        clients,
-                        true,
-                    );
-                }
-
-                if let Some(&vel) = maybe_vel {
-                    if last_vel.get(entity).map(|&l| l.0 != vel).unwrap_or(true) {
-                        let _ = last_vel.insert(entity, comp::Last(vel));
-                        send_msg(
-                            ServerMsg::EntityVel {
-                                entity: uid.into(),
-                                vel,
-                            },
-                            entity,
-                            pos,
-                            force_update,
-                            clients,
-                            true,
-                        );
-                    }
-                }
-
-                if let Some(&ori) = maybe_ori {
-                    if last_ori.get(entity).map(|&l| l.0 != ori).unwrap_or(true) {
-                        let _ = last_ori.insert(entity, comp::Last(ori));
-                        send_msg(
-                            ServerMsg::EntityOri {
-                                entity: uid.into(),
-                                ori,
-                            },
-                            entity,
-                            pos,
-                            force_update,
-                            clients,
-                            true,
-                        );
-                    }
-                }
-
-                if let Some(&character_state) = character_state {
-                    if last_character_state
-                        .get(entity)
-                        .map(|&l| !character_state.is_same_state(&l.0))
-                        .unwrap_or(true)
-                    {
-                        let _ = last_character_state.insert(entity, comp::Last(character_state));
-                        send_msg(
-                            ServerMsg::EntityCharacterState {
-                                entity: uid.into(),
-                                character_state,
-                            },
-                            entity,
-                            pos,
-                            force_update,
-                            clients,
-                            false,
-                        );
-                    }
-                }
-            }
-        }
-
-        // Sync inventories
-        for (entity, inventory, _) in (
-            &self.state.ecs().entities(),
-            &self.state.ecs().read_storage::<comp::Inventory>(),
-            &self.state.ecs().read_storage::<comp::InventoryUpdate>(),
-        )
-            .join()
-        {
-            self.clients
-                .notify(entity, ServerMsg::InventoryUpdate(inventory.clone()));
-        }
-
-        // Remove all force flags.
         self.state
-            .ecs_mut()
-            .write_storage::<comp::ForceUpdate>()
-            .clear();
-        self.state
-            .ecs_mut()
-            .write_storage::<comp::InventoryUpdate>()
-            .clear();
+            .notify_registered_clients(ServerMsg::EcsSync(sync_package));
+    }
+
+    pub fn notify_client(&self, entity: EcsEntity, msg: ServerMsg) {
+        if let Some(client) = self.state.ecs().write_storage::<Client>().get_mut(entity) {
+            client.notify(msg)
+        }
     }
 
     pub fn generate_chunk(&mut self, entity: EcsEntity, key: Vec2<i32>) {
@@ -1775,13 +1218,12 @@ impl Server {
             Some(action) => action.execute(self, entity, args),
             // Unknown command
             None => {
-                self.clients.notify(
-                    entity,
-                    ServerMsg::private(format!(
+                if let Some(client) = self.state.ecs().write_storage::<Client>().get_mut(entity) {
+                    client.notify(ServerMsg::private(format!(
                         "Unknown command '/{}'.\nType '/help' for available commands",
                         kwd
-                    )),
-                );
+                    )));
+                }
             }
         }
     }
@@ -1796,13 +1238,14 @@ impl Server {
 
 impl Drop for Server {
     fn drop(&mut self) {
-        self.clients.notify_registered(ServerMsg::Shutdown);
+        self.state.notify_registered_clients(ServerMsg::Shutdown);
     }
 }
 
 trait StateExt {
     fn give_item(&mut self, entity: EcsEntity, item: comp::Item) -> bool;
     fn apply_effect(&mut self, entity: EcsEntity, effect: Effect);
+    fn notify_registered_clients(&self, msg: ServerMsg);
 }
 
 impl StateExt for State {
@@ -1822,17 +1265,26 @@ impl StateExt for State {
     fn apply_effect(&mut self, entity: EcsEntity, effect: Effect) {
         match effect {
             Effect::Health(change) => {
-                self.ecs_mut()
+                self.ecs()
                     .write_storage::<comp::Stats>()
                     .get_mut(entity)
                     .map(|stats| stats.health.change_by(change));
             }
             Effect::Xp(xp) => {
-                self.ecs_mut()
+                self.ecs()
                     .write_storage::<comp::Stats>()
                     .get_mut(entity)
                     .map(|stats| stats.exp.change_by(xp));
             }
         }
     }
+
+    fn notify_registered_clients(&self, msg: ServerMsg) {
+        for client in (&mut self.ecs().write_storage::<Client>())
+            .join()
+            .filter(|c| c.is_registered())
+        {
+            client.notify(msg.clone())
+        }
+    }
 }
diff --git a/server/src/sys/message.rs b/server/src/sys/message.rs
new file mode 100644
index 0000000000..d611c42582
--- /dev/null
+++ b/server/src/sys/message.rs
@@ -0,0 +1,320 @@
+use crate::{auth_provider::AuthProvider, client::Client, CLIENT_TIMEOUT};
+use common::{
+    comp::{Admin, Body, CanBuild, Controller, Item, Ori, Player, Pos, Vel},
+    event::{EventBus, ServerEvent},
+    msg::{validate_chat_msg, ChatMsgValidationError, MAX_BYTES_CHAT_MSG},
+    msg::{ClientMsg, ClientState, RequestStateError, ServerMsg},
+    state::{BlockChange, Time},
+    terrain::{Block, TerrainGrid},
+    vol::Vox,
+};
+use specs::{
+    Entities, Join, Read, ReadExpect, ReadStorage, System, Write, WriteExpect, WriteStorage,
+};
+
+/// This system will handle new messages from clients
+pub struct Sys;
+impl<'a> System<'a> for Sys {
+    type SystemData = (
+        Entities<'a>,
+        Read<'a, EventBus<ServerEvent>>,
+        Read<'a, Time>,
+        ReadExpect<'a, TerrainGrid>,
+        ReadStorage<'a, Body>,
+        ReadStorage<'a, CanBuild>,
+        ReadStorage<'a, Admin>,
+        WriteExpect<'a, AuthProvider>,
+        Write<'a, BlockChange>,
+        WriteStorage<'a, Pos>,
+        WriteStorage<'a, Vel>,
+        WriteStorage<'a, Ori>,
+        WriteStorage<'a, Player>,
+        WriteStorage<'a, Client>,
+        WriteStorage<'a, Controller>,
+    );
+
+    fn run(
+        &mut self,
+        (
+            entities,
+            server_emitter,
+            time,
+            terrain,
+            bodies,
+            can_build,
+            admins,
+            mut accounts,
+            mut block_changes,
+            mut positions,
+            mut velocities,
+            mut orientations,
+            mut players,
+            mut clients,
+            mut controllers,
+        ): Self::SystemData,
+    ) {
+        let time = time.0;
+
+        let mut new_chat_msgs = Vec::new();
+
+        for (entity, client) in (&entities, &mut clients).join() {
+            let mut disconnect = false;
+            let new_msgs = client.postbox.new_messages();
+
+            // Update client ping.
+            if new_msgs.len() > 0 {
+                client.last_ping = time
+            } else if time - client.last_ping > CLIENT_TIMEOUT // Timeout
+                || client.postbox.error().is_some()
+            // Postbox error
+            {
+                disconnect = true;
+            } else if time - client.last_ping > CLIENT_TIMEOUT * 0.5 {
+                // Try pinging the client if the timeout is nearing.
+                client.postbox.send_message(ServerMsg::Ping);
+            }
+
+            // Process incoming messages.
+            for msg in new_msgs {
+                match msg {
+                    ClientMsg::RequestState(requested_state) => match requested_state {
+                        ClientState::Connected => disconnect = true, // Default state
+                        ClientState::Registered => match client.client_state {
+                            // Use ClientMsg::Register instead.
+                            ClientState::Connected => {
+                                client.error_state(RequestStateError::WrongMessage)
+                            }
+                            ClientState::Registered => {
+                                client.error_state(RequestStateError::Already)
+                            }
+                            ClientState::Spectator | ClientState::Character | ClientState::Dead => {
+                                client.allow_state(ClientState::Registered)
+                            }
+                            ClientState::Pending => {}
+                        },
+                        ClientState::Spectator => match requested_state {
+                            // Become Registered first.
+                            ClientState::Connected => {
+                                client.error_state(RequestStateError::Impossible)
+                            }
+                            ClientState::Spectator => {
+                                client.error_state(RequestStateError::Already)
+                            }
+                            ClientState::Registered
+                            | ClientState::Character
+                            | ClientState::Dead => client.allow_state(ClientState::Spectator),
+                            ClientState::Pending => {}
+                        },
+                        // Use ClientMsg::Character instead.
+                        ClientState::Character => {
+                            client.error_state(RequestStateError::WrongMessage)
+                        }
+                        ClientState::Dead => client.error_state(RequestStateError::Impossible),
+                        ClientState::Pending => {}
+                    },
+                    // Valid player
+                    ClientMsg::Register { player, password } if player.is_valid() => {
+                        if !accounts.query(player.alias.clone(), password) {
+                            client.error_state(RequestStateError::Denied);
+                            break;
+                        }
+                        match client.client_state {
+                            ClientState::Connected => {
+                                let _ = players.insert(entity, player);
+
+                                // Tell the client its request was successful.
+                                client.allow_state(ClientState::Registered);
+                            }
+                            // Use RequestState instead (No need to send `player` again).
+                            _ => client.error_state(RequestStateError::Impossible),
+                        }
+                        //client.allow_state(ClientState::Registered);
+                    }
+                    // Invalid player
+                    ClientMsg::Register { .. } => client.error_state(RequestStateError::Impossible),
+                    ClientMsg::SetViewDistance(view_distance) => match client.client_state {
+                        ClientState::Character { .. } => {
+                            players
+                                .get_mut(entity)
+                                .map(|player| player.view_distance = Some(view_distance));
+                        }
+                        _ => {}
+                    },
+                    ClientMsg::Character { name, body, main } => match client.client_state {
+                        // Become Registered first.
+                        ClientState::Connected => client.error_state(RequestStateError::Impossible),
+                        ClientState::Registered | ClientState::Spectator | ClientState::Dead => {
+                            if let (Some(player), None) = (
+                                players.get(entity),
+                                // Only send login message if the player didn't have a body
+                                // previously
+                                bodies.get(entity),
+                            ) {
+                                new_chat_msgs.push((
+                                    None,
+                                    ServerMsg::broadcast(format!(
+                                        "[{}] is now online.",
+                                        &player.alias
+                                    )),
+                                ));
+                            }
+
+                            server_emitter.emit(ServerEvent::CreatePlayer {
+                                entity,
+                                name,
+                                body,
+                                main: main.map(|t| Item::Tool {
+                                    kind: t,
+                                    power: 10,
+                                    stamina: 0,
+                                    strength: 0,
+                                    dexterity: 0,
+                                    intelligence: 0,
+                                }),
+                            });
+                        }
+                        ClientState::Character => client.error_state(RequestStateError::Already),
+                        ClientState::Pending => {}
+                    },
+                    ClientMsg::ControllerInputs(inputs) => match client.client_state {
+                        ClientState::Connected
+                        | ClientState::Registered
+                        | ClientState::Spectator => {
+                            client.error_state(RequestStateError::Impossible)
+                        }
+                        ClientState::Dead | ClientState::Character => {
+                            if let Some(controller) = controllers.get_mut(entity) {
+                                controller.inputs = inputs;
+                            }
+                        }
+                        ClientState::Pending => {}
+                    },
+                    ClientMsg::ControlEvent(event) => match client.client_state {
+                        ClientState::Connected
+                        | ClientState::Registered
+                        | ClientState::Spectator => {
+                            client.error_state(RequestStateError::Impossible)
+                        }
+                        ClientState::Dead | ClientState::Character => {
+                            if let Some(controller) = controllers.get_mut(entity) {
+                                controller.events.push(event);
+                            }
+                        }
+                        ClientState::Pending => {}
+                    },
+                    ClientMsg::ChatMsg { chat_type, message } => match client.client_state {
+                        ClientState::Connected => client.error_state(RequestStateError::Impossible),
+                        ClientState::Registered
+                        | ClientState::Spectator
+                        | ClientState::Dead
+                        | ClientState::Character => match validate_chat_msg(&message) {
+                            Ok(()) => new_chat_msgs
+                                .push((Some(entity), ServerMsg::ChatMsg { chat_type, message })),
+                            Err(ChatMsgValidationError::TooLong) => log::warn!(
+                                "Recieved a chat message that's too long (max:{} len:{})",
+                                MAX_BYTES_CHAT_MSG,
+                                message.len()
+                            ),
+                        },
+                        ClientState::Pending => {}
+                    },
+                    ClientMsg::PlayerPhysics { pos, vel, ori } => match client.client_state {
+                        ClientState::Character => {
+                            let _ = positions.insert(entity, pos);
+                            let _ = velocities.insert(entity, vel);
+                            let _ = orientations.insert(entity, ori);
+                        }
+                        // Only characters can send positions.
+                        _ => client.error_state(RequestStateError::Impossible),
+                    },
+                    ClientMsg::BreakBlock(pos) => {
+                        if can_build.get(entity).is_some() {
+                            block_changes.set(pos, Block::empty());
+                        }
+                    }
+                    ClientMsg::PlaceBlock(pos, block) => {
+                        if can_build.get(entity).is_some() {
+                            block_changes.try_set(pos, block);
+                        }
+                    }
+                    ClientMsg::TerrainChunkRequest { key } => match client.client_state {
+                        ClientState::Connected | ClientState::Registered | ClientState::Dead => {
+                            client.error_state(RequestStateError::Impossible);
+                        }
+                        ClientState::Spectator | ClientState::Character => {
+                            match terrain.get_key(key) {
+                                Some(chunk) => {
+                                    client.postbox.send_message(ServerMsg::TerrainChunkUpdate {
+                                        key,
+                                        chunk: Ok(Box::new(chunk.clone())),
+                                    })
+                                }
+                                None => server_emitter.emit(ServerEvent::ChunkRequest(entity, key)),
+                            }
+                        }
+                        ClientState::Pending => {}
+                    },
+                    // Always possible.
+                    ClientMsg::Ping => client.postbox.send_message(ServerMsg::Pong),
+                    ClientMsg::Pong => {}
+                    ClientMsg::Disconnect => {
+                        disconnect = true;
+                    }
+                }
+            }
+
+            if disconnect {
+                if let (Some(player), Some(_)) = (
+                    players.get(entity),
+                    // It only shows a message if you had a body (not in char selection)
+                    bodies.get(entity),
+                ) {
+                    new_chat_msgs.push((
+                        None,
+                        ServerMsg::broadcast(format!("{} went offline.", &player.alias)),
+                    ));
+                }
+                server_emitter.emit(ServerEvent::ClientDisconnect(entity));
+                client.postbox.send_message(ServerMsg::Disconnect);
+            }
+        }
+
+        // Handle new chat messages.
+        for (entity, msg) in new_chat_msgs {
+            match msg {
+                ServerMsg::ChatMsg { chat_type, message } => {
+                    if let Some(entity) = entity {
+                        // Handle chat commands.
+                        if message.starts_with("/") && message.len() > 1 {
+                            let argv = String::from(&message[1..]);
+                            server_emitter.emit(ServerEvent::ChatCmd(entity, argv));
+                        } else {
+                            let message = match players.get(entity) {
+                                Some(player) => {
+                                    if admins.get(entity).is_some() {
+                                        format!("[ADMIN][{}] {}", &player.alias, message)
+                                    } else {
+                                        format!("[{}] {}", &player.alias, message)
+                                    }
+                                }
+                                None => format!("[<Unknown>] {}", message),
+                            };
+                            let msg = ServerMsg::ChatMsg { chat_type, message };
+                            for client in (&mut clients).join().filter(|c| c.is_registered()) {
+                                client.notify(msg.clone());
+                            }
+                        }
+                    } else {
+                        let msg = ServerMsg::ChatMsg { chat_type, message };
+                        for client in (&mut clients).join().filter(|c| c.is_registered()) {
+                            client.notify(msg.clone());
+                        }
+                    }
+                }
+                _ => {
+                    panic!("Invalid message type.");
+                }
+            }
+        }
+    }
+}
diff --git a/server/src/sys/mod.rs b/server/src/sys/mod.rs
new file mode 100644
index 0000000000..048f4457c0
--- /dev/null
+++ b/server/src/sys/mod.rs
@@ -0,0 +1,19 @@
+pub mod sync;
+//pub mod sync_chunk;
+pub mod message;
+pub mod subscription;
+
+use specs::DispatcherBuilder;
+
+// System names
+const SYNC_SYS: &str = "server_sync_sys";
+const SUBSCRIPTION_SYS: &str = "server_subscription_sys";
+const MESSAGE_SYS: &str = "server_message_sys";
+//const SYNC_CHUNK_SYS: &str = "server_sync_chunk_sys";
+
+pub fn add_server_systems(dispatch_builder: &mut DispatcherBuilder) {
+    dispatch_builder.add(subscription::Sys, SUBSCRIPTION_SYS, &[]);
+    dispatch_builder.add(sync::Sys, SYNC_SYS, &[SUBSCRIPTION_SYS]);
+    dispatch_builder.add(message::Sys, MESSAGE_SYS, &[]);
+    //dispatch_builder.add(sync_chunk::Sys, SYNC_CHUNKR_SYS, &[]);
+}
diff --git a/server/src/sys/subscription.rs b/server/src/sys/subscription.rs
new file mode 100644
index 0000000000..2727a71001
--- /dev/null
+++ b/server/src/sys/subscription.rs
@@ -0,0 +1,125 @@
+use crate::client::{self, Client, RegionSubscription};
+use common::{
+    comp::{Player, Pos},
+    msg::ServerMsg,
+    region::{region_in_vd, regions_in_vd, Event as RegionEvent, RegionMap},
+    state::Uid,
+    terrain::TerrainChunkSize,
+    vol::RectVolSize,
+};
+use specs::{Entities, Join, ReadExpect, ReadStorage, System, WriteStorage};
+use vek::*;
+
+/// This system will update region subscriptions based on client positions
+pub struct Sys;
+impl<'a> System<'a> for Sys {
+    type SystemData = (
+        Entities<'a>,
+        ReadExpect<'a, RegionMap>,
+        ReadStorage<'a, Uid>,
+        ReadStorage<'a, Pos>,
+        ReadStorage<'a, Player>,
+        WriteStorage<'a, Client>,
+        WriteStorage<'a, RegionSubscription>,
+    );
+
+    fn run(
+        &mut self,
+        (entities, region_map, uids, positions, players, mut clients, mut subscriptions): Self::SystemData,
+    ) {
+        // To update subscriptions
+        // 1. Iterate through clients
+        // 2. Calculate current chunk position
+        // 3. If chunk is the same return, otherwise continue (use fuzzyiness)
+        // 4. Iterate through subscribed regions
+        // 5. Check if region is still in range (use fuzzyiness)
+        // 6. If not in range
+        //     - remove from hashset
+        //     - inform client of which entities to remove
+        // 7. Determine list of regions that are in range and iterate through it
+        //    - check if in hashset (hash calc) if not add it
+        let mut regions_to_remove = Vec::new();
+        for (client, subscription, pos, vd) in
+            (&mut clients, &mut subscriptions, &positions, &players)
+                .join()
+                .filter_map(|(c, s, pos, player)| player.view_distance.map(|v| (c, s, pos, v)))
+        {
+            let chunk = (Vec2::<f32>::from(pos.0))
+                .map2(TerrainChunkSize::RECT_SIZE, |e, sz| e as i32 / sz as i32);
+            // Only update regions when moving to a new chunk
+            // uses a fuzzy border to prevent rapid triggering when moving along chunk boundaries
+            if chunk != subscription.fuzzy_chunk
+                && (subscription
+                    .fuzzy_chunk
+                    .map2(TerrainChunkSize::RECT_SIZE, |e, sz| {
+                        (e as f32 + 0.5) * sz as f32
+                    })
+                    - Vec2::from(pos.0))
+                .map2(TerrainChunkSize::RECT_SIZE, |e, sz| {
+                    e.abs() > (sz / 2 + client::CHUNK_FUZZ) as f32
+                })
+                .reduce_or()
+            {
+                // Update current chunk
+                subscription.fuzzy_chunk = (Vec2::<f32>::from(pos.0))
+                    .map2(TerrainChunkSize::RECT_SIZE, |e, sz| e as i32 / sz as i32);
+                // Use the largest side length as our chunk size
+                let chunk_size = TerrainChunkSize::RECT_SIZE.reduce_max() as f32;
+                // Iterate through currently subscribed regions
+                for key in &subscription.regions {
+                    // Check if the region is not within range anymore
+                    if !region_in_vd(
+                        *key,
+                        pos.0,
+                        (vd as f32 * chunk_size)
+                            + (client::CHUNK_FUZZ as f32 + client::REGION_FUZZ as f32 + chunk_size)
+                                * 2.0f32.sqrt(),
+                    ) {
+                        // Add to the list of regions to remove
+                        regions_to_remove.push(*key);
+                    }
+                }
+
+                // Iterate through regions to remove
+                for key in regions_to_remove.drain(..) {
+                    // Remove region from this clients set of subscribed regions
+                    subscription.regions.remove(&key);
+                    // Tell the client to delete the entities in that region if it exists in the RegionMap
+                    if let Some(region) = region_map.get(key) {
+                        // Process entity left events since they won't be processed during phsyics sync because this region is no longer subscribed to
+                        for event in region.events() {
+                            match event {
+                                RegionEvent::Entered(_, _) => {} // These don't need to be processed because this region is being thrown out anyway
+                                RegionEvent::Left(id, maybe_key) => {
+                                    // Lookup UID for entity
+                                    if let Some(&uid) = uids.get(entities.entity(*id)) {
+                                        if !maybe_key
+                                            .as_ref()
+                                            .map(|key| subscription.regions.contains(key))
+                                            .unwrap_or(false)
+                                        {
+                                            client.notify(ServerMsg::DeleteEntity(uid.into()));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        for (&uid, _) in (&uids, region.entities()).join() {
+                            client.notify(ServerMsg::DeleteEntity(uid.into()))
+                        }
+                    }
+                }
+
+                for key in regions_in_vd(
+                    pos.0,
+                    (vd as f32 * chunk_size)
+                        + (client::CHUNK_FUZZ as f32 + chunk_size) * 2.0f32.sqrt(),
+                ) {
+                    if subscription.regions.insert(key) {
+                        // TODO: send the client initial infromation for all the entities in this region
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/server/src/sys/sync.rs b/server/src/sys/sync.rs
new file mode 100644
index 0000000000..3a1d7cb9e5
--- /dev/null
+++ b/server/src/sys/sync.rs
@@ -0,0 +1,226 @@
+use crate::{
+    client::{Client, RegionSubscription},
+    Tick,
+};
+use common::{
+    comp::{CharacterState, ForceUpdate, Inventory, InventoryUpdate, Last, Ori, Pos, Vel},
+    msg::ServerMsg,
+    region::{Event as RegionEvent, RegionMap},
+    state::Uid,
+};
+use specs::{
+    Entities, Entity as EcsEntity, Join, Read, ReadExpect, ReadStorage, System, WriteStorage,
+};
+
+/// This system will send physics updates to the client
+pub struct Sys;
+impl<'a> System<'a> for Sys {
+    type SystemData = (
+        Entities<'a>,
+        Read<'a, Tick>,
+        ReadExpect<'a, RegionMap>,
+        ReadStorage<'a, Uid>,
+        ReadStorage<'a, Pos>,
+        ReadStorage<'a, Vel>,
+        ReadStorage<'a, Ori>,
+        ReadStorage<'a, CharacterState>,
+        ReadStorage<'a, Inventory>,
+        ReadStorage<'a, RegionSubscription>,
+        WriteStorage<'a, Last<Pos>>,
+        WriteStorage<'a, Last<Vel>>,
+        WriteStorage<'a, Last<Ori>>,
+        WriteStorage<'a, Last<CharacterState>>,
+        WriteStorage<'a, Client>,
+        WriteStorage<'a, ForceUpdate>,
+        WriteStorage<'a, InventoryUpdate>,
+    );
+
+    fn run(
+        &mut self,
+        (
+            entities,
+            tick,
+            region_map,
+            uids,
+            positions,
+            velocities,
+            orientations,
+            character_states,
+            inventories,
+            subscriptions,
+            mut last_pos,
+            mut last_vel,
+            mut last_ori,
+            mut last_character_state,
+            mut clients,
+            mut force_updates,
+            mut inventory_updates,
+        ): Self::SystemData,
+    ) {
+        let tick = tick.0;
+        // To send entity updates
+        // 1. Iterate through regions
+        // 2. Iterate through region subscribers (ie clients)
+        //     - Collect a list of entity ids for clients who are subscribed to this region (hash calc to check each)
+        // 3. Iterate through events from that region
+        //     - For each entity left event, iterate through the client list and check if they are subscribed to the destination (hash calc per subscribed client per entity left event)
+        //     - Do something with entity entered events when sphynx is removed??
+        // 4. Iterate through entities in that region
+        // 5. Inform clients of the component changes for that entity
+        //     - Throttle update rate base on distance to each client
+
+        // Sync physics
+        // via iterating through regions
+        for (key, region) in region_map.iter() {
+            let mut subscribers = (&mut clients, &entities, &subscriptions, &positions)
+                .join()
+                .filter_map(|(client, entity, subscription, pos)| {
+                    if client.is_ingame() && subscription.regions.contains(&key) {
+                        Some((client, &subscription.regions, entity, *pos))
+                    } else {
+                        None
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            for event in region.events() {
+                match event {
+                    RegionEvent::Entered(_, _) => {} // TODO use this
+                    RegionEvent::Left(id, maybe_key) => {
+                        // Lookup UID for entity
+                        if let Some(&uid) = uids.get(entities.entity(*id)) {
+                            for (client, regions, _, _) in &mut subscribers {
+                                if !maybe_key
+                                    .as_ref()
+                                    .map(|key| regions.contains(key))
+                                    .unwrap_or(false)
+                                {
+                                    client.notify(ServerMsg::DeleteEntity(uid.into()));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            let mut send_msg =
+                |msg: ServerMsg, entity: EcsEntity, pos: Pos, force_update, throttle: bool| {
+                    for (client, _, client_entity, client_pos) in &mut subscribers {
+                        match force_update {
+                            None if client_entity == &entity => {}
+                            _ => {
+                                let distance_sq = client_pos.0.distance_squared(pos.0);
+
+                                // Throttle update rate based on distance to player
+                                let update = if !throttle || distance_sq < 100.0f32.powi(2) {
+                                    true // Closer than 100.0 blocks
+                                } else if distance_sq < 150.0f32.powi(2) {
+                                    (tick + entity.id() as u64) % 2 == 0
+                                } else if distance_sq < 200.0f32.powi(2) {
+                                    (tick + entity.id() as u64) % 4 == 0
+                                } else if distance_sq < 250.0f32.powi(2) {
+                                    (tick + entity.id() as u64) % 8 == 0
+                                } else if distance_sq < 300.0f32.powi(2) {
+                                    (tick + entity.id() as u64) % 16 == 0
+                                } else {
+                                    (tick + entity.id() as u64) % 32 == 0
+                                };
+
+                                if update {
+                                    client.notify(msg.clone());
+                                }
+                            }
+                        }
+                    }
+                };
+
+            for (_, entity, &uid, &pos, maybe_vel, maybe_ori, character_state, force_update) in (
+                region.entities(),
+                &entities,
+                &uids,
+                &positions,
+                velocities.maybe(),
+                orientations.maybe(),
+                character_states.maybe(),
+                force_updates.maybe(),
+            )
+                .join()
+            {
+                if last_pos.get(entity).map(|&l| l.0 != pos).unwrap_or(true) {
+                    let _ = last_pos.insert(entity, Last(pos));
+                    send_msg(
+                        ServerMsg::EntityPos {
+                            entity: uid.into(),
+                            pos,
+                        },
+                        entity,
+                        pos,
+                        force_update,
+                        true,
+                    );
+                }
+
+                if let Some(&vel) = maybe_vel {
+                    if last_vel.get(entity).map(|&l| l.0 != vel).unwrap_or(true) {
+                        let _ = last_vel.insert(entity, Last(vel));
+                        send_msg(
+                            ServerMsg::EntityVel {
+                                entity: uid.into(),
+                                vel,
+                            },
+                            entity,
+                            pos,
+                            force_update,
+                            true,
+                        );
+                    }
+                }
+
+                if let Some(&ori) = maybe_ori {
+                    if last_ori.get(entity).map(|&l| l.0 != ori).unwrap_or(true) {
+                        let _ = last_ori.insert(entity, Last(ori));
+                        send_msg(
+                            ServerMsg::EntityOri {
+                                entity: uid.into(),
+                                ori,
+                            },
+                            entity,
+                            pos,
+                            force_update,
+                            true,
+                        );
+                    }
+                }
+
+                if let Some(&character_state) = character_state {
+                    if last_character_state
+                        .get(entity)
+                        .map(|&l| !character_state.is_same_state(&l.0))
+                        .unwrap_or(true)
+                    {
+                        let _ = last_character_state.insert(entity, Last(character_state));
+                        send_msg(
+                            ServerMsg::EntityCharacterState {
+                                entity: uid.into(),
+                                character_state,
+                            },
+                            entity,
+                            pos,
+                            force_update,
+                            false,
+                        );
+                    }
+                }
+            }
+        }
+
+        // Sync inventories
+        for (client, inventory, _) in (&mut clients, &inventories, &inventory_updates).join() {
+            client.notify(ServerMsg::InventoryUpdate(inventory.clone()));
+        }
+
+        // Remove all force flags.
+        force_updates.clear();
+        inventory_updates.clear();
+    }
+}
diff --git a/voxygen/src/menu/char_selection/mod.rs b/voxygen/src/menu/char_selection/mod.rs
index 5a2bd9eff7..acffc56b7e 100644
--- a/voxygen/src/menu/char_selection/mod.rs
+++ b/voxygen/src/menu/char_selection/mod.rs
@@ -117,7 +117,7 @@ impl PlayState for CharSelectionState {
             if let Err(err) = self
                 .client
                 .borrow_mut()
-                .tick(comp::Controller::default(), clock.get_last_delta())
+                .tick(comp::ControllerInputs::default(), clock.get_last_delta())
             {
                 error!("Failed to tick the scene: {:?}", err);
                 return PlayStateResult::Pop;
diff --git a/voxygen/src/session.rs b/voxygen/src/session.rs
index ddccc1134c..0e89fd2907 100644
--- a/voxygen/src/session.rs
+++ b/voxygen/src/session.rs
@@ -25,7 +25,7 @@ pub struct SessionState {
     client: Rc<RefCell<Client>>,
     hud: Hud,
     key_state: KeyState,
-    controller: comp::Controller,
+    inputs: comp::ControllerInputs,
     selected_block: Block,
 }
 
@@ -43,7 +43,7 @@ impl SessionState {
             scene,
             client,
             key_state: KeyState::new(),
-            controller: comp::Controller::default(),
+            inputs: comp::ControllerInputs::default(),
             hud,
             selected_block: Block::new(BlockKind::Normal, Rgb::broadcast(255)),
         }
@@ -53,7 +53,7 @@ impl SessionState {
 impl SessionState {
     /// Tick the session (and the client attached to it).
     fn tick(&mut self, dt: Duration) -> Result<(), Error> {
-        for event in self.client.borrow_mut().tick(self.controller.clone(), dt)? {
+        for event in self.client.borrow_mut().tick(self.inputs.clone(), dt)? {
             match event {
                 client::Event::Chat {
                     chat_type: _,
@@ -139,9 +139,6 @@ impl PlayState for SessionState {
             };
             self.scene.set_select_pos(select_pos);
 
-            // Reset controller events
-            self.controller.clear_events();
-
             // Handle window events.
             for event in global_state.window.fetch_events() {
                 // Pass all events to the ui first.
@@ -168,12 +165,12 @@ impl PlayState for SessionState {
                                 client.place_block(build_pos, self.selected_block);
                             }
                         } else {
-                            self.controller.primary = state
+                            self.inputs.primary = state
                         }
                     }
 
                     Event::InputUpdate(GameInput::Secondary, state) => {
-                        self.controller.secondary = false; // To be changed later on
+                        self.inputs.secondary = false; // To be changed later on
 
                         let mut client = self.client.borrow_mut();
 
@@ -194,7 +191,7 @@ impl PlayState for SessionState {
                             .map(|cs| cs.action.is_wield())
                             .unwrap_or(false)
                         {
-                            self.controller.secondary = state;
+                            self.inputs.secondary = state;
                         } else {
                             if let Some(select_pos) = select_pos {
                                 client.collect_block(select_pos);
@@ -217,36 +214,34 @@ impl PlayState for SessionState {
                                 }
                             }
                         } else {
-                            self.controller.roll = state;
+                            self.inputs.roll = state;
                         }
                     }
                     Event::InputUpdate(GameInput::Respawn, state) => {
-                        self.controller.respawn = state;
+                        self.inputs.respawn = state;
                     }
                     Event::InputUpdate(GameInput::Jump, state) => {
-                        self.controller.jump = state;
+                        self.inputs.jump = state;
                     }
                     Event::InputUpdate(GameInput::Sit, state) => {
-                        self.controller.sit = state;
+                        self.inputs.sit = state;
                     }
                     Event::InputUpdate(GameInput::MoveForward, state) => self.key_state.up = state,
                     Event::InputUpdate(GameInput::MoveBack, state) => self.key_state.down = state,
                     Event::InputUpdate(GameInput::MoveLeft, state) => self.key_state.left = state,
                     Event::InputUpdate(GameInput::MoveRight, state) => self.key_state.right = state,
                     Event::InputUpdate(GameInput::Glide, state) => {
-                        self.controller.glide = state;
+                        self.inputs.glide = state;
                     }
-                    Event::InputUpdate(GameInput::Climb, state) => self.controller.climb = state,
+                    Event::InputUpdate(GameInput::Climb, state) => self.inputs.climb = state,
                     Event::InputUpdate(GameInput::ClimbDown, state) => {
-                        self.controller.climb_down = state
-                    }
-                    Event::InputUpdate(GameInput::WallLeap, state) => {
-                        self.controller.wall_leap = state
+                        self.inputs.climb_down = state
                     }
+                    Event::InputUpdate(GameInput::WallLeap, state) => self.inputs.wall_leap = state,
                     Event::InputUpdate(GameInput::Mount, true) => {
-                        let client = self.client.borrow();
+                        let mut client = self.client.borrow_mut();
                         if client.is_mounted() {
-                            self.controller.push_event(comp::ControlEvent::Unmount);
+                            client.unmount();
                         } else {
                             let player_pos = client
                                 .state()
@@ -271,15 +266,10 @@ impl PlayState for SessionState {
                                     .min_by_key(|(_, pos, _)| {
                                         (player_pos.0.distance_squared(pos.0) * 1000.0) as i32
                                     })
-                                    .map(|(entity, _, _)| entity);
+                                    .map(|(uid, _, _)| uid);
 
-                                if let Some(mountee_uid) =
-                                    closest_mountable.and_then(|mountee_entity| {
-                                        client.state().ecs().uid_from_entity(mountee_entity)
-                                    })
-                                {
-                                    self.controller
-                                        .push_event(comp::ControlEvent::Mount(mountee_uid.into()));
+                                if let Some(mountee_entity) = closest_mountable {
+                                    client.mount(mountee_entity);
                                 }
                             }
                         }
@@ -329,9 +319,9 @@ impl PlayState for SessionState {
                 Vec2::new(ori[0].sin(), ori[0].cos()),
             );
             let dir_vec = self.key_state.dir_vec();
-            self.controller.move_dir = unit_vecs.0 * dir_vec[0] + unit_vecs.1 * dir_vec[1];
+            self.inputs.move_dir = unit_vecs.0 * dir_vec[0] + unit_vecs.1 * dir_vec[1];
 
-            self.controller.look_dir = cam_dir;
+            self.inputs.look_dir = cam_dir;
 
             // Perform an in-game tick.
             if let Err(err) = self.tick(clock.get_avg_delta()) {