Index: binaries/data/mods/public/gui/session/input.js
===================================================================
--- binaries/data/mods/public/gui/session/input.js
+++ binaries/data/mods/public/gui/session/input.js
@@ -1574,16 +1574,6 @@
 		});
 }
 
-function lockGate(lock)
-{
-	var selection = g_Selection.toList();
-	Engine.PostNetworkCommand({
-		"type": "lock-gate",
-		"entities": selection,
-		"lock": lock,
-	});
-}
-
 function packUnit(pack)
 {
 	var selection = g_Selection.toList();
@@ -1606,21 +1596,22 @@
 	});
 }
 
-function upgradeEntity(Template)
+function chargeAbility(ability)
 {
 	Engine.PostNetworkCommand({
-		"type": "upgrade",
+		"type": "charge-ability",
 		"entities": g_Selection.toList(),
-		"template": Template,
+		"ability": ability,
 		"queued": false
 	});
 }
 
-function cancelUpgradeEntity()
+function cancelChargeAbility(ability)
 {
 	Engine.PostNetworkCommand({
-		"type": "cancel-upgrade",
+		"type": "cancel-charge-ability",
 		"entities": g_Selection.toList(),
+		"ability": ability,
 		"queued": false
 	});
 }
Index: binaries/data/mods/public/gui/session/selection_panels.js
===================================================================
--- binaries/data/mods/public/gui/session/selection_panels.js
+++ binaries/data/mods/public/gui/session/selection_panels.js
@@ -432,65 +432,6 @@
 	}
 };
 
-g_SelectionPanels.Gate = {
-	"getMaxNumberOfItems": function()
-	{
-		return 24 - getNumberOfRightPanelButtons();
-	},
-	"getItems": function(unitEntStates)
-	{
-		let gates = [];
-		for (let state of unitEntStates)
-		{
-			if (state.gate && !gates.length)
-			{
-				gates.push({
-					"gate": state.gate,
-					"tooltip": translate("Lock Gate"),
-					"locked": true,
-					"callback": function (item) { lockGate(item.locked); }
-				},
-				{
-					"gate": state.gate,
-					"tooltip": translate("Unlock Gate"),
-					"locked": false,
-					"callback": function (item) { lockGate(item.locked); }
-				});
-			}
-			// Show both 'locked' and 'unlocked' as active if the selected gates have both lock states.
-			else if (state.gate && state.gate.locked != gates[0].gate.locked)
-				for (let j = 0; j < gates.length; ++j)
-					delete gates[j].gate.locked;
-		}
-
-		return gates;
-	},
-	"setupButton": function(data)
-	{
-		data.button.onPress = function() {data.item.callback(data.item); };
-
-		data.button.tooltip = data.item.tooltip;
-
-		data.button.enabled = controlsPlayer(data.player);
-		let gateIcon;
-		if (data.item.gate)
-		{
-			// show locking actions
-			gateIcon = "icons/lock_" + GATE_ACTIONS[data.item.locked ? 0 : 1] + "ed.png";
-			if (data.item.gate.locked === undefined)
-				data.guiSelection.hidden = false;
-			else
-				data.guiSelection.hidden = data.item.gate.locked != data.item.locked;
-		}
-
-		data.icon.sprite = (data.neededResources ? resourcesToAlphaMask(data.neededResources) + ":" : "") + "stretched:session/" + gateIcon;
-
-		let index = data.i + getNumberOfRightPanelButtons();
-		setPanelObjectPosition(data.button, index, data.rowLength);
-		return true;
-	}
-};
-
 g_SelectionPanels.Pack = {
 	"getMaxNumberOfItems": function()
 	{
@@ -1066,27 +1007,22 @@
 	}
 };
 
-g_SelectionPanels.Upgrade = {
+g_SelectionPanels.Ability = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function(unitEntStates)
 	{
-		// Interface becomes complicated with multiple different units and this is meant per-entity, so prevent it if the selection has multiple different units.
+		// Interface becomes complicated with multiple different units and this is meant per-entity, so prevent it if the selection has multiple different units for now.
 		if (unitEntStates.some(state => state.template != unitEntStates[0].template))
 			return false;
 
-		return unitEntStates[0].upgrade && unitEntStates[0].upgrade.upgrades;
+		return unitEntStates[0].abilities && unitEntStates[0].abilities;
 	},
 	"setupButton" : function(data)
 	{
-		let template = GetTemplateData(data.item.entity);
-		if (!template)
-			return false;
-
 		let technologyEnabled = true;
-
 		if (data.item.requiredTechnology)
 			technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", {
 				"tech": data.item.requiredTechnology,
@@ -1099,59 +1035,59 @@
 			for (let cost in data.item.cost)
 				if (cost != "time")
 					data.item.cost[cost] *= data.unitEntStates.length;
-
 			neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
 				"cost": data.item.cost,
 				"player": data.player
 			});
 		}
 
-		let limits = getEntityLimitAndCount(data.playerState, data.item.entity);
-		let progress = data.unitEntStates[0].upgrade.progress || 0;
-		let isUpgrading = data.unitEntStates[0].upgrade.template == data.item.entity;
+		let progress = data.item.progress || 0;
+		let availability = data.item.availability;
 
 		let tooltip;
-		if (!progress)
-		{
-			let tooltips = [];
-			if (data.item.tooltip)
-				tooltips.push(sprintf(translate("Upgrade into a %(name)s. %(tooltip)s"), {
-					"name": template.name.generic,
-					"tooltip": translate(data.item.tooltip)
-				}));
-			else
-				tooltips.push(sprintf(translate("Upgrade into a %(name)s."), {
-					"name": template.name.generic
-				}));
 
+		let tooltips = [];
+		tooltips.push(sprintf(translate("[font=\"sans-bold-16\"]%(name)s[/font]"), {
+			"name": data.item.readableName
+		}));
+		tooltips = tooltips.concat(data.item.tooltips || []);
+		if (availability == "unavailable" || availability == "available")
+		{
 			tooltips.push(
-				getEntityCostTooltip(data.item),
-				formatLimitString(limits.entLimit, limits.entCount, limits.entLimitChangers),
 				getRequiredTechnologyTooltip(technologyEnabled, data.item.requiredTechnology, GetSimState().players[data.player].civ),
 				getNeededResourcesTooltip(neededResources));
 
-			tooltip = tooltips.filter(tip => tip).join("\n");
-
-			data.button.onPress = function() { upgradeEntity(data.item.entity); };
+			data.button.onPress = function() { chargeAbility(data.item.ability); };
 		}
-		else if (isUpgrading)
+		else if (availability == "charging")
 		{
-			tooltip = translate("Cancel Upgrading");
-			data.button.onPress = function() { cancelUpgradeEntity(); };
+			tooltips.push(translate("\nCancel Ability."));
+			data.button.onPress = function() { cancelChargeAbility(data.item.ability); };
+		}
+		else if (availability == "ready")
+		{
+			tooltips.push(translate("\nThis ability is charged and can now be activated."));
+			data.button.onPress = function() {};
+		}
+		else if (availability == "cooldown")
+		{
+			tooltips.push(translate("\nThis ability is cooling down and cannot be charged."));
+			data.button.onPress = function() {};
 		}
 		else
 		{
-			tooltip = translate("Cannot upgrade when the entity is already upgrading.");
+			tooltips.push(translate("\nThis ability is active."));
 			data.button.onPress = function() {};
 		}
+		tooltip = tooltips.filter(tip => tip).join("\n");
+
 		data.button.enabled = controlsPlayer(data.player);
 		data.button.tooltip = tooltip;
 
 		let modifier = "";
-		if (!isUpgrading)
+		if (availability == "unavailable" || availability == "available")
 		{
-			if (progress || !technologyEnabled || limits.canBeAddedCount == 0 &&
-				!hasSameRestrictionCategory(data.item.entity, data.unitEntStates[0].template))
+			if (availability == "unavailable" || !technologyEnabled)
 			{
 				data.button.enabled = false;
 				modifier = "color:0 0 0 127:grayscale:";
@@ -1163,19 +1099,41 @@
 			}
 		}
 
-		data.icon.sprite = modifier + "stretched:session/" +
-			(data.item.icon || "portraits/" + template.icon);
+		data.icon.sprite = modifier + "stretched:session/" + data.item.icon;
+
+		let overlayIcon = Engine.GetGUIObjectByName("unitAbilityOverlayIcon[" + data.i + "]");
+		if (data.item.overlayIcon && availability != "active")
+		{
+			overlayIcon.hidden = false;
+			overlayIcon.sprite = "stretched:session/" + data.item.overlayIcon;
+		}
+		else if (availability == "active")
+		{
+			overlayIcon.hidden = false;
+			overlayIcon.sprite = "stretched:session/icons/corners.png";
+		}
+		else
+			overlayIcon.hidden = true;
 
 		data.countDisplay.caption = data.unitEntStates.length > 1 ? data.unitEntStates.length : "";
 
-		let progressOverlay = Engine.GetGUIObjectByName("unitUpgradeProgressSlider[" + data.i + "]");
-		if (isUpgrading)
+		let progressOverlay = Engine.GetGUIObjectByName("unitAbilityProgressSlider[" + data.i + "]");
+		if (availability == "charging")
 		{
 			let size = progressOverlay.size;
 			size.top = size.left + Math.round(progress * (size.right - size.left));
 			progressOverlay.size = size;
+			progressOverlay.sprite = "queueProgressSlider";
+		}
+		else if (availability == "cooldown")
+		{
+
+			let size = progressOverlay.size;
+			size.top = size.left + Math.round(progress * (size.right - size.left));
+			progressOverlay.size = size;
+			progressOverlay.sprite = "queueGrayProgressSlider";
 		}
-		progressOverlay.hidden = !isUpgrading;
+		progressOverlay.hidden = !(availability == "charging" || availability == "cooldown");
 
 		let index = data.i + getNumberOfRightPanelButtons();
 		setPanelObjectPosition(data.button, index, data.rowLength);
@@ -1198,9 +1156,8 @@
 	"Stance", // Normal together with formation
 
 	// RIGHT PANE
-	"Gate", // Must always be shown on gates
 	"Pack", // Must always be shown on packable entities
-	"Upgrade", // Must always be shown on upgradable entities
+	"Ability", // Must always be shown on entities with abilities
 	"Training",
 	"Construction",
 	"Research", // Normal together with training
Index: binaries/data/mods/public/gui/session/selection_panels_helpers.js
===================================================================
--- binaries/data/mods/public/gui/session/selection_panels_helpers.js
+++ binaries/data/mods/public/gui/session/selection_panels_helpers.js
@@ -1,7 +1,6 @@
-const GATE_ACTIONS = ["lock", "unlock"];
-
-const UPGRADING_NOT_STARTED = -2;
-const UPGRADING_CHOSEN_OTHER = -1;
+const BARTER_RESOURCE_AMOUNT_TO_SELL = 100;
+const BARTER_BUNCH_MULTIPLIER = 5;
+const BARTER_ACTIONS = ["Sell", "Buy"];
 
 function canMoveSelectionIntoFormation(formationTemplate)
 {
Index: binaries/data/mods/public/gui/session/selection_panels_right/abilities_panel.xml
===================================================================
--- binaries/data/mods/public/gui/session/selection_panels_right/abilities_panel.xml
+++ binaries/data/mods/public/gui/session/selection_panels_right/abilities_panel.xml
@@ -1,15 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
-<object name="unitUpgradePanel"
+<object name="unitAbilityPanel"
 	size="10 12 100% 100%"
 >
 	<object size="0 0 100% 100%">
 	<repeat count="8">
-		<object name="unitUpgradeButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
-		<object name="unitUpgradeIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
-		<object name="unitUpgradeUpgradeIcon[n]" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/upgrade.png"/>
-		<object name="unitUpgradeProgressSlider[n]" type="image" sprite="queueProgressSlider" ghost="true" size="3 3 43 43" z="20"/>
-		<object name="unitUpgradeSelection[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/corners.png"/>
-		<object name="unitUpgradeCount[n]" ghost="true" style="groupIconsText" type="text" z="30"/>
+		<object name="unitAbilityButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
+		<object name="unitAbilityIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
+		<object name="unitAbilityOverlayIcon[n]" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/upgrade.png"/>
+		<object name="unitAbilityProgressSlider[n]" type="image" sprite="queueProgressSlider" ghost="true" size="3 3 43 43" z="20"/>
+		<object name="unitAbilitySelection[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/corners.png"/>
+		<object name="unitAbilityCount[n]" ghost="true" style="groupIconsText" type="text" z="30"/>
 		</object>
 	</repeat>
 	</object>
Index: binaries/data/mods/public/gui/session/selection_panels_right/gate_panel.xml
===================================================================
--- binaries/data/mods/public/gui/session/selection_panels_right/gate_panel.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<object name="unitGatePanel"
-	size="10 12 100% 100%"
->
-	<object size="0 0 100% 100%">
-	<repeat count="8">
-		<object name="unitGateButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
-		<object name="unitGateIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
-		<object name="unitGateSelection[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/corners.png"/>
-		</object>
-	</repeat>
-	</object>
-</object>
Index: binaries/data/mods/public/gui/session/selection_panels_right/upgrade_panel.xml
===================================================================
--- binaries/data/mods/public/gui/session/selection_panels_right/upgrade_panel.xml
+++ binaries/data/mods/public/gui/session/selection_panels_right/upgrade_panel.xml
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<object name="unitUpgradePanel"
-	size="10 12 100% 100%"
->
-	<object size="0 0 100% 100%">
-	<repeat count="8">
-		<object name="unitUpgradeButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
-		<object name="unitUpgradeIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
-		<object name="unitUpgradeUpgradeIcon[n]" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/upgrade.png"/>
-		<object name="unitUpgradeProgressSlider[n]" type="image" sprite="queueProgressSlider" ghost="true" size="3 3 43 43" z="20"/>
-		<object name="unitUpgradeSelection[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/corners.png"/>
-		<object name="unitUpgradeCount[n]" ghost="true" style="groupIconsText" type="text" z="30"/>
-		</object>
-	</repeat>
-	</object>
-</object>
Index: binaries/data/mods/public/gui/session/sprites.xml
===================================================================
--- binaries/data/mods/public/gui/session/sprites.xml
+++ binaries/data/mods/public/gui/session/sprites.xml
@@ -438,6 +438,10 @@
 	<sprite name="queueProgressSlider">
 		<image backcolor="0 255 0 128"/>
 	</sprite>
+	
+	<sprite name="queueGrayProgressSlider">
+		<image backcolor="0 0 0 180"/>
+	</sprite>
 
 	<sprite name="healthBackground">
 		<image backcolor="red"/>
Index: binaries/data/mods/public/gui/session/unit_commands.js
===================================================================
--- binaries/data/mods/public/gui/session/unit_commands.js
+++ binaries/data/mods/public/gui/session/unit_commands.js
@@ -12,9 +12,8 @@
 	"Command": 0,
 	"AllyCommand": 0,
 	"Stance": 0,
-	"Gate":0,
 	"Pack": 0,
-	"Upgrade": 0
+	"Ability": 0
 };
 
 /**
@@ -222,7 +221,7 @@
 {
 	var sum = 0;
 
-	for (let prop of ["Construction", "Training", "Pack", "Gate", "Upgrade"])
+	for (let prop of ["Construction", "Training", "Pack", "Ability"])
 		if (g_SelectionPanels[prop].used)
 			sum += g_unitPanelButtons[prop];
 
Index: binaries/data/mods/public/simulation/components/Abilities.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/components/Abilities.js
@@ -0,0 +1,569 @@
+function Abilities() {}
+
+// Various TODOs here:
+// - support progress bars (cf packing)
+// - allow for "delayed firing", for example an ability is charged and the user can activate it anytime, like the god powers in AOM.
+// - check availability during charging.
+
+const ABILITIES_PROGRESS_INTERVAL = 500;
+const LIVE_ABILITY_UPDATE_INTERVAL = 1000;
+
+Abilities.prototype.Schema =
+	"<zeroOrMore>" +
+		"<element>" +
+			"<anyName />" +
+			"<interleave>" +
+				"<element name='Name' a:help='Name that will appear in the GUI'>" +
+					"<text/>" +
+				"</element>" +
+				"<optional>" +
+					"<element name='Icon' a:help='Icon to show in the GUI'>" +
+						"<text/>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='Tooltip' a:help='This will be added to the tooltip of the ability.'>" +
+						"<text/>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='ChargingTime' a:help='Time required to charge this ability, ie the time between the user clicks and the time it fires/becomes available.'>" +
+						"<data type='nonNegativeInteger'/>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='CooldownTime' a:help='Cooldown time between firing and charging this ability.'>" +
+						"<data type='nonNegativeInteger'/>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='AutoActivate' a:help='This ability will charge automatically when it is available.'>" +
+						"<empty/>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='Cost' a:help='Resource cost to fire this ability'>" +
+						"<oneOrMore>" +
+							"<choice>" +
+								Resources.BuildSchema("nonNegativeInteger") +
+							"</choice>" +
+						"</oneOrMore>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='RequiredTechnology' a:help='Define what technology is required for this ability'>" +
+						"<choice>" +
+							"<text/>" +
+							"<empty/>" +
+						"</choice>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='PreventAbilities' a:help='List of abilities that cannot be charged/fired when this is charging/active'>" +
+						"<attribute name='datatype'>" +
+							"<value>tokens</value>" +
+						"</attribute>" +
+						"<text/>" +
+					"</element>" +
+				"</optional>" +
+				"<optional>" +
+					"<element name='IncompatibleAbilities' a:help='List of abilities that will be cancelled if this is fired.'>" +
+						"<attribute name='datatype'>" +
+							"<value>tokens</value>" +
+						"</attribute>" +
+						"<text/>" +
+					"</element>" +
+				"</optional>" +
+				"<oneOrMore>" +
+					"<choice>" +
+						AbilityEffects.GetEffectNames().map(name => AbilityEffects.BuildSchema(name)).join("") +
+					"</choice>" +
+				"</oneOrMore>" +
+			"</interleave>" +
+		"</element>" +
+	"</zeroOrMore>";
+
+Abilities.prototype.Init = function()
+{
+	// Map of charging abilities, as such "ability": {"timer": [timer object], progress" : [milliseconds]}
+	this.chargingAbilities = {};
+
+	// Array of abilities ready to trigger
+	this.readyAbilities = [];
+
+	// Map of currently activated abilities, for those timer-based effects, as such "ability": {[customdata]}
+	this.activatedAbilities = {};
+
+	// Map of abilities cooling down
+	this.coolingdownAbilities = {};
+
+	// Map of abilities that auto-activate. A timer for each, which will check wether we need to auto-activate that ability.
+	this.autoActivatingAbilities = {};
+
+	// save abilities template data conveniently, allowing for some ad-hoc changes.
+	this.abilitiesTemplate = {};
+
+	let availableEffects = AbilityEffects.GetEffectNames();
+	for (let ability in this.template)
+	{
+		this.abilitiesTemplate[ability] = deepcopy(this.template[ability]);
+		this.abilitiesTemplate[ability].effects = [];
+
+		for (let effect of availableEffects)
+		{
+			if (!(effect in this.template[ability]))
+				continue;
+			this.abilitiesTemplate[ability].effects.push(effect);
+			if (this.abilitiesTemplate[ability].PreventAbilities)
+				this.abilitiesTemplate[ability].PreventAbilities = this.abilitiesTemplate[ability].PreventAbilities._string.split(/\s+/);
+			if (this.abilitiesTemplate[ability].IncompatibleAbilities)
+				this.abilitiesTemplate[ability].IncompatibleAbilities = this.abilitiesTemplate[ability].IncompatibleAbilities._string.split(/\s+/);
+		}
+	}
+};
+
+// This will also deal with the "OnDestroy" case.
+Abilities.prototype.OnOwnershipChanged = function(msg)
+{
+	for (let ability in this.chargingAbilities)
+		this.CancelAbility(ability);
+
+	for (let ability of this.readyAbilities)
+		this.CancelAbility(ability);
+
+	// I don't believe it would make sense for an abililty to outlive its creator.
+	for (let ability in this.activatedAbilities)
+		this.CancelAbility(ability);
+
+	// setup now that we have an owner component.
+	if (msg.to !== -1)
+		for (let ability in this.template)
+		{
+			for (let effect of this.abilitiesTemplate[ability].effects)
+				this.abilitiesTemplate[ability] = AbilityEffects.SetupData(this.entity, effect, this.abilitiesTemplate[ability]);
+
+			if ("AutoActivate" in this.abilitiesTemplate[ability])
+			{
+				let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+				this.autoActivatingAbilities[ability] = cmpTimer.SetInterval(this.entity, IID_Abilities, "AutoActivate", ABILITIES_PROGRESS_INTERVAL, ABILITIES_PROGRESS_INTERVAL, { "ability": ability });
+				// try right now.
+				this.AutoActivate({"ability": ability});
+			}
+		}
+	else
+		// cleanup if we're destroyed.
+		for (let ability in this.abilitiesTemplate)
+		{
+			this.CancelAbility(ability);
+			this.CleanupCooldown(ability);
+		}
+};
+
+// expects the data as a ready JSon array, in particular the tokens should be an array and not a string
+Abilities.prototype.AddAbility = function(abilityName, abilityData)
+{
+	let availableEffects = AbilityEffects.GetEffectNames();
+	this.abilitiesTemplate[abilityName] = deepcopy(abilityData);
+	this.abilitiesTemplate[abilityName].effects = [];
+
+	for (let effect of availableEffects)
+	{
+		if (!(effect in abilityData))
+			continue;
+		this.abilitiesTemplate[abilityName].effects.push(effect);
+		this.abilitiesTemplate[abilityName] = AbilityEffects.SetupData(this.entity, effect, this.abilitiesTemplate[abilityName]);
+	}
+};
+
+Abilities.prototype.RemoveAbility = function(abilityName)
+{
+	this.CancelAbility(abilityName);
+	this.CleanupCooldown(abilityName);
+
+	delete this.abilitiesTemplate[abilityName];
+};
+
+// return an array with abilities data, their charge progress, their availability ("unavailable"/"available"/"charging"/"ready"/"active"/"cooldown").
+Abilities.prototype.GetAbilitiesData = function()
+{
+	let ret = [];
+
+	let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+
+	for (let ability in this.abilitiesTemplate)
+	{
+		let abilityData = this.abilitiesTemplate[ability];
+
+		let costs = this.GetResourceCosts(ability);
+		if (this.GetChargingTime(ability) > 0)
+			costs.time = this.GetChargingTime(ability);
+
+		let availability = this.CanChargeAbility(ability, false) ? "available" : "unavailable";
+		if (this.coolingdownAbilities[ability])
+			availability = "cooldown";
+		else if (this.chargingAbilities[ability])
+			availability = "charging";
+		else if (this.activatedAbilities[ability])
+			availability = "active";
+		else if (this.readyAbilities.indexOf(ability) != -1)
+			availability = "ready";
+
+		let icon = abilityData.Icon || undefined;
+		if (!icon)
+			// TODO: implement a preference system?
+			icon = AbilityEffects.GetIcon(this.entity, this.abilitiesTemplate[ability].effects[0], this.abilitiesTemplate[ability]);
+
+		let overlayIcon = abilityData.OverlayIcon || undefined;
+		if (!overlayIcon)
+			overlayIcon = AbilityEffects.GetOverlayIcon(this.entity, this.abilitiesTemplate[ability].effects[0], this.abilitiesTemplate[ability]);
+
+		let tooltips = abilityData.Tooltip ? [abilityData.Tooltip] : [];
+		tooltips = tooltips.concat(this.abilitiesTemplate[ability].effects.slice().map(effect => { return AbilityEffects.GetTooltip(this.entity, effect, this.abilitiesTemplate[ability]); }));
+
+		// todo: send to the effects objects for advanced things?
+		ret.push({
+			"ability": ability,
+			"readableName": abilityData.Name,
+			"icon": icon || undefined,
+			"overlayIcon": overlayIcon || undefined,
+			"cost": Object.keys(costs).length ? costs : undefined,
+			"tooltips": tooltips || undefined,
+			"requiredTechnology": this.GetRequiredTechnology(ability),
+			"progress": availability == "cooldown" ? this.GetCooldownProgress(ability) : this.GetChargingProgress(ability),
+			"availability": availability,
+		});
+	}
+
+	return ret;
+};
+
+Abilities.prototype.IsCharging = function(ability)
+{
+	return !!this.chargingAbilities[ability];
+};
+
+Abilities.prototype.GetChargingAbilities = function()
+{
+	let names = [];
+	for (let name in this.chargingAbilities)
+	{
+		names.push(name);
+	}
+	return names;
+};
+
+Abilities.prototype.GetRequiredTechnology = function(ability)
+{
+	if (!this.abilitiesTemplate[ability])
+		return;
+
+	if (this.abilitiesTemplate[ability].RequiredTechnology)
+		return this.abilitiesTemplate[ability].RequiredTechnology;
+
+	// TODO: send to abilities for custom things?
+	return undefined;
+};
+
+Abilities.prototype.GetResourceCosts = function(ability)
+{
+	if (!this.abilitiesTemplate[ability])
+		return {};
+
+	let choice = this.abilitiesTemplate[ability];
+	if (!choice.Cost)
+		return {};
+
+	let costs = {};
+	for (let r in choice.Cost)
+		costs[r] = ApplyValueModificationsToEntity("Upgrade/Cost/"+r, +choice.Cost[r], this.entity);
+
+	return costs;
+};
+
+Abilities.prototype.GetChargingTime = function(ability)
+{
+	if (!this.abilitiesTemplate[ability])
+		return 0;
+
+	if (!this.abilitiesTemplate[ability].ChargingTime)
+		return 0;
+
+	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+	// TODO: implement per-ability techs?
+	return ApplyValueModificationsToEntity("Abilities/ChargingTime", +this.abilitiesTemplate[ability].ChargingTime, this.entity);
+};
+
+Abilities.prototype.GetCooldownTime = function(ability)
+{
+	if (!this.abilitiesTemplate[ability])
+		return 0;
+
+	if (!this.abilitiesTemplate[ability].CooldownTime)
+		return 0;
+
+	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+	// TODO: implement per-ability techs?
+	return ApplyValueModificationsToEntity("Abilities/CooldownTime", +this.abilitiesTemplate[ability].CooldownTime, this.entity);
+};
+
+Abilities.prototype.GetPreventedAbilities = function()
+{
+	let abilities = [];
+	for (let ability in this.chargingAbilities)
+		abilities.push(ability);
+	for (let ability of this.readyAbilities)
+		abilities.push(ability);
+	for (let ability in this.activatedAbilities)
+		abilities.push(ability);
+	for (let ability in this.coolingdownAbilities)
+		abilities.push(ability);
+
+	let prevented = [];
+	for (let ability of abilities)
+		if (this.abilitiesTemplate[ability].PreventAbilities)
+			prevented = prevented.concat(this.abilitiesTemplate[ability].PreventAbilities);
+	return prevented;
+}
+
+Abilities.prototype.AutoActivate = function(data)
+{
+	// this does all the checks so it'd be redundant to re-check for "already activated".
+	if (this.CanChargeAbility(data.ability, false))
+		this.StartChargingAbility(data.ability);
+}
+
+// TODO: change "sendMessages" to "messages" and pass that around for people to use.
+Abilities.prototype.CanChargeAbility = function(ability, sendMessages)
+{
+	// cannot charge an ability we don't have, or if it's not available.
+	if (!this.abilitiesTemplate[ability]
+		|| this.chargingAbilities[ability]
+		|| this.readyAbilities.indexOf(ability) != -1
+		|| this.activatedAbilities[ability]
+		|| this.coolingdownAbilities[ability])
+		return false;
+
+	if (this.GetPreventedAbilities().indexOf(ability) != -1)
+		return false;
+
+	for (let effect of this.abilitiesTemplate[ability].effects)
+	{
+		if (!AbilityEffects.Validate(this.entity, effect, this.abilitiesTemplate[ability], sendMessages))
+			return false;
+	}
+	return true;
+}
+
+Abilities.prototype.StartChargingAbility = function(ability)
+{
+	if (!this.abilitiesTemplate[ability] || this.chargingAbilities[ability] || this.readyAbilities.indexOf(ability) != -1 || this.activatedAbilities[ability])
+		return;
+
+	if (!this.CanChargeAbility(ability, false))
+		return false;
+
+	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+
+	if (!cmpPlayer.TrySubtractResources(this.GetResourceCosts(ability)))
+		return false;
+
+	this.chargingAbilities[ability] = {"timer": null, "progress": 0};
+
+	// abilities may need to do some prep work when the charging starts (change entity limits…)
+	this.abilitiesTemplate[ability].effects.forEach(effect => AbilityEffects.OnStartCharging(this.entity, effect, this.abilitiesTemplate[ability]));
+
+	if (this.GetChargingTime(ability) !== 0)
+	{
+		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+		this.chargingAbilities[ability].timer = cmpTimer.SetInterval(this.entity, IID_Abilities, "ChargeProgress", 0, ABILITIES_PROGRESS_INTERVAL, { "ability": ability });
+	}
+	else
+		this.ChargeProgress({"ability": ability});
+}
+
+// handles equally charging, ready, and fired abilities.
+Abilities.prototype.CancelAbility = function(ability)
+{
+	if (!this.abilitiesTemplate[ability])
+		return;
+
+	// TODO? this assumes a single ability is either charging, ready, or fired.
+	this.CancelChargingAbility(ability);
+	this.CancelActiveAbility(ability);
+	this.CancelReadyAbility(ability);
+}
+
+Abilities.prototype.CancelChargingAbility = function(ability)
+{
+	if (!this.abilitiesTemplate[ability] || !this.chargingAbilities[ability])
+		return;
+
+	// TODO: this should be parameterized and we should save the actual cost, as this returns possibly tech-modified costs.
+	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+	if (cmpPlayer)
+		cmpPlayer.AddResources(this.GetResourceCosts(ability));
+
+	this.abilitiesTemplate[ability].effects.forEach(effect => AbilityEffects.OnCancelCharging(this.entity, effect, this.abilitiesTemplate[ability]));
+
+	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	cmpTimer.CancelTimer(this.chargingAbilities[ability].timer);
+
+	delete this.chargingAbilities[ability];
+}
+
+Abilities.prototype.CancelReadyAbility = function(ability)
+{
+	if (!this.abilitiesTemplate[ability] || this.readyAbilities.indexOf(ability) == -1)
+		return;
+
+	// don't give resources back.
+
+	this.abilitiesTemplate[ability].effects.forEach(effect => AbilityEffects.OnCancelCharging(this.entity, effect, this.abilitiesTemplate[ability]));
+
+	this.readyAbilities.splice(this.readyAbilities.indexOf(ability), 1);
+}
+
+Abilities.prototype.CancelActiveAbility = function(ability)
+{
+	if (!this.abilitiesTemplate[ability] || !this.activatedAbilities[ability])
+		return;
+
+	// don't give resources back.
+
+	this.activatedAbilities[ability].effects.forEach(effect => AbilityEffects.OnFinished(this.entity, effect.effect, this.abilitiesTemplate[ability], effect.data));
+
+	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	cmpTimer.CancelTimer(this.activatedAbilities[ability].timer);
+
+	delete this.activatedAbilities[ability];
+}
+
+Abilities.prototype.GetChargingProgress = function(ability)
+{
+	if (!this.abilitiesTemplate[ability] || !this.chargingAbilities[ability])
+		return;
+
+	// return 2 instead of 1 to ensure we are above 1, floating point wise.
+	return this.GetChargingTime(ability) == 0 ? 2 : Math.min(this.chargingAbilities[ability].progress / 1000.0 / this.GetChargingTime(ability), 1.0);
+};
+
+Abilities.prototype.ChargeProgress = function(data, lateness)
+{
+	let ability = data.ability;
+
+	if (!this.abilitiesTemplate[ability] || !this.chargingAbilities[ability])
+		return;
+
+	this.chargingAbilities[ability].progress += ABILITIES_PROGRESS_INTERVAL + lateness;
+
+	if (this.GetChargingProgress(ability) < 1.0)
+		return;
+
+	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	cmpTimer.CancelTimer(this.chargingAbilities[ability].timer);
+
+	// TODO: inform GUI that our ability is ready.
+	// TODO: call a custom function of the ability, should they want to do something here
+	// TODO: possibly play a sound.
+	this.readyAbilities.push(ability);
+	delete this.chargingAbilities[ability];
+
+	this.FireAbility(ability);
+};
+
+Abilities.prototype.GetCooldownProgress = function(ability)
+{
+	if (!this.abilitiesTemplate[ability] || !this.coolingdownAbilities[ability])
+		return;
+
+	// return 2 instead of 1 to ensure we are above 1, floating point wise.
+	return this.GetCooldownTime(ability) == 0 ? 2 : Math.min(this.coolingdownAbilities[ability].progress / 1000.0 / this.GetCooldownTime(ability), 1.0);
+};
+
+Abilities.prototype.CooldownProgress = function(data, lateness)
+{
+	let ability = data.ability;
+
+	if (!this.abilitiesTemplate[ability] || !this.coolingdownAbilities[ability])
+		return;
+
+	this.coolingdownAbilities[ability].progress += ABILITIES_PROGRESS_INTERVAL + lateness;
+
+	if (this.GetCooldownProgress(ability) < 1.0)
+		return;
+
+	// TODO: inform GUI that our ability is available
+	// TODO: call a custom function of the ability, should they want to do something here
+	// TODO: possibly play a sound.
+
+	this.CleanupCooldown(ability);
+};
+
+Abilities.prototype.CleanupCooldown = function(ability)
+{
+	if (!this.abilitiesTemplate[ability] || !this.coolingdownAbilities[ability])
+		return;
+
+	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	cmpTimer.CancelTimer(this.coolingdownAbilities[ability].timer);
+
+	delete this.coolingdownAbilities[ability];
+}
+
+Abilities.prototype.FireAbility = function(ability, data, force)
+{
+	if (!this.abilitiesTemplate[ability] || (!force && this.readyAbilities.indexOf(ability) == -1))
+		return;
+
+	// save custom data for each effect
+	let effects = this.abilitiesTemplate[ability].effects.slice();
+	effects = effects.map(effect => { return {"effect": effect, "data": AbilityEffects.OnFire(this.entity, effect, this.abilitiesTemplate[ability], data)}; });
+	this.activatedAbilities[ability] = {"timer": null, "effects": effects};
+	
+	if (this.readyAbilities.indexOf(ability) != -1)
+		this.readyAbilities.splice(this.readyAbilities.indexOf(ability), 1);
+
+	// TODO inform GUI?
+	// TODO play a sound? Or let the ability do that?
+
+	// deactivate incompatible abilities
+	if (this.abilitiesTemplate[ability].IncompatibleAbilities)
+		for (let ability of this.abilitiesTemplate[ability].IncompatibleAbilities)
+			this.CancelAbility(ability);
+
+	// check if we should consider this ability as done.
+	this.HasAbilityFinished({"ability": ability});
+
+	if (this.activatedAbilities[ability])
+	{
+		// if here, the ability will go on to live for some time, check regularly.
+		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+		this.activatedAbilities[ability].timer = cmpTimer.SetInterval(this.entity, IID_Abilities, "HasAbilityFinished", 1000, LIVE_ABILITY_UPDATE_INTERVAL, { "ability": ability });
+	}
+};
+
+Abilities.prototype.HasAbilityFinished = function(data)
+{
+	let ability = data.ability;
+	let finished = this.activatedAbilities[ability].effects.slice().map(effect => { return AbilityEffects.IsFinished(this.entity, effect.effect, this.abilitiesTemplate[ability], effect.data);});
+	if (finished.some(value => {return !value;}))
+		return;
+
+	this.activatedAbilities[ability].effects.forEach(effect => AbilityEffects.OnFinished(this.entity, effect.effect, this.abilitiesTemplate[ability], effect.data));
+
+	// we're done.
+	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	cmpTimer.CancelTimer(this.activatedAbilities[ability].timer);
+
+	delete this.activatedAbilities[ability];
+
+	// cooldown if necessary
+	if (this.GetCooldownTime(ability) == 0)
+		return;
+
+	this.coolingdownAbilities[ability] = {"timer": null, "progress": 0};
+	this.coolingdownAbilities[ability].timer = cmpTimer.SetInterval(this.entity, IID_Abilities, "CooldownProgress", 0, ABILITIES_PROGRESS_INTERVAL, { "ability": ability });
+}
+
+
+Engine.RegisterComponentType(IID_Abilities, "Abilities", Abilities);
Index: binaries/data/mods/public/simulation/components/Gate.js
===================================================================
--- binaries/data/mods/public/simulation/components/Gate.js
+++ binaries/data/mods/public/simulation/components/Gate.js
@@ -25,6 +25,9 @@
 	{
 		this.SetupRangeQuery(msg.to);
 		// Set the initial state, but don't play unlocking sound
+		let cmpAbilities = Engine.QueryInterface(this.entity, IID_Abilities);
+		if (cmpAbilities)
+			cmpAbilities.FireAbility(this.locked ? "Lock" : "Unlock", {"quiet": true}, true);
 		if (!this.locked)
 			this.UnlockGate(true);
 	}
Index: binaries/data/mods/public/simulation/components/GuiInterface.js
===================================================================
--- binaries/data/mods/public/simulation/components/GuiInterface.js
+++ binaries/data/mods/public/simulation/components/GuiInterface.js
@@ -249,7 +249,7 @@
 		"market": null,
 		"mirage": null,
 		"pack": null,
-		"upgrade" : null,
+		"abilities" : null,
 		"player": -1,
 		"position": null,
 		"production": null,
@@ -316,13 +316,9 @@
 			"progress": cmpPack.GetProgress(),
 		};
 
-	var cmpUpgrade = Engine.QueryInterface(ent, IID_Upgrade);
-	if (cmpUpgrade)
-		ret.upgrade = {
-			"upgrades" : cmpUpgrade.GetUpgrades(),
-			"progress": cmpUpgrade.GetProgress(),
-			"template": cmpUpgrade.GetUpgradingTo()
-		};
+	var cmpAbilities = Engine.QueryInterface(ent, IID_Abilities);
+	if (cmpAbilities)
+		ret.abilities = cmpAbilities.GetAbilitiesData();
 
 	let cmpProductionQueue = Engine.QueryInterface(ent, IID_ProductionQueue);
 	if (cmpProductionQueue)
Index: binaries/data/mods/public/simulation/components/TechnologyManager.js
===================================================================
--- binaries/data/mods/public/simulation/components/TechnologyManager.js
+++ binaries/data/mods/public/simulation/components/TechnologyManager.js
@@ -267,6 +267,16 @@
 
 	var modifiedComponents = {};
 	this.researchedTechs[tech] = template;
+
+	let cmpAbilities = Engine.QueryInterface(this.entity, IID_Abilities);
+	if (cmpAbilities && template.abilities)
+	{
+		// Give the player the ability, force-fire it, remove the ability.
+		cmpAbilities.AddAbility("tech_" + tech, template.abilities);
+		cmpAbilities.FireAbility("tech_" + tech, {}, true);
+		cmpAbilities.RemoveAbility("tech_" + tech);
+	}
+
 	// store the modifications in an easy to access structure
 	if (template.modifications)
 	{
Index: binaries/data/mods/public/simulation/components/Upgrade.js
===================================================================
--- binaries/data/mods/public/simulation/components/Upgrade.js
+++ /dev/null
@@ -1,319 +0,0 @@
-function Upgrade() {}
-
-const UPGRADING_PROGRESS_INTERVAL = 250;
-
-Upgrade.prototype.Schema =
-	"<oneOrMore>" +
-		"<element>" +
-			"<anyName />" +
-			"<interleave>" +
-				"<element name='Entity' a:help='Entity to upgrade to'>" +
-					"<text/>" +
-				"</element>" +
-				"<optional>" +
-					"<element name='Icon' a:help='Icon to show in the GUI'>" +
-						"<text/>" +
-					"</element>" +
-				"</optional>" +
-				"<optional>" +
-					"<element name='Tooltip' a:help='This will be added to the tooltip to help the player choose why to upgrade.'>" +
-						"<text/>" +
-					"</element>" +
-				"</optional>" +
-				"<optional>" +
-					"<element name='Time' a:help='Time required to upgrade this entity, in seconds'>" +
-						"<data type='nonNegativeInteger'/>" +
-					"</element>" +
-				"</optional>" +
-				"<optional>" +
-					"<element name='Cost' a:help='Resource cost to upgrade this unit'>" +
-						"<oneOrMore>" +
-							"<choice>" +
-								Resources.BuildSchema("nonNegativeInteger") +
-							"</choice>" +
-						"</oneOrMore>" +
-					"</element>" +
-				"</optional>" +
-				"<optional>" +
-					"<element name='RequiredTechnology' a:help='Define what technology is required for this upgrade'>" +
-						"<choice>" +
-							"<text/>" +
-							"<empty/>" +
-						"</choice>" +
-					"</element>" +
-				"</optional>" +
-				"<optional>" +
-					"<element name='CheckPlacementRestrictions' a:help='Upgrading will check for placement restrictions (nb:GUI only)'><empty/></element>" +
-				"</optional>" +
-			"</interleave>" +
-		"</element>" +
-	"</oneOrMore>";
-
-Upgrade.prototype.Init = function()
-{
-	this.upgrading = false;
-	this.completed = false;
-	this.elapsedTime = 0;
-	this.timer = undefined;
-	this.expendedResources = {};
-
-	this.upgradeTemplates = {};
-
-	for (let choice in this.template)
-	{
-		let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
-		let name = this.template[choice].Entity;
-		if (cmpIdentity)
-			name = name.replace(/\{civ\}/g, cmpIdentity.GetCiv());
-		if (this.upgradeTemplates.name)
-			warn("Upgrade Component: entity " + this.entity + " has two upgrades to the same entity, only the last will be used.");
-		this.upgradeTemplates[name] = choice;
-	}
-};
-
-// This will also deal with the "OnDestroy" case.
-Upgrade.prototype.OnOwnershipChanged = function(msg)
-{
-	if (!this.completed)
-		this.CancelUpgrade(msg.from);
-	if (msg.to !== -1)
-		this.owner = msg.to;
-};
-
-Upgrade.prototype.ChangeUpgradedEntityCount = function(amount)
-{
-	if (!this.IsUpgrading())
-		return;
-
-	let cmpTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
-	let template = cmpTempMan.GetTemplate(this.upgrading);
-
-	let categoryTo;
-	if (template.TrainingRestrictions)
-		categoryTo = template.TrainingRestrictions.Category;
-	else if (template.BuildRestrictions)
-		categoryTo = template.BuildRestrictions.Category;
-
-	if (!categoryTo)
-		return;
-
-	let categoryFrom;
-	let cmpTrainingRestrictions = Engine.QueryInterface(this.entity, IID_TrainingRestrictions);
-	let cmpBuildRestrictions = Engine.QueryInterface(this.entity, IID_BuildRestrictions);
-	if (cmpTrainingRestrictions)
-		categoryFrom = cmpTrainingRestrictions.GetCategory();
-	else if (cmpBuildRestrictions)
-		categoryFrom = cmpBuildRestrictions.GetCategory();
-	
-	if (categoryTo == categoryFrom)
-		return;
-
-	let cmpEntityLimits = QueryPlayerIDInterface(this.owner, IID_EntityLimits);
-	cmpEntityLimits.ChangeCount(categoryTo, amount);
-};
-
-Upgrade.prototype.CanUpgradeTo = function(template)
-{
-	return this.upgradeTemplates[template] !== undefined;
-};
-
-Upgrade.prototype.GetUpgrades = function()
-{
-	let ret = [];
-
-	let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
-
-	for (let option in this.template)
-	{
-		let choice = this.template[option];
-		let templateName = cmpIdentity ? choice.Entity.replace(/\{civ\}/g, cmpIdentity.GetCiv()) : choice.Entity
-
-		let cost = {};
-		if (choice.Cost)
-			cost = this.GetResourceCosts(templateName);
-		if (choice.Time)
-			cost.time = this.GetUpgradeTime(templateName);
-
-		let hasCost = choice.Cost || choice.Time;
-		ret.push({
-			"entity": templateName,
-			"icon": choice.Icon || undefined,
-			"cost": hasCost ? cost : undefined,
-			"tooltip": choice.Tooltip || undefined,
-			"requiredTechnology": this.GetRequiredTechnology(option),
-		});
-	}
-
-	return ret;
-};
-
-Upgrade.prototype.CancelTimer = function()
-{
-	if (!this.timer)
-		return;
-
-	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-	cmpTimer.CancelTimer(this.timer);
-	this.timer = undefined;
-};
-
-Upgrade.prototype.IsUpgrading = function()
-{
-	return !!this.upgrading;
-};
-
-Upgrade.prototype.GetUpgradingTo = function()
-{
-	return this.upgrading;
-};
-
-Upgrade.prototype.WillCheckPlacementRestrictions = function(template)
-{
-	if (!this.upgradeTemplates[template])
-		return undefined;
-
-	// is undefined by default so use X in Y
-	return "CheckPlacementRestrictions" in this.template[this.upgradeTemplates[template]];
-};
-
-Upgrade.prototype.GetRequiredTechnology = function(templateArg)
-{
-	let choice = this.upgradeTemplates[templateArg] || templateArg;
-
-	if (this.template[choice].RequiredTechnology)
-		return this.template[choice].RequiredTechnology;
-
-	if (!("RequiredTechnology" in this.template[choice]))
-		return undefined;
-
-	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
-	let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
-
-	let entType = this.template[choice].Entity;
-	if (cmpIdentity)
-		entType = entType.replace(/\{civ\}/g, cmpIdentity.GetCiv());
-
-	let template = cmpTemplateManager.GetTemplate(entType);
-	return template.Identity.RequiredTechnology || undefined;
-};
-
-Upgrade.prototype.GetResourceCosts = function(template)
-{
-	if (!this.upgradeTemplates[template])
-		return undefined;
-
-	if (this.IsUpgrading() && template == this.GetUpgradingTo())
-		return clone(this.expendedResources);
-
-	let choice = this.upgradeTemplates[template];
-	if (!this.template[choice].Cost)
-		return {};
-
-	let costs = {};
-	for (let r in this.template[choice].Cost)
-		costs[r] = ApplyValueModificationsToEntity("Upgrade/Cost/"+r, +this.template[choice].Cost[r], this.entity);
-
-	return costs;
-};
-
-Upgrade.prototype.Upgrade = function(template)
-{
-	if (this.IsUpgrading() || !this.upgradeTemplates[template])
-		return false;
-
-	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
-
-	this.expendedResources = this.GetResourceCosts(template);
-	if (!cmpPlayer.TrySubtractResources(this.expendedResources))
-	{
-		this.expendedResources = {};
-		return false;
-	}
-
-	this.upgrading = template;
-
-	// Prevent cheating
-	this.ChangeUpgradedEntityCount(1);
-
-	if (this.GetUpgradeTime(template) !== 0)
-	{
-		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-		this.timer = cmpTimer.SetInterval(this.entity, IID_Upgrade, "UpgradeProgress", 0, UPGRADING_PROGRESS_INTERVAL, { "upgrading": template });
-	}
-	else
-		this.UpgradeProgress();
-
-	return true;
-};
-
-Upgrade.prototype.CancelUpgrade = function(owner)
-{
-	if (!this.IsUpgrading())
-		return;
-
-	let cmpPlayer = QueryPlayerIDInterface(owner, IID_Player);
-	if (cmpPlayer)
-		cmpPlayer.AddResources(this.expendedResources);
-
-	this.expendedResources = {};
-	this.ChangeUpgradedEntityCount(-1);
-
-	this.upgrading = false;
-	this.CancelTimer();
-	this.SetElapsedTime(0);
-};
-
-Upgrade.prototype.GetUpgradeTime = function(templateArg)
-{
-	let template = this.upgrading || templateArg;
-	let choice = this.upgradeTemplates[template];
-
-	if (!choice)
-		return undefined;
-
-	if (!this.template[choice].Time)
-		return 0;
-
-	let cmpPlayer = QueryPlayerIDInterface(this.owner, IID_Player);
-	return ApplyValueModificationsToEntity("Upgrade/Time", +this.template[choice].Time, this.entity) *
-		cmpPlayer.GetCheatTimeMultiplier();
-};
-
-Upgrade.prototype.GetElapsedTime = function()
-{
-	return this.elapsedTime;
-};
-
-Upgrade.prototype.GetProgress = function()
-{
-	if (!this.IsUpgrading())
-		return undefined;
-	return this.GetUpgradeTime() == 0 ? 1 : Math.min(this.elapsedTime / 1000.0 / this.GetUpgradeTime(), 1.0);
-};
-
-Upgrade.prototype.SetElapsedTime = function(time)
-{
-	this.elapsedTime = time;
-};
-
-Upgrade.prototype.UpgradeProgress = function(data, lateness)
-{
-	if (this.elapsedTime/1000.0 < this.GetUpgradeTime())
-	{
-		this.SetElapsedTime(this.GetElapsedTime() + UPGRADING_PROGRESS_INTERVAL + lateness);
-		return;
-	}
-
-	this.CancelTimer();
-
-	this.completed = true;
-	this.ChangeUpgradedEntityCount(-1);
-	this.expendedResources = {};
-
-	let newEntity = ChangeEntityTemplate(this.entity, this.upgrading);
-
-	if (newEntity)
-		PlaySound("upgraded", newEntity);
-};
-
-Engine.RegisterComponentType(IID_Upgrade, "Upgrade", Upgrade);
Index: binaries/data/mods/public/simulation/components/interfaces/Abilities.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/components/interfaces/Abilities.js
@@ -0,0 +1 @@
+Engine.RegisterInterface("Abilities");
Index: binaries/data/mods/public/simulation/components/interfaces/Upgrade.js
===================================================================
--- binaries/data/mods/public/simulation/components/interfaces/Upgrade.js
+++ /dev/null
@@ -1 +0,0 @@
-Engine.RegisterInterface("Upgrade");
Index: binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js
===================================================================
--- binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js
+++ binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js
@@ -1,4 +1,5 @@
 Engine.LoadHelperScript("Player.js");
+Engine.LoadComponentScript("interfaces/Abilities.js");
 Engine.LoadComponentScript("interfaces/Attack.js");
 Engine.LoadComponentScript("interfaces/AlertRaiser.js");
 Engine.LoadComponentScript("interfaces/Auras.js");
@@ -31,7 +32,6 @@
 Engine.LoadComponentScript("interfaces/Timer.js");
 Engine.LoadComponentScript("interfaces/StatisticsTracker.js");
 Engine.LoadComponentScript("interfaces/UnitAI.js");
-Engine.LoadComponentScript("interfaces/Upgrade.js");
 Engine.LoadComponentScript("interfaces/BuildingAI.js");
 Engine.LoadComponentScript("GuiInterface.js");
 
@@ -593,7 +593,7 @@
 	market: null,
 	mirage: null,
 	pack: null,
-	upgrade: null,
+	abilities: null,
 	player: -1,
 	position: {x:1, y:2, z:3},
 	production: null,
Index: binaries/data/mods/public/simulation/data/abilities/DealDamage.json
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/DealDamage.json
@@ -0,0 +1,3 @@
+{
+	"script": "DealDamage.js"
+}
\ No newline at end of file
Index: binaries/data/mods/public/simulation/data/abilities/EntityUpgrade.json
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/EntityUpgrade.json
@@ -0,0 +1,3 @@
+{
+	"script": "EntityUpgrade.js"
+}
\ No newline at end of file
Index: binaries/data/mods/public/simulation/data/abilities/Gates.json
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/Gates.json
@@ -0,0 +1,3 @@
+{
+	"script": "Gates.js"
+}
\ No newline at end of file
Index: binaries/data/mods/public/simulation/data/abilities/GlobalUpgrade.json
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/GlobalUpgrade.json
@@ -0,0 +1,3 @@
+{
+	"script": "GlobalUpgrade.js"
+}
\ No newline at end of file
Index: binaries/data/mods/public/simulation/data/abilities/effects/DealDamage.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/effects/DealDamage.js
@@ -0,0 +1,74 @@
+function DealDamage()
+{
+	this.name = "DealDamage";
+
+	this.schema = 
+		"<element name='Damage' a:help='How much damage to deal'>" +
+			"<ref name='nonNegativeDecimal'/>" +
+		"</element>";
+}
+
+DealDamage.prototype.SetupData = function(entity, templateData)
+{
+	return templateData;
+}
+
+// TODO: reintroduce a parameter
+DealDamage.prototype.GetRequiredTechnology = function(entity, templateData)
+{
+}
+
+DealDamage.prototype.GetIcon = function(entity, templateData)
+{
+	return "icons/kill.png";
+}
+
+DealDamage.prototype.GetOverlayIcon = function(entity, templateData)
+{
+}
+
+DealDamage.prototype.GetTooltip = function(entity, templateData)
+{
+	return "This will damage the entity, inflicting it " + templateData.DealDamage.Damage + "HP of damage.";
+}
+
+DealDamage.prototype.OnFire = function(entity, templateData, commandData)
+{
+	let targets = [];
+	// TODO: support other targets
+	targets.push(entity);
+
+	for (let entity of targets)
+	{
+		let cmpHealth = Engine.QueryInterface(entity, IID_Health);
+		if (cmpHealth)
+			cmpHealth.Reduce(templateData.DealDamage.Damage);
+		else
+			Engine.DestroyEntity(ent);
+	}
+}
+
+DealDamage.prototype.OnFinished = function(entity, templateData, commandData)
+{
+}
+
+DealDamage.prototype.IsFinished = function(entity, templateData, commandData)
+{
+	return true;
+}
+
+DealDamage.prototype.OnStartCharging = function(entity, templateData)
+{
+}
+
+DealDamage.prototype.OnCancelCharging = function(entity, templateData)
+{
+}
+
+DealDamage.prototype.Validate = function(entity, templateData, sendMessages)
+{
+	return true;
+}
+
+var DealDamage = new DealDamage();
+AbilityEffects.RegisterEffect(DealDamage);
Index: binaries/data/mods/public/simulation/data/abilities/effects/EntityUpgrade.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/effects/EntityUpgrade.js
@@ -0,0 +1,171 @@
+function EntityUpgrade()
+{
+	this.name = "EntityUpgrade";
+
+	this.schema =
+		"<element name='Template' a:help='Template to upgrade to'>" +
+			"<text/>" +
+		"</element>" +
+		"<optional>" +
+			"<element name='CheckPlacementRestrictions' a:help='Upgrading will check for placement restrictions (nb:GUI only)'><empty/></element>" +
+		"</optional>";
+}
+
+EntityUpgrade.prototype.SetupData = function(entity, templateData)
+{
+	// change a generic {civ} template to a specific one.
+
+	let name = templateData.EntityUpgrade.Template;
+	let cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
+	if (cmpIdentity && cmpIdentity.GetCiv())
+		name = name.replace(/\{civ\}/g, cmpIdentity.GetCiv());
+	else
+	{
+		let cmpPlayer = QueryOwnerInterface(entity, IID_Player);
+		if (cmpPlayer)
+			name = name.replace(/\{civ\}/g, cmpPlayer.GetCiv());
+	}
+	templateData.EntityUpgrade.Template = name;
+
+	return templateData;
+}
+
+// TODO: reintroduce a parameter
+EntityUpgrade.prototype.GetRequiredTechnology = function(entity, templateData)
+{
+	if (!templateData.EntityUpgrade.UseDefaultRequiredTech)
+		return;
+
+	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	let template = cmpTemplateManager.GetTemplate(templateData.EntityUpgrade.Template);
+	return template.Identity.RequiredTechnology || undefined;
+}
+
+EntityUpgrade.prototype.GetIcon = function(entity, templateData)
+{
+	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	let template = cmpTemplateManager.GetTemplate(templateData.EntityUpgrade.Template);
+	
+	return "portraits/" + template.Identity.Icon || undefined;
+}
+
+EntityUpgrade.prototype.GetOverlayIcon = function(entity, templateData)
+{
+	return "icons/upgrade.png";
+}
+
+EntityUpgrade.prototype.GetTooltip = function(entity, templateData)
+{
+	return "TODO: limits";
+}
+
+
+EntityUpgrade.prototype.OnFire = function(entity, templateData, commandData)
+{
+	// TODO: support other targeting modes than "self"
+	let targetEntity = entity;
+	let newEntity = ChangeEntityTemplate(targetEntity, templateData.EntityUpgrade.Template);
+
+	if (newEntity)
+		PlaySound("upgraded", newEntity);
+}
+
+EntityUpgrade.prototype.OnFinished = function(entity, templateData, commandData)
+{
+}
+
+EntityUpgrade.prototype.IsFinished = function(entity, templateData, commandData)
+{
+	return true;
+}
+
+EntityUpgrade.prototype.OnStartCharging = function(entity, templateData)
+{
+	this.ChangeUpgradedEntityCount(entity, templateData.EntityUpgrade.Template, 1);	
+}
+
+EntityUpgrade.prototype.OnCancelCharging = function(entity, templateData)
+{
+	this.ChangeUpgradedEntityCount(entity, templateData.EntityUpgrade.Template, -1);
+}
+
+EntityUpgrade.prototype.Validate = function(entity, templateData, sendMessages)
+{
+	if ("CheckPlacementRestrictions" in templateData.EntityUpgrade && ObstructionsBlockingTemplateChange(entity, templateData.EntityUpgrade.Template))
+	{
+		if (sendMessages)
+		{
+			let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+			cmpGUIInterface.PushNotification({
+				"players": [data.cmpPlayer.GetPlayerID()],
+				"message": markForTranslation("Cannot upgrade as distance requirements are not verified or terrain is obstructed.")
+			});
+		}
+		return false;
+	}
+
+	if (!CanGarrisonedChangeTemplate(entity, templateData.EntityUpgrade.Template))
+	{
+		if (sendMessages)
+		{
+			let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+			cmpGUIInterface.PushNotification({
+				"players": [data.cmpPlayer.GetPlayerID()],
+				"message": markForTranslation("Cannot upgrade a garrisoned entity.")
+			});
+		}
+		return false;
+	}
+
+	// Check entity limits
+	var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	var template = cmpTemplateManager.GetTemplate(templateData.EntityUpgrade.Template);
+	var cmpEntityLimits = QueryOwnerInterface(entity, IID_EntityLimits);
+	if (template.TrainingRestrictions && !cmpEntityLimits.AllowedToTrain(template.TrainingRestrictions.Category, 1) ||
+		template.BuildRestrictions && !cmpEntityLimits.AllowedToBuild(template.BuildRestrictions.Category))
+	{
+		if (sendMessages)
+		{
+			let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+			cmpGUIInterface.PushNotification({
+				"players": [data.cmpPlayer.GetPlayerID()],
+				"message": markForTranslation("Cannot upgrade, entity limits are reached.")
+			});
+		}
+		return false;
+	}
+	return true;
+}
+
+EntityUpgrade.prototype.ChangeUpgradedEntityCount = function(fromEntity, toTemplate, amount)
+{
+	let cmpTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	let template = cmpTempMan.GetTemplate(toTemplate);
+
+	let categoryTo;
+	if (template.TrainingRestrictions)
+		categoryTo = template.TrainingRestrictions.Category;
+	else if (template.BuildRestrictions)
+		categoryTo = template.BuildRestrictions.Category;
+
+	if (!categoryTo)
+		return;
+
+	let categoryFrom;
+	let cmpTrainingRestrictions = Engine.QueryInterface(fromEntity, IID_TrainingRestrictions);
+	let cmpBuildRestrictions = Engine.QueryInterface(fromEntity, IID_BuildRestrictions);
+	if (cmpTrainingRestrictions)
+		categoryFrom = cmpTrainingRestrictions.GetCategory();
+	else if (cmpBuildRestrictions)
+		categoryFrom = cmpBuildRestrictions.GetCategory();
+	
+	if (categoryTo == categoryFrom)
+		return;
+
+	let cmpEntityLimits = QueryOwnerInterface(fromEntity, IID_EntityLimits);
+	cmpEntityLimits.ChangeCount(categoryTo, amount);
+};
+
+
+var EntityUpgrade = new EntityUpgrade();
+AbilityEffects.RegisterEffect(EntityUpgrade);
Index: binaries/data/mods/public/simulation/data/abilities/effects/Gates.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/effects/Gates.js
@@ -0,0 +1,45 @@
+const GATE_ACTIONS = ["lock", "unlock"];
+
+function GateAction(state)
+{
+	this.state = state;
+
+	this.name = "gate-" + GATE_ACTIONS[this.state];
+
+	this.schema = "<empty/>";
+}
+
+GateAction.prototype.GetIcon = function(entity, templateData)
+{
+	return "icons/lock_" + GATE_ACTIONS[this.state] + "ed.png";
+}
+
+GateAction.prototype.GetTooltip = function(entity, templateData)
+{
+}
+
+GateAction.prototype.OnFire = function(entity, templateData, commandData)
+{
+	let cmpGate = Engine.QueryInterface(entity, IID_Gate);
+	if (!cmpGate)
+		return;
+
+	let quiet = false;
+	if (commandData && commandData.quiet)
+		quiet = commandData.quiet;
+
+	if (!this.state)
+		cmpGate.LockGate(quiet);
+	else
+		cmpGate.UnlockGate(quiet);
+}
+
+GateAction.prototype.IsFinished = function(entity, templateData, commandData)
+{
+	return false;
+}
+
+var GateLock = new GateAction(0);
+var GateUnlock = new GateAction(1);
+AbilityEffects.RegisterEffect(GateLock);
+AbilityEffects.RegisterEffect(GateUnlock);
Index: binaries/data/mods/public/simulation/data/abilities/effects/GlobalUpgrade.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/data/abilities/effects/GlobalUpgrade.js
@@ -0,0 +1,173 @@
+function GlobalUpgrade()
+{
+	this.name = "GlobalUpgrade";
+
+	this.schema =
+		"<element name='ToTemplate' a:help='Template to upgrade to'>" +
+			"<text/>" +
+		"</element>" +
+		"<optional>" +
+			"<choice>" +
+				"<element name='FromTemplate' a:help='Template to upgrade'>" +
+					"<text/>" +
+				"</element>" +
+				"<element name='FromClasses' a:help='Upgrade entities that match these classes'>" +
+					"<attribute name='datatype'>" +
+						"<value>tokens</value>" +
+					"</attribute>" +
+					"<text/>" +
+				"</element>" +
+			"</choice>" +
+		"</optional>" +
+		"<optional>" +
+			"<element name='UseDefaultRequiredTech' a:help='The ability will require whatever technology the upgrade unit requires.'><empty/></element>" +
+		"</optional>" +
+		"<optional>" +
+			"<element name='CheckPlacementRestrictions' a:help='Upgrading will check for placement restrictions (nb:GUI only)'><empty/></element>" +
+		"</optional>";
+}
+
+GlobalUpgrade.prototype.SetupData = function(entity, templateData)
+{
+	// change a generic {civ} template to a specific one.
+	let cmpPlayer = Engine.QueryInterface(entity, IID_Player);
+	if (!cmpPlayer)
+		cmpPlayer = QueryOwnerInterface(entity, IID_Player);
+	if (!cmpPlayer)
+		return templateData;
+
+	let name = templateData.GlobalUpgrade.ToTemplate;
+	name = name.replace(/\{civ\}/g, cmpPlayer.GetCiv());
+	templateData.GlobalUpgrade.ToTemplate = name;
+
+	if (templateData.GlobalUpgrade.FromTemplate)
+	{
+		let name = templateData.GlobalUpgrade.FromTemplate;
+		name = name.replace(/\{civ\}/g, cmpPlayer.GetCiv());
+		templateData.GlobalUpgrade.FromTemplate = name;
+	}
+
+	return templateData;
+}
+
+// TODO: reintroduce a parameter
+GlobalUpgrade.prototype.GetRequiredTechnology = function(entity, templateData)
+{
+	if (!templateData.GlobalUpgrade.UseDefaultRequiredTech)
+		return;
+
+	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	let template = cmpTemplateManager.GetTemplate(templateData.GlobalUpgrade.ToTemplate);
+	return template.Identity.RequiredTechnology || undefined;
+}
+
+GlobalUpgrade.prototype.GetIcon = function(entity, templateData)
+{
+	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	let template = cmpTemplateManager.GetTemplate(templateData.GlobalUpgrade.ToTemplate);
+	
+	return "portraits/" + template.Identity.Icon || undefined;
+}
+
+GlobalUpgrade.prototype.GetOverlayIcon = function(entity, templateData)
+{
+	return "icons/upgrade.png";
+}
+
+GlobalUpgrade.prototype.OnFire = function(entity, templateData, commandData)
+{
+	// TODO: support target players?
+	let cmpPlayer = Engine.QueryInterface(entity, IID_Player);
+	if (!cmpPlayer)
+		cmpPlayer = QueryOwnerInterface(entity, IID_Player);
+	if (!cmpPlayer)
+	{
+		warn("Could not find player entity to fire the global upgrade for.");
+		return;
+	}
+	let player = cmpPlayer.GetPlayerID();
+	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+	let entities = cmpRangeManager.GetEntitiesByPlayer(player);
+
+	for (let target of entities)
+	{
+		if (templateData.GlobalUpgrade.FromTemplate)
+		{
+			let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+			let entityTemplateName = cmpTemplateManager.GetCurrentTemplateName(target);
+			let entityTemplate = cmpTemplateManager.GetTemplate(entityTemplateName);
+
+			if (entityTemplate != templateData.GlobalUpgrade.FromTemplate)
+				continue;
+		}
+		else
+		{
+			let cmpIdentity = Engine.QueryInterface(target, IID_Identity);
+			if (!cmpIdentity || !MatchesClassList(cmpIdentity.GetClassesList(), templateData.GlobalUpgrade.FromClasses))
+				continue;
+		}
+
+		if (!this.HiddenValidate(target, templateData, false))
+			continue;
+
+		ChangeEntityTemplate(target, templateData.GlobalUpgrade.ToTemplate);
+	}
+
+	// TODO: sound and notifications?
+}
+
+GlobalUpgrade.prototype.IsFinished = function(entity, templateData, commandData)
+{
+	return true;
+}
+
+GlobalUpgrade.prototype.HiddenValidate = function(entity, templateData, sendMessages)
+{
+	if ("CheckPlacementRestrictions" in templateData.GlobalUpgrade && ObstructionsBlockingTemplateChange(entity, templateData.GlobalUpgrade.ToTemplate))
+	{
+		if (sendMessages)
+		{
+			let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+			cmpGUIInterface.PushNotification({
+				"players": [data.cmpPlayer.GetPlayerID()],
+				"message": markForTranslation("Cannot upgrade as distance requirements are not verified or terrain is obstructed.")
+			});
+		}
+		return false;
+	}
+
+	if (!CanGarrisonedChangeTemplate(entity, templateData.GlobalUpgrade.ToTemplate))
+	{
+		if (sendMessages)
+		{
+			let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+			cmpGUIInterface.PushNotification({
+				"players": [data.cmpPlayer.GetPlayerID()],
+				"message": markForTranslation("Cannot upgrade a garrisoned entity.")
+			});
+		}
+		return false;
+	}
+
+	// Check entity limits
+	var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+	var template = cmpTemplateManager.GetTemplate(templateData.GlobalUpgrade.ToTemplate);
+	var cmpEntityLimits = QueryOwnerInterface(entity, IID_EntityLimits);
+	if (template.TrainingRestrictions && !cmpEntityLimits.AllowedToTrain(template.TrainingRestrictions.Category, 1) ||
+		template.BuildRestrictions && !cmpEntityLimits.AllowedToBuild(template.BuildRestrictions.Category))
+	{
+		if (sendMessages)
+		{
+			let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+			cmpGUIInterface.PushNotification({
+				"players": [data.cmpPlayer.GetPlayerID()],
+				"message": markForTranslation("Cannot upgrade, entity limits are reached.")
+			});
+		}
+		return false;
+	}
+	return true;
+}
+
+var GlobalUpgrade = new GlobalUpgrade();
+AbilityEffects.RegisterEffect(GlobalUpgrade);
Index: binaries/data/mods/public/simulation/helpers/Abilities.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/simulation/helpers/Abilities.js
@@ -0,0 +1,138 @@
+function AbilityEffects()
+{
+	this.effects = new Map();
+}
+
+AbilityEffects.prototype.LoadEffects = function()
+{
+	let files = Engine.FindJSONFiles("abilities", true);
+	
+	for (let file of files)
+	{
+		let data = Engine.ReadJSONFile("abilities/" + file + ".json");
+		if (!data.script)
+		{
+			warn("Effect " + file + " has no defined script");
+			continue;
+		}
+		Engine.LoadDataScript("abilities/effects/" + data.script);
+	}
+}
+
+AbilityEffects.prototype.RegisterEffect = function(effect)
+{
+	this.effects.set(effect.name, effect);
+}
+
+AbilityEffects.prototype.GetEffectNames = function(effect)
+{
+	let names = [];
+	for (let name of this.effects.keys())
+		names.push(name);
+	return names;
+}
+
+AbilityEffects.prototype.BuildSchema = function(effect)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).schema)
+		return "";
+	// wrap it in "EffectName"
+	return "<element name='" + effect + "'>" + this.effects.get(effect).schema + "</element>";
+}
+
+AbilityEffects.prototype.GetIcon = function(entity, effect, templateData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).GetIcon)
+		return undefined;
+
+	return this.effects.get(effect).GetIcon(entity, templateData);
+}
+
+AbilityEffects.prototype.GetOverlayIcon = function(entity, effect, templateData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).GetOverlayIcon)
+		return undefined;
+
+	return this.effects.get(effect).GetOverlayIcon(entity, templateData);
+}
+
+AbilityEffects.prototype.GetTooltip = function(entity, effect, templateData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).GetTooltip)
+		return undefined;
+
+	return this.effects.get(effect).GetTooltip(entity, templateData);
+}
+
+AbilityEffects.prototype.GetRequiredTechnology = function(entity, effect, templateData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).GetRequiredTechnology)
+		return undefined;
+
+	return this.effects.get(effect).GetRequiredTechnology(entity, templateData);
+}
+
+AbilityEffects.prototype.Validate = function(entity, effect, templateData, sendMessages)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).Validate)
+		return true;
+
+	return this.effects.get(effect).Validate(entity, templateData, sendMessages);
+}
+
+AbilityEffects.prototype.SetupData = function(entity, effect, templateData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).SetupData)
+		return templateData;
+
+	return this.effects.get(effect).SetupData(entity, templateData);
+}
+
+AbilityEffects.prototype.OnFire = function(entity, effect, templateData, commandData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).OnFire)
+		return undefined;
+
+	return this.effects.get(effect).OnFire(entity, templateData, commandData);	
+}
+
+AbilityEffects.prototype.OnFinished = function(entity, effect, templateData, commandData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).OnFinished)
+		return undefined;
+
+	return this.effects.get(effect).OnFinished(entity, templateData, commandData);
+}
+
+AbilityEffects.prototype.IsFinished = function(entity, effect, templateData, commandData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).IsFinished)
+		return true;
+
+	return this.effects.get(effect).IsFinished(entity, templateData, commandData);	
+}
+
+AbilityEffects.prototype.OnStartCharging = function(entity, effect, templateData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).OnStartCharging)
+		return undefined;
+
+	return this.effects.get(effect).OnStartCharging(entity, templateData);	
+}
+
+AbilityEffects.prototype.OnCancelCharging = function(entity, effect, templateData)
+{
+	if (!this.effects.has(effect) || !this.effects.get(effect).OnCancelCharging)
+		return undefined;
+
+	return this.effects.get(effect).OnStartCharging(entity, templateData);	
+}
+
+// TODO: validateAbility
+// TODO: checkAbilityAvailable
+
+var g_Effects = new AbilityEffects();
+Engine.RegisterGlobal("AbilityEffects", g_Effects);
+
+// TODO: move this to a JSON script for an additional layer of indirection.
+g_Effects.LoadEffects();
Index: binaries/data/mods/public/simulation/helpers/Commands.js
===================================================================
--- binaries/data/mods/public/simulation/helpers/Commands.js
+++ binaries/data/mods/public/simulation/helpers/Commands.js
@@ -589,21 +589,6 @@
 		}
 	},
 
-	"lock-gate": function(player, cmd, data)
-	{
-		for (let ent of data.entities)
-		{
-			var cmpGate = Engine.QueryInterface(ent, IID_Gate);
-			if (!cmpGate)
-				continue;
-
-			if (cmd.lock)
-				cmpGate.LockGate();
-			else
-				cmpGate.UnlockGate();
-		}
-	},
-
 	"setup-trade-route": function(player, cmd, data)
 	{
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
@@ -667,66 +652,34 @@
 		}
 	},
 
-	"upgrade": function(player, cmd, data)
+	"charge-ability": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
-			var cmpUpgrade = Engine.QueryInterface(ent, IID_Upgrade);
+			let cmpAbilities = Engine.QueryInterface(ent, IID_Abilities);
 
-			if (!cmpUpgrade || !cmpUpgrade.CanUpgradeTo(cmd.template))
+			if (!cmpAbilities || !cmpAbilities.CanChargeAbility(cmd.ability))
 				continue;
 
-			if (cmpUpgrade.WillCheckPlacementRestrictions(cmd.template) && ObstructionsBlockingTemplateChange(ent, cmd.template))
-			{
-				var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
-				cmpGUIInterface.PushNotification({
-					"players": [data.cmpPlayer.GetPlayerID()],
-					"message": markForTranslation("Cannot upgrade as distance requirements are not verified or terrain is obstructed.")
-				});
-				continue;
-			}
-
-			if (!CanGarrisonedChangeTemplate(ent, cmd.template))
-			{
-				var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
-				cmpGUIInterface.PushNotification({
-					"players": [data.cmpPlayer.GetPlayerID()],
-					"message": markForTranslation("Cannot upgrade a garrisoned entity.")
-				});
-				continue;
-			}
-
-			// Check entity limits
-			var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
-			var template = cmpTemplateManager.GetTemplate(cmd.template);
-			var cmpEntityLimits = QueryPlayerIDInterface(player, IID_EntityLimits);
-			if (template.TrainingRestrictions && !cmpEntityLimits.AllowedToTrain(template.TrainingRestrictions.Category, 1) ||
-				template.BuildRestrictions && !cmpEntityLimits.AllowedToBuild(template.BuildRestrictions.Category))
-			{
-				if (g_DebugCommands)
-					warn("Invalid command: build limits check failed for player " + player + ": " + uneval(cmd));
-				continue;
-			}
-
-			var cmpTechnologyManager = QueryOwnerInterface(ent, IID_TechnologyManager);
-			if (cmpUpgrade.GetRequiredTechnology(cmd.template) && !cmpTechnologyManager.IsTechnologyResearched(cmpUpgrade.GetRequiredTechnology(cmd.template)))
+			let cmpTechnologyManager = QueryOwnerInterface(ent, IID_TechnologyManager);
+			if (cmpAbilities.GetRequiredTechnology(cmd.ability) && !cmpTechnologyManager.IsTechnologyResearched(cmpAbilities.GetRequiredTechnology(cmd.ability)))
 			{
 				if (g_DebugCommands)
-					warn("Invalid command: upgrading requires unresearched technology: " + uneval(cmd));
+					warn("Invalid command: Ability requires unresearched technology: " + uneval(cmd));
 				continue;
 			}
 
-			cmpUpgrade.Upgrade(cmd.template, data.cmpPlayer);
+			cmpAbilities.StartChargingAbility(cmd.ability, data.cmpPlayer);
 		}
 	},
 
-	"cancel-upgrade": function(player, cmd, data)
+	"cancel-charge-ability": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
-			let cmpUpgrade = Engine.QueryInterface(ent, IID_Upgrade);
-			if (cmpUpgrade)
-				cmpUpgrade.CancelUpgrade(data.cmpPlayer.playerID);
+			let cmpAbilities = Engine.QueryInterface(ent, IID_Abilities);
+			if (cmpAbilities)
+				cmpAbilities.CancelAbility(cmd.ability);
 		}
 	},
 
Index: binaries/data/mods/public/simulation/templates/gaia/fauna_pig_flaming.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/gaia/fauna_pig_flaming.xml
+++ binaries/data/mods/public/simulation/templates/gaia/fauna_pig_flaming.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="gaia/fauna_pig">
+  <Abilities disable=""/>
   <Decay>
     <DelayTime>10.0</DelayTime>
     <SinkRate>0.05</SinkRate>
@@ -31,7 +32,6 @@
   <UnitMotion>
     <WalkSpeed>10.0</WalkSpeed>
   </UnitMotion>
-  <Upgrade disable=""/>
   <VisualActor>
     <Actor>fauna/pig_flaming.xml</Actor>
   </VisualActor>
Index: binaries/data/mods/public/simulation/templates/other/palisades_rocks_fort.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/other/palisades_rocks_fort.xml
+++ binaries/data/mods/public/simulation/templates/other/palisades_rocks_fort.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_sentry_tower">
+  <Abilities disable=""/>
   <Capturable disable=""/>
   <Identity>
     <Civ>gaia</Civ>
@@ -9,5 +10,4 @@
     <Classes datatype="tokens">Palisade</Classes>
   </Identity>
   <ProductionQueue disable=""/>
-  <Upgrade disable=""/>
 </Entity>
Index: binaries/data/mods/public/simulation/templates/other/palisades_rocks_long.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/other/palisades_rocks_long.xml
+++ binaries/data/mods/public/simulation/templates/other/palisades_rocks_long.xml
@@ -1,5 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_wall_long">
+  <Abilities>
+    <UpgradeGate>
+      <Name>Transform into a gate</Name>
+      <EntityUpgrade><Template>other/palisades_rocks_gate</Template></EntityUpgrade>
+      <Cost>
+        <stone>0</stone>
+        <wood>20</wood>
+      </Cost>
+      <ChargingTime>5</ChargingTime>
+    </UpgradeGate>
+  </Abilities>
   <Armour>
     <Hack>4.0</Hack>
     <Pierce>25.0</Pierce>
@@ -37,16 +48,6 @@
     <HeightOffset>9.0</HeightOffset>
   </StatusBars>
   <TerritoryInfluence disable=""/>
-  <Upgrade>
-    <Gate>
-      <Entity>other/palisades_rocks_gate</Entity>
-      <Cost>
-        <stone>0</stone>
-        <wood>20</wood>
-      </Cost>
-      <Time>5</Time>
-    </Gate>
-  </Upgrade>
   <VisualActor>
     <Actor>props/special/palisade_rocks_long.xml</Actor>
     <FoundationActor>structures/fndn_1x3pal.xml</FoundationActor>
Index: binaries/data/mods/public/simulation/templates/special/player.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/special/player.xml
+++ binaries/data/mods/public/simulation/templates/special/player.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity>
+  <Abilities/>
   <AttackDetection>
     <SuppressionTransferRange>80</SuppressionTransferRange>
     <SuppressionRange>160</SuppressionRange>
Index: binaries/data/mods/public/simulation/templates/structures/cart_s_wall_long.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/structures/cart_s_wall_long.xml
+++ binaries/data/mods/public/simulation/templates/structures/cart_s_wall_long.xml
@@ -1,21 +1,23 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="other/palisades_rocks_long">
+  <Abilities>
+    <UpgradeGate>
+      <EntityUpgrade>
+        <Template>structures/cart_s_wall_gate</Template>
+      </EntityUpgrade>
+      <Cost>
+        <stone>0</stone>
+        <wood>20</wood>
+      </Cost>
+      <ChargingTime>5</ChargingTime>
+    </UpgradeGate>
+  </Abilities>
   <Identity>
     <Civ>cart</Civ>
     <SelectionGroupName>structures/cart_wallset_short</SelectionGroupName>
     <SpecificName>Low Wall</SpecificName>
     <GenericName>Stone Wall</GenericName>
   </Identity>
-  <Upgrade>
-    <Gate>
-      <Entity>structures/cart_s_wall_gate</Entity>
-      <Cost>
-        <stone>0</stone>
-        <wood>20</wood>
-      </Cost>
-      <Time>5</Time>
-    </Gate>
-  </Upgrade>
   <VisualActor>
     <Actor>structures/carthaginians/short_wall_long.xml</Actor>
     <FoundationActor>structures/fndn_1x3pal.xml</FoundationActor>
Index: binaries/data/mods/public/simulation/templates/structures/gaul_civil_centre.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/structures/gaul_civil_centre.xml
+++ binaries/data/mods/public/simulation/templates/structures/gaul_civil_centre.xml
@@ -1,5 +1,28 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_civic_civil_centre">
+  <Abilities>
+    <UpgradeToBritCenter>
+      <Name>Upgrade to round CC</Name>
+      <Cost>
+        <food>20</food>
+      </Cost>
+      <ChargingTime>30</ChargingTime>
+      <Tooltip>Upgrade to a Round CC</Tooltip>
+      <EntityUpgrade>
+        <Template>structures/brit_civil_centre</Template>
+      </EntityUpgrade>
+    </UpgradeToBritCenter>
+    <InflictDamage>
+      <Name>Inflict Damage</Name>
+      <ChargingTime>5</ChargingTime>
+      <CooldownTime>10</CooldownTime>
+      <PreventAbilities datatype="tokens">UpgradeToBritCenter</PreventAbilities>
+      <Tooltip>This will inflict 100 damage to the civil centre.</Tooltip>
+      <DealDamage>
+        <Damage>100</Damage>
+      </DealDamage>
+    </InflictDamage>
+  </Abilities>
   <Footprint>
     <Square width="28.0" depth="28.0"/>
     <Height>8.0</Height>
Index: binaries/data/mods/public/simulation/templates/structures/iber_sentry_tower.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/structures/iber_sentry_tower.xml
+++ binaries/data/mods/public/simulation/templates/structures/iber_sentry_tower.xml
@@ -1,16 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_sentry_tower">
-  <Identity>
-    <Civ>iber</Civ>
-  </Identity>
-  <Upgrade>
-    <Tower>
+  <Abilities>
+    <UpgradeTower>
       <Cost>
         <stone>250</stone>
       </Cost>
       <Time>120</Time>
-    </Tower>
-  </Upgrade>
+    </UpgradeTower>
+  </Abilities>
+  <Identity>
+    <Civ>iber</Civ>
+  </Identity>
   <VisualActor>
     <Actor>structures/iberians/wooden_tower.xml</Actor>
   </VisualActor>
Index: binaries/data/mods/public/simulation/templates/structures/maur_wall_long.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/structures/maur_wall_long.xml
+++ binaries/data/mods/public/simulation/templates/structures/maur_wall_long.xml
@@ -1,5 +1,13 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_wall_long">
+  <Abilities>
+    <UpgradeToGate>
+      <Cost>
+        <wood>60</wood>
+        <stone>0</stone>
+      </Cost>
+    </UpgradeToGate>
+  </Abilities>
   <Cost>
     <Resources>
       <stone>0</stone>
@@ -38,14 +46,6 @@
   <Obstruction>
     <Static width="35.0" depth="7.5"/>
   </Obstruction>
-  <Upgrade>
-    <Gate>
-      <Cost>
-        <wood>60</wood>
-        <stone>0</stone>
-      </Cost>
-    </Gate>
-  </Upgrade>
   <VisualActor>
     <Actor>structures/mauryans/wall_long.xml</Actor>
   </VisualActor>
Index: binaries/data/mods/public/simulation/templates/structures/rome_siege_wall_long.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/structures/rome_siege_wall_long.xml
+++ binaries/data/mods/public/simulation/templates/structures/rome_siege_wall_long.xml
@@ -1,5 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_wall_long">
+  <Abilities>
+    <UpgradeGate>
+      <Name>Transform into a Gate</Name>
+      <EntityUpgrade><Template>structures/rome_siege_wall_gate</Template></EntityUpgrade>
+      <Cost>
+        <wood>80</wood>
+        <stone>0</stone>
+      </Cost>
+    </UpgradeGate>
+  </Abilities>
   <Armour>
     <Hack>15.0</Hack>
     <Pierce>35.0</Pierce>
@@ -62,15 +72,6 @@
     <DecayRate>1</DecayRate>
   </TerritoryDecay>
   <TerritoryInfluence disable=""/>
-  <Upgrade>
-    <Gate>
-      <Entity>structures/rome_siege_wall_gate</Entity>
-      <Cost>
-        <wood>80</wood>
-        <stone>0</stone>
-      </Cost>
-    </Gate>
-  </Upgrade>
   <VisualActor>
     <Actor>structures/romans/siege_wall_long.xml</Actor>
   </VisualActor>
Index: binaries/data/mods/public/simulation/templates/template_structure_defense_sentry_tower.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/template_structure_defense_sentry_tower.xml
+++ binaries/data/mods/public/simulation/templates/template_structure_defense_sentry_tower.xml
@@ -1,5 +1,18 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_defense_tower">
+  <Abilities>
+    <UpgradeTower>
+      <Name>Upgrade to Defense Tower</Name>
+      <EntityUpgrade><Template>structures/{civ}_defense_tower</Template></EntityUpgrade>
+      <Tooltip>Reinforce with stone and upgrade to a defense tower.</Tooltip>
+      <RequiredTechnology>phase_town</RequiredTechnology>
+      <Cost>
+        <wood>50</wood>
+        <stone>100</stone>
+      </Cost>
+      <ChargingTime>100</ChargingTime>
+    </UpgradeTower>
+  </Abilities>
   <Armour>
     <Hack op="add">-5.0</Hack>
     <Pierce op="add">-5.0</Pierce>
@@ -63,18 +76,6 @@
   <TerritoryInfluence>
     <Radius op="mul">0.5</Radius>
   </TerritoryInfluence>
-  <Upgrade>
-    <Tower>
-      <Entity>structures/{civ}_defense_tower</Entity>
-      <Tooltip>Reinforce with stone and upgrade to a defense tower.</Tooltip>
-      <RequiredTechnology>phase_town</RequiredTechnology>
-      <Cost>
-        <wood>50</wood>
-        <stone>100</stone>
-      </Cost>
-      <Time>100</Time>
-    </Tower>
-  </Upgrade>
   <VisualActor>
     <Actor>props/special/palisade_rocks_fort.xml</Actor>
   </VisualActor>
Index: binaries/data/mods/public/simulation/templates/template_structure_defense_wall_gate.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/template_structure_defense_wall_gate.xml
+++ binaries/data/mods/public/simulation/templates/template_structure_defense_wall_gate.xml
@@ -1,5 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_wall_long">
+  <Abilities replace="">
+    <Lock>
+      <Name>Lock Gate</Name>
+      <gate-lock/>
+      <IncompatibleAbilities datatype="tokens">Unlock</IncompatibleAbilities>
+    </Lock>
+    <Unlock>
+      <Name>Unlock Gate</Name>
+      <gate-unlock/>
+      <IncompatibleAbilities datatype="tokens">Lock</IncompatibleAbilities>
+    </Unlock>
+  </Abilities>
   <Auras disable=""/>
   <GarrisonHolder disable=""/>
   <Gate>
@@ -31,7 +43,6 @@
       <gate_unlocked>interface/select/building/sel_gate.xml</gate_unlocked>
     </SoundGroups>
   </Sound>
-  <Upgrade disable=""/>
   <VisualActor>
     <FoundationActor>structures/fndn_wall_long.xml</FoundationActor>
   </VisualActor>
Index: binaries/data/mods/public/simulation/templates/template_structure_defense_wall_long.xml
===================================================================
--- binaries/data/mods/public/simulation/templates/template_structure_defense_wall_long.xml
+++ binaries/data/mods/public/simulation/templates/template_structure_defense_wall_long.xml
@@ -1,5 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure_defense_wall">
+  <Abilities>
+    <UpgradeGate>
+      <Name>Transform into a Gate</Name>
+      <EntityUpgrade><Template>structures/{civ}_wall_gate</Template></EntityUpgrade>
+      <Tooltip>This will allow you to let units circulate through your fortifications.</Tooltip>
+      <Cost>
+        <stone>60</stone>
+      </Cost>
+      <ChargingTime>10</ChargingTime>
+    </UpgradeGate>
+  </Abilities>
   <Auras datatype="tokens">wall_garrisoned</Auras>
   <Cost>
     <BuildTime>45</BuildTime>
@@ -39,16 +50,6 @@
     <Classes datatype="tokens">LongWall</Classes>
     <Tooltip>Long wall segments can be converted to gates.</Tooltip>
   </Identity>
-  <Upgrade>
-    <Gate>
-      <Entity>structures/{civ}_wall_gate</Entity>
-      <Tooltip>This will allow you to let units circulate through your fortifications.</Tooltip>
-      <Cost>
-        <stone>60</stone>
-      </Cost>
-      <Time>10</Time>
-    </Gate>
-  </Upgrade>
   <VisualActor>
     <FoundationActor>structures/fndn_wall_long.xml</FoundationActor>
   </VisualActor>
Index: source/simulation2/system/ComponentManager.h
===================================================================
--- source/simulation2/system/ComponentManager.h
+++ source/simulation2/system/ComponentManager.h
@@ -336,6 +336,7 @@
 	static JS::Value Script_ReadCivJSONFile(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& fileName);
 	static std::vector<std::string> Script_FindJSONFiles(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& subPath, bool recursive);
 	static JS::Value ReadJSONFile(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& filePath, const std::wstring& fileName);
+	static bool Script_LoadDataScript(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& fileName);
 
 	// callback function to handle recursively finding files in a directory
 	static Status FindJSONFilesCallback(const VfsPath&, const CFileInfo&, const uintptr_t);
Index: source/simulation2/system/ComponentManager.cpp
===================================================================
--- source/simulation2/system/ComponentManager.cpp
+++ source/simulation2/system/ComponentManager.cpp
@@ -86,6 +86,7 @@
 		m_ScriptInterface.RegisterFunction<JS::Value, std::wstring, CComponentManager::Script_ReadJSONFile> ("ReadJSONFile");
 		m_ScriptInterface.RegisterFunction<JS::Value, std::wstring, CComponentManager::Script_ReadCivJSONFile> ("ReadCivJSONFile");
 		m_ScriptInterface.RegisterFunction<std::vector<std::string>, std::wstring, bool, CComponentManager::Script_FindJSONFiles> ("FindJSONFiles");
+		m_ScriptInterface.RegisterFunction<bool, std::wstring, CComponentManager::Script_LoadDataScript> ("LoadDataScript");
 	}
 
 	// Define MT_*, IID_* as script globals, and store their names
@@ -134,6 +135,15 @@
 }
 
 
+bool CComponentManager::Script_LoadDataScript(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& fileName)
+{
+	CComponentManager* componentManager = static_cast<CComponentManager*> (pCxPrivate->pCBData);
+
+	VfsPath path = VfsPath("simulation/data") / fileName;
+
+	return componentManager->LoadScript(path, componentManager->m_CurrentlyHotloading);
+}
+
 bool CComponentManager::LoadScript(const VfsPath& filename, bool hotload)
 {
 	m_CurrentlyHotloading = hotload;