Index: ps/trunk/binaries/data/mods/public/maps/scripts/TriggerHelper.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/scripts/TriggerHelper.js	(revision 25068)
+++ ps/trunk/binaries/data/mods/public/maps/scripts/TriggerHelper.js	(revision 25069)
@@ -1,521 +1,521 @@
 // Contains standardized functions suitable for using in trigger scripts.
 // Do not use them in any other simulation script.
 
 var TriggerHelper = {};
 
 TriggerHelper.GetPlayerIDFromEntity = function(ent)
 {
 	let cmpPlayer = Engine.QueryInterface(ent, IID_Player);
 	if (cmpPlayer)
 		return cmpPlayer.GetPlayerID();
 
 	return -1;
 };
 
 TriggerHelper.IsInWorld = function(ent)
 {
 	let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	return cmpPosition && cmpPosition.IsInWorld();
 };
 
 TriggerHelper.GetEntityPosition2D = function(ent)
 {
 	let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return undefined;
 
 	return cmpPosition.GetPosition2D();
 };
 
 TriggerHelper.GetOwner = function(ent)
 {
 	let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 	if (cmpOwnership)
 		return cmpOwnership.GetOwner();
 
 	return -1;
 };
 
 /**
  * This returns the mapsize in number of tiles, the value corresponding to map_sizes.json, also used by random map scripts.
  */
 TriggerHelper.GetMapSizeTiles = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain).GetTilesPerSide();
 };
 
 /**
  * This returns the mapsize in the the coordinate system used in the simulation/, especially cmpPosition.
  */
 TriggerHelper.GetMapSizeTerrain = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain).GetMapSize();
 };
 
 /**
  * Returns the elapsed ingame time in milliseconds since the gamestart.
  */
 TriggerHelper.GetTime = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
 };
 
- /**
+/**
   * Returns the elpased ingame time in minutes since the gamestart. Useful for balancing.
   */
 TriggerHelper.GetMinutes = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime() / 60 / 1000;
 };
 
 TriggerHelper.GetEntitiesByPlayer = function(playerID)
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetEntitiesByPlayer(playerID);
 };
 
 TriggerHelper.GetAllPlayersEntities = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetNonGaiaEntities();
 };
 
 TriggerHelper.SetUnitStance = function(ent, stance)
 {
 	let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 	if (cmpUnitAI)
 		cmpUnitAI.SwitchToStance(stance);
 };
 
 TriggerHelper.SetUnitFormation = function(playerID, entities, formation)
 {
 	ProcessCommand(playerID, {
 		"type": "formation",
 		"entities": entities,
 		"name": formation
 	});
 };
 
 /**
  * Can be used to "force" a building/unit to spawn a group of entities.
  *
  * @param source Entity id of the point where they will be spawned from
  * @param template Name of the template
  * @param count Number of units to spawn
  * @param owner Player id of the owner of the new units. By default, the owner
  * of the source entity.
  */
 TriggerHelper.SpawnUnits = function(source, template, count, owner)
 {
 	let entities = [];
 	let cmpFootprint = Engine.QueryInterface(source, IID_Footprint);
 	let cmpPosition = Engine.QueryInterface(source, IID_Position);
 
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 	{
 		error("tried to create entity from a source without position");
 		return entities;
 	}
 
 	if (owner == null)
 		owner = TriggerHelper.GetOwner(source);
 
 	for (let i = 0; i < count; ++i)
 	{
 		let ent = Engine.AddEntity(template);
 		let cmpEntPosition = Engine.QueryInterface(ent, IID_Position);
 		if (!cmpEntPosition)
 		{
 			Engine.DestroyEntity(ent);
 			error("tried to create entity without position");
 			continue;
 		}
 
 		let cmpEntOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (cmpEntOwnership)
 			cmpEntOwnership.SetOwner(owner);
 
 		entities.push(ent);
 
 		let pos;
 		if (cmpFootprint)
 			pos = cmpFootprint.PickSpawnPoint(ent);
 
 		// TODO this can happen if the player build on the place
 		// where our trigger point is
 		// We should probably warn the trigger maker in some way,
 		// but not interrupt the game for the player
 		if (!pos || pos.y < 0)
 			pos = cmpPosition.GetPosition();
 
 		cmpEntPosition.JumpTo(pos.x, pos.z);
 	}
 
 	return entities;
 };
 
 /**
  * Can be used to spawn garrisoned units inside a building/ship.
  *
  * @param entity Entity id of the garrison holder in which units will be garrisoned
  * @param template Name of the template
  * @param count Number of units to spawn
  * @param owner Player id of the owner of the new units. By default, the owner
  * of the garrisonholder entity.
  */
 TriggerHelper.SpawnGarrisonedUnits = function(entity, template, count, owner)
 {
 	let entities = [];
 
 	let cmpGarrisonHolder = Engine.QueryInterface(entity, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 	{
 		error("tried to create garrisoned entities inside a non-garrisonholder");
 		return entities;
 	}
 
 	if (owner == null)
 		owner = TriggerHelper.GetOwner(entity);
 
 	for (let i = 0; i < count; ++i)
 	{
 		let ent = Engine.AddEntity(template);
 
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (cmpOwnership)
 			cmpOwnership.SetOwner(owner);
 
 		let cmpGarrisonable = Engine.QueryInterface(ent, IID_Garrisonable);
-		if (cmpGarrisonable && cmpGarrisonable.Autogarrison(entity))
+		if (cmpGarrisonable && cmpGarrisonable.Garrison(entity))
 			entities.push(ent);
 		else
 			error("failed to garrison entity " + ent + " (" + template + ") inside " + entity);
 	}
 
 	return entities;
 };
 
 /**
  * Spawn units from all trigger points with this reference
  * If player is defined, only spaw units from the trigger points
  * that belong to that player
  * @param ref Trigger point reference name to spawn units from
  * @param template Template name
  * @param count Number of spawned entities per Trigger point
  * @param owner Owner of the spawned units. Default: the owner of the origins
  * @return A list of new entities per origin like
  * {originId1: [entId1, entId2], originId2: [entId3, entId4], ...}
  */
 TriggerHelper.SpawnUnitsFromTriggerPoints = function(ref, template, count, owner = null)
 {
 	let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 	let triggerPoints = cmpTrigger.GetTriggerPoints(ref);
 
 	let entities = {};
 	for (let point of triggerPoints)
 		entities[point] = TriggerHelper.SpawnUnits(point, template, count, owner);
 
 	return entities;
 };
 
 /**
  * Returns the resource type that can be gathered from an entity
  */
 TriggerHelper.GetResourceType = function(entity)
 {
 	let cmpResourceSupply = Engine.QueryInterface(entity, IID_ResourceSupply);
 	if (!cmpResourceSupply)
 		return undefined;
 
 	return cmpResourceSupply.GetType();
 };
 
 /**
  * The given player will win the game.
  * If it's not a last man standing game, then allies will win too and others will be defeated.
  *
  * @param {number} playerID - The player who will win.
  * @param {function} victoryReason - Function that maps from number to plural string, for example
  *     n => markForPluralTranslation(
  *         "%(lastPlayer)s has won (game mode).",
  *         "%(players)s and %(lastPlayer)s have won (game mode).",
  *         n));
  * It's a function since we don't know in advance how many players will have won.
  */
 TriggerHelper.SetPlayerWon = function(playerID, victoryReason, defeatReason)
 {
 	let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
 	cmpEndGameManager.MarkPlayerAndAlliesAsWon(playerID, victoryReason, defeatReason);
 };
 
 /**
  * Defeats a single player.
  *
  * @param {number} - ID of that player.
  * @param {string} - String to be shown in chat, for example
  *                   markForTranslation("%(player)s has been defeated (objective).")
  */
 TriggerHelper.DefeatPlayer = function(playerID, defeatReason)
 {
 	let cmpPlayer = QueryPlayerIDInterface(playerID);
 	if (cmpPlayer)
 		cmpPlayer.SetState("defeated", defeatReason);
 };
 
 /**
  * Returns the number of players including gaia and defeated ones.
  */
 TriggerHelper.GetNumberOfPlayers = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
 };
 
 /**
  * A function to determine if an entity matches specific classes.
  * See globalscripts/Templates.js for details of MatchesClassList.
  *
  * @param entity - ID of the entity that we want to check for classes.
  * @param classes - List of the classes we are checking if the entity matches.
  */
 TriggerHelper.EntityMatchesClassList = function(entity, classes)
 {
 	let cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
 	return cmpIdentity && MatchesClassList(cmpIdentity.GetClassesList(), classes);
 };
 
 TriggerHelper.MatchEntitiesByClass = function(entities, classes)
 {
 	return entities.filter(ent => TriggerHelper.EntityMatchesClassList(ent, classes));
 };
 
 TriggerHelper.GetPlayerEntitiesByClass = function(playerID, classes)
 {
 	return TriggerHelper.MatchEntitiesByClass(TriggerHelper.GetEntitiesByPlayer(playerID), classes);
 };
 
 TriggerHelper.GetAllPlayersEntitiesByClass = function(classes)
 {
 	return TriggerHelper.MatchEntitiesByClass(TriggerHelper.GetAllPlayersEntities(), classes);
 };
 
 /**
  * Return valid gaia-owned spawn points on land in neutral territory.
  * If there are none, use those available in player-owned territory.
  */
 TriggerHelper.GetLandSpawnPoints = function()
 {
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let cmpWaterManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_WaterManager);
 	let cmpTerritoryManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager);
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 
 	let neutralSpawnPoints = [];
 	let nonNeutralSpawnPoints = [];
 
 	for (let ent of cmpRangeManager.GetEntitiesByPlayer(0))
 	{
 		let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 		let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 		if (!cmpIdentity || !cmpPosition || !cmpPosition.IsInWorld())
 			continue;
 
 		let templateName = cmpTemplateManager.GetCurrentTemplateName(ent);
 		if (!templateName)
 			continue;
 
 		let template = cmpTemplateManager.GetTemplate(templateName);
 		if (!template || template.UnitMotionFlying)
 			continue;
 
 		let pos = cmpPosition.GetPosition();
 		if (pos.y <= cmpWaterManager.GetWaterLevel(pos.x, pos.z))
 			continue;
 
 		if (cmpTerritoryManager.GetOwner(pos.x, pos.z) == 0)
 			neutralSpawnPoints.push(ent);
 		else
 			nonNeutralSpawnPoints.push(ent);
 	}
 
 	return neutralSpawnPoints.length ? neutralSpawnPoints : nonNeutralSpawnPoints;
 };
 
 TriggerHelper.HasDealtWithTech = function(playerID, techName)
 {
 	let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	let playerEnt = cmpPlayerManager.GetPlayerByID(playerID);
 	let cmpTechnologyManager = Engine.QueryInterface(playerEnt, IID_TechnologyManager);
 	return cmpTechnologyManager && (cmpTechnologyManager.IsTechnologyQueued(techName) ||
 	                                cmpTechnologyManager.IsTechnologyStarted(techName) ||
 	                                cmpTechnologyManager.IsTechnologyResearched(techName));
 };
 
 /**
  * Returns all names of templates that match the given identity classes, constrainted to an optional civ.
  *
  * @param {string} classes - See MatchesClassList for the accepted formats, for example "Class1 Class2+!Class3".
  * @param [string] civ - Optionally only retrieve templates of the given civ. Can be left undefined.
  * @param [string] packedState - When retrieving siege engines filter for the "packed" or "unpacked" state
  * @param [string] rank - If given, only return templates that have no or the given rank. For example "Elite".
  * @param [boolean] excludeBarracksVariants - Optionally exclude templates whose name ends with "_barracks"
  */
 TriggerHelper.GetTemplateNamesByClasses = function(classes, civ, packedState, rank, excludeBarracksVariants)
 {
 	let templateNames = [];
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	for (let templateName of cmpTemplateManager.FindAllTemplates(false))
 	{
 		if (templateName.startsWith("campaigns/army_"))
 			continue;
 
 		if (excludeBarracksVariants && templateName.endsWith("_barracks"))
 			continue;
 
 		let template = cmpTemplateManager.GetTemplate(templateName);
 
 		if (civ && (!template.Identity || template.Identity.Civ != civ))
 			continue;
 
 		if (!MatchesClassList(GetIdentityClasses(template.Identity), classes))
 			continue;
 
 		if (rank && template.Identity.Rank && template.Identity.Rank != rank)
 			continue;
 
 		if (packedState && template.Pack && packedState != template.Pack.State)
 			continue;
 
 		templateNames.push(templateName);
 	}
 
 	return templateNames;
 };
 /**
  * Composes a random set of the given templates of the given total size.
  *
  * @param {string[]} templateNames - for example ["brit_infantry_javelineer_b", "brit_cavalry_swordsman_e"]
  * @param {number} totalCount - total amount of templates, in this  example 12
  * @returns an object where the keys are template names and values are amounts,
  *          for example { "brit_infantry_javelineer_b": 4, "brit_cavalry_swordsman_e": 8 }
  */
 TriggerHelper.RandomTemplateComposition = function(templateNames, totalCount)
 {
 	let frequencies = templateNames.map(() => randFloat(0, 1));
 	let frequencySum = frequencies.reduce((sum, frequency) => sum + frequency, 0);
 
 	let remainder = totalCount;
 	let templateCounts = {};
 
 	for (let i = 0; i < templateNames.length; ++i)
 	{
 		let count = i == templateNames.length - 1 ? remainder : Math.min(remainder, Math.round(frequencies[i] / frequencySum * totalCount));
 		if (!count)
 			continue;
 
 		templateCounts[templateNames[i]] = count;
 		remainder -= count;
 	}
 
 	return templateCounts;
 };
 
 /**
  * Composes a random set of the given templates so that the sum of templates matches totalCount.
  * For each template array that has a count item, it choses exactly that number of templates at random.
  * The remaining template arrays are chosen depending on the given frequency.
  * If a unique_entities array is given, it will only select the template if none of the given entityIDs
  * already have that entity (useful to let heroes remain unique).
  *
  * @param {Object[]} templateBalancing - for example
  *     [
  *        { "templates": ["template1", "template2"], "frequency": 2 },
  *        { "templates": ["template3"], "frequency": 1 },
  *        { "templates": ["hero1", "hero2"], "unique_entities": [380, 495], "count": 1 }
  *     ]
  * @param {number} totalCount - total amount of templates, for example 5.
  *
  * @returns an object where the keys are template names and values are amounts,
  *    for example { "template1": 1, "template2": 3, "template3": 2, "hero1": 1 }
  */
 TriggerHelper.BalancedTemplateComposition = function(templateBalancing, totalCount)
 {
 	// Remove all unavailable unique templates (heroes) and empty template arrays
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let templateBalancingFiltered = [];
 	for (let templateBalance of templateBalancing)
 	{
 		let templateBalanceNew = clone(templateBalance);
 
 		if (templateBalanceNew.unique_entities)
 			templateBalanceNew.templates = templateBalanceNew.templates.filter(templateName =>
 				templateBalanceNew.unique_entities.every(ent => templateName != cmpTemplateManager.GetCurrentTemplateName(ent)));
 
 		if (templateBalanceNew.templates.length)
 			templateBalancingFiltered.push(templateBalanceNew);
 	}
 
 	// Helper function to add randomized templates to the result
 	let remainder = totalCount;
 	let results = {};
 	let addTemplates = (templateNames, count) => {
 		let templateCounts = TriggerHelper.RandomTemplateComposition(templateNames, count);
 		for (let templateName in templateCounts)
 		{
 			if (!results[templateName])
 				results[templateName] = 0;
 
 			results[templateName] += templateCounts[templateName];
 			remainder -= templateCounts[templateName];
 		}
 	};
 
 	// Add template groups with fixed counts
 	for (let templateBalance of templateBalancingFiltered)
 		if (templateBalance.count)
 			addTemplates(templateBalance.templates, Math.min(remainder, templateBalance.count));
 
 	// Add template groups with frequency weights
 	let templateBalancingFrequencies = templateBalancingFiltered.filter(templateBalance => !!templateBalance.frequency);
 	let templateBalancingFrequencySum = templateBalancingFrequencies.reduce((sum, templateBalance) => sum + templateBalance.frequency, 0);
 	for (let i = 0; i < templateBalancingFrequencies.length; ++i)
 		addTemplates(
 			templateBalancingFrequencies[i].templates,
 			i == templateBalancingFrequencies.length - 1 ?
 				remainder :
 				Math.min(remainder, Math.round(templateBalancingFrequencies[i].frequency / templateBalancingFrequencySum * totalCount)));
 
 	if (remainder != 0)
 		warn("Could not choose as many templates as intended, remaining " + remainder + ", chosen: " + uneval(results));
 
 	return results;
 };
 
 /**
  * This will spawn random compositions of entities of the given templates at all garrisonholders of the given targetClass of the given player.
  * The garrisonholder will be filled to capacityPercent.
  * Returns an object where keys are entityIDs of the affected garrisonholders and the properties are template compositions, see RandomTemplateComposition.
  */
 TriggerHelper.SpawnAndGarrisonAtClasses = function(playerID, classes, templates, capacityPercent)
 {
 	let results = {};
 
 	for (let entGarrisonHolder of Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetEntitiesByPlayer(playerID))
 	{
 		let cmpIdentity = Engine.QueryInterface(entGarrisonHolder, IID_Identity);
 		if (!cmpIdentity || !MatchesClassList(cmpIdentity.GetClassesList(), classes))
 			continue;
 
 		let cmpGarrisonHolder = Engine.QueryInterface(entGarrisonHolder, IID_GarrisonHolder);
 		if (!cmpGarrisonHolder)
 			continue;
 
 		// TODO: account for already garrisoned entities
 		results[entGarrisonHolder] = this.RandomTemplateComposition(templates, Math.floor(cmpGarrisonHolder.GetCapacity() * capacityPercent));
 
 		for (let template in results[entGarrisonHolder])
 			TriggerHelper.SpawnGarrisonedUnits(entGarrisonHolder, template, results[entGarrisonHolder][template], playerID);
 	}
 
 	return results;
 };
 
 Engine.RegisterGlobal("TriggerHelper", TriggerHelper);
Index: ps/trunk/binaries/data/mods/public/simulation/components/GarrisonHolder.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/GarrisonHolder.js	(revision 25068)
+++ ps/trunk/binaries/data/mods/public/simulation/components/GarrisonHolder.js	(revision 25069)
@@ -1,596 +1,596 @@
 function GarrisonHolder() {}
 
 GarrisonHolder.prototype.Schema =
 	"<element name='Max' a:help='Maximum number of entities which can be garrisoned in this holder'>" +
 		"<data type='positiveInteger'/>" +
 	"</element>" +
 	"<element name='List' a:help='Classes of entities which are allowed to garrison in this holder (from Identity)'>" +
 		"<attribute name='datatype'>" +
 			"<value>tokens</value>" +
 		"</attribute>" +
 		"<text/>" +
 	"</element>" +
 	"<element name='EjectClassesOnDestroy' a:help='Classes of entities to be ejected on destroy. Others are killed'>" +
 		"<attribute name='datatype'>" +
 			"<value>tokens</value>" +
 		"</attribute>" +
 		"<text/>" +
 	"</element>" +
 	"<element name='BuffHeal' a:help='Number of hitpoints that will be restored to this holder&apos;s garrisoned units each second'>" +
 		"<ref name='nonNegativeDecimal'/>" +
 	"</element>" +
 	"<element name='LoadingRange' a:help='The maximum distance from this holder at which entities are allowed to garrison. Should be about 2.0 for land entities and preferably greater for ships'>" +
 		"<ref name='nonNegativeDecimal'/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='EjectHealth' a:help='Percentage of maximum health below which this holder no longer allows garrisoning'>" +
 			"<ref name='nonNegativeDecimal'/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Pickup' a:help='This garrisonHolder will move to pick up units to be garrisoned'>" +
 			"<data type='boolean'/>" +
 		"</element>" +
 	"</optional>";
 
 /**
  * Initialize GarrisonHolder Component
  * Garrisoning when loading a map is set in the script of the map, by setting initGarrison
  * which should contain the array of garrisoned entities.
  */
 GarrisonHolder.prototype.Init = function()
 {
 	this.entities = [];
 	this.allowedClasses = ApplyValueModificationsToEntity("GarrisonHolder/List/_string", this.template.List._string, this.entity);
 };
 
 /**
  * @param {number} entity - The entity to verify.
  * @return {boolean} - Whether the given entity is garrisoned in this GarrisonHolder.
  */
 GarrisonHolder.prototype.IsGarrisoned = function(entity)
 {
 	return this.entities.indexOf(entity) != -1;
 };
 
 /**
  * @return {Object} max and min range at which entities can garrison the holder.
  */
 GarrisonHolder.prototype.GetLoadingRange = function()
 {
 	return { "max": +this.template.LoadingRange, "min": 0 };
 };
 
 GarrisonHolder.prototype.CanPickup = function(ent)
 {
 	if (!this.template.Pickup || this.IsFull())
 		return false;
 	let cmpOwner = Engine.QueryInterface(this.entity, IID_Ownership);
 	return !!cmpOwner && IsOwnedByPlayer(cmpOwner.GetOwner(), ent);
 };
 
 GarrisonHolder.prototype.GetEntities = function()
 {
 	return this.entities;
 };
 
 /**
  * @return {Array} unit classes which can be garrisoned inside this
  * particular entity. Obtained from the entity's template.
  */
 GarrisonHolder.prototype.GetAllowedClasses = function()
 {
 	return this.allowedClasses;
 };
 
 GarrisonHolder.prototype.GetCapacity = function()
 {
 	return ApplyValueModificationsToEntity("GarrisonHolder/Max", +this.template.Max, this.entity);
 };
 
 GarrisonHolder.prototype.IsFull = function()
 {
 	return this.OccupiedSlots() >= this.GetCapacity();
 };
 
 GarrisonHolder.prototype.GetHealRate = function()
 {
 	return ApplyValueModificationsToEntity("GarrisonHolder/BuffHeal", +this.template.BuffHeal, this.entity);
 };
 
 /**
  * Set this entity to allow or disallow garrisoning in the entity.
  * Every component calling this function should do it with its own ID, and as long as one
  * component doesn't allow this entity to garrison, it can't be garrisoned
  * When this entity already contains garrisoned soldiers,
  * these will not be able to ungarrison until the flag is set to true again.
  *
  * This more useful for modern-day features. For example you can't garrison or ungarrison
  * a driving vehicle or plane.
  * @param {boolean} allow - Whether the entity should be garrisonable.
  */
 GarrisonHolder.prototype.AllowGarrisoning = function(allow, callerID)
 {
 	if (!this.allowGarrisoning)
 		this.allowGarrisoning = new Map();
 	this.allowGarrisoning.set(callerID, allow);
 };
 
 /**
  * @return {boolean} - Whether (un)garrisoning is allowed.
  */
 GarrisonHolder.prototype.IsGarrisoningAllowed = function()
 {
 	return !this.allowGarrisoning ||
 		Array.from(this.allowGarrisoning.values()).every(allow => allow);
 };
 
 GarrisonHolder.prototype.GetGarrisonedEntitiesCount = function()
 {
 	let count = this.entities.length;
 	for (let ent of this.entities)
 	{
 		let cmpGarrisonHolder = Engine.QueryInterface(ent, IID_GarrisonHolder);
 		if (cmpGarrisonHolder)
 			count += cmpGarrisonHolder.GetGarrisonedEntitiesCount();
 	}
 	return count;
 };
 
 GarrisonHolder.prototype.OccupiedSlots = function()
 {
 	let count = 0;
 	for (let ent of this.entities)
 	{
 		let cmpGarrisonable = Engine.QueryInterface(ent, IID_Garrisonable);
 		if (cmpGarrisonable)
 			count += cmpGarrisonable.TotalSize();
 	}
 	return count;
 };
 
 GarrisonHolder.prototype.IsAllowedToGarrison = function(entity)
 {
 	if (!this.IsGarrisoningAllowed())
 		return false;
 
 	let cmpGarrisonable = Engine.QueryInterface(entity, IID_Garrisonable);
 	if (!cmpGarrisonable || this.OccupiedSlots() + cmpGarrisonable.TotalSize() > this.GetCapacity())
 		return false;
 
 	return this.IsAllowedToBeGarrisoned(entity);
 };
 
 GarrisonHolder.prototype.IsAllowedToBeGarrisoned = function(entity)
 {
 	if (!IsOwnedByMutualAllyOfEntity(entity, this.entity))
 		return false;
 
 	let cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
 	return cmpIdentity && MatchesClassList(cmpIdentity.GetClassesList(), this.allowedClasses);
 };
 
 /**
  * @param {number} entity - The entityID to garrison.
  * @return {boolean} - Whether the entity was garrisoned.
  */
 GarrisonHolder.prototype.Garrison = function(entity)
 {
 	if (!this.IsAllowedToGarrison(entity))
 		return false;
 
 	if (!this.HasEnoughHealth())
 		return false;
 
 	if (!this.timer && this.GetHealRate() > 0)
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		this.timer = cmpTimer.SetTimeout(this.entity, IID_GarrisonHolder, "HealTimeout", 1000, {});
 	}
 
 	this.entities.push(entity);
 	this.UpdateGarrisonFlag();
 
 	Engine.PostMessage(this.entity, MT_GarrisonedUnitsChanged, {
 		"added": [entity],
 		"removed": []
 	});
 
 	return true;
 };
 
 /**
  * @param {number} entity - EntityID to find the spawn position for.
  * @param {boolean} forced - Optionally whether the spawning is forced.
  * @return {Vector3D} - An appropriate spawning position.
  */
 GarrisonHolder.prototype.GetSpawnPosition = function(entity, forced)
 {
 	let cmpFootprint = Engine.QueryInterface(this.entity, IID_Footprint);
 	let cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
 	let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
 
 	// If the garrisonHolder is a sinking ship, restrict the location to the intersection of both passabilities
 	// TODO: should use passability classes to be more generic
 	let pos;
 	if ((!cmpHealth || cmpHealth.GetHitpoints() == 0) && cmpIdentity && cmpIdentity.HasClass("Ship"))
 		pos = cmpFootprint.PickSpawnPointBothPass(entity);
 	else
 		pos = cmpFootprint.PickSpawnPoint(entity);
 
 	if (pos.y < 0)
 	{
 		// Error: couldn't find space satisfying the unit's passability criteria
 		if (!forced)
 			return null;
 
 		// If ejection is forced, we need to continue, so use center of the building
 		let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 		pos = cmpPosition.GetPosition();
 	}
 	return pos;
 };
 
 /**
  * @param {number} entity - The entity ID of the entity to eject.
  * @param {boolean} forced - Whether eject is forced (e.g. if building is destroyed).
  * @return {boolean} Whether the entity was ejected.
  */
 GarrisonHolder.prototype.Eject = function(entity, forced)
 {
 	if (!this.IsGarrisoningAllowed() && !forced)
 		return false;
 
 	let entityIndex = this.entities.indexOf(entity);
 	// Error: invalid entity ID, usually it's already been ejected, assume success.
 	if (entityIndex == -1)
 		return true;
 
 	this.entities.splice(entityIndex, 1);
 	this.UpdateGarrisonFlag();
 	Engine.PostMessage(this.entity, MT_GarrisonedUnitsChanged, {
 		"added": [],
 		"removed": [entity]
 	});
 
 	return true;
 };
 
 /**
  * @param {number} entity - The entity ID of the entity to order to the rally point.
  */
 GarrisonHolder.prototype.OrderToRallyPoint = function(entity)
 {
 	let cmpRallyPoint = Engine.QueryInterface(this.entity, IID_RallyPoint);
 	if (!cmpRallyPoint || !cmpRallyPoint.GetPositions()[0])
 		return;
 
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership)
 		return;
 
 	let cmpEntOwnership = Engine.QueryInterface(entity, IID_Ownership);
 	if (!cmpEntOwnership || cmpOwnership.GetOwner() != cmpEntOwnership.GetOwner())
 		return;
 
 	let commands = GetRallyPointCommands(cmpRallyPoint, [entity]);
 	// Ignore the rally point if it is autogarrison
 	if (commands[0].type == "garrison" && commands[0].target == this.entity)
 		return;
 
 	for (let command of commands)
 		ProcessCommand(cmpOwnership.GetOwner(), command);
 };
 
 /**
  * Tell unit to unload from this entity.
  * @param {number} entity - The entity to unload.
  * @return {boolean} Whether the command was successful.
  */
 GarrisonHolder.prototype.Unload = function(entity)
 {
 	let cmpGarrisonable = Engine.QueryInterface(entity, IID_Garrisonable);
 	return cmpGarrisonable && cmpGarrisonable.UnGarrison();
 };
 
 /**
  * Tell units to unload from this entity.
  * @param {number[]} entities - The entities to unload.
  * @return {boolean} - Whether all unloads were successful.
  */
 GarrisonHolder.prototype.UnloadEntities = function(entities)
 {
 	let success = true;
 	for (let entity of entities)
 		if (!this.Unload(entity))
 			success = false;
 	return success;
 };
 
 /**
  * Unload one or all units that match a template and owner from us.
  * @param {string} template - Type of units that should be ejected.
  * @param {number} owner - Id of the player whose units should be ejected.
  * @param {boolean} all - Whether all units should be ejected.
  * @return {boolean} Whether the unloading was successful.
  */
 GarrisonHolder.prototype.UnloadTemplate = function(template, owner, all)
 {
 	let entities = [];
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	for (let entity of this.entities)
 	{
 		let cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
 
 		// Units with multiple ranks are grouped together.
 		let name = cmpIdentity.GetSelectionGroupName() || cmpTemplateManager.GetCurrentTemplateName(entity);
 		if (name != template || owner != Engine.QueryInterface(entity, IID_Ownership).GetOwner())
 			continue;
 
 		entities.push(entity);
 
 		// If 'all' is false, only ungarrison the first matched unit.
 		if (!all)
 			break;
 	}
 
 	return this.UnloadEntities(entities);
 };
 
 /**
  * Unload all units, that belong to certain player
  * and order all own units to move to the rally point.
  * @param {number} owner - Id of the player whose units should be ejected.
  * @return {boolean} Whether the unloading was successful.
  */
 GarrisonHolder.prototype.UnloadAllByOwner = function(owner)
 {
 	let entities = this.entities.filter(ent => {
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		return cmpOwnership && cmpOwnership.GetOwner() == owner;
 	});
 	return this.UnloadEntities(entities);
 };
 
 /**
  * Unload all units from the entity and order them to move to the rally point.
  * @return {boolean} Whether the unloading was successful.
  */
 GarrisonHolder.prototype.UnloadAll = function()
 {
 	return this.UnloadEntities(this.entities.slice());
 };
 
 /**
  * Used to check if the garrisoning entity's health has fallen below
  * a certain limit after which all garrisoned units are unloaded.
  */
 GarrisonHolder.prototype.OnHealthChanged = function(msg)
 {
 	if (!this.HasEnoughHealth() && this.entities.length)
 		this.EjectOrKill(this.entities.slice());
 };
 
 GarrisonHolder.prototype.HasEnoughHealth = function()
 {
 	// 0 is a valid value so explicitly check for undefined.
 	if (this.template.EjectHealth === undefined)
 		return true;
 
 	let cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
 	return !cmpHealth || cmpHealth.GetHitpoints() > Math.floor(+this.template.EjectHealth * cmpHealth.GetMaxHitpoints());
 };
 
 /**
  * Called every second. Heals garrisoned units.
  */
 GarrisonHolder.prototype.HealTimeout = function(data)
 {
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	if (!this.entities.length)
 	{
 		cmpTimer.CancelTimer(this.timer);
 		delete this.timer;
 		return;
 	}
 
 	for (let entity of this.entities)
 	{
 		let cmpHealth = Engine.QueryInterface(entity, IID_Health);
 		if (cmpHealth && !cmpHealth.IsUnhealable())
 			cmpHealth.Increase(this.GetHealRate());
 	}
 
 	this.timer = cmpTimer.SetTimeout(this.entity, IID_GarrisonHolder, "HealTimeout", 1000, {});
 };
 
 /**
  * Updates the garrison flag depending whether something is garrisoned in the entity.
  */
 GarrisonHolder.prototype.UpdateGarrisonFlag = function()
 {
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (!cmpVisual)
 		return;
 
 	cmpVisual.SetVariant("garrison", this.entities.length ? "garrisoned" : "ungarrisoned");
 };
 
 /**
  * Cancel timer when destroyed.
  */
 GarrisonHolder.prototype.OnDestroy = function()
 {
 	if (this.timer)
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		cmpTimer.CancelTimer(this.timer);
 	}
 };
 
 /**
  * If a garrisoned entity is captured, or about to be killed (so its owner changes to '-1'),
  * remove it from the building so we only ever contain valid entities.
  */
 GarrisonHolder.prototype.OnGlobalOwnershipChanged = function(msg)
 {
 	// The ownership change may be on the garrisonholder
 	if (this.entity == msg.entity)
 	{
 		let entities = this.entities.filter(ent => msg.to == INVALID_PLAYER || !IsOwnedByMutualAllyOfEntity(this.entity, ent));
 
 		if (entities.length)
 			this.EjectOrKill(entities);
 
 		return;
 	}
 
 	// or on some of its garrisoned units
 	let entityIndex = this.entities.indexOf(msg.entity);
 	if (entityIndex != -1 && (msg.to == INVALID_PLAYER || !IsOwnedByMutualAllyOfEntity(this.entity, msg.entity)))
 		this.EjectOrKill([msg.entity]);
 };
 
 /**
  * Update list of garrisoned entities when a game inits.
  */
 GarrisonHolder.prototype.OnGlobalSkirmishReplacerReplaced = function(msg)
 {
 	if (!this.initGarrison)
 		return;
 
 	if (msg.entity == this.entity)
 	{
 		let cmpGarrisonHolder = Engine.QueryInterface(msg.newentity, IID_GarrisonHolder);
 		if (cmpGarrisonHolder)
 			cmpGarrisonHolder.initGarrison = this.initGarrison;
 	}
 	else
 	{
 		let entityIndex = this.initGarrison.indexOf(msg.entity);
 		if (entityIndex != -1)
 			this.initGarrison[entityIndex] = msg.newentity;
 	}
 };
 
 /**
  * Eject all foreign garrisoned entities which are no more allied.
  */
 GarrisonHolder.prototype.OnDiplomacyChanged = function()
 {
 	this.EjectOrKill(this.entities.filter(ent => !IsOwnedByMutualAllyOfEntity(this.entity, ent)));
 };
 
 /**
  * Eject or kill a garrisoned unit which can no more be garrisoned
  * (garrisonholder's health too small or ownership changed).
  */
 GarrisonHolder.prototype.EjectOrKill = function(entities)
 {
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	// Eject the units which can be ejected (if not in world, it generally means this holder
 	// is inside a holder which kills its entities, so do not eject)
 	if (cmpPosition && cmpPosition.IsInWorld())
 	{
 		let ejectables = entities.filter(ent => this.IsEjectable(ent));
 		if (ejectables.length)
 			this.UnloadEntities(ejectables);
 	}
 
 	// And destroy all remaining entities
 	let killedEntities = [];
 	for (let entity of entities)
 	{
 		let entityIndex = this.entities.indexOf(entity);
 		if (entityIndex == -1)
 			continue;
 		let cmpHealth = Engine.QueryInterface(entity, IID_Health);
 		if (cmpHealth)
 			cmpHealth.Kill();
 		else
 			Engine.DestroyEntity(entity);
 		this.entities.splice(entityIndex, 1);
 		killedEntities.push(entity);
 	}
 
 	if (killedEntities.length)
 	{
 		Engine.PostMessage(this.entity, MT_GarrisonedUnitsChanged, {
 			"added": [],
 			"removed": killedEntities
 		});
 		this.UpdateGarrisonFlag();
 	}
 };
 
 /**
  * Whether an entity is ejectable.
  * @param {number} entity - The entity-ID to be tested.
  * @return {boolean} - Whether the entity is ejectable.
  */
 GarrisonHolder.prototype.IsEjectable = function(entity)
 {
 	if (!this.entities.find(ent => ent == entity))
 		return false;
 
 	let ejectableClasses = this.template.EjectClassesOnDestroy._string;
 	let entityClasses = Engine.QueryInterface(entity, IID_Identity).GetClassesList();
 
 	return MatchesClassList(entityClasses, ejectableClasses);
 };
 
 /**
  * Sets the intitGarrison to the specified entities. Used by the mapreader.
  *
  * @param {number[]} entities - The entity IDs to garrison on init.
  */
 GarrisonHolder.prototype.SetInitGarrison = function(entities)
 {
 	this.initGarrison = clone(entities);
 };
 
 /**
  * Initialise the garrisoned units.
  */
 GarrisonHolder.prototype.OnGlobalInitGame = function(msg)
 {
 	if (!this.initGarrison)
 		return;
 
 	for (let ent of this.initGarrison)
 	{
 		let cmpGarrisonable = Engine.QueryInterface(ent, IID_Garrisonable);
 		if (cmpGarrisonable)
-			cmpGarrisonable.Autogarrison(this.entity);
+			cmpGarrisonable.Garrison(this.entity);
 	}
 	this.initGarrison = undefined;
 };
 
 GarrisonHolder.prototype.OnValueModification = function(msg)
 {
 	if (msg.component != "GarrisonHolder")
 		return;
 
 	if (msg.valueNames.indexOf("GarrisonHolder/List/_string") !== -1)
 	{
 		this.allowedClasses = ApplyValueModificationsToEntity("GarrisonHolder/List/_string", this.template.List._string, this.entity);
 		this.EjectOrKill(this.entities.filter(entity => !this.IsAllowedToBeGarrisoned(entity)));
 	}
 
 	if (msg.valueNames.indexOf("GarrisonHolder/BuffHeal") === -1)
 		return;
 
 	if (this.timer && this.GetHealRate() == 0)
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		cmpTimer.CancelTimer(this.timer);
 		delete this.timer;
 	}
 	else if (!this.timer && this.GetHealRate() > 0)
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		this.timer = cmpTimer.SetTimeout(this.entity, IID_GarrisonHolder, "HealTimeout", 1000, {});
 	}
 };
 
 Engine.RegisterComponentType(IID_GarrisonHolder, "GarrisonHolder", GarrisonHolder);
Index: ps/trunk/binaries/data/mods/public/simulation/components/Garrisonable.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Garrisonable.js	(revision 25068)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Garrisonable.js	(revision 25069)
@@ -1,194 +1,186 @@
 function Garrisonable() {}
 
 Garrisonable.prototype.Schema =
 	"<a:help>Controls the garrisonability of an entity.</a:help>" +
 	"<a:example>" +
 		"<Size>10</Size>" +
 	"</a:example>" +
 	"<element name='Size' a:help='Number of garrison slots the entity occupies.'>" +
 		"<data type='nonNegativeInteger'/>" +
 	"</element>";
 
 Garrisonable.prototype.Init = function()
 {
 };
 
 /**
  * @return {number} - The number of slots this unit takes in a garrisonHolder.
  */
 Garrisonable.prototype.UnitSize = function()
 {
 	return ApplyValueModificationsToEntity("Garrisonable/Size", +this.template.Size, this.entity);
 };
 
 /**
  * Calculates the number of slots this unit takes in a garrisonHolder by
  * adding the number of garrisoned slots to the equation.
  *
  * @return {number} - The number of slots this unit and its garrison takes in a garrisonHolder.
  */
 Garrisonable.prototype.TotalSize = function()
 {
 	let size = this.UnitSize();
 	let cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
 	if (cmpGarrisonHolder)
 		size += cmpGarrisonHolder.OccupiedSlots();
 	return size;
 };
 
 /**
  * @return {number} - The entity ID of the entity this entity is garrisoned in.
  */
 Garrisonable.prototype.HolderID = function()
 {
 	return this.holder || INVALID_ENTITY;
 };
 
 /**
+ * @return {boolean} - Whether we're garrisoned.
+ */
+Garrisonable.prototype.IsGarrisoned = function()
+{
+	return !!this.holder;
+};
+
+/**
  * @param {number} target - The entity ID to check.
  * @return {boolean} - Whether we can garrison.
  */
 Garrisonable.prototype.CanGarrison = function(target)
 {
 	if (this.holder)
 		return false;
 
 	let cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 	return cmpGarrisonHolder && cmpGarrisonHolder.IsAllowedToGarrison(this.entity);
 };
 
 /**
  * @param {number} target - The entity ID of the entity this entity is being garrisoned in.
  * @return {boolean} - Whether garrisoning succeeded.
  */
 Garrisonable.prototype.Garrison = function(target, renamed = false)
 {
 	if (!this.CanGarrison(target))
 		return false;
 
 	let cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder || !cmpGarrisonHolder.Garrison(this.entity))
 		return false;
 
 	this.holder = target;
 
 	let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
 	if (cmpUnitAI)
 		cmpUnitAI.SetGarrisoned();
 
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (cmpPosition)
 		cmpPosition.MoveOutOfWorld();
 
 	Engine.PostMessage(this.entity, MT_GarrisonedStateChanged, {
 		"oldHolder": INVALID_ENTITY,
 		"holderID": target
 	});
 
 	if (renamed)
 		return true;
 
 	let cmpTurretHolder = Engine.QueryInterface(target, IID_TurretHolder);
 	if (cmpTurretHolder)
 		cmpTurretHolder.OccupyTurret(this.entity);
 
 	return true;
 };
 
 /**
- * Called on game init when the entity was part of init garrison.
- * @param {number} target - The entityID to autogarrison.
- * @return {boolean} - Whether garrisoning succeeded.
- */
-Garrisonable.prototype.Autogarrison = function(target)
-{
-	if (!this.Garrison(target))
-		return false;
-
-	let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
-	if (cmpUnitAI)
-		cmpUnitAI.Autogarrison(target);
-	return true;
-};
-
-/**
  * @param {boolean} forced - Optionally whether the spawning is forced.
  * @param {boolean} renamed - Optionally whether the ungarrisoning is due to renaming.
  * @return {boolean} - Whether the ungarrisoning succeeded.
  */
 Garrisonable.prototype.UnGarrison = function(forced = false, renamed = false)
 {
 	if (!this.holder)
 		return true;
 
 	let cmpGarrisonHolder = Engine.QueryInterface(this.holder, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 		return false;
 
 	let pos = cmpGarrisonHolder.GetSpawnPosition(this.entity, forced);
 	if (!pos)
 		return false;
 
 	if (!cmpGarrisonHolder.Eject(this.entity, forced))
 		return false;
 
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (cmpPosition)
 	{
 		cmpPosition.JumpTo(pos.x, pos.z);
 		cmpPosition.SetHeightOffset(0);
 	}
 
 	let cmpHolderPosition = Engine.QueryInterface(this.holder, IID_Position);
 	if (cmpHolderPosition)
 		cmpPosition.SetYRotation(cmpHolderPosition.GetPosition().horizAngleTo(pos));
 
 	let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
 	if (cmpUnitAI)
 	{
 		cmpUnitAI.Ungarrison();
 		cmpUnitAI.UnsetGarrisoned();
 	}
 
 	Engine.PostMessage(this.entity, MT_GarrisonedStateChanged, {
 		"oldHolder": this.holder,
 		"holderID": INVALID_ENTITY
 	});
 
 	if (renamed)
 		return true;
 
 	let cmpTurretHolder = Engine.QueryInterface(this.holder, IID_TurretHolder);
 	if (cmpTurretHolder)
 		cmpTurretHolder.LeaveTurret(this.entity);
 
 	cmpGarrisonHolder.OrderToRallyPoint(this.entity);
 
 	delete this.holder;
 	return true;
 };
 
 Garrisonable.prototype.OnEntityRenamed = function(msg)
 {
 	if (!this.holder)
 		return;
 
 	let cmpGarrisonHolder = Engine.QueryInterface(this.holder, IID_GarrisonHolder);
 	if (cmpGarrisonHolder)
 	{
 		this.UnGarrison(true, true);
 		let cmpGarrisonable = Engine.QueryInterface(msg.newentity, IID_Garrisonable);
 		if (cmpGarrisonable)
 			cmpGarrisonable.Garrison(this.holder, true);
 	}
 
 	// We process EntityRenamed of turrets seperately since we
 	// want to occupy the same position after being renamed.
 	let cmpTurretHolder = Engine.QueryInterface(this.holder, IID_TurretHolder);
 	if (cmpTurretHolder)
 		cmpTurretHolder.SwapEntities(msg.entity, msg.newentity);
 
 	delete this.holder;
 };
 
 Engine.RegisterComponentType(IID_Garrisonable, "Garrisonable", Garrisonable);
Index: ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js	(revision 25068)
+++ ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js	(revision 25069)
@@ -1,2104 +1,2108 @@
 function GuiInterface() {}
 
 GuiInterface.prototype.Schema =
 	"<a:component type='system'/><empty/>";
 
 GuiInterface.prototype.Serialize = function()
 {
 	// This component isn't network-synchronized for the biggest part,
 	// so most of the attributes shouldn't be serialized.
 	// Return an object with a small selection of deterministic data.
 	return {
 		"timeNotifications": this.timeNotifications,
 		"timeNotificationID": this.timeNotificationID
 	};
 };
 
 GuiInterface.prototype.Deserialize = function(data)
 {
 	this.Init();
 	this.timeNotifications = data.timeNotifications;
 	this.timeNotificationID = data.timeNotificationID;
 };
 
 GuiInterface.prototype.Init = function()
 {
 	this.placementEntity = undefined; // = undefined or [templateName, entityID]
 	this.placementWallEntities = undefined;
 	this.placementWallLastAngle = 0;
 	this.notifications = [];
 	this.renamedEntities = [];
 	this.miragedEntities = [];
 	this.timeNotificationID = 1;
 	this.timeNotifications = [];
 	this.entsRallyPointsDisplayed = [];
 	this.entsWithAuraAndStatusBars = new Set();
 	this.enabledVisualRangeOverlayTypes = {};
 	this.templateModified = {};
 	this.selectionDirty = {};
 	this.obstructionSnap = new ObstructionSnap();
 };
 
 /*
  * All of the functions defined below are called via Engine.GuiInterfaceCall(name, arg)
  * from GUI scripts, and executed here with arguments (player, arg).
  *
  * CAUTION: The input to the functions in this module is not network-synchronised, so it
  * mustn't affect the simulation state (i.e. the data that is serialised and can affect
  * the behaviour of the rest of the simulation) else it'll cause out-of-sync errors.
  */
 
 /**
  * Returns global information about the current game state.
  * This is used by the GUI and also by AI scripts.
  */
 GuiInterface.prototype.GetSimulationState = function()
 {
 	let ret = {
 		"players": []
 	};
 
 	let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	let numPlayers = cmpPlayerManager.GetNumPlayers();
 	for (let i = 0; i < numPlayers; ++i)
 	{
 		let cmpPlayer = QueryPlayerIDInterface(i);
 		let cmpPlayerEntityLimits = QueryPlayerIDInterface(i, IID_EntityLimits);
 
 		// Work out which phase we are in.
 		let phase = "";
 		let cmpTechnologyManager = QueryPlayerIDInterface(i, IID_TechnologyManager);
 		if (cmpTechnologyManager)
 		{
 			if (cmpTechnologyManager.IsTechnologyResearched("phase_city"))
 				phase = "city";
 			else if (cmpTechnologyManager.IsTechnologyResearched("phase_town"))
 				phase = "town";
 			else if (cmpTechnologyManager.IsTechnologyResearched("phase_village"))
 				phase = "village";
 		}
 
 		let allies = [];
 		let mutualAllies = [];
 		let neutrals = [];
 		let enemies = [];
 
 		for (let j = 0; j < numPlayers; ++j)
 		{
 			allies[j] = cmpPlayer.IsAlly(j);
 			mutualAllies[j] = cmpPlayer.IsMutualAlly(j);
 			neutrals[j] = cmpPlayer.IsNeutral(j);
 			enemies[j] = cmpPlayer.IsEnemy(j);
 		}
 
 		ret.players.push({
 			"name": cmpPlayer.GetName(),
 			"civ": cmpPlayer.GetCiv(),
 			"color": cmpPlayer.GetColor(),
 			"controlsAll": cmpPlayer.CanControlAllUnits(),
 			"popCount": cmpPlayer.GetPopulationCount(),
 			"popLimit": cmpPlayer.GetPopulationLimit(),
 			"popMax": cmpPlayer.GetMaxPopulation(),
 			"panelEntities": cmpPlayer.GetPanelEntities(),
 			"resourceCounts": cmpPlayer.GetResourceCounts(),
 			"resourceGatherers": cmpPlayer.GetResourceGatherers(),
 			"trainingBlocked": cmpPlayer.IsTrainingBlocked(),
 			"state": cmpPlayer.GetState(),
 			"team": cmpPlayer.GetTeam(),
 			"teamsLocked": cmpPlayer.GetLockTeams(),
 			"cheatsEnabled": cmpPlayer.GetCheatsEnabled(),
 			"disabledTemplates": cmpPlayer.GetDisabledTemplates(),
 			"disabledTechnologies": cmpPlayer.GetDisabledTechnologies(),
 			"hasSharedDropsites": cmpPlayer.HasSharedDropsites(),
 			"hasSharedLos": cmpPlayer.HasSharedLos(),
 			"spyCostMultiplier": cmpPlayer.GetSpyCostMultiplier(),
 			"phase": phase,
 			"isAlly": allies,
 			"isMutualAlly": mutualAllies,
 			"isNeutral": neutrals,
 			"isEnemy": enemies,
 			"entityLimits": cmpPlayerEntityLimits ? cmpPlayerEntityLimits.GetLimits() : null,
 			"entityCounts": cmpPlayerEntityLimits ? cmpPlayerEntityLimits.GetCounts() : null,
 			"matchEntityCounts": cmpPlayerEntityLimits ? cmpPlayerEntityLimits.GetMatchCounts() : null,
 			"entityLimitChangers": cmpPlayerEntityLimits ? cmpPlayerEntityLimits.GetLimitChangers() : null,
 			"researchQueued": cmpTechnologyManager ? cmpTechnologyManager.GetQueuedResearch() : null,
 			"researchStarted": cmpTechnologyManager ? cmpTechnologyManager.GetStartedTechs() : null,
 			"researchedTechs": cmpTechnologyManager ? cmpTechnologyManager.GetResearchedTechs() : null,
 			"classCounts": cmpTechnologyManager ? cmpTechnologyManager.GetClassCounts() : null,
 			"typeCountsByClass": cmpTechnologyManager ? cmpTechnologyManager.GetTypeCountsByClass() : null,
 			"canBarter": cmpPlayer.CanBarter(),
 			"barterPrices": Engine.QueryInterface(SYSTEM_ENTITY, IID_Barter).GetPrices(cmpPlayer)
 		});
 	}
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (cmpRangeManager)
 		ret.circularMap = cmpRangeManager.GetLosCircular();
 
 	let cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 	if (cmpTerrain)
 		ret.mapSize = cmpTerrain.GetMapSize();
 
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	ret.timeElapsed = cmpTimer.GetTime();
 
 	let cmpCeasefireManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_CeasefireManager);
 	if (cmpCeasefireManager)
 	{
 		ret.ceasefireActive = cmpCeasefireManager.IsCeasefireActive();
 		ret.ceasefireTimeRemaining = ret.ceasefireActive ? cmpCeasefireManager.GetCeasefireStartedTime() + cmpCeasefireManager.GetCeasefireTime() - ret.timeElapsed : 0;
 	}
 
 	let cmpCinemaManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_CinemaManager);
 	if (cmpCinemaManager)
 		ret.cinemaPlaying = cmpCinemaManager.IsPlaying();
 
 	let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
 	ret.victoryConditions = cmpEndGameManager.GetVictoryConditions();
 	ret.alliedVictory = cmpEndGameManager.GetAlliedVictory();
 
 	ret.maxWorldPopulation = cmpPlayerManager.GetMaxWorldPopulation();
 
 	for (let i = 0; i < numPlayers; ++i)
 	{
 		let cmpPlayerStatisticsTracker = QueryPlayerIDInterface(i, IID_StatisticsTracker);
 		if (cmpPlayerStatisticsTracker)
 			ret.players[i].statistics = cmpPlayerStatisticsTracker.GetBasicStatistics();
 	}
 
 	return ret;
 };
 
 /**
  * Returns global information about the current game state, plus statistics.
  * This is used by the GUI at the end of a game, in the summary screen.
  * Note: Amongst statistics, the team exploration map percentage is computed from
  * scratch, so the extended simulation state should not be requested too often.
  */
 GuiInterface.prototype.GetExtendedSimulationState = function()
 {
 	let ret = this.GetSimulationState();
 
 	let numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
 	for (let i = 0; i < numPlayers; ++i)
 	{
 		let cmpPlayerStatisticsTracker = QueryPlayerIDInterface(i, IID_StatisticsTracker);
 		if (cmpPlayerStatisticsTracker)
 			ret.players[i].sequences = cmpPlayerStatisticsTracker.GetSequences();
 	}
 
 	return ret;
 };
 
 /**
  * Returns the gamesettings that were chosen at the time the match started.
  */
 GuiInterface.prototype.GetInitAttributes = function()
 {
 	return InitAttributes;
 };
 
 /**
  * This data will be stored in the replay metadata file after a match has been finished recording.
  */
 GuiInterface.prototype.GetReplayMetadata = function()
 {
 	let extendedSimState = this.GetExtendedSimulationState();
 	return {
 		"timeElapsed": extendedSimState.timeElapsed,
 		"playerStates": extendedSimState.players,
 		"mapSettings": InitAttributes.settings
 	};
 };
 
 /**
  * Called when the game ends if the current game is part of a campaign run.
  */
 GuiInterface.prototype.GetCampaignGameEndData = function(player)
 {
 	let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 	if (Trigger.prototype.OnCampaignGameEnd)
 		return Trigger.prototype.OnCampaignGameEnd();
 	return {};
 };
 
 GuiInterface.prototype.GetRenamedEntities = function(player)
 {
 	if (this.miragedEntities[player])
 		return this.renamedEntities.concat(this.miragedEntities[player]);
 
 	return this.renamedEntities;
 };
 
 GuiInterface.prototype.ClearRenamedEntities = function()
 {
 	this.renamedEntities = [];
 	this.miragedEntities = [];
 };
 
 GuiInterface.prototype.AddMiragedEntity = function(player, entity, mirage)
 {
 	if (!this.miragedEntities[player])
 		this.miragedEntities[player] = [];
 
 	this.miragedEntities[player].push({ "entity": entity, "newentity": mirage });
 };
 
 /**
  * Get common entity info, often used in the gui.
  */
 GuiInterface.prototype.GetEntityState = function(player, ent)
 {
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 
 	// All units must have a template; if not then it's a nonexistent entity id.
 	let template = cmpTemplateManager.GetCurrentTemplateName(ent);
 	if (!template)
 		return null;
 
 	let ret = {
 		"id": ent,
 		"player": INVALID_PLAYER,
 		"template": template
 	};
 
 	let cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
 	if (cmpMirage)
 		ret.mirage = true;
 
 	let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 	if (cmpIdentity)
 		ret.identity = {
 			"rank": cmpIdentity.GetRank(),
 			"classes": cmpIdentity.GetClassesList(),
 			"selectionGroupName": cmpIdentity.GetSelectionGroupName(),
 			"canDelete": !cmpIdentity.IsUndeletable(),
 			"hasSomeFormation": cmpIdentity.HasSomeFormation(),
 			"formations": cmpIdentity.GetFormationsList(),
 			"controllable": cmpIdentity.IsControllable()
 		};
 
 	let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	if (cmpPosition && cmpPosition.IsInWorld())
 		ret.position = cmpPosition.GetPosition();
 
 	let cmpHealth = QueryMiragedInterface(ent, IID_Health);
 	if (cmpHealth)
 	{
 		ret.hitpoints = cmpHealth.GetHitpoints();
 		ret.maxHitpoints = cmpHealth.GetMaxHitpoints();
 		ret.needsRepair = cmpHealth.IsRepairable() && cmpHealth.IsInjured();
 		ret.needsHeal = !cmpHealth.IsUnhealable();
 	}
 
 	let cmpCapturable = QueryMiragedInterface(ent, IID_Capturable);
 	if (cmpCapturable)
 	{
 		ret.capturePoints = cmpCapturable.GetCapturePoints();
 		ret.maxCapturePoints = cmpCapturable.GetMaxCapturePoints();
 	}
 
 	let cmpBuilder = Engine.QueryInterface(ent, IID_Builder);
 	if (cmpBuilder)
 		ret.builder = true;
 
 	let cmpMarket = QueryMiragedInterface(ent, IID_Market);
 	if (cmpMarket)
 		ret.market = {
 			"land": cmpMarket.HasType("land"),
 			"naval": cmpMarket.HasType("naval")
 		};
 
 	let cmpPack = Engine.QueryInterface(ent, IID_Pack);
 	if (cmpPack)
 		ret.pack = {
 			"packed": cmpPack.IsPacked(),
 			"progress": cmpPack.GetProgress()
 		};
 
 	let cmpPopulation = Engine.QueryInterface(ent, IID_Population);
 	if (cmpPopulation)
 		ret.population = {
 			"bonus": cmpPopulation.GetPopBonus()
 		};
 
 	let cmpUpgrade = Engine.QueryInterface(ent, IID_Upgrade);
 	if (cmpUpgrade)
 		ret.upgrade = {
 			"upgrades": cmpUpgrade.GetUpgrades(),
 			"progress": cmpUpgrade.GetProgress(),
 			"template": cmpUpgrade.GetUpgradingTo(),
 			"isUpgrading": cmpUpgrade.IsUpgrading()
 		};
 
 	let cmpStatusEffects = Engine.QueryInterface(ent, IID_StatusEffectsReceiver);
 	if (cmpStatusEffects)
 		ret.statusEffects = cmpStatusEffects.GetActiveStatuses();
 
 	let cmpProductionQueue = Engine.QueryInterface(ent, IID_ProductionQueue);
 	if (cmpProductionQueue)
 		ret.production = {
 			"entities": cmpProductionQueue.GetEntitiesList(),
 			"technologies": cmpProductionQueue.GetTechnologiesList(),
 			"techCostMultiplier": cmpProductionQueue.GetTechCostMultiplier(),
 			"queue": cmpProductionQueue.GetQueue()
 		};
 
 	let cmpTrader = Engine.QueryInterface(ent, IID_Trader);
 	if (cmpTrader)
 		ret.trader = {
 			"goods": cmpTrader.GetGoods()
 		};
 
 	let cmpFoundation = QueryMiragedInterface(ent, IID_Foundation);
 	if (cmpFoundation)
 		ret.foundation = {
 			"numBuilders": cmpFoundation.GetNumBuilders(),
 			"buildTime": cmpFoundation.GetBuildTime()
 		};
 
 	let cmpRepairable = QueryMiragedInterface(ent, IID_Repairable);
 	if (cmpRepairable)
 		ret.repairable = {
 			"numBuilders": cmpRepairable.GetNumBuilders(),
 			"buildTime": cmpRepairable.GetBuildTime()
 		};
 
 	let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 	if (cmpOwnership)
 		ret.player = cmpOwnership.GetOwner();
 
 	let cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 	if (cmpRallyPoint)
 		ret.rallyPoint = { "position": cmpRallyPoint.GetPositions()[0] }; // undefined or {x,z} object
 
 	let cmpGarrisonHolder = Engine.QueryInterface(ent, IID_GarrisonHolder);
 	if (cmpGarrisonHolder)
 		ret.garrisonHolder = {
 			"entities": cmpGarrisonHolder.GetEntities(),
 			"buffHeal": cmpGarrisonHolder.GetHealRate(),
 			"allowedClasses": cmpGarrisonHolder.GetAllowedClasses(),
 			"capacity": cmpGarrisonHolder.GetCapacity(),
 			"occupiedSlots": cmpGarrisonHolder.OccupiedSlots()
 		};
 
 	let cmpTurretHolder = Engine.QueryInterface(ent, IID_TurretHolder);
 	if (cmpTurretHolder)
 		ret.turretHolder = {
 			"turretPoints": cmpTurretHolder.GetTurretPoints()
 		};
 
 	let cmpGarrisonable = Engine.QueryInterface(ent, IID_Garrisonable);
 	if (cmpGarrisonable)
 		ret.garrisonable = {
 			"holder": cmpGarrisonable.HolderID(),
 			"size": cmpGarrisonable.UnitSize()
 		};
 
 	let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 	if (cmpUnitAI)
 		ret.unitAI = {
 			"state": cmpUnitAI.GetCurrentState(),
 			"orders": cmpUnitAI.GetOrders(),
 			"hasWorkOrders": cmpUnitAI.HasWorkOrders(),
 			"canGuard": cmpUnitAI.CanGuard(),
 			"isGuarding": cmpUnitAI.IsGuardOf(),
 			"canPatrol": cmpUnitAI.CanPatrol(),
 			"selectableStances": cmpUnitAI.GetSelectableStances(),
 			"isIdle": cmpUnitAI.IsIdle()
 		};
 
 	let cmpGuard = Engine.QueryInterface(ent, IID_Guard);
 	if (cmpGuard)
 		ret.guard = {
 			"entities": cmpGuard.GetEntities()
 		};
 
 	let cmpResourceGatherer = Engine.QueryInterface(ent, IID_ResourceGatherer);
 	if (cmpResourceGatherer)
 	{
 		ret.resourceCarrying = cmpResourceGatherer.GetCarryingStatus();
 		ret.resourceGatherRates = cmpResourceGatherer.GetGatherRates();
 	}
 
 	let cmpGate = Engine.QueryInterface(ent, IID_Gate);
 	if (cmpGate)
 		ret.gate = {
 			"locked": cmpGate.IsLocked()
 		};
 
 	let cmpAlertRaiser = Engine.QueryInterface(ent, IID_AlertRaiser);
 	if (cmpAlertRaiser)
 		ret.alertRaiser = true;
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	ret.visibility = cmpRangeManager.GetLosVisibility(ent, player);
 
 	let cmpAttack = Engine.QueryInterface(ent, IID_Attack);
 	if (cmpAttack)
 	{
 		let types = cmpAttack.GetAttackTypes();
 		if (types.length)
 			ret.attack = {};
 
 		for (let type of types)
 		{
 			ret.attack[type] = {};
 
 			Object.assign(ret.attack[type], cmpAttack.GetAttackEffectsData(type));
 
 			ret.attack[type].attackName = cmpAttack.GetAttackName(type);
 
 			ret.attack[type].splash = cmpAttack.GetSplashData(type);
 			if (ret.attack[type].splash)
 				Object.assign(ret.attack[type].splash, cmpAttack.GetAttackEffectsData(type, true));
 
 			let range = cmpAttack.GetRange(type);
 			ret.attack[type].minRange = range.min;
 			ret.attack[type].maxRange = range.max;
 
 			let timers = cmpAttack.GetTimers(type);
 			ret.attack[type].prepareTime = timers.prepare;
 			ret.attack[type].repeatTime = timers.repeat;
 
 			if (type != "Ranged")
 			{
 				// Not a ranged attack, set some defaults.
 				ret.attack[type].elevationBonus = 0;
 				ret.attack[type].elevationAdaptedRange = ret.attack.maxRange;
 				continue;
 			}
 
 			ret.attack[type].elevationBonus = range.elevationBonus;
 
 			if (cmpPosition && cmpPosition.IsInWorld())
 				// For units, take the range in front of it, no spread, so angle = 0,
 				// else, take the average elevation around it: angle = 2 * pi.
 				ret.attack[type].elevationAdaptedRange = cmpRangeManager.GetElevationAdaptedRange(cmpPosition.GetPosition(), cmpPosition.GetRotation(), range.max, range.elevationBonus, cmpUnitAI ? 0 : 2 * Math.PI);
 			else
 				// Not in world, set a default?
 				ret.attack[type].elevationAdaptedRange = ret.attack.maxRange;
 		}
 	}
 
 	let cmpResistance = Engine.QueryInterface(ent, IID_Resistance);
 	if (cmpResistance)
 		ret.resistance = cmpResistance.GetResistanceOfForm(cmpFoundation ? "Foundation" : "Entity");
 
 	let cmpBuildingAI = Engine.QueryInterface(ent, IID_BuildingAI);
 	if (cmpBuildingAI)
 		ret.buildingAI = {
 			"defaultArrowCount": cmpBuildingAI.GetDefaultArrowCount(),
 			"maxArrowCount": cmpBuildingAI.GetMaxArrowCount(),
 			"garrisonArrowMultiplier": cmpBuildingAI.GetGarrisonArrowMultiplier(),
 			"garrisonArrowClasses": cmpBuildingAI.GetGarrisonArrowClasses(),
 			"arrowCount": cmpBuildingAI.GetArrowCount()
 		};
 
 	if (cmpPosition && cmpPosition.GetTurretParent() != INVALID_ENTITY)
 		ret.turretParent = cmpPosition.GetTurretParent();
 
 	let cmpResourceSupply = QueryMiragedInterface(ent, IID_ResourceSupply);
 	if (cmpResourceSupply)
 		ret.resourceSupply = {
 			"isInfinite": cmpResourceSupply.IsInfinite(),
 			"max": cmpResourceSupply.GetMaxAmount(),
 			"amount": cmpResourceSupply.GetCurrentAmount(),
 			"type": cmpResourceSupply.GetType(),
 			"killBeforeGather": cmpResourceSupply.GetKillBeforeGather(),
 			"maxGatherers": cmpResourceSupply.GetMaxGatherers(),
 			"numGatherers": cmpResourceSupply.GetNumGatherers()
 		};
 
 	let cmpResourceDropsite = Engine.QueryInterface(ent, IID_ResourceDropsite);
 	if (cmpResourceDropsite)
 		ret.resourceDropsite = {
 			"types": cmpResourceDropsite.GetTypes(),
 			"sharable": cmpResourceDropsite.IsSharable(),
 			"shared": cmpResourceDropsite.IsShared()
 		};
 
 	let cmpPromotion = Engine.QueryInterface(ent, IID_Promotion);
 	if (cmpPromotion)
 		ret.promotion = {
 			"curr": cmpPromotion.GetCurrentXp(),
 			"req": cmpPromotion.GetRequiredXp()
 		};
 
 	if (!cmpFoundation && cmpIdentity && cmpIdentity.HasClass("Barter"))
 		ret.isBarterMarket = true;
 
 	let cmpHeal = Engine.QueryInterface(ent, IID_Heal);
 	if (cmpHeal)
 		ret.heal = {
 			"health": cmpHeal.GetHealth(),
 			"range": cmpHeal.GetRange().max,
 			"interval": cmpHeal.GetInterval(),
 			"unhealableClasses": cmpHeal.GetUnhealableClasses(),
 			"healableClasses": cmpHeal.GetHealableClasses()
 		};
 
 	let cmpLoot = Engine.QueryInterface(ent, IID_Loot);
 	if (cmpLoot)
 	{
 		ret.loot = cmpLoot.GetResources();
 		ret.loot.xp = cmpLoot.GetXp();
 	}
 
 	let cmpResourceTrickle = Engine.QueryInterface(ent, IID_ResourceTrickle);
 	if (cmpResourceTrickle)
 		ret.resourceTrickle = {
 			"interval": cmpResourceTrickle.GetInterval(),
 			"rates": cmpResourceTrickle.GetRates()
 		};
 
 	let cmpTreasure = Engine.QueryInterface(ent, IID_Treasure);
 	if (cmpTreasure)
 		ret.treasure = {
 			"collectTime": cmpTreasure.CollectionTime(),
 			"resources": cmpTreasure.Resources()
 		};
 
 	let cmpTreasureCollecter = Engine.QueryInterface(ent, IID_TreasureCollecter);
 	if (cmpTreasureCollecter)
 		ret.treasureCollecter = true;
 
 	let cmpUnitMotion = Engine.QueryInterface(ent, IID_UnitMotion);
 	if (cmpUnitMotion)
 		ret.speed = {
 			"walk": cmpUnitMotion.GetWalkSpeed(),
 			"run": cmpUnitMotion.GetWalkSpeed() * cmpUnitMotion.GetRunMultiplier()
 		};
 
 	return ret;
 };
 
 GuiInterface.prototype.GetMultipleEntityStates = function(player, ents)
 {
 	return ents.map(ent => ({ "entId": ent, "state": this.GetEntityState(player, ent) }));
 };
 
 GuiInterface.prototype.GetAverageRangeForBuildings = function(player, cmd)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 
 	let rot = { "x": 0, "y": 0, "z": 0 };
 	let pos = {
 		"x": cmd.x,
 		"y": cmpTerrain.GetGroundLevel(cmd.x, cmd.z),
 		"z": cmd.z
 	};
 
 	let elevationBonus = cmd.elevationBonus || 0;
 	let range = cmd.range;
 
 	return cmpRangeManager.GetElevationAdaptedRange(pos, rot, range, elevationBonus, 2 * Math.PI);
 };
 
 GuiInterface.prototype.GetTemplateData = function(player, data)
 {
 	let templateName = data.templateName;
 	let owner = data.player !== undefined ? data.player : player;
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let template = cmpTemplateManager.GetTemplate(templateName);
 
 	if (!template)
 		return null;
 
 	let aurasTemplate = {};
 
 	if (!template.Auras)
 		return GetTemplateDataHelper(template, owner, aurasTemplate);
 
 	let auraNames = template.Auras._string.split(/\s+/);
 
 	for (let name of auraNames)
 	{
 		let auraTemplate = AuraTemplates.Get(name);
 		if (!auraTemplate)
 			error("Template " + templateName + " has undefined aura " + name);
 		else
 			aurasTemplate[name] = auraTemplate;
 	}
 
 	return GetTemplateDataHelper(template, owner, aurasTemplate);
 };
 
 GuiInterface.prototype.IsTechnologyResearched = function(player, data)
 {
 	if (!data.tech)
 		return true;
 
 	let cmpTechnologyManager = QueryPlayerIDInterface(data.player !== undefined ? data.player : player, IID_TechnologyManager);
 	if (!cmpTechnologyManager)
 		return false;
 
 	return cmpTechnologyManager.IsTechnologyResearched(data.tech);
 };
 
 /**
  * Checks whether the requirements for this technology have been met.
  */
 GuiInterface.prototype.CheckTechnologyRequirements = function(player, data)
 {
 	let cmpTechnologyManager = QueryPlayerIDInterface(data.player !== undefined ? data.player : player, IID_TechnologyManager);
 	if (!cmpTechnologyManager)
 		return false;
 
 	return cmpTechnologyManager.CanResearch(data.tech);
 };
 
 /**
  * Returns technologies that are being actively researched, along with
  * which entity is researching them and how far along the research is.
  */
 GuiInterface.prototype.GetStartedResearch = function(player)
 {
 	let cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
 	if (!cmpTechnologyManager)
 		return {};
 
 	let ret = {};
 	for (let tech of cmpTechnologyManager.GetStartedTechs())
 	{
 		ret[tech] = { "researcher": cmpTechnologyManager.GetResearcher(tech) };
 		let cmpProductionQueue = Engine.QueryInterface(ret[tech].researcher, IID_ProductionQueue);
 		if (cmpProductionQueue)
 		{
 			ret[tech].progress = cmpProductionQueue.GetQueue()[0].progress;
 			ret[tech].timeRemaining = cmpProductionQueue.GetQueue()[0].timeRemaining;
 		}
 		else
 		{
 			ret[tech].progress = 0;
 			ret[tech].timeRemaining = 0;
 		}
 	}
 	return ret;
 };
 
 /**
  * Returns the battle state of the player.
  */
 GuiInterface.prototype.GetBattleState = function(player)
 {
 	let cmpBattleDetection = QueryPlayerIDInterface(player, IID_BattleDetection);
 	if (!cmpBattleDetection)
 		return false;
 
 	return cmpBattleDetection.GetState();
 };
 
 /**
  * Returns a list of ongoing attacks against the player.
  */
 GuiInterface.prototype.GetIncomingAttacks = function(player)
 {
 	let cmpAttackDetection = QueryPlayerIDInterface(player, IID_AttackDetection);
 	if (!cmpAttackDetection)
 		return [];
 
 	return cmpAttackDetection.GetIncomingAttacks();
 };
 
 /**
  * Used to show a red square over GUI elements you can't yet afford.
  */
 GuiInterface.prototype.GetNeededResources = function(player, data)
 {
 	let cmpPlayer = QueryPlayerIDInterface(data.player !== undefined ? data.player : player);
 	return cmpPlayer ? cmpPlayer.GetNeededResources(data.cost) : {};
 };
 
 /**
  * State of the templateData (player dependent): true when some template values have been modified
  * and need to be reloaded by the gui.
  */
 GuiInterface.prototype.OnTemplateModification = function(msg)
 {
 	this.templateModified[msg.player] = true;
 	this.selectionDirty[msg.player] = true;
 };
 
 GuiInterface.prototype.IsTemplateModified = function(player)
 {
 	return this.templateModified[player] || false;
 };
 
 GuiInterface.prototype.ResetTemplateModified = function()
 {
 	this.templateModified = {};
 };
 
 /**
  * Some changes may require an update to the selection panel,
  * which is cached for efficiency. Inform the GUI it needs reloading.
  */
 GuiInterface.prototype.OnDisabledTemplatesChanged = function(msg)
 {
 	this.selectionDirty[msg.player] = true;
 };
 
 GuiInterface.prototype.OnDisabledTechnologiesChanged = function(msg)
 {
 	this.selectionDirty[msg.player] = true;
 };
 
 GuiInterface.prototype.SetSelectionDirty = function(player)
 {
 	this.selectionDirty[player] = true;
 };
 
 GuiInterface.prototype.IsSelectionDirty = function(player)
 {
 	return this.selectionDirty[player] || false;
 };
 
 GuiInterface.prototype.ResetSelectionDirty = function()
 {
 	this.selectionDirty = {};
 };
 
 /**
  * Add a timed notification.
  * Warning: timed notifacations are serialised
  * (to also display them on saved games or after a rejoin)
  * so they should allways be added and deleted in a deterministic way.
  */
 GuiInterface.prototype.AddTimeNotification = function(notification, duration = 10000)
 {
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	notification.endTime = duration + cmpTimer.GetTime();
 	notification.id = ++this.timeNotificationID;
 
 	// Let all players and observers receive the notification by default.
 	if (!notification.players)
 	{
 		notification.players = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetAllPlayers();
 		notification.players[0] = -1;
 	}
 
 	this.timeNotifications.push(notification);
 	this.timeNotifications.sort((n1, n2) => n2.endTime - n1.endTime);
 
 	cmpTimer.SetTimeout(this.entity, IID_GuiInterface, "DeleteTimeNotification", duration, this.timeNotificationID);
 
 	return this.timeNotificationID;
 };
 
 GuiInterface.prototype.DeleteTimeNotification = function(notificationID)
 {
 	this.timeNotifications = this.timeNotifications.filter(n => n.id != notificationID);
 };
 
 GuiInterface.prototype.GetTimeNotifications = function(player)
 {
 	let time = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
 	// Filter on players and time, since the delete timer might be executed with a delay.
 	return this.timeNotifications.filter(n => n.players.indexOf(player) != -1 && n.endTime > time);
 };
 
 GuiInterface.prototype.PushNotification = function(notification)
 {
 	if (!notification.type || notification.type == "text")
 		this.AddTimeNotification(notification);
 	else
 		this.notifications.push(notification);
 };
 
 GuiInterface.prototype.GetNotifications = function()
 {
 	let n = this.notifications;
 	this.notifications = [];
 	return n;
 };
 
 GuiInterface.prototype.GetAvailableFormations = function(player, wantedPlayer)
 {
 	let cmpPlayer = QueryPlayerIDInterface(wantedPlayer);
 	if (!cmpPlayer)
 		return [];
 
 	return cmpPlayer.GetFormations();
 };
 
 GuiInterface.prototype.GetFormationRequirements = function(player, data)
 {
 	return GetFormationRequirements(data.formationTemplate);
 };
 
 GuiInterface.prototype.CanMoveEntsIntoFormation = function(player, data)
 {
 	return CanMoveEntsIntoFormation(data.ents, data.formationTemplate);
 };
 
 GuiInterface.prototype.GetFormationInfoFromTemplate = function(player, data)
 {
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let template = cmpTemplateManager.GetTemplate(data.templateName);
 
 	if (!template || !template.Formation)
 		return {};
 
 	return {
 		"name": template.Formation.FormationName,
 		"tooltip": template.Formation.DisabledTooltip || "",
 		"icon": template.Formation.Icon
 	};
 };
 
 GuiInterface.prototype.IsFormationSelected = function(player, data)
 {
 	return data.ents.some(ent => {
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		return cmpUnitAI && cmpUnitAI.GetFormationTemplate() == data.formationTemplate;
 	});
 };
 
 GuiInterface.prototype.IsStanceSelected = function(player, data)
 {
 	for (let ent of data.ents)
 	{
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		if (cmpUnitAI && cmpUnitAI.GetStanceName() == data.stance)
 			return true;
 	}
 	return false;
 };
 
 GuiInterface.prototype.GetAllBuildableEntities = function(player, cmd)
 {
 	let buildableEnts = [];
 	for (let ent of cmd.entities)
 	{
 		let cmpBuilder = Engine.QueryInterface(ent, IID_Builder);
 		if (!cmpBuilder)
 			continue;
 
 		for (let building of cmpBuilder.GetEntitiesList())
 			if (buildableEnts.indexOf(building) == -1)
 				buildableEnts.push(building);
 	}
 	return buildableEnts;
 };
 
 GuiInterface.prototype.UpdateDisplayedPlayerColors = function(player, data)
 {
 	let updateEntityColor = (iids, entities) => {
 		for (let ent of entities)
 			for (let iid of iids)
 			{
 				let cmp = Engine.QueryInterface(ent, iid);
 				if (cmp)
 					cmp.UpdateColor();
 			}
 	};
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
 	for (let i = 1; i < numPlayers; ++i)
 	{
 		let cmpPlayer = QueryPlayerIDInterface(i, IID_Player);
 		if (!cmpPlayer)
 			continue;
 
 		cmpPlayer.SetDisplayDiplomacyColor(data.displayDiplomacyColors);
 		if (data.displayDiplomacyColors)
 			cmpPlayer.SetDiplomacyColor(data.displayedPlayerColors[i]);
 
 		updateEntityColor(data.showAllStatusBars && (i == player || player == -1) ?
 			[IID_Minimap, IID_RangeOverlayRenderer, IID_RallyPointRenderer, IID_StatusBars] :
 			[IID_Minimap, IID_RangeOverlayRenderer, IID_RallyPointRenderer],
 		cmpRangeManager.GetEntitiesByPlayer(i));
 	}
 	updateEntityColor([IID_Selectable, IID_StatusBars], data.selected);
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager).UpdateColors();
 };
 
 GuiInterface.prototype.SetSelectionHighlight = function(player, cmd)
 {
 	// Cache of owner -> color map
 	let playerColors = {};
 
 	for (let ent of cmd.entities)
 	{
 		let cmpSelectable = Engine.QueryInterface(ent, IID_Selectable);
 		if (!cmpSelectable)
 			continue;
 
 		// Find the entity's owner's color.
 		let owner = INVALID_PLAYER;
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (cmpOwnership)
 			owner = cmpOwnership.GetOwner();
 
 		let color = playerColors[owner];
 		if (!color)
 		{
 			color = { "r": 1, "g": 1, "b": 1 };
 			let cmpPlayer = QueryPlayerIDInterface(owner);
 			if (cmpPlayer)
 				color = cmpPlayer.GetDisplayedColor();
 			playerColors[owner] = color;
 		}
 
 		cmpSelectable.SetSelectionHighlight({ "r": color.r, "g": color.g, "b": color.b, "a": cmd.alpha }, cmd.selected);
 
 		let cmpRangeOverlayManager = Engine.QueryInterface(ent, IID_RangeOverlayManager);
 		if (!cmpRangeOverlayManager || player != owner && player != INVALID_PLAYER)
 			continue;
 
 		cmpRangeOverlayManager.SetEnabled(cmd.selected, this.enabledVisualRangeOverlayTypes, false);
 	}
 };
 
 GuiInterface.prototype.EnableVisualRangeOverlayType = function(player, data)
 {
 	this.enabledVisualRangeOverlayTypes[data.type] = data.enabled;
 };
 
 GuiInterface.prototype.GetEntitiesWithStatusBars = function()
 {
 	return Array.from(this.entsWithAuraAndStatusBars);
 };
 
 GuiInterface.prototype.SetStatusBars = function(player, cmd)
 {
 	let affectedEnts = new Set();
 	for (let ent of cmd.entities)
 	{
 		let cmpStatusBars = Engine.QueryInterface(ent, IID_StatusBars);
 		if (!cmpStatusBars)
 			continue;
 		cmpStatusBars.SetEnabled(cmd.enabled, cmd.showRank, cmd.showExperience);
 
 		let cmpAuras = Engine.QueryInterface(ent, IID_Auras);
 		if (!cmpAuras)
 			continue;
 
 		for (let name of cmpAuras.GetAuraNames())
 		{
 			if (!cmpAuras.GetOverlayIcon(name))
 				continue;
 			for (let e of cmpAuras.GetAffectedEntities(name))
 				affectedEnts.add(e);
 			if (cmd.enabled)
 				this.entsWithAuraAndStatusBars.add(ent);
 			else
 				this.entsWithAuraAndStatusBars.delete(ent);
 		}
 	}
 
 	for (let ent of affectedEnts)
 	{
 		let cmpStatusBars = Engine.QueryInterface(ent, IID_StatusBars);
 		if (cmpStatusBars)
 			cmpStatusBars.RegenerateSprites();
 	}
 };
 
 GuiInterface.prototype.SetRangeOverlays = function(player, cmd)
 {
 	for (let ent of cmd.entities)
 	{
 		let cmpRangeOverlayManager = Engine.QueryInterface(ent, IID_RangeOverlayManager);
 		if (cmpRangeOverlayManager)
 			cmpRangeOverlayManager.SetEnabled(cmd.enabled, this.enabledVisualRangeOverlayTypes, true);
 	}
 };
 
 GuiInterface.prototype.GetPlayerEntities = function(player)
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetEntitiesByPlayer(player);
 };
 
 GuiInterface.prototype.GetNonGaiaEntities = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetNonGaiaEntities();
 };
 
 /**
  * Displays the rally points of a given list of entities (carried in cmd.entities).
  *
  * The 'cmd' object may carry its own x/z coordinate pair indicating the location where the rally point should
  * be rendered, in order to support instantaneously rendering a rally point marker at a specified location
  * instead of incurring a delay while PostNetworkCommand processes the set-rallypoint command (see input.js).
  * If cmd doesn't carry a custom location, then the position to render the marker at will be read from the
  * RallyPoint component.
  */
 GuiInterface.prototype.DisplayRallyPoint = function(player, cmd)
 {
 	let cmpPlayer = QueryPlayerIDInterface(player);
 
 	// If there are some rally points already displayed, first hide them.
 	for (let ent of this.entsRallyPointsDisplayed)
 	{
 		let cmpRallyPointRenderer = Engine.QueryInterface(ent, IID_RallyPointRenderer);
 		if (cmpRallyPointRenderer)
 			cmpRallyPointRenderer.SetDisplayed(false);
 	}
 
 	this.entsRallyPointsDisplayed = [];
 
 	// Show the rally points for the passed entities.
 	for (let ent of cmd.entities)
 	{
 		let cmpRallyPointRenderer = Engine.QueryInterface(ent, IID_RallyPointRenderer);
 		if (!cmpRallyPointRenderer)
 			continue;
 
 		// Entity must have a rally point component to display a rally point marker
 		// (regardless of whether cmd specifies a custom location).
 		let cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 		if (!cmpRallyPoint)
 			continue;
 
 		// Verify the owner.
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (!(cmpPlayer && cmpPlayer.CanControlAllUnits()))
 			if (!cmpOwnership || cmpOwnership.GetOwner() != player)
 				continue;
 
 		// If the command was passed an explicit position, use that and
 		// override the real rally point position; otherwise use the real position.
 		let pos;
 		if (cmd.x && cmd.z)
 			pos = cmd;
 		else
 			// May return undefined if no rally point is set.
 			pos = cmpRallyPoint.GetPositions()[0];
 
 		if (pos)
 		{
 			// Only update the position if we changed it (cmd.queued is set).
 			// Note that Add-/SetPosition take a CFixedVector2D which has X/Y components, not X/Z.
 			if ("queued" in cmd)
 			{
 				if (cmd.queued == true)
 					cmpRallyPointRenderer.AddPosition(new Vector2D(pos.x, pos.z));
 				else
 					cmpRallyPointRenderer.SetPosition(new Vector2D(pos.x, pos.z));
 			}
 			else if (!cmpRallyPointRenderer.IsSet())
 				// Rebuild the renderer when not set (when reading saved game or in case of building update).
 				for (let posi of cmpRallyPoint.GetPositions())
 					cmpRallyPointRenderer.AddPosition(new Vector2D(posi.x, posi.z));
 
 			cmpRallyPointRenderer.SetDisplayed(true);
 
 			// Remember which entities have their rally points displayed so we can hide them again.
 			this.entsRallyPointsDisplayed.push(ent);
 		}
 	}
 };
 
 GuiInterface.prototype.AddTargetMarker = function(player, cmd)
 {
 	let ent = Engine.AddLocalEntity(cmd.template);
 	if (!ent)
 		return;
 
 	let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	cmpPosition.JumpTo(cmd.x, cmd.z);
 };
 
 /**
  * Display the building placement preview.
  * cmd.template is the name of the entity template, or "" to disable the preview.
  * cmd.x, cmd.z, cmd.angle give the location.
  *
  * Returns result object from CheckPlacement:
  * 	{
  *		"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 message
  *		"translateMessage":    localisation info
  *		"translateParameters": localisation info
  *		"pluralMessage":       we might return a plural translation instead (optional)
  *		"pluralCount":         localisation info (optional)
  *  }
  */
 GuiInterface.prototype.SetBuildingPlacementPreview = function(player, cmd)
 {
 	let result = {
 		"success": false,
 		"message": "",
 		"parameters": {},
 		"translateMessage": false,
 		"translateParameters": []
 	};
 
 	if (!this.placementEntity || this.placementEntity[0] != cmd.template)
 	{
 		if (this.placementEntity)
 			Engine.DestroyEntity(this.placementEntity[1]);
 
 		if (cmd.template == "")
 			this.placementEntity = undefined;
 		else
 			this.placementEntity = [cmd.template, Engine.AddLocalEntity("preview|" + cmd.template)];
 	}
 
 	if (this.placementEntity)
 	{
 		let ent = this.placementEntity[1];
 
 		let pos = Engine.QueryInterface(ent, IID_Position);
 		if (pos)
 		{
 			pos.JumpTo(cmd.x, cmd.z);
 			pos.SetYRotation(cmd.angle);
 		}
 
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		cmpOwnership.SetOwner(player);
 
 		let cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 		if (!cmpBuildRestrictions)
 			error("cmpBuildRestrictions not defined");
 		else
 			result = cmpBuildRestrictions.CheckPlacement();
 
 		let cmpRangeOverlayManager = Engine.QueryInterface(ent, IID_RangeOverlayManager);
 		if (cmpRangeOverlayManager)
 			cmpRangeOverlayManager.SetEnabled(true, this.enabledVisualRangeOverlayTypes);
 
 		// Set it to a red shade if this is an invalid location.
 		let cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 		if (cmpVisual)
 		{
 			if (cmd.actorSeed !== undefined)
 				cmpVisual.SetActorSeed(cmd.actorSeed);
 
 			if (!result.success)
 				cmpVisual.SetShadingColor(1.4, 0.4, 0.4, 1);
 			else
 				cmpVisual.SetShadingColor(1, 1, 1, 1);
 		}
 	}
 
 	return result;
 };
 
 /**
  * Previews the placement of a wall between cmd.start and cmd.end, or just the starting piece of a wall if cmd.end is not
  * specified. Returns an object with information about the list of entities that need to be newly constructed to complete
  * at least a part of the wall, or false if there are entities required to build at least part of the wall but none of
  * them can be validly constructed.
  *
  * It's important to distinguish between three lists of entities that are at play here, because they may be subsets of one
  * another depending on things like snapping and whether some of the entities inside them can be validly positioned.
  * We have:
  *    - The list of entities that previews the wall. This list is usually equal to the entities required to construct the
  *      entire wall. However, if there is snapping to an incomplete tower (i.e. a foundation), it includes extra entities
  *      to preview the completed tower on top of its foundation.
  *
  *    - The list of entities that need to be newly constructed to build the entire wall. This list is regardless of whether
  *      any of them can be validly positioned. The emphasishere here is on 'newly'; this list does not include any existing
  *      towers at either side of the wall that we snapped to. Or, more generally; it does not include any _entities_ that we
  *      snapped to; we might still snap to e.g. terrain, in which case the towers on either end will still need to be newly
  *      constructed.
  *
  *    - The list of entities that need to be newly constructed to build at least a part of the wall. This list is the same
  *      as the one above, except that it is truncated at the first entity that cannot be validly positioned. This happens
  *      e.g. if the player tries to build a wall straight through an obstruction. Note that any entities that can be validly
  *      constructed but come after said first invalid entity are also truncated away.
  *
  * With this in mind, this method will return false if the second list is not empty, but the third one is. That is, if there
  * were entities that are needed to build the wall, but none of them can be validly constructed. False is also returned in
  * case of unexpected errors (typically missing components), and when clearing the preview by passing an empty wallset
  * argument (see below). Otherwise, it will return an object with the following information:
  *
  * result: {
  *   'startSnappedEnt':   ID of the entity that we snapped to at the starting side of the wall. Currently only supports towers.
  *   'endSnappedEnt':     ID of the entity that we snapped to at the (possibly truncated) ending side of the wall. Note that this
  *                        can only be set if no truncation of the second list occurs; if we snapped to an entity at the ending side
  *                        but the wall construction was truncated before we could reach it, it won't be set here. Currently only
  *                        supports towers.
  *   'pieces':            Array with the following data for each of the entities in the third list:
  *    [{
  *       'template':      Template name of the entity.
  *       'x':             X coordinate of the entity's position.
  *       'z':             Z coordinate of the entity's position.
  *       'angle':         Rotation around the Y axis of the entity (in radians).
  *     },
  *     ...]
  *   'cost': {            The total cost required for constructing all the pieces as listed above.
  *     'food': ...,
  *     'wood': ...,
  *     'stone': ...,
  *     'metal': ...,
  *     'population': ...,
  *   }
  * }
  *
  * @param cmd.wallSet Object holding the set of wall piece template names. Set to an empty value to clear the preview.
  * @param cmd.start Starting point of the wall segment being created.
  * @param cmd.end (Optional) Ending point of the wall segment being created. If not defined, it is understood that only
  *                 the starting point of the wall is available at this time (e.g. while the player is still in the process
  *                 of picking a starting point), and that therefore only the first entity in the wall (a tower) should be
  *                 previewed.
  * @param cmd.snapEntities List of candidate entities to snap the start and ending positions to.
  */
 GuiInterface.prototype.SetWallPlacementPreview = function(player, cmd)
 {
 	let wallSet = cmd.wallSet;
 
 	// Did the start position snap to anything?
 	// If we snapped, was it to an entity? If yes, hold that entity's ID.
 	let start = {
 		"pos": cmd.start,
 		"angle": 0,
 		"snapped": false,
 		"snappedEnt": INVALID_ENTITY
 	};
 
 	// Did the end position snap to anything?
 	// If we snapped, was it to an entity? If yes, hold that entity's ID.
 	let end = {
 		"pos": cmd.end,
 		"angle": 0,
 		"snapped": false,
 		"snappedEnt": INVALID_ENTITY
 	};
 
 	// --------------------------------------------------------------------------------
 	// Do some entity cache management and check for snapping.
 
 	if (!this.placementWallEntities)
 		this.placementWallEntities = {};
 
 	if (!wallSet)
 	{
 		// We're clearing the preview, clear the entity cache and bail.
 		for (let tpl in this.placementWallEntities)
 		{
 			for (let ent of this.placementWallEntities[tpl].entities)
 				Engine.DestroyEntity(ent);
 
 			this.placementWallEntities[tpl].numUsed = 0;
 			this.placementWallEntities[tpl].entities = [];
 			// Keep template data around.
 		}
 
 		return false;
 	}
 
 	for (let tpl in this.placementWallEntities)
 	{
 		for (let ent of this.placementWallEntities[tpl].entities)
 		{
 			let pos = Engine.QueryInterface(ent, IID_Position);
 			if (pos)
 				pos.MoveOutOfWorld();
 		}
 
 		this.placementWallEntities[tpl].numUsed = 0;
 	}
 
 	// Create cache entries for templates we haven't seen before.
 	for (let type in wallSet.templates)
 	{
 		if (type == "curves")
 			continue;
 
 		let tpl = wallSet.templates[type];
 		if (!(tpl in this.placementWallEntities))
 		{
 			this.placementWallEntities[tpl] = {
 				"numUsed": 0,
 				"entities": [],
 				"templateData": this.GetTemplateData(player, { "templateName": tpl }),
 			};
 
 			if (!this.placementWallEntities[tpl].templateData.wallPiece)
 			{
 				error("[SetWallPlacementPreview] No WallPiece component found for wall set template '" + tpl + "'");
 				return false;
 			}
 		}
 	}
 
 	// Prevent division by zero errors further on if the start and end positions are the same.
 	if (end.pos && (start.pos.x === end.pos.x && start.pos.z === end.pos.z))
 		end.pos = undefined;
 
 	// See if we need to snap the start and/or end coordinates to any of our list of snap entities. Note that, despite the list
 	// of snapping candidate entities, it might still snap to e.g. terrain features. Use the "ent" key in the returned snapping
 	// data to determine whether it snapped to an entity (if any), and to which one (see GetFoundationSnapData).
 	if (cmd.snapEntities)
 	{
 		// Value of 0.5 was determined through trial and error.
 		let snapRadius = this.placementWallEntities[wallSet.templates.tower].templateData.wallPiece.length * 0.5;
 		let startSnapData = this.GetFoundationSnapData(player, {
 			"x": start.pos.x,
 			"z": start.pos.z,
 			"template": wallSet.templates.tower,
 			"snapEntities": cmd.snapEntities,
 			"snapRadius": snapRadius,
 		});
 
 		if (startSnapData)
 		{
 			start.pos.x = startSnapData.x;
 			start.pos.z = startSnapData.z;
 			start.angle = startSnapData.angle;
 			start.snapped = true;
 
 			if (startSnapData.ent)
 				start.snappedEnt = startSnapData.ent;
 		}
 
 		if (end.pos)
 		{
 			let endSnapData = this.GetFoundationSnapData(player, {
 				"x": end.pos.x,
 				"z": end.pos.z,
 				"template": wallSet.templates.tower,
 				"snapEntities": cmd.snapEntities,
 				"snapRadius": snapRadius,
 			});
 
 			if (endSnapData)
 			{
 				end.pos.x = endSnapData.x;
 				end.pos.z = endSnapData.z;
 				end.angle = endSnapData.angle;
 				end.snapped = true;
 
 				if (endSnapData.ent)
 					end.snappedEnt = endSnapData.ent;
 			}
 		}
 	}
 
 	// Clear the single-building preview entity (we'll be rolling our own).
 	this.SetBuildingPlacementPreview(player, { "template": "" });
 
 	// --------------------------------------------------------------------------------
 	// Calculate wall placement and position preview entities.
 
 	let result = {
 		"pieces": [],
 		"cost": { "population": 0, "time": 0 }
 	};
 	for (let res of Resources.GetCodes())
 		result.cost[res] = 0;
 
 	let previewEntities = [];
 	if (end.pos)
 		// See helpers/Walls.js.
 		previewEntities = GetWallPlacement(this.placementWallEntities, wallSet, start, end);
 
 	// For wall placement, we may (and usually do) need to have wall pieces overlap each other more than would
 	// otherwise be allowed by their obstruction shapes. However, during this preview phase, this is not so much of
 	// an issue, because all preview entities have their obstruction components deactivated, meaning that their
 	// obstruction shapes do not register in the simulation and hence cannot affect it. This implies that the preview
 	// entities cannot be found to obstruct each other, which largely solves the issue of overlap between wall pieces.
 
 	// Note that they will still be obstructed by existing shapes in the simulation (that have the BLOCK_FOUNDATION
 	// flag set), which is what we want. The only exception to this is when snapping to existing towers (or
 	// foundations thereof); the wall segments that connect up to these will be found to be obstructed by the
 	// existing tower/foundation, and be shaded red to indicate that they cannot be placed there. To prevent this,
 	// we manually set the control group of the outermost wall pieces equal to those of the snapped-to towers, so
 	// that they are free from mutual obstruction (per definition of obstruction control groups). This is done by
 	// assigning them an extra "controlGroup" field, which we'll then set during the placement loop below.
 
 	// Additionally, in the situation that we're snapping to merely a foundation of a tower instead of a fully
 	// constructed one, we'll need an extra preview entity for the starting tower, which also must not be obstructed
 	// by the foundation it snaps to.
 
 	if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
 	{
 		let startEntObstruction = Engine.QueryInterface(start.snappedEnt, IID_Obstruction);
 		if (previewEntities.length && startEntObstruction)
 			previewEntities[0].controlGroups = [startEntObstruction.GetControlGroup()];
 
 		// If we're snapping to merely a foundation, add an extra preview tower and also set it to the same control group.
 		let startEntState = this.GetEntityState(player, start.snappedEnt);
 		if (startEntState.foundation)
 		{
 			let cmpPosition = Engine.QueryInterface(start.snappedEnt, IID_Position);
 			if (cmpPosition)
 				previewEntities.unshift({
 					"template": wallSet.templates.tower,
 					"pos": start.pos,
 					"angle": cmpPosition.GetRotation().y,
 					"controlGroups": [startEntObstruction ? startEntObstruction.GetControlGroup() : undefined],
 					"excludeFromResult": true // Preview only, must not appear in the result.
 				});
 		}
 	}
 	else
 	{
 		// Didn't snap to an existing entity, add the starting tower manually. To prevent odd-looking rotation jumps
 		// when shift-clicking to build a wall, reuse the placement angle that was last seen on a validly positioned
 		// wall piece.
 
 		// To illustrate the last point, consider what happens if we used some constant instead, say, 0. Issuing the
 		// build command for a wall is asynchronous, so when the preview updates after shift-clicking, the wall piece
 		// foundations are not registered yet in the simulation. This means they cannot possibly be picked in the list
 		// of candidate entities for snapping. In the next preview update, we therefore hit this case, and would rotate
 		// the preview to 0 radians. Then, after one or two simulation updates or so, the foundations register and
 		// onSimulationUpdate in session.js updates the preview again. It first grabs a new list of snapping candidates,
 		// which this time does include the new foundations; so we snap to the entity, and rotate the preview back to
 		// the foundation's angle.
 
 		// The result is a noticeable rotation to 0 and back, which is undesirable. So, for a split second there until
 		// the simulation updates, we fake it by reusing the last angle and hope the player doesn't notice.
 		previewEntities.unshift({
 			"template": wallSet.templates.tower,
 			"pos": start.pos,
 			"angle": previewEntities.length ? previewEntities[0].angle : this.placementWallLastAngle
 		});
 	}
 
 	if (end.pos)
 	{
 		// Analogous to the starting side case above.
 		if (end.snappedEnt && end.snappedEnt != INVALID_ENTITY)
 		{
 			let endEntObstruction = Engine.QueryInterface(end.snappedEnt, IID_Obstruction);
 
 			// Note that it's possible for the last entity in previewEntities to be the same as the first, i.e. the
 			// same wall piece snapping to both a starting and an ending tower. And it might be more common than you would
 			// expect; the allowed overlap between wall segments and towers facilitates this to some degree. To deal with
 			// the possibility of dual initial control groups, we use a '.controlGroups' array rather than a single
 			// '.controlGroup' property. Note that this array can only ever have 0, 1 or 2 elements (checked at a later time).
 			if (previewEntities.length > 0 && endEntObstruction)
 			{
 				previewEntities[previewEntities.length - 1].controlGroups = previewEntities[previewEntities.length - 1].controlGroups || [];
 				previewEntities[previewEntities.length - 1].controlGroups.push(endEntObstruction.GetControlGroup());
 			}
 
 			// If we're snapping to a foundation, add an extra preview tower and also set it to the same control group.
 			let endEntState = this.GetEntityState(player, end.snappedEnt);
 			if (endEntState.foundation)
 			{
 				let cmpPosition = Engine.QueryInterface(end.snappedEnt, IID_Position);
 				if (cmpPosition)
 					previewEntities.push({
 						"template": wallSet.templates.tower,
 						"pos": end.pos,
 						"angle": cmpPosition.GetRotation().y,
 						"controlGroups": [endEntObstruction ? endEntObstruction.GetControlGroup() : undefined],
 						"excludeFromResult": true
 					});
 			}
 		}
 		else
 			previewEntities.push({
 				"template": wallSet.templates.tower,
 				"pos": end.pos,
 				"angle": previewEntities.length ? previewEntities[previewEntities.length - 1].angle : this.placementWallLastAngle
 			});
 	}
 
 	let cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 	if (!cmpTerrain)
 	{
 		error("[SetWallPlacementPreview] System Terrain component not found");
 		return false;
 	}
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (!cmpRangeManager)
 	{
 		error("[SetWallPlacementPreview] System RangeManager component not found");
 		return false;
 	}
 
 	// Loop through the preview entities, and construct the subset of them that need to be, and can be, validly constructed
 	// to build at least a part of the wall (meaning that the subset is truncated after the first entity that needs to be,
 	// but cannot validly be, constructed). See method-level documentation for more details.
 
 	let allPiecesValid = true;
 	// Number of entities that are required to build the entire wall, regardless of validity.
 	let numRequiredPieces = 0;
 
 	for (let i = 0; i < previewEntities.length; ++i)
 	{
 		let entInfo = previewEntities[i];
 
 		let ent = null;
 		let tpl = entInfo.template;
 		let tplData = this.placementWallEntities[tpl].templateData;
 		let entPool = this.placementWallEntities[tpl];
 
 		if (entPool.numUsed >= entPool.entities.length)
 		{
 			ent = Engine.AddLocalEntity("preview|" + tpl);
 			entPool.entities.push(ent);
 		}
 		else
 			ent = entPool.entities[entPool.numUsed];
 
 		if (!ent)
 		{
 			error("[SetWallPlacementPreview] Failed to allocate or reuse preview entity of template '" + tpl + "'");
 			continue;
 		}
 
 		// Move piece to right location.
 		// TODO: Consider reusing SetBuildingPlacementReview for this, enhanced to be able to deal with multiple entities.
 		let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 		if (cmpPosition)
 		{
 			cmpPosition.JumpTo(entInfo.pos.x, entInfo.pos.z);
 			cmpPosition.SetYRotation(entInfo.angle);
 
 			// If this piece is a tower, then it should have a Y position that is at least as high as its surrounding pieces.
 			if (tpl === wallSet.templates.tower)
 			{
 				let terrainGroundPrev = null;
 				let terrainGroundNext = null;
 
 				if (i > 0)
 					terrainGroundPrev = cmpTerrain.GetGroundLevel(previewEntities[i - 1].pos.x, previewEntities[i - 1].pos.z);
 
 				if (i < previewEntities.length - 1)
 					terrainGroundNext = cmpTerrain.GetGroundLevel(previewEntities[i + 1].pos.x, previewEntities[i + 1].pos.z);
 
 				if (terrainGroundPrev != null || terrainGroundNext != null)
 				{
 					let targetY = Math.max(terrainGroundPrev, terrainGroundNext);
 					cmpPosition.SetHeightFixed(targetY);
 				}
 			}
 		}
 
 		let cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
 		if (!cmpObstruction)
 		{
 			error("[SetWallPlacementPreview] Preview entity of template '" + tpl + "' does not have an Obstruction component");
 			continue;
 		}
 
 		// Assign any predefined control groups. Note that there can only be 0, 1 or 2 predefined control groups; if there are
 		// more, we've made a programming error. The control groups are assigned from the entInfo.controlGroups array on a
 		// first-come first-served basis; the first value in the array is always assigned as the primary control group, and
 		// any second value as the secondary control group.
 
 		// By default, we reset the control groups to their standard values. Remember that we're reusing entities; if we don't
 		// reset them, then an ending wall segment that was e.g. at one point snapped to an existing tower, and is subsequently
 		// reused as a non-snapped ending wall segment, would no longer be capable of being obstructed by the same tower it was
 		// once snapped to.
 
 		let primaryControlGroup = ent;
 		let secondaryControlGroup = INVALID_ENTITY;
 
 		if (entInfo.controlGroups && entInfo.controlGroups.length > 0)
 		{
 			if (entInfo.controlGroups.length > 2)
 			{
 				error("[SetWallPlacementPreview] Encountered preview entity of template '" + tpl + "' with more than 2 initial control groups");
 				break;
 			}
 
 			primaryControlGroup = entInfo.controlGroups[0];
 			if (entInfo.controlGroups.length > 1)
 				secondaryControlGroup = entInfo.controlGroups[1];
 		}
 
 		cmpObstruction.SetControlGroup(primaryControlGroup);
 		cmpObstruction.SetControlGroup2(secondaryControlGroup);
 
 		let validPlacement = false;
 
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		cmpOwnership.SetOwner(player);
 
 		// Check whether it's in a visible or fogged region.
 		// TODO: Should definitely reuse SetBuildingPlacementPreview, this is just straight up copy/pasta.
 		let visible = cmpRangeManager.GetLosVisibility(ent, player) != "hidden";
 		if (visible)
 		{
 			let cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 			if (!cmpBuildRestrictions)
 			{
 				error("[SetWallPlacementPreview] cmpBuildRestrictions not defined for preview entity of template '" + tpl + "'");
 				continue;
 			}
 
 			// TODO: Handle results of CheckPlacement.
 			validPlacement = cmpBuildRestrictions && cmpBuildRestrictions.CheckPlacement().success;
 
 			// If a wall piece has two control groups, it's likely a segment that spans
 			// between two existing towers. To avoid placing a duplicate wall segment,
 			// check for collisions with entities that share both control groups.
 			if (validPlacement && entInfo.controlGroups && entInfo.controlGroups.length > 1)
 				validPlacement = cmpObstruction.CheckDuplicateFoundation();
 		}
 
 		allPiecesValid = allPiecesValid && validPlacement;
 
 		// The requirement below that all pieces so far have to have valid positions, rather than only this single one,
 		// ensures that no more foundations will be placed after a first invalidly-positioned piece. (It is possible
 		// for pieces past some invalidly-positioned ones to still have valid positions, e.g. if you drag a wall
 		// through and past an existing building).
 
 		// Additionally, the excludeFromResult flag is set for preview entities that were manually added to be placed
 		// on top of foundations of incompleted towers that we snapped to; they must not be part of the result.
 
 		if (!entInfo.excludeFromResult)
 			++numRequiredPieces;
 
 		if (allPiecesValid && !entInfo.excludeFromResult)
 		{
 			result.pieces.push({
 				"template": tpl,
 				"x": entInfo.pos.x,
 				"z": entInfo.pos.z,
 				"angle": entInfo.angle,
 			});
 			this.placementWallLastAngle = entInfo.angle;
 
 			// Grab the cost of this wall piece and add it up (note; preview entities don't have their Cost components
 			// copied over, so we need to fetch it from the template instead).
 			// TODO: We should really use a Cost object or at least some utility functions for this, this is mindless
 			// boilerplate that's probably duplicated in tons of places.
 			for (let res of Resources.GetCodes().concat(["population", "time"]))
 				result.cost[res] += tplData.cost[res];
 		}
 
 		let canAfford = true;
 		let cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
 		if (cmpPlayer && cmpPlayer.GetNeededResources(result.cost))
 			canAfford = false;
 
 		let cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 		if (cmpVisual)
 		{
 			if (!allPiecesValid || !canAfford)
 				cmpVisual.SetShadingColor(1.4, 0.4, 0.4, 1);
 			else
 				cmpVisual.SetShadingColor(1, 1, 1, 1);
 		}
 
 		++entPool.numUsed;
 	}
 
 	// If any were entities required to build the wall, but none of them could be validly positioned, return failure
 	// (see method-level documentation).
 	if (numRequiredPieces > 0 && result.pieces.length == 0)
 		return false;
 
 	if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
 		result.startSnappedEnt = start.snappedEnt;
 
 	// We should only return that we snapped to an entity if all pieces up until that entity can be validly constructed,
 	// i.e. are included in result.pieces (see docs for the result object).
 	if (end.pos && end.snappedEnt && end.snappedEnt != INVALID_ENTITY && allPiecesValid)
 		result.endSnappedEnt = end.snappedEnt;
 
 	return result;
 };
 
 /**
  * Given the current position {data.x, data.z} of an foundation of template data.template, returns the position and angle to snap
  * it to (if necessary/useful).
  *
  * @param data.x            The X position of the foundation to snap.
  * @param data.z            The Z position of the foundation to snap.
  * @param data.template     The template to get the foundation snapping data for.
  * @param data.snapEntities Optional; list of entity IDs to snap to if {data.x, data.z} is within a circle of radius data.snapRadius
  *                            around the entity. Only takes effect when used in conjunction with data.snapRadius.
  *                          When this option is used and the foundation is found to snap to one of the entities passed in this list
  *                            (as opposed to e.g. snapping to terrain features), then the result will contain an additional key "ent",
  *                            holding the ID of the entity that was snapped to.
  * @param data.snapRadius   Optional; when used in conjunction with data.snapEntities, indicates the circle radius around an entity that
  *                            {data.x, data.z} must be located within to have it snap to that entity.
  */
 GuiInterface.prototype.GetFoundationSnapData = function(player, data)
 {
 	let template = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).GetTemplate(data.template);
 	if (!template)
 	{
 		warn("[GetFoundationSnapData] Failed to load template '" + data.template + "'");
 		return false;
 	}
 
 	if (data.snapEntities && data.snapRadius && data.snapRadius > 0)
 	{
 		// See if {data.x, data.z} is inside the snap radius of any of the snap entities; and if so, to which it is closest.
 		// (TODO: Break unlikely ties by choosing the lowest entity ID.)
 
 		let minDist2 = -1;
 		let minDistEntitySnapData = null;
 		let radius2 = data.snapRadius * data.snapRadius;
 
 		for (let ent of data.snapEntities)
 		{
 			let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 			if (!cmpPosition || !cmpPosition.IsInWorld())
 				continue;
 
 			let pos = cmpPosition.GetPosition();
 			let dist2 = (data.x - pos.x) * (data.x - pos.x) + (data.z - pos.z) * (data.z - pos.z);
 			if (dist2 > radius2)
 				continue;
 
 			if (minDist2 < 0 || dist2 < minDist2)
 			{
 				minDist2 = dist2;
 				minDistEntitySnapData = {
 					"x": pos.x,
 					"z": pos.z,
 					"angle": cmpPosition.GetRotation().y,
 					"ent": ent
 				};
 			}
 		}
 
 		if (minDistEntitySnapData != null)
 			return minDistEntitySnapData;
 	}
 
 	if (data.snapToEdges)
 	{
 		let position = this.obstructionSnap.getPosition(data, template);
 		if (position)
 			return position;
 	}
 
 	if (template.BuildRestrictions.PlacementType == "shore")
 	{
 		let angle = GetDockAngle(template, data.x, data.z);
 		if (angle !== undefined)
 			return {
 				"x": data.x,
 				"z": data.z,
 				"angle": angle
 			};
 	}
 
 	return false;
 };
 
 GuiInterface.prototype.PlaySound = function(player, data)
 {
 	if (!data.entity)
 		return;
 
 	PlaySound(data.name, data.entity);
 };
 
 /**
  * Find any idle units.
  *
  * @param data.idleClasses		Array of class names to include.
  * @param data.prevUnit		The previous idle unit, if calling a second time to iterate through units.  May be left undefined.
  * @param data.limit			The number of idle units to return.  May be left undefined (will return all idle units).
  * @param data.excludeUnits	Array of units to exclude.
  *
  * Returns an array of idle units.
  * If multiple classes were supplied, and multiple items will be returned, the items will be sorted by class.
  */
 GuiInterface.prototype.FindIdleUnits = function(player, data)
 {
 	let idleUnits = [];
 	// The general case is that only the 'first' idle unit is required; filtering would examine every unit.
 	// This loop imitates a grouping/aggregation on the first matching idle class.
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	for (let entity of cmpRangeManager.GetEntitiesByPlayer(player))
 	{
 		let filtered = this.IdleUnitFilter(entity, data.idleClasses, data.excludeUnits);
 		if (!filtered.idle)
 			continue;
 
 		// If the entity is in the 'current' (first, 0) bucket on a resumed search, it must be after the "previous" unit, if any.
 		// By adding to the 'end', there is no pause if the series of units loops.
 		let bucket = filtered.bucket;
 		if (bucket == 0 && data.prevUnit && entity <= data.prevUnit)
 			bucket = data.idleClasses.length;
 
 		if (!idleUnits[bucket])
 			idleUnits[bucket] = [];
 		idleUnits[bucket].push(entity);
 
 		// If enough units have been collected in the first bucket, go ahead and return them.
 		if (data.limit && bucket == 0 && idleUnits[0].length == data.limit)
 			return idleUnits[0];
 	}
 
 	let reduced = idleUnits.reduce((prev, curr) => prev.concat(curr), []);
 	if (data.limit && reduced.length > data.limit)
 		return reduced.slice(0, data.limit);
 
 	return reduced;
 };
 
 /**
  * Discover if the player has idle units.
  *
  * @param data.idleClasses	Array of class names to include.
  * @param data.excludeUnits	Array of units to exclude.
  *
  * Returns a boolean of whether the player has any idle units
  */
 GuiInterface.prototype.HasIdleUnits = function(player, data)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return cmpRangeManager.GetEntitiesByPlayer(player).some(unit => this.IdleUnitFilter(unit, data.idleClasses, data.excludeUnits).idle);
 };
 
 /**
  * Whether to filter an idle unit
  *
  * @param unit			The unit to filter.
  * @param idleclasses	Array of class names to include.
  * @param excludeUnits	Array of units to exclude.
  *
  * Returns an object with the following fields:
  * 	- idle - true if the unit is considered idle by the filter, false otherwise.
  * 	- bucket - if idle, set to the index of the first matching idle class, undefined otherwise.
  */
 GuiInterface.prototype.IdleUnitFilter = function(unit, idleClasses, excludeUnits)
 {
 	let cmpUnitAI = Engine.QueryInterface(unit, IID_UnitAI);
-	if (!cmpUnitAI || !cmpUnitAI.IsIdle() || cmpUnitAI.IsTurret())
+	if (!cmpUnitAI || !cmpUnitAI.IsIdle())
+		return { "idle": false };
+
+	let cmpGarrisonable = Engine.QueryInterface(unit, IID_Garrisonable);
+	if (cmpGarrisonable && cmpGarrisonable.IsGarrisoned())
 		return { "idle": false };
 
 	let cmpIdentity = Engine.QueryInterface(unit, IID_Identity);
 	if (!cmpIdentity)
 		return { "idle": false };
 
 	let bucket = idleClasses.findIndex(elem => MatchesClassList(cmpIdentity.GetClassesList(), elem));
 	if (bucket == -1 || excludeUnits.indexOf(unit) > -1)
 		return { "idle": false };
 
 	return { "idle": true, "bucket": bucket };
 };
 
 GuiInterface.prototype.GetTradingRouteGain = function(player, data)
 {
 	if (!data.firstMarket || !data.secondMarket)
 		return null;
 
 	return CalculateTraderGain(data.firstMarket, data.secondMarket, data.template);
 };
 
 GuiInterface.prototype.GetTradingDetails = function(player, data)
 {
 	let cmpEntityTrader = Engine.QueryInterface(data.trader, IID_Trader);
 	if (!cmpEntityTrader || !cmpEntityTrader.CanTrade(data.target))
 		return null;
 
 	let firstMarket = cmpEntityTrader.GetFirstMarket();
 	let secondMarket = cmpEntityTrader.GetSecondMarket();
 	let result = null;
 	if (data.target === firstMarket)
 	{
 		result = {
 			"type": "is first",
 			"hasBothMarkets": cmpEntityTrader.HasBothMarkets()
 		};
 		if (cmpEntityTrader.HasBothMarkets())
 			result.gain = cmpEntityTrader.GetGoods().amount;
 	}
 	else if (data.target === secondMarket)
 		result = {
 			"type": "is second",
 			"gain": cmpEntityTrader.GetGoods().amount,
 		};
 	else if (!firstMarket)
 		result = { "type": "set first" };
 	else if (!secondMarket)
 		result = {
 			"type": "set second",
 			"gain": cmpEntityTrader.CalculateGain(firstMarket, data.target),
 		};
 	else
 		result = { "type": "set first" };
 
 	return result;
 };
 
 GuiInterface.prototype.CanAttack = function(player, data)
 {
 	let cmpAttack = Engine.QueryInterface(data.entity, IID_Attack);
 	return cmpAttack && cmpAttack.CanAttack(data.target, data.types || undefined);
 };
 
 /*
  * Returns batch build time.
  */
 GuiInterface.prototype.GetBatchTime = function(player, data)
 {
 	let cmpProductionQueue = Engine.QueryInterface(data.entity, IID_ProductionQueue);
 	if (!cmpProductionQueue)
 		return 0;
 
 	return cmpProductionQueue.GetBatchTime(data.batchSize);
 };
 
 GuiInterface.prototype.IsMapRevealed = function(player)
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetLosRevealAll(player);
 };
 
 GuiInterface.prototype.SetPathfinderDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder).SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetPathfinderHierDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder).SetHierDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetObstructionDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager).SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetMotionDebugOverlay = function(player, data)
 {
 	for (let ent of data.entities)
 	{
 		let cmpUnitMotion = Engine.QueryInterface(ent, IID_UnitMotion);
 		if (cmpUnitMotion)
 			cmpUnitMotion.SetDebugOverlay(data.enabled);
 	}
 };
 
 GuiInterface.prototype.SetRangeDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.GetTraderNumber = function(player)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let traders = cmpRangeManager.GetEntitiesByPlayer(player).filter(e => Engine.QueryInterface(e, IID_Trader));
 
 	let landTrader = { "total": 0, "trading": 0, "garrisoned": 0 };
 	let shipTrader = { "total": 0, "trading": 0 };
 
 	for (let ent of traders)
 	{
 		let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		if (!cmpIdentity || !cmpUnitAI)
 			continue;
 
 		if (cmpIdentity.HasClass("Ship"))
 		{
 			++shipTrader.total;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Trade")
 				++shipTrader.trading;
 		}
 		else
 		{
 			++landTrader.total;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Trade")
 				++landTrader.trading;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Garrison")
 			{
 				let holder = cmpUnitAI.order.data.target;
 				let cmpHolderUnitAI = Engine.QueryInterface(holder, IID_UnitAI);
 				if (cmpHolderUnitAI && cmpHolderUnitAI.order && cmpHolderUnitAI.order.type == "Trade")
 					++landTrader.garrisoned;
 			}
 		}
 	}
 
 	return { "landTrader": landTrader, "shipTrader": shipTrader };
 };
 
 GuiInterface.prototype.GetTradingGoods = function(player)
 {
 	let cmpPlayer = QueryPlayerIDInterface(player);
 	if (!cmpPlayer)
 		return [];
 
 	return cmpPlayer.GetTradingGoods();
 };
 
 GuiInterface.prototype.OnGlobalEntityRenamed = function(msg)
 {
 	this.renamedEntities.push(msg);
 };
 
 /**
  * List the GuiInterface functions that can be safely called by GUI scripts.
  * (GUI scripts are non-deterministic and untrusted, so these functions must be
  * appropriately careful. They are called with a first argument "player", which is
  * trusted and indicates the player associated with the current client; no data should
  * be returned unless this player is meant to be able to see it.)
  */
 let exposedFunctions = {
 
 	"GetSimulationState": 1,
 	"GetExtendedSimulationState": 1,
 	"GetInitAttributes": 1,
 	"GetReplayMetadata": 1,
 	"GetCampaignGameEndData": 1,
 	"GetRenamedEntities": 1,
 	"ClearRenamedEntities": 1,
 	"GetEntityState": 1,
 	"GetMultipleEntityStates": 1,
 	"GetAverageRangeForBuildings": 1,
 	"GetTemplateData": 1,
 	"IsTechnologyResearched": 1,
 	"CheckTechnologyRequirements": 1,
 	"GetStartedResearch": 1,
 	"GetBattleState": 1,
 	"GetIncomingAttacks": 1,
 	"GetNeededResources": 1,
 	"GetNotifications": 1,
 	"GetTimeNotifications": 1,
 
 	"GetAvailableFormations": 1,
 	"GetFormationRequirements": 1,
 	"CanMoveEntsIntoFormation": 1,
 	"IsFormationSelected": 1,
 	"GetFormationInfoFromTemplate": 1,
 	"IsStanceSelected": 1,
 
 	"UpdateDisplayedPlayerColors": 1,
 	"SetSelectionHighlight": 1,
 	"GetAllBuildableEntities": 1,
 	"SetStatusBars": 1,
 	"GetPlayerEntities": 1,
 	"GetNonGaiaEntities": 1,
 	"DisplayRallyPoint": 1,
 	"AddTargetMarker": 1,
 	"SetBuildingPlacementPreview": 1,
 	"SetWallPlacementPreview": 1,
 	"GetFoundationSnapData": 1,
 	"PlaySound": 1,
 	"FindIdleUnits": 1,
 	"HasIdleUnits": 1,
 	"GetTradingRouteGain": 1,
 	"GetTradingDetails": 1,
 	"CanAttack": 1,
 	"GetBatchTime": 1,
 
 	"IsMapRevealed": 1,
 	"SetPathfinderDebugOverlay": 1,
 	"SetPathfinderHierDebugOverlay": 1,
 	"SetObstructionDebugOverlay": 1,
 	"SetMotionDebugOverlay": 1,
 	"SetRangeDebugOverlay": 1,
 	"EnableVisualRangeOverlayType": 1,
 	"SetRangeOverlays": 1,
 
 	"GetTraderNumber": 1,
 	"GetTradingGoods": 1,
 	"IsTemplateModified": 1,
 	"ResetTemplateModified": 1,
 	"IsSelectionDirty": 1,
 	"ResetSelectionDirty": 1
 };
 
 GuiInterface.prototype.ScriptCall = function(player, name, args)
 {
 	if (exposedFunctions[name])
 		return this[name](player, args);
 
 	throw new Error("Invalid GuiInterface Call name \"" + name + "\"");
 };
 
 Engine.RegisterSystemComponentType(IID_GuiInterface, "GuiInterface", GuiInterface);
Index: ps/trunk/binaries/data/mods/public/simulation/components/ProductionQueue.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/ProductionQueue.js	(revision 25068)
+++ ps/trunk/binaries/data/mods/public/simulation/components/ProductionQueue.js	(revision 25069)
@@ -1,973 +1,973 @@
 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
 	//     "entityCache": [189, ...], // The entities created but not spawned yet.
 	//     "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.paused = false;
 
 	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.RemoveItem(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.
  * @param {string} templateName - The template to start production on.
  * @param {string} type - The type of production (i.e. "unit" or "technology").
  * @param {number} count - The amount of units to be produced. Ignored for a tech.
  * @param {any} metadata - Optionally any metadata to be attached to the item.
  *
  * @return {boolean} - Whether the addition of the item has succeeded.
  */
 ProductionQueue.prototype.AddItem = 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 false;
 	let player = cmpPlayer.GetPlayerID();
 
 	if (!this.queue.length)
 	{
 		let cmpUpgrade = Engine.QueryInterface(this.entity, IID_Upgrade);
 		if (cmpUpgrade && cmpUpgrade.IsUpgrading())
 		{
 			let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 			cmpGUIInterface.PushNotification({
 				"players": [player],
 				"message": markForTranslation("Entity is being upgraded. Cannot start production."),
 				"translateMessage": true
 			});
 			return false;
 		}
 	}
 	else if (this.queue.length >= this.MaxQueueSize)
 	{
 		let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGUIInterface.PushNotification({
 		    "players": [player],
 		    "message": markForTranslation("The production queue is full."),
 		    "translateMessage": true,
 		});
 		return false;
 	}
 
 	// ToDo: Lots of duplication here, much can probably be combined,
 	// but requires some more refactoring.
 	if (type == "unit")
 	{
 		if (!Number.isInteger(count) || count <= 0)
 		{
 			error("Invalid batch count " + count);
 			return false;
 		}
 
 		// Find the template data so we can determine the build costs.
 		let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 		let template = cmpTemplateManager.GetTemplate(this.GetUpgradedTemplate(templateName));
 		if (!template)
 			return false;
 
 		let costs = {};
 		let totalCosts = {};
 
 		for (let res in template.Cost.Resources)
 		{
 			costs[res] = ApplyValueModificationsToTemplate(
 			    "Cost/Resources/" + res,
 			    +template.Cost.Resources[res],
 			    player,
 			    template);
 
 			totalCosts[res] = Math.floor(count * costs[res]);
 		}
 
 		// TrySubtractResources should report error to player (they ran out of resources).
 		if (!cmpPlayer.TrySubtractResources(totalCosts))
 			return false;
 
 		if (template.TrainingRestrictions)
 		{
 			let unitCategory = template.TrainingRestrictions.Category;
 			let cmpPlayerEntityLimits = QueryPlayerIDInterface(player, IID_EntityLimits);
 			if (cmpPlayerEntityLimits)
 			{
 				cmpPlayerEntityLimits.ChangeCount(unitCategory, count);
 				if (template.TrainingRestrictions.MatchLimit)
 					cmpPlayerEntityLimits.ChangeMatchCount(templateName, count);
 			}
 		}
 
 		let buildTime = ApplyValueModificationsToTemplate(
 		    "Cost/BuildTime",
 		    +template.Cost.BuildTime,
 		    player,
 		    template);
 		let time = this.GetBatchTime(count) * buildTime * 1000;
 		this.queue.push({
 			"id": this.nextID++,
 			"player": player,
 			"unitTemplate": templateName,
 			"count": count,
 			"metadata": metadata,
 			"resources": costs,
 			"population": ApplyValueModificationsToTemplate(
 			    "Cost/Population",
 			    +template.Cost.Population,
 			    player,
 			    template),
 			"productionStarted": false,
 			"timeTotal": time,
 			"timeRemaining": time
 		});
 
 		let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 		cmpTrigger.CallEvent("TrainingQueued", {
 		    "playerid": player,
 		    "unitTemplate": templateName,
 		    "count": count,
 		    "metadata": metadata,
 		    "trainerEntity": this.entity
 		});
 	}
 	else if (type == "technology")
 	{
 		if (!TechnologyTemplates.Has(templateName))
 			return false;
 
 		if (!this.GetTechnologiesList().some(tech =>
 			tech &&
 				(tech == templateName ||
 					tech.pair &&
 					(tech.top == templateName || tech.bottom == templateName))))
 		{
 			error("This entity cannot research " + templateName);
 			return false;
 		}
 
 		let template = TechnologyTemplates.Get(templateName);
 		let techCostMultiplier = this.GetTechCostMultiplier();
 
 		let cost = {};
 		if (template.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 false;
 
 		// Tell the technology manager that we have started researching this
 		// such that players can't research the same thing twice.
 		let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
 		cmpTechnologyManager.QueuedResearch(templateName, this.entity);
 
 		let time = techCostMultiplier.time * (template.researchTime || 0) * 1000;
 		this.queue.push({
 		    "id": this.nextID++,
 		    "player": player,
 		    "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": player,
 		    "technologyTemplate": templateName,
 		    "researcherEntity": this.entity
 		});
 	}
 	else
 	{
 		warn("Tried to add invalid item of type \"" + type + "\" and template \"" + templateName + "\" to a production queue");
 		return false;
 	}
 
 	Engine.PostMessage(this.entity, MT_ProductionQueueChanged, null);
 
 	if (!this.timer)
 		this.StartTimer();
 	return true;
 };
 
 /*
  * Removes an item from the queue.
  * Refunds resource costs and population reservations.
  * item.player is used as this.entity's owner may have changed.
  */
 ProductionQueue.prototype.RemoveItem = function(id)
 {
 	let itemIndex = this.queue.findIndex(item => item.id == id);
 	if (itemIndex == -1)
 		return;
 
 	let item = this.queue[itemIndex];
 
 	// Destroy any cached entities (those which didn't spawn for some reason).
 	if (item.entityCache && item.entityCache.length)
 	{
 		for (let ent of item.entityCache)
 			Engine.DestroyEntity(ent);
 
 		item.entityCache = [];
 	}
 
 	// 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);
 			if (cmpPlayerEntityLimits)
 				cmpPlayerEntityLimits.ChangeCount(template.TrainingRestrictions.Category, -item.count);
 			if (template.TrainingRestrictions.MatchLimit)
 				cmpPlayerEntityLimits.ChangeMatchCount(item.unitTemplate, -item.count);
 		}
 	}
 
 	let totalCosts = {};
 	let cmpStatisticsTracker = QueryPlayerIDInterface(item.player, IID_StatisticsTracker);
 	for (let resource in item.resources)
 	{
 		totalCosts[resource] = Math.floor(item.count * item.resources[resource]);
 		if (cmpStatisticsTracker)
 			cmpStatisticsTracker.IncreaseResourceUsedCounter(resource, -totalCosts[resource]);
 	}
 
 	let cmpPlayer = QueryPlayerIDInterface(item.player);
 	if (cmpPlayer)
 	{
 		cmpPlayer.AddResources(totalCosts);
 		if (item.productionStarted && item.unitTemplate)
 			cmpPlayer.UnReservePopulationSlots(item.population * item.count);
 		if (itemIndex == 0)
 			cmpPlayer.UnBlockTraining();
 	}
 
 	if (item.technologyTemplate)
 	{
 		let cmpTechnologyManager = QueryPlayerIDInterface(item.player, IID_TechnologyManager);
 		if (cmpTechnologyManager)
 			cmpTechnologyManager.StoppedResearch(item.technologyTemplate, true);
 		this.SetAnimation("idle");
 	}
 
 	this.queue.splice(itemIndex, 1);
 	Engine.PostMessage(this.entity, MT_ProductionQueueChanged, null);
 
 	if (!this.queue.length)
 		this.StopTimer();
 };
 
 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.RemoveItem(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.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();
 };
 
 /*
  * This function creates the entities and places them in world if possible
  * (some of these entities may be garrisoned directly if autogarrison, the others are spawned).
  * @param {Object} item - The item to spawn units for.
  * @param {number} item.count - The number of entities to spawn.
  * @param {string} item.player - The owner of the item.
  * @param {string} item.unitTemplate - The template to spawn.
  * @param {any} - item.metadata - Optionally any metadata to add to the TrainingFinished message.
  *
  * @return {number} - The number of successfully created entities
  */
 ProductionQueue.prototype.SpawnUnits = function(item)
 {
 	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 (!item.entityCache)
 	{
 		item.entityCache = [];
 		for (let i = 0; i < item.count; ++i)
 			item.entityCache.push(Engine.AddEntity(item.unitTemplate));
 	}
 
 	let autoGarrison;
 	let cmpRallyPoint = Engine.QueryInterface(this.entity, IID_RallyPoint);
 	if (cmpRallyPoint)
 	{
 		let data = cmpRallyPoint.GetData()[0];
 		if (data && data.target && data.target == this.entity && data.command == "garrison")
 			autoGarrison = true;
 	}
 
 	let cmpFootprint = Engine.QueryInterface(this.entity, IID_Footprint);
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	let positionSelf = cmpPosition && cmpPosition.GetPosition();
 
 	let cmpPlayerEntityLimits = QueryPlayerIDInterface(item.player, IID_EntityLimits);
 	let cmpPlayerStatisticsTracker = QueryPlayerIDInterface(item.player, IID_StatisticsTracker);
 	while (item.entityCache.length)
 	{
 		let ent = item.entityCache[0];
 		let cmpNewOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		let garrisoned = false;
 
 		if (autoGarrison)
 		{
 			let cmpGarrisonable = Engine.QueryInterface(ent, IID_Garrisonable);
 			if (cmpGarrisonable)
 			{
 				// Temporary owner affectation needed for GarrisonHolder checks.
 				cmpNewOwnership.SetOwnerQuiet(item.player);
-				garrisoned = cmpGarrisonable.Autogarrison(this.entity);
+				garrisoned = cmpGarrisonable.Garrison(this.entity);
 				cmpNewOwnership.SetOwnerQuiet(INVALID_PLAYER);
 			}
 		}
 
 		if (!garrisoned)
 		{
 			let pos = cmpFootprint.PickSpawnPoint(ent);
 			if (pos.y < 0)
 				break;
 
 			let cmpNewPosition = Engine.QueryInterface(ent, IID_Position);
 			cmpNewPosition.JumpTo(pos.x, pos.z);
 
 			if (positionSelf)
 				cmpNewPosition.SetYRotation(positionSelf.horizAngleTo(pos));
 
 			spawnedEnts.push(ent);
 		}
 
 		// Decrement entity count in the EntityLimits component
 		// since it will be increased by EntityLimits.OnGlobalOwnershipChanged,
 		// i.e. we replace a 'trained' entity by 'alive' one.
 		// Must be done after spawn check so EntityLimits decrements only if unit spawns.
 		if (cmpPlayerEntityLimits)
 		{
 			let cmpTrainingRestrictions = Engine.QueryInterface(ent, IID_TrainingRestrictions);
 			if (cmpTrainingRestrictions)
 				cmpPlayerEntityLimits.ChangeCount(cmpTrainingRestrictions.GetCategory(), -1);
 		}
 		cmpNewOwnership.SetOwner(item.player);
 
 		if (cmpPlayerStatisticsTracker)
 			cmpPlayerStatisticsTracker.IncreaseTrainedUnitsCounter(ent);
 
 		item.entityCache.shift();
 		createdEnts.push(ent);
 	}
 
 	if (spawnedEnts.length && !autoGarrison && cmpRallyPoint)
 		for (let com of GetRallyPointCommands(cmpRallyPoint, spawnedEnts))
 			ProcessCommand(item.player, com);
 
 	if (createdEnts.length)
 	{
 		// Play a sound, but only for the first in the batch (to avoid nasty phasing effects).
 		PlaySound("trained", createdEnts[0]);
 		Engine.PostMessage(this.entity, MT_TrainingFinished, {
 		    "entities": createdEnts,
 		    "owner": item.player,
 		    "metadata": item.metadata
 		});
 	}
 
 	return createdEnts.length;
 };
 
 /*
  * Increments progress on the first item in the production queue and blocks the
  * queue if population limit is reached or some units failed to spawn.
  * @param {Object} data - Unused in this case.
  * @param {number} lateness - The time passed since the expected time to fire the function.
  */
 ProductionQueue.prototype.ProgressTimeout = function(data, lateness)
 {
 	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 + lateness;
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 
 	while (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();
 					return;
 				}
 
 				cmpPlayer.UnBlockTraining();
 				Engine.PostMessage(this.entity, MT_TrainingStarted, { "entity": this.entity });
 			}
 			else if (item.technologyTemplate)
 			{
 				let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
 				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 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, null);
 			return;
 		}
 
 		if (item.unitTemplate)
 		{
 			let numSpawned = this.SpawnUnits(item);
 			if (numSpawned)
 				cmpPlayer.UnReservePopulationSlots(item.population * numSpawned);
 			if (numSpawned == item.count)
 			{
 				cmpPlayer.UnBlockTraining();
 				this.spawnNotified = false;
 			}
 			else
 			{
 				if (numSpawned > 0)
 				{
 					item.count -= numSpawned;
 					Engine.PostMessage(this.entity, MT_ProductionQueueChanged, null);
 				}
 
 				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;
 				}
 				return;
 			}
 		}
 		else if (item.technologyTemplate)
 		{
 			let cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
 			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, null);
 	}
 
 	if (!this.queue.length)
 		this.StopTimer();
 };
 
 ProductionQueue.prototype.PauseProduction = function()
 {
 	this.StopTimer();
 	this.paused = true;
 };
 
 ProductionQueue.prototype.UnpauseProduction = function()
 {
 	this.paused = false;
 	this.StartTimer();
 };
 
 ProductionQueue.prototype.StartTimer = function()
 {
 	if (this.timer)
 		return;
 
 	this.timer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).SetInterval(
 		this.entity,
 		IID_ProductionQueue,
 		"ProgressTimeout",
 		this.ProgressInterval,
 		this.ProgressInterval,
 		null
 	);
 };
 
 ProductionQueue.prototype.StopTimer = function()
 {
 	if (!this.timer)
 		return;
 
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).CancelTimer(this.timer);
 	delete this.timer;
 };
 
 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.HasQueuedProduction = function()
 {
 	return this.queue.length > 0;
 };
 
 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();
 };
 
 ProductionQueue.prototype.OnGarrisonedStateChanged = function(msg)
 {
 	if (msg.holderID != INVALID_ENTITY)
 		this.PauseProduction();
 	else
 		this.UnpauseProduction();
 };
 
 Engine.RegisterComponentType(IID_ProductionQueue, "ProductionQueue", ProductionQueue);
Index: ps/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/UnitAI.js	(revision 25068)
+++ ps/trunk/binaries/data/mods/public/simulation/components/UnitAI.js	(revision 25069)
@@ -1,6645 +1,6618 @@
 function UnitAI() {}
 
 UnitAI.prototype.Schema =
 	"<a:help>Controls the unit's movement, attacks, etc, in response to commands from the player.</a:help>" +
 	"<a:example/>" +
 	"<element name='DefaultStance'>" +
 		"<choice>" +
 			"<value>violent</value>" +
 			"<value>aggressive</value>" +
 			"<value>defensive</value>" +
 			"<value>passive</value>" +
 			"<value>standground</value>" +
 			"<value>skittish</value>" +
 			"<value>passive-defensive</value>" +
 		"</choice>" +
 	"</element>" +
 	"<element name='FormationController'>" +
 		"<data type='boolean'/>" +
 	"</element>" +
 	"<element name='FleeDistance'>" +
 		"<ref name='positiveDecimal'/>" +
 	"</element>" +
 	"<element name='CanGuard'>" +
 		"<data type='boolean'/>" +
 	"</element>" +
 	"<element name='CanPatrol'>" +
 		"<data type='boolean'/>" +
 	"</element>" +
 	"<element name='PatrolWaitTime' a:help='Number of seconds to wait in between patrol waypoints.'>" +
 		"<data type='nonNegativeInteger'/>" +
 	"</element>" +
 	"<optional>" +
 		"<element name='CheeringTime'>" +
 			"<data type='nonNegativeInteger'/>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<interleave>" +
 			"<element name='RoamDistance'>" +
 				"<ref name='positiveDecimal'/>" +
 			"</element>" +
 			"<element name='RoamTimeMin'>" +
 				"<ref name='positiveDecimal'/>" +
 			"</element>" +
 			"<element name='RoamTimeMax'>" +
 				"<ref name='positiveDecimal'/>" +
 			"</element>" +
 			"<element name='FeedTimeMin'>" +
 				"<ref name='positiveDecimal'/>" +
 			"</element>" +
 			"<element name='FeedTimeMax'>" +
 				"<ref name='positiveDecimal'/>" +
 			"</element>"+
 		"</interleave>" +
 	"</optional>";
 
 // Unit stances.
 // There some targeting options:
 //   targetVisibleEnemies: anything in vision range is a viable target
 //   targetAttackersAlways: anything that hurts us is a viable target,
 //     possibly overriding user orders!
 // There are some response options, triggered when targets are detected:
 //   respondFlee: run away
 //   respondFleeOnSight: run away when an enemy is sighted
 //   respondChase: start chasing after the enemy
 //   respondChaseBeyondVision: start chasing, and don't stop even if it's out
 //     of this unit's vision range (though still visible to the player)
 //   respondStandGround: attack enemy but don't move at all
 //   respondHoldGround: attack enemy but don't move far from current position
 // TODO: maybe add targetAggressiveEnemies (don't worry about lone scouts,
 // do worry around armies slaughtering the guy standing next to you), etc.
 var g_Stances = {
 	"violent": {
 		"targetVisibleEnemies": true,
 		"targetAttackersAlways": true,
 		"respondFlee": false,
 		"respondFleeOnSight": false,
 		"respondChase": true,
 		"respondChaseBeyondVision": true,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"aggressive": {
 		"targetVisibleEnemies": true,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondFleeOnSight": false,
 		"respondChase": true,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"defensive": {
 		"targetVisibleEnemies": true,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondFleeOnSight": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": true,
 		"selectable": true
 	},
 	"passive": {
 		"targetVisibleEnemies": false,
 		"targetAttackersAlways": false,
 		"respondFlee": true,
 		"respondFleeOnSight": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"standground": {
 		"targetVisibleEnemies": true,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondFleeOnSight": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": true,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"skittish": {
 		"targetVisibleEnemies": false,
 		"targetAttackersAlways": false,
 		"respondFlee": true,
 		"respondFleeOnSight": true,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": false
 	},
 	"passive-defensive": {
 		"targetVisibleEnemies": false,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondFleeOnSight": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": true,
 		"selectable": false
 	},
 	"none": {
 		// Only to be used by AI or trigger scripts
 		"targetVisibleEnemies": false,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondFleeOnSight": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": false
 	}
 };
 
 // These orders always require a packed unit, so if a unit that is unpacking is given one of these orders,
 // it will immediately cancel unpacking.
 var g_OrdersCancelUnpacking = new Set([
 	"FormationWalk",
 	"Walk",
 	"WalkAndFight",
 	"WalkToTarget",
 	"Patrol",
 	"Garrison"
 ]);
 
 // When leaving a foundation, we want to be clear of it by this distance.
 var g_LeaveFoundationRange = 4;
 
 UnitAI.prototype.notifyToCheerInRange = 30;
 
 // To reject an order, use 'return this.FinishOrder();'
 const ACCEPT_ORDER = true;
 
 // See ../helpers/FSM.js for some documentation of this FSM specification syntax
 UnitAI.prototype.UnitFsmSpec = {
 
 	// Default event handlers:
 
 	"MovementUpdate": function(msg) {
 		// ignore spurious movement messages
 		// (these can happen when stopping moving at the same time
 		// as switching states)
 	},
 
 	"ConstructionFinished": function(msg) {
 		// ignore uninteresting construction messages
 	},
 
 	"LosRangeUpdate": function(msg) {
 		// Ignore newly-seen units by default.
 	},
 
 	"LosHealRangeUpdate": function(msg) {
 		// Ignore newly-seen injured units by default.
 	},
 
 	"LosAttackRangeUpdate": function(msg) {
 		// Ignore newly-seen enemy units by default.
 	},
 
 	"Attacked": function(msg) {
 		// ignore attacker
 	},
 
 	"PackFinished": function(msg) {
 		// ignore
 	},
 
 	"PickupCanceled": function(msg) {
 		// ignore
 	},
 
 	"TradingCanceled": function(msg) {
 		// ignore
 	},
 
 	"GuardedAttacked": function(msg) {
 		// ignore
 	},
 
 	"OrderTargetRenamed": function() {
 		// By default, trigger an exit-reenter
 		// so that state preconditions are checked against the new entity
 		// (there is no reason to assume the target is still valid).
 		this.SetNextState(this.GetCurrentState());
 	},
 
 	// Formation handlers:
 
 	"FormationLeave": function(msg) {
 		// Overloaded by FORMATIONMEMBER
 		// We end up here if LeaveFormation was called when the entity
 		// was executing an order in an individual state, so we must
 		// discard the order now that it has been executed.
 		if (this.order && this.order.type === "LeaveFormation")
 			this.FinishOrder();
 	},
 
 	// Called when being told to walk as part of a formation
 	"Order.FormationWalk": function(msg) {
 		if (!this.AbleToMove())
 			return this.FinishOrder();
 
 		if (this.CanPack())
 		{
 			// If the controller is IDLE, this is just the regular reformation timer.
 			// In that case we don't actually want to move, as that would unpack us.
 			let cmpControllerAI = Engine.QueryInterface(this.GetFormationController(), IID_UnitAI);
 			if (cmpControllerAI.IsIdle())
 				return this.FinishOrder();
 			this.PushOrderFront("Pack", { "force": true });
 		}
 		else
 			this.SetNextState("FORMATIONMEMBER.WALKING");
 		return ACCEPT_ORDER;
 	},
 
 	// Special orders:
 	// (these will be overridden by various states)
 
 	"Order.LeaveFoundation": function(msg) {
 		if (!this.WillMoveFromFoundation(msg.data.target))
 			return this.FinishOrder();
 		msg.data.min = g_LeaveFoundationRange;
 		this.SetNextState("INDIVIDUAL.WALKING");
 		return ACCEPT_ORDER;
 	},
 
 	// Individual orders:
 
 	"Order.LeaveFormation": function() {
 		if (!this.IsFormationMember())
 			return this.FinishOrder();
 
 		let cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 		if (cmpFormation)
 		{
 			cmpFormation.SetRearrange(false);
 			// Triggers FormationLeave, which ultimately will FinishOrder,
 			// discarding this order.
 			cmpFormation.RemoveMembers([this.entity]);
 			cmpFormation.SetRearrange(true);
 		}
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Stop": function(msg) {
 		this.FinishOrder();
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Walk": function(msg) {
 		if (!this.AbleToMove())
 			return this.FinishOrder();
 
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return ACCEPT_ORDER;
 		}
 
 		this.SetHeldPosition(msg.data.x, msg.data.z);
 		msg.data.relaxed = true;
 		this.SetNextState("INDIVIDUAL.WALKING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.WalkAndFight": function(msg) {
 		if (!this.AbleToMove())
 			return this.FinishOrder();
 
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return ACCEPT_ORDER;
 		}
 
 		this.SetHeldPosition(msg.data.x, msg.data.z);
 		msg.data.relaxed = true;
 		this.SetNextState("INDIVIDUAL.WALKINGANDFIGHTING");
 		return ACCEPT_ORDER;
 	},
 
 
 	"Order.WalkToTarget": function(msg) {
 		if (!this.AbleToMove())
 			return this.FinishOrder();
 
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return ACCEPT_ORDER;
 		}
 
 
 		if (this.CheckRange(msg.data))
 			return this.FinishOrder();
 
 		msg.data.relaxed = true;
 		this.SetNextState("INDIVIDUAL.WALKING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.PickupUnit": function(msg) {
 		let cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
 		if (!cmpGarrisonHolder || cmpGarrisonHolder.IsFull())
 			return this.FinishOrder();
 
 		let range = cmpGarrisonHolder.GetLoadingRange();
 		msg.data.min = range.min;
 		msg.data.max = range.max;
 		if (this.CheckRange(msg.data))
 			return this.FinishOrder();
 
 		// Check if we need to move
 		// If the target can reach us and we are reasonably close, don't move.
 		// TODO: it would be slightly more optimal to check for real, not bird-flight distance.
 		let cmpPassengerMotion = Engine.QueryInterface(msg.data.target, IID_UnitMotion);
 		if (cmpPassengerMotion &&
 		        cmpPassengerMotion.IsTargetRangeReachable(this.entity, range.min, range.max) &&
 		        PositionHelper.DistanceBetweenEntities(this.entity, msg.data.target) < 200)
 			this.SetNextState("INDIVIDUAL.PICKUP.LOADING");
 		else
 			this.SetNextState("INDIVIDUAL.PICKUP.APPROACHING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Guard": function(msg) {
 		if (!this.AddGuard(msg.data.target))
 			return this.FinishOrder();
 
 		if (!this.CheckTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
 			this.SetNextState("INDIVIDUAL.GUARD.ESCORTING");
 		else
 			this.SetNextState("INDIVIDUAL.GUARD.GUARDING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Flee": function(msg) {
 		this.SetNextState("INDIVIDUAL.FLEEING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Attack": function(msg) {
 		let type = this.GetBestAttackAgainst(msg.data.target, msg.data.allowCapture);
 		if (!type)
 			return this.FinishOrder();
 
 		msg.data.attackType = type;
 
 		this.RememberTargetPosition();
 		if (msg.data.hunting && this.orderQueue.length > 1 && this.orderQueue[1].type === "Gather")
 			this.RememberTargetPosition(this.orderQueue[1].data);
 
 		if (this.CheckTargetAttackRange(msg.data.target, msg.data.attackType))
 		{
 			if (this.CanUnpack())
 			{
 				this.PushOrderFront("Unpack", { "force": true });
 				return ACCEPT_ORDER;
 			}
 
 			// Cancel any current packing order.
 			if (this.EnsureCorrectPackStateForAttack(false))
 				this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
 
 			return ACCEPT_ORDER;
 		}
 
 		// If we're hunting, that's a special case where we should continue attacking our target.
 		if (this.GetStance().respondStandGround && !msg.data.force && !msg.data.hunting || !this.AbleToMove())
 			return this.FinishOrder();
 
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return ACCEPT_ORDER;
 		}
 
 		// If we're currently packing/unpacking, make sure we are packed, so we can move.
 		if (this.EnsureCorrectPackStateForAttack(true))
 			this.SetNextState("INDIVIDUAL.COMBAT.APPROACHING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Patrol": function(msg) {
 		if (!this.AbleToMove())
 			return this.FinishOrder();
 
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return ACCEPT_ORDER;
 		}
 
 		msg.data.relaxed = true;
 
 		this.SetNextState("INDIVIDUAL.PATROL.PATROLLING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Heal": function(msg) {
 		if (!this.TargetIsAlive(msg.data.target))
 			return this.FinishOrder();
 
 		// Healers can't heal themselves.
 		if (msg.data.target == this.entity)
 			return this.FinishOrder();
 
 		if (this.CheckTargetRange(msg.data.target, IID_Heal))
 		{
 			this.SetNextState("INDIVIDUAL.HEAL.HEALING");
 			return ACCEPT_ORDER;
 		}
 
 		if (this.GetStance().respondStandGround && !msg.data.force)
 			return this.FinishOrder();
 
 		this.SetNextState("INDIVIDUAL.HEAL.APPROACHING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Gather": function(msg) {
 		if (!this.CanGather(msg.data.target))
 		{
 			this.SetNextState("INDIVIDUAL.GATHER.FINDINGNEWTARGET");
 			return ACCEPT_ORDER;
 		}
 
 		// If the unit is full go to the nearest dropsite instead of trying to gather.
 		let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 		if (cmpResourceGatherer && !cmpResourceGatherer.CanCarryMore(msg.data.type.generic))
 		{
 			let nearestDropsite = this.FindNearestDropsite(msg.data.type.generic);
 			if (nearestDropsite)
 				this.PushOrderFront("ReturnResource", {
 					"target": nearestDropsite,
 					"force": false,
 					"type": msg.data.type
 				});
 			// Players expect the unit to move, so walk to the target instead of trying to gather.
 			else if (!this.FinishOrder())
 				this.WalkToTarget(msg.data.target, false);
 
 			return ACCEPT_ORDER;
 		}
 
 		if (this.MustKillGatherTarget(msg.data.target))
 		{
 			// Make sure we can attack the target, else we'll get very stuck
 			if (!this.GetBestAttackAgainst(msg.data.target, false))
 			{
 				// Oops, we can't attack at all - give up
 				// TODO: should do something so the player knows why this failed
 				return this.FinishOrder();
 			}
 			// The target was visible when this order was issued,
 			// but could now be invisible again.
 			if (!this.CheckTargetVisible(msg.data.target))
 			{
 				if (msg.data.secondTry === undefined)
 				{
 					msg.data.secondTry = true;
 					this.PushOrderFront("Walk", msg.data.lastPos);
 				}
 				// We couldn't move there, or the target moved away
 				else if (!this.FinishOrder())
 					this.PushOrderFront("GatherNearPosition", {
 						"x": msg.data.lastPos.x,
 						"z": msg.data.lastPos.z,
 						"type": msg.data.type,
 						"template": msg.data.template
 					});
 				return ACCEPT_ORDER;
 			}
 
 			this.PushOrderFront("Attack", { "target": msg.data.target, "force": !!msg.data.force, "hunting": true, "allowCapture": false });
 			return ACCEPT_ORDER;
 		}
 
 		this.RememberTargetPosition();
 		if (!msg.data.initPos)
 			msg.data.initPos = msg.data.lastPos;
 
 		if (this.CheckTargetRange(msg.data.target, IID_ResourceGatherer))
 			this.SetNextState("INDIVIDUAL.GATHER.GATHERING");
 		else
 			this.SetNextState("INDIVIDUAL.GATHER.APPROACHING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.GatherNearPosition": function(msg) {
 		this.SetNextState("INDIVIDUAL.GATHER.WALKING");
 		msg.data.initPos = { 'x': msg.data.x, 'z': msg.data.z };
 		msg.data.relaxed = true;
 		return ACCEPT_ORDER;
 	},
 
 	"Order.ReturnResource": function(msg) {
 		let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 		if (this.CheckTargetRange(msg.data.target, IID_ResourceGatherer) &&
 		    this.CanReturnResource(msg.data.target, true, cmpResourceGatherer))
 		{
 			cmpResourceGatherer.CommitResources(msg.data.target);
 			this.SetDefaultAnimationVariant();
 
 			// Our next order should always be a Gather,
 			// so just switch back to that order.
 			this.FinishOrder();
 		}
 		else
 			this.SetNextState("INDIVIDUAL.RETURNRESOURCE.APPROACHING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Trade": function(msg) {
 		// We must check if this trader has both markets in case it was a back-to-work order.
 		let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 		if (!cmpTrader || !cmpTrader.HasBothMarkets())
 			return this.FinishOrder();
 
 		this.waypoints = [];
 		this.SetNextState("TRADE.APPROACHINGMARKET");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Repair": function(msg) {
 		if (this.CheckTargetRange(msg.data.target, IID_Builder))
 			this.SetNextState("INDIVIDUAL.REPAIR.REPAIRING");
 		else
 			this.SetNextState("INDIVIDUAL.REPAIR.APPROACHING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Garrison": function(msg) {
 		if (!this.AbleToMove())
-		{
-			// Garrisoned turrets (unable to move) go IDLE.
-			this.SetNextState("IDLE");
-			return ACCEPT_ORDER;
-		}
-
-		if (this.isGarrisoned)
-		{
-			this.SetNextState("INDIVIDUAL.GARRISON.GARRISONED");
-			return ACCEPT_ORDER;
-		}
+			return this.FinishOrder();
 
 		// Also pack when we are in range.
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return ACCEPT_ORDER;
 		}
 
 		if (this.CheckGarrisonRange(msg.data.target))
-			this.SetNextState("INDIVIDUAL.GARRISON.GARRISONED");
+			this.SetNextState("INDIVIDUAL.GARRISON.GARRISONING");
 		else
 			this.SetNextState("INDIVIDUAL.GARRISON.APPROACHING");
 		return ACCEPT_ORDER;
 	},
 
-	"Order.Ungarrison": function() {
+	"Order.Ungarrison": function(msg) {
 		// Note that this order MUST succeed, or we break
 		// the assumptions done in garrisonable/garrisonHolder,
 		// especially in Unloading in the latter. (For user feedback.)
 		// ToDo: This can be fixed by not making that assumption :)
 		this.FinishOrder();
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Cheer": function(msg) {
 		return this.FinishOrder();
 	},
 
 	"Order.Pack": function(msg) {
 		if (!this.CanPack())
 			return this.FinishOrder();
 		this.SetNextState("INDIVIDUAL.PACKING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.Unpack": function(msg) {
 		if (!this.CanUnpack())
 			return this.FinishOrder();
 		this.SetNextState("INDIVIDUAL.UNPACKING");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.MoveToChasingPoint": function(msg) {
 		// Overriden by the CHASING state.
 		// Can however happen outside of it when renaming...
 		// TODO: don't use an order for that behaviour.
 		return this.FinishOrder();
 	},
 
 	"Order.CollectTreasure": function(msg) {
 		let cmpTreasureCollecter = Engine.QueryInterface(this.entity, IID_TreasureCollecter);
 		if (!cmpTreasureCollecter || !cmpTreasureCollecter.CanCollect(msg.data.target))
 			return this.FinishOrder();
 
 		this.SetNextState("COLLECTTREASURE");
 		return ACCEPT_ORDER;
 	},
 
 	"Order.CollectTreasureNearPosition": function(msg) {
 		let nearbyTreasure = this.FindNearbyTreasure(msg.data.x, msg.data.z);
 		if (nearbyTreasure)
 			this.CollectTreasure(nearbyTreasure, oldData.autocontinue, true);
 		else
 			this.SetNextState("COLLECTTREASURE");
 		return ACCEPT_ORDER;
 	},
 
 	// States for the special entity representing a group of units moving in formation:
 	"FORMATIONCONTROLLER": {
 
 		"Order.Walk": function(msg) {
 			this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 			this.SetNextState("WALKING");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.WalkAndFight": function(msg) {
 			this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 			this.SetNextState("WALKINGANDFIGHTING");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.MoveIntoFormation": function(msg) {
 			this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 			this.SetNextState("FORMING");
 			return ACCEPT_ORDER;
 		},
 
 		// Only used by other orders to walk there in formation.
 		"Order.WalkToTargetRange": function(msg) {
 			if (this.CheckRange(msg.data))
 				return this.FinishOrder();
 			this.SetNextState("WALKING");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.WalkToTarget": function(msg) {
 			if (this.CheckRange(msg.data))
 				return this.FinishOrder();
 			this.SetNextState("WALKING");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.WalkToPointRange": function(msg) {
 			if (this.CheckRange(msg.data))
 				return this.FinishOrder();
 			this.SetNextState("WALKING");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Patrol": function(msg) {
 			this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 			this.SetNextState("PATROL.PATROLLING");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Guard": function(msg) {
 			this.CallMemberFunction("Guard", [msg.data.target, false]);
 			Engine.QueryInterface(this.entity, IID_Formation).Disband();
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Stop": function(msg) {
 			let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 			cmpFormation.ResetOrderVariant();
 			if (!this.IsAttackingAsFormation())
 				this.CallMemberFunction("Stop", [false]);
 			this.FinishOrder();
 			return ACCEPT_ORDER;
 			// Don't move the members back into formation,
 			// as the formation then resets and it looks odd when walk-stopping.
 			// TODO: this should be improved in the formation reshaping code.
 		},
 
 		"Order.Attack": function(msg) {
 			let target = msg.data.target;
 			let allowCapture = msg.data.allowCapture;
 			let cmpTargetUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 			if (cmpTargetUnitAI && cmpTargetUnitAI.IsFormationMember())
 				target = cmpTargetUnitAI.GetFormationController();
 
 			if (!this.CheckFormationTargetAttackRange(target))
 			{
 				if (this.CanAttack(target) && this.CheckTargetVisible(target))
 				{
 					this.SetNextState("COMBAT.APPROACHING");
 					return ACCEPT_ORDER;
 				}
 				return this.FinishOrder();
 			}
 			this.CallMemberFunction("Attack", [target, allowCapture, false]);
 			let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 			if (cmpAttack && cmpAttack.CanAttackAsFormation())
 				this.SetNextState("COMBAT.ATTACKING");
 			else
 				this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Garrison": function(msg) {
 			if (!Engine.QueryInterface(msg.data.target, IID_GarrisonHolder))
 				return this.FinishOrder();
 			if (!this.CheckGarrisonRange(msg.data.target))
 			{
 				if (!this.CheckTargetVisible(msg.data.target))
 					return this.FinishOrder();
 
 				this.SetNextState("GARRISON.APPROACHING");
 			}
 			else
 				this.SetNextState("GARRISON.GARRISONING");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Gather": function(msg) {
 			if (this.MustKillGatherTarget(msg.data.target))
 			{
 				// The target was visible when this order was given,
 				// but could now be invisible.
 				if (!this.CheckTargetVisible(msg.data.target))
 				{
 					if (msg.data.secondTry === undefined)
 					{
 						msg.data.secondTry = true;
 						this.PushOrderFront("Walk", msg.data.lastPos);
 					}
 					// We couldn't move there, or the target moved away
 					else
 					{
 						let data = msg.data;
 						if (!this.FinishOrder())
 							this.PushOrderFront("GatherNearPosition", {
 								"x": data.lastPos.x,
 								"z": data.lastPos.z,
 								"type": data.type,
 								"template": data.template
 							});
 					}
 					return ACCEPT_ORDER;
 				}
 				this.PushOrderFront("Attack", { "target": msg.data.target, "force": !!msg.data.force, "hunting": true, "allowCapture": false, "min": 0, "max": 10 });
 				return ACCEPT_ORDER;
 			}
 
 			// TODO: on what should we base this range?
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.CanGather(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
 					return this.FinishOrder();
 				// TODO: Should we issue a gather-near-position order
 				// if the target isn't gatherable/doesn't exist anymore?
 				if (!msg.data.secondTry)
 				{
 					msg.data.secondTry = true;
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 					return ACCEPT_ORDER;
 				}
 				return this.FinishOrder();
 			}
 
 			this.CallMemberFunction("Gather", [msg.data.target, false]);
 
 			this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.GatherNearPosition": function(msg) {
 			// TODO: on what should we base this range?
 			if (!this.CheckPointRangeExplicit(msg.data.x, msg.data.z, 0, 20))
 			{
 				// Out of range; move there in formation
 				this.PushOrderFront("WalkToPointRange", { "x": msg.data.x, "z": msg.data.z, "min": 0, "max": 20 });
 				return ACCEPT_ORDER;
 			}
 
 			this.CallMemberFunction("GatherNearPosition", [msg.data.x, msg.data.z, msg.data.type, msg.data.template, false]);
 
 			this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Heal": function(msg) {
 			// TODO: on what should we base this range?
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.TargetIsAlive(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
 					return this.FinishOrder();
 
 				if (!msg.data.secondTry)
 				{
 					msg.data.secondTry = true;
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 					return ACCEPT_ORDER;
 				}
 				return this.FinishOrder();
 			}
 
 			this.CallMemberFunction("Heal", [msg.data.target, false]);
 
 			this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Repair": function(msg) {
 			// TODO: on what should we base this range?
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.TargetIsAlive(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
 					return this.FinishOrder();
 
 				if (!msg.data.secondTry)
 				{
 					msg.data.secondTry = true;
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 					return ACCEPT_ORDER;
 				}
 				return this.FinishOrder();
 			}
 
 			this.CallMemberFunction("Repair", [msg.data.target, msg.data.autocontinue, false]);
 
 			this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.ReturnResource": function(msg) {
 			// TODO: on what should we base this range?
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.CheckTargetVisible(msg.data.target))
 					return this.FinishOrder();
 
 				if (!msg.data.secondTry)
 				{
 					msg.data.secondTry = true;
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 					return ACCEPT_ORDER;
 				}
 				return this.FinishOrder();
 			}
 
 			this.CallMemberFunction("ReturnResource", [msg.data.target, false]);
 
 			this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Pack": function(msg) {
 			this.CallMemberFunction("Pack", [false]);
 
 			this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"Order.Unpack": function(msg) {
 			this.CallMemberFunction("Unpack", [false]);
 
 			this.SetNextState("MEMBER");
 			return ACCEPT_ORDER;
 		},
 
 		"IDLE": {
 			"enter": function(msg) {
 				// Turn rearrange off. Otherwise, if the formation is idle
 				// but individual units go off to fight,
 				// any death will rearrange the formation, which looks odd.
 				// Instead, move idle units in formation on a timer.
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(false);
 				// Start the timer on the next turn to catch up with potential stragglers.
 				this.StartTimer(100, 2000);
 				this.isIdle = true;
 				this.CallMemberFunction("ResetIdle");
 				return false;
 			},
 
 			"leave": function() {
 				this.isIdle = false;
 				this.StopTimer();
 			},
 
 			"Timer": function(msg) {
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				if (!cmpFormation)
 					return;
 
 				if (this.TestAllMemberFunction("IsIdle"))
 					cmpFormation.MoveMembersIntoFormation(false, false);
 			},
 
 		},
 
 		"WALKING": {
 			"enter": function() {
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(true);
 				cmpFormation.MoveMembersIntoFormation(true, true);
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				return false;
 			},
 
 			"leave": function() {
 				this.StopTimer();
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (msg.veryObstructed && !this.timer)
 				{
 					// It's possible that the controller (with large clearance)
 					// is stuck, but not the individual units.
 					// Ask them to move individually for a little while.
 					this.CallMemberFunction("MoveTo", [this.order.data]);
 					this.StartTimer(3000);
 					return;
 				}
 				else if (this.timer)
 					return;
 				if (msg.likelyFailure || this.CheckRange(this.order.data))
 					this.FinishOrder();
 			},
 
 			"Timer": function() {
 				// Reenter to reset the pathfinder state.
 				this.SetNextState("WALKING");
 			}
 		},
 
 		"WALKINGANDFIGHTING": {
 			"enter": function(msg) {
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(true);
 				cmpFormation.MoveMembersIntoFormation(true, true, "combat");
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				this.StartTimer(0, 1000);
 				return false;
 			},
 
 			"leave": function() {
 				this.StopMoving();
 				this.StopTimer();
 			},
 
 			"Timer": function(msg) {
 				this.FindWalkAndFightTargets();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (msg.likelyFailure || this.CheckRange(this.order.data))
 					this.FinishOrder();
 			},
 		},
 
 		"PATROL": {
 			"enter": function() {
 				let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 				if (!cmpPosition || !cmpPosition.IsInWorld())
 				{
 					this.FinishOrder();
 					return true;
 				}
 				// Memorize the origin position in case that we want to go back.
 				if (!this.patrolStartPosOrder)
 				{
 					this.patrolStartPosOrder = cmpPosition.GetPosition();
 					this.patrolStartPosOrder.targetClasses = this.order.data.targetClasses;
 					this.patrolStartPosOrder.allowCapture = this.order.data.allowCapture;
 				}
 
 				this.SetAnimationVariant("combat");
 
 				return false;
 			},
 
 			"leave": function() {
 				delete this.patrolStartPosOrder;
 				this.SetDefaultAnimationVariant();
 			},
 
 			"PATROLLING": {
 				"enter": function() {
 					let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					cmpFormation.SetRearrange(true);
 					cmpFormation.MoveMembersIntoFormation(true, true, "combat");
 
 					let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 					if (!cmpPosition || !cmpPosition.IsInWorld() ||
 					    !this.MoveTo(this.order.data))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					this.StartTimer(0, 1000);
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					this.FindWalkAndFightTargets();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (!msg.likelyFailure && !msg.likelySuccess && !this.RelaxedMaxRangeCheck(this.order.data, this.DefaultRelaxedMaxRange))
 						return;
 
 					if (this.orderQueue.length == 1)
 						this.PushOrder("Patrol", this.patrolStartPosOrder);
 
 					this.PushOrder(this.order.type, this.order.data);
 					this.SetNextState("CHECKINGWAYPOINT");
 				},
 			},
 
 			"CHECKINGWAYPOINT": {
 				"enter": function() {
 					this.StartTimer(0, 1000);
 					this.stopSurveying = 0;
 					// TODO: pick a proper animation
 					return false;
 				},
 
 				"leave": function() {
 					this.StopTimer();
 					delete this.stopSurveying;
 				},
 
 				"Timer": function(msg) {
 					if (this.stopSurveying >= +this.template.PatrolWaitTime)
 					{
 						this.FinishOrder();
 						return;
 					}
 					this.FindWalkAndFightTargets();
 					++this.stopSurveying;
 				}
 			}
 		},
 
 		"GARRISON": {
 			"APPROACHING": {
 				"enter": function() {
 					let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					cmpFormation.SetRearrange(true);
 					cmpFormation.MoveMembersIntoFormation(true, true);
 
 					if (!this.MoveToGarrisonRange(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					// If the garrisonholder should pickup, warn it so it can take needed action.
 					let cmpGarrisonHolder = Engine.QueryInterface(this.order.data.target, IID_GarrisonHolder);
 					if (cmpGarrisonHolder && cmpGarrisonHolder.CanPickup(this.entity))
 					{
 						this.pickup = this.order.data.target;       // temporary, deleted in "leave"
 						Engine.PostMessage(this.pickup, MT_PickupRequested, { "entity": this.entity });
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 					if (this.pickup)
 					{
 						Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
 						delete this.pickup;
 					}
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.likelyFailure || msg.likelySuccess)
 						this.SetNextState("GARRISONING");
 				},
 			},
 
 			"GARRISONING": {
 				"enter": function() {
 					this.CallMemberFunction("Garrison", [this.order.data.target, false]);
 					// We might have been disbanded due to the lack of members.
 					if (Engine.QueryInterface(this.entity, IID_Formation).GetMemberCount())
 						this.SetNextState("MEMBER");
 					return true;
 				},
 			},
 		},
 
 		"FORMING": {
 			"enter": function() {
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(true);
 				cmpFormation.MoveMembersIntoFormation(true, true);
 
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				return false;
 			},
 
 			"leave": function() {
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (!msg.likelyFailure && !this.CheckRange(this.order.data))
 					return;
 
 				this.FinishOrder();
 			}
 		},
 
 		"COMBAT": {
 			"APPROACHING": {
 				"enter": function() {
 					let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					cmpFormation.SetRearrange(true);
 					cmpFormation.MoveMembersIntoFormation(true, true, "combat");
 
 					if (!this.MoveFormationToTargetAttackRange(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					let target = this.order.data.target;
 					let cmpTargetUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 					if (cmpTargetUnitAI && cmpTargetUnitAI.IsFormationMember())
 						target = cmpTargetUnitAI.GetFormationController();
 					let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 					this.CallMemberFunction("Attack", [target, this.order.data.allowCapture, false]);
 					if (cmpAttack.CanAttackAsFormation())
 						this.SetNextState("COMBAT.ATTACKING");
 					else
 						this.SetNextState("MEMBER");
 				},
 			},
 
 			"ATTACKING": {
 				// Wait for individual members to finish
 				"enter": function(msg) {
 					let target = this.order.data.target;
 					let allowCapture = this.order.data.allowCapture;
 					if (!this.CheckFormationTargetAttackRange(target))
 					{
 						if (this.CanAttack(target) && this.CheckTargetVisible(target))
 						{
 							this.SetNextState("COMBAT.APPROACHING");
 							return true;
 						}
 						this.FinishOrder();
 						return true;
 					}
 
 					let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					// TODO fix the rearranging while attacking as formation
 					cmpFormation.SetRearrange(!this.IsAttackingAsFormation());
 					cmpFormation.MoveMembersIntoFormation(false, false, "combat");
 					this.StartTimer(200, 200);
 					return false;
 				},
 
 				"Timer": function(msg) {
 					let target = this.order.data.target;
 					let allowCapture = this.order.data.allowCapture;
 					if (!this.CheckFormationTargetAttackRange(target))
 					{
 						if (this.CanAttack(target) && this.CheckTargetVisible(target))
 						{
 							this.SetNextState("COMBAT.APPROACHING");
 							return;
 						}
 						this.FinishOrder();
 						return;
 					}
 				},
 
 				"leave": function(msg) {
 					this.StopTimer();
 					var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					if (cmpFormation)
 						cmpFormation.SetRearrange(true);
 				},
 			},
 		},
 
 		// Wait for individual members to finish
 		"MEMBER": {
 			"OrderTargetRenamed": function(msg) {
 				// In general, don't react - we don't want to send spurious messages to members.
 				// This looks odd for hunting however because we wait for all
 				// entities to have clumped around the dead resource before proceeding
 				// so explicitly handle this case.
 				if (this.order && this.order.data && this.order.data.hunting &&
 				     this.order.data.target == msg.data.newentity &&
 				     this.orderQueue.length > 1)
 					this.FinishOrder();
 			},
 
 			"enter": function(msg) {
 				// Don't rearrange the formation, as that forces all units to stop
 				// what they're doing.
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				if (cmpFormation)
 					cmpFormation.SetRearrange(false);
 				// While waiting on members, the formation is more like
 				// a group of unit and does not have a well-defined position,
 				// so move the controller out of the world to enforce that.
 				let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 				if (cmpPosition && cmpPosition.IsInWorld())
 					cmpPosition.MoveOutOfWorld();
 
 				this.StartTimer(1000, 1000);
 				return false;
 			},
 
 			"Timer": function(msg) {
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				if (cmpFormation && !cmpFormation.AreAllMembersWaiting())
 					return;
 
 				if (this.FinishOrder())
 				{
 					if (this.IsWalkingAndFighting())
 						this.FindWalkAndFightTargets();
 					return;
 				}
 				return;
 			},
 
 			"leave": function(msg) {
 				this.StopTimer();
 				// Reform entirely as members might be all over the place now.
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				if (cmpFormation)
 					cmpFormation.MoveMembersIntoFormation(true);
 
 				// Update the held position so entities respond to orders.
 				let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 				if (cmpPosition && cmpPosition.IsInWorld())
 				{
 					let pos = cmpPosition.GetPosition2D();
 					this.CallMemberFunction("SetHeldPosition", [pos.x, pos.y]);
 				}
 			},
 		},
 	},
 
 
 	// States for entities moving as part of a formation:
 	"FORMATIONMEMBER": {
 		"FormationLeave": function(msg) {
 			// Stop moving as soon as the formation disbands
 			// Keep current rotation
 			let facePointAfterMove = this.GetFacePointAfterMove();
 			this.SetFacePointAfterMove(false);
 			this.StopMoving();
 			this.SetFacePointAfterMove(facePointAfterMove);
 
 			// If the controller handled an order but some members rejected it,
 			// they will have no orders and be in the FORMATIONMEMBER.IDLE state.
 			if (this.orderQueue.length)
 			{
 				// We're leaving the formation, so stop our FormationWalk order
 				if (this.FinishOrder())
 					return;
 			}
 
 			this.formationAnimationVariant = undefined;
 			this.SetNextState("INDIVIDUAL.IDLE");
 		},
 
 		// Override the LeaveFoundation order since we're not doing
 		// anything more important (and we might be stuck in the WALKING
 		// state forever and need to get out of foundations in that case)
 		"Order.LeaveFoundation": function(msg) {
 			if (!this.WillMoveFromFoundation(msg.data.target))
 				return this.FinishOrder();
 			msg.data.min = g_LeaveFoundationRange;
 			this.SetNextState("WALKINGTOPOINT");
 			return ACCEPT_ORDER;
 		},
 
 		"enter": function() {
 			let cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 			if (cmpFormation)
 			{
 				this.formationAnimationVariant = cmpFormation.GetFormationAnimationVariant(this.entity);
 				if (this.formationAnimationVariant)
 					this.SetAnimationVariant(this.formationAnimationVariant);
 				else
 					this.SetDefaultAnimationVariant();
 			}
 			return false;
 		},
 
 		"leave": function() {
 			this.SetDefaultAnimationVariant();
 			this.formationAnimationVariant = undefined;
 		},
 
 		"IDLE": "INDIVIDUAL.IDLE",
 
 		"CHEERING": "INDIVIDUAL.CHEERING",
 
 		"WALKING": {
 			"enter": function() {
 				let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 				cmpUnitMotion.MoveToFormationOffset(this.order.data.target, this.order.data.x, this.order.data.z);
 				if (this.order.data.offsetsChanged)
 				{
 					let cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 					if (cmpFormation)
 						this.formationAnimationVariant = cmpFormation.GetFormationAnimationVariant(this.entity);
 				}
 				if (this.formationAnimationVariant)
 					this.SetAnimationVariant(this.formationAnimationVariant);
 				else if (this.order.data.variant)
 					this.SetAnimationVariant(this.order.data.variant);
 				else
 					this.SetDefaultAnimationVariant();
 				return false;
 			},
 
 			"leave": function() {
 				// Don't use the logic from unitMotion, as SetInPosition
 				// has already given us a custom rotation
 				// (or we failed to move and thus don't care.)
 				let facePointAfterMove = this.GetFacePointAfterMove();
 				this.SetFacePointAfterMove(false);
 				this.StopMoving();
 				this.SetFacePointAfterMove(facePointAfterMove);
 			},
 
 			// Occurs when the unit has reached its destination and the controller
 			// is done moving. The controller is notified.
 			"MovementUpdate": function(msg) {
 				// When walking in formation, we'll only get notified in case of failure
 				// if the formation controller has stopped walking.
 				// Formations can start lagging a lot if many entities request short path
 				// so prefer to finish order early than retry pathing.
 				// (see https://code.wildfiregames.com/rP23806)
 				// (if the message is likelyFailure of likelySuccess, we also want to stop).
 				this.FinishOrder();
 			},
 		},
 
 		// Special case used by Order.LeaveFoundation
 		"WALKINGTOPOINT": {
 			"enter": function() {
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				return false;
 			},
 
 			"leave": function() {
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function() {
 				if (!this.CheckRange(this.order.data))
 					return;
 				this.FinishOrder();
 			},
 		},
 	},
 
 
 	// States for entities not part of a formation:
 	"INDIVIDUAL": {
 		"Attacked": function(msg) {
 			if (this.GetStance().targetAttackersAlways || !this.order || !this.order.data || !this.order.data.force)
 				this.RespondToTargetedEntities([msg.data.attacker]);
 		},
 
 		"GuardedAttacked": function(msg) {
 			// do nothing if we have a forced order in queue before the guard order
 			for (var i = 0; i < this.orderQueue.length; ++i)
 			{
 				if (this.orderQueue[i].type == "Guard")
 					break;
 				if (this.orderQueue[i].data && this.orderQueue[i].data.force)
 					return;
 			}
 			// if we already are targeting another unit still alive, finish with it first
 			if (this.order && (this.order.type == "WalkAndFight" || this.order.type == "Attack"))
 				if (this.order.data.target != msg.data.attacker && this.CanAttack(msg.data.attacker))
 					return;
 
 			var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
 			var cmpHealth = Engine.QueryInterface(this.isGuardOf, IID_Health);
 			if (cmpIdentity && cmpIdentity.HasClass("Support") &&
 			    cmpHealth && cmpHealth.IsInjured())
 			{
 				if (this.CanHeal(this.isGuardOf))
 					this.PushOrderFront("Heal", { "target": this.isGuardOf, "force": false });
 				else if (this.CanRepair(this.isGuardOf))
 					this.PushOrderFront("Repair", { "target": this.isGuardOf, "autocontinue": false, "force": false });
 				return;
 			}
 
 			var cmpBuildingAI = Engine.QueryInterface(msg.data.attacker, IID_BuildingAI);
 			if (cmpBuildingAI && this.CanRepair(this.isGuardOf))
 			{
 				this.PushOrderFront("Repair", { "target": this.isGuardOf, "autocontinue": false, "force": false });
 				return;
 			}
 
 			if (this.CheckTargetVisible(msg.data.attacker))
 				this.PushOrderFront("Attack", { "target": msg.data.attacker, "force": false, "allowCapture": true });
 			else
 			{
 				var cmpPosition = Engine.QueryInterface(msg.data.attacker, IID_Position);
 				if (!cmpPosition || !cmpPosition.IsInWorld())
 					return;
 				var pos = cmpPosition.GetPosition();
 				this.PushOrderFront("WalkAndFight", { "x": pos.x, "z": pos.z, "target": msg.data.attacker, "force": false });
 				// if we already had a WalkAndFight, keep only the most recent one in case the target has moved
 				if (this.orderQueue[1] && this.orderQueue[1].type == "WalkAndFight")
 				{
 					this.orderQueue.splice(1, 1);
 					Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 				}
 			}
 		},
 
 		"IDLE": {
 			"Order.Cheer": function() {
 				// Do not cheer if there is no cheering time and we are not idle yet.
 				if (!this.cheeringTime || !this.isIdle)
 					return this.FinishOrder();
 
 				this.SetNextState("CHEERING");
 				return ACCEPT_ORDER;
 			},
 
 			"enter": function() {
 				// Switch back to idle animation to guarantee we won't
 				// get stuck with an incorrect animation
 				this.SelectAnimation("idle");
 
 				// Idle is the default state. If units try, from the IDLE.enter sub-state, to
 				// begin another order, and that order fails (calling FinishOrder), they might
 				// end up in an infinite loop. To avoid this, all methods that could put the unit in
 				// a new state are done on the next turn.
 				// This wastes a turn but avoids infinite loops.
 				// Further, the GUI and AI want to know when a unit is idle,
 				// but sending this info in Idle.enter will send spurious messages.
 				// Pick 100 to execute on the next turn in SP and MP.
 				this.StartTimer(100);
 				return false;
 			},
 
 			"leave": function() {
 				let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 				if (this.losRangeQuery)
 					cmpRangeManager.DisableActiveQuery(this.losRangeQuery);
 				if (this.losHealRangeQuery)
 					cmpRangeManager.DisableActiveQuery(this.losHealRangeQuery);
 				if (this.losAttackRangeQuery)
 					cmpRangeManager.DisableActiveQuery(this.losAttackRangeQuery);
 
 				this.StopTimer();
 
 				if (this.isIdle)
 				{
 					this.isIdle = false;
 					Engine.PostMessage(this.entity, MT_UnitIdleChanged, { "idle": this.isIdle });
 				}
 			},
 
 			"Attacked": function(msg) {
 				if (this.isIdle && (this.GetStance().targetAttackersAlways || !this.order || !this.order.data || !this.order.data.force))
 					this.RespondToTargetedEntities([msg.data.attacker]);
 			},
 
 			// On the range updates:
 			// We check for idleness to prevent an entity to react only to newly seen entities
 			// when receiving a Los*RangeUpdate on the same turn as the entity becomes idle
 			// since this.FindNew*Targets is called in the timer.
 
 			"LosRangeUpdate": function(msg) {
 				if (this.isIdle && msg && msg.data && msg.data.added && msg.data.added.length)
 					this.RespondToSightedEntities(msg.data.added);
 			},
 
 			"LosHealRangeUpdate": function(msg) {
 				if (this.isIdle && msg && msg.data && msg.data.added && msg.data.added.length)
 					this.RespondToHealableEntities(msg.data.added);
 			},
 
 			"LosAttackRangeUpdate": function(msg) {
 				if (this.isIdle && msg && msg.data && msg.data.added && msg.data.added.length && this.GetStance().targetVisibleEnemies)
 					this.AttackEntitiesByPreference(msg.data.added);
 			},
 
 			"Timer": function(msg) {
 				if (this.isGuardOf)
 				{
 					this.Guard(this.isGuardOf, false);
 					return;
 				}
 
 				// If a unit can heal and attack we first want to heal wounded units,
 				// so check if we are a healer and find whether there's anybody nearby to heal.
 				// (If anyone approaches later it'll be handled via LosHealRangeUpdate.)
 				// If anyone in sight gets hurt that will be handled via LosHealRangeUpdate.
 				if (this.IsHealer() && this.FindNewHealTargets())
 					return;
 
 				// If we entered the idle state we must have nothing better to do,
 				// so immediately check whether there's anybody nearby to attack.
 				// (If anyone approaches later, it'll be handled via LosAttackRangeUpdate.)
 				if (this.FindNewTargets())
 					return;
 
 				if (this.FindSightedEnemies())
 					return;
 
 				if (!this.isIdle)
 				{
 					// Move back to the held position if we drifted away.
 					// (only if not a formation member).
 					if (!this.IsFormationMember() &&
 					     this.GetStance().respondHoldGround && this.heldPosition &&
 					     !this.CheckPointRangeExplicit(this.heldPosition.x, this.heldPosition.z, 0, 10) &&
 					     this.WalkToHeldPosition())
 						return;
 
 					if (this.IsFormationMember())
 					{
 						let cmpFormationAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
 						if (!cmpFormationAI || !cmpFormationAI.IsIdle())
 							return;
 					}
 
 					this.isIdle = true;
 					Engine.PostMessage(this.entity, MT_UnitIdleChanged, { "idle": this.isIdle });
 				}
 
 				// Go linger first to prevent all roaming entities
 				// to move all at the same time on map init.
 				if (this.template.RoamDistance)
 					this.SetNextState("LINGERING");
 			},
 
 			"ROAMING": {
 				"enter": function() {
 					this.SetFacePointAfterMove(false);
 					this.MoveRandomly(+this.template.RoamDistance);
 					this.StartTimer(randIntInclusive(+this.template.RoamTimeMin, +this.template.RoamTimeMax));
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 					this.StopTimer();
 					this.SetFacePointAfterMove(true);
 				},
 
 				"Timer": function(msg) {
 					this.SetNextState("LINGERING");
 				},
 
 				"MovementUpdate": function() {
 					this.MoveRandomly(+this.template.RoamDistance);
 				},
 			},
 
 			"LINGERING": {
 				"enter": function() {
 					// ToDo: rename animations?
 					this.SelectAnimation("feeding");
 					this.StartTimer(randIntInclusive(+this.template.FeedTimeMin, +this.template.FeedTimeMax));
 					return false;
 				},
 
 				"leave": function() {
 					this.ResetAnimation();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					this.SetNextState("ROAMING");
 				},
 			},
 		},
 
 		"WALKING": {
 			"enter": function() {
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				return false;
 			},
 
 			"leave": function() {
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function(msg) {
 				// If it looks like the path is failing, and we are close enough stop anyways.
 				// This avoids pathing for an unreachable goal and reduces lag considerably.
 				if (msg.likelyFailure || msg.obstructed && this.RelaxedMaxRangeCheck(this.order.data, this.DefaultRelaxedMaxRange) ||
 					 this.CheckRange(this.order.data))
 					this.FinishOrder();
 			},
 		},
 
 		"WALKINGANDFIGHTING": {
 			"enter": function() {
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				// Show weapons rather than carried resources.
 				this.SetAnimationVariant("combat");
 
 				this.StartTimer(0, 1000);
 				return false;
 			},
 
 			"Timer": function(msg) {
 				this.FindWalkAndFightTargets();
 			},
 
 			"leave": function(msg) {
 				this.StopMoving();
 				this.StopTimer();
 				this.SetDefaultAnimationVariant();
 			},
 
 			"MovementUpdate": function(msg) {
 				// If it looks like the path is failing, and we are close enough stop anyways.
 				// This avoids pathing for an unreachable goal and reduces lag considerably.
 				if (msg.likelyFailure || msg.obstructed && this.RelaxedMaxRangeCheck(this.order.data, this.DefaultRelaxedMaxRange) ||
 					 this.CheckRange(this.order.data))
 					this.FinishOrder();
 			},
 		},
 
 		"PATROL": {
 			"enter": function() {
 				let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 				if (!cmpPosition || !cmpPosition.IsInWorld())
 				{
 					this.FinishOrder();
 					return true;
 				}
 
 				// Memorize the origin position in case that we want to go back.
 				if (!this.patrolStartPosOrder)
 				{
 					this.patrolStartPosOrder = cmpPosition.GetPosition();
 					this.patrolStartPosOrder.targetClasses = this.order.data.targetClasses;
 					this.patrolStartPosOrder.allowCapture = this.order.data.allowCapture;
 				}
 
 				this.SetAnimationVariant("combat");
 
 				return false;
 			},
 
 			"leave": function() {
 				delete this.patrolStartPosOrder;
 				this.SetDefaultAnimationVariant();
 			},
 
 			"PATROLLING": {
 				"enter": function() {
 					let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 					if (!cmpPosition || !cmpPosition.IsInWorld() ||
 					    !this.MoveTo(this.order.data))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					this.StartTimer(0, 1000);
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					this.FindWalkAndFightTargets();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (!msg.likelyFailure && !msg.likelySuccess && !this.RelaxedMaxRangeCheck(this.order.data, this.DefaultRelaxedMaxRange))
 						return;
 
 					if (this.orderQueue.length == 1)
 						this.PushOrder("Patrol", this.patrolStartPosOrder);
 
 					this.PushOrder(this.order.type, this.order.data);
 					this.SetNextState("CHECKINGWAYPOINT");
 				},
 			},
 
 			"CHECKINGWAYPOINT": {
 				"enter": function() {
 					this.StartTimer(0, 1000);
 					this.stopSurveying = 0;
 					// TODO: pick a proper animation
 					return false;
 				},
 
 				"leave": function() {
 					this.StopTimer();
 					delete this.stopSurveying;
 				},
 
 				"Timer": function(msg) {
 					if (this.stopSurveying >= +this.template.PatrolWaitTime)
 					{
 						this.FinishOrder();
 						return;
 					}
 					this.FindWalkAndFightTargets();
 					++this.stopSurveying;
 				}
 			}
 		},
 
 		"GUARD": {
 			"RemoveGuard": function() {
 				this.FinishOrder();
 			},
 
 			"ESCORTING": {
 				"enter": function() {
 					if (!this.MoveToTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					// Show weapons rather than carried resources.
 					this.SetAnimationVariant("combat");
 
 					this.StartTimer(0, 1000);
 					this.SetHeldPositionOnEntity(this.isGuardOf);
 					return false;
 				},
 
 				"Timer": function(msg) {
 					if (!this.ShouldGuard(this.isGuardOf))
 					{
 						this.FinishOrder();
 						return;
 					}
 
 					let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 					if (cmpObstructionManager.IsInTargetRange(this.entity, this.isGuardOf, 0, 3 * this.guardRange, false))
 						this.TryMatchTargetSpeed(this.isGuardOf, false);
 
 					this.SetHeldPositionOnEntity(this.isGuardOf);
 				},
 
 				"leave": function(msg) {
 					this.StopMoving();
 					this.ResetSpeedMultiplier();
 					this.StopTimer();
 					this.SetDefaultAnimationVariant();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.likelyFailure || this.CheckTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
 						this.SetNextState("GUARDING");
 				},
 			},
 
 			"GUARDING": {
 				"enter": function() {
 					this.StartTimer(1000, 1000);
 					this.SetHeldPositionOnEntity(this.entity);
 					this.SetAnimationVariant("combat");
 					this.FaceTowardsTarget(this.order.data.target);
 					return false;
 				},
 
 				"LosAttackRangeUpdate": function(msg) {
 					if (this.GetStance().targetVisibleEnemies)
 						this.AttackEntitiesByPreference(msg.data.added);
 				},
 
 				"Timer": function(msg) {
 					if (!this.ShouldGuard(this.isGuardOf))
 					{
 						this.FinishOrder();
 						return;
 					}
 					// TODO: find out what to do if we cannot move.
 					if (!this.CheckTargetRangeExplicit(this.isGuardOf, 0, this.guardRange) &&
 					    this.MoveToTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
 						this.SetNextState("ESCORTING");
 					else
 					{
 						this.FaceTowardsTarget(this.order.data.target);
 						var cmpHealth = Engine.QueryInterface(this.isGuardOf, IID_Health);
 						if (cmpHealth && cmpHealth.IsInjured())
 						{
 							if (this.CanHeal(this.isGuardOf))
 								this.PushOrderFront("Heal", { "target": this.isGuardOf, "force": false });
 							else if (this.CanRepair(this.isGuardOf))
 								this.PushOrderFront("Repair", { "target": this.isGuardOf, "autocontinue": false, "force": false });
 						}
 					}
 				},
 
 				"leave": function(msg) {
 					this.StopTimer();
 					this.SetDefaultAnimationVariant();
 				},
 			},
 		},
 
 		"FLEEING": {
 			"enter": function() {
 				// We use the distance between the entities to account for ranged attacks
 				this.order.data.distanceToFlee = PositionHelper.DistanceBetweenEntities(this.entity, this.order.data.target) + (+this.template.FleeDistance);
 				let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 				// Use unit motion directly to ignore the visibility check. TODO: change this if we add LOS to fauna.
 				if (this.CheckTargetRangeExplicit(this.order.data.target, this.order.data.distanceToFlee, -1) ||
 				    !cmpUnitMotion || !cmpUnitMotion.MoveToTargetRange(this.order.data.target, this.order.data.distanceToFlee, -1))
 				{
 					this.FinishOrder();
 					return true;
 				}
 
 				this.PlaySound("panic");
 
 				this.SetSpeedMultiplier(this.GetRunMultiplier());
 				return false;
 			},
 
 			"OrderTargetRenamed": function(msg) {
 				// To avoid replaying the panic sound, handle this explicitly.
 				let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 				if (this.CheckTargetRangeExplicit(this.order.data.target, this.order.data.distanceToFlee, -1) ||
 				    !cmpUnitMotion || !cmpUnitMotion.MoveToTargetRange(this.order.data.target, this.order.data.distanceToFlee, -1))
 					this.FinishOrder();
 			},
 
 			"Attacked": function(msg) {
 				if (msg.data.attacker == this.order.data.target)
 					return;
 
 				let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 				if (cmpObstructionManager.DistanceToTarget(this.entity, msg.data.target) > cmpObstructionManager.DistanceToTarget(this.entity, this.order.data.target))
 					return;
 
 				if (this.GetStance().targetAttackersAlways || !this.order || !this.order.data || !this.order.data.force)
 					this.RespondToTargetedEntities([msg.data.attacker]);
 			},
 
 			"leave": function() {
 				this.ResetSpeedMultiplier();
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (msg.likelyFailure || this.CheckTargetRangeExplicit(this.order.data.target, this.order.data.distanceToFlee, -1))
 					this.FinishOrder();
 			},
 		},
 
 		"COMBAT": {
 			"Order.LeaveFoundation": function(msg) {
 				// Ignore the order as we're busy.
 				return this.FinishOrder();
 			},
 
 			"Attacked": function(msg) {
 				// If we're already in combat mode, ignore anyone else who's attacking us
 				// unless it's a melee attack since they may be blocking our way to the target
 				if (msg.data.type == "Melee" && (this.GetStance().targetAttackersAlways || !this.order.data.force))
 					this.RespondToTargetedEntities([msg.data.attacker]);
 			},
 
 			"leave": function() {
 				if (!this.formationAnimationVariant)
 					this.SetDefaultAnimationVariant();
 			},
 
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					if (!this.formationAnimationVariant)
 						this.SetAnimationVariant("combat");
 
 					this.StartTimer(1000, 1000);
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Attack, this.order.data.attackType))
 					{
 						this.FinishOrder();
 
 						if (this.GetStance().respondHoldGround)
 							this.WalkToHeldPosition();
 					}
 					else
 					{
 						this.RememberTargetPosition();
 						if (this.order.data.hunting && this.orderQueue.length > 1 &&
 						     this.orderQueue[1].type === "Gather")
 							this.RememberTargetPosition(this.orderQueue[1].data);
 					}
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.likelyFailure)
 					{
 						// This also handles hunting.
 						if (this.orderQueue.length > 1)
 						{
 							this.FinishOrder();
 							return;
 						}
 						else if (!this.order.data.force || !this.order.data.lastPos)
 						{
 							this.SetNextState("COMBAT.FINDINGNEWTARGET");
 							return;
 						}
 						// If the order was forced, try moving to the target position,
 						// under the assumption that this is desirable if the target
 						// was somewhat far away - we'll likely end up closer to where
 						// the player hoped we would.
 						let lastPos = this.order.data.lastPos;
 						this.PushOrder("WalkAndFight", {
 							"x": lastPos.x, "z": lastPos.z,
 							"force": false,
 							// Force to true - otherwise structures might be attacked instead of captured,
 							// which is generally not expected (attacking units usually has allowCapture false).
 							"allowCapture": true
 						});
 						return;
 					}
 
 					if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
 					{
 						if (this.CanUnpack())
 						{
 							this.PushOrderFront("Unpack", { "force": true });
 							return;
 						}
 						this.SetNextState("ATTACKING");
 					}
 					else if (msg.likelySuccess)
 						// Try moving again,
 						// attack range uses a height-related formula and our actual max range might have changed.
 						if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
 							this.FinishOrder();
 				},
 			},
 
 			"ATTACKING": {
 				"enter": function() {
 					let target = this.order.data.target;
 					let cmpFormation = Engine.QueryInterface(target, IID_Formation);
 					if (cmpFormation)
 					{
 						this.order.data.formationTarget = target;
 						target = cmpFormation.GetClosestMember(this.entity);
 						this.order.data.target = target;
 					}
 
 					this.shouldCheer = false;
 					if (!this.CanAttack(target))
 					{
 						this.SetNextState("COMBAT.FINDINGNEWTARGET");
 						return true;
 					}
 
 					if (!this.CheckTargetAttackRange(target, this.order.data.attackType))
 					{
 						if (this.CanPack())
 						{
 							this.PushOrderFront("Pack", { "force": true });
 							return true;
 						}
 
 						this.SetNextState("COMBAT.APPROACHING");
 						return true;
 					}
 
 					let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 					this.attackTimers = cmpAttack.GetTimers(this.order.data.attackType);
 
 					// If the repeat time since the last attack hasn't elapsed,
 					// delay this attack to avoid attacking too fast.
 					let prepare = this.attackTimers.prepare;
 					if (this.lastAttacked)
 					{
 						let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 						let repeatLeft = this.lastAttacked + this.attackTimers.repeat - cmpTimer.GetTime();
 						prepare = Math.max(prepare, repeatLeft);
 					}
 
 					if (!this.formationAnimationVariant)
 						this.SetAnimationVariant("combat");
 
 					this.oldAttackType = this.order.data.attackType;
 					this.SelectAnimation("attack_" + this.order.data.attackType.toLowerCase());
 					this.SetAnimationSync(prepare, this.attackTimers.repeat);
 					this.StartTimer(prepare, this.attackTimers.repeat);
 					// TODO: we should probably only bother syncing projectile attacks, not melee
 
 					// If using a non-default prepare time, re-sync the animation when the timer runs.
 					this.resyncAnimation = prepare != this.attackTimers.prepare;
 
 					this.FaceTowardsTarget(this.order.data.target);
 
 					let cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
 					if (cmpBuildingAI)
 					{
 						cmpBuildingAI.SetUnitAITarget(this.order.data.target);
 						return false;
 					}
 
 					let cmpUnitAI = Engine.QueryInterface(this.order.data.target, IID_UnitAI);
 
 					// Units with no cheering time do not cheer.
 					this.shouldCheer = cmpUnitAI && (!cmpUnitAI.IsAnimal() || cmpUnitAI.IsDangerousAnimal()) && this.cheeringTime > 0;
 
 					return false;
 				},
 
 				"leave": function() {
 					let cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
 					if (cmpBuildingAI)
 						cmpBuildingAI.SetUnitAITarget(0);
 					this.StopTimer();
 					this.ResetAnimation();
 				},
 
 				"Timer": function(msg) {
 					let target = this.order.data.target;
 					let attackType = this.order.data.attackType;
 
 					if (!this.CanAttack(target))
 					{
 						this.SetNextState("COMBAT.FINDINGNEWTARGET");
 						return;
 					}
 
 					this.RememberTargetPosition();
 					if (this.order.data.hunting && this.orderQueue.length > 1 && this.orderQueue[1].type === "Gather")
 						this.RememberTargetPosition(this.orderQueue[1].data);
 
 					let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 					this.lastAttacked = cmpTimer.GetTime() - msg.lateness;
 
 					this.FaceTowardsTarget(target);
 
 					// BuildingAI has it's own attack-routine
 					let cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
 					if (!cmpBuildingAI)
 					{
 						let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 						cmpAttack.PerformAttack(attackType, target);
 					}
 
 					// PerformAttack might have triggered messages that moved us to another state.
 					// (use 'ends with' to handle formation members copying our state).
 					if (!this.GetCurrentState().endsWith("COMBAT.ATTACKING"))
 						return;
 
 
 					// Check we can still reach the target for the next attack
 					if (this.CheckTargetAttackRange(target, attackType))
 					{
 						if (this.resyncAnimation)
 						{
 							this.SetAnimationSync(this.attackTimers.repeat, this.attackTimers.repeat);
 							this.resyncAnimation = false;
 						}
 						return;
 					}
 
 					if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
 					{
 						if (this.CanPack())
 						{
 							this.PushOrderFront("Pack", { "force": true });
 							return;
 						}
 						this.SetNextState("COMBAT.CHASING");
 						return;
 					}
 
 					this.SetNextState("FINDINGNEWTARGET");
 				},
 
 				// TODO: respond to target deaths immediately, rather than waiting
 				// until the next Timer event
 
 				"Attacked": function(msg) {
 					if (this.order.data.attackType == "Capture" && (this.GetStance().targetAttackersAlways || !this.order.data.force)
 						&& this.order.data.target != msg.data.attacker && this.GetBestAttackAgainst(msg.data.attacker, true) != "Capture")
 						this.RespondToTargetedEntities([msg.data.attacker]);
 				},
 			},
 
 			"FINDINGNEWTARGET": {
 				"Order.Cheer": function() {
 					if (!this.cheeringTime)
 						return this.FinishOrder();
 
 					this.SetNextState("CHEERING");
 					return ACCEPT_ORDER;
 				},
 
 				"enter": function() {
 					// Try to find the formation the target was a part of.
 					let cmpFormation = Engine.QueryInterface(this.order.data.target, IID_Formation);
 					if (!cmpFormation)
 						cmpFormation = Engine.QueryInterface(this.order.data.formationTarget || INVALID_ENTITY, IID_Formation);
 
 					// If the target is a formation, pick closest member.
 					if (cmpFormation)
 					{
 						let filter = (t) => this.CanAttack(t);
 						this.order.data.formationTarget = this.order.data.target;
 						let target = cmpFormation.GetClosestMember(this.entity, filter);
 						this.order.data.target = target;
 						this.SetNextState("COMBAT.ATTACKING");
 						return true;
 					}
 
 					// Can't reach it, no longer owned by enemy, or it doesn't exist any more - give up
 					// except if in WalkAndFight mode where we look for more enemies around before moving again.
 					if (this.FinishOrder())
 					{
 						if (this.IsWalkingAndFighting())
 							this.FindWalkAndFightTargets();
 						return true;
 					}
 
 					if (this.FindNewTargets())
 						return true;
 
 					if (this.GetStance().respondHoldGround)
 						this.WalkToHeldPosition();
 
 					if (this.shouldCheer)
 					{
 						this.Cheer();
 						this.CallPlayerOwnedEntitiesFunctionInRange("Cheer", [], this.notifyToCheerInRange);
 					}
 
 					return true;
 				},
 			},
 
 			"CHASING": {
 				"Order.MoveToChasingPoint": function(msg) {
 					if (this.CheckPointRangeExplicit(msg.data.x, msg.data.z, 0, msg.data.max))
 						return this.FinishOrder();
 					msg.data.relaxed = true;
 					this.StopTimer();
 					this.SetNextState("MOVINGTOPOINT");
 					return ACCEPT_ORDER;
 				},
 				"enter": function() {
 					if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					if (!this.formationAnimationVariant)
 						this.SetAnimationVariant("combat");
 
 					var cmpUnitAI = Engine.QueryInterface(this.order.data.target, IID_UnitAI);
 					if (cmpUnitAI && cmpUnitAI.IsFleeing())
 						this.SetSpeedMultiplier(this.GetRunMultiplier());
 
 					this.StartTimer(1000, 1000);
 					return false;
 				},
 
 				"leave": function() {
 					this.ResetSpeedMultiplier();
 					this.StopMoving();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Attack, this.order.data.attackType))
 					{
 						this.FinishOrder();
 
 						if (this.GetStance().respondHoldGround)
 							this.WalkToHeldPosition();
 					}
 					else
 					{
 						this.RememberTargetPosition();
 						if (this.order.data.hunting && this.orderQueue.length > 1 &&
 						     this.orderQueue[1].type === "Gather")
 							this.RememberTargetPosition(this.orderQueue[1].data);
 					}
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.likelyFailure)
 					{
 						// This also handles hunting.
 						if (this.orderQueue.length > 1)
 						{
 							this.FinishOrder();
 							return;
 						}
 						else if (!this.order.data.force)
 						{
 							this.SetNextState("COMBAT.FINDINGNEWTARGET");
 							return;
 						}
 						else if (this.order.data.lastPos)
 						{
 							let lastPos = this.order.data.lastPos;
 							let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 							this.PushOrder("MoveToChasingPoint", {
 								"x": lastPos.x,
 								"z": lastPos.z,
 								"max": cmpAttack.GetRange(this.order.data.attackType).max,
 								"force": true
 							});
 							return;
 						}
 					}
 					if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
 					{
 						if (this.CanUnpack())
 						{
 							this.PushOrderFront("Unpack", { "force": true });
 							return;
 						}
 						this.SetNextState("ATTACKING");
 					}
 					else if (msg.likelySuccess)
 						// Try moving again,
 						// attack range uses a height-related formula and our actual max range might have changed.
 						if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
 							this.FinishOrder();
 				},
 				"MOVINGTOPOINT": {
 					"enter": function() {
 						if (!this.MoveTo(this.order.data))
 						{
 							this.FinishOrder();
 							return true;
 						}
 						return false;
 					},
 					"leave": function() {
 						this.StopMoving();
 					},
 					"MovementUpdate": function(msg) {
 						// If it looks like the path is failing, and we are close enough from wanted range
 						// stop anyways. This avoids pathing for an unreachable goal and reduces lag considerably.
 						if (msg.likelyFailure ||
 							msg.obstructed && this.RelaxedMaxRangeCheck(this.order.data, this.order.data.max + this.DefaultRelaxedMaxRange) ||
 							!msg.obstructed && this.CheckRange(this.order.data))
 							this.FinishOrder();
 					},
 				},
 			},
 		},
 
 		"GATHER": {
 			"leave": function() {
 				// Show the carried resource, if we've gathered anything.
 				this.SetDefaultAnimationVariant();
 			},
 
 			"APPROACHING": {
 				"enter": function() {
 					this.gatheringTarget = this.order.data.target;	// temporary, deleted in "leave".
 
 					let cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					let cmpMirage = Engine.QueryInterface(this.gatheringTarget, IID_Mirage);
 					if ((!cmpMirage || !cmpMirage.Mirages(IID_ResourceSupply)) &&
 					    (!cmpSupply || !cmpSupply.AddGatherer(this.entity)) ||
 					    !this.MoveTo(this.order.data, IID_ResourceGatherer))
 					{
 						// If the target's last known position is in FOW, try going there
 						// and hope that we might find it then.
 						let lastPos = this.order.data.lastPos;
 						if (this.gatheringTarget != INVALID_ENTITY &&
 						    lastPos && !this.CheckPositionVisible(lastPos.x, lastPos.z))
 						{
 							this.PushOrderFront("Walk", {
 								"x": lastPos.x, "z": lastPos.z,
 								"force": this.order.data.force
 							});
 							return true;
 						}
 						this.SetNextState("FINDINGNEWTARGET");
 						return true;
 					}
 					this.SetAnimationVariant("approach_" + this.order.data.type.specific);
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					if (cmpResourceGatherer)
 						cmpResourceGatherer.AddToPlayerCounter(this.order.data.type.generic);
 					return false;
 				},
 
 				"MovementUpdate": function(msg) {
 					// The GATHERING timer will handle finding a valid resource.
 					if (msg.likelyFailure)
 						this.SetNextState("FINDINGNEWTARGET");
 					else if (this.CheckRange(this.order.data, IID_ResourceGatherer))
 						this.SetNextState("GATHERING");
 				},
 
 				"leave": function() {
 					this.StopMoving();
 
 					if (!this.gatheringTarget)
 						return;
 					// don't use ownership because this is called after a conversion/resignation
 					// and the ownership would be invalid then.
 					let cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					if (cmpSupply)
 						cmpSupply.RemoveGatherer(this.entity);
 
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					if (cmpResourceGatherer)
 						cmpResourceGatherer.RemoveFromPlayerCounter();
 
 					delete this.gatheringTarget;
 				},
 			},
 
 			// Walking to a good place to gather resources near, used by GatherNearPosition
 			"WALKING": {
 				"enter": function() {
 					if (!this.MoveTo(this.order.data))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					this.SetAnimationVariant("approach_" + this.order.data.type.specific);
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					// If we failed, the GATHERING timer will handle finding a valid resource.
 					if (msg.likelyFailure || msg.obstructed && this.RelaxedMaxRangeCheck(this.order.data, this.DefaultRelaxedMaxRange) ||
 						 this.CheckRange(this.order.data))
 						this.SetNextState("GATHERING");
 				},
 			},
 
 			"GATHERING": {
 				"enter": function() {
 					this.gatheringTarget = this.order.data.target || INVALID_ENTITY; // deleted in "leave".
 
 					// Check if the resource is full.
 					// Will only be added if we're not already in.
 					let cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					if (!cmpSupply || !cmpSupply.AddActiveGatherer(this.entity))
 					{
 						this.SetNextState("FINDINGNEWTARGET");
 						return true;
 					}
 
 					// If this order was forced, the player probably gave it, but now we've reached the target
 					//	switch to an unforced order (can be interrupted by attacks)
 					this.order.data.force = false;
 					this.order.data.autoharvest = true;
 
 					// Calculate timing based on gather rates
 					// This allows the gather rate to control how often we gather, instead of how much.
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					let rate = cmpResourceGatherer.GetTargetGatherRate(this.gatheringTarget);
 
 					if (!rate)
 					{
 						// Try to find another target if the current one stopped existing
 						if (!Engine.QueryInterface(this.gatheringTarget, IID_Identity))
 						{
 							this.SetNextState("FINDINGNEWTARGET");
 							return true;
 						}
 
 						// No rate, give up on gathering
 						this.FinishOrder();
 						return true;
 					}
 
 					// Scale timing interval based on rate, and start timer
 					// The offset should be at least as long as the repeat time so we use the same value for both.
 					let offset = 1000 / rate;
 					this.StartTimer(offset, offset);
 
 					// We want to start the gather animation as soon as possible,
 					// but only if we're actually at the target and it's still alive
 					// (else it'll look like we're chopping empty air).
 					// (If it's not alive, the Timer handler will deal with sending us
 					// off to a different target.)
 					if (this.CheckTargetRange(this.gatheringTarget, IID_ResourceGatherer))
 					{
 						this.SetDefaultAnimationVariant();
 						this.FaceTowardsTarget(this.order.data.target);
 						this.SelectAnimation("gather_" + this.order.data.type.specific);
 						cmpResourceGatherer.AddToPlayerCounter(this.order.data.type.generic);
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopTimer();
 
 					// Don't use ownership because this is called after a conversion/resignation
 					// and the ownership would be invalid then.
 					let cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					if (cmpSupply)
 						cmpSupply.RemoveGatherer(this.entity);
 
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					if (cmpResourceGatherer)
 						cmpResourceGatherer.RemoveFromPlayerCounter();
 
 					delete this.gatheringTarget;
 
 					this.ResetAnimation();
 				},
 
 				"Timer": function(msg) {
 					let resourceTemplate = this.order.data.template;
 					let resourceType = this.order.data.type;
 
 					// TODO: we are leaking information here - if the target died in FOW, we'll know it's dead
 					// straight away.
 					// Seems one would have to listen to ownership changed messages to make it work correctly
 					// but that's likely prohibitively expansive performance wise.
 
 					let cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					// If we can't gather from the target, find a new one.
 					if (!cmpSupply || !cmpSupply.IsAvailableTo(this.entity) ||
 					    !this.CanGather(this.gatheringTarget))
 					{
 						this.SetNextState("FINDINGNEWTARGET");
 						return;
 					}
 
 					if (!this.CheckTargetRange(this.gatheringTarget, IID_ResourceGatherer))
 					{
 						// Try to follow the target
 						if (this.MoveToTargetRange(this.gatheringTarget, IID_ResourceGatherer))
 							this.SetNextState("APPROACHING");
 						// Our target is no longer visible - go to its last known position first
 						// and then hopefully it will become visible.
 						else if (!this.CheckTargetVisible(this.gatheringTarget) && this.order.data.lastPos)
 							this.PushOrderFront("Walk", {
 								"x": this.order.data.lastPos.x,
 								"z": this.order.data.lastPos.z,
 								"force": this.order.data.force
 							});
 						else
 							this.SetNextState("FINDINGNEWTARGET");
 						return;
 					}
 
 
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 
 					// If we've already got some resources but they're the wrong type,
 					// drop them first to ensure we're only ever carrying one type
 					if (cmpResourceGatherer.IsCarryingAnythingExcept(resourceType.generic))
 						cmpResourceGatherer.DropResources();
 
 					this.FaceTowardsTarget(this.order.data.target);
 
 					let status = cmpResourceGatherer.PerformGather(this.gatheringTarget);
 
 					if (status.filled)
 					{
 						let nearestDropsite = this.FindNearestDropsite(resourceType.generic);
 						if (nearestDropsite)
 						{
 							// (Keep this Gather order on the stack so we'll
 							// continue gathering after returning)
 							// However mark our target as invalid if it's exhausted, so we don't waste time
 							// trying to gather from it.
 							if (status.exhausted)
 								this.order.data.target = INVALID_ENTITY;
 							this.PushOrderFront("ReturnResource", { "target": nearestDropsite, "force": false });
 							return;
 						}
 
 						// Oh no, couldn't find any drop sites. Give up on gathering.
 						this.FinishOrder();
 						return;
 					}
 
 					if (status.exhausted)
 						this.SetNextState("FINDINGNEWTARGET");
 				},
 			},
 
 			"FINDINGNEWTARGET": {
 				"enter": function() {
 					let previousTarget = this.order.data.target;
 					let resourceTemplate = this.order.data.template;
 					let resourceType = this.order.data.type;
 
 					// Give up on this order and try our next queued order
 					// but first check what is our next order and, if needed, insert a returnResource order
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					if (cmpResourceGatherer.IsCarrying(resourceType.generic) &&
 						this.orderQueue.length > 1 && this.orderQueue[1] !== "ReturnResource" &&
 						(this.orderQueue[1].type !== "Gather" || this.orderQueue[1].data.type.generic !== resourceType.generic))
 					{
 						let nearestDropsite = this.FindNearestDropsite(resourceType.generic);
 						if (nearestDropsite)
 							this.orderQueue.splice(1, 0, { "type": "ReturnResource", "data": { "target": nearestDropsite, "force": false } });
 					}
 
 					// Must go before FinishOrder or this.order will be undefined.
 					let initPos = this.order.data.initPos;
 
 					if (this.FinishOrder())
 						return true;
 
 					// No remaining orders - pick a useful default behaviour
 
 					let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 					if (!cmpPosition || !cmpPosition.IsInWorld())
 						return true;
 
 					let filter = (ent, type, template) => {
 						if (previousTarget == ent)
 							return false;
 
 						// Don't switch to a different type of huntable animal.
 						return type.specific == resourceType.specific &&
 						    (type.specific != "meat" || resourceTemplate == template);
 					};
 
 					// Current position is often next to a dropsite.
 					let pos = cmpPosition.GetPosition();
 					let nearbyResource = this.FindNearbyResource(Vector2D.from3D(pos), filter);
 
 					// If there is an initPos, search there as well when we haven't found anything.
 					// Otherwise set initPos to our current pos.
 					if (!initPos)
 						initPos = { 'x': pos.X, 'z': pos.Z };
 					else if (!nearbyResource)
 						nearbyResource = this.FindNearbyResource(new Vector2D(initPos.X, initPos.Z), filter);
 
 					if (nearbyResource)
 					{
 						this.PerformGather(nearbyResource, false, false);
 						return true;
 					}
 
 					// Failing that, try to move there and se if we are more lucky: maybe there are resources in FOW.
 					// Only move if we are some distance away (TODO: pick the distance better?)
 					if (!this.CheckPointRangeExplicit(initPos.x, initPos.z, 0, 10))
 					{
 						this.GatherNearPosition(initPos.x, initPos.z, resourceType, resourceTemplate);
 						return true;
 					}
 
 					// Nothing else to gather - if we're carrying anything then we should
 					// drop it off, and if not then we might as well head to the dropsite
 					// anyway because that's a nice enough place to congregate and idle
 
 					let nearestDropsite = this.FindNearestDropsite(resourceType.generic);
 					if (nearestDropsite)
 					{
 						this.PushOrderFront("ReturnResource", { "target": nearestDropsite, "force": false });
 						return true;
 					}
 					// No dropsites - just give up.
 					return true;
 				},
 			},
 		},
 
 		"HEAL": {
 			"Attacked": function(msg) {
 				if (!this.GetStance().respondStandGround && !this.order.data.force)
 					this.Flee(msg.data.attacker, false);
 			},
 
 			"APPROACHING": {
 				"enter": function() {
 					if (this.CheckRange(this.order.data, IID_Heal))
 					{
 						this.SetNextState("HEALING");
 						return true;
 					}
 
 					if (!this.MoveTo(this.order.data, IID_Heal))
 					{
 						this.SetNextState("FINDINGNEWTARGET");
 						return true;
 					}
 
 					this.StartTimer(1000, 1000);
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Heal, null))
 						this.SetNextState("FINDINGNEWTARGET");
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.likelyFailure || this.CheckRange(this.order.data, IID_Heal))
 						this.SetNextState("HEALING");
 				},
 			},
 
 			"HEALING": {
 				"enter": function() {
 					if (!this.CheckRange(this.order.data, IID_Heal))
 					{
 						this.SetNextState("APPROACHING");
 						return true;
 					}
 
 					if (!this.TargetIsAlive(this.order.data.target) ||
 					    !this.CanHeal(this.order.data.target))
 					{
 						this.SetNextState("FINDINGNEWTARGET");
 						return true;
 					}
 
 					let cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
 					this.healTimers = cmpHeal.GetTimers();
 
 					// If the repeat time since the last heal hasn't elapsed,
 					// delay the action to avoid healing too fast.
 					var prepare = this.healTimers.prepare;
 					if (this.lastHealed)
 					{
 						var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 						var repeatLeft = this.lastHealed + this.healTimers.repeat - cmpTimer.GetTime();
 						prepare = Math.max(prepare, repeatLeft);
 					}
 
 					this.SelectAnimation("heal");
 					this.SetAnimationSync(prepare, this.healTimers.repeat);
 					this.StartTimer(prepare, this.healTimers.repeat);
 
 					// If using a non-default prepare time, re-sync the animation when the timer runs.
 					this.resyncAnimation = prepare != this.healTimers.prepare;
 
 					this.FaceTowardsTarget(this.order.data.target);
 					return false;
 				},
 
 				"leave": function() {
 					this.ResetAnimation();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					let target = this.order.data.target;
 					if (!this.TargetIsAlive(target) || !this.CanHeal(target))
 					{
 						this.SetNextState("FINDINGNEWTARGET");
 						return;
 					}
 					if (!this.CheckRange(this.order.data, IID_Heal))
 					{
 						if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
 						{
 							if (this.CanPack())
 							{
 								this.PushOrderFront("Pack", { "force": true });
 								return;
 							}
 							this.SetNextState("HEAL.APPROACHING");
 						}
 						else
 							this.SetNextState("FINDINGNEWTARGET");
 						return;
 					}
 
 					let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 					this.lastHealed = cmpTimer.GetTime() - msg.lateness;
 
 					this.FaceTowardsTarget(target);
 					let cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
 					cmpHeal.PerformHeal(target);
 
 					if (this.resyncAnimation)
 					{
 						this.SetAnimationSync(this.healTimers.repeat, this.healTimers.repeat);
 						this.resyncAnimation = false;
 					}
 				},
 			},
 
 			"FINDINGNEWTARGET": {
 				"enter": function() {
 					// If we have another order, do that instead.
 					if (this.FinishOrder())
 						return true;
 
 					if (this.FindNewHealTargets())
 						return true;
 
 					if (this.GetStance().respondHoldGround)
 						this.WalkToHeldPosition();
 
 					// We quit this state right away.
 					return true;
 				},
 			},
 		},
 
 		// Returning to dropsite
 		"RETURNRESOURCE": {
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveTo(this.order.data, IID_ResourceGatherer))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					// Check the dropsite is in range and we can return our resource there
 					// (we didn't get stopped before reaching it)
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					if (this.CheckTargetRange(this.order.data.target, IID_ResourceGatherer) &&
 					    this.CanReturnResource(this.order.data.target, true, cmpResourceGatherer))
 					{
 						cmpResourceGatherer.CommitResources(this.order.data.target);
 
 						// Stop showing the carried resource animation.
 						this.SetDefaultAnimationVariant();
 
 						// Our next order should always be a Gather,
 						// so just switch back to that order.
 						this.FinishOrder();
 						return;
 					}
 
 					if (msg.obstructed)
 						return;
 
 					// If we are here: we are in range but not carrying the right resources (or resources at all),
 					// the dropsite was destroyed, or we couldn't reach it, or ownership changed.
 					// Look for a new one.
 					let genericType = cmpResourceGatherer.GetMainCarryingType();
 					let nearby = this.FindNearestDropsite(genericType);
 					if (nearby)
 					{
 						this.FinishOrder();
 						this.PushOrderFront("ReturnResource", { "target": nearby, "force": false });
 						return;
 					}
 
 					// Oh no, couldn't find any drop sites. Give up on returning.
 					this.FinishOrder();
 				},
 			},
 		},
 
 		"COLLECTTREASURE": {
 			"enter": function() {
 				let cmpTreasureCollecter = Engine.QueryInterface(this.entity, IID_TreasureCollecter);
 				if (!cmpTreasureCollecter || !cmpTreasureCollecter.CanCollect(this.order.data.target))
 				{
 					this.SetNextState("FINDINGNEWTARGET");
 					return true;
 				}
 				if (this.CheckTargetRange(this.order.data.target, IID_TreasureCollecter))
 					this.SetNextState("COLLECTING");
 				else
 					this.SetNextState("APPROACHING");
 				return true;
 			},
 
 			"leave": function() {
 			},
 
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveToTargetRange(this.order.data.target, IID_TreasureCollecter))
 					{
 						this.SetNextState("FINDINGNEWTARGET");
 						return true;
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (this.CheckTargetRange(this.order.data.target, IID_TreasureCollecter))
 						this.SetNextState("COLLECTING");
 					else if (msg.likelyFailure)
 						this.SetNextState("FINDINGNEWTARGET");
 				},
 			},
 
 			"COLLECTING": {
 				"enter": function() {
 					let cmpTreasureCollecter = Engine.QueryInterface(this.entity, IID_TreasureCollecter);
 					if (!cmpTreasureCollecter.StartCollecting(this.order.data.target, IID_UnitAI))
 					{
 						this.ProcessMessage("TargetInvalidated");
 						return true;
 					}
 					this.FaceTowardsTarget(this.order.data.target);
 					this.SelectAnimation("collecting_treasure");
 					return false;
 				},
 
 				"leave": function() {
 					let cmpTreasureCollecter = Engine.QueryInterface(this.entity, IID_TreasureCollecter);
 					if (cmpTreasureCollecter)
 						cmpTreasureCollecter.StopCollecting();
 					this.ResetAnimation();
 				},
 
 				"OutOfRange": function(msg) {
 					this.SetNextState("APPROACHING");
 				},
 
 				"TargetInvalidated": function(msg) {
 					this.SetNextState("FINDINGNEWTARGET");
 				},
 			},
 
 			"FINDINGNEWTARGET": {
 				"enter": function() {
 					let oldData = this.order.data;
 
 					// Switch to the next order (if any).
 					if (this.FinishOrder())
 						return true;
 
 					// If autocontinue explicitly disabled (e.g. by AI)
 					// then do nothing automatically.
 					if (!oldData.autocontinue)
 						return false;
 
 					let nearbyTreasure = this.FindNearbyTreasure(this.TargetPosOrEntPos(oldData.target));
 					if (nearbyTreasure)
 						this.CollectTreasure(nearbyTreasure, oldData.autocontinue, true);
 
 					return true;
 				},
 			},
 		},
 
 		"TRADE": {
 			"Attacked": function(msg) {
 				// Ignore attack
 				// TODO: Inform player
 			},
 
 			"APPROACHINGMARKET": {
 				"enter": function() {
 					if (!this.MoveToMarket(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (!msg.likelyFailure && !this.CheckRange(this.order.data.nextTarget, IID_Trader))
 						return;
 					if (this.waypoints && this.waypoints.length)
 					{
 						if (!this.MoveToMarket(this.order.data.target))
 							this.StopTrading();
 					}
 					else
 						this.PerformTradeAndMoveToNextMarket(this.order.data.target);
 				},
 			},
 
 			"TradingCanceled": function(msg) {
 				if (msg.market != this.order.data.target)
 					return;
 				let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 				let otherMarket = cmpTrader && cmpTrader.GetFirstMarket();
 				this.StopTrading();
 				if (otherMarket)
 					this.WalkToTarget(otherMarket);
 			},
 		},
 
 		"REPAIR": {
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveTo(this.order.data, IID_Builder))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.likelyFailure || msg.likelySuccess)
 						this.SetNextState("REPAIRING");
 				},
 			},
 
 			"REPAIRING": {
 				"enter": function() {
 					// If this order was forced, the player probably gave it, but now we've reached the target
 					//	switch to an unforced order (can be interrupted by attacks)
 					if (this.order.data.force)
 						this.order.data.autoharvest = true;
 
 					this.order.data.force = false;
 
 					// Needed to remove the entity from the builder list when leaving this state.
 					this.repairTarget = this.order.data.target;
 
 					if (!this.CanRepair(this.repairTarget))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					if (!this.CheckTargetRange(this.repairTarget, IID_Builder))
 					{
 						this.SetNextState("APPROACHING");
 						return true;
 					}
 
 					let cmpHealth = Engine.QueryInterface(this.repairTarget, IID_Health);
 					if (cmpHealth && cmpHealth.GetHitpoints() >= cmpHealth.GetMaxHitpoints())
 					{
 						// The building was already finished/fully repaired before we arrived;
 						// let the ConstructionFinished handler handle this.
 						this.ConstructionFinished({ "entity": this.repairTarget, "newentity": this.repairTarget });
 						return true;
 					}
 
 					let cmpBuilderList = QueryBuilderListInterface(this.repairTarget);
 					if (cmpBuilderList)
 						cmpBuilderList.AddBuilder(this.entity);
 
 					this.FaceTowardsTarget(this.repairTarget);
 
 					this.SelectAnimation("build");
 					this.StartTimer(1000, 1000);
 					return false;
 				},
 
 				"leave": function() {
 					let cmpBuilderList = QueryBuilderListInterface(this.repairTarget);
 					if (cmpBuilderList)
 						cmpBuilderList.RemoveBuilder(this.entity);
 					delete this.repairTarget;
 					this.StopTimer();
 					this.ResetAnimation();
 				},
 
 				"Timer": function(msg) {
 					if (!this.CanRepair(this.repairTarget))
 					{
 						this.FinishOrder();
 						return;
 					}
 
 					this.FaceTowardsTarget(this.repairTarget);
 
 					let cmpBuilder = Engine.QueryInterface(this.entity, IID_Builder);
 					cmpBuilder.PerformBuilding(this.repairTarget);
 					// If the building is completed, the leave() function will be called
 					// by the ConstructionFinished message.
 					// In that case, the repairTarget is deleted, and we can just return.
 					if (!this.repairTarget)
 						return;
 					if (!this.CheckTargetRange(this.repairTarget, IID_Builder))
 						this.SetNextState("APPROACHING");
 				},
 			},
 
 			"ConstructionFinished": function(msg) {
 				if (msg.data.entity != this.order.data.target)
 					return; // ignore other buildings
 
 				let oldData = this.order.data;
 
 				// Save the current state so we can continue walking if necessary
 				// FinishOrder() below will switch to IDLE if there's no order, which sets the idle animation.
 				// Idle animation while moving towards finished construction looks weird (ghosty).
 				let oldState = this.GetCurrentState();
 
 				let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 				let canReturnResources = this.CanReturnResource(msg.data.newentity, true, cmpResourceGatherer);
 				if (this.CheckTargetRange(msg.data.newentity, IID_Builder) && canReturnResources)
 				{
 					cmpResourceGatherer.CommitResources(msg.data.newentity);
 					this.SetDefaultAnimationVariant();
 				}
 
 				// Switch to the next order (if any)
 				if (this.FinishOrder())
 				{
 					if (canReturnResources)
 					{
 						// We aren't in range, but we can still return resources there: always do so.
 						this.SetDefaultAnimationVariant();
 						this.PushOrderFront("ReturnResource", { "target": msg.data.newentity, "force": false });
 					}
 					return;
 				}
 
 				if (canReturnResources)
 				{
 					// We aren't in range, but we can still return resources there: always do so.
 					this.SetDefaultAnimationVariant();
 					this.PushOrderFront("ReturnResource", { "target": msg.data.newentity, "force": false });
 				}
 
 				// No remaining orders - pick a useful default behaviour
 
 				// If autocontinue explicitly disabled (e.g. by AI) then
 				// do nothing automatically
 				if (!oldData.autocontinue)
 					return;
 
 				// If this building was e.g. a farm of ours, the entities that received
 				// the build command should start gathering from it
 				if ((oldData.force || oldData.autoharvest) && this.CanGather(msg.data.newentity))
 				{
 					this.PerformGather(msg.data.newentity, true, false);
 					return;
 				}
 
 				// If this building was e.g. a farmstead of ours, entities that received
 				// the build command should look for nearby resources to gather
 				if ((oldData.force || oldData.autoharvest) &&
 				    this.CanReturnResource(msg.data.newentity, false, cmpResourceGatherer))
 				{
 					let cmpResourceDropsite = Engine.QueryInterface(msg.data.newentity, IID_ResourceDropsite);
 					let types = cmpResourceDropsite.GetTypes();
 					// TODO: Slightly undefined behavior here, we don't know what type of resource will be collected,
 					//   may cause problems for AIs (especially hunting fast animals), but avoid ugly hacks to fix that!
 					let nearby = this.FindNearbyResource(this.TargetPosOrEntPos(msg.data.newentity),
 						(ent, type, template) => types.indexOf(type.generic) != -1);
 
 					if (nearby)
 					{
 						this.PerformGather(nearby, true, false);
 						return;
 					}
 				}
 
 				let nearbyFoundation = this.FindNearbyFoundation(this.TargetPosOrEntPos(msg.data.newentity));
 				if (nearbyFoundation)
 				{
 					this.AddOrder("Repair", { "target": nearbyFoundation, "autocontinue": oldData.autocontinue, "force": false }, true);
 					return;
 				}
 
 				// Unit was approaching and there's nothing to do now, so switch to walking
 				if (oldState.endsWith("REPAIR.APPROACHING"))
 					// We're already walking to the given point, so add this as a order.
 					this.WalkToTarget(msg.data.newentity, true);
 			},
 		},
 
 		"GARRISON": {
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.CanGarrison(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					if (!this.MoveToGarrisonRange(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					if (this.pickup)
 						Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
 
 					let cmpGarrisonHolder = Engine.QueryInterface(this.order.data.target, IID_GarrisonHolder);
 					if (cmpGarrisonHolder && cmpGarrisonHolder.CanPickup(this.entity))
 					{
 						this.pickup = this.order.data.target;
 						Engine.PostMessage(this.pickup, MT_PickupRequested, { "entity": this.entity });
 					}
 					return false;
 				},
 
 				"leave": function() {
 					if (this.pickup)
 					{
 						Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
 						delete this.pickup;
 					}
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (!msg.likelyFailure && !msg.likelySuccess)
 						return;
 
 					if (this.CheckGarrisonRange(this.order.data.target))
-						this.SetNextState("GARRISONED");
+						this.SetNextState("GARRISONING");
 					else
 					{
 						// Unable to reach the target, try again (or follow if it is a moving target)
 						// except if the target does not exist anymore or its orders have changed.
 						if (this.pickup)
 						{
 							let cmpUnitAI = Engine.QueryInterface(this.pickup, IID_UnitAI);
 							if (!cmpUnitAI || (!cmpUnitAI.HasPickupOrder(this.entity) && !cmpUnitAI.IsIdle()))
 								this.FinishOrder();
 						}
 					}
 				},
 			},
 
-			"GARRISONED": {
+			"GARRISONING": {
 				"enter": function() {
 					let target = this.order.data.target;
 					let cmpGarrisonable = Engine.QueryInterface(this.entity, IID_Garrisonable);
 					if (!cmpGarrisonable || !cmpGarrisonable.Garrison(target))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					if (this.formationController)
 					{
 						let cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 						if (cmpFormation)
 						{
 							let rearrange = cmpFormation.rearrange;
 							cmpFormation.SetRearrange(false);
 							cmpFormation.RemoveMembers([this.entity]);
 							cmpFormation.SetRearrange(rearrange);
 						}
 					}
 
 					let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					if (this.CanReturnResource(target, true, cmpResourceGatherer))
 					{
 						cmpResourceGatherer.CommitResources(target);
 						this.SetDefaultAnimationVariant();
 					}
 
-					if (this.IsTurret())
-					{
-						this.SetNextState("IDLE");
-						return true;
-					}
-
-					return false;
+					this.FinishOrder();
+					return true;
 				},
 
 				"leave": function() {
 				},
 			},
 		},
 
 		"CHEERING": {
 			"enter": function() {
 				this.SelectAnimation("promotion");
 				this.StartTimer(this.cheeringTime);
 				return false;
 			},
 
 			"leave": function() {
 				// PushOrderFront preserves the cheering order,
 				// which can lead to very bad behaviour, so make
 				// sure to delete any queued ones.
 				for (let i = 1; i < this.orderQueue.length; ++i)
 					if (this.orderQueue[i].type == "Cheer")
 						this.orderQueue.splice(i--, 1);
 				this.StopTimer();
 				this.ResetAnimation();
 			},
 
 			"LosRangeUpdate": function(msg) {
 				if (msg && msg.data && msg.data.added && msg.data.added.length)
 					this.RespondToSightedEntities(msg.data.added);
 			},
 
 			"LosHealRangeUpdate": function(msg) {
 				if (msg && msg.data && msg.data.added && msg.data.added.length)
 					this.RespondToHealableEntities(msg.data.added);
 			},
 
 			"LosAttackRangeUpdate": function(msg) {
 				if (msg && msg.data && msg.data.added && msg.data.added.length && this.GetStance().targetVisibleEnemies)
 					this.AttackEntitiesByPreference(msg.data.added);
 			},
 
 			"Timer": function(msg) {
 				this.FinishOrder();
 			},
 		},
 
 		"PACKING": {
 			"enter": function() {
 				let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 				cmpPack.Pack();
 				return false;
 			},
 
 			"Order.CancelPack": function(msg) {
 				this.FinishOrder();
 				return ACCEPT_ORDER;
 			},
 
 			"PackFinished": function(msg) {
 				this.FinishOrder();
 			},
 
 			"leave": function() {
 				let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 				cmpPack.CancelPack();
 			},
 
 			"Attacked": function(msg) {
 				// Ignore attacks while packing
 			},
 		},
 
 		"UNPACKING": {
 			"enter": function() {
 				let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 				cmpPack.Unpack();
 				return false;
 			},
 
 			"Order.CancelUnpack": function(msg) {
 				this.FinishOrder();
 				return ACCEPT_ORDER;
 			},
 
 			"PackFinished": function(msg) {
 				this.FinishOrder();
 			},
 
 			"leave": function() {
 				let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 				cmpPack.CancelPack();
 			},
 
 			"Attacked": function(msg) {
 				// Ignore attacks while unpacking
 			},
 		},
 
 		"PICKUP": {
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveTo(this.order.data))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					return false;
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.likelyFailure || msg.likelySuccess)
 						this.SetNextState("LOADING");
 				},
 
 				"PickupCanceled": function() {
 					this.FinishOrder();
 				},
 			},
 
 			"LOADING": {
 				"enter": function() {
 					let cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
 					if (!cmpGarrisonHolder || cmpGarrisonHolder.IsFull())
 					{
 						this.FinishOrder();
 						return true;
 					}
 					return false;
 				},
 
 				"PickupCanceled": function() {
 					this.FinishOrder();
 				},
 			},
 		},
 	},
 };
 
 UnitAI.prototype.Init = function()
 {
 	this.orderQueue = []; // current order is at the front of the list
 	this.order = undefined; // always == this.orderQueue[0]
 	this.formationController = INVALID_ENTITY; // entity with IID_Formation that we belong to
 	this.isIdle = false;
 
 	this.heldPosition = undefined;
 
 	// Queue of remembered works
 	this.workOrders = [];
 
 	this.isGuardOf = undefined;
 
 	// For preventing increased action rate due to Stop orders or target death.
 	this.lastAttacked = undefined;
 	this.lastHealed = undefined;
 
 	this.formationAnimationVariant = undefined;
 	this.cheeringTime = +(this.template.CheeringTime || 0);
 	this.SetStance(this.template.DefaultStance);
 };
 
 UnitAI.prototype.IsTurret = function()
 {
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	return cmpPosition && cmpPosition.GetTurretParent() != INVALID_ENTITY;
 };
 
 UnitAI.prototype.IsFormationController = function()
 {
 	return (this.template.FormationController == "true");
 };
 
 UnitAI.prototype.IsFormationMember = function()
 {
 	return (this.formationController != INVALID_ENTITY);
 };
 
 /**
  * For now, entities with a RoamDistance are animals.
  */
 UnitAI.prototype.IsAnimal = function()
 {
 	return !!this.template.RoamDistance;
 };
 
 /**
  * ToDo: Make this not needed by fixing gaia
  * range queries in BuildingAI and UnitAI regarding
  * animals and other gaia entities.
  */
 UnitAI.prototype.IsDangerousAnimal = function()
 {
 	return this.IsAnimal() && this.GetStance().targetVisibleEnemies && !!Engine.QueryInterface(this.entity, IID_Attack);
 };
 
 UnitAI.prototype.IsHealer = function()
 {
 	return Engine.QueryInterface(this.entity, IID_Heal);
 };
 
 UnitAI.prototype.IsIdle = function()
 {
 	return this.isIdle;
 };
 
 /**
  * Used by formation controllers to toggle the idleness of their members.
  */
 UnitAI.prototype.ResetIdle = function()
 {
 	let shouldBeIdle = this.GetCurrentState().endsWith(".IDLE");
 	if (this.isIdle == shouldBeIdle)
 		return;
 	this.isIdle = shouldBeIdle;
 	Engine.PostMessage(this.entity, MT_UnitIdleChanged, { "idle": this.isIdle });
 };
 
 UnitAI.prototype.SetGarrisoned = function()
 {
 	// UnitAI caches its own garrisoned state for performance.
 	this.isGarrisoned = true;
 	this.SetImmobile();
 };
 
 UnitAI.prototype.UnsetGarrisoned = function()
 {
 	delete this.isGarrisoned;
 	this.SetMobile();
 };
 
 UnitAI.prototype.GetGarrisonHolder = function()
 {
 	if (!this.isGarrisoned)
 		return INVALID_ENTITY;
 
 	let cmpGarrisonable = Engine.QueryInterface(this.entity, IID_Garrisonable);
 	return cmpGarrisonable ? cmpGarrisonable.HolderID() : INVALID_ENTITY;
 };
 
 UnitAI.prototype.ShouldRespondToEndOfAlert = function()
 {
 	return !this.orderQueue.length || this.orderQueue[0].type == "Garrison";
 };
 
 UnitAI.prototype.SetImmobile = function()
 {
 	if (this.isImmobile)
 		return;
 
 	this.isImmobile = true;
 	Engine.PostMessage(this.entity, MT_UnitAbleToMoveChanged, {
 		"entity": this.entity,
 		"ableToMove": this.AbleToMove()
 	});
 };
 
 UnitAI.prototype.SetMobile = function()
 {
 	if (!this.isImmobile)
 		return;
 
 	delete this.isImmobile;
 	Engine.PostMessage(this.entity, MT_UnitAbleToMoveChanged, {
 		"entity": this.entity,
 		"ableToMove": this.AbleToMove()
 	});
 };
 
 /**
  * @param cmpUnitMotion - optionally pass unitMotion to avoid querying it here
  * @returns true if the entity can move, i.e. has UnitMotion and isn't immobile.
  */
 UnitAI.prototype.AbleToMove = function(cmpUnitMotion)
 {
 	if (this.isImmobile || this.IsTurret())
 		return false;
 
 	if (!cmpUnitMotion)
 		cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 
 	return !!cmpUnitMotion;
 };
 
 UnitAI.prototype.IsFleeing = function()
 {
 	var state = this.GetCurrentState().split(".").pop();
 	return (state == "FLEEING");
 };
 
 UnitAI.prototype.IsWalking = function()
 {
 	var state = this.GetCurrentState().split(".").pop();
 	return (state == "WALKING");
 };
 
 /**
  * Return true if the current order is WalkAndFight or Patrol.
  */
 UnitAI.prototype.IsWalkingAndFighting = function()
 {
 	if (this.IsFormationMember())
 		return false;
 
 	return this.orderQueue.length > 0 && (this.orderQueue[0].type == "WalkAndFight" || this.orderQueue[0].type == "Patrol");
 };
 
 UnitAI.prototype.OnCreate = function()
 {
 	if (this.IsFormationController())
 		this.UnitFsm.Init(this, "FORMATIONCONTROLLER.IDLE");
 	else
 		this.UnitFsm.Init(this, "INDIVIDUAL.IDLE");
 	this.isIdle = true;
 };
 
 UnitAI.prototype.OnDiplomacyChanged = function(msg)
 {
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (cmpOwnership && cmpOwnership.GetOwner() == msg.player)
 		this.SetupRangeQueries();
 
 	if (this.isGuardOf && !IsOwnedByMutualAllyOfEntity(this.entity, this.isGuardOf))
 		this.RemoveGuard();
 };
 
 UnitAI.prototype.OnOwnershipChanged = function(msg)
 {
 	this.SetupRangeQueries();
 
 	if (this.isGuardOf && (msg.to == INVALID_PLAYER || !IsOwnedByMutualAllyOfEntity(this.entity, this.isGuardOf)))
 		this.RemoveGuard();
 
 	// If the unit isn't being created or dying, reset stance and clear orders
 	if (msg.to != INVALID_PLAYER && msg.from != INVALID_PLAYER)
 	{
 		// Switch to a virgin state to let states execute their leave handlers.
-		// Except if garrisoned or (un)packing, in which case we only clear the order queue.
-		if (this.isGarrisoned || this.IsPacking())
+		// Except if (un)packing, in which case we only clear the order queue.
+		if (this.IsPacking())
 		{
 			this.orderQueue.length = Math.min(this.orderQueue.length, 1);
 			Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 		}
 		else
 		{
 			let index = this.GetCurrentState().indexOf(".");
 			if (index != -1)
 				this.UnitFsm.SwitchToNextState(this, this.GetCurrentState().slice(0,index));
 			this.Stop(false);
 		}
 
 		this.workOrders = [];
 		let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 		if (cmpTrader)
 			cmpTrader.StopTrading();
 
 		this.SetStance(this.template.DefaultStance);
 		if (this.IsTurret())
 			this.SetTurretStance();
 	}
 };
 
 UnitAI.prototype.OnDestroy = function()
 {
 	// Switch to an empty state to let states execute their leave handlers.
 	this.UnitFsm.SwitchToNextState(this, "");
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (this.losRangeQuery)
 		cmpRangeManager.DestroyActiveQuery(this.losRangeQuery);
 	if (this.losHealRangeQuery)
 		cmpRangeManager.DestroyActiveQuery(this.losHealRangeQuery);
 	if (this.losAttackRangeQuery)
 		cmpRangeManager.DestroyActiveQuery(this.losAttackRangeQuery);
 };
 
 UnitAI.prototype.OnVisionRangeChanged = function(msg)
 {
 	if (this.entity == msg.entity)
 		this.SetupRangeQueries();
 };
 
 UnitAI.prototype.HasPickupOrder = function(entity)
 {
 	return this.orderQueue.some(order => order.type == "PickupUnit" && order.data.target == entity);
 };
 
 UnitAI.prototype.OnPickupRequested = function(msg)
 {
 	if (this.HasPickupOrder(msg.entity))
 		return;
 	this.PushOrderAfterForced("PickupUnit", { "target": msg.entity });
 };
 
 UnitAI.prototype.OnPickupCanceled = function(msg)
 {
 	for (let i = 0; i < this.orderQueue.length; ++i)
 	{
 		if (this.orderQueue[i].type != "PickupUnit" || this.orderQueue[i].data.target != msg.entity)
 			continue;
 		if (i == 0)
 			this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});
 		else
 			this.orderQueue.splice(i, 1);
 		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 		break;
 	}
 };
 
 /**
  * Wrapper function that sets up the LOS, healer and attack range queries.
  * This should be called whenever our ownership changes.
  */
 UnitAI.prototype.SetupRangeQueries = function()
 {
 	if (this.GetStance().respondFleeOnSight)
 		this.SetupLOSRangeQuery();
 
 	if (this.IsHealer())
 		this.SetupHealRangeQuery();
 
 	if (Engine.QueryInterface(this.entity, IID_Attack))
 		this.SetupAttackRangeQuery();
 };
 
 UnitAI.prototype.UpdateRangeQueries = function()
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (this.losRangeQuery)
 		this.SetupLOSRangeQuery(cmpRangeManager.IsActiveQueryEnabled(this.losRangeQuery));
 
 	if (this.losHealRangeQuery)
 		this.SetupHealRangeQuery(cmpRangeManager.IsActiveQueryEnabled(this.losHealRangeQuery));
 
 	if (this.losAttackRangeQuery)
 		this.SetupAttackRangeQuery(cmpRangeManager.IsActiveQueryEnabled(this.losAttackRangeQuery));
 };
 
 /**
  * Set up a range query for all enemy units within LOS range.
  * @param {boolean} enable - Optional parameter whether to enable the query.
  */
 UnitAI.prototype.SetupLOSRangeQuery = function(enable = true)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (this.losRangeQuery)
 	{
 		cmpRangeManager.DestroyActiveQuery(this.losRangeQuery);
 		this.losRangeQuery = undefined;
 	}
 
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	// If we are being destructed (owner == -1), creating a range query is pointless.
 	if (!cmpPlayer)
 		return;
 
 	let players = cmpPlayer.GetEnemies();
 	if (!players.length)
 		return;
 
 	let range = this.GetQueryRange(IID_Vision);
 	// Do not compensate for entity sizes: LOS doesn't, and UnitAI relies on that.
 	this.losRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity,
 		range.min, range.max, players, IID_Identity,
 		cmpRangeManager.GetEntityFlagMask("normal"), false);
 
 	if (enable)
 		cmpRangeManager.EnableActiveQuery(this.losRangeQuery);
 };
 
 /**
  * Set up a range query for all own or ally units within LOS range
  * which can be healed.
  * @param {boolean} enable - Optional parameter whether to enable the query.
  */
 UnitAI.prototype.SetupHealRangeQuery = function(enable = true)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 
 	if (this.losHealRangeQuery)
 	{
 		cmpRangeManager.DestroyActiveQuery(this.losHealRangeQuery);
 		this.losHealRangeQuery = undefined;
 	}
 
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	// If we are being destructed (owner == -1), creating a range query is pointless.
 	if (!cmpPlayer)
 		return;
 
 	let players = cmpPlayer.GetAllies();
 	let range = this.GetQueryRange(IID_Heal);
 
 	// Do not compensate for entity sizes: LOS doesn't, and UnitAI relies on that.
 	this.losHealRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity,
 		range.min, range.max, players, IID_Health,
 		cmpRangeManager.GetEntityFlagMask("injured"), false);
 
 	if (enable)
 		cmpRangeManager.EnableActiveQuery(this.losHealRangeQuery);
 };
 
 /**
  * Set up a range query for all enemy and gaia units within range
  * which can be attacked.
  * @param {boolean} enable - Optional parameter whether to enable the query.
  */
 UnitAI.prototype.SetupAttackRangeQuery = function(enable = true)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 
 	if (this.losAttackRangeQuery)
 	{
 		cmpRangeManager.DestroyActiveQuery(this.losAttackRangeQuery);
 		this.losAttackRangeQuery = undefined;
 	}
 
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	// If we are being destructed (owner == -1), creating a range query is pointless.
 	if (!cmpPlayer)
 		return;
 
 	// TODO: How to handle neutral players - Special query to attack military only?
 	let players = cmpPlayer.GetEnemies();
 	if (!players.length)
 		return;
 
 	let range = this.GetQueryRange(IID_Attack);
 	// Do not compensate for entity sizes: LOS doesn't, and UnitAI relies on that.
 	this.losAttackRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity,
 		range.min, range.max, players, IID_Resistance,
 		cmpRangeManager.GetEntityFlagMask("normal"), false);
 
 	if (enable)
 		cmpRangeManager.EnableActiveQuery(this.losAttackRangeQuery);
 };
 
 
 //// FSM linkage functions ////
 
 // Setting the next state to the current state will leave/re-enter the top-most substate.
 // Must be called from inside the FSM.
 UnitAI.prototype.SetNextState = function(state)
 {
 	this.UnitFsm.SetNextState(this, state);
 };
 
 // Must be called from inside the FSM.
 UnitAI.prototype.DeferMessage = function(msg)
 {
 	this.UnitFsm.DeferMessage(this, msg);
 };
 
 UnitAI.prototype.GetCurrentState = function()
 {
 	return this.UnitFsm.GetCurrentState(this);
 };
 
 UnitAI.prototype.FsmStateNameChanged = function(state)
 {
 	Engine.PostMessage(this.entity, MT_UnitAIStateChanged, { "to": state });
 };
 
 /**
  * Call when the current order has been completed (or failed).
  * Removes the current order from the queue, and processes the
  * next one (if any). Returns false and defaults to IDLE
  * if there are no remaining orders or if the unit is not
  * inWorld and not garrisoned (thus usually waiting to be destroyed).
  * Must be called from inside the FSM.
  */
 UnitAI.prototype.FinishOrder = function()
 {
 	if (!this.orderQueue.length)
 	{
 		let stack = new Error().stack.trimRight().replace(/^/mg, '  '); // indent each line
 		let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 		let template = cmpTemplateManager.GetCurrentTemplateName(this.entity);
 		error("FinishOrder called for entity " + this.entity + " (" + template + ") when order queue is empty\n" + stack);
 	}
 
 	this.orderQueue.shift();
 	this.order = this.orderQueue[0];
 
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (this.orderQueue.length && (this.isGarrisoned || this.IsFormationController() ||
 	        cmpPosition && cmpPosition.IsInWorld()))
 	{
 		let ret = this.UnitFsm.ProcessMessage(this,
 			{ "type": "Order."+this.order.type, "data": this.order.data }
 		);
 
 		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 
 		return ret;
 	}
 
 	this.orderQueue = [];
 	this.order = undefined;
 
 	// Switch to IDLE as a default state.
 	this.SetNextState("IDLE");
 
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 
 	// Check if there are queued formation orders
 	if (this.IsFormationMember())
 	{
 		this.SetNextState("FORMATIONMEMBER.IDLE");
 		let cmpUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
 		if (cmpUnitAI)
 		{
 			// Inform the formation controller that we finished this task
 			let cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 			cmpFormation.SetWaitingOnController(this.entity);
 			// We don't want to carry out the default order
 			// if there are still queued formation orders left
 			if (cmpUnitAI.GetOrders().length > 1)
 				return true;
 		}
 	}
 	return false;
 };
 
 /**
  * Add an order onto the back of the queue,
  * and execute it if we didn't already have an order.
  */
 UnitAI.prototype.PushOrder = function(type, data)
 {
 	var order = { "type": type, "data": data };
 	this.orderQueue.push(order);
 
 	if (this.orderQueue.length == 1)
 	{
 		this.order = order;
 		this.UnitFsm.ProcessMessage(this,
 			{ "type": "Order."+this.order.type, "data": this.order.data }
 		);
 	}
 
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 };
 
 /**
  * Add an order onto the front of the queue,
  * and execute it immediately.
  */
 UnitAI.prototype.PushOrderFront = function(type, data, ignorePacking = false)
 {
 	var order = { "type": type, "data": data };
 	// If current order is packing/unpacking then add new order after it.
 	if (!ignorePacking && this.order && this.IsPacking())
 	{
 		var packingOrder = this.orderQueue.shift();
 		this.orderQueue.unshift(packingOrder, order);
 	}
 	else
 	{
 		this.orderQueue.unshift(order);
 		this.order = order;
 		this.UnitFsm.ProcessMessage(this,
 			{ "type": "Order."+this.order.type, "data": this.order.data }
 		);
 	}
 
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 
 };
 
 /**
  * Insert an order after the last forced order onto the queue
  * and after the other orders of the same type
  */
 UnitAI.prototype.PushOrderAfterForced = function(type, data)
 {
 	if (!this.order || ((!this.order.data || !this.order.data.force) && this.order.type != type))
 		this.PushOrderFront(type, data);
 	else
 	{
 		for (let i = 1; i < this.orderQueue.length; ++i)
 		{
 			if (this.orderQueue[i].data && this.orderQueue[i].data.force)
 				continue;
 			if (this.orderQueue[i].type == type)
 				continue;
 			this.orderQueue.splice(i, 0, {"type": type, "data": data});
 			Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 			return;
 		}
 		this.PushOrder(type, data);
 	}
 
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 };
 
 /**
  * For a unit that is packing and trying to attack something,
  * either cancel packing or continue with packing, as appropriate.
  * Precondition:  if the unit is packing/unpacking, then orderQueue
  * should have the Attack order at index 0,
  * and the Pack/Unpack order at index 1.
  * This precondition holds because if we are packing while processing "Order.Attack",
  * then we must have come from ReplaceOrder, which guarantees it.
  *
  * @param {boolean} requirePacked - true if the unit needs to be packed to continue attacking,
  *   false if it needs to be unpacked.
  * @return {boolean} true if the unit can attack now, false if it must continue packing (or unpacking) first.
  */
 UnitAI.prototype.EnsureCorrectPackStateForAttack = function(requirePacked)
 {
 	let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	if (!cmpPack ||
 	  !cmpPack.IsPacking() ||
 	  this.orderQueue.length != 2 ||
 	  this.orderQueue[0].type != "Attack" ||
 	  this.orderQueue[1].type != "Pack" &&
 	  this.orderQueue[1].type != "Unpack")
 		return true;
 
 	if (cmpPack.IsPacked() == requirePacked)
 	{
 		// The unit is already in the packed/unpacked state we want.
 		// Delete the packing order.
 		this.orderQueue.splice(1, 1);
 		cmpPack.CancelPack();
 		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 		// Continue with the attack order.
 		return true;
 	}
 	// Move the attack order behind the unpacking order, to continue unpacking.
 	let tmp = this.orderQueue[0];
 	this.orderQueue[0] = this.orderQueue[1];
 	this.orderQueue[1] = tmp;
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 	return false;
 };
 
 UnitAI.prototype.WillMoveFromFoundation = function(target, checkPacking = true)
 {
 	let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 	if (!IsOwnedByAllyOfEntity(this.entity, target) && cmpUnitAI && !cmpUnitAI.IsAnimal() &&
 	    !Engine.QueryInterface(SYSTEM_ENTITY, IID_CeasefireManager).IsCeasefireActive() ||
 	    checkPacking && this.IsPacking() || this.CanPack() || !this.AbleToMove())
 		return false;
 
 	return !this.CheckTargetRangeExplicit(target, g_LeaveFoundationRange, -1);
 };
 
 UnitAI.prototype.ReplaceOrder = function(type, data)
 {
 	// Remember the previous work orders to be able to go back to them later if required
 	if (data && data.force)
 	{
 		if (this.IsFormationController())
 			this.CallMemberFunction("UpdateWorkOrders", [type]);
 		else
 			this.UpdateWorkOrders(type);
 	}
 
-	let garrisonHolder = this.isGarrisoned && type != "Ungarrison" ? this.GetGarrisonHolder() : null;
-
 	// Do not replace packing/unpacking unless it is cancel order.
 	// TODO: maybe a better way of doing this would be to use priority levels
 	if (this.IsPacking() && type != "CancelPack" && type != "CancelUnpack" && type != "Stop")
 	{
 		var order = { "type": type, "data": data };
 		var packingOrder = this.orderQueue.shift();
 		if (type == "Attack")
 		{
 			// The Attack order is able to handle a packing unit, while other orders can't.
 			this.orderQueue = [packingOrder];
 			this.PushOrderFront(type, data, true);
 		}
 		else if (packingOrder.type == "Unpack" && g_OrdersCancelUnpacking.has(type))
 		{
 			// Immediately cancel unpacking before processing an order that demands a packed unit.
 			let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 			cmpPack.CancelPack();
 			this.orderQueue = [];
 			this.PushOrder(type, data);
 		}
 		else
 			this.orderQueue = [packingOrder, order];
 	}
 	else if (this.IsFormationMember())
 	{
 		// Don't replace orders after a LeaveFormation order
 		// (this is needed to support queued no-formation orders).
 		let idx = this.orderQueue.findIndex(o => o.type == "LeaveFormation");
 		if (idx === -1)
 		{
 			this.orderQueue = [];
 			this.order = undefined;
 		}
 		else
 			this.orderQueue.splice(0, idx);
 		this.PushOrderFront(type, data);
 	}
 	else
 	{
 		this.orderQueue = [];
 		this.PushOrder(type, data);
 	}
 
-	if (garrisonHolder)
-		this.PushOrder("Garrison", { "target": garrisonHolder });
-
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 };
 
 UnitAI.prototype.GetOrders = function()
 {
 	return this.orderQueue.slice();
 };
 
 UnitAI.prototype.AddOrders = function(orders)
 {
 	orders.forEach(order => this.PushOrder(order.type, order.data));
 };
 
 UnitAI.prototype.GetOrderData = function()
 {
 	var orders = [];
 	for (let order of this.orderQueue)
 		if (order.data)
 			orders.push(clone(order.data));
 
 	return orders;
 };
 
 UnitAI.prototype.UpdateWorkOrders = function(type)
 {
 	var isWorkType = type => type == "Gather" || type == "Trade" || type == "Repair" || type == "ReturnResource";
 	if (isWorkType(type))
 	{
 		this.workOrders = [];
 		return;
 	}
 
 	if (this.workOrders.length)
 		return;
 
 	if (this.IsFormationMember())
 	{
 		var cmpUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
 		if (cmpUnitAI)
 		{
 			for (var i = 0; i < cmpUnitAI.orderQueue.length; ++i)
 			{
 				if (isWorkType(cmpUnitAI.orderQueue[i].type))
 				{
 					this.workOrders = cmpUnitAI.orderQueue.slice(i);
 					return;
 				}
 			}
 		}
 	}
 
 	// If nothing found, take the unit orders
 	for (var i = 0; i < this.orderQueue.length; ++i)
 	{
 		if (isWorkType(this.orderQueue[i].type))
 		{
 			this.workOrders = this.orderQueue.slice(i);
 			return;
 		}
 	}
 };
 
 UnitAI.prototype.BackToWork = function()
 {
 	if (this.workOrders.length == 0)
 		return false;
 
 	if (this.isGarrisoned)
 	{
 		let cmpGarrisonable = Engine.QueryInterface(this.entity, IID_Garrisonable);
 		if (!cmpGarrisonable || !cmpGarrisonable.UnGarrison(false))
 			return false;
 	}
 
 	this.orderQueue = [];
 
 	this.AddOrders(this.workOrders);
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 
 	if (this.IsFormationMember())
 	{
 		var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 		if (cmpFormation)
 			cmpFormation.RemoveMembers([this.entity]);
 	}
 
 	this.workOrders = [];
 	return true;
 };
 
 UnitAI.prototype.HasWorkOrders = function()
 {
 	return this.workOrders.length > 0;
 };
 
 UnitAI.prototype.GetWorkOrders = function()
 {
 	return this.workOrders;
 };
 
 UnitAI.prototype.SetWorkOrders = function(orders)
 {
 	this.workOrders = orders;
 };
 
 UnitAI.prototype.TimerHandler = function(data, lateness)
 {
 	// Reset the timer
 	if (data.timerRepeat === undefined)
 		this.timer = undefined;
 
 	this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
 };
 
 /**
  * Set up the UnitAI timer to run after 'offset' msecs, and then
  * every 'repeat' msecs until StopTimer is called. A "Timer" message
  * will be sent each time the timer runs.
  */
 UnitAI.prototype.StartTimer = function(offset, repeat)
 {
 	if (this.timer)
 		error("Called StartTimer when there's already an active timer");
 
 	var data = { "timerRepeat": repeat };
 
 	var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	if (repeat === undefined)
 		this.timer = cmpTimer.SetTimeout(this.entity, IID_UnitAI, "TimerHandler", offset, data);
 	else
 		this.timer = cmpTimer.SetInterval(this.entity, IID_UnitAI, "TimerHandler", offset, repeat, data);
 };
 
 /**
  * Stop the current UnitAI timer.
  */
 UnitAI.prototype.StopTimer = function()
 {
 	if (!this.timer)
 		return;
 
 	var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	cmpTimer.CancelTimer(this.timer);
 	this.timer = undefined;
 };
 
 UnitAI.prototype.OnMotionUpdate = function(msg)
 {
 	if (msg.veryObstructed)
 		msg.obstructed = true;
 	this.UnitFsm.ProcessMessage(this, Object.assign({ "type": "MovementUpdate" }, msg));
 };
 
 /**
  * Called directly by cmpFoundation and cmpRepairable to
  * inform builders that repairing has finished.
  * This not done by listening to a global message due to performance.
  */
 UnitAI.prototype.ConstructionFinished = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, { "type": "ConstructionFinished", "data": msg });
 };
 
 UnitAI.prototype.OnGlobalEntityRenamed = function(msg)
 {
 	let changed = false;
 	let currentOrderChanged = false;
 	for (let i = 0; i < this.orderQueue.length; ++i)
 	{
 		let order = this.orderQueue[i];
 		if (order.data && order.data.target && order.data.target == msg.entity)
 		{
 			changed = true;
 			if (i == 0)
 				currentOrderChanged = true;
 			order.data.target = msg.newentity;
 		}
 		if (order.data && order.data.formationTarget && order.data.formationTarget == msg.entity)
 		{
 			changed = true;
 			if (i == 0)
 				currentOrderChanged = true;
 			order.data.formationTarget = msg.newentity;
 		}
 	}
 	if (!changed)
 		return;
 
 	if (currentOrderChanged)
 		this.UnitFsm.ProcessMessage(this, { "type": "OrderTargetRenamed", "data": msg });
 
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 };
 
 UnitAI.prototype.OnAttacked = function(msg)
 {
 	if (msg.fromStatusEffect)
 		return;
 
 	this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
 };
 
 UnitAI.prototype.OnGuardedAttacked = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});
 };
 
 UnitAI.prototype.OnRangeUpdate = function(msg)
 {
 	if (msg.tag == this.losRangeQuery)
 		this.UnitFsm.ProcessMessage(this, { "type": "LosRangeUpdate", "data": msg });
 	else if (msg.tag == this.losHealRangeQuery)
 		this.UnitFsm.ProcessMessage(this, { "type": "LosHealRangeUpdate", "data": msg });
 	else if (msg.tag == this.losAttackRangeQuery)
 		this.UnitFsm.ProcessMessage(this, { "type": "LosAttackRangeUpdate", "data": msg });
 };
 
 UnitAI.prototype.OnPackFinished = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
 };
 
 /**
  * A general function to process messages sent from components.
  * @param {string} type - The type of message to process.
  * @param {Object} msg - Optionally extra data to use.
  */
 UnitAI.prototype.ProcessMessage = function(type, msg)
 {
 	this.UnitFsm.ProcessMessage(this, { "type": type, "data": msg });
 };
 
 //// Helper functions to be called by the FSM ////
 
 UnitAI.prototype.GetWalkSpeed = function()
 {
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (!cmpUnitMotion)
 		return 0;
 	return cmpUnitMotion.GetWalkSpeed();
 };
 
 UnitAI.prototype.GetRunMultiplier = function()
 {
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (!cmpUnitMotion)
 		return 0;
 	return cmpUnitMotion.GetRunMultiplier();
 };
 
 /**
  * Returns true if the target exists and has non-zero hitpoints.
  */
 UnitAI.prototype.TargetIsAlive = function(ent)
 {
 	var cmpFormation = Engine.QueryInterface(ent, IID_Formation);
 	if (cmpFormation)
 		return true;
 
 	var cmpHealth = QueryMiragedInterface(ent, IID_Health);
 	return cmpHealth && cmpHealth.GetHitpoints() != 0;
 };
 
 /**
  * Returns true if the target exists and needs to be killed before
  * beginning to gather resources from it.
  */
 UnitAI.prototype.MustKillGatherTarget = function(ent)
 {
 	var cmpResourceSupply = Engine.QueryInterface(ent, IID_ResourceSupply);
 	if (!cmpResourceSupply)
 		return false;
 
 	if (!cmpResourceSupply.GetKillBeforeGather())
 		return false;
 
 	return this.TargetIsAlive(ent);
 };
 
 /**
  * Returns the position of target or, if there is none,
  * the entity's position, or undefined.
  */
 UnitAI.prototype.TargetPosOrEntPos = function(target)
 {
 	let cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
 	if (cmpTargetPosition && cmpTargetPosition.IsInWorld())
 		return cmpTargetPosition.GetPosition2D();
 
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (cmpPosition && cmpPosition.IsInWorld())
 		return cmpPosition.GetPosition2D();
 
 	return undefined;
 };
 
 
 /**
  * Returns the entity ID of the nearest resource supply where the given
  * filter returns true, or undefined if none can be found.
  * "Nearest" is nearest from @param position.
  * TODO: extend this to exclude resources that already have lots of gatherers.
  */
 UnitAI.prototype.FindNearbyResource = function(position, filter)
 {
 	if (!position)
 		return undefined;
 
 	// We accept resources owned by Gaia or any player
 	let players = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetAllPlayers();
 
 	let range = 64; // TODO: what's a sensible number?
 
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	// Don't account for entity size, we need to match LOS visibility.
 	let nearby = cmpRangeManager.ExecuteQueryAroundPos(position, 0, range, players, IID_ResourceSupply, false);
 	return nearby.find(ent => {
 		if (!this.CanGather(ent) || !this.CheckTargetVisible(ent))
 			return false;
 		let cmpResourceSupply = Engine.QueryInterface(ent, IID_ResourceSupply);
 		let type = cmpResourceSupply.GetType();
 		let amount = cmpResourceSupply.GetCurrentAmount();
 
 		let template = cmpTemplateManager.GetCurrentTemplateName(ent);
 		if (template.indexOf("resource|") != -1)
 			template = template.slice(9);
 
 		return amount > 0 && cmpResourceSupply.IsAvailableTo(this.entity) && filter(ent, type, template);
 	});
 };
 
 /**
  * Returns the entity ID of the nearest resource dropsite that accepts
  * the given type, or undefined if none can be found.
  */
 UnitAI.prototype.FindNearestDropsite = function(genericType)
 {
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership || cmpOwnership.GetOwner() == INVALID_PLAYER)
 		return undefined;
 
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return undefined;
 
 	let pos = cmpPosition.GetPosition2D();
 	let bestDropsite;
 	let bestDist = Infinity;
 	// Maximum distance a point on an obstruction can be from the center of the obstruction.
 	let maxDifference = 40;
 
 	let owner = cmpOwnership.GetOwner();
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	let players = cmpPlayer && cmpPlayer.HasSharedDropsites() ? cmpPlayer.GetMutualAllies() : [owner];
 	let nearestDropsites = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).ExecuteQuery(this.entity, 0, -1, players, IID_ResourceDropsite, false);
 
 	let isShip = Engine.QueryInterface(this.entity, IID_Identity).HasClass("Ship");
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	for (let dropsite of nearestDropsites)
 	{
 		// Ships are unable to reach land dropsites and shouldn't attempt to do so.
 		if (isShip && !Engine.QueryInterface(dropsite, IID_Identity).HasClass("Naval"))
 			continue;
 
 		let cmpResourceDropsite = Engine.QueryInterface(dropsite, IID_ResourceDropsite);
 		if (!cmpResourceDropsite.AcceptsType(genericType) || !this.CheckTargetVisible(dropsite))
 			continue;
 		if (Engine.QueryInterface(dropsite, IID_Ownership).GetOwner() != owner && !cmpResourceDropsite.IsShared())
 			continue;
 
 		// The range manager sorts entities by the distance to their center,
 		// but we want the distance to the point where resources will be dropped off.
 		let dist = cmpObstructionManager.DistanceToPoint(dropsite, pos.x, pos.y);
 		if (dist == -1)
 			continue;
 
 		if (dist < bestDist)
 		{
 			bestDropsite = dropsite;
 			bestDist = dist;
 		}
 		else if (dist > bestDist + maxDifference)
 			break;
 	}
 	return bestDropsite;
 };
 
 /**
  * Returns the entity ID of the nearest building that needs to be constructed.
  * "Nearest" is nearest from @param position.
  */
 UnitAI.prototype.FindNearbyFoundation = function(position)
 {
 	if (!position)
 		return undefined;
 
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership || cmpOwnership.GetOwner() == INVALID_PLAYER)
 		return undefined;
 
 	let players = [cmpOwnership.GetOwner()];
 
 	let range = 64; // TODO: what's a sensible number?
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	// Don't account for entity size, we need to match LOS visibility.
 	let nearby = cmpRangeManager.ExecuteQueryAroundPos(position, 0, range, players, IID_Foundation, false);
 
 	// Skip foundations that are already complete. (This matters since
 	// we process the ConstructionFinished message before the foundation
 	// we're working on has been deleted.)
 	return nearby.find(ent => !Engine.QueryInterface(ent, IID_Foundation).IsFinished());
 };
 
 /**
  * Returns the entity ID of the nearest treasure.
  * "Nearest" is nearest from @param position.
  */
 UnitAI.prototype.FindNearbyTreasure = function(position)
 {
 	if (!position)
 		return undefined;
 
 	let cmpTreasureCollecter = Engine.QueryInterface(this.entity, IID_TreasureCollecter);
 	if (!cmpTreasureCollecter)
 		return undefined;
 
 	let players = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetAllPlayers();
 
 	let range = 64; // TODO: what's a sensible number?
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	// Don't account for entity size, we need to match LOS visibility.
 	let nearby = cmpRangeManager.ExecuteQueryAroundPos(position, 0, range, players, IID_Treasure, false);
 	return nearby.find(ent => cmpTreasureCollecter.CanCollect(ent));
 };
 
 /**
  * Play a sound appropriate to the current entity.
  */
 UnitAI.prototype.PlaySound = function(name)
 {
 	if (this.IsFormationController())
 	{
 		var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 		var member = cmpFormation.GetPrimaryMember();
 		if (member)
 			PlaySound(name, member);
 	}
 	else
 	{
 		PlaySound(name, this.entity);
 	}
 };
 
 /*
  * Set a visualActor animation variant.
  * By changing the animation variant, you can change animations based on unitAI state.
  * If there are no specific variants or the variant doesn't exist in the actor,
  * the actor fallbacks to any existing animation.
  * @param type if present, switch to a specific animation variant.
  */
 UnitAI.prototype.SetAnimationVariant = function(type)
 {
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (!cmpVisual)
 		return;
 
 	cmpVisual.SetVariant("animationVariant", type);
 };
 
 /*
  * Reset the animation variant to default behavior.
  * Default behavior is to pick a resource-carrying variant if resources are being carried.
  * Otherwise pick nothing in particular.
  */
 UnitAI.prototype.SetDefaultAnimationVariant = function()
 {
 	let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 	if (cmpResourceGatherer)
 	{
 		let type = cmpResourceGatherer.GetLastCarriedType();
 		if (type)
 		{
 			let typename = "carry_" + type.generic;
 
 			if (type.specific == "meat")
 				typename = "carry_" + type.specific;
 
 			this.SetAnimationVariant(typename);
 			return;
 		}
 	}
 
 	this.SetAnimationVariant("");
 };
 
 UnitAI.prototype.ResetAnimation = function()
 {
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (!cmpVisual)
 		return;
 
 	cmpVisual.SelectAnimation("idle", false, 1.0);
 };
 
 UnitAI.prototype.SelectAnimation = function(name, once = false, speed = 1.0)
 {
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (!cmpVisual)
 		return;
 
 	cmpVisual.SelectAnimation(name, once, speed);
 };
 
 UnitAI.prototype.SetAnimationSync = function(actiontime, repeattime)
 {
 	var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (!cmpVisual)
 		return;
 
 	cmpVisual.SetAnimationSyncRepeat(repeattime);
 	cmpVisual.SetAnimationSyncOffset(actiontime);
 };
 
 UnitAI.prototype.StopMoving = function()
 {
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (cmpUnitMotion)
 		cmpUnitMotion.StopMoving();
 };
 
 /**
  * Generic dispatcher for other MoveTo functions.
  * @param iid - Interface ID (optional) implementing GetRange
  * @param type - Range type for the interface call
  * @returns whether the move succeeded or failed.
  */
 UnitAI.prototype.MoveTo = function(data, iid, type)
 {
 	if (data.target)
 	{
 		if (data.min || data.max)
 			return this.MoveToTargetRangeExplicit(data.target, data.min || -1, data.max || -1);
 		else if (!iid)
 			return this.MoveToTarget(data.target);
 
 		return this.MoveToTargetRange(data.target, iid, type);
 	}
 	else if (data.min || data.max)
 		return this.MoveToPointRange(data.x, data.z, data.min || -1, data.max || -1);
 
 	return this.MoveToPoint(data.x, data.z);
 };
 
 UnitAI.prototype.MoveToPoint = function(x, z)
 {
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return this.AbleToMove(cmpUnitMotion) && cmpUnitMotion.MoveToPointRange(x, z, 0, 0); // For point goals, allow a max range of 0.
 };
 
 UnitAI.prototype.MoveToPointRange = function(x, z, rangeMin, rangeMax)
 {
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return this.AbleToMove(cmpUnitMotion) && cmpUnitMotion.MoveToPointRange(x, z, rangeMin, rangeMax);
 };
 
 UnitAI.prototype.MoveToTarget = function(target)
 {
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return this.AbleToMove(cmpUnitMotion) && cmpUnitMotion.MoveToTargetRange(target, 0, 1);
 };
 
 UnitAI.prototype.MoveToTargetRange = function(target, iid, type)
 {
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	let range = this.GetRange(iid, type);
 	if (!range)
 		return false;
 
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return this.AbleToMove(cmpUnitMotion) && cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
 };
 
 /**
  * Move unit so we hope the target is in the attack range
  * for melee attacks, this goes straight to the default range checks
  * for ranged attacks, the parabolic range is used
  */
 UnitAI.prototype.MoveToTargetAttackRange = function(target, type)
 {
 	// for formation members, the formation will take care of the range check
 	if (this.IsFormationMember())
 	{
 		let cmpFormationUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
 		if (cmpFormationUnitAI && cmpFormationUnitAI.IsAttackingAsFormation())
 			return false;
 	}
 
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (!this.AbleToMove(cmpUnitMotion))
 		return false;
 
 	let cmpFormation = Engine.QueryInterface(target, IID_Formation);
 	if (cmpFormation)
 		target = cmpFormation.GetClosestMember(this.entity);
 
 	if (type != "Ranged")
 		return this.MoveToTargetRange(target, IID_Attack, type);
 
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	let range = this.GetRange(IID_Attack, type);
 	if (!range)
 		return false;
 
 	let thisCmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (!thisCmpPosition.IsInWorld())
 		return false;
 	let s = thisCmpPosition.GetPosition();
 
 	let targetCmpPosition = Engine.QueryInterface(target, IID_Position);
 	if (!targetCmpPosition || !targetCmpPosition.IsInWorld())
 		return false;
 
 	// Parabolic range compuation is the same as in BuildingAI's FireArrows.
 	let t = targetCmpPosition.GetPosition();
 	// h is positive when I'm higher than the target
 	let h = s.y - t.y + range.elevationBonus;
 
 	let parabolicMaxRange = Math.sqrt(Math.square(range.max) + 2 * range.max * h);
 	// No negative roots please
 	if (h <= -range.max / 2)
 		// return false? Or hope you come close enough?
 		parabolicMaxRange = 0;
 
 	// The parabole changes while walking so be cautious:
 	let guessedMaxRange = parabolicMaxRange > range.max ? (range.max + parabolicMaxRange) / 2 : parabolicMaxRange;
 
 	return cmpUnitMotion && cmpUnitMotion.MoveToTargetRange(target, range.min, guessedMaxRange);
 };
 
 UnitAI.prototype.MoveToTargetRangeExplicit = function(target, min, max)
 {
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return this.AbleToMove(cmpUnitMotion) && cmpUnitMotion.MoveToTargetRange(target, min, max);
 };
 
 /**
  * Move unit so we hope the target is in the attack range of the formation.
  *
  * @param {number} target - The target entity ID to attack.
  * @return {boolean} - Whether the order to move has succeeded.
  */
 UnitAI.prototype.MoveFormationToTargetAttackRange = function(target)
 {
 	let cmpTargetFormation = Engine.QueryInterface(target, IID_Formation);
 	if (cmpTargetFormation)
 		target = cmpTargetFormation.GetClosestMember(this.entity);
 
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	let cmpFormationAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpFormationAttack)
 		return false;
 	let range = cmpFormationAttack.GetRange(target);
 
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return this.AbleToMove(cmpUnitMotion) && cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
 };
 
 UnitAI.prototype.MoveToGarrisonRange = function(target)
 {
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	var cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 		return false;
 	var range = cmpGarrisonHolder.GetLoadingRange();
 
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return this.AbleToMove(cmpUnitMotion) && cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
 };
 
 /**
  * Generic dispatcher for other Check...Range functions.
  * @param iid - Interface ID (optional) implementing GetRange
  * @param type - Range type for the interface call
  */
 UnitAI.prototype.CheckRange = function(data, iid, type)
 {
 	if (data.target)
 	{
 		if (data.min || data.max)
 			return this.CheckTargetRangeExplicit(data.target, data.min || -1, data.max || -1);
 		else if (!iid)
 			return this.CheckTargetRangeExplicit(data.target, 0, 1);
 
 		return this.CheckTargetRange(data.target, iid, type);
 	}
 	else if (data.min || data.max)
 		return this.CheckPointRangeExplicit(data.x, data.z, data.min || -1, data.max || -1);
 
 	return this.CheckPointRangeExplicit(data.x, data.z, 0, 0);
 };
 
 UnitAI.prototype.CheckPointRangeExplicit = function(x, z, min, max)
 {
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	return cmpObstructionManager.IsInPointRange(this.entity, x, z, min, max, false);
 };
 
 UnitAI.prototype.CheckTargetRange = function(target, iid, type)
 {
 	let range = this.GetRange(iid, type);
 	if (!range)
 		return false;
 
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	return cmpObstructionManager.IsInTargetRange(this.entity, target, range.min, range.max, false);
 };
 
 /**
  * Check if the target is inside the attack range
  * For melee attacks, this goes straigt to the regular range calculation
  * For ranged attacks, the parabolic formula is used to accout for bigger ranges
  * when the target is lower, and smaller ranges when the target is higher
  */
 UnitAI.prototype.CheckTargetAttackRange = function(target, type)
 {
 	// for formation members, the formation will take care of the range check
 	if (this.IsFormationMember())
 	{
 		let cmpFormationUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
 		if (cmpFormationUnitAI && cmpFormationUnitAI.IsAttackingAsFormation() &&
 		    cmpFormationUnitAI.order.data.target == target)
 			return true;
 	}
 
 	let cmpFormation = Engine.QueryInterface(target, IID_Formation);
 	if (cmpFormation)
 		target = cmpFormation.GetClosestMember(this.entity);
 
 	if (type != "Ranged")
 		return this.CheckTargetRange(target, IID_Attack, type);
 
 	let targetCmpPosition = Engine.QueryInterface(target, IID_Position);
 	if (!targetCmpPosition || !targetCmpPosition.IsInWorld())
 		return false;
 
 	let range = this.GetRange(IID_Attack, type);
 	if (!range)
 		return false;
 
 	let thisCmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (!thisCmpPosition.IsInWorld())
 		return false;
 
 	let s = thisCmpPosition.GetPosition();
 
 	let t = targetCmpPosition.GetPosition();
 
 	let h = s.y - t.y + range.elevationBonus;
 	let maxRange = Math.sqrt(Math.square(range.max) + 2 * range.max * h);
 
 	if (maxRange < 0)
 		return false;
 
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	return cmpObstructionManager.IsInTargetRange(this.entity, target, range.min, maxRange, false);
 };
 
 UnitAI.prototype.CheckTargetRangeExplicit = function(target, min, max)
 {
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	return cmpObstructionManager.IsInTargetRange(this.entity, target, min, max, false);
 };
 
 /**
  * Check if the target is inside the attack range of the formation.
  *
  * @param {number} target - The target entity ID to attack.
  * @return {boolean} - Whether the entity is within attacking distance.
  */
 UnitAI.prototype.CheckFormationTargetAttackRange = function(target)
 {
 	let cmpTargetFormation = Engine.QueryInterface(target, IID_Formation);
 	if (cmpTargetFormation)
 		target = cmpTargetFormation.GetClosestMember(this.entity);
 
 	let cmpFormationAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpFormationAttack)
 		return false;
 	let range = cmpFormationAttack.GetRange(target);
 
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	return cmpObstructionManager.IsInTargetRange(this.entity, target, range.min, range.max, false);
 };
 
 UnitAI.prototype.CheckGarrisonRange = function(target)
 {
 	let cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 		return false;
 
 	let range = cmpGarrisonHolder.GetLoadingRange();
 	return this.CheckTargetRangeExplicit(target, range.min, range.max);
 };
 
 /**
  * Returns true if the target entity is visible through the FoW/SoD.
  */
 UnitAI.prototype.CheckTargetVisible = function(target)
 {
 	var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership)
 		return false;
 
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (!cmpRangeManager)
 		return false;
 
 	// Entities that are hidden and miraged are considered visible
 	var cmpFogging = Engine.QueryInterface(target, IID_Fogging);
 	if (cmpFogging && cmpFogging.IsMiraged(cmpOwnership.GetOwner()))
 		return true;
 
 	if (cmpRangeManager.GetLosVisibility(target, cmpOwnership.GetOwner()) == "hidden")
 		return false;
 
 	// Either visible directly, or visible in fog
 	return true;
 };
 
 /**
  * Returns true if the given position is currentl visible (not in FoW/SoD).
  */
 UnitAI.prototype.CheckPositionVisible = function(x, z)
 {
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership)
 		return false;
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (!cmpRangeManager)
 		return false;
 
 	return cmpRangeManager.GetLosVisibilityPosition(x, z, cmpOwnership.GetOwner()) == "visible";
 };
 
 /**
  * How close to our goal do we consider it's OK to stop if the goal appears unreachable.
  * Currently 3 terrain tiles as that's relatively close but helps pathfinding.
  */
 UnitAI.prototype.DefaultRelaxedMaxRange = 12;
 
 /**
  * @returns true if the unit is in the relaxed-range from the target.
  */
 UnitAI.prototype.RelaxedMaxRangeCheck = function(data, relaxedRange)
 {
 	if (!data.relaxed)
 		return false;
 
 	let ndata = data;
 	ndata.min = 0;
 	ndata.max = relaxedRange;
 	return this.CheckRange(ndata);
 };
 
 /**
  * Let an entity face its target.
  * @param {number} target - The entity-ID of the target.
  */
 UnitAI.prototype.FaceTowardsTarget = function(target)
 {
 	let cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
 	if (!cmpTargetPosition || !cmpTargetPosition.IsInWorld())
 		return;
 
 	let targetPosition = cmpTargetPosition.GetPosition2D();
 
 	// Use cmpUnitMotion for units that support that, otherwise try cmpPosition (e.g. turrets)
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (cmpUnitMotion)
 	{
 		cmpUnitMotion.FaceTowardsPoint(targetPosition.x, targetPosition.y);
 		return;
 	}
 
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (cmpPosition && cmpPosition.IsInWorld())
 		cmpPosition.TurnTo(cmpPosition.GetPosition2D().angleTo(targetPosition));
 };
 
 UnitAI.prototype.CheckTargetDistanceFromHeldPosition = function(target, iid, type)
 {
 	let range = this.GetRange(iid, type);
 	if (!range)
 		return false;
 
 	let cmpPosition = Engine.QueryInterface(target, IID_Position);
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return false;
 
 	let cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 	if (!cmpVision)
 		return false;
 	let halfvision = cmpVision.GetRange() / 2;
 
 	let pos = cmpPosition.GetPosition();
 	let heldPosition = this.heldPosition;
 	if (heldPosition === undefined)
 		heldPosition = { "x": pos.x, "z": pos.z };
 
 	return Math.euclidDistance2D(pos.x, pos.z, heldPosition.x, heldPosition.z) < halfvision + range.max;
 };
 
 UnitAI.prototype.CheckTargetIsInVisionRange = function(target)
 {
 	let cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 	if (!cmpVision)
 		return false;
 
 	let range = cmpVision.GetRange();
 	let distance = PositionHelper.DistanceBetweenEntities(this.entity, target);
 
 	return distance < range;
 };
 
 UnitAI.prototype.GetBestAttackAgainst = function(target, allowCapture)
 {
 	var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpAttack)
 		return undefined;
 	return cmpAttack.GetBestAttackAgainst(target, allowCapture);
 };
 
 /**
  * Try to find one of the given entities which can be attacked,
  * and start attacking it.
  * Returns true if it found something to attack.
  */
 UnitAI.prototype.AttackVisibleEntity = function(ents)
 {
 	var target = ents.find(target => this.CanAttack(target));
 	if (!target)
 		return false;
 
 	this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": true });
 	return true;
 };
 
 /**
  * Try to find one of the given entities which can be attacked
  * and which is close to the hold position, and start attacking it.
  * Returns true if it found something to attack.
  */
 UnitAI.prototype.AttackEntityInZone = function(ents)
 {
 	var target = ents.find(target =>
 		this.CanAttack(target)
 		&& this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
 		&& (this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
 	);
 	if (!target)
 		return false;
 
 	this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": true });
 	return true;
 };
 
 /**
  * Try to respond appropriately given our current stance,
  * given a list of entities that match our stance's target criteria.
  * Returns true if it responded.
  */
 UnitAI.prototype.RespondToTargetedEntities = function(ents)
 {
 	if (!ents.length)
 		return false;
 
 	if (this.GetStance().respondChase)
 		return this.AttackVisibleEntity(ents);
 
 	if (this.GetStance().respondStandGround)
 		return this.AttackVisibleEntity(ents);
 
 	if (this.GetStance().respondHoldGround)
 		return this.AttackEntityInZone(ents);
 
 	if (this.GetStance().respondFlee)
 	{
 		if (this.order && this.order.type == "Flee")
 			this.orderQueue.shift();
 		this.PushOrderFront("Flee", { "target": ents[0], "force": false });
 		return true;
 	}
 
 	return false;
 };
 
 /**
  * @param {number} ents - An array of the IDs of the spotted entities.
  * @return {boolean} - Whether we responded.
  */
 UnitAI.prototype.RespondToSightedEntities = function(ents)
 {
 	if (!ents || !ents.length)
 		return false;
 
 	if (this.GetStance().respondFleeOnSight)
 	{
 		this.Flee(ents[0], false);
 		return true;
 	}
 
 	return false;
 };
 
 /**
  * Try to respond to healable entities.
  * Returns true if it responded.
  */
 UnitAI.prototype.RespondToHealableEntities = function(ents)
 {
 	let ent = ents.find(ent => this.CanHeal(ent));
 	if (!ent)
 		return false;
 
 	this.PushOrderFront("Heal", { "target": ent, "force": false });
 	return true;
 };
 
 /**
  * Returns true if we should stop following the target entity.
  */
 UnitAI.prototype.ShouldAbandonChase = function(target, force, iid, type)
 {
 	if (!this.CheckTargetVisible(target))
 		return true;
 
 	// Forced orders shouldn't be interrupted.
 	if (force)
 		return false;
 
 	// If we are guarding/escorting, don't abandon as long as the guarded unit is in target range of the attacker
 	if (this.isGuardOf)
 	{
 		let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 		let cmpAttack = Engine.QueryInterface(target, IID_Attack);
 		if (cmpUnitAI && cmpAttack &&
 		    cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
 				return false;
 	}
 
 	if (this.GetStance().respondHoldGround)
 		if (!this.CheckTargetDistanceFromHeldPosition(target, iid, type))
 			return true;
 
 	// Stop if it's left our vision range, unless we're especially persistent.
 	if (!this.GetStance().respondChaseBeyondVision)
 		if (!this.CheckTargetIsInVisionRange(target))
 			return true;
 
 	return false;
 };
 
 /*
  * Returns whether we should chase the targeted entity,
  * given our current stance.
  */
 UnitAI.prototype.ShouldChaseTargetedEntity = function(target, force)
 {
 	if (!this.AbleToMove())
 		return false;
 
 	if (this.GetStance().respondChase)
 		return true;
 
 	// If we are guarding/escorting, chase at least as long as the guarded unit is in target range of the attacker
 	if (this.isGuardOf)
 	{
 		let cmpUnitAI =  Engine.QueryInterface(target, IID_UnitAI);
 		let cmpAttack = Engine.QueryInterface(target, IID_Attack);
 		if (cmpUnitAI && cmpAttack &&
 		    cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
 			return true;
 	}
 
 	return force;
 };
 
 //// External interface functions ////
 
 /**
  * Order a unit to leave the formation it is in.
  * Used to handle queued no-formation orders for units in formation.
  */
 UnitAI.prototype.LeaveFormation = function(queued = true)
 {
 	// If queued, add the order even if we're not in formation,
 	// maybe we will be later.
 	if (!queued && !this.IsFormationMember())
 		return;
 
 	if (queued)
 		this.AddOrder("LeaveFormation", { "force": true }, queued);
 	else
 		this.PushOrderFront("LeaveFormation", { "force": true });
 };
 
 UnitAI.prototype.SetFormationController = function(ent)
 {
 	this.formationController = ent;
 
 	// Set obstruction group, so we can walk through members
 	// of our own formation (or ourself if not in formation)
 	var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
 	if (cmpObstruction)
 	{
 		if (ent == INVALID_ENTITY)
 			cmpObstruction.SetControlGroup(this.entity);
 		else
 			cmpObstruction.SetControlGroup(ent);
 	}
 
 	// If we were removed from a formation, let the FSM switch back to INDIVIDUAL
 	if (ent == INVALID_ENTITY)
 		this.UnitFsm.ProcessMessage(this, { "type": "FormationLeave" });
 };
 
 UnitAI.prototype.GetFormationController = function()
 {
 	return this.formationController;
 };
 
 UnitAI.prototype.GetFormationTemplate = function()
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).GetCurrentTemplateName(this.formationController) || NULL_FORMATION;
 };
 
 UnitAI.prototype.MoveIntoFormation = function(cmd)
 {
 	var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 	if (!cmpFormation)
 		return;
 
 	var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return;
 
 	var pos = cmpPosition.GetPosition();
 	this.PushOrderFront("MoveIntoFormation", { "x": pos.x, "z": pos.z, "force": true });
 };
 
 UnitAI.prototype.GetTargetPositions = function()
 {
 	var targetPositions = [];
 	for (var i = 0; i < this.orderQueue.length; ++i)
 	{
 		var order = this.orderQueue[i];
 		switch (order.type)
 		{
 		case "Walk":
 		case "WalkAndFight":
 		case "WalkToPointRange":
 		case "MoveIntoFormation":
 		case "GatherNearPosition":
 		case "Patrol":
 			targetPositions.push(new Vector2D(order.data.x, order.data.z));
 			break; // and continue the loop
 
 		case "WalkToTarget":
 		case "WalkToTargetRange": // This doesn't move to the target (just into range), but a later order will.
 		case "Guard":
 		case "Flee":
 		case "LeaveFoundation":
 		case "Attack":
 		case "Heal":
 		case "Gather":
 		case "ReturnResource":
 		case "Repair":
 		case "Garrison":
 			var cmpTargetPosition = Engine.QueryInterface(order.data.target, IID_Position);
 			if (!cmpTargetPosition || !cmpTargetPosition.IsInWorld())
 				return targetPositions;
 			targetPositions.push(cmpTargetPosition.GetPosition2D());
 			return targetPositions;
 
 		case "Stop":
 			return [];
 
 		default:
 			error("GetTargetPositions: Unrecognised order type '"+order.type+"'");
 			return [];
 		}
 	}
 	return targetPositions;
 };
 
 /**
  * Returns the estimated distance that this unit will travel before either
  * finishing all of its orders, or reaching a non-walk target (attack, gather, etc).
  * Intended for Formation to switch to column layout on long walks.
  */
 UnitAI.prototype.ComputeWalkingDistance = function()
 {
 	var distance = 0;
 
 	var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return 0;
 
 	// Keep track of the position at the start of each order
 	var pos = cmpPosition.GetPosition2D();
 	var targetPositions = this.GetTargetPositions();
 	for (var i = 0; i < targetPositions.length; ++i)
 	{
 		distance += pos.distanceTo(targetPositions[i]);
 
 		// Remember this as the start position for the next order
 		pos = targetPositions[i];
 	}
 
 	return distance;
 };
 
 UnitAI.prototype.AddOrder = function(type, data, queued, pushFront)
 {
 	if (this.expectedRoute)
 		this.expectedRoute = undefined;
 
 	if (pushFront)
 		this.PushOrderFront(type, data);
 	else if (queued)
 		this.PushOrder(type, data);
 	else
 	{
 		// May happen if an order arrives on the same turn the unit is garrisoned
-		// in that case, just forget the order as this will lead to an infinite loop
+		// in that case, just forget the order as this will lead to an infinite loop.
+		// ToDo: Fix that by checking for the ability to move on orders that need that.
 		if (this.isGarrisoned && !this.IsTurret() && type != "Ungarrison")
 			return;
 		this.ReplaceOrder(type, data);
 	}
 };
 
 /**
  * Adds guard/escort order to the queue, forced by the player.
  */
 UnitAI.prototype.Guard = function(target, queued, pushFront)
 {
 	if (!this.CanGuard())
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	if (target === this.entity)
 		return;
 
 	if (this.isGuardOf)
 	{
 		if (this.isGuardOf == target && this.order && this.order.type == "Guard")
 			return;
 		else
 			this.RemoveGuard();
 	}
 
 	this.AddOrder("Guard", { "target": target, "force": false }, queued, pushFront);
 };
 
 /**
  * @return {boolean} - Whether it makes sense to guard the given entity.
  */
 UnitAI.prototype.ShouldGuard = function(target)
 {
 	return this.TargetIsAlive(target) ||
 		Engine.QueryInterface(target, IID_Capturable) ||
 		Engine.QueryInterface(target, IID_StatusEffectsReceiver);
 };
 
 UnitAI.prototype.AddGuard = function(target)
 {
 	if (!this.CanGuard())
 		return false;
 
 	var cmpGuard = Engine.QueryInterface(target, IID_Guard);
 	if (!cmpGuard)
 		return false;
 
 	this.isGuardOf = target;
 	this.guardRange = cmpGuard.GetRange(this.entity);
 	cmpGuard.AddGuard(this.entity);
 	return true;
 };
 
 UnitAI.prototype.RemoveGuard = function()
 {
 	if (!this.isGuardOf)
 		return;
 
 	let cmpGuard = Engine.QueryInterface(this.isGuardOf, IID_Guard);
 	if (cmpGuard)
 		cmpGuard.RemoveGuard(this.entity);
 	this.guardRange = undefined;
 	this.isGuardOf = undefined;
 
 	if (!this.order)
 		return;
 
 	if (this.order.type == "Guard")
 		this.UnitFsm.ProcessMessage(this, { "type": "RemoveGuard" });
 	else
 		for (let i = 1; i < this.orderQueue.length; ++i)
 			if (this.orderQueue[i].type == "Guard")
 				this.orderQueue.splice(i, 1);
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 };
 
 UnitAI.prototype.IsGuardOf = function()
 {
 	return this.isGuardOf;
 };
 
 UnitAI.prototype.SetGuardOf = function(entity)
 {
 	// entity may be undefined
 	this.isGuardOf = entity;
 };
 
 UnitAI.prototype.CanGuard = function()
 {
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	return this.template.CanGuard == "true";
 };
 
 UnitAI.prototype.CanPatrol = function()
 {
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	return this.IsFormationController() || this.template.CanPatrol == "true";
 };
 
 /**
  * Adds walk order to queue, forced by the player.
  */
 UnitAI.prototype.Walk = function(x, z, queued, pushFront)
 {
 	if (!pushFront && this.expectedRoute && queued)
 		this.expectedRoute.push({ "x": x, "z": z });
 	else
 		this.AddOrder("Walk", { "x": x, "z": z, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds walk to point range order to queue, forced by the player.
  */
 UnitAI.prototype.WalkToPointRange = function(x, z, min, max, queued, pushFront)
 {
 	this.AddOrder("Walk", { "x": x, "z": z, "min": min, "max": max, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds stop order to queue, forced by the player.
  */
 UnitAI.prototype.Stop = function(queued, pushFront)
 {
 	this.AddOrder("Stop", { "force": true }, queued, pushFront);
 };
 
 /**
  * Adds walk-to-target order to queue, this only occurs in response
  * to a player order, and so is forced.
  */
 UnitAI.prototype.WalkToTarget = function(target, queued, pushFront)
 {
 	this.AddOrder("WalkToTarget", { "target": target, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds walk-and-fight order to queue, this only occurs in response
  * to a player order, and so is forced.
  * If targetClasses is given, only entities matching the targetClasses can be attacked.
  */
 UnitAI.prototype.WalkAndFight = function(x, z, targetClasses, allowCapture = true, queued = false, pushFront = false)
 {
 	this.AddOrder("WalkAndFight", { "x": x, "z": z, "targetClasses": targetClasses, "allowCapture": allowCapture, "force": true }, queued, pushFront);
 };
 
 UnitAI.prototype.Patrol = function(x, z, targetClasses, allowCapture = true, queued = false, pushFront = false)
 {
 	if (!this.CanPatrol())
 	{
 		this.Walk(x, z, queued);
 		return;
 	}
 
 	this.AddOrder("Patrol", { "x": x, "z": z, "targetClasses": targetClasses, "allowCapture": allowCapture, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds leave foundation order to queue, treated as forced.
  */
 UnitAI.prototype.LeaveFoundation = function(target)
 {
 	// If we're already being told to leave a foundation, then
 	// ignore this new request so we don't end up being too indecisive
 	// to ever actually move anywhere.
 	if (this.order && (this.order.type == "LeaveFoundation" || (this.order.type == "Flee" && this.order.data.target == target)))
 		return;
 
 	if (this.orderQueue.length && this.orderQueue[0].type == "Unpack" && this.WillMoveFromFoundation(target, false))
 	{
 		let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 		if (cmpPack)
 			cmpPack.CancelPack();
 	}
 
 	if (this.IsPacking())
 		return;
 
 	this.PushOrderFront("LeaveFoundation", { "target": target, "force": true });
 };
 
 /**
  * Adds attack order to the queue, forced by the player.
  */
 UnitAI.prototype.Attack = function(target, allowCapture = true, queued = false, pushFront = false)
 {
 	if (!this.CanAttack(target))
 	{
 		// We don't want to let healers walk to the target unit so they can be easily killed.
 		// Instead we just let them get into healing range.
 		if (this.IsHealer())
 			this.MoveToTargetRange(target, IID_Heal);
 		else
 			this.WalkToTarget(target, queued, pushFront);
 		return;
 	}
 
 	let order = {
 		"target": target,
 		"force": true,
 		"allowCapture": allowCapture,
 	};
 
 	this.RememberTargetPosition(order);
 
 	if (this.order && this.order.type == "Attack" &&
 		this.order.data &&
 		this.order.data.target === order.target &&
 		this.order.data.allowCapture === order.allowCapture)
 	{
 		this.order.data.lastPos = order.lastPos;
 		this.order.data.force = order.force;
 		return;
 	}
 
 	this.AddOrder("Attack", order, queued, pushFront);
 };
 
 /**
  * Adds garrison order to the queue, forced by the player.
  */
 UnitAI.prototype.Garrison = function(target, queued, pushFront)
 {
 	if (target == this.entity)
 		return;
 	if (!this.CanGarrison(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 	this.AddOrder("Garrison", { "target": target, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds ungarrison order to the queue.
  */
 UnitAI.prototype.Ungarrison = function()
 {
 	if (!this.isGarrisoned)
 		return;
 	this.AddOrder("Ungarrison", null, false);
 };
 
 /**
- * Adds a garrison order for units that are already garrisoned in the garrison holder.
- */
-UnitAI.prototype.Autogarrison = function(target)
-{
-	this.PushOrderFront("Garrison", { "target": target });
-};
-
-/**
  * Adds gather order to the queue, forced by the player
  * until the target is reached
  */
 UnitAI.prototype.Gather = function(target, queued, pushFront)
 {
 	this.PerformGather(target, queued, true, pushFront);
 };
 
 /**
  * Internal function to abstract the force parameter.
  */
 UnitAI.prototype.PerformGather = function(target, queued, force, pushFront = false)
 {
 	if (!this.CanGather(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	// Save the resource type now, so if the resource gets destroyed
 	// before we process the order then we still know what resource
 	// type to look for more of
 	var type;
 	var cmpResourceSupply = QueryMiragedInterface(target, IID_ResourceSupply);
 	if (cmpResourceSupply)
 		type = cmpResourceSupply.GetType();
 	else
 		error("CanGather allowed gathering from invalid entity");
 
 	// Also save the target entity's template, so that if it's an animal,
 	// we won't go from hunting slow safe animals to dangerous fast ones
 	var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	var template = cmpTemplateManager.GetCurrentTemplateName(target);
 	if (template.indexOf("resource|") != -1)
 		template = template.slice(9);
 
 	let order = {
 		"target": target,
 		"type": type,
 		"template": template,
 		"force": force,
 	};
 
 	this.RememberTargetPosition(order);
 	order.initPos = order.lastPos;
 
 	if (this.order &&
 		(this.order.type == "Gather" || this.order.type == "Attack") &&
 		this.order.data &&
 		this.order.data.target === order.target)
 	{
 		this.order.data.lastPos = order.lastPos;
 		this.order.data.force = order.force;
 		return;
 	}
 
 	this.AddOrder("Gather", order, queued, pushFront);
 };
 
 /**
  * Adds gather-near-position order to the queue, not forced, so it can be
  * interrupted by attacks.
  */
 UnitAI.prototype.GatherNearPosition = function(x, z, type, template, queued, pushFront)
 {
 	if (template.indexOf("resource|") != -1)
 		template = template.slice(9);
 
 	if (this.IsFormationController() || Engine.QueryInterface(this.entity, IID_ResourceGatherer))
 		this.AddOrder("GatherNearPosition", { "type": type, "template": template, "x": x, "z": z, "force": false }, queued, pushFront);
 	else
 		this.AddOrder("Walk", { "x": x, "z": z, "force": false }, queued, pushFront);
 };
 
 /**
  * Adds heal order to the queue, forced by the player.
  */
 UnitAI.prototype.Heal = function(target, queued, pushFront)
 {
 	if (!this.CanHeal(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	if (this.order && this.order.type == "Heal" &&
 		this.order.data &&
 		this.order.data.target === target)
 	{
 		this.order.data.force = true;
 		return;
 	}
 
 	this.AddOrder("Heal", { "target": target, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds return resource order to the queue, forced by the player.
  */
 UnitAI.prototype.ReturnResource = function(target, queued, pushFront)
 {
 	if (!this.CanReturnResource(target, true))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	this.AddOrder("ReturnResource", { "target": target, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds order to collect a treasure to queue, forced by the player.
  */
 UnitAI.prototype.CollectTreasure = function(target, autocontinue, queued)
 {
 	this.AddOrder("CollectTreasure", {
 		"target": target,
 		"autocontinue": autocontinue,
 		"force": true
 	}, queued);
 };
 
 /**
  * Adds order to collect a treasure to queue, forced by the player.
  */
 UnitAI.prototype.CollectTreasureNearPosition = function(posX, posZ, autocontinue, queued)
 {
 	this.AddOrder("CollectTreasureNearPosition", {
 		"x": posX,
 		"z": posZ,
 		"target": target,
 		"autocontinue": autocontinue,
 		"force": false
 	}, queued);
 };
 
 UnitAI.prototype.CancelSetupTradeRoute = function(target)
 {
 	let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 	if (!cmpTrader)
 		return;
 	cmpTrader.RemoveTargetMarket(target);
 
 	if (this.IsFormationController())
 		this.CallMemberFunction("CancelSetupTradeRoute", [target]);
 };
 
 /**
  * Adds trade order to the queue. Either walk to the first market, or
  * start a new route. Not forced, so it can be interrupted by attacks.
  * The possible route may be given directly as a SetupTradeRoute argument
  * if coming from a RallyPoint, or through this.expectedRoute if a user command.
  */
 UnitAI.prototype.SetupTradeRoute = function(target, source, route, queued, pushFront)
 {
 	if (!this.CanTrade(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	// AI has currently no access to BackToWork
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	if (cmpPlayer && cmpPlayer.IsAI() && !this.IsFormationController() &&
 	    this.workOrders.length && this.workOrders[0].type == "Trade")
 	{
 		let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 		if (cmpTrader.HasBothMarkets() &&
 		   (cmpTrader.GetFirstMarket() == target && cmpTrader.GetSecondMarket() == source ||
 		    cmpTrader.GetFirstMarket() == source && cmpTrader.GetSecondMarket() == target))
 		{
 			this.BackToWork();
 			return;
 		}
 	}
 
 	var marketsChanged = this.SetTargetMarket(target, source);
 	if (!marketsChanged)
 		return;
 
 	var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 	if (cmpTrader.HasBothMarkets())
 	{
 		let data = {
 			"target": cmpTrader.GetFirstMarket(),
 			"route": route,
 			"force": false
 		};
 
 		if (this.expectedRoute)
 		{
 			if (!route && this.expectedRoute.length)
 				data.route = this.expectedRoute.slice();
 			this.expectedRoute = undefined;
 		}
 
 		if (this.IsFormationController())
 		{
 			this.CallMemberFunction("AddOrder", ["Trade", data, queued]);
 			let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 			if (cmpFormation)
 				cmpFormation.Disband();
 		}
 		else
 			this.AddOrder("Trade", data, queued, pushFront);
 	}
 	else
 	{
 		if (this.IsFormationController())
 			this.CallMemberFunction("WalkToTarget", [cmpTrader.GetFirstMarket(), queued, pushFront]);
 		else
 			this.WalkToTarget(cmpTrader.GetFirstMarket(), queued, pushFront);
 		this.expectedRoute = [];
 	}
 };
 
 UnitAI.prototype.SetTargetMarket = function(target, source)
 {
 	var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 	if (!cmpTrader)
 		return false;
 	var marketsChanged = cmpTrader.SetTargetMarket(target, source);
 
 	if (this.IsFormationController())
 		this.CallMemberFunction("SetTargetMarket", [target, source]);
 
 	return marketsChanged;
 };
 
 UnitAI.prototype.SwitchMarketOrder = function(oldMarket, newMarket)
 {
 	if (this.order && this.order.data && this.order.data.target && this.order.data.target == oldMarket)
 		this.order.data.target = newMarket;
 };
 
 UnitAI.prototype.MoveToMarket = function(targetMarket)
 {
 	let nextTarget;
 	if (this.waypoints && this.waypoints.length >= 1)
 		nextTarget = this.waypoints.pop();
 	else
 		nextTarget = { "target": targetMarket };
 	this.order.data.nextTarget = nextTarget;
 	return this.MoveTo(this.order.data.nextTarget, IID_Trader);
 };
 
 UnitAI.prototype.PerformTradeAndMoveToNextMarket = function(currentMarket)
 {
 	if (!this.CanTrade(currentMarket))
 	{
 		this.StopTrading();
 		return;
 	}
 
 	if (!this.CheckTargetRange(currentMarket, IID_Trader))
 	{
 		if (!this.MoveToMarket(currentMarket))	// If the current market is not reached try again
 			this.StopTrading();
 		return;
 	}
 
 	let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 	let nextMarket = cmpTrader.PerformTrade(currentMarket);
 	let amount = cmpTrader.GetGoods().amount;
 	if (!nextMarket || !amount || !amount.traderGain)
 	{
 		this.StopTrading();
 		return;
 	}
 
 	this.order.data.target = nextMarket;
 
 	if (this.order.data.route && this.order.data.route.length)
 	{
 		this.waypoints = this.order.data.route.slice();
 		if (this.order.data.target == cmpTrader.GetSecondMarket())
 			this.waypoints.reverse();
 	}
 
 	this.SetNextState("APPROACHINGMARKET");
 };
 
 UnitAI.prototype.MarketRemoved = function(market)
 {
 	if (this.order && this.order.data && this.order.data.target && this.order.data.target == market)
 		this.UnitFsm.ProcessMessage(this, { "type": "TradingCanceled", "market": market });
 };
 
 UnitAI.prototype.StopTrading = function()
 {
 	this.FinishOrder();
 	var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 	cmpTrader.StopTrading();
 };
 
 /**
  * Adds repair/build order to the queue, forced by the player
  * until the target is reached
  */
 UnitAI.prototype.Repair = function(target, autocontinue, queued, pushFront)
 {
 	if (!this.CanRepair(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	if (this.order && this.order.type == "Repair" &&
 		this.order.data &&
 		this.order.data.target === target &&
 		this.order.data.autocontinue === autocontinue)
 	{
 		this.order.data.force = true;
 		return;
 	}
 
 	this.AddOrder("Repair", { "target": target, "autocontinue": autocontinue, "force": true }, queued, pushFront);
 };
 
 /**
  * Adds flee order to the queue, not forced, so it can be
  * interrupted by attacks.
  */
 UnitAI.prototype.Flee = function(target, queued, pushFront)
 {
 	this.AddOrder("Flee", { "target": target, "force": false }, queued, pushFront);
 };
 
 UnitAI.prototype.Cheer = function()
 {
 	this.PushOrderFront("Cheer", { "force": false });
 };
 
 UnitAI.prototype.Pack = function(queued, pushFront)
 {
 	if (this.CanPack())
 		this.AddOrder("Pack", { "force": true }, queued, pushFront);
 };
 
 UnitAI.prototype.Unpack = function(queued, pushFront)
 {
 	if (this.CanUnpack())
 		this.AddOrder("Unpack", { "force": true }, queued, pushFront);
 };
 
 UnitAI.prototype.CancelPack = function(queued, pushFront)
 {
 	var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	if (cmpPack && cmpPack.IsPacking() && !cmpPack.IsPacked())
 		this.AddOrder("CancelPack", { "force": true }, queued, pushFront);
 };
 
 UnitAI.prototype.CancelUnpack = function(queued, pushFront)
 {
 	var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	if (cmpPack && cmpPack.IsPacking() && cmpPack.IsPacked())
 		this.AddOrder("CancelUnpack", { "force": true }, queued, pushFront);
 };
 
 UnitAI.prototype.SetStance = function(stance)
 {
 	if (g_Stances[stance])
 	{
 		this.stance = stance;
 		Engine.PostMessage(this.entity, MT_UnitStanceChanged, { "to": this.stance });
 	}
 	else
 		error("UnitAI: Setting to invalid stance '"+stance+"'");
 };
 
 UnitAI.prototype.SwitchToStance = function(stance)
 {
 	var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return;
 	var pos = cmpPosition.GetPosition();
 	this.SetHeldPosition(pos.x, pos.z);
 
 	this.SetStance(stance);
 
 	// Reset the range queries, since the range depends on stance.
 	this.SetupRangeQueries();
 };
 
 UnitAI.prototype.SetTurretStance = function()
 {
 	this.previousStance = undefined;
 	if (this.GetStance().respondStandGround)
 		return;
 	for (let stance in g_Stances)
 	{
 		if (!g_Stances[stance].respondStandGround)
 			continue;
 		this.previousStance = this.GetStanceName();
 		this.SwitchToStance(stance);
 		return;
 	}
 };
 
 UnitAI.prototype.ResetTurretStance = function()
 {
 	if (!this.previousStance)
 		return;
 	this.SwitchToStance(this.previousStance);
 	this.previousStance = undefined;
 };
 
 /**
  * Resets the losRangeQuery.
  * @return {boolean} - Whether there are targets in range that we ought to react upon.
  */
 UnitAI.prototype.FindSightedEnemies = function()
 {
 	if (!this.losRangeQuery)
 		return false;
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return this.RespondToSightedEntities(cmpRangeManager.ResetActiveQuery(this.losRangeQuery));
 };
 
 /**
  * Resets losHealRangeQuery, and if there are some targets in range that we can heal
  * then we start healing and this returns true; otherwise, returns false.
  */
 UnitAI.prototype.FindNewHealTargets = function()
 {
 	if (!this.losHealRangeQuery)
 		return false;
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return this.RespondToHealableEntities(cmpRangeManager.ResetActiveQuery(this.losHealRangeQuery));
 };
 
 /**
  * Resets losAttackRangeQuery, and if there are some targets in range that we can
  * attack then we start attacking and this returns true; otherwise, returns false.
  */
 UnitAI.prototype.FindNewTargets = function()
 {
 	if (!this.losAttackRangeQuery)
 		return false;
 
 	if (!this.GetStance().targetVisibleEnemies)
 		return false;
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return this.AttackEntitiesByPreference(cmpRangeManager.ResetActiveQuery(this.losAttackRangeQuery));
 };
 
 UnitAI.prototype.FindWalkAndFightTargets = function()
 {
 	if (this.IsFormationController())
 	{
 		var cmpUnitAI;
 		var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 		for (var ent of cmpFormation.members)
 		{
 			if (!(cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI)))
 				continue;
 			var targets = cmpUnitAI.GetTargetsFromUnit();
 			for (var targ of targets)
 			{
 				if (!cmpUnitAI.CanAttack(targ))
 					continue;
 				if (this.order.data.targetClasses)
 				{
 					var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
 					var targetClasses = this.order.data.targetClasses;
 					if (targetClasses.attack && cmpIdentity
 						&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
 						continue;
 					if (targetClasses.avoid && cmpIdentity
 						&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
 						continue;
 					// Only used by the AIs to prevent some choices of targets
 					if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
 						continue;
 				}
 				this.PushOrderFront("Attack", { "target": targ, "force": false, "allowCapture": this.order.data.allowCapture });
 				return true;
 			}
 		}
 		return false;
 	}
 
 	var targets = this.GetTargetsFromUnit();
 	for (var targ of targets)
 	{
 		if (!this.CanAttack(targ))
 			continue;
 		if (this.order.data.targetClasses)
 		{
 			var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
 			var targetClasses = this.order.data.targetClasses;
 			if (cmpIdentity && targetClasses.attack
 				&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
 				continue;
 			if (cmpIdentity && targetClasses.avoid
 				&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
 				continue;
 			// Only used by the AIs to prevent some choices of targets
 			if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
 				continue;
 		}
 		this.PushOrderFront("Attack", { "target": targ, "force": false, "allowCapture": this.order.data.allowCapture });
 		return true;
 	}
 
 	// healers on a walk-and-fight order should heal injured units
 	if (this.IsHealer())
 		return this.FindNewHealTargets();
 
 	return false;
 };
 
 UnitAI.prototype.GetTargetsFromUnit = function()
 {
 	if (!this.losAttackRangeQuery)
 		return [];
 
 	if (!this.GetStance().targetVisibleEnemies)
 		return [];
 
 	let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpAttack)
 		return [];
 
 	let attackfilter = function(e) {
 		if (!cmpAttack.CanAttack(e))
 			return false;
 
 		let cmpOwnership = Engine.QueryInterface(e, IID_Ownership);
 		if (cmpOwnership && cmpOwnership.GetOwner() > 0)
 			return true;
 
 		let cmpUnitAI = Engine.QueryInterface(e, IID_UnitAI);
 		return cmpUnitAI && (!cmpUnitAI.IsAnimal() || cmpUnitAI.IsDangerousAnimal());
 	};
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let entities = cmpRangeManager.ResetActiveQuery(this.losAttackRangeQuery);
 	let targets = entities.filter(attackfilter).sort(function(a, b) {
 		return cmpAttack.CompareEntitiesByPreference(a, b);
 	});
 
 	return targets;
 };
 
 UnitAI.prototype.GetQueryRange = function(iid)
 {
 	let ret = { "min": 0, "max": 0 };
 
 	let cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 	if (!cmpVision)
 		return ret;
 	let visionRange = cmpVision.GetRange();
 
 	if (iid === IID_Vision)
 	{
 		ret.max = visionRange;
 		return ret;
 	}
 
 	if (this.GetStance().respondStandGround)
 	{
 		let range = this.GetRange(iid);
 		if (!range)
 			return ret;
 		ret.min = range.min;
 		ret.max = Math.min(range.max, visionRange);
 	}
 	else if (this.GetStance().respondChase)
 		ret.max = visionRange;
 	else if (this.GetStance().respondHoldGround)
 	{
 		let range = this.GetRange(iid);
 		if (!range)
 			return ret;
 		ret.max = Math.min(range.max + visionRange / 2, visionRange);
 	}
 	// We probably have stance 'passive' and we wouldn't have a range,
 	// but as it is the default for healers we need to set it to something sane.
 	else if (iid === IID_Heal)
 		ret.max = visionRange;
 
 	return ret;
 };
 
 UnitAI.prototype.GetStance = function()
 {
 	return g_Stances[this.stance];
 };
 
 UnitAI.prototype.GetSelectableStances = function()
 {
 	if (this.IsTurret())
 		return [];
 	return Object.keys(g_Stances).filter(key => g_Stances[key].selectable);
 };
 
 UnitAI.prototype.GetStanceName = function()
 {
 	return this.stance;
 };
 
 /*
  * Make the unit walk at its normal pace.
  */
 UnitAI.prototype.ResetSpeedMultiplier = function()
 {
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (cmpUnitMotion)
 		cmpUnitMotion.SetSpeedMultiplier(1);
 };
 
 UnitAI.prototype.SetSpeedMultiplier = function(speed)
 {
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (cmpUnitMotion)
 		cmpUnitMotion.SetSpeedMultiplier(speed);
 };
 
 /**
  * Try to match the targets current movement speed.
  *
  * @param {number} target - The entity ID of the target to match.
  * @param {boolean} mayRun - Whether the entity is allowed to run to match the speed.
  */
 UnitAI.prototype.TryMatchTargetSpeed = function(target, mayRun = true)
 {
 	let cmpUnitMotionTarget = Engine.QueryInterface(target, IID_UnitMotion);
 	if (cmpUnitMotionTarget)
 	{
 		let targetSpeed = cmpUnitMotionTarget.GetCurrentSpeed();
 		if (targetSpeed)
 			this.SetSpeedMultiplier(Math.min(mayRun ? this.GetRunMultiplier() : 1, targetSpeed / this.GetWalkSpeed()));
 	}
 };
 
 /*
  * Remember the position of the target (in lastPos), if any, in case it disappears later
  * and we want to head to its last known position.
  * @param orderData - The order data to set this on. Defaults to this.order.data
  */
 UnitAI.prototype.RememberTargetPosition = function(orderData)
 {
 	if (!orderData)
 		orderData = this.order.data;
 	let cmpPosition = Engine.QueryInterface(orderData.target, IID_Position);
 	if (cmpPosition && cmpPosition.IsInWorld())
 		orderData.lastPos = cmpPosition.GetPosition();
 };
 
 UnitAI.prototype.SetHeldPosition = function(x, z)
 {
 	this.heldPosition = {"x": x, "z": z};
 };
 
 UnitAI.prototype.SetHeldPositionOnEntity = function(entity)
 {
 	var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return;
 	var pos = cmpPosition.GetPosition();
 	this.SetHeldPosition(pos.x, pos.z);
 };
 
 UnitAI.prototype.GetHeldPosition = function()
 {
 	return this.heldPosition;
 };
 
 UnitAI.prototype.WalkToHeldPosition = function()
 {
 	if (this.heldPosition)
 	{
 		this.AddOrder("Walk", { "x": this.heldPosition.x, "z": this.heldPosition.z, "force": false }, false, false);
 		return true;
 	}
 	return false;
 };
 
 //// Helper functions ////
 
 /**
  * General getter for ranges.
  *
  * @param {number} iid
  * @param {string} type - [Optional]
  * @return {Object | undefined} - The range in the form
  *	{ "min": number, "max": number }
  *	Object."elevationBonus": number may be present when iid == IID_Attack.
  *	Returns undefined when the entity does not have the requested component.
  */
 UnitAI.prototype.GetRange = function(iid, type)
 {
 	let component = Engine.QueryInterface(this.entity, iid);
 	if (!component)
 		return undefined;
 
 	return component.GetRange(type);
 }
 
 UnitAI.prototype.CanAttack = function(target)
 {
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	return cmpAttack && cmpAttack.CanAttack(target);
 };
 
 UnitAI.prototype.CanGarrison = function(target)
 {
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	let cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 		return false;
 
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership || !(IsOwnedByPlayer(cmpOwnership.GetOwner(), target) || IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target)))
 		return false;
 
 	return true;
 };
 
 UnitAI.prototype.CanGather = function(target)
 {
 	if (this.IsTurret())
 		return false;
 
 	var cmpResourceSupply = QueryMiragedInterface(target, IID_ResourceSupply);
 	if (!cmpResourceSupply)
 		return false;
 
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 	if (!cmpResourceGatherer)
 		return false;
 
 	if (!cmpResourceGatherer.GetTargetGatherRate(target))
 		return false;
 
 	// No need to verify ownership as we should be able to gather from
 	// a target regardless of ownership.
 	// No need to call "cmpResourceSupply.IsAvailable()" either because that
 	// would cause units to walk to full entities instead of choosing another one
 	// nearby to gather from, which is undesirable.
 	return true;
 };
 
 UnitAI.prototype.CanHeal = function(target)
 {
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	let cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
 	return cmpHeal && cmpHeal.CanHeal(target);
 };
 
 /**
  * Check if the entity can return carried resources at @param target
  * @param checkCarriedResource check we are carrying resources
  * @param cmpResourceGatherer if present, use this directly instead of re-querying.
  */
 UnitAI.prototype.CanReturnResource = function(target, checkCarriedResource, cmpResourceGatherer = undefined)
 {
 	if (this.IsTurret())
 		return false;
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	if (!cmpResourceGatherer)
 	{
 		cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 		if (!cmpResourceGatherer)
 			return false;
 	}
 
 	let cmpResourceDropsite = Engine.QueryInterface(target, IID_ResourceDropsite);
 	if (!cmpResourceDropsite)
 		return false;
 
 	if (checkCarriedResource)
 	{
 		let type = cmpResourceGatherer.GetMainCarryingType();
 		if (!type || !cmpResourceDropsite.AcceptsType(type))
 			return false;
 	}
 
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (cmpOwnership && IsOwnedByPlayer(cmpOwnership.GetOwner(), target))
 		return true;
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	return cmpPlayer && cmpPlayer.HasSharedDropsites() && cmpResourceDropsite.IsShared() &&
 	       cmpOwnership && IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target);
 };
 
 UnitAI.prototype.CanTrade = function(target)
 {
 	if (this.IsTurret())
 		return false;
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 	return cmpTrader && cmpTrader.CanTrade(target);
 };
 
 UnitAI.prototype.CanRepair = function(target)
 {
 	if (this.IsTurret())
 		return false;
 	// Formation controllers should always respond to commands
 	// (then the individual units can make up their own minds)
 	if (this.IsFormationController())
 		return true;
 
 	// Verify that we're able to respond to Repair (Builder) commands
 	var cmpBuilder = Engine.QueryInterface(this.entity, IID_Builder);
 	if (!cmpBuilder)
 		return false;
 
 	var cmpFoundation = QueryMiragedInterface(target, IID_Foundation);
 	var cmpRepairable = Engine.QueryInterface(target, IID_Repairable);
 	if (!cmpFoundation && !cmpRepairable)
 		return false;
 
 	var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	return cmpOwnership && IsOwnedByAllyOfPlayer(cmpOwnership.GetOwner(), target);
 };
 
 UnitAI.prototype.CanPack = function()
 {
 	var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	return cmpPack && !cmpPack.IsPacking() && !cmpPack.IsPacked();
 };
 
 UnitAI.prototype.CanUnpack = function()
 {
 	var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	return cmpPack && !cmpPack.IsPacking() && cmpPack.IsPacked();
 };
 
 UnitAI.prototype.IsPacking = function()
 {
 	var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	return cmpPack && cmpPack.IsPacking();
 };
 
 //// Formation specific functions ////
 
 UnitAI.prototype.IsAttackingAsFormation = function()
 {
 	var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	return cmpAttack && cmpAttack.CanAttackAsFormation()
 		&& this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
 };
 
 UnitAI.prototype.MoveRandomly = function(distance)
 {
 	// To minimize drift all across the map, describe circles
 	// approximated by polygons.
 	// And to avoid getting stuck in obstacles or narrow spaces, each side
 	// of the polygon is obtained by trying to go away from a point situated
 	// half a meter backwards of the current position, after rotation.
 	// We also add a fluctuation on the length of each side of the polygon (dist)
 	// which, in addition to making the move more random, helps escaping narrow spaces
 	// with bigger values of dist.
 
 	let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (!cmpPosition || !cmpPosition.IsInWorld() || !cmpUnitMotion)
 		return;
 
 	let pos = cmpPosition.GetPosition();
 	let ang = cmpPosition.GetRotation().y;
 
 	if (!this.roamAngle)
 	{
 		this.roamAngle = (randBool() ? 1 : -1) * Math.PI / 6;
 		ang -= this.roamAngle / 2;
 		this.startAngle = ang;
 	}
 	else if (Math.abs((ang - this.startAngle + Math.PI) % (2 * Math.PI) - Math.PI) < Math.abs(this.roamAngle / 2))
 		this.roamAngle *= randBool() ? 1 : -1;
 
 	let halfDelta = randFloat(this.roamAngle / 4, this.roamAngle * 3 / 4);
 	// First half rotation to decrease the impression of immediate rotation
 	ang += halfDelta;
 	cmpUnitMotion.FaceTowardsPoint(pos.x + 0.5 * Math.sin(ang), pos.z + 0.5 * Math.cos(ang));
 	// Then second half of the rotation
 	ang += halfDelta;
 	let dist = randFloat(0.5, 1.5) * distance;
 	cmpUnitMotion.MoveToPointRange(pos.x - 0.5 * Math.sin(ang), pos.z - 0.5 * Math.cos(ang), dist, -1);
 };
 
 UnitAI.prototype.SetFacePointAfterMove = function(val)
 {
 	var cmpMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	if (cmpMotion)
 		cmpMotion.SetFacePointAfterMove(val);
 };
 
 UnitAI.prototype.GetFacePointAfterMove = function()
 {
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return cmpUnitMotion && cmpUnitMotion.GetFacePointAfterMove();
 }
 
 UnitAI.prototype.AttackEntitiesByPreference = function(ents)
 {
 	if (!ents.length)
 		return false;
 
 	let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpAttack)
 		return false;
 
 	let attackfilter = function(e) {
 		if (!cmpAttack.CanAttack(e))
 			return false;
 
 		let cmpOwnership = Engine.QueryInterface(e, IID_Ownership);
 		if (cmpOwnership && cmpOwnership.GetOwner() > 0)
 			return true;
 
 		let cmpUnitAI = Engine.QueryInterface(e, IID_UnitAI);
 		return cmpUnitAI && (!cmpUnitAI.IsAnimal() || cmpUnitAI.IsDangerousAnimal());
 	};
 
 	let entsByPreferences = {};
 	let preferences = [];
 	let entsWithoutPref = [];
 	for (let ent of ents)
 	{
 		if (!attackfilter(ent))
 			continue;
 		let pref = cmpAttack.GetPreference(ent);
 		if (pref === null || pref === undefined)
 			entsWithoutPref.push(ent);
 		else if (!entsByPreferences[pref])
 		{
 			preferences.push(pref);
 			entsByPreferences[pref] = [ent];
 		}
 		else
 			entsByPreferences[pref].push(ent);
 	}
 
 	if (preferences.length)
 	{
 		preferences.sort((a, b) => a - b);
 		for (let pref of preferences)
 			if (this.RespondToTargetedEntities(entsByPreferences[pref]))
 				return true;
 	}
 
 	return this.RespondToTargetedEntities(entsWithoutPref);
 };
 
 /**
  * Call UnitAI.funcname(args) on all formation members.
  * @param resetWaitingEntities - If true, call ResetWaitingEntities first.
  *     If the controller wants to wait on its members to finish their order,
  *     this needs to be reset before sending new orders (in case they instafail)
  *     so it makes sense to do it here.
  *     Only set this to false if you're sure it's safe.
  */
 UnitAI.prototype.CallMemberFunction = function(funcname, args, resetWaitingEntities = true)
 {
 	var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 	if (!cmpFormation)
 		return;
 
 	if (resetWaitingEntities)
 		cmpFormation.ResetWaitingEntities();
 
 	cmpFormation.GetMembers().forEach(ent => {
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		cmpUnitAI[funcname].apply(cmpUnitAI, args);
 	});
 };
 
 /**
  * Call obj.funcname(args) on UnitAI components owned by player in given range.
  */
 UnitAI.prototype.CallPlayerOwnedEntitiesFunctionInRange = function(funcname, args, range)
 {
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership)
 		return;
 	let owner = cmpOwnership.GetOwner();
 	if (owner == INVALID_PLAYER)
 		return;
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let nearby = cmpRangeManager.ExecuteQuery(this.entity, 0, range, [owner], IID_UnitAI, true);
 	for (let i = 0; i < nearby.length; ++i)
 	{
 		let cmpUnitAI = Engine.QueryInterface(nearby[i], IID_UnitAI);
 		cmpUnitAI[funcname].apply(cmpUnitAI, args);
 	}
 };
 
 /**
  * Call obj.functname(args) on UnitAI components of all formation members,
  * and return true if all calls return true.
  */
 UnitAI.prototype.TestAllMemberFunction = function(funcname, args)
 {
 	let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 	return cmpFormation && cmpFormation.GetMembers().every(ent => {
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		return cmpUnitAI[funcname].apply(cmpUnitAI, args);
 	});
 };
 
 UnitAI.prototype.UnitFsm = new FSM(UnitAI.prototype.UnitFsmSpec);
 
 Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);
Index: ps/trunk/binaries/data/mods/public/simulation/helpers/Transform.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/helpers/Transform.js	(revision 25068)
+++ ps/trunk/binaries/data/mods/public/simulation/helpers/Transform.js	(revision 25069)
@@ -1,266 +1,266 @@
 // Helper functions to change an entity's template and check if the transformation is possible
 
 // returns the ID of the new entity or INVALID_ENTITY.
 function ChangeEntityTemplate(oldEnt, newTemplate)
 {
 	// Done un/packing, copy our parameters to the final entity
 	var newEnt = Engine.AddEntity(newTemplate);
 	if (newEnt == INVALID_ENTITY)
 	{
 		error("Transform.js: Error replacing entity " + oldEnt + " for a '" + newTemplate + "'");
 		return INVALID_ENTITY;
 	}
 
 	var cmpPosition = Engine.QueryInterface(oldEnt, IID_Position);
 	var cmpNewPosition = Engine.QueryInterface(newEnt, IID_Position);
 	if (cmpPosition && cmpNewPosition)
 	{
 		if (cmpPosition.IsInWorld())
 		{
 			let pos = cmpPosition.GetPosition2D();
 			cmpNewPosition.JumpTo(pos.x, pos.y);
 		}
 		let rot = cmpPosition.GetRotation();
 		cmpNewPosition.SetYRotation(rot.y);
 		cmpNewPosition.SetXZRotation(rot.x, rot.z);
 		cmpNewPosition.SetHeightOffset(cmpPosition.GetHeightOffset());
 	}
 
 	var cmpOwnership = Engine.QueryInterface(oldEnt, IID_Ownership);
 	var cmpNewOwnership = Engine.QueryInterface(newEnt, IID_Ownership);
 	if (cmpOwnership && cmpNewOwnership)
 		cmpNewOwnership.SetOwner(cmpOwnership.GetOwner());
 
 	// Copy control groups
 	CopyControlGroups(oldEnt, newEnt);
 
 	// Rescale capture points
 	var cmpCapturable = Engine.QueryInterface(oldEnt, IID_Capturable);
 	var cmpNewCapturable = Engine.QueryInterface(newEnt, IID_Capturable);
 	if (cmpCapturable && cmpNewCapturable)
 	{
 		let scale = cmpCapturable.GetMaxCapturePoints() / cmpNewCapturable.GetMaxCapturePoints();
 		let newCapturePoints = cmpCapturable.GetCapturePoints().map(v => v / scale);
 		cmpNewCapturable.SetCapturePoints(newCapturePoints);
 	}
 
 	// Maintain current health level
 	var cmpHealth = Engine.QueryInterface(oldEnt, IID_Health);
 	var cmpNewHealth = Engine.QueryInterface(newEnt, IID_Health);
 	if (cmpHealth && cmpNewHealth)
 	{
 		var healthLevel = Math.max(0, Math.min(1, cmpHealth.GetHitpoints() / cmpHealth.GetMaxHitpoints()));
 		cmpNewHealth.SetHitpoints(cmpNewHealth.GetMaxHitpoints() * healthLevel);
 	}
 
 	let cmpBuilderList = QueryBuilderListInterface(oldEnt);
 	let cmpNewBuilderList = QueryBuilderListInterface(newEnt);
 	if (cmpBuilderList && cmpNewBuilderList)
 		cmpNewBuilderList.AddBuilders(cmpBuilderList.GetBuilders());
 
 	var cmpUnitAI = Engine.QueryInterface(oldEnt, IID_UnitAI);
 	var cmpNewUnitAI = Engine.QueryInterface(newEnt, IID_UnitAI);
 	if (cmpUnitAI && cmpNewUnitAI)
 	{
 		let pos = cmpUnitAI.GetHeldPosition();
 		if (pos)
 			cmpNewUnitAI.SetHeldPosition(pos.x, pos.z);
 		if (cmpUnitAI.GetStanceName())
 			cmpNewUnitAI.SwitchToStance(cmpUnitAI.GetStanceName());
 		if (cmpUnitAI.GetGarrisonHolder() != INVALID_ENTITY)
 			cmpNewUnitAI.SetGarrisoned();
 		cmpNewUnitAI.AddOrders(cmpUnitAI.GetOrders());
 		if (cmpUnitAI.IsGuardOf())
 		{
 			let guarded = cmpUnitAI.IsGuardOf();
 			let cmpGuard = Engine.QueryInterface(guarded, IID_Guard);
 			if (cmpGuard)
 			{
 				cmpGuard.RenameGuard(oldEnt, newEnt);
 				cmpNewUnitAI.SetGuardOf(guarded);
 			}
 		}
 	}
 
 	let cmpPromotion = Engine.QueryInterface(oldEnt, IID_Promotion);
 	let cmpNewPromotion = Engine.QueryInterface(newEnt, IID_Promotion);
 	if (cmpPromotion && cmpNewPromotion)
 		cmpNewPromotion.IncreaseXp(cmpPromotion.GetCurrentXp());
 
 	let cmpResGatherer = Engine.QueryInterface(oldEnt, IID_ResourceGatherer);
 	let cmpNewResGatherer = Engine.QueryInterface(newEnt, IID_ResourceGatherer);
 	if (cmpResGatherer && cmpNewResGatherer)
 	{
 		let carriedResources = cmpResGatherer.GetCarryingStatus();
 		cmpNewResGatherer.GiveResources(carriedResources);
 		cmpNewResGatherer.SetLastCarriedType(cmpResGatherer.GetLastCarriedType());
 	}
 
 
 	// Maintain the list of guards
 	let cmpGuard = Engine.QueryInterface(oldEnt, IID_Guard);
 	let cmpNewGuard = Engine.QueryInterface(newEnt, IID_Guard);
 	if (cmpGuard && cmpNewGuard)
 	{
 		let entities = cmpGuard.GetEntities();
 		if (entities.length)
 		{
 			cmpNewGuard.SetEntities(entities);
 			for (let ent of entities)
 			{
 				let cmpEntUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 				if (cmpEntUnitAI)
 					cmpEntUnitAI.SetGuardOf(newEnt);
 			}
 		}
 	}
 
 	let cmpStatusEffectsReceiver = Engine.QueryInterface(oldEnt, IID_StatusEffectsReceiver);
 	let cmpNewStatusEffectsReceiver = Engine.QueryInterface(newEnt, IID_StatusEffectsReceiver);
 	if (cmpStatusEffectsReceiver && cmpNewStatusEffectsReceiver)
 	{
 		let activeStatus = cmpStatusEffectsReceiver.GetActiveStatuses();
 		for (let status in activeStatus)
 		{
 			let newStatus = activeStatus[status];
 			if (newStatus.Duration)
 				newStatus.Duration -= newStatus._timeElapsed;
 			cmpNewStatusEffectsReceiver.ApplyStatus({ [status]: newStatus }, newStatus.source.entity, newStatus.source.owner);
 		}
 	}
 
 	TransferGarrisonedUnits(oldEnt, newEnt);
 
 	Engine.PostMessage(oldEnt, MT_EntityRenamed, { "entity": oldEnt, "newentity": newEnt });
 
 	if (cmpPosition && cmpPosition.IsInWorld())
 		cmpPosition.MoveOutOfWorld();
 	Engine.DestroyEntity(oldEnt);
 
 	return newEnt;
 }
 
 function CopyControlGroups(oldEnt, newEnt)
 {
 	let cmpObstruction = Engine.QueryInterface(oldEnt, IID_Obstruction);
 	let cmpNewObstruction = Engine.QueryInterface(newEnt, IID_Obstruction);
 	if (cmpObstruction && cmpNewObstruction)
 	{
 		cmpNewObstruction.SetControlGroup(cmpObstruction.GetControlGroup());
 		cmpNewObstruction.SetControlGroup2(cmpObstruction.GetControlGroup2());
 	}
 }
 
 function ObstructionsBlockingTemplateChange(ent, templateArg)
 {
 	var previewEntity = Engine.AddEntity("preview|"+templateArg);
 
 	if (previewEntity == INVALID_ENTITY)
 		return true;
 
 	CopyControlGroups(ent, previewEntity);
 	var cmpBuildRestrictions = Engine.QueryInterface(previewEntity, IID_BuildRestrictions);
 	var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 
 	var cmpNewPosition = Engine.QueryInterface(previewEntity, IID_Position);
 
 	// Return false if no ownership as BuildRestrictions.CheckPlacement needs an owner and I have no idea if false or true is better
 	// Plus there are no real entities without owners currently.
 	if (!cmpBuildRestrictions || !cmpPosition || !cmpOwnership)
 		return DeleteEntityAndReturn(previewEntity, cmpPosition, null, null, cmpNewPosition, false);
 
 	var pos = cmpPosition.GetPosition2D();
 	var angle = cmpPosition.GetRotation();
 	// move us away to prevent our own obstruction from blocking the upgrade.
 	cmpPosition.MoveOutOfWorld();
 
 	cmpNewPosition.JumpTo(pos.x, pos.y);
 	cmpNewPosition.SetYRotation(angle.y);
 
 	var cmpNewOwnership = Engine.QueryInterface(previewEntity, IID_Ownership);
 	cmpNewOwnership.SetOwner(cmpOwnership.GetOwner());
 
 	var checkPlacement = cmpBuildRestrictions.CheckPlacement();
 
 	if (checkPlacement && !checkPlacement.success)
 		return DeleteEntityAndReturn(previewEntity, cmpPosition, pos, angle, cmpNewPosition, true);
 
 	var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	var template = cmpTemplateManager.GetTemplate(cmpTemplateManager.GetCurrentTemplateName(ent));
 	var newTemplate = cmpTemplateManager.GetTemplate(templateArg);
 
 	// Check if units are blocking our template change
 	if (template.Obstruction && newTemplate.Obstruction)
 	{
 		// This only needs to be done if the new template is strictly bigger than the old one
 		// "Obstructions" are annoying to test so just check.
 		if (newTemplate.Obstruction.Obstructions ||
 
 			newTemplate.Obstruction.Static && template.Obstruction.Static &&
 				(newTemplate.Obstruction.Static["@width"] > template.Obstruction.Static["@width"] ||
 				 newTemplate.Obstruction.Static["@depth"] > template.Obstruction.Static["@depth"]) ||
 			newTemplate.Obstruction.Static && template.Obstruction.Unit &&
 				(newTemplate.Obstruction.Static["@width"] > template.Obstruction.Unit["@radius"] ||
 				 newTemplate.Obstruction.Static["@depth"] > template.Obstruction.Unit["@radius"]) ||
 
 			newTemplate.Obstruction.Unit && template.Obstruction.Unit &&
 				newTemplate.Obstruction.Unit["@radius"] > template.Obstruction.Unit["@radius"] ||
 			newTemplate.Obstruction.Unit && template.Obstruction.Static &&
 				(newTemplate.Obstruction.Unit["@radius"] > template.Obstruction.Static["@width"] ||
 				 newTemplate.Obstruction.Unit["@radius"] > template.Obstruction.Static["@depth"]))
 		{
 			var cmpNewObstruction = Engine.QueryInterface(previewEntity, IID_Obstruction);
 			if (cmpNewObstruction && cmpNewObstruction.GetBlockMovementFlag())
 			{
 				// Remove all obstructions at the new entity, especially animal corpses
 				for (let ent of cmpNewObstruction.GetEntitiesDeletedUponConstruction())
 					Engine.DestroyEntity(ent);
 
 				let collisions = cmpNewObstruction.GetEntitiesBlockingConstruction();
 				if (collisions.length)
 					return DeleteEntityAndReturn(previewEntity, cmpPosition, pos, angle, cmpNewPosition, true);
 			}
 		}
 	}
 
 	return DeleteEntityAndReturn(previewEntity, cmpPosition, pos, angle, cmpNewPosition, false);
 }
 
 function DeleteEntityAndReturn(ent, cmpPosition, position, angle, cmpNewPosition, ret)
 {
 	// prevent preview from interfering in the world
 	cmpNewPosition.MoveOutOfWorld();
 	if (position !== null)
 	{
 		cmpPosition.JumpTo(position.x, position.y);
 		cmpPosition.SetYRotation(angle.y);
 	}
 
 	Engine.DestroyEntity(ent);
 	return ret;
 }
 
 function TransferGarrisonedUnits(oldEnt, newEnt)
 {
 	// Transfer garrisoned units if possible, or unload them
 	let cmpOldGarrison = Engine.QueryInterface(oldEnt, IID_GarrisonHolder);
 	if (!cmpOldGarrison || !cmpOldGarrison.GetEntities().length)
 		return;
 
 	let cmpNewGarrison = Engine.QueryInterface(newEnt, IID_GarrisonHolder);
 	let entities = cmpOldGarrison.GetEntities().slice();
 	for (let ent of entities)
 	{
 		cmpOldGarrison.Unload(ent);
 		if (!cmpNewGarrison)
 			continue;
 		let cmpGarrisonable = Engine.QueryInterface(ent, IID_Garrisonable);
 		if (!cmpGarrisonable)
 			continue;
-		cmpGarrisonable.Autogarrison(newEnt);
+		cmpGarrisonable.Garrison(newEnt);
 	}
 }
 
 Engine.RegisterGlobal("ChangeEntityTemplate", ChangeEntityTemplate);
 Engine.RegisterGlobal("ObstructionsBlockingTemplateChange", ObstructionsBlockingTemplateChange);