Merge branch 'interact' into master

19 files changed, 343 insertions, 283 deletions

diff --git a/content/encyclopediae/crops.json b/content/encyclopediae/crops.json
index 2d2b5ce..29901d9 100644
--- a/content/encyclopediae/crops.json
+++ b/content/encyclopediae/crops.json
@@ -5,7 +5,7 @@
 			"name": "radishplant",
 			"height": 0.5,
 			"components": [
-				["Interactable", {"action": ["interaction", ["trigger", "die"]]}],
+				["Interactable", {"typ": "trigger", "arg": "die"}],
 				["Loot", {"loot": ["list", [
 					["list", [{"type": "radishseed"}, 0.92]],
 					["list", [{"type": "radishseed"}, 0.20]],
@@ -136,7 +136,7 @@
 			"name": "carrotplant",
 			"height": 1.0,
 			"components": [
-				["Interactable", {"action": ["interaction", ["trigger", "die"]]}],
+				["Interactable", {"typ": "trigger", "arg": "die"}],
 				["Loot", {"loot": ["list", [
 					["list", [{"type": "carrotseed"}, 1.0]],
 					["list", [{"type": "carrot"}, 1.0]]
diff --git a/content/encyclopediae/default_encyclopedia.json b/content/encyclopediae/default_encyclopedia.json
index f6a3e48..d4f7094 100644
--- a/content/encyclopediae/default_encyclopedia.json
+++ b/content/encyclopediae/default_encyclopedia.json
@@ -12,7 +12,7 @@
 			"extract": {"allowed": ["Whitelist", "allowed"], "dedup_priority": ["Dedup", "priority"]},
 			"components": [
 				["RoomExit", {"destination": "_home+{player}", "dest_pos": ""}],
-				["Interactable", {"action": ["interaction", ["visit", "_home+{player}"]]}],
+				["Interactable", {"typ": "visit", "arg": "_home+{player}"}],
 				["Whitelist", {"allowed": ["arg", "allowed"]}],
 				["Dedup", {"id": ["arg", "dedup_id"], "priority": ["arg", "dedup_priority"]}]
 			],
@@ -69,7 +69,7 @@
 			"height": 2,
 			"flags": ["Blocking"],
 			"components": [
-				["Interactable", {"action": ["interaction", ["trigger", "change"]]}],
+				["Interactable", {"typ": "trigger", "arg": "change"}],
 				["Build", {"obj": {"type": "opendoor", "save": false}}]
 			]
 		},
@@ -78,7 +78,7 @@
 			"height": 0.8,
 			"flags": ["Occupied"],
 			"components": [
-				["Interactable", {"action": ["interaction", ["trigger", "change"]]}],
+				["Interactable", {"typ": "trigger", "arg": "change"}],
 				["Build", {"obj": {"type": "closeddoor", "save": false}}]
 			]
 		},
@@ -87,14 +87,14 @@
 			"height": 1,
 			"flags": ["Occupied"],
 			"components": [
-				["Interactable", {"action": ["interaction", ["say", "Good morning there, World"]]}]
+				["Interactable", {"typ": "say", "arg": "Good morning there, World"}]
 			]
 		},
 		"quarry": {
 			"sprite": "quarry",
 			"height": 2,
 			"components": [
-				["Interactable", {"action": ["interaction", ["mine", "mining"]]}],
+				["Interactable", {"typ": "mine", "arg": "mining"}],
 				["Minable", {"total": 20, "trigger": "loot"}],
 				["Loot", {"loot": ["list", [
 					["list", [{"type": "stone"}, 1.0]]
diff --git a/content/encyclopediae/npcs.json b/content/encyclopediae/npcs.json
index bfaa6fe..00c45d6 100644
--- a/content/encyclopediae/npcs.json
+++ b/content/encyclopediae/npcs.json
@@ -79,18 +79,21 @@
 			"height": 1.5,
 			"flags": ["Occupied"],
 			"components": [
-				["Interactable", {"action": ["interaction", ["reply", "did you say '{}'?"]]}]
+				["Interactable", {"typ": "say", "arg": "Hey there, welcome to Asciifarm"}]
 			]
 		},
 		"trader": {
 			"sprite": "human",
 			"height": 1.5,
 			"components": [
-				["Interactable", {"action": ["interaction", ["exchange", ["buy ", {
-					"pebble": [["radish", "radish"], ["pebble"]],
-					"radishseed": [["radish"], ["radishseed", "radishseed"]],
-					"carrotseed": [["radish"], ["carrotseed"]]
-				}]]]}]
+				["Interactable", {"typ": "exchange", "arg": ["list", [
+					"buy ",
+					["list", [
+						["list", ["pebble", ["list", ["radish", "radish"]], ["list", ["pebble"]]]],
+						["list", ["radishseed", ["list", ["radish"]], ["list", ["radishseed", "radishseed"]]]],
+						["list", ["carrotseed", ["list", ["radish"]], ["list", ["carrotseed"]]]]
+					]]
+				]]}]
 			]
 		}
 	}
diff --git a/content/maps/room.json b/content/maps/room.json
index b923986..84201a0 100644
--- a/content/maps/room.json
+++ b/content/maps/room.json
@@ -13,7 +13,7 @@
 		" ~~,,,,.,,,,,,,,,,,~~~,,,,,,,,,,,,,,,,,,,,X",
 		" X,,,,,.,,,,,,,,,,,~~~~,,,,,,T,,,,,,,,,,,,X",
 		" X,,,,,.,,,,,,,,,,,,~~~,,,,,,,,,,,,,,,,,,,X",
-		" X,,,,,.,,,,,,,,,,,,~~~,,,,,T,,,,######,,,X",
+		" X,,,,,.,u,,,,,,,,,,~~~,,,,,T,,,,######,,,X",
 		" X,,,,,.,,,,,,,,,,,,bbb,,,,,,,,,,#++++#,,,X",
 		" X,,,t..............bbb..........D++++#,,,X",
 		" X,,,,,.,,,,,,,,,,,,bbb,,,,,,,,,,#++++#,,,X",
diff --git a/src/assemblage.rs b/src/assemblage.rs
index 2b60ea3..c706ed0 100644
--- a/src/assemblage.rs
+++ b/src/assemblage.rs
@@ -2,7 +2,7 @@
 use std::collections::HashMap;
 use serde_json::{Value, json, value};
 use crate::{
-	componentparameter::ComponentParameter,
+	parameterexpression::ParameterExpression,
 	parameter::{Parameter, ParameterType},
 	componentwrapper::{ComponentWrapper, ComponentType},
 	components::Serialise,
@@ -18,7 +18,7 @@ type ArgumentDef = (String, ParameterType, Option<Parameter>);
 #[derive(Debug, PartialEq, Clone)]
 pub struct Assemblage {
 	pub arguments: Vec<ArgumentDef>,
-	pub components: Vec<(ComponentType, HashMap<String, ComponentParameter>)>,
+	pub components: Vec<(ComponentType, HashMap<String, ParameterExpression>)>,
 	pub save: bool,
 	pub extract: Vec<(String, ComponentType, String)>
 }
@@ -37,7 +37,7 @@ impl Assemblage {
 					(
 						key.clone(),
 						typ,
-						Some(Parameter::from_typed_json(typ, def).ok_or(perr!("invalid argument default {:?} {:?}", typ, def))?)
+						Some(Parameter::from_typed_json(typ, def)?)
 					)
 				);
 			} else  {
@@ -47,7 +47,7 @@ impl Assemblage {
 		Ok(arguments)
 	}
 	
-	fn parse_definition_components(comps: &[Value]) -> PResult<Vec<(ComponentType, HashMap<String, ComponentParameter>)>> {
+	fn parse_definition_components(comps: &[Value]) -> PResult<Vec<(ComponentType, HashMap<String, ParameterExpression>)>> {
 		let mut components = Vec::new();
 		for tup in comps {
 			if let Some(name) = tup.as_str() {
@@ -55,9 +55,9 @@ impl Assemblage {
 			} else {
 				let (name, params) = value::from_value::<(String, HashMap<String, Value>)>(tup.clone()).map_err(|e| perr!("invalid component definition: {:?}", e))?;
 				let comptype = ComponentType::from_str(&name).ok_or(perr!("{} not a valid componenttype", name))?;
-				let mut parameters: HashMap<String, ComponentParameter> = HashMap::new();
+				let mut parameters: HashMap<String, ParameterExpression> = HashMap::new();
 				for (key, value) in params.into_iter() {
-					let param = ComponentParameter::from_json(&value)?;
+					let param = ParameterExpression::from_json(&value)?;
 					parameters.insert(key, param);
 				}
 				components.push((comptype, parameters));
@@ -227,9 +227,9 @@ mod tests {
 				arguments: vec![("sprite".to_string(), ParameterType::String, Some(Parameter::String("grass1".to_string())))],
 				components: vec![
 					(ComponentType::Visible, hashmap!(
-						"sprite".to_string() => ComponentParameter::Argument("sprite".to_string()),
-						"height".to_string() => ComponentParameter::Constant(Parameter::Float(0.1)),
-						"name".to_string() => ComponentParameter::Constant(Parameter::String("grass".to_string()))
+						"sprite".to_string() => ParameterExpression::Argument("sprite".to_string()),
+						"height".to_string() => ParameterExpression::Constant(Parameter::Float(0.1)),
+						"name".to_string() => ParameterExpression::Constant(Parameter::String("grass".to_string()))
 					))
 				],
 				save: true,
@@ -346,9 +346,9 @@ mod tests {
 				arguments: vec![("sprite".to_string(), ParameterType::String, None)],
 				components: vec![
 					(ComponentType::Visible, hashmap!(
-						"sprite".to_string() => ComponentParameter::Argument("sprite".to_string()),
-						"height".to_string() => ComponentParameter::Constant(Parameter::Float(0.1)),
-						"name".to_string() => ComponentParameter::Argument("sprite".to_string())
+						"sprite".to_string() => ParameterExpression::Argument("sprite".to_string()),
+						"height".to_string() => ParameterExpression::Constant(Parameter::Float(0.1)),
+						"name".to_string() => ParameterExpression::Argument("sprite".to_string())
 					))
 				],
 				save: true,
diff --git a/src/componentparameter.rs b/src/componentparameter.rs
deleted file mode 100644
index 333c6e1..0000000
--- a/src/componentparameter.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-
-use std::collections::HashMap;
-use rand::Rng;
-use serde_json::Value;
-use crate::{
-	parameter::{Parameter, ParameterType},
-	Template,
-	Result,
-	aerr,
-	PResult,
-	perr
-};
-
-const MAX_NESTING: usize = 5;
-
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum ComponentParameter {
-	Constant(Parameter),
-	Argument(String),
-	Random(Vec<ComponentParameter>),
-	Concat(Vec<ComponentParameter>),
-	If(Box<ComponentParameter>, Box<ComponentParameter>, Box<ComponentParameter>),
-	TemplateSelf,
-	TemplateName
-}
-
-impl ComponentParameter {
-
-	pub fn evaluate(&self, arguments: &HashMap<&str, Parameter>, template: &Template) -> Option<Parameter> {
-		self.evaluate_(arguments, template, 0)
-	}
-	
-	fn evaluate_(&self, arguments: &HashMap<&str, Parameter>, template: &Template, nesting: usize) -> Option<Parameter> {
-		if nesting > MAX_NESTING {
-			return None;
-		}
-		match self {
-			Self::Constant(val) => {
-				Some(val.clone())
-			}
-			Self::Argument(argname) => {
-				Some(arguments.get(argname.as_str())?.clone())
-			}
-			Self::Random(options) => {
-				let r = rand::thread_rng().gen_range(0, options.len());
-				options[r].evaluate_(arguments, template, nesting + 1)
-			}
-			Self::Concat(options) => {
-				let mut string = String::new();
-				for option in options {
-					if let Parameter::String(s) = option.evaluate_(arguments, template, nesting+1)? {
-						string.push_str(&s);
-					} else {
-						return None;
-					}
-				}
-				Some(Parameter::String(string))
-			}
-			Self::If(condition, thenval, elseval) => {
-				if let Parameter::Bool(b) = condition.evaluate_(arguments, template, nesting+1)? {
-					if b {
-						thenval.evaluate_(arguments, template, nesting+1)
-					} else {
-						elseval.evaluate_(arguments, template, nesting+1)
-					}
-				} else {
-					None
-				}
-			}
-			Self::TemplateSelf => Some(Parameter::Template(template.clone())),
-			Self::TemplateName => Some(Parameter::String(template.name.0.clone())),
-			
-		}
-	}
-	
-	pub fn from_json(value: &Value) -> PResult<Self> {
-		if !value.is_array() {
-			return Ok(Self::Constant(Parameter::guess_from_json(value).ok_or(perr!("invalid component parameter {:?}", value))?));
-		}
-		let paramvalue = value.get(1).ok_or(perr!("index 1 not in component parameter"))?;
-		let typename = value.get(0).ok_or(perr!("index 0 not in component parameter"))?.as_str().ok_or(perr!("compparam type not a string"))?;
-		if let Some(paramtype) = ParameterType::from_str(typename) {
-			Ok(Self::Constant(Parameter::from_typed_json(paramtype, paramvalue).ok_or_else(||
-				perr!("failed to parse parameter constant: {:?} {:?}", paramtype, paramvalue)
-			)?))
-		} else {
-			match typename {
-				"A" | "arg" => {
-					let argname = paramvalue.as_str().ok_or(perr!("argument parameter not a string"))?.to_string();
-					Ok(Self::Argument(argname))
-				},
-				"random" => {
-					let optionvalues = paramvalue.as_array().ok_or(perr!("random argument not an array"))?;
-					let mut options = Vec::new();
-					for option in optionvalues {
-						options.push(Self::from_json(option)?)
-					}
-					Ok(Self::Random(options))
-				},
-				"concat" => {
-					let values = paramvalue.as_array().ok_or(perr!("concat argument not an array"))?;
-					let mut options = Vec::new();
-					for option in values {
-						options.push(Self::from_json(option)?)
-					}
-					Ok(Self::Concat(options))
-				},
-				"if" => {
-					Ok(Self::If(
-						Box::new(Self::from_json(paramvalue.get(0).ok_or(perr!("if does not have condition"))?)?),
-						Box::new(Self::from_json(paramvalue.get(1).ok_or(perr!("if does not have then value"))?)?),
-						Box::new(Self::from_json(paramvalue.get(2).ok_or(perr!("if does not have else value"))?)?)
-					))
-				}
-				"self" => Ok(Self::TemplateSelf),
-				"name" => Ok(Self::TemplateName),
-				_ => Err(perr!("unknown compparam type '{}'", typename))
-			}
-		}
-	}
-	
-	pub fn get_type(&self, arguments: &[(String, ParameterType, Option<Parameter>)]) -> Result<ParameterType>{
-		Ok(match self {
-			Self::Constant(param) => param.paramtype(),
-			Self::Argument(argname) => arguments.iter().find(|(n, _t, _d)| n == argname).ok_or(aerr!("unknown argument name {} in {:?}", argname, arguments))?.1,
-			Self::Random(options) => {
-				let typ: ParameterType = options.get(0).ok_or(aerr!("random has no options"))?.get_type(arguments)?;
-				for param in options {
-					if param.get_type(arguments)? != typ {
-						return Err(aerr!("inconsistent parameter types in random"));
-					}
-				}
-				typ
-			},
-			Self::If(condition, thenval, elseval) => {
-				if condition.get_type(arguments)? != ParameterType::Bool {
-					return Err(aerr!("if condition is not a bool"));
-				}
-				let typ: ParameterType = thenval.get_type(arguments)?;
-				if elseval.get_type(arguments)? != typ {
-					return Err(aerr!("inconsistent parameter types in if"));
-				}
-				typ
-			},
-			Self::Concat(_s) => ParameterType::String,
-			Self::TemplateSelf => ParameterType::Template,
-			Self::TemplateName => ParameterType::String
-		})
-	}
-}
diff --git a/src/components/interactable.rs b/src/components/interactable.rs
index d97b742..2f20966 100644
--- a/src/components/interactable.rs
+++ b/src/components/interactable.rs
@@ -1,59 +1,60 @@
 
 use std::collections::HashMap;
-use serde_json;
-use serde_json::{Value};
 use specs::{
 	Component,
-	HashMapStorage
+	HashMapStorage,
 };
 use crate::{
 	exchange::Exchange,
-	ItemId,
 	components::{Trigger, equipment::Stat},
-	RoomId
+	RoomId,
+	parameter::Parameter,
+	fromtoparameter::FromToParameter,
+	ItemId,
 };
 
 #[derive(Component, Debug, Clone, PartialEq)]
 #[storage(HashMapStorage)]
 pub enum Interactable {
 	Trigger(Trigger),
+	Visit(RoomId),
+	Mine(Stat),
 	Say(String),
 	Reply(String),
 	Exchange(String, HashMap<String, Exchange>),
-	Visit(RoomId),
-	Mine(Stat)
 }
 
 use Interactable::*;
 
 impl Interactable {
-	pub fn from_json(val: &Value) -> Option<Self> {
-		let typ = val.get(0)?;
-		let arg = val.get(1)?;
-		Some(match typ.as_str()? {
-			"trigger" => Trigger(Trigger::from_str(arg.as_str()?)?),
-			"say" => Say(arg.as_str()?.to_string()),
-			"reply" => Reply(arg.as_str()?.to_string()),
-			"exchange" => {
-				let (prefix, change) = serde_json::value::from_value::<
-						(String, HashMap<String, (Vec<ItemId>, Vec<ItemId>)>)
-					>(arg.clone()).ok()?;
-				Exchange(
-					prefix,
-					change.into_iter().map(
-						|(id, (cost, offer))| (id, Exchange{cost, offer})
-					).collect::<HashMap<String, Exchange>>()
-				)
-			},
-			"visit" => Visit(RoomId::from_str(arg.as_str()?)),
-			"mine" => Mine(Stat::from_str(arg.as_str()?)?),
-			_ => None?
+	
+	pub fn parse_from_parameter(typ: &str, arg: &Parameter) -> Option<Self> {
+		Some(match (typ, arg) {
+			("trigger", Parameter::String(s)) => Trigger(Trigger::from_str(s)?),
+			("visit", Parameter::String(s)) => Visit(RoomId::from_str(s)),
+			("mine", Parameter::String(s)) => Mine(Stat::from_str(s)?),
+			("say", Parameter::String(s)) => Say(s.clone()),
+			("reply", Parameter::String(s)) => Reply(s.clone()),
+			("exchange", p) => {
+				let (prefix, trades) = <(String, Vec<(String, Vec<ItemId>, Vec<ItemId>)>)>::from_parameter(p.clone())?;
+				let exchanges = trades.into_iter().map(|(k, cost, offer)| (k, Exchange{cost, offer})).collect();
+				Exchange(prefix, exchanges)
+			}
+			_ => {return None}
 		})
 	}
 	
 	pub fn accepts_arg(&self, arg: &Option<String>) -> bool {
 		match self {
 			Trigger(_) => arg.is_none(),
+			Visit(_) => {
+				if let Some(txt) = arg {
+					 txt.starts_with("visit ") || txt.starts_with("disallow ") || txt.starts_with("allow ") || txt.starts_with("whitelist")
+				} else {
+					true
+				}
+			}
+			Mine(_) => arg.is_none(),
 			Say(_) => arg.is_none(),
 			Reply(_) => arg.is_some(),
 			Exchange(prefix, _exchanges) => {
@@ -63,14 +64,8 @@ impl Interactable {
 					true
 				}
 			},
-			Visit(_) => {
-				if let Some(txt) = arg {
-					 txt.starts_with("visit ") || txt.starts_with("disallow ") || txt.starts_with("allow ") || txt.starts_with("whitelist")
-				} else {
-					true
-				}
-			}
-			Mine(_) => arg.is_none()
 		}
 	}
 }
+
+
diff --git a/src/components/mod.rs b/src/components/mod.rs
index ee5176e..38a14bd 100644
--- a/src/components/mod.rs
+++ b/src/components/mod.rs
@@ -16,7 +16,7 @@ pub use messages::{
 	TriggerBox
 };
 pub use faction::Faction;
-pub use interactable::Interactable;
+pub use interactable::{Interactable};
 pub use equipment::Equipment;
 pub use inventory::Inventory;
 pub use serialise::Serialise;
diff --git a/src/componentwrapper.rs b/src/componentwrapper.rs
index 2619d9c..08d95ee 100644
--- a/src/componentwrapper.rs
+++ b/src/componentwrapper.rs
@@ -14,8 +14,7 @@ use crate::{
 		AttackType,
 		Clan,
 		Flag,
-		Trigger,
-		interactable::Interactable
+		Trigger
 	},
 	parameter::{Parameter},
 	fromtoparameter::FromToParameter,
@@ -50,12 +49,13 @@ macro_rules! components {
 						ComponentType::$comp => Ok(Self::$comp({
 							use crate::components::$comp;
 							$(
-								let $paramname = <$paramtype>::from_parameter(
-										parameters
+								let $paramname = {
+									let param = parameters
 										.remove(stringify!($paramname))
-										.ok_or(aerr!("required parameter '{}'not found", stringify!($paramname)))?
-									)
-									.ok_or(aerr!("parameter {} is invalid type", stringify!($paramname)))?;
+										.ok_or(aerr!("required parameter '{}'not found", stringify!($paramname)))?;
+									<$paramtype>::from_parameter(param.clone())
+										.ok_or(aerr!("parameter {} is invalid type: {:?} is not of type {}", stringify!($paramname), param, stringify!($paramtype)))?
+								};
 
 							)*
 							$creation
@@ -183,7 +183,9 @@ components!(all:
 	Clan (name: String);
 	Home (home: Pos);
 	Faction (faction: String) {Faction::from_str(faction.as_str()).ok_or(aerr!("invalid faction name"))?};
-	Interactable (action: Interactable) {action};
+	Interactable (typ: String, arg: Parameter) {
+		Interactable::parse_from_parameter(&typ, &arg).ok_or(aerr!("invalid interaction {:?} {:?}", typ, arg))?
+	};
 	Loot (loot: Vec<(Template, f64)>);
 	Timer (
 			trigger: String, (panic!("can't turn trigger to string")),
diff --git a/src/encyclopedia.rs b/src/encyclopedia.rs
index e100cad..70f0ac6 100644
--- a/src/encyclopedia.rs
+++ b/src/encyclopedia.rs
@@ -94,7 +94,7 @@ impl Encyclopedia {
 			let mut assemblage = assemblages.get(&enttype).ok_or(perr!("template name '{:?}' does not point to not an assemblage", enttype))?.clone();
 			for arg in assemblage.arguments.iter_mut() {
 				if let Some(x) = values.get(&arg.0) {
-					let param = Parameter::from_typed_json(arg.1, x).ok_or(perr!("subtitution parameter has wrong type"))?;
+					let param = Parameter::from_typed_json(arg.1, x)?;
 					arg.2 = Some(param);
 				}
 			}
diff --git a/src/fromtoparameter.rs b/src/fromtoparameter.rs
index f201a2a..75912ae 100644
--- a/src/fromtoparameter.rs
+++ b/src/fromtoparameter.rs
@@ -5,7 +5,6 @@ use crate::{
 	parameter::Parameter,
 	Template,
 	Pos,
-	components::interactable::Interactable,
 	PlayerId,
 	Sprite,
 	ItemId
@@ -78,7 +77,6 @@ tofrom!(bool:Bool);
 tofrom!(String: String);
 tofrom!(Pos: Pos);
 tofrom!(Template: Template);
-tofrom!(Interactable: Interaction);
 
 tofrom!(PlayerId{name: String});
 tofrom!(Sprite{name: String});
diff --git a/src/main.rs b/src/main.rs
index cbc92a6..9020e3c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,7 +18,7 @@ mod pos;
 mod componentwrapper;
 mod parameter;
 mod assemblage;
-mod componentparameter;
+mod parameterexpression;
 mod encyclopedia;
 mod template;
 mod roomtemplate;
diff --git a/src/parameter.rs b/src/parameter.rs
index cee6342..e303f76 100644
--- a/src/parameter.rs
+++ b/src/parameter.rs
@@ -2,8 +2,9 @@
 use serde_json::{Value, json};
 use crate::{
 	Template,
-	components::interactable::Interactable,
-	Pos
+	Pos,
+	PResult,
+	perr
 };
 
 
@@ -17,10 +18,10 @@ macro_rules! parameters {
 			)*
 		}
 		impl Parameter {
-			pub fn from_typed_json(typ: ParameterType, val: &Value) -> Option<Parameter>{
+			pub fn from_typed_json(typ: ParameterType, val: &Value) -> PResult<Parameter>{
 				match typ {
 					$(
-						ParameterType::$name => Some(Self::$name({
+						ParameterType::$name => Ok(Self::$name({
 							let $v = val;
 							$fromjson
 						})),
@@ -63,20 +64,19 @@ macro_rules! parameters {
 }
 
 parameters!(
-	String (String) string, v (v.as_str()?.to_string()) (json!(v));
-	Int (i64) int, v (v.as_i64()?) (json!(v));
-	Pos (Pos) pos, v (Pos::from_json(v)?) (json!(v));
-	Float (f64) float, v (v.as_f64()?) (json!(v));
-	Template (Template) template, v (Template::from_json(v).ok()?) (json!(["template", v.to_json()]));
-	Interaction (Interactable) interaction, _v (Interactable::from_json(_v)?) (panic!("interactions can't be serialized"));
-	Bool (bool) bool, v (v.as_bool()?) (json!(v));
+	String (String) string, v (v.as_str().ok_or(perr!("{:?} not a string", v))?.to_string()) (json!(v));
+	Int (i64) int, v (v.as_i64().ok_or(perr!("{:?} not an int", v))?) (json!(v));
+	Pos (Pos) pos, v (Pos::from_json(v).ok_or(perr!("{:?} not a pos", v))?) (json!(v));
+	Float (f64) float, v (v.as_f64().ok_or(perr!("{:?} not an float", v))?) (json!(v));
+	Template (Template) template, v (Template::from_json(v)?) (json!(["template", v.to_json()]));
+	Bool (bool) bool, v (v.as_bool().ok_or(perr!("{:?} not a bool", v))?) (json!(v));
 	List (Vec<Parameter>) list, v 
 		({
 			v
-				.as_array()?
+				.as_array().ok_or(perr!("{:?} not an array", v))?
 				.iter()
 				.map(|item| Parameter::guess_from_json(item))
-				.collect::<Option<Vec<Parameter>>>()?
+				.collect::<PResult<Vec<Parameter>>>()?
 		})
 		(json!(["list", v.iter().map(Parameter::to_json).collect::<Vec<Value>>()]));
 );
@@ -88,11 +88,11 @@ impl Parameter {
 		Self::String(string.to_string())
 	}
 	
-	pub fn guess_from_json(val: &Value) -> Option<Parameter> {
+	pub fn guess_from_json(val: &Value) -> PResult<Parameter> {
 		if let Some(arr) = val.as_array() {
 			if arr.len() == 2 && arr[0].is_string() {
 				let typestr = arr[0].as_str().unwrap();
-				let typ = ParameterType::from_str(typestr)?;
+				let typ = ParameterType::from_str(typestr).ok_or(perr!("invalid parameter type {}", typestr))?;
 				return Self::from_typed_json(typ, &arr[1]);
 			}
 		}
@@ -108,7 +108,7 @@ impl Parameter {
 			} else if val.is_object(){
 				ParameterType::Template
 			} else {
-				return None
+				return Err(perr!("can't guess the type of parameter {:?}", val));
 			};
 		Self::from_typed_json(typ, val)
 	}
diff --git a/src/parameterexpression.rs b/src/parameterexpression.rs
new file mode 100644
index 0000000..65ad4c8
--- /dev/null
+++ b/src/parameterexpression.rs
@@ -0,0 +1,204 @@
+
+use std::collections::HashMap;
+use rand::Rng;
+use serde_json::{Value, json};
+use crate::{
+	parameter::{Parameter, ParameterType},
+	Template,
+	template::{SaveOption, EntityType},
+	Result,
+	aerr,
+	PResult,
+	perr
+};
+
+const MAX_NESTING: usize = 5;
+
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum ParameterExpression {
+	Constant(Parameter),
+	List(Vec<ParameterExpression>),
+	#[allow(dead_code)] // rustc bug does not know that this variant is used: https://github.com/rust-lang/rust/issues/68408
+	Template{name: EntityType, kwargs: HashMap<String, ParameterExpression>, save: SaveOption},
+	Argument(String),
+	Random(Vec<ParameterExpression>),
+	Concat(Vec<ParameterExpression>),
+	If(Box<ParameterExpression>, Box<ParameterExpression>, Box<ParameterExpression>),
+	TemplateSelf,
+	TemplateName
+}
+
+impl ParameterExpression {
+
+	pub fn evaluate(&self, arguments: &HashMap<&str, Parameter>, template: &Template) -> Option<Parameter> {
+		self.evaluate_(arguments, template, 0)
+	}
+	
+	fn evaluate_(&self, arguments: &HashMap<&str, Parameter>, template: &Template, nesting: usize) -> Option<Parameter> {
+		if nesting > MAX_NESTING {
+			return None;
+		}
+		match self {
+			Self::Constant(val) => {
+				Some(val.clone())
+			}
+			Self::List(values) => {
+				Some(Parameter::List(values.iter().map(|v| v.evaluate_(arguments, template, nesting+1)).collect::<Option<Vec<Parameter>>>()?))
+			}
+			Self::Template{name, kwargs, save} => {
+				Some(Parameter::Template(Template{
+					name: name.clone(),
+					args: Vec::new(),
+					save: *save,
+					kwargs: kwargs
+						.iter()
+						.map(
+							|(k, v)|
+							Some((k.clone(), v.evaluate_(arguments, template, nesting+1)?)))
+						.collect::<Option<HashMap<String, Parameter>>>()?
+				}))
+			}
+			Self::Argument(argname) => {
+				Some(arguments.get(argname.as_str())?.clone())
+			}
+			Self::Random(options) => {
+				let r = rand::thread_rng().gen_range(0, options.len());
+				options[r].evaluate_(arguments, template, nesting + 1)
+			}
+			Self::Concat(options) => {
+				let mut string = String::new();
+				for option in options {
+					if let Parameter::String(s) = option.evaluate_(arguments, template, nesting+1)? {
+						string.push_str(&s);
+					} else {
+						return None;
+					}
+				}
+				Some(Parameter::String(string))
+			}
+			Self::If(condition, thenval, elseval) => {
+				if let Parameter::Bool(b) = condition.evaluate_(arguments, template, nesting+1)? {
+					if b {
+						thenval.evaluate_(arguments, template, nesting+1)
+					} else {
+						elseval.evaluate_(arguments, template, nesting+1)
+					}
+				} else {
+					None
+				}
+			}
+			Self::TemplateSelf => Some(Parameter::Template(template.clone())),
+			Self::TemplateName => Some(Parameter::String(template.name.0.clone())),
+			
+		}
+	}
+	
+	pub fn from_json(value: &Value) -> PResult<Self> {
+		if !value.is_array() {
+			return Ok(Self::Constant(Parameter::guess_from_json(value)?));
+		}
+		let paramvalue = value.get(1).ok_or(perr!("index 1 not in component parameter"))?;
+		let typename = value.get(0).ok_or(perr!("index 0 not in component parameter"))?.as_str().ok_or(perr!("compparam type not a string"))?;
+		match typename {
+			"string" | "int" | "float" | "bool" | "pos" => {
+				let paramtype = ParameterType::from_str(typename).expect(&format!("unknown parameter type {:?}", typename));
+				Ok(Self::Constant(Parameter::from_typed_json(paramtype, paramvalue)?))
+			}
+			"list" => {
+				let values = paramvalue.as_array().ok_or(perr!("random argument not an array"))?;
+				let mut entries = Vec::new();
+				for entry in values {
+					entries.push(Self::from_json(entry)?)
+				}
+				Ok(Self::List(entries))
+			}
+			"template" => {
+				match paramvalue {
+					Value::String(s) => Ok(Self::Template{
+						name: EntityType(s.clone()),
+						kwargs: HashMap::new(),
+						save: SaveOption::Default
+					}),
+					Value::Object(o) => {
+						let name = EntityType(o.get("type").ok_or(perr!("template doesn't have 'type'"))?.as_str().ok_or(perr!("template type not a string"))?.to_string());
+						let mut kwargs = HashMap::new();
+						for (key, arg) in o.get("kwargs").unwrap_or(&json!({})).as_object().ok_or(perr!("template kwargs not a json object"))? {
+							kwargs.insert(key.to_string(), Self::from_json(arg)?);
+						}
+						let save = match o.get("save") {
+							Some(Value::Bool(b)) if *b => SaveOption::Always,
+							Some(Value::Bool(_b)) => SaveOption::False,
+							None => SaveOption::Default,
+							_ => {return Err(perr!("save not a bool"))}
+						};
+						Ok(Self::Template{name, kwargs, save})
+					}
+					_ => return Err(perr!("invalid template {:?}", paramvalue))
+				}
+			}
+			"A" | "arg" => {
+				let argname = paramvalue.as_str().ok_or(perr!("argument parameter not a string"))?.to_string();
+				Ok(Self::Argument(argname))
+			}
+			"random" => {
+				let optionvalues = paramvalue.as_array().ok_or(perr!("random argument not an array"))?;
+				let mut options = Vec::new();
+				for option in optionvalues {
+					options.push(Self::from_json(option)?)
+				}
+				Ok(Self::Random(options))
+			}
+			"concat" => {
+				let values = paramvalue.as_array().ok_or(perr!("concat argument not an array"))?;
+				let mut options = Vec::new();
+				for option in values {
+					options.push(Self::from_json(option)?)
+				}
+				Ok(Self::Concat(options))
+			}
+			"if" => {
+				Ok(Self::If(
+					Box::new(Self::from_json(paramvalue.get(0).ok_or(perr!("if does not have condition"))?)?),
+					Box::new(Self::from_json(paramvalue.get(1).ok_or(perr!("if does not have then value"))?)?),
+					Box::new(Self::from_json(paramvalue.get(2).ok_or(perr!("if does not have else value"))?)?)
+				))
+			}
+			"self" => Ok(Self::TemplateSelf),
+			"name" => Ok(Self::TemplateName),
+			_ => Err(perr!("unknown compparam type '{}'", typename))
+		}
+	}
+	
+	#[allow(dead_code)]
+	pub fn get_type(&self, arguments: &[(String, ParameterType, Option<Parameter>)]) -> Result<ParameterType>{
+		Ok(match self {
+			Self::Constant(param) => param.paramtype(),
+			Self::List(_) => ParameterType::List,
+			Self::Template{name: _, kwargs: _, save: _} => ParameterType::Template,
+			Self::Argument(argname) => arguments.iter().find(|(n, _t, _d)| n == argname).ok_or(aerr!("unknown argument name {} in {:?}", argname, arguments))?.1,
+			Self::Random(options) => {
+				let typ: ParameterType = options.get(0).ok_or(aerr!("random has no options"))?.get_type(arguments)?;
+				for param in options {
+					if param.get_type(arguments)? != typ {
+						return Err(aerr!("inconsistent parameter types in random"));
+					}
+				}
+				typ
+			},
+			Self::If(condition, thenval, elseval) => {
+				if condition.get_type(arguments)? != ParameterType::Bool {
+					return Err(aerr!("if condition is not a bool"));
+				}
+				let typ: ParameterType = thenval.get_type(arguments)?;
+				if elseval.get_type(arguments)? != typ {
+					return Err(aerr!("inconsistent parameter types in if"));
+				}
+				typ
+			},
+			Self::Concat(_s) => ParameterType::String,
+			Self::TemplateSelf => ParameterType::Template,
+			Self::TemplateName => ParameterType::String
+		})
+	}
+}
diff --git a/src/resources/ground.rs b/src/resources/ground.rs
index 7411a15..7868be9 100644
--- a/src/resources/ground.rs
+++ b/src/resources/ground.rs
@@ -9,7 +9,8 @@ use specs::{
 
 use crate::{
 	components::{Visible, Flags, Flag},
-	Pos
+	Pos,
+	controls::Direction
 };
 
 #[derive(Default)]
@@ -43,6 +44,19 @@ impl Ground {
 			.collect()
 	}
 	
+	pub fn components_near<'a, C: Component>(&self, pos: Pos, directions: &[Direction], component_type: &'a ReadStorage<C>) -> Vec<(Entity, &'a C)> {
+		let mut nearby_components: Vec<(Entity, &'a C)> = Vec::new();
+		for direction in directions {
+			let pos = pos + direction.to_position();
+			for ent in self.cells.get(&pos).unwrap_or(&HashSet::new()) {
+				if let Some(comp) = component_type.get(*ent) {
+					nearby_components.push((*ent, comp));
+				}
+			}
+		}
+		nearby_components
+	}
+	
 	pub fn by_height(&self, pos: &Pos, visibles: &ReadStorage<Visible>, ignore: &Entity) -> Vec<Entity> {
 		let mut entities: Vec<Entity> = self.cells
 			.get(&pos).unwrap_or(&HashSet::new())
diff --git a/src/room.rs b/src/room.rs
index 0b8ee3b..56fe2e6 100644
--- a/src/room.rs
+++ b/src/room.rs
@@ -70,7 +70,7 @@ use crate::{
 		Building,
 		Deduplicate,
 		SpawnTrigger,
-		Replace
+		Replace,
 	}
 };
 
diff --git a/src/systems/interact.rs b/src/systems/interact.rs
index b377a7a..1eb4589 100644
--- a/src/systems/interact.rs
+++ b/src/systems/interact.rs
@@ -28,7 +28,7 @@ use crate::{
 		Minable
 	},
 	controls::{Control},
-	resources::{Ground, NewEntities, Emigration},
+	resources::{Ground, Emigration, NewEntities},
 	hashmap,
 	playerstate::RoomPos,
 	PlayerId,
@@ -45,31 +45,26 @@ impl <'a> System<'a> for Interact {
 		WriteStorage<'a, ControlCooldown>,
 		ReadStorage<'a, Interactable>,
 		WriteStorage<'a, TriggerBox>,
-		Write<'a, NewEntities>,
 		WriteStorage<'a, Ear>,
 		WriteStorage<'a, Inventory>,
 		ReadStorage<'a, Visible>,
 		ReadStorage<'a, Player>,
 		Write<'a, Emigration>,
 		WriteStorage<'a, Whitelist>,
-		WriteStorage<'a, Minable>
+		WriteStorage<'a, Minable>,
+		Read<'a, NewEntities>
 	);
 	
-	fn run(&mut self, (entities, controllers, positions, ground, mut cooldowns, interactables, mut triggerbox, new, mut ears, mut inventories, visibles, players, mut emigration, mut whitelists, mut minables): 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, new): Self::SystemData) {
 		for (actor, controller, position) in (&entities, &controllers, &positions).join(){
 			let mut target = None;
 			let ear = ears.get_mut(actor);
 			match &controller.control {
 				Control::Interact(directions, arg) => {
-					'targets: for direction in directions {
-						let pos = position.pos + direction.to_position();
-						for ent in ground.cells.get(&pos).unwrap_or(&HashSet::new()) {
-							if let Some(interactable) = interactables.get(*ent) {
-								if interactable.accepts_arg(arg){
-									target = Some((*ent, interactable, arg.clone()));
-									break 'targets;
-								}
-							}
+					for (ent, interactable) in ground.components_near(position.pos, directions, &interactables) {
+						if interactable.accepts_arg(arg){
+							target = Some((ent, interactable, arg.clone()));
+							break;
 						}
 					}
 				}
@@ -79,35 +74,14 @@ impl <'a> System<'a> for Interact {
 				let mut cooldown = 2;
 				let name = visibles.get(ent).map(|v| v.name.as_str());
 				match interactable {
-					Interactable::Trigger(trigger) => {
-						TriggerBox::add_message(&mut triggerbox, ent, *trigger);
-					}
 					Interactable::Say(text) => {
 						say(ear, text.clone(), name);
 					}
 					Interactable::Reply(text) => {
 						say(ear, text.replace("{}", &arg.unwrap()), name);
 					}
-					Interactable::Exchange(prefix, exchanges) => {
-						if let Some(txt) = arg {
-							if let (Some(inventory), Some(action)) = (inventories.get_mut(actor), strip_prefix(&txt, prefix)) {
-								if let Some(exchange) = exchanges.get(action) {
-									if exchange.can_trade(inventory){
-										exchange.trade(inventory, &new.encyclopedia);
-										say(ear, format!("Success! '{}' ({})", txt, exchange.show()), name);
-									} else {
-										say(ear, format!("You do not have the required items or inventory space for '{}' ({})", txt, exchange.show()), name);
-									}
-								} else {
-									say(ear, format!("Invalid option: {}", action), name);
-								}
-							}
-						} else if let Some(ear) = ear {
-							ear.sounds.push(Notification::Options{
-								description: "".to_string(),
-								options: exchanges.iter().map(|(id, exchange)| (format!("{}{}", prefix, id), exchange.show())).collect()
-							})
-						}
+					Interactable::Trigger(trigger) => {
+						TriggerBox::add_message(&mut triggerbox, ent, *trigger);
 					}
 					Interactable::Visit(dest) => {
 						if let Some(argument) = arg {
@@ -163,6 +137,27 @@ impl <'a> System<'a> for Interact {
 							}
 						}
 					}
+					Interactable::Exchange(prefix, exchanges) => {
+						if let Some(txt) = arg {
+							if let (Some(inventory), Some(action)) = (inventories.get_mut(actor), strip_prefix(&txt, prefix)) {
+								if let Some(exchange) = exchanges.get(action) {
+									if exchange.can_trade(inventory){
+										exchange.trade(inventory, &new.encyclopedia);
+										say(ear, format!("Success! '{}' ({})", txt, exchange.show()), name);
+									} else {
+										say(ear, format!("You do not have the required items or inventory space for '{}' ({})", txt, exchange.show()), name);
+									}
+								} else {
+									say(ear, format!("Invalid option: {}", action), name);
+								}
+							}
+						} else if let Some(ear) = ear {
+							ear.sounds.push(Notification::Options{
+								description: "".to_string(),
+								options: exchanges.iter().map(|(id, exchange)| (format!("{}{}", prefix, id), exchange.show())).collect()
+							})
+						}
+					}
 				}
 				cooldowns.insert(actor, ControlCooldown{amount: cooldown}).unwrap();
 			}
diff --git a/src/systems/mod.rs b/src/systems/mod.rs
index 7323dee..7f93bb9 100644
--- a/src/systems/mod.rs
+++ b/src/systems/mod.rs
@@ -50,5 +50,5 @@ pub use self::{
 	building::Building,
 	deduplicate::Deduplicate,
 	spawntrigger::SpawnTrigger,
-	replace::Replace
+	replace::Replace,
 };
diff --git a/src/template.rs b/src/template.rs
index 0ac03cd..7422465 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -89,11 +89,11 @@ impl Template {
 		let name = EntityType(val.get("type").ok_or(perr!("template doesn't have 'type'"))?.as_str().ok_or(perr!("template type not a string"))?.to_string());
 		let mut args = Vec::new();
 		for arg in val.get("args").unwrap_or(&json!([])).as_array().ok_or(perr!("template args not an array"))? {
-			args.push(Parameter::guess_from_json(arg).ok_or(perr!("template arg {:?} not a parameter", arg))?);
+			args.push(Parameter::guess_from_json(arg)?);
 		}
 		let mut kwargs = HashMap::new();
 		for (key, arg) in val.get("kwargs").unwrap_or(&json!({})).as_object().ok_or(perr!("template kwargs not a json object"))? {
-			kwargs.insert(key.to_string(), Parameter::guess_from_json(arg).ok_or(perr!("template kwarg {}: {:?} not a parameter", key, arg))?);
+			kwargs.insert(key.to_string(), Parameter::guess_from_json(arg)?);
 		}
 		let save = 
 			if let Some(saveval) = val.get("save") {