Index: binaries/data/mods/public/simulation/helpers/Requirements.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/helpers/Requirements.js
@@ -0,0 +1,161 @@
+function RequirementsHelper() {}
+
+const EntityRequirementSchema =
+	"</element name='Entities' a:help='Entities that need to be controlled.'>" +
+		"<oneOrMore>" +
+			"<element a:help='Class of entity that needs to be controlled.'>" +
+				"</anyname>" +
+				"<oneOrMore>" +
+					"<choice>" +
+						"<element name='Count' a:help='Number of entities required.'>" +
+							"<data type='nonNegativeInteger'/>" +
+						"</element>" +
+						"<element name='Variants' a:help='Number of different entities of this class required.'>" +
+							"<data type='nonNegativeInteger'/>" +
+						"</element>" +
+					"</choice>" +
+				"</oneOrMore>" +
+			"</element>" +
+		"</oneOrMore>" +
+	"</element>";
+
+const TechnologyRequirementSchema =
+	"<element name='Techs' a:help='White-space separated list of technologies that need to be researched. ! negates a tech.'>" +
+		"<attribute name='datatype'>" +
+		    "<value>tokens</value>" +
+		"</attribute>" +
+		"<text/>" +
+	"</element>";
+
+const CombinedRequirementSchema =
+	"<oneOrMore>" +
+		"<choice>" +
+			EntityRequirementSchema +
+			TechnologyRequirementSchema +
+		"</choice>" +
+	"</oneOrMore>";
+
+RequirementsHelper.prototype.RequirementSchema =
+	"<zeroOrMore>" +
+		"<choice>" +
+			"<element name='All' a:help='Requires all of the conditions to be met.>" +
+				CombinedRequirementSchema +
+			"</element>" +
+			"<element name='Any' a:help='Requires at least one of the following conditions met.>" +
+				CombinedRequirementSchema +
+			"</element>" +
+			EntityRequirementSchema +
+			TechnologyRequirementSchema +
+		"</choice>" +
+	"</zeroOrMore>";
+
+/**
+ * @return {string} - A RelaxRNG schema for requirements.
+ */
+RequirementsHelper.prototype.BuildSchema = function()
+{
+	return "" +
+	"<element name='Requirements' a:help='The requirements that ought to be met before this entity can be produced.'>" +
+		"<optional>" +
+			"<choice>" +
+				"<element name='All' a:help='Requires all of the conditions to be met.>" +
+					this.RequirementSchema +
+				"</element>" +
+				"<element name='Any' a:help='Requires at least one of the following conditions met.>" +
+					this.RequirementSchema +
+				"</element>" +
+			"</choice>" +
+		"</optional>" +
+	"</element>";
+};
+
+/**
+ * @param {Object} template - The requirements template as defined above.
+ * @param {number} playerID - The player ID to check the requirements for.
+ * @return {boolean} - Whether the requirements are met.
+ */
+RequirementsHelper.prototype.AreRequirementsMet = function(template, playerID)
+{
+	if (!template || !Object.keys(template).length)
+		return true;
+
+	const cmpTechManager = QueryPlayerIDInterface(playerID, IID_TechnologyManager);
+
+	if (template.All)
+		return this.AllRequirementsMet(template.All, cmpTechManager);
+	if (template.Any)
+		return this.AnyRequirementsMet(template.Any, cmpTechManager);
+	return true;
+};
+
+RequirementsHelper.prototype.AllRequirementsMet = function(template, cmpTechManager)
+{
+	for (const requirementType in template)
+	{
+		const requirement = template[requirementType];
+		if (requirementType === "All" && !this.AllRequirementsMet(requirement, cmpTechManager))
+			return false;
+		if (requirementType === "Any" && !this.AnyRequirementsMet(requirement, cmpTechManager))
+			return false;
+		if (requirementType === "Entities")
+		{
+			for (const className in requirement)
+			{
+				const entReq = requirement[className];
+				if ("Count" in entReq && (!(className in cmpTechManager.classCounts) || cmpTechManager.classCounts[className] < entReq.Count))
+					return false;
+				if ("Variants" in entReq && (!(className in cmpTechManager.typeCountsByClass) || Object.keys(cmpTechManager.typeCountsByClass[className]).length < entReq.Variants))
+					return false;
+			}
+		}
+		if (requirementType === "Techs")
+		{
+			for (const tech of requirement.split(" "))
+			{
+				const negate = tech[0] === "!";
+				if (negate && cmpTechManager.IsTechnologyResearched(tech.substring(1)))
+					return false;
+				if (!negate && !cmpTechManager.IsTechnologyResearched(tech))
+					return false;
+			}
+		}
+	}
+	return true;
+};
+
+RequirementsHelper.prototype.AnyRequirementsMet = function(template, cmpTechManager)
+{
+	for (const requirementType in template)
+	{
+		const requirement = template[requirementType];
+		if (requirementType === "All" && this.AllRequirementsMet(requirement, cmpTechManager))
+			return true;
+		if (requirementType === "Any" && this.AnyRequirementsMet(requirement, cmpTechManager))
+			return true;
+		if (requirementType === "Entities")
+		{
+			for (const className in requirement)
+			{
+				const entReq = requirement[className];
+				if ("Count" in entReq && className in cmpTechManager.classCounts && cmpTechManager.classCounts[className] >= entReq.Count)
+					return true;
+				if ("Variants" in entReq && className in cmpTechManager.typeCountsByClass && Object.keys(cmpTechManager.typeCountsByClass[className]).length >= entReq.Variants)
+					return true;
+			}
+		}
+		if (requirementType === "Techs")
+		{
+			for (const tech of requirement.split(" "))
+			{
+				const negate = tech[0] === "!";
+				if (negate && !cmpTechManager.IsTechnologyResearched(tech.substring(1)))
+					return true;
+				if (!negate && cmpTechManager.IsTechnologyResearched(tech))
+					return true;
+			}
+		}
+	}
+	return false;
+};
+
+Engine.RegisterGlobal("RequirementsHelper", new RequirementsHelper());
Index: binaries/data/mods/public/simulation/helpers/tests/test_Requirements.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/helpers/tests/test_Requirements.js
@@ -0,0 +1,630 @@
+Engine.LoadComponentScript("interfaces/PlayerManager.js");
+Engine.LoadComponentScript("interfaces/TechnologyManager.js");
+Engine.LoadHelperScript("Player.js");
+Engine.LoadHelperScript("Requirements.js");
+
+const playerID = 1;
+const playerEnt = 11;
+
+AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+	"GetPlayerByID": () => playerEnt
+});
+
+let template = {
+	"Requirements": {}
+};
+
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"All": {
+			"Entities": {
+				"class_1": {
+					"Count": 1
+				}
+			}
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {},
+	"typeCountsByClass": {}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 0
+	},
+	"typeCountsByClass": {}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_2": 1
+	},
+	"typeCountsByClass": {}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 1
+	},
+	"typeCountsByClass": {}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 1
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"All": {
+			"Entities": {
+				"class_1": {
+					"Variants": 2
+				}
+			}
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 2
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 1
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"All": {
+			"Entities": {
+				"class_1": {
+					"Count": 1,
+					"Variants": 2
+				}
+			}
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 1
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"All": {
+			"Entities": {
+				"class_1": {
+					"Count": 3,
+					"Variants": 2
+				}
+			}
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 2,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"All": {
+			"Techs": "phase_town"
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => false
+});
+
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_town"
+});
+
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"All": {
+			"Techs": "phase_city"
+		}
+	}
+};
+
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"All": {
+			"Techs": "phase_town phase_city"
+		}
+	}
+};
+
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_town" || tech === "phase_city"
+});
+
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"All": {
+			"Techs": "!phase_city"
+		}
+	}
+};
+
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"All": {
+			"Techs": "!phase_town phase_city"
+		}
+	}
+};
+
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_city"
+});
+
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"All": {
+			"Entities": {
+				"class_1": {
+					"Count": 3,
+					"Variants": 2
+				}
+			},
+			"Techs": "phase_town"
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"IsTechnologyResearched": (tech) => false,
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 2,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_town",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 2,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_city",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 2,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"Any": {
+			"Entities": {
+				"class_1": {
+					"Count": 1,
+				}
+			},
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 0
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 1
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"Any": {
+			"Entities": {
+				"class_1": {
+					"Count": 5,
+					"Variants": 2
+				}
+			},
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3,
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 2,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"Any": {
+			"Techs": "phase_town"
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_city"
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_town"
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"Any": {
+			"Techs": "phase_town phase_city"
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_city"
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"Any": {
+			"Techs": "!phase_town"
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_town"
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_city"
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+template = {
+	"Requirements": {
+		"Any": {
+			"Techs": "!phase_town phase_city"
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"IsTechnologyResearched": (tech) => tech === "phase_town" || tech === "phase_city"
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"Any": {
+			"Entities": {
+				"class_1": {
+					"Count": 3,
+					"Variants": 2
+				}
+			},
+			"Techs": "!phase_town"
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_town",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"All": {
+			"All": {
+				"Techs": "!phase_town"
+			},
+			"Any": {
+				"Entities": {
+					"class_1": {
+						"Count": 3,
+						"Variants": 2
+					}
+				},
+				"Techs": "phase_city"
+			}
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_town",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_town" || tech === "phase_city",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_city",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"IsTechnologyResearched": (tech) => false,
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+
+template = {
+	"Requirements": {
+		"Any": {
+			"All": {
+				"Techs": "!phase_town"
+			},
+			"Any": {
+				"Entities": {
+					"class_1": {
+						"Count": 3,
+						"Variants": 2
+					}
+				},
+				"Techs": "phase_city"
+			}
+		}
+	}
+};
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_town",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3
+		}
+	}
+});
+TS_ASSERT(!RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 3
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_town" || tech === "phase_city",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"IsTechnologyResearched": (tech) => tech === "phase_city",
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 3
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));
+
+AddMock(playerEnt, IID_TechnologyManager, {
+	"classCounts": {
+		"class_1": 2
+	},
+	"IsTechnologyResearched": (tech) => false,
+	"typeCountsByClass": {
+		"class_1": {
+			"template_1": 1,
+			"template_2": 1
+		}
+	}
+});
+TS_ASSERT(RequirementsHelper.AreRequirementsMet(template.Requirements, playerID));