added dense grass; home is now part of monsterAI component

5 files changed, 60 insertions, 14 deletions

diff --git a/src/systems/controlai.rs b/src/systems/controlai.rs
index ab72f77..5032cc4 100644
--- a/src/systems/controlai.rs
+++ b/src/systems/controlai.rs
@@ -11,7 +11,7 @@ use specs::{
 };
 
 use crate::{
-	components::{Controller, ControlCooldown, Fighter, MonsterAI, Home, Health, Position, Faction},
+	components::{Controller, ControlCooldown, Fighter, MonsterAI, Health, Position, Faction},
 	controls::{Control, Direction::{self, North, South, East, West}},
 	Pos
 };
@@ -25,12 +25,11 @@ impl <'a> System<'a> for ControlAI {
 		ReadStorage<'a, ControlCooldown>,
 		ReadStorage<'a, MonsterAI>,
 		ReadStorage<'a, Fighter>,
-		ReadStorage<'a, Home>,
 		ReadStorage<'a, Health>,
 		ReadStorage<'a, Position>,
 		ReadStorage<'a, Faction>
 	);
-	fn run(&mut self, (entities, mut controllers, cooldowns, ais, fighters, homes, healths, positions, factions): Self::SystemData) {
+	fn run(&mut self, (entities, mut controllers, cooldowns, ais, fighters, healths, positions, factions): Self::SystemData) {
 	
 		for (entity, ai, position, ()) in (&entities, &ais, &positions, !&cooldowns).join() {
 			if let Some(fighter) = fighters.get(entity) {
@@ -60,9 +59,9 @@ impl <'a> System<'a> for ControlAI {
 				}
 			}
 			if rand::thread_rng().gen_range(0.0, 1.0) < ai.move_chance {
-				if let Some(home) = homes.get(entity) {
-					if rand::thread_rng().gen_range(0.0, 1.0) < ai.homesickness * (position.pos.distance_to(home.home) as f64) {
-						let direction = step_to(position.pos, home.home).unwrap();
+				if let Some(home) = ai.home {
+					if rand::thread_rng().gen_range(0.0, 1.0) < ai.homesickness * (position.pos.distance_to(home) as f64) {
+						let direction = step_to(position.pos, home).unwrap();
 						controllers.insert(entity, Controller{control: Control::Move(direction)}).unwrap();
 						return;
 					}
diff --git a/src/systems/interact.rs b/src/systems/interact.rs
index 81563e8..204cd86 100644
--- a/src/systems/interact.rs
+++ b/src/systems/interact.rs
@@ -1,5 +1,5 @@
 
-use std::collections::HashSet;
+use std::collections::{HashSet, HashMap};
 use rand::Rng;
 
 use specs::{
@@ -25,7 +25,8 @@ use crate::{
 		Visible,
 		Player,
 		Whitelist,
-		Minable
+		Minable,
+		Stats
 	},
 	controls::{Control},
 	resources::{Ground, Emigration, NewEntities},
@@ -52,10 +53,11 @@ impl <'a> System<'a> for Interact {
 		Write<'a, Emigration>,
 		WriteStorage<'a, Whitelist>,
 		WriteStorage<'a, Minable>,
+		ReadStorage<'a, Stats>,
 		Read<'a, NewEntities>
 	);
 	
-	fn run(&mut self, (entities, controllers, positions, ground, mut cooldowns, interactables, mut triggerbox, mut ears, mut inventories, visibles, players, mut emigration, mut whitelists, mut minables, new): Self::SystemData) {
+	fn run(&mut self, (entities, controllers, positions, ground, mut cooldowns, interactables, mut triggerbox, mut ears, mut inventories, visibles, players, mut emigration, mut whitelists, mut minables, stats, new): Self::SystemData) {
 		for (actor, controller, position) in (&entities, &controllers, &positions).join(){
 			let mut target = None;
 			let ear = ears.get_mut(actor);
@@ -121,9 +123,15 @@ impl <'a> System<'a> for Interact {
 						}
 					}
 					Interactable::Mine(skill) => {
-						if let (Some(inventory), Some(minable)) = (inventories.get(actor), minables.get_mut(ent)) {
-							let stats = inventory.equipment_bonuses();
-							if let Some(skill_value) = stats.get(skill) {
+						if let Some(minable) = minables.get_mut(ent) {
+							let mut skills = inventories.get(actor).map(Inventory::equipment_bonuses).unwrap_or_else(HashMap::new);
+							if let Some(skillset) = stats.get(actor) {
+								for (skill, val) in skillset.skills.iter() {
+									*skills.entry(*skill).or_insert(0) += val;
+								}
+							}
+							if let Some(skill_value) = skills.get(skill) {
+								println!("{:?} {:?}", skill, skill_value);
 								// todo: give player feedback
 								cooldown = 20;
 								minable.progress += rand::thread_rng().gen_range(0, skill_value+1);
diff --git a/src/systems/mod.rs b/src/systems/mod.rs
index e0ae2e8..598feaa 100644
--- a/src/systems/mod.rs
+++ b/src/systems/mod.rs
@@ -23,6 +23,7 @@ mod clear;
 mod building;
 mod spawntrigger;
 mod replace;
+mod spawncheck;
 
 pub use self::{
 	controlinput::ControlInput,
@@ -49,4 +50,5 @@ pub use self::{
 	building::Building,
 	spawntrigger::SpawnTrigger,
 	replace::Replace,
+	spawncheck::SpawnCheck
 };
diff --git a/src/systems/spawn.rs b/src/systems/spawn.rs
index da0735d..c6db0e4 100644
--- a/src/systems/spawn.rs
+++ b/src/systems/spawn.rs
@@ -17,7 +17,6 @@ use crate::{
 		Position,
 		Spawner,
 		Clan,
-		Home,
 		TriggerBox,
 		Trigger,
 		TimeOffset
@@ -62,7 +61,6 @@ impl <'a> System<'a> for Spawn {
 						match new.encyclopedia.construct(&spawner.template) {
 							Ok(mut preent) => {
 								preent.push(ComponentWrapper::Clan(spawner.clan.clone()));
-								preent.push(ComponentWrapper::Home(Home{home: position.pos}));
 								let offset = Pos::new(
 									rng.gen::<i64>()%(spawner.radius*2+1)-spawner.radius,
 									rng.gen::<i64>()%(spawner.radius*2+1)-spawner.radius);
diff --git a/src/systems/spawncheck.rs b/src/systems/spawncheck.rs
new file mode 100644
index 0000000..52ff38e
--- /dev/null
+++ b/src/systems/spawncheck.rs
@@ -0,0 +1,39 @@
+
+use std::collections::HashSet;
+use specs::{
+	WriteStorage,
+	ReadStorage,
+	Entities,
+	System,
+	Join,
+	Read
+};
+
+use crate::{
+	components::{Removed, Requirements, New, Position, Flag, Flags},
+	resources::{Ground, RoomFlags}
+};
+
+
+pub struct SpawnCheck;
+impl <'a> System<'a> for SpawnCheck {
+	type SystemData = (
+		Entities<'a>,
+		ReadStorage<'a, Requirements>,
+		ReadStorage<'a, New>,
+		WriteStorage<'a, Removed>,
+		Read<'a, Ground>,
+		Read<'a, RoomFlags>,
+		ReadStorage<'a, Position>,
+		ReadStorage<'a, Flags>
+	);
+	fn run(&mut self, (entities, requirements, new, mut removeds, ground, roomflags, positions, flags): Self::SystemData) {
+		for (entity, requirements, _new, position) in (&entities, &requirements, &new, &positions).join() {
+			let ground_flags: HashSet<Flag> = ground.flags_on(position.pos, &flags).union(&roomflags.0).cloned().collect();
+			if !(requirements.required_flags.is_subset(&ground_flags) && requirements.blocking_flags.is_disjoint(&ground_flags)){
+				removeds.insert(entity, Removed).unwrap();
+			}
+		}
+	}
+}
+