grow is now also using build trigger/component

2 files changed, 25 insertions, 25 deletions

diff --git a/src/systems/building.rs b/src/systems/building.rs
index 876554e..8459144 100644
--- a/src/systems/building.rs
+++ b/src/systems/building.rs
@@ -7,13 +7,15 @@ use specs::{
 };
 
 use crate::{
+	ComponentWrapper,
 	components::{
 		Position,
 		Build,
 		Trigger,
-		TriggerBox
+		TriggerBox,
+		OwnTime
 	},
-	resources::{NewEntities}
+	resources::{NewEntities},
 };
 
 
@@ -23,16 +25,21 @@ impl <'a> System<'a> for Building{
 		ReadStorage<'a, Position>,
 		Write<'a, NewEntities>,
 		ReadStorage<'a, TriggerBox>,
-		ReadStorage<'a, Build>
+		ReadStorage<'a, Build>,
+		ReadStorage<'a, OwnTime>
 	);
 	
-	fn run(&mut self, (positions, mut new, triggerboxes, builds): Self::SystemData) {
-		for (position, triggerbox, build) in (&positions, &triggerboxes, &builds).join(){
+	fn run(&mut self, (positions, mut new, triggerboxes, builds, own_times): Self::SystemData) {
+		for (position, triggerbox, build, own_time) in (&positions, &triggerboxes, &builds, (&own_times).maybe()).join(){
 			for message in triggerbox.messages.iter() {
 				match message {
 					Trigger::Build | Trigger::Change => {
 						// todo: better error handling
-						new.create(position.pos, &build.obj).unwrap();
+						let mut preent = new.encyclopedia.construct(&build.obj).unwrap();
+						if let Some(time) = own_time {
+							preent.push(ComponentWrapper::OwnTime(time.clone()));
+						}
+						new.to_build.push((position.pos, preent));
 					}
 					_ => {}
 				}
diff --git a/src/systems/growth.rs b/src/systems/growth.rs
index 97ae5f3..b1b1af5 100644
--- a/src/systems/growth.rs
+++ b/src/systems/growth.rs
@@ -2,24 +2,20 @@
 use rand;
 
 use specs::{
-	ReadStorage,
 	WriteStorage,
 	Entities,
 	System,
 	Join,
-	Write,
 	Read
 };
 
 use crate::{
 	components::{
-		Position,
 		Grow,
-		Removed,
-		CreationTime
+		OwnTime,
+		TriggerBox
 	},
-	resources::{NewEntities, Time},
-	componentwrapper::ComponentWrapper
+	resources::{Time}
 };
 
 
@@ -27,28 +23,25 @@ pub struct Growth;
 impl <'a> System<'a> for Growth{
 	type SystemData = (
 		Entities<'a>,
-		ReadStorage<'a, Position>,
-		Write<'a, NewEntities>,
 		WriteStorage<'a, Grow>,
-		WriteStorage<'a, Removed>,
+		WriteStorage<'a, TriggerBox>,
 		Read<'a, Time>,
-		ReadStorage<'a, CreationTime>
+		WriteStorage<'a, OwnTime>
 	);
 	
-	fn run(&mut self, (entities, positions, mut new, mut grows, mut removeds, time, creation_times): Self::SystemData) {
-		for (entity, position, grow) in (&entities, &positions, &mut grows).join(){
-			let creation_time = creation_times.get(entity).map(|ct| ct.time).unwrap_or(time.time);
+	fn run(&mut self, (entities, mut grows, mut triggerboxes, time, mut own_times): Self::SystemData) {
+		for (entity, grow) in (&entities, &mut grows).join(){
 			if grow.target_time == None {
+				let creation_time = own_times.get(entity).map(|ct| ct.time).unwrap_or(time.time);
 				let duration = grow.delay as f64 * (1.0 + rand::random::<f64>()) / (if rand::random() {1.0} else {2.0});
 				grow.target_time = Some(creation_time + duration as i64);
 			}
 			let target_time = grow.target_time.unwrap();
 			if target_time <= time.time {
-				removeds.insert(entity, Removed).unwrap();
-				// todo: error handling
-				let mut preent = new.encyclopedia.construct(&grow.into).unwrap();
-				preent.push(ComponentWrapper::CreationTime(CreationTime{time: target_time + 1}));
-				new.to_build.push((position.pos, preent));
+				if target_time + 1 < time.time {
+					own_times.insert(entity, OwnTime{time: target_time + 1}).unwrap();
+				}
+				TriggerBox::add_message(&mut triggerboxes, entity, grow.trigger);
 			}
 		}
 	}