Index: ps/trunk/binaries/data/mods/public/simulation/components/ResourceGatherer.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/ResourceGatherer.js	(revision 23352)
+++ ps/trunk/binaries/data/mods/public/simulation/components/ResourceGatherer.js	(revision 23353)
@@ -1,350 +1,355 @@
 function ResourceGatherer() {}
 
 ResourceGatherer.prototype.Schema =
 	"<a:help>Lets the unit gather resources from entities that have the ResourceSupply component.</a:help>" +
 	"<a:example>" +
 		"<MaxDistance>2.0</MaxDistance>" +
 		"<BaseSpeed>1.0</BaseSpeed>" +
 		"<Rates>" +
 			"<food.fish>1</food.fish>" +
 			"<metal.ore>3</metal.ore>" +
 			"<stone.rock>3</stone.rock>" +
 			"<wood.tree>2</wood.tree>" +
 		"</Rates>" +
 		"<Capacities>" +
 			"<food>10</food>" +
 			"<metal>10</metal>" +
 			"<stone>10</stone>" +
 			"<wood>10</wood>" +
 		"</Capacities>" +
 	"</a:example>" +
 	"<element name='MaxDistance' a:help='Max resource-gathering distance'>" +
 		"<ref name='positiveDecimal'/>" +
 	"</element>" +
 	"<element name='BaseSpeed' a:help='Base resource-gathering rate (in resource units per second)'>" +
 		"<ref name='positiveDecimal'/>" +
 	"</element>" +
 	"<element name='Rates' a:help='Per-resource-type gather rate multipliers. If a resource type is not specified then it cannot be gathered by this unit'>" +
 		Resources.BuildSchema("positiveDecimal", ["treasure"], true) +
 	"</element>" +
 	"<element name='Capacities' a:help='Per-resource-type maximum carrying capacity'>" +
 		Resources.BuildSchema("positiveDecimal") +
 	"</element>";
 
 ResourceGatherer.prototype.Init = function()
 {
 	this.carrying = {}; // { generic type: integer amount currently carried }
 	// (Note that this component supports carrying multiple types of resources,
 	// each with an independent capacity, but the rest of the game currently
 	// ensures and assumes we'll only be carrying one type at once)
 
 	// The last exact type gathered, so we can render appropriate props
 	this.lastCarriedType = undefined; // { generic, specific }
 };
 
 /**
  * Returns data about what resources the unit is currently carrying,
  * in the form [ {"type":"wood", "amount":7, "max":10} ]
  */
 ResourceGatherer.prototype.GetCarryingStatus = function()
 {
 	let ret = [];
 	for (let type in this.carrying)
 	{
 		ret.push({
 			"type": type,
 			"amount": this.carrying[type],
 			"max": +this.GetCapacity(type)
 		});
 	}
 	return ret;
 };
 
 /**
  * Used to instantly give resources to unit
  * @param resources The same structure as returned form GetCarryingStatus
  */
 ResourceGatherer.prototype.GiveResources = function(resources)
 {
 	for (let resource of resources)
 		this.carrying[resource.type] = +resource.amount;
 
 	Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 };
 
 /**
  * Returns the generic type of one particular resource this unit is
  * currently carrying, or undefined if none.
  */
 ResourceGatherer.prototype.GetMainCarryingType = function()
 {
 	// Return the first key, if any
 	for (let type in this.carrying)
 		return type;
 
 	return undefined;
 };
 
 /**
  * Returns the exact resource type we last picked up, as long as
  * we're still carrying something similar enough, in the form
  * { generic, specific }
  */
 ResourceGatherer.prototype.GetLastCarriedType = function()
 {
 	if (this.lastCarriedType && this.lastCarriedType.generic in this.carrying)
 		return this.lastCarriedType;
 
 	return undefined;
 };
 
+ResourceGatherer.prototype.SetLastCarriedType = function(lastCarriedType)
+{
+	this.lastCarriedType = lastCarriedType;
+};
+
 // Since this code is very performancecritical and applying technologies quite slow, cache it.
 ResourceGatherer.prototype.RecalculateGatherRatesAndCapacities = function()
 {
 	this.baseSpeed = ApplyValueModificationsToEntity("ResourceGatherer/BaseSpeed", +this.template.BaseSpeed, this.entity);
 
 	this.rates = {};
 	for (let r in this.template.Rates)
 	{
 		let type = r.split(".");
 
 		if (type[0] != "treasure" && type.length > 1 && !Resources.GetResource(type[0]).subtypes[type[1]])
 		{
 			error("Resource subtype not found: " + type[0] + "." + type[1]);
 			continue;
 		}
 
 		let rate = ApplyValueModificationsToEntity("ResourceGatherer/Rates/" + r, +this.template.Rates[r], this.entity);
 		this.rates[r] = rate * this.baseSpeed;
 	}
 
 	this.capacities = {};
 	for (let r in this.template.Capacities)
 		this.capacities[r] = ApplyValueModificationsToEntity("ResourceGatherer/Capacities/" + r, +this.template.Capacities[r], this.entity);
 };
 
 ResourceGatherer.prototype.GetGatherRates = function()
 {
 	return this.rates;
 };
 
 ResourceGatherer.prototype.GetGatherRate = function(resourceType)
 {
 	if (!this.template.Rates[resourceType])
 		return 0;
 
 	return this.rates[resourceType];
 };
 
 ResourceGatherer.prototype.GetCapacity = function(resourceType)
 {
 	if(!this.template.Capacities[resourceType])
 		return 0;
 	return this.capacities[resourceType];
 };
 
 ResourceGatherer.prototype.GetRange = function()
 {
 	return { "max": +this.template.MaxDistance, "min": 0 };
 	// maybe this should depend on the unit or target or something?
 };
 
 /**
  * Try to gather treasure
  * @return 'true' if treasure is successfully gathered, otherwise 'false'
  */
 ResourceGatherer.prototype.TryInstantGather = function(target)
 {
 	let cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
 	let type = cmpResourceSupply.GetType();
 
 	if (type.generic != "treasure")
 		return false;
 
 	let status = cmpResourceSupply.TakeResources(cmpResourceSupply.GetCurrentAmount());
 
 	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
 	if (cmpPlayer)
 		cmpPlayer.AddResource(type.specific, status.amount);
 
 	let cmpStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
 	if (cmpStatisticsTracker)
 		cmpStatisticsTracker.IncreaseTreasuresCollectedCounter();
 
 	let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
 	if (cmpTrigger && cmpPlayer)
 		cmpTrigger.CallEvent("TreasureCollected", { "player": cmpPlayer.GetPlayerID(), "type": type.specific, "amount": status.amount });
 
 	return true;
 };
 
 /**
  * Gather from the target entity. This should only be called after a successful range check,
  * and if the target has a compatible ResourceSupply.
  * Call interval will be determined by gather rate, so always gather 1 amount when called.
  */
 ResourceGatherer.prototype.PerformGather = function(target)
 {
 	if (!this.GetTargetGatherRate(target))
 		return { "exhausted": true };
 
 	let gatherAmount = 1;
 
 	let cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
 	let type = cmpResourceSupply.GetType();
 
 	// Initialise the carried count if necessary
 	if (!this.carrying[type.generic])
 		this.carrying[type.generic] = 0;
 
 	// Find the maximum so we won't exceed our capacity
 	let maxGathered = this.GetCapacity(type.generic) - this.carrying[type.generic];
 
 	let status = cmpResourceSupply.TakeResources(Math.min(gatherAmount, maxGathered));
 
 	this.carrying[type.generic] += status.amount;
 
 	this.lastCarriedType = type;
 
 	// Update stats of how much the player collected.
 	// (We have to do it here rather than at the dropsite, because we
 	// need to know what subtype it was)
 	let cmpStatisticsTracker = QueryOwnerInterface(this.entity, IID_StatisticsTracker);
 	if (cmpStatisticsTracker)
 		cmpStatisticsTracker.IncreaseResourceGatheredCounter(type.generic, status.amount, type.specific);
 
 	Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 
 
 	return {
 		"amount": status.amount,
 		"exhausted": status.exhausted,
 		"filled": this.carrying[type.generic] >= this.GetCapacity(type.generic)
 	};
 };
 
 /**
  * Compute the amount of resources collected per second from the target.
  * Returns 0 if resources cannot be collected (e.g. the target doesn't
  * exist, or is the wrong type).
  */
 ResourceGatherer.prototype.GetTargetGatherRate = function(target)
 {
 	let cmpResourceSupply = QueryMiragedInterface(target, IID_ResourceSupply);
 	if (!cmpResourceSupply)
 		return 0;
 
 	let type = cmpResourceSupply.GetType();
 
 	let rate = 0;
 	if (type.specific)
 		rate = this.GetGatherRate(type.generic+"."+type.specific);
 	if (rate == 0 && type.generic)
 		rate = this.GetGatherRate(type.generic);
 
 	if ("Mirages" in cmpResourceSupply)
 		return rate;
 
 	// Apply diminishing returns with more gatherers, for e.g. infinite farms. For most resources this has no effect
 	// (GetDiminishingReturns will return null). We can assume that for resources that are miraged this is the case
 	// (else just add the diminishing returns data to the mirage data and remove the early return above)
 	let diminishingReturns = cmpResourceSupply.GetDiminishingReturns();
 	if (diminishingReturns)
 		rate *= diminishingReturns;
 
 	return rate;
 };
 
 /**
  * Returns whether this unit can carry more of the given type of resource.
  * (This ignores whether the unit is actually able to gather that
  * resource type or not.)
  */
 ResourceGatherer.prototype.CanCarryMore = function(type)
 {
 	let amount = this.carrying[type] || 0;
 	return amount < this.GetCapacity(type);
 };
 
 
 ResourceGatherer.prototype.IsCarrying = function(type)
 {
 	let amount = this.carrying[type] || 0;
 	return amount > 0;
 };
 
 /**
  * Returns whether this unit is carrying any resources of a type that is
  * not the requested type. (This is to support cases where the unit is
  * only meant to be able to carry one type at once.)
  */
 ResourceGatherer.prototype.IsCarryingAnythingExcept = function(exceptedType)
 {
 	for (let type in this.carrying)
 		if (type != exceptedType)
 			return true;
 
 	return false;
 };
 
 /**
  * Transfer our carried resources to our owner immediately.
  * Only resources of the given types will be transferred.
  * (This should typically be called after reaching a dropsite).
  */
 ResourceGatherer.prototype.CommitResources = function(types)
 {
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 
 	if (cmpPlayer)
 		for (let type of types)
 			if (type in this.carrying)
 			{
 				cmpPlayer.AddResource(type, this.carrying[type]);
 				delete this.carrying[type];
 			}
 
 	Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 };
 
 /**
  * Drop all currently-carried resources.
  * (Currently they just vanish after being dropped - we don't bother depositing
  * them onto the ground.)
  */
 ResourceGatherer.prototype.DropResources = function()
 {
 	this.carrying = {};
 
 	Engine.PostMessage(this.entity, MT_ResourceCarryingChanged, { "to": this.GetCarryingStatus() });
 };
 
 // Since we cache gather rates, we need to make sure we update them when tech changes.
 // and when our owner change because owners can had different techs.
 ResourceGatherer.prototype.OnValueModification = function(msg)
 {
 	if (msg.component != "ResourceGatherer")
 		return;
 
 	this.RecalculateGatherRatesAndCapacities();
 };
 
 ResourceGatherer.prototype.OnOwnershipChanged = function(msg)
 {
 	if (msg.to == INVALID_PLAYER)
 		return;
 	this.RecalculateGatherRatesAndCapacities();
 };
 
 ResourceGatherer.prototype.OnGlobalInitGame = function(msg)
 {
 	this.RecalculateGatherRatesAndCapacities();
 };
 
 ResourceGatherer.prototype.OnMultiplierChanged = function(msg)
 {
 	if (msg.player == QueryOwnerInterface(this.entity, IID_Player).GetPlayerID())
 		this.RecalculateGatherRatesAndCapacities();
 };
 
 Engine.RegisterComponentType(IID_ResourceGatherer, "ResourceGatherer", ResourceGatherer);
Index: ps/trunk/binaries/data/mods/public/simulation/helpers/Transform.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/helpers/Transform.js	(revision 23352)
+++ ps/trunk/binaries/data/mods/public/simulation/helpers/Transform.js	(revision 23353)
@@ -1,261 +1,262 @@
 // 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 newCp = cmpCapturable.GetCapturePoints().map(v => v / scale);
 		cmpNewCapturable.SetCapturePoints(newCp);
 	}
 
 	// 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);
 	}
 
 	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());
 		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);
 			}
 		}
 		if (cmpUnitAI.IsGarrisoned())
 			cmpNewUnitAI.SetGarrisoned();
 	}
 
 	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);
 			}
 		}
 	}
 
 	TransferGarrisonedUnits(oldEnt, newEnt);
 
 	Engine.PostMessage(oldEnt, MT_EntityRenamed, { "entity": oldEnt, "newentity": newEnt });
 
 	if (cmpPosition && cmpPosition.IsInWorld())
 		cmpPosition.MoveOutOfWorld();
 	Engine.DestroyEntity(oldEnt);
 
 	return newEnt;
 }
 
 function CanGarrisonedChangeTemplate(ent, template)
 {
 	var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	var unitAI = Engine.QueryInterface(ent, IID_UnitAI);
 	if (cmpPosition && !cmpPosition.IsInWorld() && unitAI && unitAI.IsGarrisoned())
 	{
 		// We're a garrisoned unit, assume impossibility as I've been unable to find a way to get the holder ID.
 		// TODO: change this if that ever becomes possibles
 		return false;
 	}
 	return true;
 }
 
 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.Eject(ent);
 		if (!cmpNewGarrison)
 			continue;
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		if (!cmpUnitAI)
 			continue;
 		cmpUnitAI.Autogarrison(newEnt);
 		cmpNewGarrison.Garrison(ent);
 	}
 }
 
 Engine.RegisterGlobal("ChangeEntityTemplate", ChangeEntityTemplate);
 Engine.RegisterGlobal("CanGarrisonedChangeTemplate", CanGarrisonedChangeTemplate);
 Engine.RegisterGlobal("ObstructionsBlockingTemplateChange", ObstructionsBlockingTemplateChange);