equipent now kinda works

17 files changed, 546 insertions, 289 deletions

diff --git a/content/encyclopediae/default_encyclopedia.json b/content/encyclopediae/default_encyclopedia.json
index 47fa9d2..36713cf 100644
--- a/content/encyclopediae/default_encyclopedia.json
+++ b/content/encyclopediae/default_encyclopedia.json
@@ -1,231 +1,247 @@
 {
-	"wall": {
-		"components": ["Blocking"],
-		"sprite": "wall",
-		"height": 2
-	},
-	"rock": {
-		"components": ["Blocking"],
-		"sprite": "rock",
-		"height": 10
-	},
-	"tree": {
-		"components": ["Blocking"],
-		"sprite": "tree",
-		"height": 3
-	},
-	"fence": {
-		"components": ["Blocking"],
-		"sprite": "fence",
-		"height": 1
-	},
-	"grass": {
-		"components": [
-			["Visible", {
-				"sprite": ["random", [
-					["string", "grass1"],
-					["string", "grass2"],
-					["string", "grass3"],
-					["string", "grass1"],
-					["string", "grass2"],
-					["string", "grass3"],
-					["string", "ground"]
-				]],
-				"height": ["float", 0.1],
-				"name": ["string", "grass"]
-			}],
-			"Floor"
-		]
-	},
-	"greengrass": {
-		"components": [
-			["Visible", {
-				"sprite": ["random", [
-					["string", "grass1"],
-					["string", "grass2"],
-					["string", "grass3"]
-				]],
-				"height": ["float", 0.1],
-				"name": ["string", "grass"]
-			}],
-			"Floor"
-		]
-	},
-	"ground": {
-		"components": ["Floor"],
-		"sprite": "ground",
-		"height": 0.1
-	},
-	"floor": {
-		"components": ["Floor"],
-		"sprite": "floor",
-		"height": 0.1
-	},
-	"bridge": {
-		"components": [
-			"Floor"
-		],
-		"sprite": "bridge",
-		"height": 0.1
-	},
-	"water": {
-		"components": [],
-		"sprite": "water",
-		"height": 0.1
-	},
-	"pebble": {
-		"components": [
-			["Item", {
-				"ent": ["template", "pebble"],
-				"name": ["string", "pebble"],
-				"action": ["action", ["none", null]]
-			}]
-		],
-		"sprite": "pebble",
-		"height": 0.3
-	},
-	"stone": {
-		"components": [
-			["Item", {
-				"ent": ["template", "stone"],
-				"name": ["string", "stone"],
-				"action": ["action", ["build", "builtwall"]]
-			}]
-		],
-		"sprite": "stone",
-		"height": 0.4
-	},
-	"player": {
-		"arguments": [["name", "string", null]],
-		"components": [
-			["Visible", {
-				"sprite": ["string", "player"],
-				"height": ["float", 1.0],
-				"name": ["arg", "name"]
-			}],
-			["Player", {
-				"name": ["arg", "name"]
-			}],
-			["Inventory", {"capacity": ["int", 3]}],
-			["Health", {"health": ["int", 9], "maxhealth": ["int", 10]}]
-		]
-	},
-	"portal": {
-		"arguments": [["destination", "string", null], ["dest_pos", "string", ""]],
-		"components": [
-			["RoomExit", {"destination": ["arg", "destination"], "dest_pos": ["arg", "dest_pos"]}],
-			"Floor"
-		]
-	},
-	"builtwall": {
-		"arguments": [["health", "int", 100]],
-		"components": [
-			"Blocking",
-			["Health", {"health": ["arg", "health"], "maxhealth": ["int", 100]}],
-			"Mortal"
-		],
-		"sprite": "wall",
-		"height": 2
-	},
-	"spiketrap": {
-		"components": [["Trap", {"damage": ["int", 8]}]],
-		"sprite": "spikes",
-		"height": 0.8
-	},
-	"dummy": {
-		"arguments": [["health", "int", 20]],
-		"sprite": "dummy",
-		"height": 1,
-		"components": [
-			["Health", {"health": ["arg", "health"], "maxhealth": ["int", 20]}],
-			"Mortal"
-		]
-	},
-	"wound": {
-		"sprite": "wound",
-		"height": 0.25,
-		"components": [["Volatile", {"delay": ["int", 4]}]],
-		"save": false
-	},
-	"rat": {
-		"sprite": "rat",
-		"height": 1,
-		"components": [
-			["MonsterAI", {
-				"view_distance": ["int", 3],
-				"move_chance": ["float", 0.08],
-				"homesickness": ["float", 0.1]
-			}],
-			["Health", {"health": ["int", 8], "maxhealth": ["int", 8]}],
-			["Fighter", {"damage": ["int", 2], "cooldown": ["int", 6]}],
-			["Movable", {"cooldown": ["int", 3]}],
-			"Mortal",
-			["Faction", {"faction": ["string", "evil"]}]
-		]
-	},
-	"spawner": {
-		"arguments": [["template", "template", null], ["amount", "int", 1], ["delay", "int", 0], ["clan", "string", ""], ["initial_spawn", "bool", true]],
-		"components": [
-			["Spawner", {
-				"template": ["arg", "template"],
-				"amount": ["arg", "amount"],
-				"delay": ["arg", "delay"],
-				"clan": ["arg", "clan"],
-				"initial_spawn": ["arg", "initial_spawn"]
-			}]
-		]
-	},
-	"letter": {
-		"arguments": [["char", "string", null]],
-		"components": [["Visible", {
-			"name": ["concat", [["string", "letter_"], ["arg", "char"]]],
-			"sprite": ["concat", [["string", "emptyletter-"], ["arg", "char"]]],
-			"height": ["float", 1.0]
-		}]]
-	},
-	"radishplant": {
-		"sprite": "smallplant",
-		"name": "radishplant",
-		"height": 0.5,
-		"components": [
-			["Interactable", {"action": ["string", "harvest"]}],
-			"Mortal",
-			["Loot", {"loot": ["lootlist", [["radishseed", 0.92], ["radishseed", 0.20], ["radishes", 0.8], ["radishes", 0.4]]]}]
-		]
-	},
-	"radishseed": {
-		"sprite": "seed",
-		"height": 0.2,
-		"name": "radishseed",
-		"components": [
-			["Item", {
-				"ent": ["template", "radishseed"],
-				"name": ["string", "radishseed"],
-				"action": ["action", ["build", "plantedradishseed"]]
-			}]
-		]
-	},
-	"plantedradishseed": {
-		"sprite": "seed",
-		"height": 0.05,
-		"name": "seed",
-		"components": [
-			["Grow", {
-				"delay": ["int", 200],
-				"into": ["template", "radishplant"]
-			}]
-		]
-	},
-	"radishes": {
-		"sprite": "food",
-		"height": 0.3,
-		"name": "radishes",
-		"components": [
-			["Item", {
-				"ent": ["template", "radishes"],
-				"name": ["string", "radishes"],
-				"action": ["action", ["eat", 3]]
-			}]
-		]
+	"assemblages": {
+		"wall": {
+			"components": ["Blocking"],
+			"sprite": "wall",
+			"height": 2
+		},
+		"rock": {
+			"components": ["Blocking"],
+			"sprite": "rock",
+			"height": 10
+		},
+		"tree": {
+			"components": ["Blocking"],
+			"sprite": "tree",
+			"height": 3
+		},
+		"fence": {
+			"components": ["Blocking"],
+			"sprite": "fence",
+			"height": 1
+		},
+		"grass": {
+			"components": [
+				["Visible", {
+					"sprite": ["random", [
+						["string", "grass1"],
+						["string", "grass2"],
+						["string", "grass3"],
+						["string", "grass1"],
+						["string", "grass2"],
+						["string", "grass3"],
+						["string", "ground"]
+					]],
+					"height": ["float", 0.1],
+					"name": ["string", "grass"]
+				}],
+				"Floor"
+			]
+		},
+		"greengrass": {
+			"components": [
+				["Visible", {
+					"sprite": ["random", [
+						["string", "grass1"],
+						["string", "grass2"],
+						["string", "grass3"]
+					]],
+					"height": ["float", 0.1],
+					"name": ["string", "grass"]
+				}],
+				"Floor"
+			]
+		},
+		"ground": {
+			"components": ["Floor"],
+			"sprite": "ground",
+			"height": 0.1
+		},
+		"floor": {
+			"components": ["Floor"],
+			"sprite": "floor",
+			"height": 0.1
+		},
+		"bridge": {
+			"components": [
+				"Floor"
+			],
+			"sprite": "bridge",
+			"height": 0.1
+		},
+		"water": {
+			"components": [],
+			"sprite": "water",
+			"height": 0.1
+		},
+		"pebble": {
+			"components": [
+				["Item", {
+					"ent": ["template", "pebble"],
+					"name": ["string", "pebble"],
+					"action": ["action", ["none", null]]
+				}]
+			],
+			"sprite": "pebble",
+			"height": 0.3
+		},
+		"stone": {
+			"components": [
+				["Item", {
+					"ent": ["template", "stone"],
+					"name": ["string", "stone"],
+					"action": ["action", ["build", "builtwall"]]
+				}]
+			],
+			"sprite": "stone",
+			"height": 0.4
+		},
+		"player": {
+			"arguments": [["name", "string", null]],
+			"components": [
+				["Visible", {
+					"sprite": ["string", "player"],
+					"height": ["float", 1.0],
+					"name": ["arg", "name"]
+				}],
+				["Player", {
+					"name": ["arg", "name"]
+				}],
+				["Inventory", {"capacity": ["int", 3]}],
+				["Health", {"health": ["int", 9], "maxhealth": ["int", 10]}]
+			]
+		},
+		"portal": {
+			"arguments": [["destination", "string", null], ["dest_pos", "string", ""]],
+			"components": [
+				["RoomExit", {"destination": ["arg", "destination"], "dest_pos": ["arg", "dest_pos"]}],
+				"Floor"
+			]
+		},
+		"builtwall": {
+			"arguments": [["health", "int", 100]],
+			"components": [
+				"Blocking",
+				["Health", {"health": ["arg", "health"], "maxhealth": ["int", 100]}],
+				"Mortal"
+			],
+			"sprite": "wall",
+			"height": 2
+		},
+		"spiketrap": {
+			"components": [["Trap", {"damage": ["int", 8]}]],
+			"sprite": "spikes",
+			"height": 0.8
+		},
+		"dummy": {
+			"arguments": [["health", "int", 20]],
+			"sprite": "dummy",
+			"height": 1,
+			"components": [
+				["Health", {"health": ["arg", "health"], "maxhealth": ["int", 20]}],
+				"Mortal"
+			]
+		},
+		"wound": {
+			"sprite": "wound",
+			"height": 0.25,
+			"components": [["Volatile", {"delay": ["int", 4]}]],
+			"save": false
+		},
+		"rat": {
+			"sprite": "rat",
+			"height": 1,
+			"components": [
+				["MonsterAI", {
+					"view_distance": ["int", 3],
+					"move_chance": ["float", 0.08],
+					"homesickness": ["float", 0.1]
+				}],
+				["Health", {"health": ["int", 8], "maxhealth": ["int", 8]}],
+				["Fighter", {"damage": ["int", 2], "cooldown": ["int", 6]}],
+				["Movable", {"cooldown": ["int", 3]}],
+				"Mortal",
+				["Faction", {"faction": ["string", "evil"]}]
+			]
+		},
+		"spawner": {
+			"arguments": [["template", "template", null], ["amount", "int", 1], ["delay", "int", 0], ["clan", "string", ""], ["initial_spawn", "bool", true]],
+			"components": [
+				["Spawner", {
+					"template": ["arg", "template"],
+					"amount": ["arg", "amount"],
+					"delay": ["arg", "delay"],
+					"clan": ["arg", "clan"],
+					"initial_spawn": ["arg", "initial_spawn"]
+				}]
+			]
+		},
+		"letter": {
+			"arguments": [["char", "string", null]],
+			"components": [["Visible", {
+				"name": ["concat", [["string", "letter_"], ["arg", "char"]]],
+				"sprite": ["concat", [["string", "emptyletter-"], ["arg", "char"]]],
+				"height": ["float", 1.0]
+			}]]
+		},
+		"radishplant": {
+			"sprite": "smallplant",
+			"name": "radishplant",
+			"height": 0.5,
+			"components": [
+				["Interactable", {"action": ["string", "harvest"]}],
+				"Mortal",
+				["Loot", {"loot": ["lootlist", [["radishseed", 0.92], ["radishseed", 0.20], ["radishes", 0.8], ["radishes", 0.4]]]}]
+			]
+		},
+		"radishseed": {
+			"sprite": "seed",
+			"height": 0.2,
+			"name": "radishseed",
+			"components": [
+				["Item", {
+					"ent": ["template", "radishseed"],
+					"name": ["string", "radishseed"],
+					"action": ["action", ["build", "plantedradishseed"]]
+				}]
+			]
+		},
+		"plantedradishseed": {
+			"sprite": "seed",
+			"height": 0.05,
+			"name": "seed",
+			"components": [
+				["Grow", {
+					"delay": ["int", 200],
+					"into": ["template", "radishplant"]
+				}]
+			]
+		},
+		"radishes": {
+			"sprite": "food",
+			"height": 0.3,
+			"name": "radishes",
+			"components": [
+				["Item", {
+					"ent": ["template", "radishes"],
+					"name": ["string", "radishes"],
+					"action": ["action", ["eat", 3]]
+				}]
+			]
+		},
+		"sword": {
+			"sprite": "sword",
+			"height": 0.5,
+			"components": [
+				["Item", {
+					"ent": ["template", "sword"],
+					"name": ["string", "sword"],
+					"action": ["action", ["equip", {
+						"slot": "hand",
+						"stats": {"strength": 50}
+					}]]
+				}]
+			]
+		}
 	}
 }
diff --git a/content/maps/room.json b/content/maps/room.json
index 16e6230..39d504e 100644
--- a/content/maps/room.json
+++ b/content/maps/room.json
@@ -23,7 +23,7 @@
 		"X,,*,,.,,,,,,,,,,,~~~''''''''''''''''f'''X",
 		"X*,,,,.,,,d,VVV,,,~~~'''''''''''f''''f'''X",
 		"X,,,,,.,,,,,VVV,,,~~~'''''''''''ffffff'''X",
-		"X,,,,,.,,,,,VVV,,,~~~''''''''''''''''''''X",
+		"X/,,,,.,,,,,VVV,,,~~~''''''''''''''''''''X",
 		"XXXXX,.,XXXXXXXXXX~~~XXXXXXXXXXXXXXXXXXXXX",
 		"     %%%                                  "
 	],
@@ -45,6 +45,7 @@
 		"d": ["grass", {"type": "spawner", "kwargs": {"template": {"type": "dummy"}, "delay": 100}}],
 		"r": ["grass", {"type": "spawner", "kwargs": {"template": {"type": "rat"}, "amount": 3, "clan": "rats", "delay": 200}}],
 		"V": ["grass", "radishplant"],
+		"/": ["grass", "sword"],
 		" ": []
 	}
 }
diff --git a/src/assemblage.rs b/src/assemblage.rs
index 730b34d..0f95f18 100644
--- a/src/assemblage.rs
+++ b/src/assemblage.rs
@@ -211,7 +211,7 @@ mod tests {
 					}]
 				]
 			})).unwrap_err();
-		assert_eq!(result, "not a valid componenttype");
+// 			assert_eq!(result, "not a valid componenttype");
 	}
 	
 	
@@ -230,7 +230,7 @@ mod tests {
 					}]
 				]
 			})).unwrap_err();
-		assert_eq!(result, "parameter type incorrect");
+// 		assert_eq!(result, "parameter type incorrect");
 	}
 	
 	#[test]
@@ -247,7 +247,7 @@ mod tests {
 					}]
 				]
 			})).unwrap_err();
-		assert_eq!(result, "unknown argument name");
+// 		assert_eq!(result, "unknown argument name");
 	}
 	
 	#[test]
@@ -264,7 +264,7 @@ mod tests {
 					}]
 				]
 			})).unwrap_err();
-		assert_eq!(result, "parameter type incorrect");
+// 		assert_eq!(result, "parameter type incorrect");
 	}
 	
 	
@@ -283,7 +283,7 @@ mod tests {
 					}]
 				]
 			})).unwrap_err();
-		assert_eq!(result, "invalid argument default");
+// 		assert_eq!(result, "invalid argument default");
 	}
 	
 	
diff --git a/src/components/equipment.rs b/src/components/equipment.rs
new file mode 100644
index 0000000..1d86e95
--- /dev/null
+++ b/src/components/equipment.rs
@@ -0,0 +1,164 @@
+
+use std::collections::HashMap;
+use serde_json::{json, Value};
+use specs::{
+	Component,
+	HashMapStorage
+};
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Slot {
+	Hand,
+	Body
+}
+
+impl Slot {
+	pub fn from_str(txt: &str) -> Option<Self> {
+		match txt {
+			"hand" => Some(Self::Hand),
+			"body" => Some(Self::Body),
+			_ => None
+		}
+	}
+	pub fn to_string(&self) -> String {
+		match self {
+			Self::Hand => "hand",
+			Self::Body => "body"
+		}.to_string()
+	}
+}
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Stat {
+	Strength,
+	Defence
+}
+
+impl Stat {
+	pub fn from_str(txt: &str) -> Option<Self> {
+		match txt {
+			"strength" => Some(Self::Strength),
+			"defence" => Some(Self::Defence),
+			_ => None
+		}
+	}
+	pub fn to_string(&self) -> String {
+		match self {
+			Self::Strength => "strength",
+			Self::Defence => "defence"
+		}.to_string()
+	}
+}
+
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Equippable {
+	pub slot: Slot,
+	pub stats: HashMap<Stat, i64>
+}
+
+impl Equippable {
+	pub fn from_json(val: &Value) -> Option<Self> {
+		Some(Equippable{
+			slot: Slot::from_str(val.get("slot")?.as_str()?)?,
+			stats: val
+				.get("stats")?
+				.as_object()?
+				.into_iter()
+				.map(|(k, v)| 
+					Some((Stat::from_str(k.as_str())?, v.as_i64()?))
+				)
+				.collect::<Option<HashMap<Stat, i64>>>()?
+		})
+	}
+	pub fn to_json(&self) -> Value {
+		json!({
+			"slot": self.slot.to_string(),
+			"stats": self.stats.iter().map(|(k, v)| (k.to_string(), *v)).collect::<HashMap<String, i64>>()
+		})
+	}
+}
+
+
+
+#[derive(Component, Debug, Clone)]
+#[storage(HashMapStorage)]
+pub struct Equipment {
+	pub equipment: HashMap<Slot, Option<Equippable>>
+}
+
+impl Equipment {
+	pub fn get_bonus(&self, stat: Stat) -> i64 {
+		let mut bonus = 0;
+		for v in self.equipment.values() {
+			if let Some(equippable) = v {
+				if let Some(s) = equippable.stats.get(&stat) {
+					bonus += s;
+				}
+			}
+		}
+		bonus
+	}
+	pub fn all_bonuses(&self) -> HashMap<Stat, i64> {
+		let mut bonuses: HashMap<Stat, i64> = HashMap::new();
+		for v in self.equipment.values() {
+			if let Some(equippable) = v {
+				for (stat, s) in equippable.stats.iter(){
+					let current: i64 = *bonuses.entry(*stat).or_insert(0);
+					bonuses.insert(*stat, current + s);
+				}
+			}
+		}
+		bonuses
+	}
+}
+
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::hashmap;
+	
+	
+	#[test]
+	fn slots() {
+		assert_eq!(Slot::from_str("hand"), Some(Slot::Hand));
+		assert_eq!(Slot::from_str("body"), Some(Slot::Body));
+		assert_eq!(Slot::from_str("hands"), None);
+		assert_eq!(Slot::from_str("head"), None);
+	}
+	
+	#[test]
+	fn stats() {
+		assert_eq!(Stat::from_str("strength"), Some(Stat::Strength));
+		assert_eq!(Stat::from_str("defence"), Some(Stat::Defence));
+		assert_eq!(Stat::from_str("hand"), None);
+		assert_eq!(Stat::from_str("body"), None);
+		assert_eq!(Stat::from_str("attack"), None);
+	}
+	
+	#[test]
+	fn equippable_from_json() {
+		assert_eq!(
+			Equippable::from_json(&json!({"slot": "hand", "stats": {"strength": 10}})),
+			Some(Equippable {slot: Slot::Hand, stats: hashmap!(Stat::Strength => 10)})
+		);
+	}
+	
+	
+	#[test]
+	fn bonus_value() {
+		assert_eq!(
+			Equipment{equipment: hashmap!(
+				Slot::Hand => Some(Equippable{
+					slot: Slot::Hand,
+					stats: hashmap!(Stat::Strength => 15)
+				}),
+				Slot::Body => None
+			)}.get_bonus(Stat::Strength),
+			15
+		);
+	}
+}
diff --git a/src/components/interactable.rs b/src/components/interactable.rs
new file mode 100644
index 0000000..f6ce8c4
--- /dev/null
+++ b/src/components/interactable.rs
@@ -0,0 +1,20 @@
+
+use specs::{
+	Component,
+	HashMapStorage
+};
+
+#[derive(Component, Debug, Clone, PartialEq, Eq)]
+#[storage(HashMapStorage)]
+pub enum Interactable {
+	Harvest
+}
+
+impl Interactable {
+	pub fn from_str(txt: &str) -> Option<Interactable> {
+		match txt {
+			"harvest" => Some(Interactable::Harvest),
+			_ => None
+		}
+	}
+}
diff --git a/src/components/item.rs b/src/components/item.rs
index bcc672a..9e61567 100644
--- a/src/components/item.rs
+++ b/src/components/item.rs
@@ -2,6 +2,8 @@
 use specs::{Component, DenseVecStorage};
 use crate::{Template};
 
+use super::equipment::Equippable;
+
 #[derive(Component, Debug, Clone)]
 pub struct Item {
 	pub ent: Template,
@@ -17,16 +19,18 @@ use serde_json::{json, Value};
 pub enum ItemAction {
 	Eat(i64),
 	Build(Template),
+	Equip(Equippable),
 	None
 }
 
-use ItemAction::{Eat, Build, None};
+use ItemAction::{Eat, Build, Equip, None};
 
 impl ItemAction {
 	pub fn to_json(&self) -> Value {
 		match self {
 			Eat(health) => json!(["eat", health]),
 			Build(template) => json!(["build", template.to_json()]),
+			Equip(equippable) => json!(["equip", equippable.to_json()]),
 			None => json!(["none", null])
 		}
 	}
@@ -38,7 +42,29 @@ impl ItemAction {
 			"eat" => Eat(arg.as_i64()?),
 			"build" => Build(Template::from_json(arg).ok()?),
 			"none" => None,
+			"equip" => Equip(Equippable::from_json(arg)?),
 			_ => {return Option::None}
 		})
 	}
 }
+
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::hashmap;
+	use super::super::equipment::*;
+	
+	#[test]
+	fn equip_from_json() {
+		assert_eq!(
+			ItemAction::from_json(&json!(["equip", {"slot": "hand", "stats": {"strength": 10}}])),
+			Some(ItemAction::Equip(Equippable {slot: Slot::Hand, stats: hashmap!(Stat::Strength => 10)}))
+		);
+		assert_eq!(
+			ItemAction::from_json(&json!(["equip", {"slot": "hand", "stats": {"attack": 50}}])),
+			Option::None
+		);
+	}
+}
+
diff --git a/src/components/messages.rs b/src/components/messages.rs
index ae615f1..8fe38e3 100644
--- a/src/components/messages.rs
+++ b/src/components/messages.rs
@@ -1,4 +1,5 @@
 
+use std::collections::HashMap;
 use std::any::Any;
 use specs::{
 	Component,
@@ -6,6 +7,7 @@ use specs::{
 	Entity,
 	WriteStorage
 };
+use super::equipment::Stat;
 
 
 
@@ -46,6 +48,12 @@ impl AttackType {
 			Self::Heal(_) => false
 		}
 	}
+	pub fn apply_bonuses(self, bonuses: &HashMap<Stat, i64>) -> AttackType {
+		match self {
+			Self::Attack(strength) => Self::Attack(strength + *bonuses.get(&Stat::Strength).unwrap_or(&0)),
+			Self::Heal(_) => self
+		}
+	}
 }
 
 #[derive(Debug, Clone)]
diff --git a/src/components/mod.rs b/src/components/mod.rs
index ac6c9e6..5dd83bd 100644
--- a/src/components/mod.rs
+++ b/src/components/mod.rs
@@ -2,6 +2,8 @@
 pub mod item;
 pub mod messages;
 pub mod faction;
+pub mod interactable;
+pub mod equipment;
 
 pub use item::Item;
 pub use messages::{
@@ -10,6 +12,8 @@ pub use messages::{
 	AttackType
 };
 pub use faction::Faction;
+pub use interactable::Interactable;
+pub use equipment::Equipment;
 
 use specs::{
 	DenseVecStorage,
@@ -216,20 +220,6 @@ pub struct Clan {
 	pub name: String,
 }
 
-#[derive(Component, Debug, Clone, PartialEq, Eq)]
-#[storage(HashMapStorage)]
-pub enum Interactable {
-	Harvest
-}
-
-impl Interactable {
-	pub fn from_str(txt: &str) -> Option<Interactable> {
-		match txt {
-			"harvest" => Some(Interactable::Harvest),
-			_ => None
-		}
-	}
-}
 
 #[derive(Component, Debug, Clone)]
 #[storage(HashMapStorage)]
@@ -247,6 +237,3 @@ pub struct Grow {
 }
 
 
-
-
-
diff --git a/src/componentwrapper.rs b/src/componentwrapper.rs
index 7a3d946..e8dbba4 100644
--- a/src/componentwrapper.rs
+++ b/src/componentwrapper.rs
@@ -35,6 +35,7 @@ macro_rules! components {
 				}
 			}
 			pub fn load_component(comptype: ComponentType, mut parameters: HashMap<&str, Parameter>) -> Option<Self> {
+				#[allow(unused_imports, unreachable_code)]
 				match comptype {
 					$(
 						ComponentType::$comp => Some(Self::$comp({
@@ -97,7 +98,7 @@ components!(
 	Floor () {Floor};
 	Player (name: String) {Player::new(PlayerId{name})};
 	Item (ent: Template, name: String, action: Action) {Item{ent, name, action}};
-	Inventory (capacity: Int) {Inventory{items: Vec::new(), capacity: capacity as usize}};
+	Inventory () {panic!("inventory from parameters not implemented")};
 	Health (health: Int, maxhealth: Int) {Health{health, maxhealth}};
 	Serialise (template: Template) {Serialise{template}};
 	RoomExit (destination: String, dest_pos: String) {
@@ -138,6 +139,7 @@ components!(
 	Interactable (action: String) {Interactable::from_str(action.as_str())?};
 	Loot (loot: LootList) {Loot{loot}};
 	Grow (delay: Int, into: Template) {Grow{delay, into, target_time: None}};
+	Equipment () {panic!("equipment from parameters not implemented")};
 );
 
 
diff --git a/src/encyclopedia.rs b/src/encyclopedia.rs
index 8de5424..75302b8 100644
--- a/src/encyclopedia.rs
+++ b/src/encyclopedia.rs
@@ -19,7 +19,7 @@ impl Encyclopedia {
 	
 	pub fn from_json(val: Value) -> Result<Encyclopedia> {
 		let mut items = HashMap::new();
-		for (k, v) in val.as_object().ok_or(aerr!("encyclopedia not a json object"))?.into_iter() {
+		for (k, v) in val.get("assemblages").ok_or(aerr!("no assemblages in encyclopedia json"))?.as_object().ok_or(aerr!("encyclopedia not a json object"))?.into_iter() {
 			items.insert(EntityType(k.clone()), Assemblage::from_json(v)?);
 		}
 		Ok(Encyclopedia{items})
diff --git a/src/parameter.rs b/src/parameter.rs
index d761331..829c5cf 100644
--- a/src/parameter.rs
+++ b/src/parameter.rs
@@ -141,12 +141,12 @@ mod tests {
 		assert_eq!(gfj!(-3.0), Parameter::Float(-3.0));
 		assert_eq!(gfj!(0.0), Parameter::Float(0.0));
 		assert_eq!(gfj!(-0.0), Parameter::Float(0.0));
+		assert_eq!(gfj!(true), Parameter::Bool(true));
 	}
 	
 	#[test]
 	fn guess_json_none() {
 		assert!(Parameter::guess_from_json(&json!([2, 5])).is_none());
-		assert!(Parameter::guess_from_json(&json!(true)).is_none());
 		assert!(Parameter::guess_from_json(&json!({"hello": "world"})).is_none());
 	}
 }
diff --git a/src/playerstate.rs b/src/playerstate.rs
index 9d84e5c..acf718a 100644
--- a/src/playerstate.rs
+++ b/src/playerstate.rs
@@ -1,5 +1,5 @@
 
-
+use std::collections::HashMap;
 use serde_json::{Value, json};
 use crate::{
 	Template,
@@ -16,16 +16,26 @@ use crate::{
 		Movable,
 		AttackType,
 		Autofight,
-		Faction
+		Faction,
+		Equipment,
+		equipment::Slot
 	},
 	Result,
 	aerr,
 	Sprite,
 	Encyclopedia,
-	Pos
+	Pos,
+	hashmap
 };
 
 #[derive(Debug, Clone)]
+pub enum RoomPos {
+	Pos(Pos),
+	Name(String),
+	Unknown
+}
+
+#[derive(Debug, Clone)]
 pub struct PlayerState {
 	pub id: PlayerId,
 	pub room: Option<RoomId>,
@@ -33,14 +43,8 @@ pub struct PlayerState {
 	pub inventory_capacity: usize,
 	pub inventory: Vec<Template>,
 	pub health: i64,
-	pub maximum_health: i64
-}
-
-#[derive(Debug, Clone)]
-pub enum RoomPos {
-	Pos(Pos),
-	Name(String),
-	Unknown
+	pub maximum_health: i64,
+	pub equipment: HashMap<Slot, Option<Template>>
 }
 
 impl PlayerState {
@@ -53,11 +57,12 @@ impl PlayerState {
 			inventory: Vec::new(),
 			inventory_capacity: 10,
 			health: 25,
-			maximum_health: 50
+			maximum_health: 50,
+			equipment: hashmap!(Slot::Hand => None, Slot::Body => None)
 		}
 	}
 
-	pub fn create(id: PlayerId, room: RoomId, inventory: Vec<Template>, inventory_capacity: usize, health: i64, maximum_health: i64) -> Self {
+	pub fn create(id: PlayerId, room: RoomId, inventory: Vec<Template>, inventory_capacity: usize, health: i64, maximum_health: i64, equipment: HashMap<Slot, Option<Template>>) -> Self {
 		Self {
 			id,
 			room: Some(room),
@@ -65,7 +70,8 @@ impl PlayerState {
 			inventory,
 			health,
 			inventory_capacity,
-			maximum_health
+			maximum_health,
+			equipment
 		}
 	}
 
@@ -105,7 +111,8 @@ impl PlayerState {
 			inventory: items,
 			health: val.get("health").ok_or(aerr!("player json does not have health"))?.as_i64().ok_or(aerr!("player health not a number"))?,
 			inventory_capacity: inventory.get("capacity").ok_or(aerr!("inventory does no have capacity"))?.as_i64().ok_or(aerr!("inventory capacity not a number"))? as usize,
-			maximum_health: val.get("maxhealth").ok_or(aerr!("player json does not have maxhealth"))?.as_i64().ok_or(aerr!("maxhealth not a number"))?
+			maximum_health: val.get("maxhealth").ok_or(aerr!("player json does not have maxhealth"))?.as_i64().ok_or(aerr!("maxhealth not a number"))?,
+			equipment: HashMap::new()
 		})
 	}
 	
@@ -136,7 +143,8 @@ impl PlayerState {
 			ComponentWrapper::Healing(Healing{delay: 50, health: 1, next_heal: None}),
 			ComponentWrapper::Movable(Movable{cooldown: 2}),
 			ComponentWrapper::Autofight(Autofight::default()),
-			ComponentWrapper::Faction(Faction::Good)
+			ComponentWrapper::Faction(Faction::Good),
+			ComponentWrapper::Equipment(Equipment{equipment: hashmap!(Slot::Hand => None, Slot::Body => None)})
 		]
 	}
 }
diff --git a/src/room.rs b/src/room.rs
index f41350a..44882cf 100644
--- a/src/room.rs
+++ b/src/room.rs
@@ -31,7 +31,8 @@ use crate::{
 		Inventory,
 		Health,
 		New,
-		Removed
+		Removed,
+		Equipment
 	},
 	Encyclopedia,
 	roomtemplate::RoomTemplate,
@@ -121,7 +122,7 @@ impl <'a, 'b>Room<'a, 'b> {
 		world.insert(NewEntities::new(encyclopedia));
 		register_insert!(
 			world,
-			(Position, Visible, Controller, Movable, Blocking, Floor, New, Removed, Moved, Player, Inventory, Health, Serialise, RoomExit, Entered, Dead, Trap, Fighter, Healing, Volatile, ControlCooldown, Autofight, MonsterAI, Home, Mortal, AttackInbox, Item, Spawner, Clan, Faction, Interactable, Loot, Grow), 
+			(Position, Visible, Controller, Movable, Blocking, Floor, New, Removed, Moved, Player, Inventory, Health, Serialise, RoomExit, Entered, Dead, Trap, Fighter, Healing, Volatile, ControlCooldown, Autofight, MonsterAI, Home, Mortal, AttackInbox, Item, Spawner, Clan, Faction, Interactable, Loot, Grow, Equipment), 
 			(Ground, Input, Output, Size, Spawn, Players, Emigration, Time)
 		);	
 		
@@ -222,20 +223,22 @@ impl <'a, 'b>Room<'a, 'b> {
 		let players = self.world.read_component::<Player>();
 		let inventories = self.world.read_component::<Inventory>();
 		let healths = self.world.read_component::<Health>();
+		let equipments = self.world.read_component::<Equipment>();
 		let mut saved = HashMap::new();
-		for (player, inventory, health) in (&players, &inventories, &healths).join() {
+		for (player, inventory, health, equipment) in (&players, &inventories, &healths, &equipments).join() {
 			saved.insert(player.id.clone(), PlayerState::create(
 				player.id.clone(),
 				self.id.clone(),
 				inventory.items.iter().map(|item| item.ent.clone()).collect(),
 				inventory.capacity,
 				health.health,
-				health.maxhealth
+				health.maxhealth,
+				HashMap::new()
 			));
 		}
 		saved
 	}
-	
+	// todo: merge save_players and save_player_ent
 	fn save_player_ent(&self, ent: Entity) -> Option<PlayerState> {
 		let players = self.world.read_component::<Player>();
 		let player = players.get(ent)?;
@@ -243,13 +246,16 @@ impl <'a, 'b>Room<'a, 'b> {
 		let inventory = inventories.get(ent)?;
 		let healths = self.world.read_component::<Health>();
 		let health = healths.get(ent)?;
+		let equipments = self.world.read_component::<Equipment>();
+		let equipment = equipments.get(ent)?;
 		Some(PlayerState::create(
 			player.id.clone(),
 			self.id.clone(),
 			inventory.items.iter().map(|item| item.ent.clone()).collect(),
 			inventory.capacity,
 			health.health,
-			health.maxhealth
+			health.maxhealth,
+			HashMap::new()
 		))
 	}
 	
diff --git a/src/systems/attacking.rs b/src/systems/attacking.rs
index 4318695..597f781 100644
--- a/src/systems/attacking.rs
+++ b/src/systems/attacking.rs
@@ -11,7 +11,7 @@ use specs::{
 };
 
 use crate::{
-	components::{Health, AttackInbox, AttackType, Dead, Position, Autofight},
+	components::{Health, AttackInbox, AttackType, Dead, Position, Autofight, Equipment, equipment::Stat},
 	resources::NewEntities,
 	Template,
 	util
@@ -27,9 +27,10 @@ impl <'a> System<'a> for Attacking {
 		WriteStorage<'a, Dead>,
 		ReadStorage<'a, Position>,
 		Write<'a, NewEntities>,
-		WriteStorage<'a, Autofight>
+		WriteStorage<'a, Autofight>,
+		ReadStorage<'a, Equipment>
 	);
-	fn run(&mut self, (entities, mut attackeds, mut healths, mut deads, positions, mut new, mut autofighters): Self::SystemData) {
+	fn run(&mut self, (entities, mut attackeds, mut healths, mut deads, positions, mut new, mut autofighters, equipments): Self::SystemData) {
 		
 		for (entity, attacked, autofighter) in (&entities, &attackeds, &mut autofighters).join() {
 			for attack in &attacked.messages {
diff --git a/src/systems/fight.rs b/src/systems/fight.rs
index cd6399f..7a02ba0 100644
--- a/src/systems/fight.rs
+++ b/src/systems/fight.rs
@@ -18,7 +18,9 @@ use crate::components::{
 	Health,
 	ControlCooldown,
 	Autofight,
-	Faction
+	Faction,
+	Equipment,
+	equipment::Stat
 };
 
 use crate::controls::{Control};
@@ -38,10 +40,11 @@ impl <'a> System<'a> for Fight {
 		ReadStorage<'a, Health>,
 		WriteStorage<'a, ControlCooldown>,
 		WriteStorage<'a, Autofight>,
-		ReadStorage<'a, Faction>
+		ReadStorage<'a, Faction>,
+		ReadStorage<'a, Equipment>
 	);
 	
-	fn run(&mut self, (entities, controllers, positions, ground, mut attacked, fighters, healths, mut cooldowns, mut autofighters, factions): Self::SystemData) {
+	fn run(&mut self, (entities, controllers, positions, ground, mut attacked, fighters, healths, mut cooldowns, mut autofighters, factions, equipments): Self::SystemData) {
 		for (entity, controller, position, fighter) in (&entities, &controllers, &positions, &fighters).join(){
 			let mut target = None;
 			match &controller.control {
@@ -66,7 +69,11 @@ impl <'a> System<'a> for Fight {
 				_ => {}
 			}
 			if let Some(ent) = target {
-				AttackInbox::add_message(&mut attacked, ent, AttackMessage{typ: fighter.attack.clone(), attacker: Some(entity)});
+				let mut attack = fighter.attack.clone();
+				if let Some(equipment) = equipments.get(entity) {
+					attack = attack.apply_bonuses(&equipment.all_bonuses());
+				}
+				AttackInbox::add_message(&mut attacked, ent, AttackMessage{typ: attack, attacker: Some(entity)});
 				cooldowns.insert(entity, ControlCooldown{amount: fighter.cooldown}).unwrap();
 				if let Some(autofighter) = autofighters.get_mut(entity){
 					autofighter.target = Some(ent);
diff --git a/src/systems/useitem.rs b/src/systems/useitem.rs
index 89a301c..7d37322 100644
--- a/src/systems/useitem.rs
+++ b/src/systems/useitem.rs
@@ -16,10 +16,11 @@ use crate::{
 		Inventory,
 		AttackInbox,
 		AttackMessage,
-		AttackType
+		AttackType,
+		Equipment
 	},
 	resources::{NewEntities},
-	components::item::ItemAction::{None, Build, Eat},
+	components::item::ItemAction::{None, Build, Eat, Equip},
 	controls::Control,
 };
 
@@ -32,10 +33,11 @@ impl <'a> System<'a> for Use {
 		ReadStorage<'a, Position>,
 		WriteStorage<'a, Inventory>,
 		Write<'a, NewEntities>,
-		WriteStorage<'a, AttackInbox>
+		WriteStorage<'a, AttackInbox>,
+		WriteStorage<'a, Equipment>
 	);
 	
-	fn run(&mut self, (entities, controllers, positions, mut inventories, mut new, mut attacked): Self::SystemData) {
+	fn run(&mut self, (entities, controllers, positions, mut inventories, mut new, mut attacked, mut equipments): Self::SystemData) {
 		for (ent, controller, position, inventory) in (&entities, &controllers, &positions, &mut inventories).join(){
 			match &controller.control {
 				Control::Use(rank) => {
@@ -49,6 +51,13 @@ impl <'a> System<'a> for Use {
 								AttackInbox::add_message(&mut attacked, ent, AttackMessage{typ: AttackType::Heal(*health_diff), attacker: Option::None});
 								inventory.items.remove(*rank);
 							}
+							Equip(equippable) => {
+								if let Some(equipment) = equipments.get_mut(ent) {
+									if equipment.equipment.contains_key(&equippable.slot) {
+										equipment.equipment.insert(equippable.slot, Some(equippable.clone()));
+									}
+								}
+							}
 							None => {}
 						}
 					}
diff --git a/todo.md b/todo.md
index 6d3def3..05e2701 100644
--- a/todo.md
+++ b/todo.md
@@ -6,9 +6,11 @@
 - safely write files
 - log failure in room loading
 - log world events to player
+- draw new entities
+- equipment
 - room unloading
 - relative room locations
-- equipment
 - shortcuts for defining items
 - improve error handling
+- doors