draw the room after new entities have been added

6 files changed, 52 insertions, 49 deletions

diff --git a/src/systems/clear.rs b/src/systems/clear.rs
new file mode 100644
index 0000000..64588d3
--- /dev/null
+++ b/src/systems/clear.rs
@@ -0,0 +1,19 @@
+
+use specs::{
+	Write,
+	System
+};
+
+use crate::{
+	resources::Ground
+};
+
+pub struct Clear;
+impl <'a> System<'a> for Clear {
+	type SystemData = 
+		Write<'a, Ground>;
+	fn run(&mut self, mut ground: Self::SystemData) {
+		ground.changes.clear();
+	}
+}
+
diff --git a/src/systems/mod.rs b/src/systems/mod.rs
index 318d5ee..3f990a7 100644
--- a/src/systems/mod.rs
+++ b/src/systems/mod.rs
@@ -20,6 +20,7 @@ mod spawn;
 mod interact;
 mod droploot;
 mod growth;
+mod clear;
 
 pub use self::{
 	controlinput::ControlInput,
@@ -42,5 +43,6 @@ pub use self::{
 	spawn::Spawn,
 	interact::Interact,
 	droploot::DropLoot,
-	growth::Growth
+	growth::Growth,
+	clear::Clear
 };
diff --git a/src/systems/moving.rs b/src/systems/moving.rs
index 6ecf040..ccd29d6 100644
--- a/src/systems/moving.rs
+++ b/src/systems/moving.rs
@@ -1,18 +1,14 @@
 
-use std::collections::HashSet;
-
 use specs::{
 	Entities,
 	ReadStorage,
 	WriteStorage,
-	Read,
 	System,
 	Join,
 	Write
 };
 
 use crate::{
-	Pos,
 	components::{
 		Controller,
 		Position,
@@ -27,7 +23,6 @@ use crate::{
 		Control
 	},
 	resources::{
-		Size,
 		Ground
 	},
 };
@@ -39,7 +34,6 @@ impl <'a> System<'a> for Move {
 		Entities<'a>,
 		ReadStorage<'a, Controller>,
 		WriteStorage<'a, Position>,
-		Read<'a, Size>,
 		ReadStorage<'a, Flags>,
 		Write<'a, Ground>,
 		WriteStorage<'a, Moved>,
@@ -48,20 +42,19 @@ impl <'a> System<'a> for Move {
 		WriteStorage<'a, ControlCooldown>
 	);
 	
-	fn run(&mut self, (entities, controllers, mut positions, size, flags, mut ground, mut moved, mut entered, movables, mut cooldowns): Self::SystemData) {
+	fn run(&mut self, (entities, controllers, mut positions, flags, mut ground, mut moved, mut entered, movables, mut cooldowns): Self::SystemData) {
 		moved.clear();
 		entered.clear();
-		for (ent, controller, mut pos, movable) in (&entities, &controllers, &mut positions.restrict_mut(), &movables).join(){
+		for (ent, controller, mut position, movable) in (&entities, &controllers, &mut positions, &movables).join(){
 			match &controller.control {
 				Control::Move(direction) => {
-					let newpos = (pos.get_unchecked().pos + direction.to_position()).clamp(Pos::new(0, 0), Pos::new(size.width - 1, size.height - 1));
+					let newpos = position.pos + direction.to_position();
 					let ground_flags = ground.flags_on(newpos, &flags);
 					if !ground_flags.contains(&Flag::Blocking) && ground_flags.contains(&Flag::Floor) {
-						let mut pos_mut = pos.get_mut_unchecked();
-						moved.insert(ent, Moved{from: pos_mut.pos}).expect("can't insert Moved");
-						ground.cells.get_mut(&pos_mut.pos).unwrap().remove(&ent);
-						pos_mut.pos = newpos;
-						ground.cells.entry(newpos).or_insert_with(HashSet::new).insert(ent);
+						moved.insert(ent, Moved{from: position.pos}).expect("can't insert Moved");
+						ground.remove(&position.pos, ent);
+						position.pos = newpos;
+						ground.insert(newpos, ent);
 						for ent in ground.cells.get(&newpos).unwrap() {
 							let _ = entered.insert(*ent, Entered);
 						}
diff --git a/src/systems/registernew.rs b/src/systems/registernew.rs
index c53309f..0091296 100644
--- a/src/systems/registernew.rs
+++ b/src/systems/registernew.rs
@@ -1,5 +1,4 @@
 
-use std::collections::HashSet;
 
 use specs::{
 	ReadStorage,
@@ -11,26 +10,32 @@ use specs::{
 
 use crate::components::{
 	Position,
-	New
+	New,
+	Player
 };
 
 use crate::resources::{
-	Ground
+	Ground,
+	Players
 };
 
 
-#[derive(Default)]
 pub struct RegisterNew;
 impl <'a> System<'a> for RegisterNew {
 	type SystemData = (
 		Entities<'a>,
+		ReadStorage<'a, New>,
 		Write<'a, Ground>,
 		ReadStorage<'a, Position>,
-		ReadStorage<'a, New>,
+		Write<'a, Players>,
+		ReadStorage<'a, Player>
 	);
-	fn run(&mut self, (entities, mut ground, positions, new): Self::SystemData) {
+	fn run(&mut self, (entities, new, mut ground, positions, mut player_list, players): Self::SystemData) {
 		for (ent, pos, _new) in (&entities, &positions, &new).join() {
-			ground.cells.entry(pos.pos).or_insert_with(HashSet::new).insert(ent);
+			ground.insert(pos.pos, ent);
+		}
+		for (ent, player, _new) in (&entities, &players, &new).join(){
+			player_list.entities.insert(player.id.clone(), ent);
 		}
 	}
 }
diff --git a/src/systems/remove.rs b/src/systems/remove.rs
index b73a2fb..a228a32 100644
--- a/src/systems/remove.rs
+++ b/src/systems/remove.rs
@@ -26,7 +26,7 @@ impl <'a> System<'a> for Remove {
 				println!("{:?}", msg);
 			}
 			if let Some(position) = positions.get(ent) {
-				ground.cells.get_mut(&position.pos).unwrap().remove(&ent);
+				ground.remove(&position.pos, ent);
 			}
 		}
 	}
diff --git a/src/systems/view.rs b/src/systems/view.rs
index 49338ac..4419203 100644
--- a/src/systems/view.rs
+++ b/src/systems/view.rs
@@ -1,5 +1,4 @@
 
-use std::collections::{HashSet};
 
 use specs::{
 	ReadStorage,
@@ -14,12 +13,11 @@ use specs::{
 use crate::{
 	Pos,
 	Sprite,
-	components::{Visible, Player, Position, Inventory, New, Moved, Removed, Health, Ear},
+	components::{Visible, Player, Position, Inventory, New, Health, Ear},
 	resources::{Size, Output, Ground},
 	worldmessages::{WorldMessage, FieldMessage}
 };
 
-#[derive(Default)]
 pub struct View;
 
 impl <'a> System<'a> for View {
@@ -33,37 +31,23 @@ impl <'a> System<'a> for View {
 		ReadStorage<'a, Player>,
 		Write<'a, Output>,
 		ReadStorage<'a, New>,
-		ReadStorage<'a, Moved>,
-		ReadStorage<'a, Removed>,
 		Read<'a, Ground>,
 		WriteStorage<'a, Ear>
 	);
-	fn run(&mut self, (entities, positions, inventories, healths, visible, size, players, mut output, new, moved, removed, ground, mut ears): Self::SystemData) {
+	fn run(&mut self, (entities, positions, inventories, healths, visible, size, players, mut output, new, ground, mut ears): Self::SystemData) {
 		
-		let mut changed = HashSet::new();
-		for (pos, _new) in (&positions, &new).join() {
-			changed.insert(pos.pos);
-		}
-		for (pos, mov) in (&positions, &moved).join() {
-			changed.insert(pos.pos);
-			changed.insert(mov.from);
-		}
-		for (pos, _removed) in (&positions, &removed).join() {
-			changed.insert(pos.pos);
-		}
+		let changes: Vec<(Pos, Vec<Sprite>)> = ground.changes
+			.iter()
+			.map(|pos| (*pos, cell_sprites(ground.components_on(*pos, &visible))))
+			.collect();
 		
-		
-		let has_changed: bool = !changed.is_empty();
-		let mut changes: Vec<(Pos, Vec<Sprite>)> = Vec::new();
-		for pos in changed {
-			changes.push((pos, cell_sprites(ground.components_on(pos, &visible, &removed))));
-		}
+		let has_changed: bool = !changes.is_empty();
 		output.output.clear();
 		
 		for (ent, player, pos) in (&entities, &players, &positions).join() {
 			let mut updates = WorldMessage::default();
 			if new.get(ent).is_some() {
-				let (values, mapping) = draw_room(&ground, (size.width, size.height), &visible, &removed);
+				let (values, mapping) = draw_room(&ground, (size.width, size.height), &visible);
 				let field = FieldMessage{
 					width: size.width,
 					height: size.height,
@@ -105,14 +89,14 @@ fn cell_sprites(mut visibles: Vec<&Visible>) -> Vec<Sprite> {
 	visibles.iter().map(|vis| vis.sprite.clone()).collect()
 }
 
-fn draw_room(ground: &Read<Ground>, (width, height): (i64, i64), visible: &ReadStorage<Visible>, removals: &ReadStorage<Removed>) -> (Vec<usize>, Vec<Vec<Sprite>>){
+fn draw_room(ground: &Read<Ground>, (width, height): (i64, i64), visible: &ReadStorage<Visible>) -> (Vec<usize>, Vec<Vec<Sprite>>){
 	
 	let size = width * height;
 	let mut values :Vec<usize> = Vec::with_capacity(size as usize);
 	let mut mapping: Vec<Vec<Sprite>> = Vec::new();
 	for y in 0..height {
 		for x in 0..width {
-			let sprites: Vec<Sprite> = cell_sprites(ground.components_on(Pos{x, y}, visible, removals));
+			let sprites: Vec<Sprite> = cell_sprites(ground.components_on(Pos{x, y}, visible));
 			values.push(
 				match mapping.iter().position(|x| x == &sprites) {
 					Some(index) => {