don't rebuild the ground each step

7 files changed, 154 insertions, 19 deletions

diff --git a/src/systems/controlinput.rs b/src/systems/controlinput.rs
index 27ef5cf..0771b1e 100644
--- a/src/systems/controlinput.rs
+++ b/src/systems/controlinput.rs
@@ -11,7 +11,7 @@ use specs::{
 	Join
 };
 
-use crate::components::{Controller, Player};
+use crate::components::{Controller, Player, Removed};
 use crate::controls::{Control, Action};
 use crate::resources::{Input, NewEntities, Spawn};
 use crate::hashmap;
@@ -23,8 +23,26 @@ use crate::parameter::Parameter;
 
 pub struct ControlInput;
 impl <'a> System<'a> for ControlInput {
-	type SystemData = (Entities<'a>, Read<'a, Input>, WriteStorage<'a, Controller>, ReadStorage<'a, Player>, Write<'a, NewEntities>, Read<'a, Spawn>);
-	fn run(&mut self, (entities, input, mut controllers, players, mut new, spawn): Self::SystemData) {
+	type SystemData = (
+		Entities<'a>,
+		Read<'a, Input>,
+		WriteStorage<'a, Controller>,
+		ReadStorage<'a, Player>,
+		Write<'a, NewEntities>,
+		Read<'a, Spawn>,
+		WriteStorage<'a, Removed>
+	);
+	fn run(&mut self, (entities, input, mut controllers, players, mut new, spawn, mut removed): Self::SystemData) {
+		{
+			let mut ents = Vec::new();
+			for (ent, _controller) in (&*entities, &controllers).join() {
+				ents.push(ent);
+			}
+			for ent in ents {
+				controllers.remove(ent);
+			}
+		}
+	
 		let mut playercontrols: HashMap<&str, Control> = HashMap::new();
 		let mut leaving = HashSet::new();
 		for action in &input.actions {
@@ -44,7 +62,7 @@ impl <'a> System<'a> for ControlInput {
 				let _ = controllers.insert(entity, Controller(control.clone()));
 			}
 			if leaving.contains(&player.name) {
-				let _ = entities.delete(entity);
+				let _ = removed.insert(entity, Removed);
 			}
 		}
 	}
diff --git a/src/systems/create.rs b/src/systems/create.rs
new file mode 100644
index 0000000..35ef747
--- /dev/null
+++ b/src/systems/create.rs
@@ -0,0 +1,51 @@
+
+use specs::{
+	Read,
+	Write,
+	WriteStorage,
+	System,
+	Join,
+	Entities,
+	LazyUpdate,
+	Builder
+};
+
+use crate::components::{New, Position};
+use crate::resources::{NewEntities};
+
+
+
+pub struct Create;
+impl <'a> System<'a> for Create {
+	type SystemData = (
+		Entities<'a>,
+		Write<'a, NewEntities>,
+		Read<'a, LazyUpdate>,
+		WriteStorage<'a, New>
+	);
+	
+	fn run(&mut self, (entities, mut new_entities, updater, mut new): Self::SystemData) {
+		{
+			let mut ents = Vec::new();
+			for (ent, _new) in (&entities, &new).join() {
+				ents.push(ent);
+			}
+			for ent in ents {
+				new.remove(ent);
+			}
+		}
+		for (pos, template) in &new_entities.templates {
+			let mut builder = updater.create_entity(&entities);
+			match new_entities.encyclopedia.construct(template) {
+				Ok(comps) => {
+					for comp in comps {
+						builder = comp.build(builder);
+					}
+					builder.with(Position::new(*pos)).with(New).build();
+				},
+				Err(msg) => {println!("{}", msg);}
+			}
+		}
+		new_entities.templates.clear();
+	}
+}
diff --git a/src/systems/makefloor.rs b/src/systems/makefloor.rs
index 8b550bc..74e4389 100644
--- a/src/systems/makefloor.rs
+++ b/src/systems/makefloor.rs
@@ -1,4 +1,5 @@
 
+use std::collections::HashSet;
 
 use specs::{
 	ReadStorage,
@@ -8,20 +9,40 @@ use specs::{
 	Join
 };
 
-use super::super::components::Position;
+use crate::components::{
+	Position,
+	New,
+	Moved,
+	Removed
+};
 
-use super::super::resources::{
+use crate::resources::{
 	Ground
 };
 
 
+#[derive(Default)]
 pub struct MakeFloor;
 impl <'a> System<'a> for MakeFloor {
-	type SystemData = (Entities<'a>, Write<'a, Ground>, ReadStorage<'a, Position>);
-	fn run(&mut self, (entities, mut ground, positions): Self::SystemData) {
-		ground.cells.clear();
-		for (ent, pos) in (&entities, &positions).join() {
-			ground.cells.entry(pos.pos).or_insert(Vec::new()).push(ent);
+	type SystemData = (
+		Entities<'a>,
+		Write<'a, Ground>,
+		ReadStorage<'a, Position>,
+		ReadStorage<'a, New>,
+		ReadStorage<'a, Moved>,
+		ReadStorage<'a, Removed>
+	);
+	fn run(&mut self, (entities, mut ground, positions, new, moved, removed): Self::SystemData) {
+		for (ent, pos, _new) in (&entities, &positions, &new).join() {
+			ground.cells.entry(pos.pos).or_insert(HashSet::new()).insert(ent);
+		}
+		for (ent, pos, mov) in (&entities, &positions, &moved).join() {
+			ground.cells.entry(pos.pos).or_insert(HashSet::new()).insert(ent);
+			ground.cells.get_mut(&mov.from).unwrap().remove(&ent);
+		}
+		for (ent, pos, _removed) in (&entities, &positions, &removed).join() {
+			ground.cells.get_mut(&pos.pos).unwrap().remove(&ent);
 		}
 	}
 }
+
diff --git a/src/systems/mod.rs b/src/systems/mod.rs
index 0382e39..a4dd473 100644
--- a/src/systems/mod.rs
+++ b/src/systems/mod.rs
@@ -1,8 +1,10 @@
 
-pub mod clearcontrols;
+// pub mod clearcontrols;
 pub mod controlinput;
 pub mod makefloor;
 pub mod moving;
 pub mod view;
+pub mod remove;
+pub mod create;
 
 
diff --git a/src/systems/moving.rs b/src/systems/moving.rs
index 28c3d3f..35f73ea 100644
--- a/src/systems/moving.rs
+++ b/src/systems/moving.rs
@@ -1,5 +1,8 @@
 
+use std::collections::HashSet;
+
 use specs::{
+	Entities,
 	ReadStorage,
 	WriteStorage,
 	Read,
@@ -13,7 +16,8 @@ use super::super::components::{
 	Controller,
 	Blocking,
 	Position,
-	Floor
+	Floor,
+	Moved
 };
 
 use super::super::controls::{
@@ -30,22 +34,33 @@ use super::super::resources::{
 pub struct Move;
 impl <'a> System<'a> for Move {
 	type SystemData = (
+		Entities<'a>,
 		ReadStorage<'a, Controller>,
 		WriteStorage<'a, Position>,
 		Read<'a, Size>,
 		ReadStorage<'a, Blocking>,
 		Read<'a, Ground>,
 		ReadStorage<'a, Floor>,
+		WriteStorage<'a, Moved>
 	);
 	
-	fn run(&mut self, (controllers, mut positions, size, blocking, ground, floor): Self::SystemData) {
-		for (controller, mut pos) in (&controllers, &mut positions.restrict_mut()).join(){
+	fn run(&mut self, (entities, controllers, mut positions, size, blocking, ground, floor, mut moved): Self::SystemData) {
+		{
+			let mut ents = Vec::new();
+			for (ent, _moved) in (&*entities, &moved).join() {
+				ents.push(ent);
+			}
+			for ent in ents {
+				moved.remove(ent);
+			}
+		}
+		for (ent, controller, mut pos) in (&entities, &controllers, &mut positions.restrict_mut()).join(){
 			match &controller.0 {
 				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 mut blocked = false;
 					let mut on_floor = false;
-					for ent in ground.cells.get(&newpos).unwrap_or(&Vec::new()) {
+					for ent in ground.cells.get(&newpos).unwrap_or(&HashSet::new()) {
 						if blocking.get(*ent).is_some(){
 							blocked = true;
 							break;
@@ -57,6 +72,7 @@ impl <'a> System<'a> for Move {
 					if !blocked && on_floor {
 						let mut pos_mut = pos.get_mut_unchecked();
 						pos_mut.prev = Some(pos_mut.pos);
+						moved.insert(ent, Moved{from: pos_mut.pos}).expect("can't insert Moved");
 						pos_mut.pos = newpos.clone();
 					}
 				}
diff --git a/src/systems/remove.rs b/src/systems/remove.rs
new file mode 100644
index 0000000..2c531e2
--- /dev/null
+++ b/src/systems/remove.rs
@@ -0,0 +1,27 @@
+
+use specs::{
+	ReadStorage,
+	System,
+	Join,
+	Entities
+};
+
+use crate::components::{Removed};
+
+
+
+pub struct Remove;
+impl <'a> System<'a> for Remove {
+	type SystemData = (
+		Entities<'a>,
+		ReadStorage<'a, Removed>
+	);
+	
+	fn run(&mut self, (entities, removals): Self::SystemData) {
+		for (ent, _) in (&*entities, &removals).join() {
+			if let Err(msg) = entities.delete(ent){
+				println!("{:?}", msg);
+			}
+		}
+	}
+}
diff --git a/src/systems/view.rs b/src/systems/view.rs
index fec5ee7..12b5f78 100644
--- a/src/systems/view.rs
+++ b/src/systems/view.rs
@@ -16,7 +16,7 @@ use specs::{
 };
 
 use super::super::pos::Pos;
-use super::super::components::{Visible, Player, Position};
+use super::super::components::{Visible, Player, Position, New};
 use super::super::resources::{Size, Output};
 use super::super::worldmessages::{WorldMessage, WorldUpdate, FieldMessage};
 
@@ -29,8 +29,8 @@ pub struct View {
 }
 
 impl <'a> System<'a> for View {
-	type SystemData = (ReadStorage<'a, Position>, ReadStorage<'a, Visible>, Read<'a, Size>, WriteStorage<'a, Player>, Write<'a, Output>);
-	fn run(&mut self, (positions, visible, size, mut players, mut output): Self::SystemData) {
+	type SystemData = (ReadStorage<'a, Position>, ReadStorage<'a, Visible>, Read<'a, Size>, WriteStorage<'a, Player>, Write<'a, Output>, ReadStorage<'a, New>);
+	fn run(&mut self, (positions, visible, size, mut players, mut output, _new): Self::SystemData) {
 		
 		let mut cells: HashMap<Pos, Vec<Visible>> = HashMap::new();
 		for (pos, vis) in (&positions, &visible).join(){