Index: ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest_triggers.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest_triggers.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest_triggers.js	(revision 24050)
@@ -1,307 +1,311 @@
 /**
  * If set to true, it will print how many templates would be spawned if the players were not defeated.
  */
 const dryRun = false;
 
 /**
  * If enabled, prints the number of units to the command line output.
  */
 const debugLog = false;
 
 /**
  * Get the number of minutes to pass between spawning new treasures.
  */
 var treasureTime = () => randFloat(3, 5);
 
 /**
  * Get the time in minutes when the first wave of attackers will be spawned.
  */
 var firstWaveTime = () => randFloat(4, 6);
 
 /**
  * Maximum time in minutes between two consecutive waves.
  */
 var maxWaveTime = 4;
 
 /**
  * Get the next attacker wave delay.
  */
 var waveTime = () => randFloat(0.5, 1) * maxWaveTime;
 
 /**
  * Roughly the number of attackers on the first wave.
  */
 var initialAttackers = 5;
 
 /**
  * Increase the number of attackers exponentially, by this percent value per minute.
  */
 var percentPerMinute = 1.05;
 
 /**
  * Greatest amount of attackers that can be spawned.
  */
 var totalAttackerLimit = 200;
 
 /**
  * Least and greatest amount of siege engines per wave.
  */
 var siegeFraction = () => randFloat(0.2, 0.5);
 
 /**
  * Potentially / definitely spawn a gaia hero after this number of minutes.
  */
 var heroTime = () => randFloat(20, 60);
 
 /**
  * The following templates can't be built by any player.
  */
 var disabledTemplates = (civ) => [
 	// Economic structures
 	"structures/" + civ + "_corral",
 	"structures/" + civ + "_farmstead",
 	"structures/" + civ + "_field",
 	"structures/" + civ + "_storehouse",
 	"structures/" + civ + "_rotarymill",
 	"units/maur_support_elephant",
 
 	// Expansions
 	"structures/" + civ + "_civil_centre",
 	"structures/" + civ + "_military_colony",
 
 	// Walls
 	"structures/" + civ + "_wallset_stone",
 	"structures/rome_wallset_siege",
 	"structures/wallset_palisade",
 
 	// Shoreline
 	"structures/" + civ + "_dock",
 	"structures/brit_crannog",
 	"structures/cart_super_dock",
 	"structures/ptol_lighthouse"
 ];
 
 /**
  * Spawn these treasures in regular intervals.
  */
 var treasures = [
 	"gaia/treasure/food_barrel",
 	"gaia/treasure/food_bin",
 	"gaia/treasure/food_crate",
 	"gaia/treasure/food_jars",
 	"gaia/treasure/metal",
 	"gaia/treasure/stone",
 	"gaia/treasure/wood",
 	"gaia/treasure/wood",
 	"gaia/treasure/wood"
 ];
 
 /**
  * An object that maps from civ [f.e. "spart"] to an object
  * that has the keys "champions", "siege" and "heroes",
  * which is an array containing all these templates,
  * trainable from a building or not.
  */
 var attackerUnitTemplates = {};
 
 Trigger.prototype.InitSurvival = function()
 {
 	this.InitStartingUnits();
 	this.LoadAttackerTemplates();
 	this.SetDisableTemplates();
 	this.PlaceTreasures();
 	this.InitializeEnemyWaves();
 };
 
 Trigger.prototype.debugLog = function(txt)
 {
 	if (!debugLog)
 		return;
 
 	print("DEBUG [" + Math.round(TriggerHelper.GetMinutes()) + "]  " + txt + "\n");
 };
 
 Trigger.prototype.LoadAttackerTemplates = function()
 {
 	for (let civ of ["gaia", ...Object.keys(loadCivFiles(false))])
 		attackerUnitTemplates[civ] = {
 			"heroes": TriggerHelper.GetTemplateNamesByClasses("Hero", civ, undefined, true),
 			"champions": TriggerHelper.GetTemplateNamesByClasses("Champion+!Elephant", civ, undefined, true),
 			"siege": TriggerHelper.GetTemplateNamesByClasses("Siege Champion+Elephant", civ, "packed", undefined)
 		};
 
 	this.debugLog("Attacker templates:");
 	this.debugLog(uneval(attackerUnitTemplates));
 };
 
 Trigger.prototype.SetDisableTemplates = function()
 {
 	for (let i = 1; i < TriggerHelper.GetNumberOfPlayers(); ++i)
 	{
 		let cmpPlayer = QueryPlayerIDInterface(i);
 		cmpPlayer.SetDisabledTemplates(disabledTemplates(cmpPlayer.GetCiv()));
 	}
 };
 
 /**
  *  Remember civic centers and make women invincible.
  */
 Trigger.prototype.InitStartingUnits = function()
 {
 	for (let playerID = 1; playerID < TriggerHelper.GetNumberOfPlayers(); ++playerID)
 	{
 		this.playerCivicCenter[playerID] = TriggerHelper.GetPlayerEntitiesByClass(playerID, "CivilCentre")[0];
 		this.treasureFemale[playerID] = TriggerHelper.GetPlayerEntitiesByClass(playerID, "FemaleCitizen")[0];
 		Engine.QueryInterface(this.treasureFemale[playerID], IID_Resistance).SetInvulnerability(true);
 	}
 };
 
 Trigger.prototype.InitializeEnemyWaves = function()
 {
 	let time = firstWaveTime() * 60 * 1000;
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface).AddTimeNotification({
 		"message": markForTranslation("The first wave will start in %(time)s!"),
 		"translateMessage": true
 	}, time);
 	this.DoAfterDelay(time, "StartAnEnemyWave", {});
 };
 
 Trigger.prototype.StartAnEnemyWave = function()
 {
 	let currentMin = TriggerHelper.GetMinutes();
 	let nextWaveTime = waveTime();
 	let civ = pickRandom(Object.keys(attackerUnitTemplates));
 
 	// Determine total attacker count of the current wave.
 	// Exponential increase with time, capped to the limit and fluctuating proportionally with the current wavetime.
 	let totalAttackers = Math.ceil(Math.min(totalAttackerLimit,
 		initialAttackers * Math.pow(percentPerMinute, currentMin) * nextWaveTime / maxWaveTime));
 
 	let siegeRatio = siegeFraction();
 
 	this.debugLog("Spawning " + totalAttackers + " attackers, siege ratio " + siegeRatio.toFixed(2));
 
 	let attackerCount = TriggerHelper.BalancedTemplateComposition(
 		[
 			{
 				"templates": attackerUnitTemplates[civ].heroes,
 				"count": currentMin > heroTime() && attackerUnitTemplates[civ].heroes.length ? 1 : 0
 			},
 			{
 				"templates": attackerUnitTemplates[civ].siege,
 				"frequency": siegeRatio
 			},
 			{
 				"templates": attackerUnitTemplates[civ].champions,
 				"frequency": 1 - siegeRatio
 			}
 		],
 		totalAttackers);
 
 	this.debugLog("Templates: " + uneval(attackerCount));
 
 	// Spawn the templates
 	let spawned = false;
 	for (let point of this.GetTriggerPoints("A"))
 	{
 		if (dryRun)
 		{
 			spawned = true;
 			break;
 		}
 
 		// Don't spawn attackers for defeated players and players that lost their cc after win
-		let playerID = QueryOwnerInterface(point, IID_Player).GetPlayerID();
+		let cmpPlayer = QueryOwnerInterface(point, IID_Player);
+		if (!cmpPlayer)
+			continue;
+
+		let playerID = cmpPlayer.GetPlayerID();
 		let civicCentre = this.playerCivicCenter[playerID];
 		if (!civicCentre)
 			continue;
 
 		// Check if the cc is garrisoned in another building
 		let targetPos = TriggerHelper.GetEntityPosition2D(civicCentre);
 		if (!targetPos)
 			continue;
 
 		for (let templateName in attackerCount)
 		{
 			let isHero = attackerUnitTemplates[civ].heroes.indexOf(templateName) != -1;
 
 			// Don't spawn gaia hero if the previous one is still alive
 			if (this.gaiaHeroes[playerID] && isHero)
 			{
 				let cmpHealth = Engine.QueryInterface(this.gaiaHeroes[playerID], IID_Health);
 				if (cmpHealth && cmpHealth.GetHitpoints() != 0)
 				{
 					this.debugLog("Not spawning hero for player " + playerID + " as the previous one is still alive");
 					continue;
 				}
 			}
 
 			if (dryRun)
 				continue;
 
 			let entities = TriggerHelper.SpawnUnits(point, templateName, attackerCount[templateName], 0);
 
 			ProcessCommand(0, {
 				"type": "attack-walk",
 				"entities": entities,
 				"x": targetPos.x,
 				"z": targetPos.y,
 				"targetClasses": undefined,
 				"allowCapture": false,
 				"queued": true
 			});
 
 			if (isHero)
 				this.gaiaHeroes[playerID] = entities[0];
 		}
 		spawned = true;
 	}
 
 	if (!spawned)
 		return;
 
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface).PushNotification({
 		"message": markForTranslation("An enemy wave is attacking!"),
 		"translateMessage": true
 	});
 
 	this.DoAfterDelay(nextWaveTime * 60 * 1000, "StartAnEnemyWave", {});
 };
 
 Trigger.prototype.PlaceTreasures = function()
 {
 	let triggerPoints = this.GetTriggerPoints(pickRandom(["B", "C", "D"]));
 	for (let point of triggerPoints)
 		TriggerHelper.SpawnUnits(point, pickRandom(treasures), 1, 0);
 
 	this.DoAfterDelay(treasureTime() * 60 * 1000, "PlaceTreasures", {});
 };
 
 Trigger.prototype.OnOwnershipChanged = function(data)
 {
 	if (data.entity == this.playerCivicCenter[data.from])
 	{
 		this.playerCivicCenter[data.from] = undefined;
 
 		TriggerHelper.DefeatPlayer(
 			data.from,
 			markForTranslation("%(player)s has been defeated (lost civic center)."));
 	}
 	else if (data.entity == this.treasureFemale[data.from])
 	{
 		this.treasureFemale[data.from] = undefined;
 		Engine.DestroyEntity(data.entity);
 	}
 };
 
 
 {
 	let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 
 	cmpTrigger.treasureFemale = [];
 	cmpTrigger.playerCivicCenter = [];
 	cmpTrigger.gaiaHeroes = [];
 
 	cmpTrigger.RegisterTrigger("OnInitGame", "InitSurvival", { "enabled": true });
 	cmpTrigger.RegisterTrigger("OnOwnershipChanged", "OnOwnershipChanged", { "enabled": true });
 }
Index: ps/trunk/binaries/data/mods/public/maps/scripts/CaptureTheRelic.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/scripts/CaptureTheRelic.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/maps/scripts/CaptureTheRelic.js	(revision 24050)
@@ -1,190 +1,198 @@
 Trigger.prototype.InitCaptureTheRelic = function()
 {
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let catafalqueTemplates = shuffleArray(cmpTemplateManager.FindAllTemplates(false).filter(
 		name => GetIdentityClasses(cmpTemplateManager.GetTemplate(name).Identity || {}).indexOf("Relic") != -1));
 
 	let potentialSpawnPoints = TriggerHelper.GetLandSpawnPoints();
 	if (!potentialSpawnPoints.length)
 	{
 		error("No gaia entities found on this map that could be used as spawn points!");
 		return;
 	}
 
 	let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
 	let numSpawnedRelics = cmpEndGameManager.GetGameSettings().relicCount;
 	this.playerRelicsCount = new Array(TriggerHelper.GetNumberOfPlayers()).fill(0, 1);
 	this.playerRelicsCount[0] = numSpawnedRelics;
 
 	for (let i = 0; i < numSpawnedRelics; ++i)
 	{
 		this.relics[i] = TriggerHelper.SpawnUnits(pickRandom(potentialSpawnPoints), catafalqueTemplates[i], 1, 0)[0];
 
 		let cmpResistance = Engine.QueryInterface(this.relics[i], IID_Resistance);
 		cmpResistance.SetInvulnerability(true);
 
 		let cmpPositionRelic = Engine.QueryInterface(this.relics[i], IID_Position);
 		cmpPositionRelic.SetYRotation(randomAngle());
 	}
 };
 
 Trigger.prototype.CheckCaptureTheRelicVictory = function(data)
 {
 	let cmpIdentity = Engine.QueryInterface(data.entity, IID_Identity);
 	if (!cmpIdentity || !cmpIdentity.HasClass("Relic") || data.from == INVALID_PLAYER)
 		return;
 
 	--this.playerRelicsCount[data.from];
 
 	if (data.to == -1)
 	{
-		warn("Relic entity " + data.entity + " has been destroyed");
+		warn("Relic entity " + data.entity + " has been destroyed.");
 		this.relics.splice(this.relics.indexOf(data.entity), 1);
 	}
 	else
 		++this.playerRelicsCount[data.to];
 
 	this.DeleteCaptureTheRelicVictoryMessages();
 	this.CheckCaptureTheRelicCountdown();
 };
 
 /**
  * Check if a group of mutually allied players have acquired all relics.
  * The winning players are the relic owners and all players mutually allied to all relic owners.
  * Reset the countdown if the group of winning players changes or extends.
  */
 Trigger.prototype.CheckCaptureTheRelicCountdown = function()
 {
 	if (this.playerRelicsCount[0])
 	{
 		this.DeleteCaptureTheRelicVictoryMessages();
 		return;
 	}
 
 	let activePlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetActivePlayers();
 	let relicOwners = activePlayers.filter(playerID => this.playerRelicsCount[playerID]);
 	if (!relicOwners.length)
 	{
 		this.DeleteCaptureTheRelicVictoryMessages();
 		return;
 	}
 
 	let winningPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager).GetAlliedVictory() ?
 		activePlayers.filter(playerID => relicOwners.every(owner => QueryPlayerIDInterface(playerID).IsMutualAlly(owner))) :
 		[relicOwners[0]];
 
 	// All relicOwners should be mutually allied
 	if (relicOwners.some(owner => winningPlayers.indexOf(owner) == -1))
 	{
 		this.DeleteCaptureTheRelicVictoryMessages();
 		return;
 	}
 
 	// Reset the timer when playerAndAllies isn't the same as this.relicsVictoryCountdownPlayers
 	if (winningPlayers.length != this.relicsVictoryCountdownPlayers.length ||
 	    winningPlayers.some(player => this.relicsVictoryCountdownPlayers.indexOf(player) == -1))
 	{
 		this.relicsVictoryCountdownPlayers = winningPlayers;
 		this.StartCaptureTheRelicCountdown(winningPlayers);
 	}
 };
 
 Trigger.prototype.DeleteCaptureTheRelicVictoryMessages = function()
 {
 	if (!this.relicsVictoryTimer)
 		return;
 
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).CancelTimer(this.relicsVictoryTimer);
 	this.relicsVictoryTimer = undefined;
 
 	let cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	cmpGuiInterface.DeleteTimeNotification(this.ownRelicsVictoryMessage);
 	cmpGuiInterface.DeleteTimeNotification(this.othersRelicsVictoryMessage);
 	this.relicsVictoryCountdownPlayers = [];
 };
 
 Trigger.prototype.StartCaptureTheRelicCountdown = function(winningPlayers)
 {
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	let cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 
 	if (this.relicsVictoryTimer)
 	{
 		cmpTimer.CancelTimer(this.relicsVictoryTimer);
 		cmpGuiInterface.DeleteTimeNotification(this.ownRelicsVictoryMessage);
 		cmpGuiInterface.DeleteTimeNotification(this.othersRelicsVictoryMessage);
 	}
 
 	if (!this.relics.length)
 		return;
 
 	let others = [-1];
 	for (let playerID = 1; playerID < TriggerHelper.GetNumberOfPlayers(); ++playerID)
 	{
 		let cmpPlayer = QueryPlayerIDInterface(playerID);
 		if (cmpPlayer.GetState() == "won")
 			return;
 
 		if (winningPlayers.indexOf(playerID) == -1)
 			others.push(playerID);
 	}
 
 	let cmpPlayer = QueryOwnerInterface(this.relics[0], IID_Player);
+	if (!cmpPlayer)
+	{
+		warn("Relic entity " + this.relics[0] + " has no owner.");
+		this.relics.splice(0, 1);
+
+		this.CheckCaptureTheRelicCountdown();
+		return;
+	}
 	let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
 	let captureTheRelicDuration = cmpEndGameManager.GetGameSettings().relicDuration;
 
 	let isTeam = winningPlayers.length > 1;
 	this.ownRelicsVictoryMessage = cmpGuiInterface.AddTimeNotification({
 		"message": isTeam ?
 			markForTranslation("%(_player_)s and their allies have captured all relics and will win in %(time)s.") :
 			markForTranslation("%(_player_)s has captured all relics and will win in %(time)s."),
 		"players": others,
 		"parameters": {
 			"_player_": cmpPlayer.GetPlayerID()
 		},
 		"translateMessage": true,
 		"translateParameters": []
 	}, captureTheRelicDuration);
 
 	this.othersRelicsVictoryMessage = cmpGuiInterface.AddTimeNotification({
 		"message": isTeam ?
 			markForTranslation("You and your allies have captured all relics and will win in %(time)s.") :
 			markForTranslation("You have captured all relics and will win in %(time)s."),
 		"players": winningPlayers,
 		"translateMessage": true
 	}, captureTheRelicDuration);
 
 	this.relicsVictoryTimer = cmpTimer.SetTimeout(SYSTEM_ENTITY, IID_Trigger,
 		"CaptureTheRelicVictorySetWinner", captureTheRelicDuration, winningPlayers);
 };
 
 Trigger.prototype.CaptureTheRelicVictorySetWinner = function(winningPlayers)
 {
 	let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
 	cmpEndGameManager.MarkPlayersAsWon(
 		winningPlayers,
 		n => markForPluralTranslation(
 			"%(lastPlayer)s has won (Capture the Relic).",
 			"%(players)s and %(lastPlayer)s have won (Capture the Relic).",
 			n),
 		n => markForPluralTranslation(
 			"%(lastPlayer)s has been defeated (Capture the Relic).",
 			"%(players)s and %(lastPlayer)s have been defeated (Capture the Relic).",
 			n));
 };
 
 {
 	let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 	cmpTrigger.relics = [];
 	cmpTrigger.playerRelicsCount = [];
 	cmpTrigger.relicsVictoryTimer = undefined;
 	cmpTrigger.ownRelicsVictoryMessage = undefined;
 	cmpTrigger.othersRelicsVictoryMessage = undefined;
 	cmpTrigger.relicsVictoryCountdownPlayers = [];
 
 	cmpTrigger.DoAfterDelay(0, "InitCaptureTheRelic", {});
 	cmpTrigger.RegisterTrigger("OnDiplomacyChanged", "CheckCaptureTheRelicCountdown", { "enabled": true });
 	cmpTrigger.RegisterTrigger("OnOwnershipChanged", "CheckCaptureTheRelicVictory", { "enabled": true });
 	cmpTrigger.RegisterTrigger("OnPlayerWon", "DeleteCaptureTheRelicVictoryMessages", { "enabled": true });
 	cmpTrigger.RegisterTrigger("OnPlayerDefeated", "CheckCaptureTheRelicCountdown", { "enabled": true });
 }
Index: ps/trunk/binaries/data/mods/public/simulation/components/BuildRestrictions.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/BuildRestrictions.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/BuildRestrictions.js	(revision 24050)
@@ -1,325 +1,326 @@
 function BuildRestrictions() {}
 
 BuildRestrictions.prototype.Schema =
 	"<a:help>Specifies building placement restrictions as they relate to terrain, territories, and distance.</a:help>" +
 	"<a:example>" +
 		"<BuildRestrictions>" +
 			"<PlacementType>land</PlacementType>" +
 			"<Territory>own</Territory>" +
 			"<Category>Special</Category>" +
 			"<Distance>" +
 				"<FromClass>CivilCentre</FromClass>" +
 				"<MaxDistance>40</MaxDistance>" +
 			"</Distance>" +
 		"</BuildRestrictions>" +
 	"</a:example>" +
 	"<element name='PlacementType' a:help='Specifies the terrain type restriction for this building.'>" +
 		"<choice>" +
 			"<value>land</value>" +
 			"<value>shore</value>" +
 			"<value>land-shore</value>"+
 		"</choice>" +
 	"</element>" +
 	"<element name='Territory' a:help='Specifies territory type restrictions for this building.'>" +
 		"<list>" +
 			"<oneOrMore>" +
 				"<choice>" +
 					"<value>own</value>" +
 					"<value>ally</value>" +
 					"<value>neutral</value>" +
 					"<value>enemy</value>" +
 				"</choice>" +
 			"</oneOrMore>" +
 		"</list>" +
 	"</element>" +
 	"<element name='Category' a:help='Specifies the category of this building, for satisfying special constraints. Choices include: Apadana, CivilCentre, Council, Embassy, Fortress, Gladiator, Hall, Hero, Juggernaut, Library, Lighthouse, Monument, Pillar, PyramidLarge, PyramidSmall, Stoa, TempleOfAmun, Theater, Tower, UniqueBuilding, WarDog, Wonder'>" +
 		"<text/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='Distance' a:help='Specifies distance restrictions on this building, relative to buildings from the given category.'>" +
 			"<interleave>" +
 				"<element name='FromClass'>" +
 					"<text/>" +
 				"</element>" +
 				"<optional><element name='MinDistance'><data type='positiveInteger'/></element></optional>" +
 				"<optional><element name='MaxDistance'><data type='positiveInteger'/></element></optional>" +
 			"</interleave>" +
 		"</element>" +
 	"</optional>";
 
 BuildRestrictions.prototype.Init = function()
 {
 	this.territories = this.template.Territory.split(/\s+/);
 };
 
 /**
  * Checks whether building placement is valid
  *	1. Visibility is not hidden (may be fogged or visible)
  *	2. Check foundation
  *		a. Doesn't obstruct foundation-blocking entities
  *		b. On valid terrain, based on passability class
  *	3. Territory type is allowed (see note below)
  *	4. Dock is on shoreline and facing into water
  *	5. Distance constraints satisfied
  *
  * Returns result object:
  * 	{
  *		"success":             true iff the placement is valid, else false
  *		"message":             message to display in UI for invalid placement, else ""
  *		"parameters":          parameters to use in the GUI message
  *		"translateMessage":    always true
  *		"translateParameters": list of parameters to translate
  *		"pluralMessage":       we might return a plural translation instead (optional)
  *		"pluralCount":         plural translation argument (optional)
  *  }
  *
  * Note: The entity which is used to check this should be a preview entity
  *  (template name should be "preview|"+templateName), as otherwise territory
  *  checks for buildings with territory influence will not work as expected.
  */
 BuildRestrictions.prototype.CheckPlacement = function()
 {
 	var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
 	var name = cmpIdentity ? cmpIdentity.GetGenericName() : "Building";
 
 	var result = {
 		"success": false,
 		"message": markForTranslation("%(name)s cannot be built due to unknown error"),
 		"parameters": {
 			"name": name,
 		},
 		"translateMessage": true,
 		"translateParameters": ["name"],
 	};
 
-	// TODO: AI has no visibility info
 	var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+	if (!cmpPlayer)
+		return result; // Fail
+
+	// TODO: AI has no visibility info
 	if (!cmpPlayer.IsAI())
 	{
 		// Check whether it's in a visible or fogged region
 		var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 		var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 		if (!cmpRangeManager || !cmpOwnership)
 			return result; // Fail
 
 		var explored = (cmpRangeManager.GetLosVisibility(this.entity, cmpOwnership.GetOwner()) != "hidden");
 		if (!explored)
 		{
 			result.message = markForTranslation("%(name)s cannot be built in unexplored area");
 			return result; // Fail
 		}
 	}
 
 	// Check obstructions and terrain passability
 	var passClassName = "";
 	switch (this.template.PlacementType)
 	{
 	case "shore":
 		passClassName = "building-shore";
 		break;
 
 	case "land-shore":
 		// 'default-terrain-only' is everywhere a normal unit can go, ignoring
 		// obstructions (i.e. on passable land, and not too deep in the water)
 		passClassName = "default-terrain-only";
 		break;
 
 	case "land":
 	default:
 		passClassName = "building-land";
 	}
 
 	var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
 	if (!cmpObstruction)
 		return result; // Fail
 
 
 	if (this.template.Category == "Wall")
 	{
 		// for walls, only test the center point
 		var ret = cmpObstruction.CheckFoundation(passClassName, true);
 	}
 	else
 	{
 		var ret = cmpObstruction.CheckFoundation(passClassName, false);
 	}
 
 	if (ret != "success")
 	{
 		switch (ret)
 		{
 		case "fail_error":
 		case "fail_no_obstruction":
 			error("CheckPlacement: Error returned from CheckFoundation");
 			break;
 		case "fail_obstructs_foundation":
 			result.message = markForTranslation("%(name)s cannot be built on another building or resource");
 			break;
 		case "fail_terrain_class":
 			// TODO: be more specific and/or list valid terrain?
 			result.message = markForTranslation("%(name)s cannot be built on invalid terrain");
 		}
 		return result; // Fail
 	}
 
 	// Check territory restrictions
 	var cmpTerritoryManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager);
-	var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
 	var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
-	if (!(cmpTerritoryManager && cmpPlayer && cmpPosition && cmpPosition.IsInWorld()))
+	if (!cmpTerritoryManager || !cmpPosition || !cmpPosition.IsInWorld())
 		return result;	// Fail
 
 	var pos = cmpPosition.GetPosition2D();
 	var tileOwner = cmpTerritoryManager.GetOwner(pos.x, pos.y);
 	var isConnected = !cmpTerritoryManager.IsTerritoryBlinking(pos.x, pos.y);
 	var isOwn = tileOwner == cmpPlayer.GetPlayerID();
 	var isMutualAlly = cmpPlayer.IsExclusiveMutualAlly(tileOwner);
 	var isNeutral = tileOwner == 0;
 
 	var invalidTerritory = "";
 	if (isOwn)
 	{
 		if (!this.HasTerritory("own"))
 			// Translation: territoryType being displayed in a translated sentence in the form: "House cannot be built in %(territoryType)s territory.".
 			invalidTerritory = markForTranslationWithContext("Territory type", "own");
 		else if (!isConnected && !this.HasTerritory("neutral"))
 			// Translation: territoryType being displayed in a translated sentence in the form: "House cannot be built in %(territoryType)s territory.".
 			invalidTerritory = markForTranslationWithContext("Territory type", "unconnected own");
 	}
 	else if (isMutualAlly)
 	{
 		if (!this.HasTerritory("ally"))
 			// Translation: territoryType being displayed in a translated sentence in the form: "House cannot be built in %(territoryType)s territory.".
 			invalidTerritory = markForTranslationWithContext("Territory type", "allied");
 		else if (!isConnected && !this.HasTerritory("neutral"))
 			// Translation: territoryType being displayed in a translated sentence in the form: "House cannot be built in %(territoryType)s territory.".
 			invalidTerritory = markForTranslationWithContext("Territory type", "unconnected allied");
 	}
 	else if (isNeutral)
 	{
 		if (!this.HasTerritory("neutral"))
 			// Translation: territoryType being displayed in a translated sentence in the form: "House cannot be built in %(territoryType)s territory.".
 			invalidTerritory = markForTranslationWithContext("Territory type", "neutral");
 	}
 	else
 	{
 		// consider everything else enemy territory
 		if (!this.HasTerritory("enemy"))
 			// Translation: territoryType being displayed in a translated sentence in the form: "House cannot be built in %(territoryType)s territory.".
 			invalidTerritory = markForTranslationWithContext("Territory type", "enemy");
 	}
 
 	if (invalidTerritory)
 	{
 		result.message = markForTranslation("%(name)s cannot be built in %(territoryType)s territory. Valid territories: %(validTerritories)s");
 		result.translateParameters.push("territoryType");
 		result.translateParameters.push("validTerritories");
 		result.parameters.territoryType = {"context": "Territory type", "message": invalidTerritory};
 		// gui code will join this array to a string
 		result.parameters.validTerritories = {"context": "Territory type list", "list": this.GetTerritories()};
 		return result;	// Fail
 	}
 
 	// Check special requirements
 	if (this.template.PlacementType == "shore")
 	{
 		if (!cmpObstruction.CheckShorePlacement())
 		{
 			result.message = markForTranslation("%(name)s must be built on a valid shoreline");
 			return result;	// Fail
 		}
 	}
 
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 
 	let templateName = cmpTemplateManager.GetCurrentTemplateName(this.entity);
 	let template = cmpTemplateManager.GetTemplate(removeFiltersFromTemplateName(templateName));
 
 	// Check distance restriction
 	if (this.template.Distance)
 	{
 		var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-		var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
 		var cat = this.template.Distance.FromClass;
 
 		var filter = function(id)
 		{
 			var cmpIdentity = Engine.QueryInterface(id, IID_Identity);
 			return cmpIdentity.GetClassesList().indexOf(cat) > -1;
 		};
 
 		if (this.template.Distance.MinDistance !== undefined)
 		{
 			let minDistance = ApplyValueModificationsToTemplate("BuildRestrictions/Distance/MinDistance", +this.template.Distance.MinDistance, cmpPlayer.GetPlayerID(), template);
 			if (cmpRangeManager.ExecuteQuery(this.entity, 0, minDistance, [cmpPlayer.GetPlayerID()], IID_BuildRestrictions).some(filter))
 			{
 				let result = markForPluralTranslation(
 					"%(name)s too close to a %(category)s, must be at least %(distance)s meter away",
 					"%(name)s too close to a %(category)s, must be at least %(distance)s meters away",
 					minDistance);
 
 				result.success = false;
 				result.translateMessage = true;
 				result.parameters = {
 					"name": name,
 					"category": cat,
 					"distance": minDistance
 				};
 				result.translateParameters = ["name", "category"];
 				return result;  // Fail
 			}
 		}
 		if (this.template.Distance.MaxDistance !== undefined)
 		{
 			let maxDistance = ApplyValueModificationsToTemplate("BuildRestrictions/Distance/MaxDistance", +this.template.Distance.MaxDistance, cmpPlayer.GetPlayerID(), template);
 			if (!cmpRangeManager.ExecuteQuery(this.entity, 0, maxDistance, [cmpPlayer.GetPlayerID()], IID_BuildRestrictions).some(filter))
 			{
 				let result = markForPluralTranslation(
 					"%(name)s too far from a %(category)s, must be within %(distance)s meter",
 					"%(name)s too far from a %(category)s, must be within %(distance)s meters",
 					maxDistance);
 
 				result.success = false;
 				result.translateMessage = true;
 				result.parameters = {
 					"name": name,
 					"category": cat,
 					"distance": maxDistance
 				};
 				result.translateParameters = ["name", "category"];
 				return result;	// Fail
 			}
 		}
 	}
 
 	// Success
 	result.success = true;
 	result.message = "";
 	return result;
 };
 
 BuildRestrictions.prototype.GetCategory = function()
 {
 	return this.template.Category;
 };
 
 BuildRestrictions.prototype.GetTerritories = function()
 {
 	return ApplyValueModificationsToEntity("BuildRestrictions/Territory", this.territories, this.entity);
 };
 
 BuildRestrictions.prototype.HasTerritory = function(territory)
 {
 	return (this.GetTerritories().indexOf(territory) != -1);
 };
 
 // Translation: Territory types being displayed as part of a list like "Valid territories: own, ally".
 markForTranslationWithContext("Territory type list", "own");
 // Translation: Territory types being displayed as part of a list like "Valid territories: own, ally".
 markForTranslationWithContext("Territory type list", "ally");
 // Translation: Territory types being displayed as part of a list like "Valid territories: own, ally".
 markForTranslationWithContext("Territory type list", "neutral");
 // Translation: Territory types being displayed as part of a list like "Valid territories: own, ally".
 markForTranslationWithContext("Territory type list", "enemy");
 
 Engine.RegisterComponentType(IID_BuildRestrictions, "BuildRestrictions", BuildRestrictions);
Index: ps/trunk/binaries/data/mods/public/simulation/components/Looter.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Looter.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Looter.js	(revision 24050)
@@ -1,45 +1,46 @@
 function Looter() {}
 
 Looter.prototype.Schema =
 	"<empty/>";
 
 Looter.prototype.Serialize = null; // We have no dynamic state to save
 
 /**
  * Try to collect loot from target entity
  */
 Looter.prototype.Collect = function(targetEntity)
 {
 	var cmpLoot = Engine.QueryInterface(targetEntity, IID_Loot);
 	if (!cmpLoot)
 		return;
 
 	// Collect resources carried by workers and traders
 	var cmpResourceGatherer = Engine.QueryInterface(targetEntity, IID_ResourceGatherer);
 	var cmpTrader = Engine.QueryInterface(targetEntity, IID_Trader);
 
 	let resourcesCarried = calculateCarriedResources(
 		cmpResourceGatherer && cmpResourceGatherer.GetCarryingStatus(),
 		cmpTrader && cmpTrader.GetGoods()
 	);
 
 	// Loot resources as defined in the templates
 	let lootTemplate = cmpLoot.GetResources();
 	let resources = {};
 	for (let type of Resources.GetCodes())
 		resources[type] =
 			ApplyValueModificationsToEntity(
 				"Looter/Resource/"+type, lootTemplate[type] || 0, this.entity) +
 			(resourcesCarried[type] || 0);
 
 	// Transfer resources
 	var cmpPlayer = QueryOwnerInterface(this.entity);
-	cmpPlayer.AddResources(resources);
+	if (cmpPlayer)
+		cmpPlayer.AddResources(resources);
 
 	// Update statistics
 	var cmpStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
 	if (cmpStatisticsTracker)
 		cmpStatisticsTracker.IncreaseLootCollectedCounter(resources);
 };
 
 Engine.RegisterComponentType(IID_Looter, "Looter", Looter);
Index: ps/trunk/binaries/data/mods/public/simulation/components/ProductionQueue.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/ProductionQueue.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/ProductionQueue.js	(revision 24050)
@@ -1,957 +1,972 @@
 function ProductionQueue() {}
 
 ProductionQueue.prototype.Schema =
 	"<a:help>Allows the building to train new units and research technologies</a:help>" +
 	"<a:example>" +
 		"<BatchTimeModifier>0.7</BatchTimeModifier>" +
 		"<Entities datatype='tokens'>" +
 			"\n    units/{civ}_support_female_citizen\n    units/{native}_support_trader\n    units/athen_infantry_spearman_b\n  " +
 		"</Entities>" +
 	"</a:example>" +
 	"<element name='BatchTimeModifier' a:help='Modifier that influences the time benefit for batch training'>" +
 		"<ref name='nonNegativeDecimal'/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='Entities' a:help='Space-separated list of entity template names that this entity can train. The special string \"{civ}\" will be automatically replaced by the civ code of the entity&apos;s owner, while the string \"{native}\" will be automatically replaced by the entity&apos;s civ code.'>" +
 			"<attribute name='datatype'>" +
 				"<value>tokens</value>" +
 			"</attribute>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Technologies' a:help='Space-separated list of technology names that this building can research. When present, the special string \"{civ}\" will be automatically replaced either by the civ code of the building&apos;s owner if such a tech exists, or by \"generic\".'>" +
 			"<attribute name='datatype'>" +
 				"<value>tokens</value>" +
 			"</attribute>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>" +
 	"<element name='TechCostMultiplier' a:help='Multiplier to modify ressources cost and research time of technologies searched in this building.'>" +
 		Resources.BuildSchema("nonNegativeDecimal", ["time"]) +
 	"</element>";
 
 ProductionQueue.prototype.ProgressInterval = 1000;
 ProductionQueue.prototype.MaxQueueSize = 16;
 
 ProductionQueue.prototype.Init = function()
 {
 	this.nextID = 1;
 
 	this.queue = [];
 	// Queue items are:
 	//   {
 	//     "id": 1,
 	//     "player": 1, // who paid for this batch; we need this to cope with refunds cleanly
 	//     "unitTemplate": "units/example",
 	//     "count": 10,
 	//     "neededSlots": 3, // number of population slots missing for production to begin
 	//     "resources": { "wood": 100, ... }, // resources per unit, multiply by count to get total
 	//     "population": 1,	// population per unit, multiply by count to get total
 	//     "productionStarted": false, // true iff we have reserved population
 	//     "timeTotal": 15000, // msecs
 	//     "timeRemaining": 10000, // msecs
 	//   }
 	//
 	//   {
 	//     "id": 1,
 	//     "player": 1, // who paid for this research; we need this to cope with refunds cleanly
 	//     "technologyTemplate": "example_tech",
 	//     "resources": { "wood": 100, ... }, // resources needed for research
 	//     "productionStarted": false, // true iff production has started
 	//     "timeTotal": 15000, // msecs
 	//     "timeRemaining": 10000, // msecs
 	//   }
 
 	this.timer = undefined; // this.ProgressInterval msec timer, active while the queue is non-empty
 	this.paused = false;
 
 	this.entityCache = [];
 	this.spawnNotified = false;
 };
 
 /*
  * Returns list of entities that can be trained by this building.
  */
 ProductionQueue.prototype.GetEntitiesList = function()
 {
 	return Array.from(this.entitiesMap.values());
 };
 
 /**
  * Calculate the new list of producible entities
  * and update any entities currently being produced.
  */
 ProductionQueue.prototype.CalculateEntitiesMap = function()
 {
 	// Don't reset the map, it's used below to update entities.
 	if (!this.entitiesMap)
 		this.entitiesMap = new Map();
 	if (!this.template.Entities)
 		return;
 
 	let string = this.template.Entities._string;
 	// Tokens can be added -> process an empty list to get them.
 	let addedTokens = ApplyValueModificationsToEntity("ProductionQueue/Entities/_string", "", this.entity);
 	if (!addedTokens && !string)
 		return;
 
 	addedTokens = addedTokens == "" ? [] : addedTokens.split(/\s+/);
 
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
 
 	let disabledEntities = cmpPlayer ? cmpPlayer.GetDisabledTemplates() : {};
 
 	/**
 	 * Process tokens:
 	 * - process token modifiers (this is a bit tricky).
 	 * - replace the "{civ}" and "{native}" codes with the owner's civ ID and entity's civ ID
 	 * - remove disabled entities
 	 * - upgrade templates where necessary
 	 * This also updates currently queued production (it's more convenient to do it here).
 	 */
 
 	let removeAllQueuedTemplate = (token) => {
 		let queue = clone(this.queue);
 		let template = this.entitiesMap.get(token);
 		for (let item of queue)
 			if (item.unitTemplate && item.unitTemplate === template)
 				this.RemoveBatch(item.id);
 	};
 	let updateAllQueuedTemplate = (token, updateTo) => {
 		let template = this.entitiesMap.get(token);
 		for (let item of this.queue)
 			if (item.unitTemplate && item.unitTemplate === template)
 				item.unitTemplate = updateTo;
 	};
 
 	let toks = string.split(/\s+/);
 	for (let tok of addedTokens)
 		toks.push(tok);
 
 	let addedDict = addedTokens.reduce((out, token) => { out[token] = true; return out; }, {});
 	this.entitiesMap = toks.reduce((entMap, token) => {
 		let rawToken = token;
 		if (!(token in addedDict))
 		{
 			// This is a bit wasteful but I can't think of a simpler/better way.
 			// The list of token is unlikely to be a performance bottleneck anyways.
 			token = ApplyValueModificationsToEntity("ProductionQueue/Entities/_string", token, this.entity);
 			token = token.split(/\s+/);
 			if (token.every(tok => addedTokens.indexOf(tok) !== -1))
 			{
 				removeAllQueuedTemplate(rawToken);
 				return entMap;
 			}
 			token = token[0];
 		}
 		// Replace the "{civ}" and "{native}" codes with the owner's civ ID and entity's civ ID.
 		if (cmpIdentity)
 			token = token.replace(/\{native\}/g, cmpIdentity.GetCiv());
 		if (cmpPlayer)
 			token = token.replace(/\{civ\}/g, cmpPlayer.GetCiv());
 
 		// Filter out disabled and invalid entities.
 		if (disabledEntities[token] || !cmpTemplateManager.TemplateExists(token))
 		{
 			removeAllQueuedTemplate(rawToken);
 			return entMap;
 		}
 
 		token = this.GetUpgradedTemplate(token);
 		entMap.set(rawToken, token);
 		updateAllQueuedTemplate(rawToken, token);
 		return entMap;
 	}, new Map());
 };
 
 /*
  * Returns the upgraded template name if necessary.
  */
 ProductionQueue.prototype.GetUpgradedTemplate = function(templateName)
 {
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	if (!cmpPlayer)
 		return templateName;
 
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let template = cmpTemplateManager.GetTemplate(templateName);
 	while (template && template.Promotion !== undefined)
 	{
 		let requiredXp = ApplyValueModificationsToTemplate(
 		    "Promotion/RequiredXp",
 		    +template.Promotion.RequiredXp,
 		    cmpPlayer.GetPlayerID(),
 		    template);
 		if (requiredXp > 0)
 			break;
 		templateName = template.Promotion.Entity;
 		template = cmpTemplateManager.GetTemplate(templateName);
 	}
 	return templateName;
 };
 
 /*
  * Returns list of technologies that can be researched by this building.
  */
 ProductionQueue.prototype.GetTechnologiesList = function()
 {
 	if (!this.template.Technologies)
 		return [];
 
 	let string = this.template.Technologies._string;
 	string = ApplyValueModificationsToEntity("ProductionQueue/Technologies/_string", string, this.entity);
 
 	if (!string)
 		return [];
 
 	let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
 	if (!cmpTechnologyManager)
 		return [];
 
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	if (!cmpPlayer)
 		return [];
 
 	let techs = string.split(/\s+/);
 
 	// Replace the civ specific technologies.
 	for (let i = 0; i < techs.length; ++i)
 	{
 		let tech = techs[i];
 		if (tech.indexOf("{civ}") == -1)
 			continue;
 		let civTech = tech.replace("{civ}", cmpPlayer.GetCiv());
 		techs[i] = TechnologyTemplates.Has(civTech) ? civTech : tech.replace("{civ}", "generic");
 	}
 
 	// Remove any technologies that can't be researched by this civ.
 	techs = techs.filter(tech =>
 		cmpTechnologyManager.CheckTechnologyRequirements(
 			DeriveTechnologyRequirements(TechnologyTemplates.Get(tech), cmpPlayer.GetCiv()),
 			true));
 
 	let techList = [];
 	// Stores the tech which supersedes the key.
 	let superseded = {};
 
 	let disabledTechnologies = cmpPlayer.GetDisabledTechnologies();
 
 	// Add any top level technologies to an array which corresponds to the displayed icons.
 	// Also store what technology is superseded in the superseded object { "tech1":"techWhichSupercedesTech1", ... }.
 	for (let tech of techs)
 	{
 		if (disabledTechnologies && disabledTechnologies[tech])
 			continue;
 
 		let template = TechnologyTemplates.Get(tech);
 		if (!template.supersedes || techs.indexOf(template.supersedes) === -1)
 			techList.push(tech);
 		else
 			superseded[template.supersedes] = tech;
 	}
 
 	// Now make researched/in progress techs invisible.
 	for (let i in techList)
 	{
 		let tech = techList[i];
 		while (this.IsTechnologyResearchedOrInProgress(tech))
 			tech = superseded[tech];
 
 		techList[i] = tech;
 	}
 
 	let ret = [];
 
 	// This inserts the techs into the correct positions to line up the technology pairs.
 	for (let i = 0; i < techList.length; ++i)
 	{
 		let tech = techList[i];
 		if (!tech)
 		{
 			ret[i] = undefined;
 			continue;
 		}
 
 		let template = TechnologyTemplates.Get(tech);
 		if (template.top)
 			ret[i] = { "pair": true, "top": template.top, "bottom": template.bottom };
 		else
 			ret[i] = tech;
 	}
 
 	return ret;
 };
 
 ProductionQueue.prototype.GetTechCostMultiplier = function()
 {
 	let techCostMultiplier = {};
 	for (let res in this.template.TechCostMultiplier)
 		techCostMultiplier[res] = ApplyValueModificationsToEntity(
 		    "ProductionQueue/TechCostMultiplier/" + res,
 		    +this.template.TechCostMultiplier[res],
 		    this.entity);
 
 	return techCostMultiplier;
 };
 
 ProductionQueue.prototype.IsTechnologyResearchedOrInProgress = function(tech)
 {
 	if (!tech)
 		return false;
 
 	let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
+	if (!cmpTechnologyManager)
+		return false;
 
 	let template = TechnologyTemplates.Get(tech);
 	if (template.top)
 		return cmpTechnologyManager.IsTechnologyResearched(template.top) ||
 		    cmpTechnologyManager.IsInProgress(template.top) ||
 		    cmpTechnologyManager.IsTechnologyResearched(template.bottom) ||
 		    cmpTechnologyManager.IsInProgress(template.bottom);
 
 	return cmpTechnologyManager.IsTechnologyResearched(tech) || cmpTechnologyManager.IsInProgress(tech);
 };
 
 /*
  * Adds a new batch of identical units to train or a technology to research to the production queue.
  */
 ProductionQueue.prototype.AddBatch = function(templateName, type, count, metadata)
 {
 	// TODO: there should probably be a limit on the number of queued batches.
 	// TODO: there should be a way for the GUI to determine whether it's going
 	// to be possible to add a batch (based on resource costs and length limits).
 	let cmpPlayer = QueryOwnerInterface(this.entity);
+	if (!cmpPlayer)
+		return;
 
 	if (this.queue.length < this.MaxQueueSize)
 	{
 
 		if (type == "unit")
 		{
 			if (!Number.isInteger(count) || count <= 0)
 			{
 				error("Invalid batch count " + count);
 				return;
 			}
 
 			// Find the template data so we can determine the build costs.
 			let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 			let template = cmpTemplateManager.GetTemplate(templateName);
 			if (!template)
 				return;
 			if (template.Promotion &&
 			  !ApplyValueModificationsToTemplate(
 			    "Promotion/RequiredXp",
 			    +template.Promotion.RequiredXp,
 			    cmpPlayer.GetPlayerID(),
 			    template))
 			{
 				this.AddBatch(template.Promotion.Entity, type, count, metadata);
 				return;
 			}
 
 			// We need the costs after tech modifications.
 			// Obviously we don't have the entities yet, so we must use template data.
 			let costs = {};
 			let totalCosts = {};
 
 			for (let res in template.Cost.Resources)
 			{
 				costs[res] = ApplyValueModificationsToTemplate(
 				    "Cost/Resources/" + res,
 				    +template.Cost.Resources[res],
 				    cmpPlayer.GetPlayerID(),
 				    template);
 
 				totalCosts[res] = Math.floor(count * costs[res]);
 			}
 
 			// TrySubtractResources should report error to player (they ran out of resources).
 			if (!cmpPlayer.TrySubtractResources(totalCosts))
 				return;
 
 			// Update entity count in the EntityLimits component.
 			if (template.TrainingRestrictions)
 			{
 				let unitCategory = template.TrainingRestrictions.Category;
 				let cmpPlayerEntityLimits = QueryOwnerInterface(this.entity, IID_EntityLimits);
-				cmpPlayerEntityLimits.ChangeCount(unitCategory, count);
+				if (cmpPlayerEntityLimits)
+					cmpPlayerEntityLimits.ChangeCount(unitCategory, count);
 			}
 
 			let buildTime = ApplyValueModificationsToTemplate(
 			    "Cost/BuildTime",
 			    +template.Cost.BuildTime,
 			    cmpPlayer.GetPlayerID(),
 			    template);
 			// Apply a time discount to larger batches.
 			let time = this.GetBatchTime(count) * buildTime * 1000;
 			this.queue.push({
 				"id": this.nextID++,
 				"player": cmpPlayer.GetPlayerID(),
 				"unitTemplate": templateName,
 				"count": count,
 				"metadata": metadata,
 				"resources": costs,
 				"population": ApplyValueModificationsToTemplate(
 				    "Cost/Population",
 				    +template.Cost.Population,
 				    cmpPlayer.GetPlayerID(),
 				    template),
 				"productionStarted": false,
 				"timeTotal": time,
 				"timeRemaining": time
 			});
 
 			// Call the related trigger event.
 			let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 			cmpTrigger.CallEvent("TrainingQueued", {
 			    "playerid": cmpPlayer.GetPlayerID(),
 			    "unitTemplate": templateName,
 			    "count": count,
 			    "metadata": metadata,
 			    "trainerEntity": this.entity
 			});
 		}
 		else if (type == "technology")
 		{
 			if (!TechnologyTemplates.Has(templateName))
 				return;
 
 			if (!this.GetTechnologiesList().some(tech =>
 				tech &&
 					(tech == templateName ||
 						tech.pair &&
 						(tech.top == templateName || tech.bottom == templateName))))
 			{
 				error("This entity cannot research " + templateName);
 				return;
 			}
 
 			let template = TechnologyTemplates.Get(templateName);
 			let techCostMultiplier = this.GetTechCostMultiplier();
 
 			let cost = {};
 			for (let res in template.cost)
 				cost[res] = Math.floor((techCostMultiplier[res] || 1) * template.cost[res]);
 
 			// TrySubtractResources should report error to player (they ran out of resources).
 			if (!cmpPlayer.TrySubtractResources(cost))
 				return;
 
 			// Tell the technology manager that we have started researching this so that people can't research the same
 			// thing twice.
 			let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
 			cmpTechnologyManager.QueuedResearch(templateName, this.entity);
 			if (!this.queue.length)
 			{
 				cmpTechnologyManager.StartedResearch(templateName, false);
 				this.SetAnimation("researching");
 			}
 
 			let time = techCostMultiplier.time * template.researchTime * 1000;
 			this.queue.push({
 			    "id": this.nextID++,
 			    "player": cmpPlayer.GetPlayerID(),
 			    "count": 1,
 			    "technologyTemplate": templateName,
 			    "resources": cost,
 			    "productionStarted": false,
 			    "timeTotal": time,
 			    "timeRemaining": time
 			});
 
 			// Call the related trigger event.
 			let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 			cmpTrigger.CallEvent("ResearchQueued", {
 			    "playerid": cmpPlayer.GetPlayerID(),
 			    "technologyTemplate": templateName,
 			    "researcherEntity": this.entity
 			});
 		}
 		else
 		{
 			warn("Tried to add invalid item of type \"" + type + "\" and template \"" + templateName + "\" to a production queue");
 			return;
 		}
 
 		Engine.PostMessage(this.entity, MT_ProductionQueueChanged, {});
 
 		// If this is the first item in the queue, start the timer.
 		if (!this.timer)
 		{
 			let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 			this.timer = cmpTimer.SetTimeout(this.entity, IID_ProductionQueue, "ProgressTimeout", this.ProgressInterval, {});
 		}
 	}
 	else
 	{
 		let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGUIInterface.PushNotification({
 		    "players": [cmpPlayer.GetPlayerID()],
 		    "message": markForTranslation("The production queue is full."),
 		    "translateMessage": true,
 		});
 	}
 };
 
 /*
  * Removes an existing batch of units from the production queue.
  * Refunds resource costs and population reservations.
  */
 ProductionQueue.prototype.RemoveBatch = function(id)
 {
 	// Destroy any cached entities (those which didn't spawn for some reason).
 	for (let ent of this.entityCache)
 		Engine.DestroyEntity(ent);
 
 	this.entityCache = [];
 
 	for (let i = 0; i < this.queue.length; ++i)
 	{
 		let item = this.queue[i];
 		if (item.id != id)
 			continue;
 
 		// Now we've found the item to remove.
 		let cmpPlayer = QueryPlayerIDInterface(item.player);
 
 		// Update entity count in the EntityLimits component.
 		if (item.unitTemplate)
 		{
 			let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 			let template = cmpTemplateManager.GetTemplate(item.unitTemplate);
 			if (template.TrainingRestrictions)
 			{
 				let cmpPlayerEntityLimits = QueryPlayerIDInterface(item.player, IID_EntityLimits);
 				cmpPlayerEntityLimits.ChangeCount(template.TrainingRestrictions.Category, -item.count);
 			}
 		}
 
 		// Refund the resource cost for this batch.
 		let totalCosts = {};
 		let cmpStatisticsTracker = QueryPlayerIDInterface(item.player, IID_StatisticsTracker);
 		for (let r in item.resources)
 		{
 			totalCosts[r] = Math.floor(item.count * item.resources[r]);
 			if (cmpStatisticsTracker)
 				cmpStatisticsTracker.IncreaseResourceUsedCounter(r, -totalCosts[r]);
 		}
 
 		cmpPlayer.AddResources(totalCosts);
 
 		// Remove reserved population slots if necessary.
 		if (item.productionStarted && item.unitTemplate)
 			cmpPlayer.UnReservePopulationSlots(item.population * item.count);
 
 		// Mark the research as stopped if we cancel it.
 		if (item.technologyTemplate)
 		{
 			// item.player is used as this.entity's owner may be invalid (deletion, etc.)
 			let cmpTechnologyManager = QueryPlayerIDInterface(item.player, IID_TechnologyManager);
 			cmpTechnologyManager.StoppedResearch(item.technologyTemplate, true);
 			this.SetAnimation("idle");
 		}
 
 		// Remove from the queue.
 		// (We don't need to remove the timer - it'll expire if it discovers the queue is empty.)
 		this.queue.splice(i, 1);
 		Engine.PostMessage(this.entity, MT_ProductionQueueChanged, {});
 
 		return;
 	}
 };
 
 ProductionQueue.prototype.SetAnimation = function(name)
 {
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (cmpVisual)
 		cmpVisual.SelectAnimation(name, false, 1);
 };
 
 /*
  * Returns basic data from all batches in the production queue.
  */
 ProductionQueue.prototype.GetQueue = function()
 {
 	return this.queue.map(item => ({
 	    "id": item.id,
 	    "unitTemplate": item.unitTemplate,
 	    "technologyTemplate": item.technologyTemplate,
 	    "count": item.count,
 	    "neededSlots": item.neededSlots,
 	    "progress": 1 - (item.timeRemaining / (item.timeTotal || 1)),
 	    "timeRemaining": item.timeRemaining,
 	    "metadata": item.metadata
 	}));
 };
 
 /*
  * Removes all existing batches from the queue.
  */
 ProductionQueue.prototype.ResetQueue = function()
 {
 	// Empty the production queue and refund all the resource costs
 	// to the player. (This is to avoid players having to micromanage their
 	// buildings' queues when they're about to be destroyed or captured.)
 
 	while (this.queue.length)
 		this.RemoveBatch(this.queue[0].id);
 };
 
 /*
  * Returns batch build time.
  */
 ProductionQueue.prototype.GetBatchTime = function(batchSize)
 {
 	// TODO: work out what equation we should use here.
 	return Math.pow(batchSize, ApplyValueModificationsToEntity(
 	    "ProductionQueue/BatchTimeModifier",
 	    +this.template.BatchTimeModifier,
 	    this.entity));
 };
 
 ProductionQueue.prototype.OnOwnershipChanged = function(msg)
 {
 	if (msg.from != INVALID_PLAYER)
 	{
 		// Unset flag that previous owner's training may be blocked.
 		let cmpPlayer = QueryPlayerIDInterface(msg.from);
 		if (cmpPlayer && this.queue.length)
 			cmpPlayer.UnBlockTraining();
 	}
 	if (msg.to != INVALID_PLAYER)
 		this.CalculateEntitiesMap();
 
 	// Reset the production queue whenever the owner changes.
 	// (This should prevent players getting surprised when they capture
 	// an enemy building, and then loads of the enemy's civ's soldiers get
 	// created from it. Also it means we don't have to worry about
 	// updating the reserved pop slots.)
 	this.ResetQueue();
 };
 
 ProductionQueue.prototype.OnCivChanged = function()
 {
 	this.CalculateEntitiesMap();
 };
 
 ProductionQueue.prototype.OnDestroy = function()
 {
 	// Reset the queue to refund any resources.
 	this.ResetQueue();
 
 	if (this.timer)
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		cmpTimer.CancelTimer(this.timer);
 	}
 };
 
 /*
  * This function creates the entities and places them in world if possible
  * and returns the number of successfully created entities.
  * (some of these entities may be garrisoned directly if autogarrison, the others are spawned).
  */
 ProductionQueue.prototype.SpawnUnits = function(templateName, count, metadata)
 {
 	let cmpFootprint = Engine.QueryInterface(this.entity, IID_Footprint);
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	let cmpRallyPoint = Engine.QueryInterface(this.entity, IID_RallyPoint);
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	let cmpPlayerEntityLimits = QueryOwnerInterface(this.entity, IID_EntityLimits);
 	let cmpPlayerStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
 
 	let createdEnts = [];
 	let spawnedEnts = [];
 
 	// We need entities to test spawning, but we don't want to waste resources,
 	// so only create them once and use as needed.
 	if (!this.entityCache.length)
 		for (let i = 0; i < count; ++i)
 			this.entityCache.push(Engine.AddEntity(templateName));
 
 	let cmpAutoGarrison;
 	if (cmpRallyPoint)
 	{
 		let data = cmpRallyPoint.GetData()[0];
 		if (data && data.target && data.target == this.entity && data.command == "garrison")
 			cmpAutoGarrison = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
 	}
 
 	for (let i = 0; i < count; ++i)
 	{
 		let ent = this.entityCache[0];
 		let cmpNewOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		let garrisoned = false;
 
 		if (cmpAutoGarrison)
 		{
 			// Temporary owner affectation needed for GarrisonHolder checks.
 			cmpNewOwnership.SetOwnerQuiet(cmpOwnership.GetOwner());
 			garrisoned = cmpAutoGarrison.Garrison(ent);
 			cmpNewOwnership.SetOwnerQuiet(INVALID_PLAYER);
 		}
 
 		if (garrisoned)
 		{
 			let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			if (cmpUnitAI)
 				cmpUnitAI.Autogarrison(this.entity);
 		}
 		else
 		{
 			let pos = cmpFootprint.PickSpawnPoint(ent);
 			if (pos.y < 0)
 				break;
 
 			let cmpNewPosition = Engine.QueryInterface(ent, IID_Position);
 			cmpNewPosition.JumpTo(pos.x, pos.z);
 
 			if (cmpPosition)
 				cmpNewPosition.SetYRotation(cmpPosition.GetPosition().horizAngleTo(pos));
 
 			spawnedEnts.push(ent);
 		}
 
 		// Decrement entity count in the EntityLimits component
 		// since it will be increased by EntityLimits.OnGlobalOwnershipChanged function,
 		// i.e. we replace a 'trained' entity by 'alive' one.
 		// Must be done after spawn check so EntityLimits decrements only if unit spawns.
-		let cmpTrainingRestrictions = Engine.QueryInterface(ent, IID_TrainingRestrictions);
-		if (cmpTrainingRestrictions)
+		if (cmpPlayerEntityLimits)
 		{
-			let unitCategory = cmpTrainingRestrictions.GetCategory();
-			cmpPlayerEntityLimits.ChangeCount(unitCategory, -1);
+			let cmpTrainingRestrictions = Engine.QueryInterface(ent, IID_TrainingRestrictions);
+			if (cmpTrainingRestrictions)
+				cmpPlayerEntityLimits.ChangeCount(cmpTrainingRestrictions.GetCategory(), -1);
 		}
-
 		cmpNewOwnership.SetOwner(cmpOwnership.GetOwner());
 
 		if (cmpPlayerStatisticsTracker)
 			cmpPlayerStatisticsTracker.IncreaseTrainedUnitsCounter(ent);
 
 		// Play a sound, but only for the first in the batch (to avoid nasty phasing effects).
 		if (!createdEnts.length)
 			PlaySound("trained", ent);
 
 		this.entityCache.shift();
 		createdEnts.push(ent);
 	}
 
 	if (spawnedEnts.length && !cmpAutoGarrison)
 	{
 		// If a rally point is set, walk towards it (in formation) using a suitable command based on where the
 		// rally point is placed.
 		if (cmpRallyPoint)
 		{
 			let rallyPos = cmpRallyPoint.GetPositions()[0];
 			if (rallyPos)
 			{
 				let commands = GetRallyPointCommands(cmpRallyPoint, spawnedEnts);
 				for (let com of commands)
 					ProcessCommand(cmpOwnership.GetOwner(), com);
 			}
 		}
 	}
 
 	if (createdEnts.length)
 		Engine.PostMessage(this.entity, MT_TrainingFinished, {
 		    "entities": createdEnts,
 		    "owner": cmpOwnership.GetOwner(),
 		    "metadata": metadata
 		});
 
 	return createdEnts.length;
 };
 
 /*
  * Increments progress on the first batch in the production queue, and blocks the
  * queue if population limit is reached or some units failed to spawn.
  */
 ProductionQueue.prototype.ProgressTimeout = function(data)
 {
 	// Check if the production is paused (eg the entity is garrisoned)
 	if (this.paused)
 		return;
+
+	let cmpPlayer = QueryOwnerInterface(this.entity);
+	if (!cmpPlayer)
+		return;
+
 	// Allocate available time to as many queue items as it takes
 	// until we've used up all the time (so that we work accurately
 	// with items that take fractions of a second).
 	let time = this.ProgressInterval;
-	let cmpPlayer = QueryOwnerInterface(this.entity);
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 
 	while (time > 0 && this.queue.length)
 	{
 		let item = this.queue[0];
 		if (!item.productionStarted)
 		{
 			// If the item is a unit then do population checks.
 			if (item.unitTemplate)
 			{
 				// If something change population cost.
 				let template = cmpTemplateManager.GetTemplate(item.unitTemplate);
 				item.population = ApplyValueModificationsToTemplate(
 				    "Cost/Population",
 				    +template.Cost.Population,
 				    item.player,
 				    template);
 
 				// Batch's training hasn't started yet.
 				// Try to reserve the necessary population slots.
 				item.neededSlots = cmpPlayer.TryReservePopulationSlots(item.population * item.count);
 				if (item.neededSlots)
 				{
 					// Not enough slots available - don't train this batch now
 					// (we'll try again on the next timeout).
 
 					cmpPlayer.BlockTraining();
 					break;
 				}
 
 				cmpPlayer.UnBlockTraining();
 			}
 
 			if (item.technologyTemplate)
 			{
 				// Mark the research as started.
 				let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
-				cmpTechnologyManager.StartedResearch(item.technologyTemplate, true);
+				if (cmpTechnologyManager)
+					cmpTechnologyManager.StartedResearch(item.technologyTemplate, true);
+				else
+					warn("Failed to start researching " + item.technologyTemplate + ": No TechnologyManager available.");
+
 				this.SetAnimation("researching");
 			}
 
 			item.productionStarted = true;
 			if (item.unitTemplate)
 				Engine.PostMessage(this.entity, MT_TrainingStarted, { "entity": this.entity });
 		}
 
 		// If we won't finish the batch now, just update its timer.
 		if (item.timeRemaining > time)
 		{
 			item.timeRemaining -= time;
 			// send a message for the AIs.
 			Engine.PostMessage(this.entity, MT_ProductionQueueChanged, {});
 			break;
 		}
 
 		if (item.unitTemplate)
 		{
 			let numSpawned = this.SpawnUnits(item.unitTemplate, item.count, item.metadata);
 			if (numSpawned == item.count)
 			{
 				// All entities spawned, this batch finished.
 				cmpPlayer.UnReservePopulationSlots(item.population * numSpawned);
 				time -= item.timeRemaining;
 				this.queue.shift();
 				// Unset flag that training is blocked.
 				cmpPlayer.UnBlockTraining();
 				this.spawnNotified = false;
 				Engine.PostMessage(this.entity, MT_ProductionQueueChanged, {});
 			}
 			else
 			{
 				if (numSpawned > 0)
 				{
 					// Training is only partially finished.
 					cmpPlayer.UnReservePopulationSlots(item.population * numSpawned);
 					item.count -= numSpawned;
 					Engine.PostMessage(this.entity, MT_ProductionQueueChanged, {});
 				}
 
 				// Some entities failed to spawn.
 				// Set flag that training is blocked.
 				cmpPlayer.BlockTraining();
 
 				if (!this.spawnNotified)
 				{
 					let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 					cmpGUIInterface.PushNotification({
 					    "players": [cmpPlayer.GetPlayerID()],
 					    "message": markForTranslation("Can't find free space to spawn trained units"),
 					    "translateMessage": true
 					});
 					this.spawnNotified = true;
 				}
 				break;
 			}
 		}
 		else if (item.technologyTemplate)
 		{
 			let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
-			cmpTechnologyManager.ResearchTechnology(item.technologyTemplate);
+			if (cmpTechnologyManager)
+				cmpTechnologyManager.ResearchTechnology(item.technologyTemplate);
+			else
+				warn("Failed to stop researching " + item.technologyTemplate + ": No TechnologyManager available.");
+
 			this.SetAnimation("idle");
 			let template = TechnologyTemplates.Get(item.technologyTemplate);
 			if (template && template.soundComplete)
 			{
 				let cmpSoundManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_SoundManager);
-
 				if (cmpSoundManager)
 					cmpSoundManager.PlaySoundGroup(template.soundComplete, this.entity);
 			}
 
 			time -= item.timeRemaining;
 
 			this.queue.shift();
 			Engine.PostMessage(this.entity, MT_ProductionQueueChanged, {});
 		}
 	}
 
 	// If the queue's empty, delete the timer, else repeat it.
 	if (!this.queue.length)
 	{
 		this.timer = undefined;
 
 		// Unset flag that training is blocked.
 		// (This might happen when the player unqueues all batches.)
 		cmpPlayer.UnBlockTraining();
 	}
 	else
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		this.timer = cmpTimer.SetTimeout(this.entity, IID_ProductionQueue, "ProgressTimeout", this.ProgressInterval, data);
 	}
 };
 
 ProductionQueue.prototype.PauseProduction = function()
 {
 	this.timer = undefined;
 	this.paused = true;
 };
 
 ProductionQueue.prototype.UnpauseProduction = function()
 {
 	this.paused = false;
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	this.timer = cmpTimer.SetTimeout(this.entity, IID_ProductionQueue, "ProgressTimeout", this.ProgressInterval, {});
 };
 
 ProductionQueue.prototype.OnValueModification = function(msg)
 {
 	// If the promotion requirements of units is changed,
 	// update the entities list so that automatically promoted units are shown
 	// appropriately in the list.
 	if (msg.component != "Promotion" && (msg.component != "ProductionQueue" ||
 	        !msg.valueNames.some(val => val.startsWith("ProductionQueue/Entities/"))))
 		return;
 
 	if (msg.entities.indexOf(this.entity) === -1)
 		return;
 
 	// This also updates the queued production if necessary.
 	this.CalculateEntitiesMap();
 
 	// Inform the GUI that it'll need to recompute the selection panel.
 	// TODO: it would be better to only send the message if something actually changing
 	// for the current production queue.
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	if (cmpPlayer)
 		Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface).SetSelectionDirty(cmpPlayer.GetPlayerID());
 };
 
 ProductionQueue.prototype.OnDisabledTemplatesChanged = function(msg)
 {
 	// If the disabled templates of the player is changed,
 	// update the entities list so that this is reflected there.
 	this.CalculateEntitiesMap();
 };
 
 Engine.RegisterComponentType(IID_ProductionQueue, "ProductionQueue", ProductionQueue);
Index: ps/trunk/binaries/data/mods/public/simulation/components/Promotion.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Promotion.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Promotion.js	(revision 24050)
@@ -1,134 +1,138 @@
 function Promotion() {}
 
 Promotion.prototype.Schema =
 	"<element name='Entity'>" +
 		"<text/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='TrickleRate' a:help='Trickle of XP gained each second.'>" +
 			"<ref name='nonNegativeDecimal'/>" +
 		"</element>" +
 	"</optional>" +
 	"<element name='RequiredXp'>" +
 		"<data type='positiveInteger'/>" +
 	"</element>";
 
 Promotion.prototype.Init = function()
 {
 	this.currentXp = 0;
 	this.ComputeTrickleRate();
 };
 
 Promotion.prototype.GetRequiredXp = function()
 {
 	return ApplyValueModificationsToEntity("Promotion/RequiredXp", +this.template.RequiredXp, this.entity);
 };
 
 Promotion.prototype.GetCurrentXp = function()
 {
 	return this.currentXp;
 };
 
 Promotion.prototype.GetPromotedTemplateName = function()
 {
 	return this.template.Entity;
 };
 
 Promotion.prototype.Promote = function(promotedTemplateName)
 {
 	// If the unit is dead, don't promote it
 	let cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
 	if (cmpHealth && cmpHealth.GetHitpoints() == 0)
 	{
 		this.promotedUnitEntity = INVALID_ENTITY;
 		return;
 	}
 
 	// Save the entity id.
 	this.promotedUnitEntity = ChangeEntityTemplate(this.entity, promotedTemplateName);
 };
 
 Promotion.prototype.IncreaseXp = function(amount)
 {
 	// if the unit was already promoted, but is waiting for the engine to be destroyed
 	// transfer the gained xp to the promoted unit if applicable
 	if (this.promotedUnitEntity)
 	{
 		let cmpPromotion = Engine.QueryInterface(this.promotedUnitEntity, IID_Promotion);
 		if (cmpPromotion)
 			cmpPromotion.IncreaseXp(amount);
 		return;
 	}
 
-	this.currentXp += +(amount);
-	var requiredXp = this.GetRequiredXp();
+	this.currentXp += +amount;
+	let requiredXp = this.GetRequiredXp();
 
 	if (this.currentXp >= requiredXp)
 	{
-		var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
-		var playerID = QueryOwnerInterface(this.entity, IID_Player).GetPlayerID();
+		let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+		let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+		if (!cmpPlayer)
+			return;
+
+		let playerID = cmpPlayer.GetPlayerID();
 		this.currentXp -= requiredXp;
-		var promotedTemplateName = this.GetPromotedTemplateName();
+		let promotedTemplateName = this.GetPromotedTemplateName();
 		// check if we can upgrade a second time (or even more)
 		while (true)
 		{
-			var template = cmpTemplateManager.GetTemplate(promotedTemplateName);
+			let template = cmpTemplateManager.GetTemplate(promotedTemplateName);
 			if (!template.Promotion)
 				break;
 			requiredXp = ApplyValueModificationsToTemplate("Promotion/RequiredXp", +template.Promotion.RequiredXp, playerID, template);
 			// compare the current xp to the required xp of the promoted entity
 			if (this.currentXp < requiredXp)
 				break;
 			this.currentXp -= requiredXp;
 			promotedTemplateName = template.Promotion.Entity;
 		}
 		this.Promote(promotedTemplateName);
 		let cmpPromotion = Engine.QueryInterface(this.promotedUnitEntity, IID_Promotion);
 		if (cmpPromotion)
 			cmpPromotion.IncreaseXp(this.currentXp);
 	}
 
 	Engine.PostMessage(this.entity, MT_ExperienceChanged, {});
 };
 
 Promotion.prototype.ComputeTrickleRate = function()
 {
 	this.trickleRate = ApplyValueModificationsToEntity("Promotion/TrickleRate", +(this.template.TrickleRate || 0), this.entity);
 	this.CheckTrickleTimer();
 };
 
 Promotion.prototype.CheckTrickleTimer = function()
 {
 	if (!this.trickleRate)
 	{
 		if (this.trickleTimer)
 		{
 			let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 			cmpTimer.CancelTimer(this.trickleTimer);
 			delete this.trickleTimer;
 		}
 		return;
 	}
 
 	if (this.trickleTimer)
 		return;
 
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	this.trickleTimer = cmpTimer.SetInterval(this.entity, IID_Promotion, "TrickleTick", 1000, 1000, null);
 };
 
 Promotion.prototype.TrickleTick = function()
 {
 	this.IncreaseXp(this.trickleRate);
 };
 
 Promotion.prototype.OnValueModification = function(msg)
 {
 	if (msg.component != "Promotion")
 		return;
 
 	this.ComputeTrickleRate();
 	this.IncreaseXp(0);
 };
 
 Engine.RegisterComponentType(IID_Promotion, "Promotion", Promotion);
Index: ps/trunk/binaries/data/mods/public/simulation/components/ResourceGatherer.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/ResourceGatherer.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/ResourceGatherer.js	(revision 24050)
@@ -1,365 +1,366 @@
 function ResourceGatherer() {}
 
 ResourceGatherer.prototype.Schema =
 	"<a:help>Lets the unit gather resources from entities that have the ResourceSupply component.</a:help>" +
 	"<a:example>" +
 		"<MaxDistance>2.0</MaxDistance>" +
 		"<BaseSpeed>1.0</BaseSpeed>" +
 		"<Rates>" +
 			"<food.fish>1</food.fish>" +
 			"<metal.ore>3</metal.ore>" +
 			"<stone.rock>3</stone.rock>" +
 			"<wood.tree>2</wood.tree>" +
 		"</Rates>" +
 		"<Capacities>" +
 			"<food>10</food>" +
 			"<metal>10</metal>" +
 			"<stone>10</stone>" +
 			"<wood>10</wood>" +
 		"</Capacities>" +
 	"</a:example>" +
 	"<element name='MaxDistance' a:help='Max resource-gathering distance'>" +
 		"<ref name='positiveDecimal'/>" +
 	"</element>" +
 	"<element name='BaseSpeed' a:help='Base resource-gathering rate (in resource units per second)'>" +
 		"<ref name='positiveDecimal'/>" +
 	"</element>" +
 	"<element name='Rates' a:help='Per-resource-type gather rate multipliers. If a resource type is not specified then it cannot be gathered by this unit'>" +
 		Resources.BuildSchema("positiveDecimal", ["treasure"], true) +
 	"</element>" +
 	"<element name='Capacities' a:help='Per-resource-type maximum carrying capacity'>" +
 		Resources.BuildSchema("positiveDecimal") +
 	"</element>";
 
 ResourceGatherer.prototype.Init = function()
 {
 	this.carrying = {}; // { generic type: integer amount currently carried }
 	// (Note that this component supports carrying multiple types of resources,
 	// each with an independent capacity, but the rest of the game currently
 	// ensures and assumes we'll only be carrying one type at once)
 
 	// The last exact type gathered, so we can render appropriate props
 	this.lastCarriedType = undefined; // { generic, specific }
 };
 
 /**
  * Returns data about what resources the unit is currently carrying,
  * in the form [ {"type":"wood", "amount":7, "max":10} ]
  */
 ResourceGatherer.prototype.GetCarryingStatus = function()
 {
 	let ret = [];
 	for (let type in this.carrying)
 	{
 		ret.push({
 			"type": type,
 			"amount": this.carrying[type],
 			"max": +this.GetCapacity(type)
 		});
 	}
 	return ret;
 };
 
 /**
  * Used to instantly give resources to unit
  * @param resources The same structure as returned form GetCarryingStatus
  */
 ResourceGatherer.prototype.GiveResources = function(resources)
 {
 	for (let resource of resources)
 		this.carrying[resource.type] = +resource.amount;
 
 	Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 };
 
 /**
  * Returns the generic type of one particular resource this unit is
  * currently carrying, or undefined if none.
  */
 ResourceGatherer.prototype.GetMainCarryingType = function()
 {
 	// Return the first key, if any
 	for (let type in this.carrying)
 		return type;
 
 	return undefined;
 };
 
 /**
  * Returns the exact resource type we last picked up, as long as
  * we're still carrying something similar enough, in the form
  * { generic, specific }
  */
 ResourceGatherer.prototype.GetLastCarriedType = function()
 {
 	if (this.lastCarriedType && this.lastCarriedType.generic in this.carrying)
 		return this.lastCarriedType;
 
 	return undefined;
 };
 
 ResourceGatherer.prototype.SetLastCarriedType = function(lastCarriedType)
 {
 	this.lastCarriedType = lastCarriedType;
 };
 
 // Since this code is very performancecritical and applying technologies quite slow, cache it.
 ResourceGatherer.prototype.RecalculateGatherRatesAndCapacities = function()
 {
 	this.baseSpeed = ApplyValueModificationsToEntity("ResourceGatherer/BaseSpeed", +this.template.BaseSpeed, this.entity);
 
 	this.rates = {};
 	for (let r in this.template.Rates)
 	{
 		let type = r.split(".");
 
 		if (type[0] != "treasure" && type.length > 1 && !Resources.GetResource(type[0]).subtypes[type[1]])
 		{
 			error("Resource subtype not found: " + type[0] + "." + type[1]);
 			continue;
 		}
 
 		let rate = ApplyValueModificationsToEntity("ResourceGatherer/Rates/" + r, +this.template.Rates[r], this.entity);
 		this.rates[r] = rate * this.baseSpeed;
 	}
 
 	this.capacities = {};
 	for (let r in this.template.Capacities)
 		this.capacities[r] = ApplyValueModificationsToEntity("ResourceGatherer/Capacities/" + r, +this.template.Capacities[r], this.entity);
 };
 
 ResourceGatherer.prototype.GetGatherRates = function()
 {
 	return this.rates;
 };
 
 ResourceGatherer.prototype.GetGatherRate = function(resourceType)
 {
 	if (!this.template.Rates[resourceType])
 		return 0;
 
 	return this.rates[resourceType];
 };
 
 ResourceGatherer.prototype.GetCapacity = function(resourceType)
 {
 	if(!this.template.Capacities[resourceType])
 		return 0;
 	return this.capacities[resourceType];
 };
 
 ResourceGatherer.prototype.GetRange = function()
 {
 	return { "max": +this.template.MaxDistance, "min": 0 };
 	// maybe this should depend on the unit or target or something?
 };
 
 /**
  * Try to gather treasure
  * @return 'true' if treasure is successfully gathered, otherwise 'false'
  */
 ResourceGatherer.prototype.TryInstantGather = function(target)
 {
 	let cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
 	let type = cmpResourceSupply.GetType();
 
 	if (type.generic != "treasure")
 		return false;
 
 	let status = cmpResourceSupply.TakeResources(cmpResourceSupply.GetCurrentAmount());
 
 	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
 	if (cmpPlayer)
 		cmpPlayer.AddResource(type.specific, status.amount);
 
 	let cmpStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
 	if (cmpStatisticsTracker)
 		cmpStatisticsTracker.IncreaseTreasuresCollectedCounter();
 
 	let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 	if (cmpTrigger && cmpPlayer)
 		cmpTrigger.CallEvent("TreasureCollected", { "player": cmpPlayer.GetPlayerID(), "type": type.specific, "amount": status.amount });
 
 	return true;
 };
 
 /**
  * Gather from the target entity. This should only be called after a successful range check,
  * and if the target has a compatible ResourceSupply.
  * Call interval will be determined by gather rate, so always gather 1 amount when called.
  */
 ResourceGatherer.prototype.PerformGather = function(target)
 {
 	if (!this.GetTargetGatherRate(target))
 		return { "exhausted": true };
 
 	let gatherAmount = 1;
 
 	let cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
 	let type = cmpResourceSupply.GetType();
 
 	// Initialise the carried count if necessary
 	if (!this.carrying[type.generic])
 		this.carrying[type.generic] = 0;
 
 	// Find the maximum so we won't exceed our capacity
 	let maxGathered = this.GetCapacity(type.generic) - this.carrying[type.generic];
 
 	let status = cmpResourceSupply.TakeResources(Math.min(gatherAmount, maxGathered));
 
 	this.carrying[type.generic] += status.amount;
 
 	this.lastCarriedType = type;
 
 	// Update stats of how much the player collected.
 	// (We have to do it here rather than at the dropsite, because we
 	// need to know what subtype it was)
 	let cmpStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
 	if (cmpStatisticsTracker)
 		cmpStatisticsTracker.IncreaseResourceGatheredCounter(type.generic, status.amount, type.specific);
 
 	Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 
 
 	return {
 		"amount": status.amount,
 		"exhausted": status.exhausted,
 		"filled": this.carrying[type.generic] >= this.GetCapacity(type.generic)
 	};
 };
 
 /**
  * Compute the amount of resources collected per second from the target.
  * Returns 0 if resources cannot be collected (e.g. the target doesn't
  * exist, or is the wrong type).
  */
 ResourceGatherer.prototype.GetTargetGatherRate = function(target)
 {
 	let cmpResourceSupply = QueryMiragedInterface(target, IID_ResourceSupply);
 	if (!cmpResourceSupply)
 		return 0;
 
 	let type = cmpResourceSupply.GetType();
 
 	let rate = 0;
 	if (type.specific)
 		rate = this.GetGatherRate(type.generic+"."+type.specific);
 	if (rate == 0 && type.generic)
 		rate = this.GetGatherRate(type.generic);
 
 	if ("Mirages" in cmpResourceSupply)
 		return rate;
 
 	// Apply diminishing returns with more gatherers, for e.g. infinite farms. For most resources this has no effect
 	// (GetDiminishingReturns will return null). We can assume that for resources that are miraged this is the case
 	// (else just add the diminishing returns data to the mirage data and remove the early return above)
 	let diminishingReturns = cmpResourceSupply.GetDiminishingReturns();
 	if (diminishingReturns)
 		rate *= diminishingReturns;
 
 	return rate;
 };
 
 /**
  * Returns whether this unit can carry more of the given type of resource.
  * (This ignores whether the unit is actually able to gather that
  * resource type or not.)
  */
 ResourceGatherer.prototype.CanCarryMore = function(type)
 {
 	let amount = this.carrying[type] || 0;
 	return amount < this.GetCapacity(type);
 };
 
 
 ResourceGatherer.prototype.IsCarrying = function(type)
 {
 	let amount = this.carrying[type] || 0;
 	return amount > 0;
 };
 
 /**
  * Returns whether this unit is carrying any resources of a type that is
  * not the requested type. (This is to support cases where the unit is
  * only meant to be able to carry one type at once.)
  */
 ResourceGatherer.prototype.IsCarryingAnythingExcept = function(exceptedType)
 {
 	for (let type in this.carrying)
 		if (type != exceptedType)
 			return true;
 
 	return false;
 };
 
 /**
  * Transfer our carried resources to our owner immediately.
  * Only resources of the appropriate types will be transferred.
  * (This should typically be called after reaching a dropsite.)
  *
  * @param {number} target - The target entity ID to drop resources at.
  */
 ResourceGatherer.prototype.CommitResources = function(target)
 {
 	let cmpResourceDropsite = Engine.QueryInterface(target, IID_ResourceDropsite);
 	if (!cmpResourceDropsite)
 		return;
 
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	if (!cmpPlayer)
 		return;
 
 	let changed = false;
 	for (let type in this.carrying)
 		if (cmpResourceDropsite.AcceptsType(type))
 		{
 			cmpPlayer.AddResource(type, this.carrying[type]);
 			delete this.carrying[type];
 			changed = true;
 		}
 
 	if (changed)
 		Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 };
 
 /**
  * Drop all currently-carried resources.
  * (Currently they just vanish after being dropped - we don't bother depositing
  * them onto the ground.)
  */
 ResourceGatherer.prototype.DropResources = function()
 {
 	this.carrying = {};
 
 	Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 };
 
 // Since we cache gather rates, we need to make sure we update them when tech changes.
 // and when our owner change because owners can had different techs.
 ResourceGatherer.prototype.OnValueModification = function(msg)
 {
 	if (msg.component != "ResourceGatherer")
 		return;
 
 	this.RecalculateGatherRatesAndCapacities();
 };
 
 ResourceGatherer.prototype.OnOwnershipChanged = function(msg)
 {
 	if (msg.to == INVALID_PLAYER)
 		return;
 	this.RecalculateGatherRatesAndCapacities();
 };
 
 ResourceGatherer.prototype.OnGlobalInitGame = function(msg)
 {
 	this.RecalculateGatherRatesAndCapacities();
 };
 
 ResourceGatherer.prototype.OnMultiplierChanged = function(msg)
 {
-	if (msg.player == QueryOwnerInterface(this.entity, IID_Player).GetPlayerID())
+	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+	if (cmpPlayer && msg.player == cmpPlayer.GetPlayerID())
 		this.RecalculateGatherRatesAndCapacities();
 };
 
 Engine.RegisterComponentType(IID_ResourceGatherer, "ResourceGatherer", ResourceGatherer);
Index: ps/trunk/binaries/data/mods/public/simulation/components/SkirmishReplacer.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/SkirmishReplacer.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/SkirmishReplacer.js	(revision 24050)
@@ -1,96 +1,99 @@
 function SkirmishReplacer() {}
 
 SkirmishReplacer.prototype.Schema =
 		"<optional>" +
 			"<element name='general' a:help='The general element replaces {civ} with the civ code.'>" +
 				"<interleave>" +
 					"<text/>" +
 				"</interleave>" +
 			"</element>" +
 		"</optional>";
 
 SkirmishReplacer.prototype.Init = function()
 {
 };
 
 SkirmishReplacer.prototype.Serialize = null; // We have no dynamic state to save
 
 function getReplacementEntities(civ)
 {
 	return Engine.ReadJSONFile("simulation/data/civs/" + civ + ".json").SkirmishReplacements;
 }
 
 SkirmishReplacer.prototype.OnOwnershipChanged = function(msg)
 {
 	if (msg.to == 0)
 		warn("Skirmish map elements can only be owned by regular players. Please delete entity "+this.entity+" or change the ownership to a non-gaia player.");
 };
 
 SkirmishReplacer.prototype.ReplaceEntities = function()
 {
 	var cmpPlayer = QueryOwnerInterface(this.entity);
+	if (!cmpPlayer)
+		return;
+
 	var civ = cmpPlayer.GetCiv();
 	var replacementEntities = getReplacementEntities(civ);
 
 	var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	var templateName = cmpTemplateManager.GetCurrentTemplateName(this.entity);
 
 	let specialFilters = templateName.substr(0, templateName.lastIndexOf("|") + 1);
 	templateName = removeFiltersFromTemplateName(templateName);
 
 	if (templateName in replacementEntities)
 		templateName = replacementEntities[templateName];
 	else if (this.template && "general" in this.template)
 		templateName = this.template.general;
 	else
 		templateName = "";
 
 	if (!templateName || civ == "gaia")
 	{
 		Engine.DestroyEntity(this.entity);
 		return;
 	}
 
 	templateName = specialFilters + templateName.replace(/\{civ\}/g, civ);
 
 	var cmpCurPosition = Engine.QueryInterface(this.entity, IID_Position);
 	var replacement = Engine.AddEntity(templateName);
 	if (!replacement)
 	{
 		Engine.DestroyEntity(this.entity);
 		return;
 	}
 	var cmpReplacementPosition = Engine.QueryInterface(replacement, IID_Position);
 	var pos = cmpCurPosition.GetPosition2D();
 	cmpReplacementPosition.JumpTo(pos.x, pos.y);
 	var rot = cmpCurPosition.GetRotation();
 	cmpReplacementPosition.SetYRotation(rot.y);
 	var cmpCurOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	var cmpReplacementOwnership = Engine.QueryInterface(replacement, IID_Ownership);
 	cmpReplacementOwnership.SetOwner(cmpCurOwnership.GetOwner());
 
 	Engine.PostMessage(this.entity, MT_EntityRenamed, { "entity": this.entity, "newentity": replacement });
 	Engine.DestroyEntity(this.entity);
 };
 
 /**
  * Replace this entity with a civ-specific entity
  * Message is sent right before InitGame() is called, in InitGame.js
  * Replacement needs to happen early on real games to not confuse the AI
  */
 SkirmishReplacer.prototype.OnSkirmishReplace = function(msg)
 {
 	this.ReplaceEntities();
 };
 
 /**
  * Replace this entity with a civ-specific entity
  * This is needed for Atlas, when the entity isn't replaced before the game starts,
  * so it needs to be replaced on the first turn.
  */
 SkirmishReplacer.prototype.OnUpdate = function(msg)
 {
 	this.ReplaceEntities();
 };
 
 Engine.RegisterComponentType(IID_SkirmishReplacer, "SkirmishReplacer", SkirmishReplacer);
Index: ps/trunk/binaries/data/mods/public/simulation/components/Trader.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Trader.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Trader.js	(revision 24050)
@@ -1,311 +1,311 @@
 // See helpers/TraderGain.js for the CalculateTaderGain() function which works out how many
 // resources a trader gets
 
 function Trader() {}
 
 Trader.prototype.Schema =
 	"<a:help>Lets the unit generate resouces while moving between markets (or docks in case of water trading).</a:help>" +
 	"<a:example>" +
 		"<GainMultiplier>0.75</GainMultiplier>" +
 		"<GarrisonGainMultiplier>0.2</GarrisonGainMultiplier>" +
 	"</a:example>" +
 	"<element name='GainMultiplier' a:help='Trader gain for a 100m distance and mapSize = 1024'>" +
 		"<ref name='positiveDecimal'/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='GarrisonGainMultiplier' a:help='Additional gain for garrisonable unit for each garrisoned trader (1.0 means 100%)'>" +
 			"<ref name='positiveDecimal'/>" +
 		"</element>" +
 	"</optional>";
 
 Trader.prototype.Init = function()
 {
 	this.markets = [];
 	this.index = -1;
 	this.goods = {
 		"type": null,
 		"amount": null,
 		"origin": null
 	};
 };
 
 Trader.prototype.CalculateGain = function(currentMarket, nextMarket)
 {
 	let gain = CalculateTraderGain(currentMarket, nextMarket, this.template, this.entity);
 	if (!gain)	// One of our markets must have been destroyed
 		return null;
 
 	// For garrisonable unit increase gain for each garrisoned trader
 	// Calculate this here to save passing unnecessary stuff into the CalculateTraderGain function
 	let garrisonGainMultiplier = this.GetGarrisonGainMultiplier();
 	if (garrisonGainMultiplier === undefined)
 		return gain;
 
 	let cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 		return gain;
 
 	let garrisonMultiplier = 1;
 	let garrisonedTradersCount = 0;
 	for (let entity of cmpGarrisonHolder.GetEntities())
 	{
 		let cmpGarrisonedUnitTrader = Engine.QueryInterface(entity, IID_Trader);
 		if (cmpGarrisonedUnitTrader)
 			++garrisonedTradersCount;
 	}
 	garrisonMultiplier *= 1 + garrisonGainMultiplier * garrisonedTradersCount;
 
 	if (gain.traderGain)
 		gain.traderGain = Math.round(garrisonMultiplier * gain.traderGain);
 	if (gain.market1Gain)
 		gain.market1Gain = Math.round(garrisonMultiplier * gain.market1Gain);
 	if (gain.market2Gain)
 		gain.market2Gain = Math.round(garrisonMultiplier * gain.market2Gain);
 
 	return gain;
 };
 
 /**
  * Remove market from trade route iff only first market is set.
  * @param {number} id of market to be removed.
  * @return {boolean} true iff removal was successful.
  */
 Trader.prototype.RemoveTargetMarket = function(target)
 {
 	if (this.markets.length != 1 || this.markets[0] != target)
 		return false;
 	let cmpTargetMarket = QueryMiragedInterface(target, IID_Market);
 	if (!cmpTargetMarket)
 		return false;
 	cmpTargetMarket.RemoveTrader(this.entity);
 	this.index = -1;
 	this.markets = [];
 	return true;
-}
+};
 
 // Set target as target market.
 // Return true if at least one of markets was changed.
 Trader.prototype.SetTargetMarket = function(target, source)
 {
 	let cmpTargetMarket = QueryMiragedInterface(target, IID_Market);
 	if (!cmpTargetMarket)
 		return false;
 
 	if (source)
 	{
 		// Establish a trade route with both markets in one go.
 		let cmpSourceMarket = QueryMiragedInterface(source, IID_Market);
 		if (!cmpSourceMarket)
 			return false;
 		this.markets = [source];
 	}
 	if (this.markets.length >= 2)
 	{
 		// If we already have both markets - drop them
 		// and use the target as first market
 		for (let market of this.markets)
 		{
 			let cmpMarket = QueryMiragedInterface(market, IID_Market);
 			if (cmpMarket)
 				cmpMarket.RemoveTrader(this.entity);
 		}
 		this.index = 0;
 		this.markets = [target];
 		cmpTargetMarket.AddTrader(this.entity);
 	}
 	else if (this.markets.length == 1)
 	{
 		// If we have only one market and target is different from it,
 		// set the target as second one
 		if (target == this.markets[0])
 			return false;
 
 		this.index = 0;
 		this.markets.push(target);
 		cmpTargetMarket.AddTrader(this.entity);
 		this.goods.amount = this.CalculateGain(this.markets[0], this.markets[1]);
 	}
 	else
 	{
 		// Else we don't have target markets at all,
 		// set the target as first market
 		this.index = 0;
 		this.markets = [target];
 		cmpTargetMarket.AddTrader(this.entity);
 	}
 	// Drop carried goods if markets were changed
 	this.goods.amount = null;
 	return true;
 };
 
 Trader.prototype.GetFirstMarket = function()
 {
 	return this.markets[0] || null;
 };
 
 Trader.prototype.GetSecondMarket = function()
 {
 	return this.markets[1] || null;
 };
 
 Trader.prototype.GetTraderGainMultiplier = function()
 {
 	return ApplyValueModificationsToEntity("Trader/GainMultiplier", +this.template.GainMultiplier, this.entity);
 };
 
 Trader.prototype.GetGarrisonGainMultiplier = function()
 {
 	if (this.template.GarrisonGainMultiplier === undefined)
 		return undefined;
 	return ApplyValueModificationsToEntity("Trader/GarrisonGainMultiplier", +this.template.GarrisonGainMultiplier, this.entity);
 };
 
 Trader.prototype.HasBothMarkets = function()
 {
 	return this.markets.length >= 2;
 };
 
 Trader.prototype.CanTrade = function(target)
 {
 	let cmpTraderIdentity = Engine.QueryInterface(this.entity, IID_Identity);
 
 	let cmpTargetMarket = QueryMiragedInterface(target, IID_Market);
 	if (!cmpTargetMarket)
 		return false;
 
 	let cmpTargetFoundation = Engine.QueryInterface(target, IID_Foundation);
 	if (cmpTargetFoundation)
 		return false;
 
 	if (!(cmpTraderIdentity.HasClass("Organic") && cmpTargetMarket.HasType("land")) &&
 		!(cmpTraderIdentity.HasClass("Ship") && cmpTargetMarket.HasType("naval")))
 		return false;
 
 	let cmpTraderPlayer = QueryOwnerInterface(this.entity, IID_Player);
 	let cmpTargetPlayer = QueryOwnerInterface(target, IID_Player);
 
-	return !cmpTraderPlayer.IsEnemy(cmpTargetPlayer.GetPlayerID());
+	return cmpTraderPlayer && cmpTargetPlayer && !cmpTraderPlayer.IsEnemy(cmpTargetPlayer.GetPlayerID());
 };
 
 Trader.prototype.AddResources = function(ent, gain)
 {
 	let cmpPlayer = QueryOwnerInterface(ent);
 	if (cmpPlayer)
 		cmpPlayer.AddResource(this.goods.type, gain);
 
 	let cmpStatisticsTracker = QueryOwnerInterface(ent, IID_StatisticsTracker);
 	if (cmpStatisticsTracker)
 		cmpStatisticsTracker.IncreaseTradeIncomeCounter(gain);
 };
 
 Trader.prototype.GenerateResources = function(currentMarket, nextMarket)
 {
 	this.AddResources(this.entity, this.goods.amount.traderGain);
 
 	if (this.goods.amount.market1Gain)
 		this.AddResources(currentMarket, this.goods.amount.market1Gain);
 
 	if (this.goods.amount.market2Gain)
 		this.AddResources(nextMarket, this.goods.amount.market2Gain);
 };
 
 Trader.prototype.PerformTrade = function(currentMarket)
 {
 	let previousMarket = this.markets[this.index];
 	if (previousMarket != currentMarket)  // Inconsistent markets
 	{
 		this.goods.amount = null;
 		return INVALID_ENTITY;
 	}
 
 	this.index = ++this.index % this.markets.length;
 	let nextMarket = this.markets[this.index];
 
 	if (this.goods.amount && this.goods.amount.traderGain)
 		this.GenerateResources(previousMarket, nextMarket);
 
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	if (!cmpPlayer)
 		return INVALID_ENTITY;
 
 	this.goods.type = cmpPlayer.GetNextTradingGoods();
 	this.goods.amount = this.CalculateGain(currentMarket, nextMarket);
 	this.goods.origin = currentMarket;
 
 	return nextMarket;
 };
 
 Trader.prototype.GetGoods = function()
 {
 	return this.goods;
 };
 
 /**
  * Returns true if the trader has the given market (can be either a market or a mirage)
  */
 Trader.prototype.HasMarket = function(market)
 {
 	return this.markets.indexOf(market) != -1;
 };
 
 /**
  * Remove a market when this trader can no longer trade with it
  */
 Trader.prototype.RemoveMarket = function(market)
 {
 	let index = this.markets.indexOf(market);
 	if (index == -1)
 		return;
 	this.markets.splice(index, 1);
 	let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
 	if (cmpUnitAI)
 		cmpUnitAI.MarketRemoved(market);
 };
 
 /**
  * Switch between a market and its mirage according to visibility
  */
 Trader.prototype.SwitchMarket = function(oldMarket, newMarket)
 {
 	let index = this.markets.indexOf(oldMarket);
 	if (index == -1)
 		return;
 	this.markets[index] = newMarket;
 	let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
 	if (cmpUnitAI)
 		cmpUnitAI.SwitchMarketOrder(oldMarket, newMarket);
 };
 
 Trader.prototype.StopTrading = function()
 {
 	for (let market of this.markets)
 	{
 		let cmpMarket = QueryMiragedInterface(market, IID_Market);
 		if (cmpMarket)
 			cmpMarket.RemoveTrader(this.entity);
 	}
 	this.index = -1;
 	this.markets = [];
 	this.goods.amount = null;
 	this.markets = [];
 };
 
 // Get range in which deals with market are available,
 // i.e. trader should be in no more than MaxDistance from market
 // to be able to trade with it.
 Trader.prototype.GetRange = function()
 {
 	let cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
 	let max = 1;
 	if (cmpObstruction)
 		max += cmpObstruction.GetSize() * 1.5;
 	return { "min": 0, "max": max };
 };
 
 Trader.prototype.OnGarrisonedUnitsChanged = function()
 {
 	if (this.HasBothMarkets())
 		this.goods.amount = this.CalculateGain(this.markets[0], this.markets[1]);
 };
 
 Engine.RegisterComponentType(IID_Trader, "Trader", Trader);
Index: ps/trunk/binaries/data/mods/public/simulation/components/Upgrade.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Upgrade.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Upgrade.js	(revision 24050)
@@ -1,348 +1,348 @@
 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='Variant' a:help='The name of the variant to switch to when upgrading'>" +
 						"<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 != INVALID_PLAYER)
 		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))
+	if (!cmpPlayer || !cmpPlayer.TrySubtractResources(this.expendedResources))
 	{
 		this.expendedResources = {};
 		return false;
 	}
 
 	this.upgrading = template;
 	this.SetUpgradeAnimationVariant();
 
 	// 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);
 
 	// Do not update visual actor if the animation didn't change.
 	let choice = this.upgradeTemplates[this.upgrading];
 	if (choice && this.template[choice].Variant)
 	{
 		let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 		if (cmpVisual)
 			cmpVisual.SelectAnimation("idle", false, 1.0);
 	}
 
 	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;
 
 	return ApplyValueModificationsToEntity("Upgrade/Time", +this.template[choice].Time, this.entity);
 };
 
 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;
 	Engine.PostMessage(this.entity, MT_UpgradeProgressUpdate, null);
 };
 
 Upgrade.prototype.SetUpgradeAnimationVariant = function()
 {
 	let choice = this.upgradeTemplates[this.upgrading];
 
 	if (!choice || !this.template[choice].Variant)
 		return;
 
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (!cmpVisual)
 		return;
 
 	cmpVisual.SelectAnimation(this.template[choice].Variant, false, 1.0);
 };
 
 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: ps/trunk/binaries/data/mods/public/simulation/helpers/Commands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/helpers/Commands.js	(revision 24049)
+++ ps/trunk/binaries/data/mods/public/simulation/helpers/Commands.js	(revision 24050)
@@ -1,1727 +1,1727 @@
 // Setting this to true will display some warnings when commands
 //	are likely to fail, which may be useful for debugging AIs
 var g_DebugCommands = false;
 
 function ProcessCommand(player, cmd)
 {
 	let cmpPlayer = QueryPlayerIDInterface(player);
 	if (!cmpPlayer)
 		return;
 
 	let data = {
 		"cmpPlayer": cmpPlayer,
 		"controlAllUnits": cmpPlayer.CanControlAllUnits()
 	};
 
 	if (cmd.entities)
 		data.entities = FilterEntityList(cmd.entities, player, data.controlAllUnits);
 
 	// Allow focusing the camera on recent commands
 	let commandData = {
 		"type": "playercommand",
 		"players": [player],
 		"cmd": cmd
 	};
 
 	// Save the position, since the GUI event is received after the unit died
 	if (cmd.type == "delete-entities")
 	{
 		let cmpPosition = cmd.entities[0] && Engine.QueryInterface(cmd.entities[0], IID_Position);
 		commandData.position = cmpPosition && cmpPosition.IsInWorld() && cmpPosition.GetPosition2D();
 	}
 
 	let cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	cmpGuiInterface.PushNotification(commandData);
 
 	// Note: checks of UnitAI targets are not robust enough here, as ownership
 	//	can change after the order is issued, they should be checked by UnitAI
 	//	when the specific behavior (e.g. attack, garrison) is performed.
 	// (Also it's not ideal if a command silently fails, it's nicer if UnitAI
 	//	moves the entities closer to the target before giving up.)
 
 	// Now handle various commands
 	if (g_Commands[cmd.type])
 	{
 		var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 		cmpTrigger.CallEvent("PlayerCommand", { "player": player, "cmd": cmd });
 		g_Commands[cmd.type](player, cmd, data);
 	}
 	else
 		error("Invalid command: unknown command type: "+uneval(cmd));
 }
 
 var g_Commands = {
 
 	"aichat": function(player, cmd, data)
 	{
 		var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		var notification = { "players": [player] };
 		for (var key in cmd)
 			notification[key] = cmd[key];
 		cmpGuiInterface.PushNotification(notification);
 	},
 
 	"cheat": function(player, cmd, data)
 	{
 		Cheat(cmd);
 	},
 
 	"diplomacy": function(player, cmd, data)
 	{
 		let cmpCeasefireManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_CeasefireManager);
 		if (data.cmpPlayer.GetLockTeams() ||
 		        cmpCeasefireManager && cmpCeasefireManager.IsCeasefireActive())
 			return;
 
 		switch(cmd.to)
 		{
 		case "ally":
 			data.cmpPlayer.SetAlly(cmd.player);
 			break;
 		case "neutral":
 			data.cmpPlayer.SetNeutral(cmd.player);
 			break;
 		case "enemy":
 			data.cmpPlayer.SetEnemy(cmd.player);
 			break;
 		default:
 			warn("Invalid command: Could not set "+player+" diplomacy status of player "+cmd.player+" to "+cmd.to);
 		}
 
 		var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGuiInterface.PushNotification({
 			"type": "diplomacy",
 			"players": [player],
 			"targetPlayer": cmd.player,
 			"status": cmd.to
 		});
 	},
 
 	"tribute": function(player, cmd, data)
 	{
 		data.cmpPlayer.TributeResource(cmd.player, cmd.amounts);
 	},
 
 	"control-all": function(player, cmd, data)
 	{
 		if (!data.cmpPlayer.GetCheatsEnabled())
 			return;
 
 		var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGuiInterface.PushNotification({
 			"type": "aichat",
 			"players": [player],
 			"message": markForTranslation("(Cheat - control all units)")
 		});
 
 		data.cmpPlayer.SetControlAllUnits(cmd.flag);
 	},
 
 	"reveal-map": function(player, cmd, data)
 	{
 		if (!data.cmpPlayer.GetCheatsEnabled())
 			return;
 
 		var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGuiInterface.PushNotification({
 			"type": "aichat",
 			"players": [player],
 			"message": markForTranslation("(Cheat - reveal map)")
 		});
 
 		// Reveal the map for all players, not just the current player,
 		// primarily to make it obvious to everyone that the player is cheating
 		var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 		cmpRangeManager.SetLosRevealAll(-1, cmd.enable);
 	},
 
 	"walk": function(player, cmd, data)
 	{
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Walk(cmd.x, cmd.z, cmd.queued);
 		});
 	},
 
 	"walk-custom": function(player, cmd, data)
 	{
 		for (let ent in data.entities)
 			GetFormationUnitAIs([data.entities[ent]], player).forEach(cmpUnitAI => {
 				cmpUnitAI.Walk(cmd.targetPositions[ent].x, cmd.targetPositions[ent].y, cmd.queued);
 			});
 	},
 
 	"walk-to-range": function(player, cmd, data)
 	{
 		// Only used by the AI
 		for (let ent of data.entities)
 		{
 			var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			if (cmpUnitAI)
 				cmpUnitAI.WalkToPointRange(cmd.x, cmd.z, cmd.min, cmd.max, cmd.queued);
 		}
 	},
 
 	"attack-walk": function(player, cmd, data)
 	{
 		let allowCapture = cmd.allowCapture || cmd.allowCapture == null;
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.WalkAndFight(cmd.x, cmd.z, cmd.targetClasses, allowCapture, cmd.queued);
 		});
 	},
 
 	"attack-walk-custom": function(player, cmd, data)
 	{
 		let allowCapture = cmd.allowCapture || cmd.allowCapture == null;
 		for (let ent in data.entities)
 			GetFormationUnitAIs([data.entities[ent]], player).forEach(cmpUnitAI => {
 				cmpUnitAI.WalkAndFight(cmd.targetPositions[ent].x, cmd.targetPositions[ent].y, cmd.targetClasses, allowCapture, cmd.queued);
 			});
 	},
 
 	"attack": function(player, cmd, data)
 	{
 		let allowCapture = cmd.allowCapture || cmd.allowCapture == null;
 
 		if (g_DebugCommands && !allowCapture &&
 		   !(IsOwnedByEnemyOfPlayer(player, cmd.target) || IsOwnedByNeutralOfPlayer(player, cmd.target)))
 			warn("Invalid command: attack target is not owned by enemy of player "+player+": "+uneval(cmd));
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Attack(cmd.target, allowCapture, cmd.queued);
 		});
 	},
 
 	"patrol": function(player, cmd, data)
 	{
 		let allowCapture = cmd.allowCapture || cmd.allowCapture == null;
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI =>
 			cmpUnitAI.Patrol(cmd.x, cmd.z, cmd.targetClasses, allowCapture, cmd.queued)
 		);
 	},
 
 	"heal": function(player, cmd, data)
 	{
 		if (g_DebugCommands && !(IsOwnedByPlayer(player, cmd.target) || IsOwnedByAllyOfPlayer(player, cmd.target)))
 			warn("Invalid command: heal target is not owned by player "+player+" or their ally: "+uneval(cmd));
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Heal(cmd.target, cmd.queued);
 		});
 	},
 
 	"repair": function(player, cmd, data)
 	{
 		// This covers both repairing damaged buildings, and constructing unfinished foundations
 		if (g_DebugCommands && !IsOwnedByAllyOfPlayer(player, cmd.target))
 			warn("Invalid command: repair target is not owned by ally of player "+player+": "+uneval(cmd));
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Repair(cmd.target, cmd.autocontinue, cmd.queued);
 		});
 	},
 
 	"gather": function(player, cmd, data)
 	{
 		if (g_DebugCommands && !(IsOwnedByPlayer(player, cmd.target) || IsOwnedByGaia(cmd.target)))
 			warn("Invalid command: resource is not owned by gaia or player "+player+": "+uneval(cmd));
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Gather(cmd.target, cmd.queued);
 		});
 	},
 
 	"gather-near-position": function(player, cmd, data)
 	{
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.GatherNearPosition(cmd.x, cmd.z, cmd.resourceType, cmd.resourceTemplate, cmd.queued);
 		});
 	},
 
 	"returnresource": function(player, cmd, data)
 	{
 		if (g_DebugCommands && !IsOwnedByPlayer(player, cmd.target))
 			warn("Invalid command: dropsite is not owned by player "+player+": "+uneval(cmd));
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.ReturnResource(cmd.target, cmd.queued);
 		});
 	},
 
 	"back-to-work": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			if(!cmpUnitAI || !cmpUnitAI.BackToWork())
 				notifyBackToWorkFailure(player);
 		}
 	},
 
 	"remove-guard": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			if (cmpUnitAI)
 				cmpUnitAI.RemoveGuard();
 		}
 	},
 
 	"train": function(player, cmd, data)
 	{
 		if (!Number.isInteger(cmd.count) || cmd.count <= 0)
 		{
 			warn("Invalid command: can't train " + uneval(cmd.count) + " units");
 			return;
 		}
 
 		// Check entity limits
 		var template = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).GetTemplate(cmd.template);
 		var unitCategory = null;
 		if (template.TrainingRestrictions)
 			unitCategory = template.TrainingRestrictions.Category;
 
 		// Verify that the building(s) can be controlled by the player
 		if (data.entities.length <= 0)
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: training building(s) cannot be controlled by player "+player+": "+uneval(cmd));
 			return;
 		}
 
 		for (let ent of data.entities)
 		{
 			if (unitCategory)
 			{
 				var cmpPlayerEntityLimits = QueryOwnerInterface(ent, IID_EntityLimits);
-				if (!cmpPlayerEntityLimits.AllowedToTrain(unitCategory, cmd.count))
+				if (cmpPlayerEntityLimits && !cmpPlayerEntityLimits.AllowedToTrain(unitCategory, cmd.count))
 				{
 					if (g_DebugCommands)
 						warn(unitCategory + " train limit is reached: " + uneval(cmd));
 					continue;
 				}
 			}
 
 			var cmpTechnologyManager = QueryOwnerInterface(ent, IID_TechnologyManager);
-			if (!cmpTechnologyManager.CanProduce(cmd.template))
+			if (cmpTechnologyManager && !cmpTechnologyManager.CanProduce(cmd.template))
 			{
 				if (g_DebugCommands)
 					warn("Invalid command: training requires unresearched technology: " + uneval(cmd));
 				continue;
 			}
 
 			var queue = Engine.QueryInterface(ent, IID_ProductionQueue);
 			// Check if the building can train the unit
 			// TODO: the AI API does not take promotion technologies into account for the list
 			// of trainable units (taken directly from the unit template). Here is a temporary fix.
 			if (queue && data.cmpPlayer.IsAI())
 			{
 				var list = queue.GetEntitiesList();
 				if (list.indexOf(cmd.template) === -1 && cmd.promoted)
 				{
 					for (var promoted of cmd.promoted)
 					{
 						if (list.indexOf(promoted) === -1)
 							continue;
 						cmd.template = promoted;
 						break;
 					}
 				}
 			}
 			if (queue && queue.GetEntitiesList().indexOf(cmd.template) != -1)
 				if ("metadata" in cmd)
 					queue.AddBatch(cmd.template, "unit", +cmd.count, cmd.metadata);
 				else
 					queue.AddBatch(cmd.template, "unit", +cmd.count);
 		}
 	},
 
 	"research": function(player, cmd, data)
 	{
 		if (!CanControlUnit(cmd.entity, player, data.controlAllUnits))
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: research building cannot be controlled by player "+player+": "+uneval(cmd));
 			return;
 		}
 
 		var cmpTechnologyManager = QueryOwnerInterface(cmd.entity, IID_TechnologyManager);
-		if (!cmpTechnologyManager.CanResearch(cmd.template))
+		if (cmpTechnologyManager && !cmpTechnologyManager.CanResearch(cmd.template))
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: Requirements to research technology are not met: " + uneval(cmd));
 			return;
 		}
 
 		var queue = Engine.QueryInterface(cmd.entity, IID_ProductionQueue);
 		if (queue)
 			queue.AddBatch(cmd.template, "technology");
 	},
 
 	"stop-production": function(player, cmd, data)
 	{
 		if (!CanControlUnit(cmd.entity, player, data.controlAllUnits))
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: production building cannot be controlled by player "+player+": "+uneval(cmd));
 			return;
 		}
 
 		var queue = Engine.QueryInterface(cmd.entity, IID_ProductionQueue);
 		if (queue)
 			queue.RemoveBatch(cmd.id);
 	},
 
 	"construct": function(player, cmd, data)
 	{
 		TryConstructBuilding(player, data.cmpPlayer, data.controlAllUnits, cmd);
 	},
 
 	"construct-wall": function(player, cmd, data)
 	{
 		TryConstructWall(player, data.cmpPlayer, data.controlAllUnits, cmd);
 	},
 
 	"delete-entities": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			if (!data.controlAllUnits)
 			{
 				let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 				if (cmpIdentity && cmpIdentity.IsUndeletable())
 					continue;
 
 				let cmpCapturable = QueryMiragedInterface(ent, IID_Capturable);
 				if (cmpCapturable &&
 				    cmpCapturable.GetCapturePoints()[player] < cmpCapturable.GetMaxCapturePoints() / 2)
 					continue;
 
 				let cmpResourceSupply = QueryMiragedInterface(ent, IID_ResourceSupply);
 				if (cmpResourceSupply && cmpResourceSupply.GetKillBeforeGather())
 					continue;
 			}
 
 			let cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
 			if (cmpMirage)
 			{
 				let cmpMiragedHealth = Engine.QueryInterface(cmpMirage.parent, IID_Health);
 				if (cmpMiragedHealth)
 					cmpMiragedHealth.Kill();
 				else
 					Engine.DestroyEntity(cmpMirage.parent);
 
 				Engine.DestroyEntity(ent);
 				continue;
 			}
 
 			let cmpHealth = Engine.QueryInterface(ent, IID_Health);
 			if (cmpHealth)
 				cmpHealth.Kill();
 			else
 				Engine.DestroyEntity(ent);
 		}
 	},
 
 	"set-rallypoint": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 			if (cmpRallyPoint)
 			{
 				if (!cmd.queued)
 					cmpRallyPoint.Unset();
 
 				cmpRallyPoint.AddPosition(cmd.x, cmd.z);
 				cmpRallyPoint.AddData(clone(cmd.data));
 			}
 		}
 	},
 
 	"unset-rallypoint": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 			if (cmpRallyPoint)
 				cmpRallyPoint.Reset();
 		}
 	},
 
 	"resign": function(player, cmd, data)
 	{
 		data.cmpPlayer.SetState("defeated", markForTranslation("%(player)s has resigned."));
 	},
 
 	"garrison": function(player, cmd, data)
 	{
 		// Verify that the building can be controlled by the player or is mutualAlly
 		if (!CanControlUnitOrIsAlly(cmd.target, player, data.controlAllUnits))
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: garrison target cannot be controlled by player "+player+" (or ally): "+uneval(cmd));
 			return;
 		}
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Garrison(cmd.target, cmd.queued);
 		});
 	},
 
 	"guard": function(player, cmd, data)
 	{
 		// Verify that the target can be controlled by the player or is mutualAlly
 		if (!CanControlUnitOrIsAlly(cmd.target, player, data.controlAllUnits))
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: guard/escort target cannot be controlled by player "+player+": "+uneval(cmd));
 			return;
 		}
 
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Guard(cmd.target, cmd.queued);
 		});
 	},
 
 	"stop": function(player, cmd, data)
 	{
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.Stop(cmd.queued);
 		});
 	},
 
 	"unload": function(player, cmd, data)
 	{
 		// Verify that the building can be controlled by the player or is mutualAlly
 		if (!CanControlUnitOrIsAlly(cmd.garrisonHolder, player, data.controlAllUnits))
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: unload target cannot be controlled by player "+player+" (or ally): "+uneval(cmd));
 			return;
 		}
 
 		var cmpGarrisonHolder = Engine.QueryInterface(cmd.garrisonHolder, IID_GarrisonHolder);
 		var notUngarrisoned = 0;
 
 		// The owner can ungarrison every garrisoned unit
 		if (IsOwnedByPlayer(player, cmd.garrisonHolder))
 			data.entities = cmd.entities;
 
 		for (let ent of data.entities)
 			if (!cmpGarrisonHolder || !cmpGarrisonHolder.Unload(ent))
 				++notUngarrisoned;
 
 		if (notUngarrisoned != 0)
 			notifyUnloadFailure(player, cmd.garrisonHolder);
 	},
 
 	"unload-template": function(player, cmd, data)
 	{
 		var entities = FilterEntityListWithAllies(cmd.garrisonHolders, player, data.controlAllUnits);
 		for (let garrisonHolder of entities)
 		{
 			var cmpGarrisonHolder = Engine.QueryInterface(garrisonHolder, IID_GarrisonHolder);
 			if (cmpGarrisonHolder)
 			{
 				// Only the owner of the garrisonHolder may unload entities from any owners
 				if (!IsOwnedByPlayer(player, garrisonHolder) && !data.controlAllUnits
 				    && player != +cmd.owner)
 						continue;
 
 				if (!cmpGarrisonHolder.UnloadTemplate(cmd.template, cmd.owner, cmd.all))
 					notifyUnloadFailure(player, garrisonHolder);
 			}
 		}
 	},
 
 	"unload-all-by-owner": function(player, cmd, data)
 	{
 		var entities = FilterEntityListWithAllies(cmd.garrisonHolders, player, data.controlAllUnits);
 		for (let garrisonHolder of entities)
 		{
 			var cmpGarrisonHolder = Engine.QueryInterface(garrisonHolder, IID_GarrisonHolder);
 			if (!cmpGarrisonHolder || !cmpGarrisonHolder.UnloadAllByOwner(player))
 				notifyUnloadFailure(player, garrisonHolder);
 		}
 	},
 
 	"unload-all": function(player, cmd, data)
 	{
 		var entities = FilterEntityList(cmd.garrisonHolders, player, data.controlAllUnits);
 		for (let garrisonHolder of entities)
 		{
 			var cmpGarrisonHolder = Engine.QueryInterface(garrisonHolder, IID_GarrisonHolder);
 			if (!cmpGarrisonHolder || !cmpGarrisonHolder.UnloadAll())
 				notifyUnloadFailure(player, garrisonHolder);
 		}
 	},
 
 	"alert-raise": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpAlertRaiser = Engine.QueryInterface(ent, IID_AlertRaiser);
 			if (cmpAlertRaiser)
 				cmpAlertRaiser.RaiseAlert();
 		}
 	},
 
 	"alert-end": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpAlertRaiser = Engine.QueryInterface(ent, IID_AlertRaiser);
 			if (cmpAlertRaiser)
 				cmpAlertRaiser.EndOfAlert();
 		}
 	},
 
 	"formation": function(player, cmd, data)
 	{
 		GetFormationUnitAIs(data.entities, player, cmd.name).forEach(cmpUnitAI => {
 			cmpUnitAI.MoveIntoFormation(cmd);
 		});
 	},
 
 	"promote": function(player, cmd, data)
 	{
 		if (!data.cmpPlayer.GetCheatsEnabled())
 			return;
 
 		var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGuiInterface.PushNotification({
 			"type": "aichat",
 			"players": [player],
 			"message": markForTranslation("(Cheat - promoted units)"),
 			"translateMessage": true
 		});
 
 		for (let ent of cmd.entities)
 		{
 			var cmpPromotion = Engine.QueryInterface(ent, IID_Promotion);
 			if (cmpPromotion)
 				cmpPromotion.IncreaseXp(cmpPromotion.GetRequiredXp() - cmpPromotion.GetCurrentXp());
 		}
 	},
 
 	"stance": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			if (cmpUnitAI && !cmpUnitAI.IsTurret())
 				cmpUnitAI.SwitchToStance(cmd.name);
 		}
 	},
 
 	"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 => {
 			cmpUnitAI.SetupTradeRoute(cmd.target, cmd.source, cmd.route, cmd.queued);
 		});
 	},
 
 	"cancel-setup-trade-route": function(player, cmd, data)
 	{
 		GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
 			cmpUnitAI.CancelSetupTradeRoute(cmd.target);
 		});
 	},
 
 	"set-trading-goods": function(player, cmd, data)
 	{
 		data.cmpPlayer.SetTradingGoods(cmd.tradingGoods);
 	},
 
 	"barter": function(player, cmd, data)
 	{
 		var cmpBarter = Engine.QueryInterface(SYSTEM_ENTITY, IID_Barter);
 		cmpBarter.ExchangeResources(player, cmd.sell, cmd.buy, cmd.amount);
 	},
 
 	"set-shading-color": function(player, cmd, data)
 	{
 		// Prevent multiplayer abuse
 		if (!data.cmpPlayer.IsAI())
 			return;
 
 		// Debug command to make an entity brightly colored
 		for (let ent of cmd.entities)
 		{
 			var cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 			if (cmpVisual)
 				cmpVisual.SetShadingColor(cmd.rgb[0], cmd.rgb[1], cmd.rgb[2], 0); // alpha isn't used so just send 0
 		}
 	},
 
 	"pack": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			if (!cmpUnitAI)
 				continue;
 
 			if (cmd.pack)
 				cmpUnitAI.Pack(cmd.queued);
 			else
 				cmpUnitAI.Unpack(cmd.queued);
 		}
 	},
 
 	"cancel-pack": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			if (!cmpUnitAI)
 				continue;
 
 			if (cmd.pack)
 				cmpUnitAI.CancelPack(cmd.queued);
 			else
 				cmpUnitAI.CancelUnpack(cmd.queued);
 		}
 	},
 
 	"upgrade": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			var cmpUpgrade = Engine.QueryInterface(ent, IID_Upgrade);
 
 			if (!cmpUpgrade || !cmpUpgrade.CanUpgradeTo(cmd.template))
 				continue;
 
 			if (cmpUpgrade.WillCheckPlacementRestrictions(cmd.template) && ObstructionsBlockingTemplateChange(ent, cmd.template))
 			{
 				var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 				cmpGUIInterface.PushNotification({
 					"players": [player],
 					"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": [player],
 					"message": markForTranslation("Cannot upgrade a garrisoned entity.")
 				});
 				continue;
 			}
 
 			// Check entity limits
 			var cmpEntityLimits = QueryPlayerIDInterface(player, IID_EntityLimits);
 			if (cmpEntityLimits && !cmpEntityLimits.AllowedToReplace(ent, cmd.template))
 			{
 				if (g_DebugCommands)
 					warn("Invalid command: build limits check failed for player " + player + ": " + uneval(cmd));
 				continue;
 			}
 
 			let cmpTechnologyManager = QueryOwnerInterface(ent, IID_TechnologyManager);
 			let requiredTechnology = cmpUpgrade.GetRequiredTechnology(cmd.template);
 
 			if (requiredTechnology && (!cmpTechnologyManager || !cmpTechnologyManager.IsTechnologyResearched(requiredTechnology)))
 			{
 				if (g_DebugCommands)
 					warn("Invalid command: upgrading is not possible for this player or requires unresearched technology: " + uneval(cmd));
 				continue;
 			}
 
 			cmpUpgrade.Upgrade(cmd.template, data.cmpPlayer);
 		}
 	},
 
 	"cancel-upgrade": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			let cmpUpgrade = Engine.QueryInterface(ent, IID_Upgrade);
 			if (cmpUpgrade)
 				cmpUpgrade.CancelUpgrade(player);
 		}
 	},
 
 	"attack-request": function(player, cmd, data)
 	{
 		// Send a chat message to human players
 		var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGuiInterface.PushNotification({
 			"type": "aichat",
 			"players": [player],
 			"message": "/allies " + markForTranslation("Attack against %(_player_)s requested."),
 			"translateParameters": ["_player_"],
 			"parameters": { "_player_": cmd.player }
 		});
 
 		// And send an attackRequest event to the AIs
 		let cmpAIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_AIInterface);
 		if (cmpAIInterface)
 			cmpAIInterface.PushEvent("AttackRequest", cmd);
 	},
 
 	"spy-request": function(player, cmd, data)
 	{
 		let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 		let ent = pickRandom(cmpRangeManager.GetEntitiesByPlayer(cmd.player).filter(ent => {
 			let cmpVisionSharing = Engine.QueryInterface(ent, IID_VisionSharing);
 			return cmpVisionSharing && cmpVisionSharing.IsBribable() && !cmpVisionSharing.ShareVisionWith(player);
 		}));
 
 		let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGUIInterface.PushNotification({
 			"type": "spy-response",
 			"players": [player],
 			"target": cmd.player,
 			"entity": ent
 		});
 		if (ent)
 			Engine.QueryInterface(ent, IID_VisionSharing).AddSpy(cmd.source);
 		else
 		{
 			let template = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).GetTemplate("special/spy");
 			IncurBribeCost(template, player, cmd.player, true);
 			// update statistics for failed bribes
 			let cmpBribesStatisticsTracker = QueryPlayerIDInterface(player, IID_StatisticsTracker);
 			if (cmpBribesStatisticsTracker)
 				cmpBribesStatisticsTracker.IncreaseFailedBribesCounter();
 			cmpGUIInterface.PushNotification({
 				"type": "text",
 				"players": [player],
 				"message": markForTranslation("There are no bribable units"),
 				"translateMessage": true
 			});
 		}
 	},
 
 	"diplomacy-request": function(player, cmd, data)
 	{
 		let cmpAIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_AIInterface);
 		if (cmpAIInterface)
 			cmpAIInterface.PushEvent("DiplomacyRequest", cmd);
 	},
 
 	"tribute-request": function(player, cmd, data)
 	{
 		let cmpAIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_AIInterface);
 		if (cmpAIInterface)
 			cmpAIInterface.PushEvent("TributeRequest", cmd);
 	},
 
 	"dialog-answer": function(player, cmd, data)
 	{
 		// Currently nothing. Triggers can read it anyway, and send this
 		// message to any component you like.
 	},
 
 	"set-dropsite-sharing": function(player, cmd, data)
 	{
 		for (let ent of data.entities)
 		{
 			let cmpResourceDropsite = Engine.QueryInterface(ent, IID_ResourceDropsite);
 			if (cmpResourceDropsite && cmpResourceDropsite.IsSharable())
 				cmpResourceDropsite.SetSharing(cmd.shared);
 		}
 	},
 };
 
 /**
  * Sends a GUI notification about unit(s) that failed to ungarrison.
  */
 function notifyUnloadFailure(player, garrisonHolder)
 {
 	var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	cmpGUIInterface.PushNotification({
 		"type": "text",
 		"players": [player],
 		"message": markForTranslation("Unable to ungarrison unit(s)"),
 		"translateMessage": true
 	});
 }
 
 /**
  * Sends a GUI notification about worker(s) that failed to go back to work.
  */
 function notifyBackToWorkFailure(player)
 {
 	var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	cmpGUIInterface.PushNotification({
 		"type": "text",
 		"players": [player],
 		"message": markForTranslation("Some unit(s) can't go back to work"),
 		"translateMessage": true
 	});
 }
 
 /**
  * Get some information about the formations used by entities.
  * The entities must have a UnitAI component.
  */
 function ExtractFormations(ents)
 {
 	var entities = []; // subset of ents that have UnitAI
 	var members = {}; // { formationentity: [ent, ent, ...], ... }
 	for (let ent of ents)
 	{
 		var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		var fid = cmpUnitAI.GetFormationController();
 		if (fid != INVALID_ENTITY)
 		{
 			if (!members[fid])
 				members[fid] = [];
 			members[fid].push(ent);
 		}
 		entities.push(ent);
 	}
 
 	return { "entities": entities, "members": members };
 }
 
 /**
  * Tries to find the best angle to put a dock at a given position
  * Taken from GuiInterface.js
  */
 function GetDockAngle(template, x, z)
 {
 	var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 	var cmpWaterManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_WaterManager);
 	if (!cmpTerrain || !cmpWaterManager)
 		return undefined;
 
 	// Get footprint size
 	var halfSize = 0;
 	if (template.Footprint.Square)
 		halfSize = Math.max(template.Footprint.Square["@depth"], template.Footprint.Square["@width"])/2;
 	else if (template.Footprint.Circle)
 		halfSize = template.Footprint.Circle["@radius"];
 
 	/* Find direction of most open water, algorithm:
 	 *	1. Pick points in a circle around dock
 	 *	2. If point is in water, add to array
 	 *	3. Scan array looking for consecutive points
 	 *	4. Find longest sequence of consecutive points
 	 *	5. If sequence equals all points, no direction can be determined,
 	 *		expand search outward and try (1) again
 	 *	6. Calculate angle using average of sequence
 	 */
 	const numPoints = 16;
 	for (var dist = 0; dist < 4; ++dist)
 	{
 		var waterPoints = [];
 		for (var i = 0; i < numPoints; ++i)
 		{
 			var angle = (i/numPoints)*2*Math.PI;
 			var d = halfSize*(dist+1);
 			var nx = x - d*Math.sin(angle);
 			var nz = z + d*Math.cos(angle);
 
 			if (cmpTerrain.GetGroundLevel(nx, nz) < cmpWaterManager.GetWaterLevel(nx, nz))
 				waterPoints.push(i);
 		}
 		var consec = [];
 		var length = waterPoints.length;
 		if (!length)
 			continue;
 		for (var i = 0; i < length; ++i)
 		{
 			var count = 0;
 			for (let j = 0; j < length - 1; ++j)
 			{
 				if ((waterPoints[(i + j) % length] + 1) % numPoints == waterPoints[(i + j + 1) % length])
 					++count;
 				else
 					break;
 			}
 			consec[i] = count;
 		}
 		var start = 0;
 		var count = 0;
 		for (var c in consec)
 		{
 			if (consec[c] > count)
 			{
 				start = c;
 				count = consec[c];
 			}
 		}
 
 		// If we've found a shoreline, stop searching
 		if (count != numPoints-1)
 			return -((waterPoints[start] + consec[start]/2) % numPoints) / numPoints * 2 * Math.PI;
 	}
 	return undefined;
 }
 
 /**
  * Attempts to construct a building using the specified parameters.
  * Returns true on success, false on failure.
  */
 function TryConstructBuilding(player, cmpPlayer, controlAllUnits, cmd)
 {
 	// Message structure:
 	// {
 	//   "type": "construct",
 	//   "entities": [...],                 // entities that will be ordered to construct the building (if applicable)
 	//   "template": "...",                 // template name of the entity being constructed
 	//   "x": ...,
 	//   "z": ...,
 	//   "angle": ...,
 	//   "metadata": "...",                 // AI metadata of the building
 	//   "actorSeed": ...,
 	//   "autorepair": true,                // whether to automatically start constructing/repairing the new foundation
 	//   "autocontinue": true,              // whether to automatically gather/build/etc after finishing this
 	//   "queued": true,                    // whether to add the construction/repairing of this foundation to entities' queue (if applicable)
 	//   "obstructionControlGroup": ...,    // Optional; the obstruction control group ID that should be set for this building prior to obstruction
 	//                                      // testing to determine placement validity. If specified, must be a valid control group ID (> 0).
 	//   "obstructionControlGroup2": ...,   // Optional; secondary obstruction control group ID that should be set for this building prior to obstruction
 	//                                      // testing to determine placement validity. May be INVALID_ENTITY.
 	// }
 
 	/*
 	 * Construction process:
 	 *  . Take resources away immediately.
 	 *  . Create a foundation entity with 1hp, 0% build progress.
 	 *  . Increase hp and build progress up to 100% when people work on it.
 	 *  . If it's destroyed, an appropriate fraction of the resource cost is refunded.
 	 *  . If it's completed, it gets replaced with the real building.
 	 */
 
 	// Check whether we can control these units
 	var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
 	if (!entities.length)
 		return false;
 
 	var foundationTemplate = "foundation|" + cmd.template;
 
 	// Tentatively create the foundation (we might find later that it's a invalid build command)
 	var ent = Engine.AddEntity(foundationTemplate);
 	if (ent == INVALID_ENTITY)
 	{
 		// Error (e.g. invalid template names)
 		error("Error creating foundation entity for '" + cmd.template + "'");
 		return false;
 	}
 
 	// If it's a dock, get the right angle.
 	var template = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).GetTemplate(cmd.template);
 	var angle = cmd.angle;
 	if (template.BuildRestrictions.PlacementType === "shore")
 	{
 		let angleDock = GetDockAngle(template, cmd.x, cmd.z);
 		if (angleDock !== undefined)
 			angle = angleDock;
 	}
 
 	// Move the foundation to the right place
 	var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	cmpPosition.JumpTo(cmd.x, cmd.z);
 	cmpPosition.SetYRotation(angle);
 
 	// Set the obstruction control group if needed
 	if (cmd.obstructionControlGroup || cmd.obstructionControlGroup2)
 	{
 		var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
 
 		// primary control group must always be valid
 		if (cmd.obstructionControlGroup)
 		{
 			if (cmd.obstructionControlGroup <= 0)
 				warn("[TryConstructBuilding] Invalid primary obstruction control group " + cmd.obstructionControlGroup + " received; must be > 0");
 
 			cmpObstruction.SetControlGroup(cmd.obstructionControlGroup);
 		}
 
 		if (cmd.obstructionControlGroup2)
 			cmpObstruction.SetControlGroup2(cmd.obstructionControlGroup2);
 	}
 
 	// Make it owned by the current player
 	var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 	cmpOwnership.SetOwner(player);
 
 	// Check whether building placement is valid
 	var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 	if (cmpBuildRestrictions)
 	{
 		var ret = cmpBuildRestrictions.CheckPlacement();
 		if (!ret.success)
 		{
 			if (g_DebugCommands)
 				warn("Invalid command: build restrictions check failed with '"+ret.message+"' for player "+player+": "+uneval(cmd));
 
 			var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 			ret.players = [player];
 			cmpGuiInterface.PushNotification(ret);
 
 			// Remove the foundation because the construction was aborted
 			// move it out of world because it's not destroyed immediately.
 			cmpPosition.MoveOutOfWorld();
 			Engine.DestroyEntity(ent);
 			return false;
 		}
 	}
 	else
 		error("cmpBuildRestrictions not defined");
 
 	// Check entity limits
 	var cmpEntityLimits = QueryPlayerIDInterface(player, IID_EntityLimits);
 	if (cmpEntityLimits && !cmpEntityLimits.AllowedToBuild(cmpBuildRestrictions.GetCategory()))
 	{
 		if (g_DebugCommands)
 			warn("Invalid command: build limits check failed for player "+player+": "+uneval(cmd));
 
 		// Remove the foundation because the construction was aborted
 		cmpPosition.MoveOutOfWorld();
 		Engine.DestroyEntity(ent);
 		return false;
 	}
 
 	var cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
 	if (cmpTechnologyManager && !cmpTechnologyManager.CanProduce(cmd.template))
 	{
 		if (g_DebugCommands)
 			warn("Invalid command: required technology check failed for player "+player+": "+uneval(cmd));
 
 		var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGuiInterface.PushNotification({
 			"type": "text",
 			"players": [player],
 			"message": markForTranslation("The building's technology requirements are not met."),
 			"translateMessage": true
 		});
 
 		// Remove the foundation because the construction was aborted
 		cmpPosition.MoveOutOfWorld();
 		Engine.DestroyEntity(ent);
 	}
 
 	// We need the cost after tech and aura modifications
 	// To calculate this with an entity requires ownership, so use the template instead
 	let cmpCost = Engine.QueryInterface(ent, IID_Cost);
 	let costs = cmpCost.GetResourceCosts(player);
 
 	if (!cmpPlayer.TrySubtractResources(costs))
 	{
 		if (g_DebugCommands)
 			warn("Invalid command: building cost check failed for player "+player+": "+uneval(cmd));
 
 		Engine.DestroyEntity(ent);
 		cmpPosition.MoveOutOfWorld();
 		return false;
 	}
 
 	var cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 	if (cmpVisual && cmd.actorSeed !== undefined)
 		cmpVisual.SetActorSeed(cmd.actorSeed);
 
 	// Initialise the foundation
 	var cmpFoundation = Engine.QueryInterface(ent, IID_Foundation);
 	cmpFoundation.InitialiseConstruction(player, cmd.template);
 
 	// send Metadata info if any
 	if (cmd.metadata)
 		Engine.PostMessage(ent, MT_AIMetadata, { "id": ent, "metadata" : cmd.metadata, "owner" : player } );
 
 	// Tell the units to start building this new entity
 	if (cmd.autorepair)
 	{
 		ProcessCommand(player, {
 			"type": "repair",
 			"entities": entities,
 			"target": ent,
 			"autocontinue": cmd.autocontinue,
 			"queued": cmd.queued
 		});
 	}
 
 	return ent;
 }
 
 function TryConstructWall(player, cmpPlayer, controlAllUnits, cmd)
 {
 	// 'cmd' message structure:
 	// {
 	//   "type": "construct-wall",
 	//   "entities": [...],           // entities that will be ordered to construct the wall (if applicable)
 	//   "pieces": [                  // ordered list of information about the pieces making up the wall (towers, wall segments, ...)
 	//      {
 	//         "template": "...",     // one of the templates from the wallset
 	//         "x": ...,
 	//         "z": ...,
 	//         "angle": ...,
 	//      },
 	//      ...
 	//   ],
 	//   "wallSet": {
 	//      "templates": {
 	//        "tower":                // tower template name
 	//        "long":                 // long wall segment template name
 	//        ...                     // etc.
 	//      },
 	//      "maxTowerOverlap": ...,
 	//      "minTowerOverlap": ...,
 	//   },
 	//   "startSnappedEntity":        // optional; entity ID of tower being snapped to at the starting side of the wall
 	//   "endSnappedEntity":          // optional; entity ID of tower being snapped to at the ending side of the wall
 	//   "autorepair": true,          // whether to automatically start constructing/repairing the new foundation
 	//   "autocontinue": true,        // whether to automatically gather/build/etc after finishing this
 	//   "queued": true,              // whether to add the construction/repairing of this wall's pieces to entities' queue (if applicable)
 	// }
 
 	if (cmd.pieces.length <= 0)
 		return;
 
 	if (cmd.startSnappedEntity && cmd.pieces[0].template == cmd.wallSet.templates.tower)
 	{
 		error("[TryConstructWall] Starting wall piece cannot be a tower (" + cmd.wallSet.templates.tower + ") when snapping at the starting side");
 		return;
 	}
 
 	if (cmd.endSnappedEntity && cmd.pieces[cmd.pieces.length - 1].template == cmd.wallSet.templates.tower)
 	{
 		error("[TryConstructWall] Ending wall piece cannot be a tower (" + cmd.wallSet.templates.tower + ") when snapping at the ending side");
 		return;
 	}
 
 	// Assign obstruction control groups to allow the wall pieces to mutually overlap during foundation placement
 	// and during construction. The scheme here is that whatever wall pieces are inbetween two towers inherit the control
 	// groups of both of the towers they are connected to (either newly constructed ones as part of the wall, or existing
 	// towers in the case of snapping). The towers themselves all keep their default unique control groups.
 
 	// To support this, every non-tower piece registers the entity ID of the towers (or foundations thereof) that neighbour
 	// it on either side. Specifically, each non-tower wall piece has its primary control group set equal to that of the
 	// first tower encountered towards the starting side of the wall, and its secondary control group set equal to that of
 	// the first tower encountered towards the ending side of the wall (if any).
 
 	// We can't build the whole wall at once by linearly stepping through the wall pieces and build them, because the
 	// wall segments may/will need the entity IDs of towers that come afterwards. So, build it in two passes:
 	//
 	//   FIRST PASS:
 	//    - Go from start to end and construct wall piece foundations as far as we can without running into a piece that
 	//        cannot be built (e.g. because it is obstructed). At each non-tower, set the most recently built tower's ID
 	//        as the primary control group, thus allowing it to be built overlapping the previous piece.
 	//    - If we encounter a new tower along the way (which will gain its own control group), do the following:
 	//        o First build it using temporarily the same control group of the previous (non-tower) piece
 	//        o Set the previous piece's secondary control group to the tower's entity ID
 	//        o Restore the primary control group of the constructed tower back its original (unique) value.
 	//      The temporary control group is necessary to allow the newer tower with its unique control group ID to be able
 	//        to be placed while overlapping the previous piece.
 	//
 	//   SECOND PASS:
 	//    - Go end to start from the last successfully placed wall piece (which might be a tower we backtracked to), this
 	//      time registering the right neighbouring tower in each non-tower piece.
 
 	// first pass; L -> R
 
 	var lastTowerIndex = -1; // index of the last tower we've encountered in cmd.pieces
 	var lastTowerControlGroup = null; // control group of the last tower we've encountered, to assign to non-tower pieces
 
 	// If we're snapping to an existing entity at the starting end, set lastTowerControlGroup to its control group ID so that
 	// the first wall piece can be built while overlapping it.
 	if (cmd.startSnappedEntity)
 	{
 		var cmpSnappedStartObstruction = Engine.QueryInterface(cmd.startSnappedEntity, IID_Obstruction);
 		if (!cmpSnappedStartObstruction)
 		{
 			error("[TryConstructWall] Snapped entity on starting side does not have an obstruction component");
 			return;
 		}
 
 		lastTowerControlGroup = cmpSnappedStartObstruction.GetControlGroup();
 		//warn("setting lastTowerControlGroup to control group of start snapped entity " + cmd.startSnappedEntity + ": " + lastTowerControlGroup);
 	}
 
 	var i = 0;
 	var queued = cmd.queued;
 	var pieces = clone(cmd.pieces);
 	for (; i < pieces.length; ++i)
 	{
 		var piece = pieces[i];
 
 		// All wall pieces after the first must be queued.
 		if (i > 0 && !queued)
 			queued = true;
 
 		// 'lastTowerControlGroup' must always be defined and valid here, except if we're at the first piece and we didn't do
 		// start position snapping (implying that the first entity we build must be a tower)
 		if (lastTowerControlGroup === null || lastTowerControlGroup == INVALID_ENTITY)
 		{
 			if (!(i == 0 && piece.template == cmd.wallSet.templates.tower && !cmd.startSnappedEntity))
 			{
     			error("[TryConstructWall] Expected last tower control group to be available, none found (1st pass, iteration " + i + ")");
     			break;
 			}
 		}
 
 		var constructPieceCmd = {
 			"type": "construct",
 			"entities": cmd.entities,
 			"template": piece.template,
 			"x": piece.x,
 			"z": piece.z,
 			"angle": piece.angle,
 			"autorepair": cmd.autorepair,
 			"autocontinue": cmd.autocontinue,
 			"queued": queued,
 			// Regardless of whether we're building a tower or an intermediate wall piece, it is always (first) constructed
 			// using the control group of the last tower (see comments above).
 			"obstructionControlGroup": lastTowerControlGroup,
 		};
 
 		// If we're building the last piece and we're attaching to a snapped entity, we need to add in the snapped entity's
 		// control group directly at construction time (instead of setting it in the second pass) to allow it to be built
 		// while overlapping the snapped entity.
 		if (i == pieces.length - 1 && cmd.endSnappedEntity)
 		{
 			var cmpEndSnappedObstruction = Engine.QueryInterface(cmd.endSnappedEntity, IID_Obstruction);
 			if (cmpEndSnappedObstruction)
 				constructPieceCmd.obstructionControlGroup2 = cmpEndSnappedObstruction.GetControlGroup();
 		}
 
 		var pieceEntityId = TryConstructBuilding(player, cmpPlayer, controlAllUnits, constructPieceCmd);
 		if (pieceEntityId)
 		{
 			// wall piece foundation successfully built, save the entity ID in the piece info object so we can reference it later
 			piece.ent = pieceEntityId;
 
 			// if we built a tower, do the control group dance (see outline above) and update lastTowerControlGroup and lastTowerIndex
 			if (piece.template == cmd.wallSet.templates.tower)
 			{
 				var cmpTowerObstruction = Engine.QueryInterface(pieceEntityId, IID_Obstruction);
 				var newTowerControlGroup = pieceEntityId;
 
 				if (i > 0)
 				{
 					//warn("   updating previous wall piece's secondary control group to " + newTowerControlGroup);
 					var cmpPreviousObstruction = Engine.QueryInterface(pieces[i-1].ent, IID_Obstruction);
 					// TODO: ensure that cmpPreviousObstruction exists
 					// TODO: ensure that the previous obstruction does not yet have a secondary control group set
 					cmpPreviousObstruction.SetControlGroup2(newTowerControlGroup);
 				}
 
 				// TODO: ensure that cmpTowerObstruction exists
 				cmpTowerObstruction.SetControlGroup(newTowerControlGroup); // give the tower its own unique control group
 
 				lastTowerIndex = i;
 				lastTowerControlGroup = newTowerControlGroup;
 			}
 		}
 		else // failed to build wall piece, abort
 			break;
 	}
 
 	var lastBuiltPieceIndex = i - 1;
 	var wallComplete = (lastBuiltPieceIndex == pieces.length - 1);
 
 	// At this point, 'i' is the index of the last wall piece that was successfully constructed (which may or may not be a tower).
 	// Now do the second pass going right-to-left, registering the control groups of the towers to the right of each piece (if any)
 	// as their secondary control groups.
 
 	lastTowerControlGroup = null; // control group of the last tower we've encountered, to assign to non-tower pieces
 
 	// only start off with the ending side's snapped tower's control group if we were able to build the entire wall
 	if (cmd.endSnappedEntity && wallComplete)
 	{
 		var cmpSnappedEndObstruction = Engine.QueryInterface(cmd.endSnappedEntity, IID_Obstruction);
 		if (!cmpSnappedEndObstruction)
 		{
 			error("[TryConstructWall] Snapped entity on ending side does not have an obstruction component");
 			return;
 		}
 
 		lastTowerControlGroup = cmpSnappedEndObstruction.GetControlGroup();
 	}
 
 	for (var j = lastBuiltPieceIndex; j >= 0; --j)
 	{
 		var piece = pieces[j];
 
 		if (!piece.ent)
 		{
 			error("[TryConstructWall] No entity ID set for constructed entity of template '" + piece.template + "'");
 			continue;
 		}
 
 		var cmpPieceObstruction = Engine.QueryInterface(piece.ent, IID_Obstruction);
 		if (!cmpPieceObstruction)
 		{
 			error("[TryConstructWall] Wall piece of template '" + piece.template + "' has no Obstruction component");
 			continue;
 		}
 
 		if (piece.template == cmd.wallSet.templates.tower)
 		{
 			// encountered a tower entity, update the last tower control group
 			lastTowerControlGroup = cmpPieceObstruction.GetControlGroup();
 		}
 		else
 		{
 			// Encountered a non-tower entity, update its secondary control group to 'lastTowerControlGroup'.
 			// Note that the wall piece may already have its secondary control group set to the tower's entity ID from a control group
 			// dance during the first pass, in which case we should validate it against 'lastTowerControlGroup'.
 
 			var existingSecondaryControlGroup = cmpPieceObstruction.GetControlGroup2();
 			if (existingSecondaryControlGroup == INVALID_ENTITY)
 			{
 				if (lastTowerControlGroup != null && lastTowerControlGroup != INVALID_ENTITY)
 				{
 					cmpPieceObstruction.SetControlGroup2(lastTowerControlGroup);
 				}
 			}
 			else if (existingSecondaryControlGroup != lastTowerControlGroup)
 			{
 				error("[TryConstructWall] Existing secondary control group of non-tower entity does not match expected value (2nd pass, iteration " + j + ")");
 				break;
 			}
 		}
 	}
 }
 
 /**
  * Remove the given list of entities from their current formations.
  */
 function RemoveFromFormation(ents)
 {
 	var formation = ExtractFormations(ents);
 	for (var fid in formation.members)
 	{
 		var cmpFormation = Engine.QueryInterface(+fid, IID_Formation);
 		if (cmpFormation)
 			cmpFormation.RemoveMembers(formation.members[fid]);
 	}
 }
 
 /**
  * Returns a list of UnitAI components, each belonging either to a
  * selected unit or to a formation entity for groups of the selected units.
  */
 function GetFormationUnitAIs(ents, player, formationTemplate)
 {
 	// If an individual was selected, remove it from any formation
 	// and command it individually
 	if (ents.length == 1)
 	{
 		// Skip unit if it has no UnitAI
 		var cmpUnitAI = Engine.QueryInterface(ents[0], IID_UnitAI);
 		if (!cmpUnitAI)
 			return [];
 
 		RemoveFromFormation(ents);
 
 		return [ cmpUnitAI ];
 	}
 
 	// Separate out the units that don't support the chosen formation
 	var formedEnts = [];
 	var nonformedUnitAIs = [];
 	for (let ent of ents)
 	{
 		// Skip units with no UnitAI or no position
 		var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 		if (!cmpUnitAI || !cmpPosition || !cmpPosition.IsInWorld())
 			continue;
 
 		var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 		// TODO: We only check if the formation is usable by some units
 		// if we move them to it. We should check if we can use formations
 		// for the other cases.
 		var nullFormation = (formationTemplate || cmpUnitAI.GetFormationTemplate()) == "special/formations/null";
 		if (!nullFormation && cmpIdentity && cmpIdentity.CanUseFormation(formationTemplate || "special/formations/null"))
 			formedEnts.push(ent);
 		else
 		{
 			if (nullFormation)
 				RemoveFromFormation([ent]);
 
 			nonformedUnitAIs.push(cmpUnitAI);
 		}
 	}
 
 	if (formedEnts.length == 0)
 	{
 		// No units support the formation - return all the others
 		return nonformedUnitAIs;
 	}
 
 	// Find what formations the formationable selected entities are currently in
 	var formation = ExtractFormations(formedEnts);
 
 	var formationUnitAIs = [];
 	let formationIds = Object.keys(formation.members);
 	if (formationIds.length == 1)
 	{
 		// Selected units either belong to this formation or have no formation
 		// Check that all its members are selected
 		var fid = formationIds[0];
 		var cmpFormation = Engine.QueryInterface(+fid, IID_Formation);
 		if (cmpFormation && cmpFormation.GetMemberCount() == formation.members[fid].length
 			&& cmpFormation.GetMemberCount() == formation.entities.length)
 		{
 			cmpFormation.DeleteTwinFormations();
 			// The whole formation was selected, so reuse its controller for this command
 			formationUnitAIs = [Engine.QueryInterface(+fid, IID_UnitAI)];
 			if (formationTemplate && CanMoveEntsIntoFormation(formation.entities, formationTemplate))
 				cmpFormation.LoadFormation(formationTemplate);
 		}
 	}
 
 	if (!formationUnitAIs.length)
 	{
 		// We need to give the selected units a new formation controller
 
 		// TODO replace the fixed 60 with something sensible, based on vision range f.e.
 		var formationSeparation = 60;
 		var clusters = ClusterEntities(formation.entities, formationSeparation);
 		var formationEnts = [];
 		for (let cluster of clusters)
 		{
 			if (!formationTemplate || !CanMoveEntsIntoFormation(cluster, formationTemplate))
 			{
 				// Use the last formation template if everyone was using it
 				var lastFormationTemplate = undefined;
 				for (let ent of cluster)
 				{
 					var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 					if (cmpUnitAI)
 					{
 						var template = cmpUnitAI.GetFormationTemplate();
 						if (lastFormationTemplate === undefined)
 						{
 							lastFormationTemplate = template;
 						}
 						else if (lastFormationTemplate != template)
 						{
 							lastFormationTemplate = undefined;
 							break;
 						}
 					}
 				}
 				if (lastFormationTemplate && CanMoveEntsIntoFormation(cluster, lastFormationTemplate))
 					formationTemplate = lastFormationTemplate;
 				else
 					formationTemplate = "special/formations/null";
 			}
 
 			RemoveFromFormation(cluster);
 
 			if (formationTemplate == "special/formations/null")
 			{
 				for (let ent of cluster)
 					nonformedUnitAIs.push(Engine.QueryInterface(ent, IID_UnitAI));
 
 				continue;
 			}
 
 			// Create the new controller
 			var formationEnt = Engine.AddEntity(formationTemplate);
 			var cmpFormation = Engine.QueryInterface(formationEnt, IID_Formation);
 			formationUnitAIs.push(Engine.QueryInterface(formationEnt, IID_UnitAI));
 			cmpFormation.SetFormationSeparation(formationSeparation);
 			cmpFormation.SetMembers(cluster);
 
 			for (let ent of formationEnts)
 				cmpFormation.RegisterTwinFormation(ent);
 
 			formationEnts.push(formationEnt);
 			var cmpOwnership = Engine.QueryInterface(formationEnt, IID_Ownership);
 			cmpOwnership.SetOwner(player);
 		}
 	}
 
 	return nonformedUnitAIs.concat(formationUnitAIs);
 }
 
 /**
  * Group a list of entities in clusters via single-links
  */
 function ClusterEntities(ents, separationDistance)
 {
 	let clusters = [];
 	if (!ents.length)
 		return clusters;
 
 	let distSq = separationDistance * separationDistance;
 	let positions = [];
 	// triangular matrix with the (squared) distances between the different clusters
 	// the other half is not initialised
 	let matrix = [];
 	for (let i = 0; i < ents.length; ++i)
 	{
 		matrix[i] = [];
 		clusters.push([ents[i]]);
 		let cmpPosition = Engine.QueryInterface(ents[i], IID_Position);
 		positions.push(cmpPosition.GetPosition2D());
 		for (let j = 0; j < i; ++j)
 			matrix[i][j] = positions[i].distanceToSquared(positions[j]);
 	}
 	while (clusters.length > 1)
 	{
 		// search two clusters that are closer than the required distance
 		let closeClusters = undefined;
 
 		for (let i = matrix.length - 1; i >= 0 && !closeClusters; --i)
 			for (let j = i - 1; j >= 0 && !closeClusters; --j)
 				if (matrix[i][j] < distSq)
 					closeClusters = [i,j];
 
 		// if no more close clusters found, just return all found clusters so far
 		if (!closeClusters)
 			return clusters;
 
 		// make a new cluster with the entities from the two found clusters
 		let newCluster = clusters[closeClusters[0]].concat(clusters[closeClusters[1]]);
 
 		// calculate the minimum distance between the new cluster and all other remaining
 		// clusters by taking the minimum of the two distances.
 		let distances = [];
 		for (let i = 0; i < clusters.length; ++i)
 		{
 			let a = closeClusters[1];
 			let b = closeClusters[0];
 			if (i == a || i == b)
 				continue;
 			let dist1 = matrix[a][i] !== undefined ? matrix[a][i] : matrix[i][a];
 			let dist2 = matrix[b][i] !== undefined ? matrix[b][i] : matrix[i][b];
 			distances.push(Math.min(dist1, dist2));
 		}
 		// remove the rows and columns in the matrix for the merged clusters,
 		// and the clusters themselves from the cluster list
 		clusters.splice(closeClusters[0],1);
 		clusters.splice(closeClusters[1],1);
 		matrix.splice(closeClusters[0],1);
 		matrix.splice(closeClusters[1],1);
 		for (let i = 0; i < matrix.length; ++i)
 		{
 			if (matrix[i].length > closeClusters[0])
 				matrix[i].splice(closeClusters[0],1);
 			if (matrix[i].length > closeClusters[1])
 				matrix[i].splice(closeClusters[1],1);
 		}
 		// add a new row of distances to the matrix and the new cluster
 		clusters.push(newCluster);
 		matrix.push(distances);
 	}
 	return clusters;
 }
 
 function GetFormationRequirements(formationTemplate)
 {
 	var template = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).GetTemplate(formationTemplate);
 	if (!template.Formation)
 		return false;
 
 	return { "minCount": +template.Formation.RequiredMemberCount };
 }
 
 
 function CanMoveEntsIntoFormation(ents, formationTemplate)
 {
 	// TODO: should check the player's civ is allowed to use this formation
 	// See simulation/components/Player.js GetFormations() for a list of all allowed formations
 
 	var requirements = GetFormationRequirements(formationTemplate);
 	if (!requirements)
 		return false;
 
 	var count = 0;
 	for (let ent of ents)
 	{
 		var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 		if (!cmpIdentity || !cmpIdentity.CanUseFormation(formationTemplate))
 			continue;
 
 		++count;
 	}
 
 	return count >= requirements.minCount;
 }
 
 /**
  * Check if player can control this entity
  * returns: true if the entity is valid and owned by the player
  *          or control all units is activated, else false
  */
 function CanControlUnit(entity, player, controlAll)
 {
 	return IsOwnedByPlayer(player, entity) || controlAll;
 }
 
 /**
  * Check if player can control this entity
  * returns: true if the entity is valid and owned by the player
  *          or the entity is owned by an mutualAlly
  *          or control all units is activated, else false
  */
 function CanControlUnitOrIsAlly(entity, player, controlAll)
 {
 	return IsOwnedByPlayer(player, entity) || IsOwnedByMutualAllyOfPlayer(player, entity) || controlAll;
 }
 
 /**
  * Filter entities which the player can control
  */
 function FilterEntityList(entities, player, controlAll)
 {
 	return entities.filter(ent => CanControlUnit(ent, player, controlAll));
 }
 
 /**
  * Filter entities which the player can control or are mutualAlly
  */
 function FilterEntityListWithAllies(entities, player, controlAll)
 {
 	return entities.filter(ent => CanControlUnitOrIsAlly(ent, player, controlAll));
 }
 
 /**
  * Incur the player with the cost of a bribe, optionally multiply the cost with
  * the additionalMultiplier
  */
 function IncurBribeCost(template, player, playerBribed, failedBribe)
 {
 	let cmpPlayerBribed = QueryPlayerIDInterface(playerBribed);
 	if (!cmpPlayerBribed)
 		return false;
 
 	let costs = {};
 	// Additional cost for this owner
 	let multiplier = cmpPlayerBribed.GetSpyCostMultiplier();
 	if (failedBribe)
 		multiplier *= template.VisionSharing.FailureCostRatio;
 
 	for (let res in template.Cost.Resources)
 		costs[res] = Math.floor(multiplier * ApplyValueModificationsToTemplate("Cost/Resources/" + res, +template.Cost.Resources[res], player, template));
 
 	let cmpPlayer = QueryPlayerIDInterface(player);
 	return cmpPlayer && cmpPlayer.TrySubtractResources(costs);
 }
 
 Engine.RegisterGlobal("GetFormationRequirements", GetFormationRequirements);
 Engine.RegisterGlobal("CanMoveEntsIntoFormation", CanMoveEntsIntoFormation);
 Engine.RegisterGlobal("GetDockAngle", GetDockAngle);
 Engine.RegisterGlobal("ProcessCommand", ProcessCommand);
 Engine.RegisterGlobal("g_Commands", g_Commands);
 Engine.RegisterGlobal("IncurBribeCost", IncurBribeCost);