Index: ps/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/UnitAI.js	(revision 22445)
+++ ps/trunk/binaries/data/mods/public/simulation/components/UnitAI.js	(revision 22446)
@@ -1,5944 +1,5922 @@
 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>" +
 		"</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>" +
 	"<optional>" +
 		"<interleave>" +
 			"<element name='NaturalBehaviour' a:help='Behaviour of the unit in the absence of player commands (intended for animals)'>" +
 				"<choice>" +
 					"<value a:help='Will actively attack any unit it encounters, even if not threatened'>violent</value>" +
 					"<value a:help='Will attack nearby units if it feels threatened (if they linger within LOS for too long)'>aggressive</value>" +
 					"<value a:help='Will attack nearby units if attacked'>defensive</value>" +
 					"<value a:help='Will never attack units but will attempt to flee when attacked'>passive</value>" +
 					"<value a:help='Will never attack units. Will typically attempt to flee for short distances when units approach'>skittish</value>" +
 					"<value a:help='Will never attack units and will not attempt to flee when attacked'>domestic</value>" +
 				"</choice>" +
 			"</element>" +
 			"<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
 //   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,
 		"respondChase": true,
 		"respondChaseBeyondVision": true,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"aggressive": {
 		"targetVisibleEnemies": true,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondChase": true,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"defensive": {
 		"targetVisibleEnemies": true,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": true,
 		"selectable": true
 	},
 	"passive": {
 		"targetVisibleEnemies": false,
 		"targetAttackersAlways": false,
 		"respondFlee": true,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"standground": {
 		"targetVisibleEnemies": true,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": true,
 		"respondHoldGround": false,
 		"selectable": true
 	},
 	"none": {
 		// Only to be used by AI or trigger scripts
 		"targetVisibleEnemies": false,
 		"targetAttackersAlways": false,
 		"respondFlee": false,
 		"respondChase": false,
 		"respondChaseBeyondVision": false,
 		"respondStandGround": false,
 		"respondHoldGround": false,
 		"selectable": false
 	}
 };
 
 // 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
 	},
 
 	"Attacked": function(msg) {
 		// ignore attacker
 	},
 
 	"HealthChanged": function(msg) {
 		// ignore
 	},
 
 	"PackFinished": function(msg) {
 		// ignore
 	},
 
 	"PickupCanceled": function(msg) {
 		// ignore
 	},
 
 	"TradingCanceled": function(msg) {
 		// ignore
 	},
 
 	"GuardedAttacked": function(msg) {
 		// ignore
 	},
 
 	// Formation handlers:
 
 	"FormationLeave": function(msg) {
 		// ignore when we're not in FORMATIONMEMBER
 	},
 
 	// Called when being told to walk as part of a formation
 	"Order.FormationWalk": function(msg) {
 		// Let players move captured domestic animals around
 		if (this.IsAnimal() && !this.IsDomestic() || this.IsTurret())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// For packable units:
 		// 1. If packed, we can move.
 		// 2. If unpacked, we first need to pack, then follow case 1.
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return;
 		}
 
 		this.SetNextState("FORMATIONMEMBER.WALKING");
 	},
 
 	// Special orders:
 	// (these will be overridden by various states)
 
 	"Order.LeaveFoundation": function(msg) {
 		// If foundation is not ally of entity, or if entity is unpacked siege,
 		// ignore the order
 		if (!IsOwnedByAllyOfEntity(this.entity, msg.data.target) && !Engine.QueryInterface(SYSTEM_ENTITY, IID_CeasefireManager).IsCeasefireActive() ||
 			this.IsPacking() || this.CanPack() || this.IsTurret())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// Move a tile outside the building if necessary.
 		let range = 4;
 		if (this.CheckTargetRangeExplicit(msg.data.target, range, -1))
 			this.FinishOrder();
 		else
 		{
 			this.order.data.min = range;
 			this.SetNextState("INDIVIDUAL.WALKING");
 		}
 	},
 
 	// Individual orders:
 	// (these will switch the unit out of formation mode)
 
 	"Order.Stop": function(msg) {
 		// We have no control over non-domestic animals.
 		if (this.IsAnimal() && !this.IsDomestic())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// Stop moving immediately.
 		this.StopMoving();
 		this.FinishOrder();
 
 		// No orders left, we're an individual now
 		if (this.IsAnimal())
 			this.SetNextState("ANIMAL.IDLE");
 		else
 			this.SetNextState("INDIVIDUAL.IDLE");
 
 	},
 
 	"Order.Walk": function(msg) {
 		// Let players move captured domestic animals around
 		if (this.IsAnimal() && !this.IsDomestic() || this.IsTurret())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// For packable units:
 		// 1. If packed, we can move.
 		// 2. If unpacked, we first need to pack, then follow case 1.
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return;
 		}
 
 		this.SetHeldPosition(this.order.data.x, this.order.data.z);
 		if (this.IsAnimal())
 			this.SetNextState("ANIMAL.WALKING");
 		else
 			this.SetNextState("INDIVIDUAL.WALKING");
 	},
 
 	"Order.WalkAndFight": function(msg) {
 		// Let players move captured domestic animals around
 		if (this.IsAnimal() && !this.IsDomestic() || this.IsTurret())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// For packable units:
 		// 1. If packed, we can move.
 		// 2. If unpacked, we first need to pack, then follow case 1.
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return;
 		}
 
 		this.SetHeldPosition(this.order.data.x, this.order.data.z);
 		if (this.IsAnimal())
 			this.SetNextState("ANIMAL.WALKING");   // WalkAndFight not applicable for animals
 		else
 			this.SetNextState("INDIVIDUAL.WALKINGANDFIGHTING");
 	},
 
 
 	"Order.WalkToTarget": function(msg) {
 		// Let players move captured domestic animals around
 		if (this.IsAnimal() && !this.IsDomestic() || this.IsTurret())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// For packable units:
 		// 1. If packed, we can move.
 		// 2. If unpacked, we first need to pack, then follow case 1.
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return;
 		}
 
 
 		if (this.CheckTargetRangeExplicit(this.order.data.target, 0, 0))
 		{
 			// We are already at the target, or can't move at all
 			this.FinishOrder();
 			return true;
 		}
 
 		if (this.IsAnimal())
 			this.SetNextState("ANIMAL.WALKING");
 		else
 			this.SetNextState("INDIVIDUAL.WALKING");
 	},
 
 	"Order.PickupUnit": function(msg) {
 		var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
 		if (!cmpGarrisonHolder || cmpGarrisonHolder.IsFull())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		if (this.CheckTargetRangeExplicit(this.order.data.target, 0, 0))
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// Check if we need to move     TODO implement a better way to know if we are on the shoreline
 		var needToMove = true;
 		var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 		if (this.lastShorelinePosition && cmpPosition && (this.lastShorelinePosition.x == cmpPosition.GetPosition().x)
 		    && (this.lastShorelinePosition.z == cmpPosition.GetPosition().z))
 		{
 			// we were already on the shoreline, and have not moved since
 			if (DistanceBetweenEntities(this.entity, this.order.data.target) < 50)
 				needToMove = false;
 		}
 
 		if (needToMove)
 			this.SetNextState("INDIVIDUAL.PICKUP.APPROACHING");
 		else
 			this.SetNextState("INDIVIDUAL.PICKUP.LOADING");
 	},
 
 	"Order.Guard": function(msg) {
 		if (!this.AddGuard(this.order.data.target))
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		if (!this.CheckTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
 			this.SetNextState("INDIVIDUAL.GUARD.ESCORTING");
 		else
 			this.SetNextState("INDIVIDUAL.GUARD.GUARDING");
 	},
 
 	"Order.Flee": function(msg) {
 		if (this.IsAnimal())
 			this.SetNextState("ANIMAL.FLEEING");
 		else
 			this.SetNextState("INDIVIDUAL.FLEEING");
 	},
 
 	"Order.Attack": function(msg) {
 		// Check the target is alive
 		if (!this.TargetIsAlive(this.order.data.target))
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// Work out how to attack the given target
 		var type = this.GetBestAttackAgainst(this.order.data.target, this.order.data.allowCapture);
 		if (!type)
 		{
 			// Oops, we can't attack at all
 			this.FinishOrder();
 			return;
 		}
 		this.order.data.attackType = type;
 
 		this.RememberTargetPosition();
 
 		// If we are already at the target, try attacking it from here
 		if (this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
 		{
 			// For packable units within attack range:
 			// 1. If unpacked, we can attack the target.
 			// 2. If packed, we first need to unpack, then follow case 1.
 			if (this.CanUnpack())
 			{
 				this.PushOrderFront("Unpack", { "force": true });
 				return;
 			}
 
 			if (this.IsAnimal())
 				this.SetNextState("ANIMAL.COMBAT.ATTACKING");
 			else
 				this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
 			return;
 		}
 
 		// If we can't reach the target, but are standing ground, then abandon this attack order.
 		// Unless we're hunting, that's a special case where we should continue attacking our target.
 		if (this.GetStance().respondStandGround && !this.order.data.force && !this.order.data.hunting || this.IsTurret())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// For packable units out of attack range:
 		// 1. If packed, we need to move to attack range and then unpack.
 		// 2. If unpacked, we first need to pack, then follow case 1.
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return;
 		}
 
 		if (this.IsAnimal())
 			this.SetNextState("ANIMAL.COMBAT.APPROACHING");
 		else
 			this.SetNextState("INDIVIDUAL.COMBAT.APPROACHING");
 	},
 
 	"Order.Patrol": function(msg) {
 		if (this.IsAnimal() || this.IsTurret())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return;
 		}
 
 		this.SetNextState("INDIVIDUAL.PATROL");
 	},
 
 	"Order.Heal": function(msg) {
 		// Check the target is alive
 		if (!this.TargetIsAlive(this.order.data.target))
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// Healers can't heal themselves.
 		if (this.order.data.target == this.entity)
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// Check if the target is in range
 		if (this.CheckTargetRange(this.order.data.target, IID_Heal))
 		{
 			this.SetNextState("INDIVIDUAL.HEAL.HEALING");
 			return;
 		}
 
 		// If we can't reach the target, but are standing ground,
 		// then abandon this heal order
 		if (this.GetStance().respondStandGround && !this.order.data.force)
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		this.SetNextState("INDIVIDUAL.HEAL.APPROACHING");
 	},
 
 	"Order.Gather": function(msg) {
 		// If the target is still alive, we need to kill it first
 		if (this.MustKillGatherTarget(this.order.data.target))
 		{
 			// Make sure we can attack the target, else we'll get very stuck
 			if (!this.GetBestAttackAgainst(this.order.data.target, false))
 			{
 				// Oops, we can't attack at all - give up
 				// TODO: should do something so the player knows why this failed
 				this.FinishOrder();
 				return;
 			}
 			// The target was visible when this order was issued,
 			// but could now be invisible again.
 			if (!this.CheckTargetVisible(this.order.data.target))
 			{
 				if (this.order.data.secondTry === undefined)
 				{
 					this.order.data.secondTry = true;
 					this.PushOrderFront("Walk", this.order.data.lastPos);
 				}
 				else
 				{
 					// We couldn't move there, or the target moved away
 					this.FinishOrder();
 				}
 				return;
 			}
 
 			this.PushOrderFront("Attack", { "target": this.order.data.target, "force": !!this.order.data.force, "hunting": true, "allowCapture": false });
 			return;
 		}
 
 		this.RememberTargetPosition();
 		this.order.data.initPos = this.order.data.lastPos;
 
 		if (this.CheckTargetRange(this.order.data.target, IID_ResourceGatherer))
 			this.SetNextState("INDIVIDUAL.GATHER.GATHERING");
 		else
 			this.SetNextState("INDIVIDUAL.GATHER.APPROACHING");
 	},
 
 	"Order.GatherNearPosition": function(msg) {
 		this.SetNextState("INDIVIDUAL.GATHER.WALKING");
 		this.order.data.initPos = { 'x': this.order.data.x, 'z': this.order.data.z };
 	},
 
 	"Order.ReturnResource": function(msg) {
 		// Check if the dropsite is already in range
 		if (this.CheckTargetRange(this.order.data.target, IID_ResourceGatherer) && this.CanReturnResource(this.order.data.target, true))
 		{
 			var cmpResourceDropsite = Engine.QueryInterface(this.order.data.target, IID_ResourceDropsite);
 			if (cmpResourceDropsite)
 			{
 				// Dump any resources we can
 				var dropsiteTypes = cmpResourceDropsite.GetTypes();
 
 				Engine.QueryInterface(this.entity, IID_ResourceGatherer).CommitResources(dropsiteTypes);
 				// 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;
 			}
 		}
 		this.SetNextState("INDIVIDUAL.RETURNRESOURCE.APPROACHING");
 	},
 
 	"Order.Trade": function(msg) {
 		// We must check if this trader has both markets in case it was a back-to-work order
 		var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
 		if (!cmpTrader || !cmpTrader.HasBothMarkets())
 		{
 			this.FinishOrder();
 			return;
 		}
 
 		// TODO find the nearest way-point from our position, and start with it
 		this.waypoints = undefined;
 		this.SetNextState("TRADE.APPROACHINGMARKET");
 	},
 
 	"Order.Repair": function(msg) {
 		// Try to move within range
 		if (this.CheckTargetRange(this.order.data.target, IID_Builder))
 			this.SetNextState("INDIVIDUAL.REPAIR.REPAIRING");
 		else
 			this.SetNextState("INDIVIDUAL.REPAIR.APPROACHING");
 	},
 
 	"Order.Garrison": function(msg) {
 		if (this.IsTurret())
 		{
 			this.SetNextState("IDLE");
 			return;
 		}
 		else if (this.IsGarrisoned())
 		{
 			this.SetNextState("INDIVIDUAL.GARRISON.GARRISONED");
 			return;
 		}
 
 		// For packable units:
 		// 1. If packed, we can move to the garrison target.
 		// 2. If unpacked, we first need to pack, then follow case 1.
 		if (this.CanPack())
 		{
 			this.PushOrderFront("Pack", { "force": true });
 			return;
 		}
 
 		this.SetNextState("INDIVIDUAL.GARRISON.APPROACHING");
 	},
 
 	"Order.Ungarrison": function() {
 		this.FinishOrder();
 		this.isGarrisoned = false;
 	},
 
 	"Order.Cheering": function(msg) {
 		this.SetNextState("INDIVIDUAL.CHEERING");
 	},
 
 	"Order.Pack": function(msg) {
 		if (this.CanPack())
 			this.SetNextState("INDIVIDUAL.PACKING");
 	},
 
 	"Order.Unpack": function(msg) {
 		if (this.CanUnpack())
 			this.SetNextState("INDIVIDUAL.UNPACKING");
 	},
 
 	"Order.CancelPack": function(msg) {
 		var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 		if (cmpPack && cmpPack.IsPacking() && !cmpPack.IsPacked())
 			cmpPack.CancelPack();
 		this.FinishOrder();
 	},
 
 	"Order.CancelUnpack": function(msg) {
 		var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 		if (cmpPack && cmpPack.IsPacking() && cmpPack.IsPacked())
 			cmpPack.CancelPack();
 		this.FinishOrder();
 	},
 
 	// 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");
 		},
 
 		"Order.WalkAndFight": function(msg) {
 			this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 			this.SetNextState("WALKINGANDFIGHTING");
 		},
 
 		"Order.MoveIntoFormation": function(msg) {
 			this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 			this.SetNextState("FORMING");
 		},
 
 		// Only used by other orders to walk there in formation
 		"Order.WalkToTargetRange": function(msg) {
 			if (!this.CheckTargetRangeExplicit(this.order.data.target, this.order.data.min, this.order.data.max))
 				this.SetNextState("WALKING");
 			else
 				this.FinishOrder();
 		},
 
 		"Order.WalkToTarget": function(msg) {
 			if (!this.CheckTargetRangeExplicit(this.order.data.target, 0, 0))
 				this.SetNextState("WALKING");
 			else
 				this.FinishOrder();
 		},
 
 		"Order.WalkToPointRange": function(msg) {
 			if (!this.CheckPointRangeExplicit(this.order.data.x, this.order.data.z, this.order.data.min, this.order.data.max))
 				this.SetNextState("WALKING");
 			else
 				this.FinishOrder();
 		},
 
 		"Order.Patrol": function(msg) {
 			this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 			this.SetNextState("PATROL");
 		},
 
 		"Order.Guard": function(msg) {
 			this.CallMemberFunction("Guard", [msg.data.target, false]);
 			var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 			cmpFormation.Disband();
 		},
 
 		"Order.Stop": function(msg) {
 			if (!this.IsAttackingAsFormation())
 				this.CallMemberFunction("Stop", [false]);
 			this.StopMoving();
 			this.FinishOrder();
 		},
 
 		"Order.Attack": function(msg) {
 			var target = msg.data.target;
 			var allowCapture = msg.data.allowCapture;
 			var cmpTargetUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 			if (cmpTargetUnitAI && cmpTargetUnitAI.IsFormationMember())
 				target = cmpTargetUnitAI.GetFormationController();
 
 			var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 			// Check if we are already in range, otherwise walk there
 			if (!this.CheckTargetAttackRange(target, target))
 			{
 				if (this.TargetIsAlive(target) && this.CheckTargetVisible(target))
 				{
 					this.SetNextState("COMBAT.APPROACHING");
 					return;
 				}
 				this.FinishOrder();
 				return;
 			}
 			this.CallMemberFunction("Attack", [target, allowCapture, false]);
 			if (cmpAttack.CanAttackAsFormation())
 				this.SetNextState("COMBAT.ATTACKING");
 			else
 				this.SetNextState("MEMBER");
 		},
 
 		"Order.Garrison": function(msg) {
 			if (!Engine.QueryInterface(msg.data.target, IID_GarrisonHolder))
 			{
 				this.FinishOrder();
 				return;
 			}
 			// Check if we are already in range, otherwise walk there
 			if (!this.CheckGarrisonRange(msg.data.target))
 			{
 				if (!this.CheckTargetVisible(msg.data.target))
 				{
 					this.FinishOrder();
 					return;
 				}
 				else
 				{
 					this.SetNextState("GARRISON.APPROACHING");
 					return;
 				}
 			}
 
 			this.SetNextState("GARRISON.GARRISONING");
 		},
 
 		"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);
 					}
 					else
 					{
 						// We couldn't move there, or the target moved away
 						this.FinishOrder();
 					}
 					return;
 				}
 
 				this.PushOrderFront("Attack", { "target": msg.data.target, "force": !!msg.data.force, "hunting": true, "allowCapture": false });
 				return;
 			}
 
 			// TODO: on what should we base this range?
 			// Check if we are already in range, otherwise walk there
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.CanGather(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
 					// The target isn't gatherable or not visible any more.
 					this.FinishOrder();
 				// TODO: Should we issue a gather-near-position order
 				// if the target isn't gatherable/doesn't exist anymore?
 				else
 					// Out of range; move there in formation
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 				return;
 			}
 
 			this.CallMemberFunction("Gather", [msg.data.target, false]);
 
 			this.SetNextState("MEMBER");
 		},
 
 		"Order.GatherNearPosition": function(msg) {
 			// TODO: on what should we base this range?
 			// Check if we are already in range, otherwise walk there
 			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;
 			}
 
 			this.CallMemberFunction("GatherNearPosition", [msg.data.x, msg.data.z, msg.data.type, msg.data.template, false]);
 
 			this.SetNextState("MEMBER");
 		},
 
 		"Order.Heal": function(msg) {
 			// TODO: on what should we base this range?
 			// Check if we are already in range, otherwise walk there
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.TargetIsAlive(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
 					// The target was destroyed
 					this.FinishOrder();
 				else
 					// Out of range; move there in formation
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 				return;
 			}
 
 			this.CallMemberFunction("Heal", [msg.data.target, false]);
 
 			this.SetNextState("MEMBER");
 		},
 
 		"Order.Repair": function(msg) {
 			// TODO: on what should we base this range?
 			// Check if we are already in range, otherwise walk there
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.TargetIsAlive(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
 					// The building was finished or destroyed
 					this.FinishOrder();
 				else
 					// Out of range move there in formation
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 				return;
 			}
 
 			this.CallMemberFunction("Repair", [msg.data.target, msg.data.autocontinue, false]);
 
 			this.SetNextState("MEMBER");
 		},
 
 		"Order.ReturnResource": function(msg) {
 			// TODO: on what should we base this range?
 			// Check if we are already in range, otherwise walk there
 			if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
 			{
 				if (!this.TargetIsAlive(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
 					// The target was destroyed
 					this.FinishOrder();
 				else
 					// Out of range; move there in formation
 					this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
 				return;
 			}
 
 			this.CallMemberFunction("ReturnResource", [msg.data.target, false]);
 
 			this.SetNextState("MEMBER");
 		},
 
 		"Order.Pack": function(msg) {
 			this.CallMemberFunction("Pack", [false]);
 
 			this.SetNextState("MEMBER");
 		},
 
 		"Order.Unpack": function(msg) {
 			this.CallMemberFunction("Unpack", [false]);
 
 			this.SetNextState("MEMBER");
 		},
 
 		"IDLE": {
 			"enter": function(msg) {
 				var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(false);
 			},
 		},
 
 		"WALKING": {
 			"enter": function() {
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(true);
 				cmpFormation.MoveMembersIntoFormation(true, true);
 			},
 
 			"leave": function() {
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (this.CheckRange(this.order.data) && this.FinishOrder())
 					this.CallMemberFunction("ResetFinishOrder", []);
 			},
 		},
 
 		"WALKINGANDFIGHTING": {
 			"enter": function(msg) {
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				this.StartTimer(0, 1000);
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(true);
 				cmpFormation.MoveMembersIntoFormation(true, true);
 			},
 
 			"leave": function() {
 				this.StopMoving();
 				this.StopTimer();
 			},
 
 			"Timer": function(msg) {
 				// check if there are no enemies to attack
 				this.FindWalkAndFightTargets();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (this.CheckRange(this.order.data) && this.FinishOrder())
 					this.CallMemberFunction("ResetFinishOrder", []);
 			},
 		},
 
 		"PATROL": {
 			"enter": function(msg) {
 				// Memorize the origin position in case that we want to go back
 				let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 				if (!cmpPosition || !cmpPosition.IsInWorld())
 				{
 					this.FinishOrder();
 					return;
 				}
 				if (!this.patrolStartPosOrder)
 				{
 					this.patrolStartPosOrder = cmpPosition.GetPosition();
 					this.patrolStartPosOrder.targetClasses = this.order.data.targetClasses;
 					this.patrolStartPosOrder.allowCapture = this.order.data.allowCapture;
 				}
 
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				this.StartTimer(0, 1000);
 
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(true);
 				cmpFormation.MoveMembersIntoFormation(true, true);
 			},
 
 			"Timer": function(msg) {
 				// Check if there are no enemies to attack
 				this.FindWalkAndFightTargets();
 			},
 
 			"leave": function(msg) {
 				this.StopTimer();
 				this.StopMoving();
 				delete this.patrolStartPosOrder;
 			},
 
 			"MovementUpdate": function(msg) {
 				if (!msg.error && !this.CheckRange(this.order.data))
 					return;
 				/**
 				 * A-B-A-B-..:
 				 * if the user only commands one patrol order, the patrol will be between
 				 * the last position and the defined waypoint
 				 * A-B-C-..-A-B-..:
 				 * otherwise, the patrol is only between the given patrol commands and the
 				 * last position is not included (last position = the position where the unit
 				 * is located at the time of the first patrol order)
 				 */
 
 				if (this.orderQueue.length == 1)
 					this.PushOrder("Patrol", this.patrolStartPosOrder);
 
 				this.PushOrder(this.order.type, this.order.data);
 				this.FinishOrder();
 			},
 		},
 
 		"GARRISON":{
 			"enter": function() {
 				// If the garrisonholder should pickup, warn it so it can take needed action
 				var 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 });
 				}
 			},
 
 			"leave": function() {
 				// If a pickup has been requested and not yet canceled, cancel it
 				if (this.pickup)
 				{
 					Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
 					delete this.pickup;
 				}
 			},
 
 
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveToGarrisonRange(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					cmpFormation.SetRearrange(true);
 					cmpFormation.MoveMembersIntoFormation(true, true);
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					this.SetNextState("GARRISONING");
 				},
 			},
 
 			"GARRISONING": {
 				"enter": function() {
 					// If a pickup has been requested, cancel it as it will be requested by members
 					if (this.pickup)
 					{
 						Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
 						delete this.pickup;
 					}
 					this.CallMemberFunction("Garrison", [this.order.data.target, false]);
 					this.SetNextState("MEMBER");
 				},
 			},
 		},
 
 		"FORMING": {
 			"enter": function() {
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(true);
 				cmpFormation.MoveMembersIntoFormation(true, true);
 			},
 
 			"leave": function() {
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (!msg.error && !this.CheckRange(this.order.data))
 					return;
 
 				if (this.FinishOrder())
 				{
 					this.CallMemberFunction("ResetFinishOrder", []);
 					return;
 				}
 				var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 
 				cmpFormation.FindInPosition();
 			}
 		},
 
 		"COMBAT": {
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveTo(this.order.data))
 					{
 						this.FinishOrder();
 						return true;
 					}
 					let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					cmpFormation.SetRearrange(true);
 					cmpFormation.MoveMembersIntoFormation(true, true);
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 					this.CallMemberFunction("Attack", [this.order.data.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) {
 					var target = this.order.data.target;
 					var allowCapture = this.order.data.allowCapture;
 					// Check if we are already in range, otherwise walk there
 					if (!this.CheckTargetAttackRange(target, target))
 					{
 						if (this.TargetIsAlive(target) && this.CheckTargetVisible(target))
 						{
 							this.FinishOrder();
 							this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": allowCapture });
 							return true;
 						}
 						this.FinishOrder();
 						return true;
 					}
 
 					var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					// TODO fix the rearranging while attacking as formation
 					cmpFormation.SetRearrange(!this.IsAttackingAsFormation());
 					cmpFormation.MoveMembersIntoFormation(false, false);
 					this.StartTimer(200, 200);
 					return false;
 				},
 
 				"Timer": function(msg) {
 					var target = this.order.data.target;
 					var allowCapture = this.order.data.allowCapture;
 					// Check if we are already in range, otherwise walk there
 					if (!this.CheckTargetAttackRange(target, target))
 					{
 						if (this.TargetIsAlive(target) && this.CheckTargetVisible(target))
 						{
 							this.FinishOrder();
 							this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": allowCapture });
 							return;
 						}
 						this.FinishOrder();
 						return;
 					}
 				},
 
 				"leave": function(msg) {
 					this.StopTimer();
 					var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 					if (cmpFormation)
 						cmpFormation.SetRearrange(true);
 				},
 			},
 		},
 
 		"MEMBER": {
 			// Wait for individual members to finish
 			"enter": function(msg) {
 				var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.SetRearrange(false);
 				this.StopMoving();
 				this.StartTimer(1000, 1000);
 			},
 
 			"Timer": function(msg) {
 				// Have all members finished the task?
 				if (!this.TestAllMemberFunction("HasFinishedOrder", []))
 					return;
 
 				this.CallMemberFunction("ResetFinishOrder", []);
 
 				// Execute the next order
 				if (this.FinishOrder())
 				{
 					// if WalkAndFight order, look for new target before moving again
 					if (this.IsWalkingAndFighting())
 						this.FindWalkAndFightTargets();
 					return;
 				}
 			},
 
 			"leave": function(msg) {
 				this.StopTimer();
 				let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 				cmpFormation.MoveToMembersCenter();
 			},
 		},
 	},
 
 
 	// States for entities moving as part of a formation:
 	"FORMATIONMEMBER": {
 		"FormationLeave": function(msg) {
 			// We're not in a formation anymore, so no need to track this.
 			this.finishedOrder = false;
 
 			// Stop moving as soon as the formation disbands
 			this.StopMoving();
 
 			// 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;
 			}
 
 			// No orders left, we're an individual now
 			if (this.IsAnimal())
 				this.SetNextState("ANIMAL.IDLE");
 			else
 				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 foundation is not ally of entity, or if entity is unpacked siege,
 			// ignore the order
 			if (!IsOwnedByAllyOfEntity(this.entity, msg.data.target) && !Engine.QueryInterface(SYSTEM_ENTITY, IID_CeasefireManager).IsCeasefireActive() ||
 				this.IsPacking() || this.CanPack() || this.IsTurret())
 			{
 				this.FinishOrder();
 				return;
 			}
 			// Move a tile outside the building
 			let range = 4;
 			if (this.CheckTargetRangeExplicit(msg.data.target, range, -1))
 			{
 				// We are already at the target, or can't move at all
 				this.FinishOrder();
 			}
 			else
 			{
 				this.order.data.min = range;
 				this.SetNextState("WALKINGTOPOINT");
 			}
 		},
 
 		"enter": function() {
 			let cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 			if (cmpFormation)
 				this.SetAnimationVariant(cmpFormation.GetFormationAnimation(this.entity));
 		},
 
 		"leave": function() {
 			this.SetDefaultAnimationVariant();
 		},
 
 		"IDLE": {
 			"enter": function() {
 				if (this.IsAnimal())
 					this.SetNextState("ANIMAL.IDLE");
 				else
 					this.SetNextState("INDIVIDUAL.IDLE");
 				return true;
 			},
 		},
 
 		"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);
-
-				this.SelectAnimation("move");
 			},
 
 			// Occurs when the unit has reached its destination and the controller
 			// is done moving. The controller is notified.
 			"MovementUpdate": function(msg) {
 				// We can only finish this order if the move was really completed.
 				if (!this.CheckRange(this.order.data) || msg.error)
 					return;
 
 				if (this.FinishOrder())
 					return;
 
 				let cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 				if (cmpFormation)
 					cmpFormation.SetInPosition(this.entity);
 			},
 		},
 
 		// Special case used by Order.LeaveFoundation
 		"WALKINGTOPOINT": {
 			"enter": function() {
 				var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 				if (cmpFormation)
 					cmpFormation.UnsetInPosition(this.entity);
+
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
-				this.SelectAnimation("move");
 			},
 
 			"MovementUpdate": function() {
 				if (!this.CheckRange(this.order.data))
 					return;
 				this.StopMoving();
 				this.FinishOrder();
 			},
 		},
 	},
 
 
 	// States for entities not part of a formation:
 	"INDIVIDUAL": {
 
 		"enter": function() {
 			// Sanity-checking
 			if (this.IsAnimal())
 				error("Animal got moved into INDIVIDUAL.* state");
 		},
 
 		"Attacked": function(msg) {
 			// Respond to attack if we always target attackers or during unforced orders
 			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.TargetIsAlive(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;
 			}
 
 			// if the attacker is a building and we can repair the guarded, repair it rather than attacking
 			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;
 			}
 
 			// target the unit
 			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": {
 			"enter": function() {
 				// Switch back to idle animation to guarantee we won't
 				// get stuck with an incorrect animation
 				var animationName = "idle";
 				if (this.IsFormationMember())
 				{
 					var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 					if (cmpFormation)
 						animationName = cmpFormation.GetFormationAnimation(this.entity, animationName);
 				}
 				this.SelectAnimation(animationName);
 
 				// If we have some orders, it is because we are in an intermediary state
 				// from FinishOrder (SetNextState("IDLE") is only executed when we get
 				// a ProcessMessage), and thus we should not start another order which could
 				// put us in a weird state
 				if (this.orderQueue.length > 0 && !this.IsGarrisoned())
 					return false;
 
 				// If the unit is guarding/escorting, go back to its duty
 				if (this.isGuardOf)
 				{
 					this.Guard(this.isGuardOf, false);
 					return true;
 				}
 
 				// The GUI and AI want to know when a unit is idle, but we don't
 				// want to send frequent spurious messages if the unit's only
 				// idle for an instant and will quickly go off and do something else.
 				// So we'll set a timer here and only report the idle event if we
 				// remain idle
 				this.StartTimer(1000);
 
 				// 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 true; // (abort the FSM transition since we may have already switched state)
 
 				// 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 LosRangeUpdate.)
 				if (this.FindNewTargets())
 					return true; // (abort the FSM transition since we may have already switched state)
 
 				// Nobody to attack - stay in idle
 				return false;
 			},
 
 			"leave": function() {
 				var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 				if (this.losRangeQuery)
 					cmpRangeManager.DisableActiveQuery(this.losRangeQuery);
 				if (this.losHealRangeQuery)
 					cmpRangeManager.DisableActiveQuery(this.losHealRangeQuery);
 
 				this.StopTimer();
 
 				if (this.isIdle)
 				{
 					this.isIdle = false;
 					Engine.PostMessage(this.entity, MT_UnitIdleChanged, { "idle": this.isIdle });
 				}
 			},
 
 			"LosRangeUpdate": function(msg) {
 				if (this.GetStance().targetVisibleEnemies)
 				{
 					// Start attacking one of the newly-seen enemy (if any)
 					this.AttackEntitiesByPreference(msg.data.added);
 				}
 			},
 
 			"LosHealRangeUpdate": function(msg) {
 				this.RespondToHealableEntities(msg.data.added);
 			},
 
-			"MoveCompleted": function() {
-				this.SelectAnimation("idle");
-			},
-
 			"Timer": function(msg) {
 				if (!this.isIdle)
 				{
 					this.isIdle = true;
 					Engine.PostMessage(this.entity, MT_UnitIdleChanged, { "idle": this.isIdle });
 				}
 			},
 		},
 
 		"WALKING": {
 			"enter": function() {
 				if (!this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
-				this.SelectAnimation("move");
 			},
 
 			"leave": function () {
-				this.SelectAnimation("idle");
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function() {
 				if (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);
-				this.SelectAnimation("move");
 			},
 
 			"Timer": function(msg) {
 				this.FindWalkAndFightTargets();
 			},
 
 			"leave": function(msg) {
 				this.StopMoving();
 				this.StopTimer();
 				this.SetDefaultAnimationVariant();
 			},
 
 			"MovementUpdate": function() {
 				if (this.CheckRange(this.order.data))
 					this.FinishOrder();
 			},
 		},
 
 		"PATROL": {
 			"enter": function() {
 				// Memorize the origin position in case that we want to go back
 				let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 				if (!cmpPosition || !cmpPosition.IsInWorld() ||
 				    !this.MoveTo(this.order.data))
 				{
 					this.FinishOrder();
 					return true;
 				}
 
 				if (!this.patrolStartPosOrder)
 				{
 					this.patrolStartPosOrder = cmpPosition.GetPosition();
 					this.patrolStartPosOrder.targetClasses = this.order.data.targetClasses;
 					this.patrolStartPosOrder.allowCapture = this.order.data.allowCapture;
 				}
 
 				this.StartTimer(0, 1000);
 				this.SetAnimationVariant("combat");
-				this.SelectAnimation("move");
 			},
 
 			"leave": function() {
 				this.StopMoving();
 				this.StopTimer();
 				delete this.patrolStartPosOrder;
 				this.SetDefaultAnimationVariant();
 			},
 
 			"Timer": function(msg) {
 				this.FindWalkAndFightTargets();
 			},
 
 			"MovementUpdate": function(msg) {
 				if (!msg.error && !this.CheckRange(this.order.data))
 					return;
 
 				if (this.orderQueue.length == 1)
 					this.PushOrder("Patrol", this.patrolStartPosOrder);
 
 				this.PushOrder(this.order.type, this.order.data);
 				this.FinishOrder();
 			},
 		},
 
 		"GUARD": {
 			"RemoveGuard": function() {
 				this.StopMoving();
 				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.SelectAnimation("move");
 					this.SetHeldPositionOnEntity(this.isGuardOf);
 					return false;
 				},
 
 				"Timer": function(msg) {
 					// Check the target is alive
 					if (!this.TargetIsAlive(this.isGuardOf))
 					{
 						this.FinishOrder();
 						return;
 					}
 
 					// Adapt the speed to the one of the target if needed
 					let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 					if (cmpObstructionManager.IsInTargetRange(this.entity, this.isGuardOf, 0, 3 * this.guardRange, false))
 					{
 						let cmpUnitAI = Engine.QueryInterface(this.isGuardOf, IID_UnitAI);
 						if (cmpUnitAI)
 						{
 							let speed = cmpUnitAI.GetWalkSpeed();
 							if (speed < this.GetWalkSpeed())
 								this.SetSpeedMultiplier(speed / this.GetWalkSpeed());
 						}
 					}
 
 					this.SetHeldPositionOnEntity(this.isGuardOf);
 				},
 
 				"leave": function(msg) {
 					this.StopMoving();
 					this.ResetSpeedMultiplier();
 					this.StopTimer();
 					this.SetDefaultAnimationVariant();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.error || this.CheckTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
 						this.SetNextState("GUARDING");
 				},
 			},
 
 			"GUARDING": {
 				"enter": function() {
 					this.StopMoving();
 					this.StartTimer(1000, 1000);
 					this.SetHeldPositionOnEntity(this.entity);
 					this.SetAnimationVariant("combat");
-					this.SelectAnimation("idle");
 					return false;
 				},
 
 				"LosRangeUpdate": function(msg) {
 					// Start attacking one of the newly-seen enemy (if any)
 					if (this.GetStance().targetVisibleEnemies)
 						this.AttackEntitiesByPreference(msg.data.added);
 				},
 
 				"Timer": function(msg) {
 					// Check the target is alive
 					if (!this.TargetIsAlive(this.isGuardOf))
 					{
 						this.FinishOrder();
 						return;
 					}
 					// Then check is the target has moved and try following it.
 					// 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
 					{
 						// if nothing better to do, check if the guarded needs to be healed or repaired
 						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 = 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");
 
 				// Run quickly
-				this.SelectAnimation("move");
 				this.SetSpeedMultiplier(this.GetRunMultiplier());
 			},
 
 			"HealthChanged": function() {
 				this.SetSpeedMultiplier(this.GetRunMultiplier());
 			},
 
 			"leave": function() {
 				this.ResetSpeedMultiplier();
 				this.StopMoving();
 			},
 
 			"MovementUpdate": function(msg) {
 				// When we've run far enough, stop fleeing
 				if (msg.error || this.CheckTargetRangeExplicit(this.order.data.target, this.order.data.distanceToFlee, -1))
 					this.FinishOrder();
 			},
 
 			// TODO: what if we run into more enemies while fleeing?
 		},
 
 		"COMBAT": {
 			"Order.LeaveFoundation": function(msg) {
 				// Ignore the order as we're busy.
 				return { "discardOrder": true };
 			},
 
 			"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]);
 			},
 
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					// Show weapons rather than carried resources.
 					this.SetAnimationVariant("combat");
 
-					this.SelectAnimation("move");
 					this.StartTimer(1000, 1000);
 				},
 
 				"leave": function() {
 					// Show carried resources when walking.
 					this.SetDefaultAnimationVariant();
 					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.StopMoving();
 						this.FinishOrder();
 
 						// Return to our original position
 						if (this.GetStance().respondHoldGround)
 							this.WalkToHeldPosition();
 					}
 					else
 						this.RememberTargetPosition();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (msg.error)
 					{
 						// This also handles hunting.
 						if (this.orderQueue.length > 1)
 						{
 							this.FinishOrder();
 							return;
 						}
 						else if (!this.order.data.force)
 						{
 							this.SetNextState("COMBAT.FINDINGNEWTARGET");
 							return;
 						}
 						// Go to the last known position and try to find enemies there.
 						let lastPos = this.order.data.lastPos;
 						this.PushOrder("Walk", { "x": lastPos.x, "z": lastPos.z, "force": false });
 						this.PushOrder("WalkAndFight", { "x": lastPos.x, "z": lastPos.z, "force": false });
 						return;
 					}
 
 					if (!this.CheckTargetAttackRange(this.order.data.target, this.order.data.attackType))
 					{
 						// 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();
 						return;
 					}
 
 					// If the unit needs to unpack, do so
 					if (this.CanUnpack())
 					{
 						this.PushOrderFront("Unpack", { "force": true });
 						return;
 					}
 					this.SetNextState("ATTACKING");
 				},
 			},
 
 			"ATTACKING": {
 				"enter": function() {
 					let target = this.order.data.target;
 					let cmpFormation = Engine.QueryInterface(target, IID_Formation);
 					// if the target is a formation, save the attacking formation, and pick a member
 					if (cmpFormation)
 					{
 						this.order.data.formationTarget = target;
 						target = cmpFormation.GetClosestMember(this.entity);
 						this.order.data.target = target;
 					}
 
 					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;
 					}
 
 					this.StopMoving();
 
 					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.IsFormationMember())
 						this.SetAnimationVariant("combat");
 
 					this.oldAttackType = this.order.data.attackType;
 					// add prefix + no capital first letter for 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);
 				},
 
 				"leave": function() {
 					let cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
 					if (cmpBuildingAI)
 						cmpBuildingAI.SetUnitAITarget(0);
 					this.StopTimer();
 					this.SetDefaultAnimationVariant();
+					this.ResetAnimation();
 				},
 
 				"Timer": function(msg) {
 					let target = this.order.data.target;
 					let cmpFormation = Engine.QueryInterface(target, IID_Formation);
 
 					// if the target is a formation, save the attacking formation, and pick a member
 					if (cmpFormation)
 					{
 						let thisObject = this;
 						let filter = function(t) {
 							return thisObject.CanAttack(t);
 						};
 						this.order.data.formationTarget = target;
 						target = cmpFormation.GetClosestMember(this.entity, filter);
 						this.order.data.target = target;
 					}
 
 					// Check the target is still alive and attackable
 					if (!this.CanAttack(target))
 					{
 						this.SetNextState("COMBAT.FINDINGNEWTARGET");
 						return;
 					}
 
 					this.RememberTargetPosition();
 
 					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(this.order.data.attackType, target);
 					}
 
 					// Check we can still reach the target for the next attack
 					if (this.CheckTargetAttackRange(target, this.order.data.attackType))
 					{
 						if (this.resyncAnimation)
 						{
 							this.SetAnimationSync(this.attackTimers.repeat, this.attackTimers.repeat);
 							this.resyncAnimation = false;
 						}
 						return;
 					}
 
 					// Can't reach it - try to chase after it
 					if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
 					{
 						if (this.CanPack())
 						{
 							this.PushOrderFront("Pack", { "force": true });
 							return;
 						}
 						this.SetNextState("COMBAT.CHASING");
 						return;
 					}
 				},
 
 				// TODO: respond to target deaths immediately, rather than waiting
 				// until the next Timer event
 
 				"Attacked": function(msg) {
 					// If we are capturing and are attacked by something that we would not capture, attack that entity instead
 					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": {
 				"enter": function() {
 					// If we're targetting a formation, find a new member of that formation.
 					let cmpTargetFormation = Engine.QueryInterface(this.order.data.formationTarget || INVALID_ENTITY, IID_Formation);
 					// if there is no target, it means previously searching for the target inside the target formation failed, so don't repeat the search
 					if (this.order.data.target && cmpTargetFormation)
 					{
 						this.order.data.target = this.order.data.formationTarget;
 						this.TimerHandler(msg.data, msg.lateness);
 						return;
 					}
 
 					// 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;
 					}
 
 					// See if we can switch to a new nearby enemy
 					if (this.FindNewTargets())
 						return true;
 
 					// Return to our original position
 					if (this.GetStance().respondHoldGround)
 						this.WalkToHeldPosition();
 
 					return true;
 				},
 			},
 
 			"CHASING": {
 				"enter": function() {
 					if (!this.MoveToTargetAttackRange(this.order.data.target, this.order.data.attackType))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					// Show weapons rather than carried resources.
 					this.SetAnimationVariant("combat");
 
-					this.SelectAnimation("move");
 					var cmpUnitAI = Engine.QueryInterface(this.order.data.target, IID_UnitAI);
 					if (cmpUnitAI && cmpUnitAI.IsFleeing())
 					{
 						// Run after a fleeing target
 						this.SetSpeedMultiplier(this.GetRunMultiplier());
 					}
 					this.StartTimer(1000, 1000);
 				},
 
 				"leave": function() {
 					this.ResetSpeedMultiplier();
 
 					// Show carried resources when walking.
 					this.SetDefaultAnimationVariant();
 					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.StopMoving();
 						this.FinishOrder();
 
 						// Return to our original position
 						if (this.GetStance().respondHoldGround)
 							this.WalkToHeldPosition();
 					}
 				},
 
 				"MovementUpdate": function() {
 					this.SetNextState("ATTACKING");
 				},
 			},
 		},
 
 		"GATHER": {
 			"APPROACHING": {
 				"enter": function() {
 					this.gatheringTarget = this.order.data.target;	// temporary, deleted in "leave".
 
 					// check that we can gather from the resource we're supposed to gather from.
 					var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 					var cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					var cmpMirage = Engine.QueryInterface(this.gatheringTarget, IID_Mirage);
 					if ((!cmpMirage || !cmpMirage.Mirages(IID_ResourceSupply)) &&
 					    (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity)) ||
 					    !this.MoveTo(this.order.data, IID_ResourceGatherer))
 					{
 						// The GATHERING timer will handle finding a valid resource.
 						this.SetNextState("GATHERING");
 						return true;
 					}
-
-					this.SelectAnimation("move");
 					return false;
 				},
 
 				"MovementUpdate": function(msg) {
 					// The GATHERING timer will handle finding a valid resource.
 					this.SetNextState("GATHERING");
 				},
 
 				"leave": function() {
 					this.StopMoving();
 
 					this.SetDefaultAnimationVariant();
 					if (!this.gatheringTarget)
 						return;
 					// don't use ownership because this is called after a conversion/resignation
 					// and the ownership would be invalid then.
 					var cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					if (cmpSupply)
 						cmpSupply.RemoveGatherer(this.entity);
 					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.SelectAnimation("move");
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					// If we failed, the GATHERING timer will handle finding a valid resource.
 					if (msg.error || 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 cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 					let cmpSupply;
 					if (cmpOwnership)
 						cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					if (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity))
 					{
 						this.StartTimer(0);
 						return false;
 					}
 
 					// 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.
 					var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					var 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))
 						{
 							// Let the Timer logic handle this
 							this.StartTimer(0);
 							return false;
 						}
 
 						// 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.
 					var offset = 1000/rate;
 					var repeat = offset;
 					this.StartTimer(offset, repeat);
 
 					// 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.StopMoving();
 						this.SetDefaultAnimationVariant();
 						var typename = "gather_" + this.order.data.type.specific;
 						this.SelectAnimation(typename);
 					}
 					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.
 					var cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					if (cmpSupply)
 						cmpSupply.RemoveGatherer(this.entity);
 					delete this.gatheringTarget;
 
 					// Show the carried resource, if we've gathered anything.
+					this.ResetAnimation();
 					this.SetDefaultAnimationVariant();
 				},
 
 				"Timer": function(msg) {
 					let resourceTemplate = this.order.data.template;
 					let resourceType = this.order.data.type;
 
 					let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 					if (!cmpOwnership)
 						return;
 
 					let cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
 					if (cmpSupply && cmpSupply.IsAvailable(cmpOwnership.GetOwner(), this.entity))
 						// Check we can still reach and gather from the target
 						if (this.CheckTargetRange(this.gatheringTarget, IID_ResourceGatherer) && this.CanGather(this.gatheringTarget))
 						{
 							// Gather the resources:
 
 							let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 
 							// Try to gather treasure
 							if (cmpResourceGatherer.TryInstantGather(this.gatheringTarget))
 								return;
 
 							// 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();
 
 							// Collect from the target
 							let status = cmpResourceGatherer.PerformGather(this.gatheringTarget);
 
 							// If we've collected as many resources as possible,
 							// return to the nearest dropsite
 							if (status.filled)
 							{
 								let nearby = this.FindNearestDropsite(resourceType.generic);
 								if (nearby)
 								{
 									// (Keep this Gather order on the stack so we'll
 									// continue gathering after returning)
 									this.PushOrderFront("ReturnResource", { "target": nearby, "force": false });
 									return;
 								}
 
 								// Oh no, couldn't find any drop sites. Give up on gathering.
 								this.FinishOrder();
 								return;
 							}
 
 							// We can gather more from this target, do so in the next timer
 							if (!status.exhausted)
 								return;
 						}
 						else
 						{
 							// Try to follow the target
 							if (this.MoveToTargetRange(this.gatheringTarget, IID_ResourceGatherer))
 							{
 								this.SetNextState("APPROACHING");
 								return;
 							}
 
 							// Our target is no longer visible - go to its last known position first
 							// and then hopefully it will become visible.
 							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
 								});
 								return;
 							}
 						}
 
 					// We're already in range, can't get anywhere near it or the target is exhausted.
 
 					// 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 nearby = this.FindNearestDropsite(resourceType.generic);
 						if (nearby)
 							this.orderQueue.splice(1, 0, { "type": "ReturnResource", "data": { "target": nearby, "force": false } });
 					}
 
 					// Must go before FinishOrder or this.order will be undefined.
 					let initPos = this.order.data.initPos;
 
 					if (this.FinishOrder())
 						return;
 
 					// No remaining orders - pick a useful default behaviour
 
 					if (!initPos)
 					{
 						let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 						if (cmpPosition && cmpPosition.IsInWorld())
 						{
 							let pos = cmpPosition.GetPosition();
 							initPos = { 'x': pos.X, 'z': pos.Z };
 						}
 					}
 
 					if (initPos)
 					{
 						// Try to find a new resource of the same specific type near the initial resource position:
 						// Also don't switch to a different type of huntable animal
 						let nearby = this.FindNearbyResource(function(ent, type, template) {
 							return (
 								(type.generic == "treasure" && resourceType.generic == "treasure") ||
 								(type.specific == resourceType.specific &&
 									(type.specific != "meat" || resourceTemplate == template))
 							);
 						}, new Vector2D(initPos.x, initPos.z));
 
 						if (nearby)
 						{
 							this.PerformGather(nearby, false, false);
 							return;
 						}
 
 						// 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;
 						}
 					}
 
 					// 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 nearby = this.FindNearestDropsite(resourceType.generic);
 					if (nearby)
 					{
 						this.PushOrderFront("ReturnResource", { "target": nearby, "force": false });
 						return;
 					}
 
 					// No dropsites - just give up
 				},
 			},
 		},
 
 		"HEAL": {
 			"Attacked": function(msg) {
 				// If we stand ground we will rather die than flee
 				if (!this.GetStance().respondStandGround && !this.order.data.force)
 					this.Flee(msg.data.attacker, false);
 			},
 
 			"APPROACHING": {
 				"enter": function() {
 					if (this.CheckTargetRange(this.order.data.target, IID_Heal))
 					{
 						this.SetNextState("HEALING");
 						return true;
 					}
 
 					if (!this.MoveTo(this.order.data, IID_Heal))
 					{
 						this.FinishOrder();
 						return true;
 					}
 
-					this.SelectAnimation("move");
 					this.StartTimer(1000, 1000);
 				},
 
 				"leave": function() {
 					this.StopMoving();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Heal, null))
 					{
 						// Return to our original position unless we have a better order.
 						if (!this.FinishOrder() && this.GetStance().respondHoldGround)
 							this.WalkToHeldPosition();
 					}
 				},
 
 				"MovementUpdate": function() {
 					this.SetNextState("HEALING");
 				},
 			},
 
 			"HEALING": {
 				"enter": function() {
 					var 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.StopMoving();
 
 					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) ? true : false;
 
 					this.FaceTowardsTarget(this.order.data.target);
 				},
 
 				"leave": function() {
+					this.ResetAnimation();
 					this.StopTimer();
 				},
 
 				"Timer": function(msg) {
 					var target = this.order.data.target;
 					// Check the target is still alive and healable
 					if (this.TargetIsAlive(target) && this.CanHeal(target))
 					{
 						// Check if we can still reach the target
 						if (this.CheckTargetRange(target, IID_Heal))
 						{
 							var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 							this.lastHealed = cmpTimer.GetTime() - msg.lateness;
 
 							this.FaceTowardsTarget(target);
 							var cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
 							cmpHeal.PerformHeal(target);
 
 							if (this.resyncAnimation)
 							{
 								this.SetAnimationSync(this.healTimers.repeat, this.healTimers.repeat);
 								this.resyncAnimation = false;
 							}
 							return;
 						}
 						// Can't reach it - try to chase after it
 						if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
 						{
 							if (this.CanPack())
 							{
 								this.PushOrderFront("Pack", { "force": true });
 								return;
 							}
 							this.SetNextState("HEAL.APPROACHING");
 						}
 					}
 					// Can't reach it, healed to max hp or doesn't exist any more - give up
 					if (this.FinishOrder())
 						return;
 
 					// Heal another one
 					if (this.FindNewHealTargets())
 						return;
 
 					// Return to our original position
 					if (this.GetStance().respondHoldGround)
 						this.WalkToHeldPosition();
 				},
 			},
 		},
 
 		// Returning to dropsite
 		"RETURNRESOURCE": {
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveTo(this.order.data, IID_ResourceGatherer))
 					{
 						this.FinishOrder();
 						return true;
 					}
-					this.SelectAnimation("move");
 				},
 
 				"leave": function() {
-					// Switch back to idle animation to guarantee we won't
-					// get stuck with the carry animation after stopping moving
-					this.SelectAnimation("idle");
+					this.StopMoving();
 				},
 
 				"MovementUpdate": function() {
 					// Check the dropsite is in range and we can return our resource there
 					// (we didn't get stopped before reaching it)
 					if (this.CheckTargetRange(this.order.data.target, IID_ResourceGatherer) && this.CanReturnResource(this.order.data.target, true))
 					{
 						var cmpResourceDropsite = Engine.QueryInterface(this.order.data.target, IID_ResourceDropsite);
 						if (cmpResourceDropsite)
 						{
 							// Dump any resources we can
 							var dropsiteTypes = cmpResourceDropsite.GetTypes();
 
 							var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 							cmpResourceGatherer.CommitResources(dropsiteTypes);
 
 							// 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;
 						}
 					}
 
 					// The dropsite was destroyed, or we couldn't reach it, or ownership changed
 					// Look for a new one.
 
 					var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 					var genericType = cmpResourceGatherer.GetMainCarryingType();
 					var 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();
 				},
 			},
 		},
 
 		"TRADE": {
 			"Attacked": function(msg) {
 				// Ignore attack
 				// TODO: Inform player
 			},
 
 			"APPROACHINGMARKET": {
 				"enter": function() {
 					if (!this.MoveToMarket(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
-					this.SelectAnimation("move");
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function(msg) {
 					if (!msg.error && !this.CheckTargetRange(this.order.data.target, 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;
 					}
-					this.SelectAnimation("move");
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function() {
 					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;
 
 					this.repairTarget = this.order.data.target;	// temporary, deleted in "leave".
 					// Check we can still reach and repair the target
 					if (!this.CanRepair(this.repairTarget))
 					{
 						// Can't reach it, no longer owned by ally, or it doesn't exist any more
 						this.FinishOrder();
 						return true;
 					}
 
 					if (!this.CheckTargetRange(this.repairTarget, IID_Builder))
 					{
 						this.SetNextState("APPROACHING");
 						return true;
 					}
 					// Check if the target is still repairable
 					var 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.OnGlobalConstructionFinished({"entity": this.repairTarget, "newentity": this.repairTarget});
 						return true;
 					}
 
 					this.StopMoving();
 
 					let cmpBuilderList = QueryBuilderListInterface(this.repairTarget);
 					if (cmpBuilderList)
 						cmpBuilderList.AddBuilder(this.entity);
 
 					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) {
 					// Check we can still reach and repair the target
 					if (!this.CanRepair(this.repairTarget))
 					{
 						// No longer owned by ally, or it doesn't exist any more
 						this.FinishOrder();
 						return;
 					}
 
 					var 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
 
 				// Save the current order's data in case we need it later
 				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();
 
 				// Drop any resource we can if we are in range when the construction finishes
 				let cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 				let cmpResourceDropsite = Engine.QueryInterface(msg.data.newentity, IID_ResourceDropsite);
 				if (cmpResourceGatherer && cmpResourceDropsite && this.CheckTargetRange(msg.data.newentity, IID_Builder) &&
 					this.CanReturnResource(msg.data.newentity, true))
 				{
 					let dropsiteTypes = cmpResourceDropsite.GetTypes();
 					cmpResourceGatherer.CommitResources(dropsiteTypes);
 					this.SetDefaultAnimationVariant();
 				}
 
 				// We finished building it.
 				// Switch to the next order (if any)
 				if (this.FinishOrder())
 				{
 					if (this.CanReturnResource(msg.data.newentity, true))
 					{
 						this.SetDefaultAnimationVariant();
 						this.PushOrderFront("ReturnResource", { "target": msg.data.newentity, "force": false });
 					}
 					return;
 				}
 
 				// 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))
 				{
 					if (this.CanReturnResource(msg.data.newentity, true))
 					{
 						this.SetDefaultAnimationVariant();
 						this.PushOrder("ReturnResource", { "target": msg.data.newentity, "force": false });
 					}
 					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))
 				{
 					let types = cmpResourceDropsite.GetTypes();
 					let pos;
 					let cmpPosition = Engine.QueryInterface(msg.data.newentity, IID_Position);
 					if (cmpPosition && cmpPosition.IsInWorld())
 						pos = cmpPosition.GetPosition2D();
 
 					// 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(function(ent, type, template) {
 						return (types.indexOf(type.generic) != -1);
 					}, pos);
 
 					if (nearby)
 					{
 						this.PerformGather(nearby, true, false);
 						return;
 					}
 				}
 
 				// Look for a nearby foundation to help with
 				let nearbyFoundation = this.FindNearbyFoundation();
 				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 === "INDIVIDUAL.REPAIR.APPROACHING")
 					// We're already walking to the given point, so add this as a order.
 					this.WalkToTarget(msg.data.newentity, true);
 			},
 		},
 
 		"GARRISON": {
 			"enter": function() {
 				// If the garrisonholder should pickup, warn it so it can take needed action
 				var 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 });
 				}
 			},
 
 			"leave": function() {
 				// If a pickup has been requested and not yet canceled, cancel it
 				if (this.pickup)
 				{
 					Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
 					delete this.pickup;
 				}
 
 			},
 
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveToGarrisonRange(this.order.data.target))
 					{
 						this.FinishOrder();
 						return true;
 					}
-					this.SelectAnimation("move");
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function() {
 					this.SetNextState("GARRISONED");
 				},
 			},
 
 			"GARRISONED": {
 				"enter": function() {
 					let target = this.order.data.target;
 					if (!target)
 					{
 						this.FinishOrder();
 						return true;
 					}
 
 					if (this.IsGarrisoned())
 						return false;
 
 					// Check that we can garrison here
 					if (this.CanGarrison(target))
 						// Check that we're in range of the garrison target
 						if (this.CheckGarrisonRange(target))
 						{
 							var cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 							// Check that garrisoning succeeds
 							if (cmpGarrisonHolder.Garrison(this.entity))
 							{
 								this.isGarrisoned = true;
 
 								if (this.formationController)
 								{
 									var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
 									if (cmpFormation)
 									{
 										// disable rearrange for this removal,
 										// but enable it again for the next
 										// move command
 										var rearrange = cmpFormation.rearrange;
 										cmpFormation.SetRearrange(false);
 										cmpFormation.RemoveMembers([this.entity]);
 										cmpFormation.SetRearrange(rearrange);
 									}
 								}
 
 								// Check if we are garrisoned in a dropsite
 								var cmpResourceDropsite = Engine.QueryInterface(target, IID_ResourceDropsite);
 								if (cmpResourceDropsite && this.CanReturnResource(target, true))
 								{
 									// Dump any resources we can
 									var dropsiteTypes = cmpResourceDropsite.GetTypes();
 									var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 									if (cmpResourceGatherer)
 									{
 										cmpResourceGatherer.CommitResources(dropsiteTypes);
 										this.SetDefaultAnimationVariant();
 									}
 								}
 
 								// If a pickup has been requested, remove it
 								if (this.pickup)
 								{
 									var cmpHolderPosition = Engine.QueryInterface(target, IID_Position);
 									var cmpHolderUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 									if (cmpHolderUnitAI && cmpHolderPosition)
 										cmpHolderUnitAI.lastShorelinePosition = cmpHolderPosition.GetPosition();
 									Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
 									delete this.pickup;
 								}
 
 								if (this.IsTurret())
 								{
 									this.SetNextState("IDLE");
 									return true;
 								}
 
 								return false;
 							}
 						}
 						else
 						{
 							// Unable to reach the target, try again (or follow if it is a moving target)
 							// except if the does not exits anymore or its orders have changed
 							if (this.pickup)
 							{
 								var cmpUnitAI = Engine.QueryInterface(this.pickup, IID_UnitAI);
 								if (!cmpUnitAI || !cmpUnitAI.HasPickupOrder(this.entity))
 								{
 									this.FinishOrder();
 									return true;
 								}
 
 							}
 							this.SetNextState("APPROACHING");
 							return true;
 						}
 					// Garrisoning failed for some reason, so finish the order
 					this.FinishOrder();
 					return true;
 				},
 
 				"leave": function() {
 				}
 			},
 		},
 
 		"CHEERING": {
 			"enter": function() {
 				// Unit is invulnerable while cheering
 				var cmpDamageReceiver = Engine.QueryInterface(this.entity, IID_DamageReceiver);
 				cmpDamageReceiver.SetInvulnerability(true);
 				this.SelectAnimation("promotion");
 				this.StartTimer(2800, 2800);
 				return false;
 			},
 
 			"leave": function() {
 				this.StopTimer();
+				this.ResetAnimation();
 				var cmpDamageReceiver = Engine.QueryInterface(this.entity, IID_DamageReceiver);
 				cmpDamageReceiver.SetInvulnerability(false);
 			},
 
 			"Timer": function(msg) {
 				this.FinishOrder();
 			},
 		},
 
 		"PACKING": {
 			"enter": function() {
 				this.StopMoving();
 
 				var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 				cmpPack.Pack();
 			},
 
 			"PackFinished": function(msg) {
 				this.FinishOrder();
 			},
 
 			"leave": function() {
 			},
 
 			"Attacked": function(msg) {
 				// Ignore attacks while packing
 			},
 		},
 
 		"UNPACKING": {
 			"enter": function() {
 				this.StopMoving();
 
 				var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 				cmpPack.Unpack();
 			},
 
 			"PackFinished": function(msg) {
 				this.FinishOrder();
 			},
 
 			"leave": function() {
 			},
 
 			"Attacked": function(msg) {
 				// Ignore attacks while unpacking
 			},
 		},
 
 		"PICKUP": {
 			"APPROACHING": {
 				"enter": function() {
 					if (!this.MoveTo(this.order.data))
 					{
 						this.FinishOrder();
 						return true;
 					}
-					this.SelectAnimation("move");
 				},
 
 				"leave": function() {
 					this.StopMoving();
 				},
 
 				"MovementUpdate": function() {
 					this.SetNextState("LOADING");
 				},
 
 				"PickupCanceled": function() {
 					this.StopMoving();
 					this.FinishOrder();
 				},
 			},
 
 			"LOADING": {
 				"enter": function() {
 					this.StopMoving();
-					this.SelectAnimation("idle");
 					var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
 					if (!cmpGarrisonHolder || cmpGarrisonHolder.IsFull())
 					{
 						this.FinishOrder();
 						return true;
 					}
 					return false;
 				},
 
 				"PickupCanceled": function() {
 					this.FinishOrder();
 				},
 			},
 		},
 	},
 
 	"ANIMAL": {
 		"Attacked": function(msg) {
 			if (this.template.NaturalBehaviour == "skittish" ||
 			    this.template.NaturalBehaviour == "passive")
 			{
 				this.Flee(msg.data.attacker, false);
 			}
 			else if (this.IsDangerousAnimal() || this.template.NaturalBehaviour == "defensive")
 			{
 				if (this.CanAttack(msg.data.attacker))
 					this.Attack(msg.data.attacker, false);
 			}
 			else if (this.template.NaturalBehaviour == "domestic")
 			{
 				// Never flee, stop what we were doing
 				this.SetNextState("IDLE");
 			}
 		},
 
 		"Order.LeaveFoundation": function(msg) {
 			// Move a tile outside the building
 			let range = 4;
 			if (this.CheckTargetRangeExplicit(msg.data.target, range, -1))
 			{
 				this.FinishOrder();
 				return;
 			}
 			this.order.data.min = range;
 			this.SetNextState("WALKING");
 		},
 
 		"IDLE": {
 			// (We need an IDLE state so that FinishOrder works)
 
 			"enter": function() {
 				// Start feeding immediately
 				this.SetNextState("FEEDING");
 				return true;
 			},
 		},
 
 		"ROAMING": {
 			"enter": function() {
 				// Walk in a random direction
-				this.SelectAnimation("move", false, 1);
 				this.SetFacePointAfterMove(false);
 				this.MoveRandomly(+this.template.RoamDistance);
 				// Set a random timer to switch to feeding state
 				this.StartTimer(randIntInclusive(+this.template.RoamTimeMin, +this.template.RoamTimeMax));
 			},
 
 			"leave": function() {
 				this.StopMoving();
 				this.StopTimer();
 				this.SetFacePointAfterMove(true);
 			},
 
 			"LosRangeUpdate": function(msg) {
 				if (this.template.NaturalBehaviour == "skittish")
 				{
 					if (msg.data.added.length > 0)
 					{
 						this.Flee(msg.data.added[0], false);
 						return;
 					}
 				}
 				// Start attacking one of the newly-seen enemy (if any)
 				else if (this.IsDangerousAnimal())
 				{
 					this.AttackVisibleEntity(msg.data.added);
 				}
 
 				// TODO: if two units enter our range together, we'll attack the
 				// first and then the second won't trigger another LosRangeUpdate
 				// so we won't notice it. Probably we should do something with
 				// ResetActiveQuery in ROAMING.enter/FEEDING.enter in order to
 				// find any units that are already in range.
 			},
 
 			"Timer": function(msg) {
 				this.SetNextState("FEEDING");
 			},
 
 			"MovementUpdate": function() {
 				this.MoveRandomly(+this.template.RoamDistance);
 			},
 		},
 
 		"FEEDING": {
 			"enter": function() {
 				// Stop and eat for a while
 				this.SelectAnimation("feeding");
 				this.StopMoving();
 				this.StartTimer(randIntInclusive(+this.template.FeedTimeMin, +this.template.FeedTimeMax));
 			},
 
 			"leave": function() {
+				this.ResetAnimation();
 				this.StopTimer();
 			},
 
 			"LosRangeUpdate": function(msg) {
 				if (this.template.NaturalBehaviour == "skittish")
 				{
 					if (msg.data.added.length > 0)
 					{
 						this.Flee(msg.data.added[0], false);
 						return;
 					}
 				}
 				// Start attacking one of the newly-seen enemy (if any)
 				else if (this.template.NaturalBehaviour == "violent")
 				{
 					this.AttackVisibleEntity(msg.data.added);
 				}
 			},
 
 			"Timer": function(msg) {
 				this.SetNextState("ROAMING");
 			},
 		},
 
 		"FLEEING": "INDIVIDUAL.FLEEING", // reuse the same fleeing behaviour for animals
 
 		"COMBAT": "INDIVIDUAL.COMBAT", // reuse the same combat behaviour for animals
 
 		"WALKING": "INDIVIDUAL.WALKING",	// reuse the same walking behaviour for animals
 							// only used for domestic animals
 	},
 };
 
 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.isGarrisoned = false;
 	this.isIdle = false;
 	this.finishedOrder = false; // used to find if all formation members finished the order
 
 	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.SetStance(this.template.DefaultStance);
 };
 
 UnitAI.prototype.IsTurret = function()
 {
 	if (!this.IsGarrisoned())
 		return false;
 	var 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);
 };
 
 UnitAI.prototype.HasFinishedOrder = function()
 {
 	return this.finishedOrder;
 };
 
 UnitAI.prototype.ResetFinishOrder = function()
 {
 	this.finishedOrder = false;
 };
 
 UnitAI.prototype.IsAnimal = function()
 {
 	return (this.template.NaturalBehaviour ? true : false);
 };
 
 UnitAI.prototype.IsDangerousAnimal = function()
 {
 	return (this.IsAnimal() && (this.template.NaturalBehaviour == "violent" ||
 			this.template.NaturalBehaviour == "aggressive"));
 };
 
 UnitAI.prototype.IsDomestic = function()
 {
 	var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
 	return cmpIdentity && cmpIdentity.HasClass("Domestic");
 };
 
 UnitAI.prototype.IsHealer = function()
 {
 	return Engine.QueryInterface(this.entity, IID_Heal);
 };
 
 UnitAI.prototype.IsIdle = function()
 {
 	return this.isIdle;
 };
 
 UnitAI.prototype.IsGarrisoned = function()
 {
 	return this.isGarrisoned;
 };
 
 UnitAI.prototype.SetGarrisoned = function()
 {
 	this.isGarrisoned = true;
 };
 
 UnitAI.prototype.GetGarrisonHolder = function()
 {
 	if (this.IsGarrisoned())
 	{
 		for (let order of this.orderQueue)
 			if (order.type == "Garrison")
 				return order.data.target;
 	}
 	return INVALID_ENTITY;
 };
 
 UnitAI.prototype.ShouldRespondToEndOfAlert = function()
 {
 	return !this.orderQueue.length || this.orderQueue[0].type == "Garrison";
 };
 
 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.IsAnimal())
 		this.UnitFsm.Init(this, "ANIMAL.FEEDING");
 	else 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 cheering or (un)packing, in which case we only clear the order queue
 		if (this.isGarrisoned || this.IsPacking() || this.orderQueue[0] && this.orderQueue[0].type == "Cheering")
 		{
 			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, "");
 
 	// Clean up range queries
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (this.losRangeQuery)
 		cmpRangeManager.DestroyActiveQuery(this.losRangeQuery);
 	if (this.losHealRangeQuery)
 		cmpRangeManager.DestroyActiveQuery(this.losHealRangeQuery);
 };
 
 UnitAI.prototype.OnVisionRangeChanged = function(msg)
 {
 	// Update range queries
 	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)
 {
 	// First check if we already have such a request
 	if (this.HasPickupOrder(msg.entity))
 		return;
 	// Otherwise, insert the PickUp order after the last forced order
 	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 normal and healer range queries.
 UnitAI.prototype.SetupRangeQueries = function()
 {
 	this.SetupRangeQuery();
 
 	if (this.IsHealer())
 		this.SetupHealRangeQuery();
 };
 
 UnitAI.prototype.UpdateRangeQueries = function()
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (this.losRangeQuery)
 		this.SetupRangeQuery(cmpRangeManager.IsActiveQueryEnabled(this.losRangeQuery));
 
 	if (this.IsHealer() && this.losHealRangeQuery)
 		this.SetupHealRangeQuery(cmpRangeManager.IsActiveQueryEnabled(this.losHealRangeQuery));
 };
 
 // Set up a range query for all enemy and gaia units within LOS range
 // which can be attacked.
 // This should be called whenever our ownership changes.
 UnitAI.prototype.SetupRangeQuery = function(enable = true)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 
 	if (this.losRangeQuery)
 	{
 		cmpRangeManager.DestroyActiveQuery(this.losRangeQuery);
 		this.losRangeQuery = undefined;
 	}
 
 	var cmpPlayer = QueryOwnerInterface(this.entity);
 	// If we are being destructed (owner -1), creating a range query is pointless
 	if (!cmpPlayer)
 		return;
 
 	// Exclude allies, and self
 	// TODO: How to handle neutral players - Special query to attack military only?
 	var players = cmpPlayer.GetEnemies();
 	var range = this.GetQueryRange(IID_Attack);
 
 	this.losRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity, range.min, range.max, players, IID_DamageReceiver, cmpRangeManager.GetEntityFlagMask("normal"));
 
 	if (enable)
 		cmpRangeManager.EnableActiveQuery(this.losRangeQuery);
 };
 
 // Set up a range query for all own or ally units within LOS range
 // which can be healed.
 // This should be called whenever our ownership changes.
 UnitAI.prototype.SetupHealRangeQuery = function(enable = true)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 
 	if (this.losHealRangeQuery)
 	{
 		cmpRangeManager.DestroyActiveQuery(this.losHealRangeQuery);
 		this.losHealRangeQuery = undefined;
 	}
 
 	var cmpPlayer = QueryOwnerInterface(this.entity);
 	// If we are being destructed (owner -1), creating a range query is pointless
 	if (!cmpPlayer)
 		return;
 
 	var players = cmpPlayer.GetAllies();
 	var range = this.GetQueryRange(IID_Heal);
 
 	this.losHealRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity, range.min, range.max, players, IID_Health, cmpRangeManager.GetEntityFlagMask("injured"));
 
 	if (enable)
 		cmpRangeManager.EnableActiveQuery(this.losHealRangeQuery);
 };
 
 
 //// FSM linkage functions ////
 
 // Setting the next state to the current state will leave/re-enter the top-most substate.
 UnitAI.prototype.SetNextState = function(state)
 {
 	this.UnitFsm.SetNextState(this, state);
 };
 
 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).
  */
 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() || 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() });
 
 		// If the order was rejected then immediately take it off
 		// and process the remaining queue
 		if (ret && ret.discardOrder)
 			return this.FinishOrder();
 
 		// Otherwise we've successfully processed a new order
 		return true;
 	}
 
 	this.orderQueue = [];
 	this.order = undefined;
 
 	// Switch to IDLE as a default state, but only if our current state is not IDLE
 	// as this can trigger infinite loops by entering IDLE repeatedly.
 	if (!this.GetCurrentState().endsWith(".IDLE"))
 		this.SetNextState("IDLE");
 
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 
 	// Check if there are queued formation orders
 	if (this.IsFormationMember())
 	{
 		let cmpUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
 		if (cmpUnitAI)
 		{
 			// Inform the formation controller that we finished this task
 			this.finishedOrder = true;
 			// 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 we didn't already have an order, then process this new one
 	if (this.orderQueue.length == 1)
 	{
 		this.order = order;
 		let ret = this.UnitFsm.ProcessMessage(this,
 			{ "type": "Order."+this.order.type, "data": this.order.data }
 		);
 
 		// If the order was rejected then immediately take it off
 		// and process the remaining queue
 		if (ret && ret.discardOrder)
 			this.FinishOrder();
 	}
 
 	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)
 {
 	var order = { "type": type, "data": data };
 	// If current order is cheering then add new order after it
 	// same thing if current order if packing/unpacking
 	if (this.order && this.order.type == "Cheering")
 	{
 		var cheeringOrder = this.orderQueue.shift();
 		this.orderQueue.unshift(cheeringOrder, order);
 	}
 	else if (this.order && this.IsPacking())
 	{
 		var packingOrder = this.orderQueue.shift();
 		this.orderQueue.unshift(packingOrder, order);
 	}
 	else
 	{
 		this.orderQueue.unshift(order);
 		this.order = order;
 		let ret = this.UnitFsm.ProcessMessage(this,
 			{ "type": "Order."+this.order.type, "data": this.order.data }
 		);
 
 		// If the order was rejected then immediately take it off again;
 		// assume the previous active order is still valid (the short-lived
 		// new order hasn't changed state or anything) so we can carry on
 		// as if nothing had happened
 		if (ret && ret.discardOrder)
 		{
 			this.orderQueue.shift();
 			this.order = this.orderQueue[0];
 		}
 	}
 
 	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() });
 };
 
 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;
 
 	// Special cases of orders that shouldn't be replaced:
 	// 1. Cheering - we're invulnerable, add order after we finish
 	// 2. Packing/unpacking - we're immobile, add order after we finish (unless it's cancel)
 	// TODO: maybe a better way of doing this would be to use priority levels
 	if (this.order && this.order.type == "Cheering")
 	{
 		var order = { "type": type, "data": data };
 		var cheeringOrder = this.orderQueue.shift();
 		this.orderQueue = [cheeringOrder, order];
 	}
 	else if (this.IsPacking() && type != "CancelPack" && type != "CancelUnpack")
 	{
 		var order = { "type": type, "data": data };
 		var packingOrder = this.orderQueue.shift();
 		this.orderQueue = [packingOrder, order];
 	}
 	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 we are being re-affected to a work order, forget the previous ones
 	if (isWorkType(type))
 	{
 		this.workOrders = [];
 		return;
 	}
 
 	// Then if we already have work orders, keep them
 	if (this.workOrders.length)
 		return;
 
 	// First if the unit is in a formation, get its workOrders from it
 	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 cmpGarrisonHolder = Engine.QueryInterface(this.GetGarrisonHolder(), IID_GarrisonHolder);
 		if (!cmpGarrisonHolder || !cmpGarrisonHolder.PerformEject([this.entity], false))
 			return false;
 	}
 
 	// Clear the order queue considering special orders not to avoid
 	if (this.order && this.order.type == "Cheering")
 	{
 		var cheeringOrder = this.orderQueue.shift();
 		this.orderQueue = [cheeringOrder];
 	}
 	else
 		this.orderQueue = [];
 
 	this.AddOrders(this.workOrders);
 	Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 
 	// And if the unit is in a formation, remove it from the formation
 	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;
 };
 
 //// Message handlers /////
 
 UnitAI.prototype.OnMotionChanged = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, { "type": "MovementUpdate", "error": msg.error });
 };
 
 UnitAI.prototype.OnGlobalConstructionFinished = function(msg)
 {
 	// TODO: This is a bit inefficient since every unit listens to every
 	// construction message - ideally we could scope it to only the one we're building
 
 	this.UnitFsm.ProcessMessage(this, {"type": "ConstructionFinished", "data": msg});
 };
 
 UnitAI.prototype.OnGlobalEntityRenamed = function(msg)
 {
 	let changed = false;
 	for (let order of this.orderQueue)
 	{
 		if (order.data && order.data.target && order.data.target == msg.entity)
 		{
 			changed = true;
 			order.data.target = msg.newentity;
 		}
 		if (order.data && order.data.formationTarget && order.data.formationTarget == msg.entity)
 		{
 			changed = true;
 			order.data.formationTarget = msg.newentity;
 		}
 	}
 	if (changed)
 		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
 };
 
 UnitAI.prototype.OnAttacked = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
 };
 
 UnitAI.prototype.OnGuardedAttacked = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});
 };
 
 UnitAI.prototype.OnHealthChanged = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to});
 };
 
 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});
 };
 
 UnitAI.prototype.OnPackFinished = function(msg)
 {
 	this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
 };
 
 //// 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 entity ID of the nearest resource supply where the given
  * filter returns true, or undefined if none can be found.
  * if position (as a vector2D) is given, the nearest is computed versus this position.
  * TODO: extend this to exclude resources that already have lots of
  * gatherers.
  */
 UnitAI.prototype.FindNearbyResource = function(filter, position)
 {
 	let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership || cmpOwnership.GetOwner() == INVALID_PLAYER)
 		return undefined;
 	let owner = cmpOwnership.GetOwner();
 
 	// 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);
 	let pos = position;
 	if (!pos)
 	{
 		let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 		if (cmpPosition && cmpPosition.IsInWorld())
 			pos = cmpPosition.GetPosition2D();
 	}
 	let nearby = cmpRangeManager.ExecuteQueryAroundPos(pos, 0, range, players, IID_ResourceSupply);
 	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);
 		// Remove "resource|" prefix from template names, if present.
 		if (template.indexOf("resource|") != -1)
 			template = template.slice(9);
 
 		return amount > 0 && cmpResourceSupply.IsAvailable(owner, 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;
 
 	// Find dropsites owned by this unit's player or allied ones if allowed.
 	let owner = cmpOwnership.GetOwner();
 	let cmpPlayer = QueryOwnerInterface(this.entity);
 	let players = cmpPlayer && cmpPlayer.HasSharedDropsites() ? cmpPlayer.GetMutualAllies() : [owner];
 	let nearbyDropsites = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).ExecuteQuery(this.entity, 0, -1, players, IID_ResourceDropsite);
 
 	let isShip = Engine.QueryInterface(this.entity, IID_Identity).HasClass("Ship");
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	for (let dropsite of nearbyDropsites)
 	{
 		// 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,
  * or undefined if none can be found close enough.
  */
 UnitAI.prototype.FindNearbyFoundation = function()
 {
 	var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership || cmpOwnership.GetOwner() == INVALID_PLAYER)
 		return undefined;
 
 	// Find buildings owned by this unit's player
 	var players = [cmpOwnership.GetOwner()];
 
 	var range = 64; // TODO: what's a sensible number?
 
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	var nearby = cmpRangeManager.ExecuteQuery(this.entity, 0, range, players, IID_Foundation);
 
 	// 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());
 };
 
 /**
  * Play a sound appropriate to the current entity.
  */
 UnitAI.prototype.PlaySound = function(name)
 {
 	// If we're a formation controller, use the sounds from our first member
 	if (this.IsFormationController())
 	{
 		var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 		var member = cmpFormation.GetPrimaryMember();
 		if (member)
 			PlaySound(name, member);
 	}
 	else
 	{
 		// Otherwise use our own sounds
 		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);
 	return;
 };
 
 /*
  * 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)
 	{
 		this.SetAnimationVariant("");
 		return;
 	}
 
 	let type = cmpResourceGatherer.GetLastCarriedType();
 	if (type)
 	{
 		let typename = "carry_" + type.generic;
 
 		// Special case for meat
 		if (type.specific == "meat")
 			typename = "carry_" + type.specific;
 
 		this.SetAnimationVariant(typename);
 		return;
 	}
 
 	this.SetAnimationVariant("");
 };
 
-UnitAI.prototype.SelectAnimation = function(name, once = false, speed = 1.0)
+UnitAI.prototype.ResetAnimation = function()
 {
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (!cmpVisual)
 		return;
 
-	// Special case: the "move" animation gets turned into a special
-	// movement mode that deals with speeds and walk/run automatically
-	if (name == "move")
-	{
-		// Speed to switch from walking to running animations
-		cmpVisual.SelectMovementAnimation(this.GetWalkSpeed());
+	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()
 {
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	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)
 {
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return cmpUnitMotion.MoveToPointRange(x, z, 0, 0);
 };
 
 UnitAI.prototype.MoveToPointRange = function(x, z, rangeMin, rangeMax)
 {
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return cmpUnitMotion.MoveToPointRange(x, z, rangeMin, rangeMax);
 };
 
 UnitAI.prototype.MoveToTarget = function(target)
 {
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return cmpUnitMotion.MoveToTargetRange(target, 0, 0);
 };
 
 UnitAI.prototype.MoveToTargetRange = function(target, iid, type)
 {
 	if (!this.CheckTargetVisible(target) || this.IsTurret())
 		return false;
 
 	var cmpRanged = Engine.QueryInterface(this.entity, iid);
 	if (!cmpRanged)
 		return false;
 	var range = cmpRanged.GetRange(type);
 
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return 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 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 cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	let range = cmpAttack.GetRange(type);
 
 	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.IsInWorld())
 		return false;
 
 	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;
 
 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return cmpUnitMotion.MoveToTargetRange(target, range.min, guessedMaxRange);
 };
 
 UnitAI.prototype.MoveToTargetRangeExplicit = function(target, min, max)
 {
 	if (!this.CheckTargetVisible(target))
 		return false;
 
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return cmpUnitMotion.MoveToTargetRange(target, min, 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();
 
 	var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
 	return 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, 0);
 
 		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)
 {
 	var cmpRanged = Engine.QueryInterface(this.entity, iid);
 	if (!cmpRanged)
 		return false;
 	var range = cmpRanged.GetRange(type);
 
 	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 cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	let range = cmpAttack.GetRange(type);
 
 	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);
 };
 
 UnitAI.prototype.CheckGarrisonRange = function(target)
 {
 	var cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 		return false;
 	var range = cmpGarrisonHolder.GetLoadingRange();
 
 	var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
 	if (cmpObstruction)
 		range.max += cmpObstruction.GetUnitRadius()*1.5; // multiply by something larger than sqrt(2)
 
 	let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	return cmpObstructionManager.IsInTargetRange(this.entity, target, range.min, range.max, false);
 };
 
 /**
  * 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;
 };
 
 /**
  * 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)
 {
 	var cmpRanged = Engine.QueryInterface(this.entity, iid);
 	var range = iid !== IID_Attack ? cmpRanged.GetRange() : cmpRanged.GetRange(type);
 
 	var cmpPosition = Engine.QueryInterface(target, IID_Position);
 	if (!cmpPosition || !cmpPosition.IsInWorld())
 		return false;
 
 	var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 	if (!cmpVision)
 		return false;
 	var halfvision = cmpVision.GetRange() / 2;
 
 	var pos = cmpPosition.GetPosition();
 	var 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)
 {
 	var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 	if (!cmpVision)
 		return false;
 	var range = cmpVision.GetRange();
 
 	var distance = 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)
 	{
 		this.PushOrderFront("Flee", { "target": ents[0], "force": false });
 		return true;
 	}
 
 	return false;
 };
 
 /**
  * Try to respond to healable entities.
  * Returns true if it responded.
  */
 UnitAI.prototype.RespondToHealableEntities = function(ents)
 {
 	var 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)
 {
 	// 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)
 	{
 		var cmpUnitAI =  Engine.QueryInterface(target, IID_UnitAI);
 		var cmpAttack = Engine.QueryInterface(target, IID_Attack);
 		if (cmpUnitAI && cmpAttack &&
 		    cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
 				return false;
 	}
 
 	// Stop if we're in hold-ground mode and it's too far from the holding point
 	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;
 	}
 
 	// (Note that CCmpUnitMotion will detect if the target is lost in FoW,
 	// and will continue moving to its last seen position and then stop)
 
 	return false;
 };
 
 /*
  * Returns whether we should chase the targeted entity,
  * given our current stance.
  */
 UnitAI.prototype.ShouldChaseTargetedEntity = function(target, force)
 {
 	if (this.IsTurret())
 		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;
 	}
 
 	if (force)
 		return true;
 
 	return false;
 };
 
 //// External interface functions ////
 
 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) || "special/formations/null";
 };
 
 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();
 
 	// Add new order to move into formation at the current position
 	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":
 			// Find the target unit's position
 			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 the total distance to the end of the order queue
 	return distance;
 };
 
 UnitAI.prototype.AddOrder = function(type, data, queued)
 {
 	if (this.expectedRoute)
 		this.expectedRoute = undefined;
 
 	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
 		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)
 {
 	if (!this.CanGuard())
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	// if we already had an old guard order, do nothing if the target is the same
 	// and the order is running, otherwise remove the previous order
 	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);
 };
 
 UnitAI.prototype.AddGuard = function(target)
 {
 	if (!this.CanGuard())
 		return false;
 
 	var cmpGuard = Engine.QueryInterface(target, IID_Guard);
 	if (!cmpGuard)
 		return false;
 
 	// Do not allow to guard a unit already guarding
 	var cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 	if (cmpUnitAI && cmpUnitAI.IsGuardOf())
 		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;
 
 	// Do not let a unit already guarded to guard. This would work in principle,
 	// but would clutter the gui with too much buttons to take all cases into account
 	var cmpGuard = Engine.QueryInterface(this.entity, IID_Guard);
 	if (cmpGuard && cmpGuard.GetEntities().length)
 		return false;
 
 	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)
 {
 	if (this.expectedRoute && queued)
 		this.expectedRoute.push({ "x": x, "z": z });
 	else
 		this.AddOrder("Walk", { "x": x, "z": z, "force": true }, queued);
 };
 
 /**
  * Adds walk to point range order to queue, forced by the player.
  */
 UnitAI.prototype.WalkToPointRange = function(x, z, min, max, queued)
 {
 	this.AddOrder("Walk", { "x": x, "z": z, "min": min, "max": max, "force": true }, queued);
 };
 
 /**
  * Adds stop order to queue, forced by the player.
  */
 UnitAI.prototype.Stop = function(queued)
 {
 	this.AddOrder("Stop", { "force": true }, queued);
 };
 
 /**
  * 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)
 {
 	this.AddOrder("WalkToTarget", { "target": target, "force": true }, queued);
 };
 
 /**
  * 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)
 {
 	this.AddOrder("WalkAndFight", { "x": x, "z": z, "targetClasses": targetClasses, "allowCapture": allowCapture, "force": true }, queued);
 };
 
 UnitAI.prototype.Patrol = function(x, z, targetClasses, allowCapture = true, queued = false)
 {
 	if (!this.CanPatrol())
 	{
 		this.Walk(x, z, queued);
 		return;
 	}
 
 	this.AddOrder("Patrol", { "x": x, "z": z, "targetClasses": targetClasses, "allowCapture": allowCapture, "force": true }, queued);
 };
 
 /**
  * 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
 	// Ignore also the request if we are packing
 	if (this.order && (this.order.type == "LeaveFoundation" || (this.order.type == "Flee" && this.order.data.target == target) || 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)
 {
 	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);
 		return;
 	}
 
 	let order = {
 		"target": target,
 		"force": true,
 		"allowCapture": allowCapture,
 	};
 
 	this.RememberTargetPosition(order);
 
 	this.AddOrder("Attack", order, queued);
 };
 
 /**
  * Adds garrison order to the queue, forced by the player.
  */
 UnitAI.prototype.Garrison = function(target, queued)
 {
 	if (target == this.entity)
 		return;
 	if (!this.CanGarrison(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 	this.AddOrder("Garrison", { "target": target, "force": true }, queued);
 };
 
 /**
  * Adds ungarrison order to the queue.
  */
 UnitAI.prototype.Ungarrison = function()
 {
 	if (this.IsGarrisoned())
 		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.isGarrisoned = true;
 	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)
 {
 	this.PerformGather(target, queued, true);
 };
 
 /**
  * Internal function to abstract the force parameter.
  */
 UnitAI.prototype.PerformGather = function(target, queued, force)
 {
 	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);
 
 	// Remove "resource|" prefix from template name, if present.
 	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;
 
 	this.AddOrder("Gather", order, queued);
 };
 
 /**
  * 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)
 {
 	// Remove "resource|" prefix from template name, if present.
 	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);
 	else
 		this.AddOrder("Walk", { "x": x, "z": z, "force": false }, queued);
 };
 
 /**
  * Adds heal order to the queue, forced by the player.
  */
 UnitAI.prototype.Heal = function(target, queued)
 {
 	if (!this.CanHeal(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	this.AddOrder("Heal", { "target": target, "force": true }, queued);
 };
 
 /**
  * Adds return resource order to the queue, forced by the player.
  */
 UnitAI.prototype.ReturnResource = function(target, queued)
 {
 	if (!this.CanReturnResource(target, true))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	this.AddOrder("ReturnResource", { "target": target, "force": true }, queued);
 };
 
 /**
  * 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)
 {
 	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);
 	}
 	else
 	{
 		if (this.IsFormationController())
 			this.CallMemberFunction("WalkToTarget", [cmpTrader.GetFirstMarket(), queued]);
 		else
 			this.WalkToTarget(cmpTrader.GetFirstMarket(), queued);
 		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)
 {
 	if (this.waypoints && this.waypoints.length > 1)
 	{
 		let point = this.waypoints.pop();
 		return this.MoveToPoint(point.x, point.z) || this.MoveToMarket(targetMarket);
 	}
 
 	this.waypoints = undefined;
 	return this.MoveToTargetRange(targetMarket, 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.waypoints.unshift(null);  // additionnal dummy point for the market
 	}
 
 	if (this.MoveToMarket(nextMarket))	// We've started walking to the next market
 		this.SetNextState("APPROACHINGMARKET");
 	else
 		this.StopTrading();
 };
 
 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.StopMoving();
 	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)
 {
 	if (!this.CanRepair(target))
 	{
 		this.WalkToTarget(target, queued);
 		return;
 	}
 
 	this.AddOrder("Repair", { "target": target, "autocontinue": autocontinue, "force": true }, queued);
 };
 
 /**
  * Adds flee order to the queue, not forced, so it can be
  * interrupted by attacks.
  */
 UnitAI.prototype.Flee = function(target, queued)
 {
 	this.AddOrder("Flee", { "target": target, "force": false }, queued);
 };
 
 /**
  * Adds cheer order to the queue. Forced so it won't be interrupted by attacks.
  */
 UnitAI.prototype.Cheer = function()
 {
 	this.AddOrder("Cheering", { "force": true }, false);
 };
 
 UnitAI.prototype.Pack = function(queued)
 {
 	// Check that we can pack
 	if (this.CanPack())
 		this.AddOrder("Pack", { "force": true }, queued);
 };
 
 UnitAI.prototype.Unpack = function(queued)
 {
 	// Check that we can unpack
 	if (this.CanUnpack())
 		this.AddOrder("Unpack", { "force": true }, queued);
 };
 
 UnitAI.prototype.CancelPack = function(queued)
 {
 	var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	if (cmpPack && cmpPack.IsPacking() && !cmpPack.IsPacked())
 		this.AddOrder("CancelPack", { "force": true }, queued);
 };
 
 UnitAI.prototype.CancelUnpack = function(queued)
 {
 	var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
 	if (cmpPack && cmpPack.IsPacking() && cmpPack.IsPacked())
 		this.AddOrder("CancelUnpack", { "force": true }, queued);
 };
 
 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);
 	// Stop moving if switching to stand ground
 	// TODO: Also stop existing orders in a sensible way
 	if (stance == "standground")
 		this.StopMoving();
 
 	// 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 losRangeQuery, 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.losRangeQuery)
 		return false;
 
 	if (!this.GetStance().targetVisibleEnemies)
 		return false;
 
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return this.AttackEntitiesByPreference(cmpRangeManager.ResetActiveQuery(this.losRangeQuery));
 };
 
 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.losRangeQuery)
 		return [];
 
 	if (!this.GetStance().targetVisibleEnemies)
 		return [];
 
 	var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpAttack)
 		return [];
 
 	var attackfilter = function(e) {
 		var cmpOwnership = Engine.QueryInterface(e, IID_Ownership);
 		if (cmpOwnership && cmpOwnership.GetOwner() > 0)
 			return true;
 		var cmpUnitAI = Engine.QueryInterface(e, IID_UnitAI);
 		return cmpUnitAI && (!cmpUnitAI.IsAnimal() || cmpUnitAI.IsDangerousAnimal());
 	};
 
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	var entities = cmpRangeManager.ResetActiveQuery(this.losRangeQuery);
 	var targets = entities.filter(function(v) { return cmpAttack.CanAttack(v) && attackfilter(v); })
 		.sort(function(a, b) { return cmpAttack.CompareEntitiesByPreference(a, b); });
 
 	return targets;
 };
 
 /**
  * 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;
 
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return this.RespondToHealableEntities(cmpRangeManager.ResetActiveQuery(this.losHealRangeQuery));
 };
 
 UnitAI.prototype.GetQueryRange = function(iid)
 {
 	var ret = { "min": 0, "max": 0 };
 	if (this.GetStance().respondStandGround)
 	{
 		var cmpRanged = Engine.QueryInterface(this.entity, iid);
 		if (!cmpRanged)
 			return ret;
 		var range = iid !== IID_Attack ? cmpRanged.GetRange() : cmpRanged.GetFullAttackRange();
 		var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 		if (!cmpVision)
 			return ret;
 		ret.min = range.min;
 		ret.max = Math.min(range.max, cmpVision.GetRange());
 	}
 	else if (this.GetStance().respondChase)
 	{
 		var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 		if (!cmpVision)
 			return ret;
 		var range = cmpVision.GetRange();
 		ret.max = range;
 	}
 	else if (this.GetStance().respondHoldGround)
 	{
 		var cmpRanged = Engine.QueryInterface(this.entity, iid);
 		if (!cmpRanged)
 			return ret;
 		var range = iid !== IID_Attack ? cmpRanged.GetRange() : cmpRanged.GetFullAttackRange();
 		var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 		if (!cmpVision)
 			return ret;
 		var vision = cmpVision.GetRange();
 		ret.max = Math.min(range.max + vision / 2, vision);
 	}
 	// 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)
 	{
 		var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
 		if (!cmpVision)
 			return ret;
 		var range = cmpVision.GetRange();
 		ret.max = range;
 	}
 	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);
 };
 
 /*
  * 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);
 		return true;
 	}
 	return false;
 };
 
 //// Helper functions ////
 
 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;
 
 	var cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
 	if (!cmpGarrisonHolder)
 		return false;
 
 	// Verify that the target is owned by this entity's player or a mutual ally of this player
 	var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership || !(IsOwnedByPlayer(cmpOwnership.GetOwner(), target) || IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target)))
 		return false;
 
 	// Don't let animals garrison for now
 	// (If we want to support that, we'll need to change Order.Garrison so it
 	// doesn't move the animal into an INVIDIDUAL.* state)
 	if (this.IsAnimal())
 		return false;
 
 	return true;
 };
 
 UnitAI.prototype.CanGather = function(target)
 {
 	if (this.IsTurret())
 		return false;
 	// The target must be a valid resource supply, or the mirage of one.
 	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;
 
 	// Verify that we're able to respond to Gather commands
 	var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 	if (!cmpResourceGatherer)
 		return false;
 
 	// Verify that we can gather from this target
 	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;
 
 	// Verify that we're able to respond to Heal commands
 	var cmpHeal = Engine.QueryInterface(this.entity, IID_Heal);
 	if (!cmpHeal)
 		return false;
 
 	// Verify that the target is alive
 	if (!this.TargetIsAlive(target))
 		return false;
 
 	// Verify that the target is owned by the same player as the entity or of an ally
 	var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (!cmpOwnership || !(IsOwnedByPlayer(cmpOwnership.GetOwner(), target) || IsOwnedByAllyOfPlayer(cmpOwnership.GetOwner(), target)))
 		return false;
 
 	// Verify that the target is not unhealable (or at max health)
 	var cmpHealth = Engine.QueryInterface(target, IID_Health);
 	if (!cmpHealth || cmpHealth.IsUnhealable())
 		return false;
 
 	// Verify that the target has no unhealable class
 	var cmpIdentity = Engine.QueryInterface(target, IID_Identity);
 	if (!cmpIdentity)
 		return false;
 
 	if (MatchesClassList(cmpIdentity.GetClassesList(), cmpHeal.GetUnhealableClasses()))
 		return false;
 
 	// Verify that the target is a healable class
 	if (MatchesClassList(cmpIdentity.GetClassesList(), cmpHeal.GetHealableClasses()))
 		return true;
 
 	return false;
 };
 
 UnitAI.prototype.CanReturnResource = function(target, checkCarriedResource)
 {
 	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 ReturnResource commands
 	var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
 	if (!cmpResourceGatherer)
 		return false;
 
 	// Verify that the target is a dropsite
 	var cmpResourceDropsite = Engine.QueryInterface(target, IID_ResourceDropsite);
 	if (!cmpResourceDropsite)
 		return false;
 
 	if (checkCarriedResource)
 	{
 		// Verify that we are carrying some resources,
 		// and can return our current resource to this target
 		var type = cmpResourceGatherer.GetMainCarryingType();
 		if (!type || !cmpResourceDropsite.AcceptsType(type))
 			return false;
 	}
 
 	// Verify that the dropsite is owned by this entity's player (or a mutual ally's if allowed)
 	var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
 	if (cmpOwnership && IsOwnedByPlayer(cmpOwnership.GetOwner(), target))
 		return true;
 	var 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;
 
 	// Verify that we're able to respond to Trade commands
 	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;
 
 	// Verify that the target can be either built or repaired
 	var cmpFoundation = QueryMiragedInterface(target, IID_Foundation);
 	var cmpRepairable = Engine.QueryInterface(target, IID_Repairable);
 	if (!cmpFoundation && !cmpRepairable)
 		return false;
 
 	// Verify that the target is owned by an ally of this entity's player
 	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";
 };
 
 //// Animal specific functions ////
 
 UnitAI.prototype.MoveRandomly = function(distance)
 {
 	// To minimize drift all across the map, animals 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.AttackEntitiesByPreference = function(ents)
 {
 	if (!ents.length)
 		return false;
 
 	var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
 	if (!cmpAttack)
 		return false;
 
 	var attackfilter = function(e) {
 		var cmpOwnership = Engine.QueryInterface(e, IID_Ownership);
 		if (cmpOwnership && cmpOwnership.GetOwner() > 0)
 			return true;
 		var 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 obj.funcname(args) on UnitAI components of all formation members.
  */
 UnitAI.prototype.CallMemberFunction = function(funcname, args)
 {
 	var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 	if (!cmpFormation)
 		return;
 
 	cmpFormation.GetMembers().forEach(ent => {
 		var cmpUnitAI = Engine.QueryInterface(ent, 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)
 {
 	var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
 	if (!cmpFormation)
 		return false;
 
 	return cmpFormation.GetMembers().every(ent => {
 		var 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/source/simulation2/components/CCmpUnitMotion.cpp
===================================================================
--- ps/trunk/source/simulation2/components/CCmpUnitMotion.cpp	(revision 22445)
+++ ps/trunk/source/simulation2/components/CCmpUnitMotion.cpp	(revision 22446)
@@ -1,1579 +1,1588 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "simulation2/system/Component.h"
 #include "ICmpUnitMotion.h"
 
 #include "simulation2/components/ICmpObstruction.h"
 #include "simulation2/components/ICmpObstructionManager.h"
 #include "simulation2/components/ICmpOwnership.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpPathfinder.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpValueModificationManager.h"
+#include "simulation2/components/ICmpVisual.h"
 #include "simulation2/helpers/Geometry.h"
 #include "simulation2/helpers/Render.h"
 #include "simulation2/MessageTypes.h"
 #include "simulation2/serialization/SerializeTemplates.h"
 
 #include "graphics/Overlay.h"
 #include "graphics/Terrain.h"
 #include "maths/FixedVector2D.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "renderer/Scene.h"
 
 // For debugging; units will start going straight to the target
 // instead of calling the pathfinder
 #define DISABLE_PATHFINDER 0
 
 /**
  * When advancing along the long path, and picking a new waypoint to move
  * towards, we'll pick one that's up to this far from the unit's current
  * position (to minimise the effects of grid-constrained movement)
  */
 static const entity_pos_t WAYPOINT_ADVANCE_MAX = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*8);
 
 /**
  * Min/Max range to restrict short path queries to. (Larger ranges are slower,
  * smaller ranges might miss some legitimate routes around large obstacles.)
  */
 static const entity_pos_t SHORT_PATH_MIN_SEARCH_RANGE = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*2);
 static const entity_pos_t SHORT_PATH_MAX_SEARCH_RANGE = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*9);
 
 /**
  * Minimum distance to goal for a long path request
  */
 static const entity_pos_t LONG_PATH_MIN_DIST = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*4);
 
 /**
  * When short-pathing, and the short-range pathfinder failed to return a path,
  * Assume we are at destination if we are closer than this distance to the target
  * And we have no target entity.
  * This is somewhat arbitrary, but setting a too big distance means units might lose sight of their end goal too much;
  */
 static const entity_pos_t SHORT_PATH_GOAL_RADIUS = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*2);
 
 /**
  * If we are this close to our target entity/point, then think about heading
  * for it in a straight line instead of pathfinding.
  */
 static const entity_pos_t DIRECT_PATH_RANGE = entity_pos_t::FromInt(TERRAIN_TILE_SIZE*4);
 
 static const CColor OVERLAY_COLOR_LONG_PATH(1, 1, 1, 1);
 static const CColor OVERLAY_COLOR_SHORT_PATH(1, 0, 0, 1);
 
 class CCmpUnitMotion : public ICmpUnitMotion
 {
 public:
 	static void ClassInit(CComponentManager& componentManager)
 	{
 		componentManager.SubscribeToMessageType(MT_Update_MotionFormation);
 		componentManager.SubscribeToMessageType(MT_Update_MotionUnit);
 		componentManager.SubscribeToMessageType(MT_PathResult);
 		componentManager.SubscribeToMessageType(MT_OwnershipChanged);
 		componentManager.SubscribeToMessageType(MT_ValueModification);
 		componentManager.SubscribeToMessageType(MT_Deserialized);
 	}
 
 	DEFAULT_COMPONENT_ALLOCATOR(UnitMotion)
 
 	bool m_DebugOverlayEnabled;
 	std::vector<SOverlayLine> m_DebugOverlayLongPathLines;
 	std::vector<SOverlayLine> m_DebugOverlayShortPathLines;
 
 	// Template state:
 
 	bool m_FormationController;
 
 	fixed m_TemplateWalkSpeed, m_TemplateRunMultiplier;
 	pass_class_t m_PassClass;
 	std::string m_PassClassName;
 
 	// Dynamic state:
 
 	entity_pos_t m_Clearance;
 
 	// cached for efficiency
 	fixed m_WalkSpeed, m_RunMultiplier;
 
 	bool m_FacePointAfterMove;
 
 	enum PathState
 	{
 		/*
 		 * There is no path.
 		 * (This should only happen in IDLE and STOPPING.)
 		 */
 		PATHSTATE_NONE,
 
 		/*
 		 * We have an outstanding long path request.
 		 * No paths are usable yet, so we can't move anywhere.
 		 */
 		PATHSTATE_WAITING_REQUESTING_LONG,
 
 		/*
 		 * We have an outstanding short path request.
 		 * m_LongPath is valid.
 		 * m_ShortPath is not yet valid, so we can't move anywhere.
 		 */
 		PATHSTATE_WAITING_REQUESTING_SHORT,
 
 		/*
 		 * We are following our path, and have no path requests.
 		 * m_LongPath and m_ShortPath are valid.
 		 */
 		PATHSTATE_FOLLOWING,
 
 		/*
 		 * We are following our path, and have an outstanding long path request.
 		 * (This is because our target moved a long way and we need to recompute
 		 * the whole path).
 		 * m_LongPath and m_ShortPath are valid.
 		 */
 		PATHSTATE_FOLLOWING_REQUESTING_LONG,
 
 		/*
 		 * We are following our path, and have an outstanding short path request.
 		 * (This is because our target moved and we've got a new long path
 		 * which we need to follow).
 		 * m_LongPath is valid; m_ShortPath is valid but obsolete.
 		 */
 		PATHSTATE_FOLLOWING_REQUESTING_SHORT,
 
 		PATHSTATE_MAX
 	};
 	u8 m_PathState;
 
 	u32 m_ExpectedPathTicket; // asynchronous request ID we're waiting for, or 0 if none
 
 	struct MoveRequest {
 		enum Type {
 			NONE,
 			POINT,
 			ENTITY,
 			OFFSET
 		} m_Type = NONE;
 		entity_id_t m_Entity = INVALID_ENTITY;
 		CFixedVector2D m_Position;
 		entity_pos_t m_MinRange, m_MaxRange;
 
 		// For readability
 		CFixedVector2D GetOffset() const { return m_Position; };
 
 		MoveRequest() = default;
 		MoveRequest(CFixedVector2D pos, entity_pos_t minRange, entity_pos_t maxRange) : m_Type(POINT), m_Position(pos), m_MinRange(minRange), m_MaxRange(maxRange) {};
 		MoveRequest(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange) : m_Type(ENTITY), m_Entity(target), m_MinRange(minRange), m_MaxRange(maxRange) {};
 		MoveRequest(entity_id_t target, CFixedVector2D offset) : m_Type(OFFSET), m_Entity(target), m_Position(offset) {};
 	} m_MoveRequest;
 
 	// If the entity moves, it will do so at m_WalkSpeed * m_SpeedMultiplier.
 	fixed m_SpeedMultiplier;
 	// This caches the resulting speed from m_WalkSpeed * m_SpeedMultiplier for convenience.
 	fixed m_Speed;
 
 	// Current mean speed (over the last turn).
 	fixed m_CurSpeed;
 
 	// Currently active paths (storing waypoints in reverse order).
 	// The last item in each path is the point we're currently heading towards.
 	WaypointPath m_LongPath;
 	WaypointPath m_ShortPath;
 
 	// Motion planning
 	u8 m_Tries; // how many tries we've done to get to our current Final Goal.
 
 	PathGoal m_FinalGoal;
 
 	static std::string GetSchema()
 	{
 		return
 			"<a:help>Provides the unit with the ability to move around the world by itself.</a:help>"
 			"<a:example>"
 				"<WalkSpeed>7.0</WalkSpeed>"
 				"<PassabilityClass>default</PassabilityClass>"
 			"</a:example>"
 			"<element name='FormationController'>"
 				"<data type='boolean'/>"
 			"</element>"
 			"<element name='WalkSpeed' a:help='Basic movement speed (in metres per second)'>"
 				"<ref name='positiveDecimal'/>"
 			"</element>"
 			"<optional>"
 				"<element name='RunMultiplier' a:help='How much faster the unit goes when running (as a multiple of walk speed)'>"
 					"<ref name='positiveDecimal'/>"
 				"</element>"
 			"</optional>"
 			"<element name='PassabilityClass' a:help='Identifies the terrain passability class (values are defined in special/pathfinder.xml)'>"
 				"<text/>"
 			"</element>";
 	}
 
 	virtual void Init(const CParamNode& paramNode)
 	{
 		m_FormationController = paramNode.GetChild("FormationController").ToBool();
 
 		m_FacePointAfterMove = true;
 
 		m_WalkSpeed = m_TemplateWalkSpeed = m_Speed = paramNode.GetChild("WalkSpeed").ToFixed();
 		m_SpeedMultiplier = fixed::FromInt(1);
 		m_CurSpeed = fixed::Zero();
 
 		m_RunMultiplier = m_TemplateRunMultiplier = fixed::FromInt(1);
 		if (paramNode.GetChild("RunMultiplier").IsOk())
 			m_RunMultiplier = m_TemplateRunMultiplier = paramNode.GetChild("RunMultiplier").ToFixed();
 
 		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
 		if (cmpPathfinder)
 		{
 			m_PassClassName = paramNode.GetChild("PassabilityClass").ToUTF8();
 			m_PassClass = cmpPathfinder->GetPassabilityClass(m_PassClassName);
 			m_Clearance = cmpPathfinder->GetClearance(m_PassClass);
 
 			CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
 			if (cmpObstruction)
 				cmpObstruction->SetUnitClearance(m_Clearance);
 		}
 
 		m_PathState = PATHSTATE_NONE;
 
 		m_ExpectedPathTicket = 0;
 
 		m_Tries = 0;
 
 		m_FinalGoal.type = PathGoal::POINT;
 
 		m_DebugOverlayEnabled = false;
 	}
 
 	virtual void Deinit()
 	{
 	}
 
 	template<typename S>
 	void SerializeCommon(S& serialize)
 	{
 		serialize.NumberU8("path state", m_PathState, 0, PATHSTATE_MAX-1);
 
 		serialize.StringASCII("pass class", m_PassClassName, 0, 64);
 
 		serialize.NumberU32_Unbounded("ticket", m_ExpectedPathTicket);
 
 		SerializeU8_Enum<MoveRequest::Type, MoveRequest::Type::OFFSET>()(serialize, "target type", m_MoveRequest.m_Type);
 		serialize.NumberU32_Unbounded("target entity", m_MoveRequest.m_Entity);
 		serialize.NumberFixed_Unbounded("target pos x", m_MoveRequest.m_Position.X);
 		serialize.NumberFixed_Unbounded("target pos y", m_MoveRequest.m_Position.Y);
 		serialize.NumberFixed_Unbounded("target min range", m_MoveRequest.m_MinRange);
 		serialize.NumberFixed_Unbounded("target max range", m_MoveRequest.m_MaxRange);
 
 		serialize.NumberFixed_Unbounded("speed multiplier", m_SpeedMultiplier);
 
 		serialize.NumberFixed_Unbounded("current speed", m_CurSpeed);
 
 		serialize.Bool("facePointAfterMove", m_FacePointAfterMove);
 
 		serialize.NumberU8("tries", m_Tries, 0, 255);
 
 		SerializeVector<SerializeWaypoint>()(serialize, "long path", m_LongPath.m_Waypoints);
 		SerializeVector<SerializeWaypoint>()(serialize, "short path", m_ShortPath.m_Waypoints);
 
 		SerializeGoal()(serialize, "goal", m_FinalGoal);
 	}
 
 	virtual void Serialize(ISerializer& serialize)
 	{
 		SerializeCommon(serialize);
 	}
 
 	virtual void Deserialize(const CParamNode& paramNode, IDeserializer& deserialize)
 	{
 		Init(paramNode);
 
 		SerializeCommon(deserialize);
 
 		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
 		if (cmpPathfinder)
 			m_PassClass = cmpPathfinder->GetPassabilityClass(m_PassClassName);
 	}
 
 	virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
 	{
 		switch (msg.GetType())
 		{
 		case MT_Update_MotionFormation:
 		{
 			if (m_FormationController)
 			{
 				fixed dt = static_cast<const CMessageUpdate_MotionFormation&> (msg).turnLength;
 				Move(dt);
 			}
 			break;
 		}
 		case MT_Update_MotionUnit:
 		{
 			if (!m_FormationController)
 			{
 				fixed dt = static_cast<const CMessageUpdate_MotionUnit&> (msg).turnLength;
 				Move(dt);
 			}
 			break;
 		}
 		case MT_RenderSubmit:
 		{
 			PROFILE("UnitMotion::RenderSubmit");
 			const CMessageRenderSubmit& msgData = static_cast<const CMessageRenderSubmit&> (msg);
 			RenderSubmit(msgData.collector);
 			break;
 		}
 		case MT_PathResult:
 		{
 			const CMessagePathResult& msgData = static_cast<const CMessagePathResult&> (msg);
 			PathResult(msgData.ticket, msgData.path);
 			break;
 		}
 		case MT_ValueModification:
 		{
 			const CMessageValueModification& msgData = static_cast<const CMessageValueModification&> (msg);
 			if (msgData.component != L"UnitMotion")
 				break;
 			FALLTHROUGH;
 		}
 		case MT_OwnershipChanged:
 		case MT_Deserialized:
 		{
 			CmpPtr<ICmpValueModificationManager> cmpValueModificationManager(GetSystemEntity());
 			if (!cmpValueModificationManager)
 				break;
 
 			m_WalkSpeed = cmpValueModificationManager->ApplyModifications(L"UnitMotion/WalkSpeed", m_TemplateWalkSpeed, GetEntityId());
 			m_RunMultiplier = cmpValueModificationManager->ApplyModifications(L"UnitMotion/RunMultiplier", m_TemplateRunMultiplier, GetEntityId());
 
 			// For MT_Deserialize compute m_Speed from the serialized m_SpeedMultiplier.
 			// For MT_ValueModification and MT_OwnershipChanged, adjust m_SpeedMultiplier if needed
 			// (in case then new m_RunMultiplier value is lower than the old).
 			SetSpeedMultiplier(m_SpeedMultiplier);
 
 			break;
 		}
 		}
 	}
 
 	void UpdateMessageSubscriptions()
 	{
 		bool needRender = m_DebugOverlayEnabled;
 		GetSimContext().GetComponentManager().DynamicSubscriptionNonsync(MT_RenderSubmit, this, needRender);
 	}
 
 	virtual bool IsMoving() const
 	{
 		return m_MoveRequest.m_Type != MoveRequest::NONE;
 	}
 
 	virtual fixed GetSpeedMultiplier() const
 	{
 		return m_SpeedMultiplier;
 	}
 
 	virtual void SetSpeedMultiplier(fixed multiplier)
 	{
 		m_SpeedMultiplier = std::min(multiplier, m_RunMultiplier);
 		m_Speed = m_SpeedMultiplier.Multiply(GetWalkSpeed());
 	}
 
 	virtual fixed GetSpeed() const
 	{
 		return m_Speed;
 	}
 
 	virtual fixed GetWalkSpeed() const
 	{
 		return m_WalkSpeed;
 	}
 
 	virtual fixed GetRunMultiplier() const
 	{
 		return m_RunMultiplier;
 	}
 
 	virtual pass_class_t GetPassabilityClass() const
 	{
 		return m_PassClass;
 	}
 
 	virtual std::string GetPassabilityClassName() const
 	{
 		return m_PassClassName;
 	}
 
 	virtual void SetPassabilityClassName(const std::string& passClassName)
 	{
 		m_PassClassName = passClassName;
 		CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
 		if (cmpPathfinder)
 			m_PassClass = cmpPathfinder->GetPassabilityClass(passClassName);
 	}
 
 	virtual fixed GetCurrentSpeed() const
 	{
 		return m_CurSpeed;
 	}
 
 	virtual void SetFacePointAfterMove(bool facePointAfterMove)
 	{
 		m_FacePointAfterMove = facePointAfterMove;
 	}
 
 	virtual void SetDebugOverlay(bool enabled)
 	{
 		m_DebugOverlayEnabled = enabled;
 		UpdateMessageSubscriptions();
 	}
 
 	virtual bool MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange);
 	virtual bool MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange);
 	virtual void MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z);
 
 	virtual void FaceTowardsPoint(entity_pos_t x, entity_pos_t z);
 
 	virtual void StopMoving()
 	{
 		if (m_FacePointAfterMove)
 		{
 			CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 			if (cmpPosition && cmpPosition->IsInWorld())
 				FaceTowardsPointFromPos(cmpPosition->GetPosition2D(), m_FinalGoal.x, m_FinalGoal.z);
 		}
 
 		m_MoveRequest = MoveRequest();
 		m_ExpectedPathTicket = 0;
 		m_PathState = PATHSTATE_NONE;
 		m_LongPath.m_Waypoints.clear();
 		m_ShortPath.m_Waypoints.clear();
 	}
 
 	virtual entity_pos_t GetUnitClearance() const
 	{
 		return m_Clearance;
 	}
 
 private:
 	bool ShouldAvoidMovingUnits() const
 	{
 		return !m_FormationController;
 	}
 
 	bool IsFormationMember() const
 	{
 		// TODO: this really shouldn't be what we are checking for.
 		return m_MoveRequest.m_Type == MoveRequest::OFFSET;
 	}
 
 	entity_id_t GetGroup() const
 	{
 		return IsFormationMember() ? m_MoveRequest.m_Entity : GetEntityId();
 	}
 
 	bool HasValidPath() const
 	{
 		return m_PathState == PATHSTATE_FOLLOWING
 			|| m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG
 			|| m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT;
 	}
 
 	void MoveFailed()
 	{
 		CMessageMotionChanged msg(true);
 		GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
 	}
 
 	void MoveSucceeded()
 	{
 		CMessageMotionChanged msg(false);
 		GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
 	}
 
 	/**
 	 * Update other components on our speed.
 	 * This doesn't use messages for efficiency.
 	 * This should only be called when speed changes.
 	 */
 	void UpdateMovementState(entity_pos_t speed)
 	{
 		CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
+		CmpPtr<ICmpVisual> cmpVisual(GetEntityHandle());
 		// Moved last turn, didn't this turn.
 		if (speed == fixed::Zero() && m_CurSpeed > fixed::Zero())
 		{
 			if (cmpObstruction)
 				cmpObstruction->SetMovingFlag(false);
+			if (cmpVisual)
+				cmpVisual->SelectMovementAnimation("idle", fixed::FromInt(1));
 		}
 		// Moved this turn, didn't last turn
 		else if (speed > fixed::Zero() && m_CurSpeed == fixed::Zero())
 		{
 			if (cmpObstruction)
 				cmpObstruction->SetMovingFlag(true);
+			if (cmpVisual)
+				cmpVisual->SelectMovementAnimation(m_Speed > m_WalkSpeed ? "run" : "walk", m_Speed);
 		}
+		// Speed change, update the visual actor if necessary.
+		else if (speed != m_CurSpeed && cmpVisual)
+			cmpVisual->SelectMovementAnimation(m_Speed > m_WalkSpeed ? "run" : "walk", m_Speed);
 
 		m_CurSpeed = speed;
 	}
 
 	bool MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange, entity_id_t target);
 
 	/**
 	 * Handle the result of an asynchronous path query.
 	 */
 	void PathResult(u32 ticket, const WaypointPath& path);
 
 	/**
 	 * Do the per-turn movement and other updates.
 	 */
 	void Move(fixed dt);
 
 	/**
 	 * Returns true if we are possibly at our destination.
 	 */
 	bool PossiblyAtDestination() const;
 
 	/**
 	 * Process the move the unit will do this turn.
 	 * This does not send actually change the position.
 	 * @returns true if the move was obstructed.
 	 */
 	bool PerformMove(fixed dt, WaypointPath& shortPath, WaypointPath& longPath, CFixedVector2D& pos) const;
 
 	/**
 	 * React if our move was obstructed.
 	 * @returns true if the obstruction required handling, false otherwise.
 	 */
 	bool HandleObstructedMove();
 
 	/**
 	 * Decide whether to approximate the given range from a square target as a circle,
 	 * rather than as a square.
 	 */
 	bool ShouldTreatTargetAsCircle(entity_pos_t range, entity_pos_t circleRadius) const;
 
 	/**
 	 * Returns true if the target position is valid. False otherwise.
 	 * (this may indicate that the target is e.g. out of the world/dead).
 	 * NB: for code-writing convenience, if we have no target, this returns true.
 	 */
 	bool TargetHasValidPosition() const;
 
 	/**
 	 * Computes the current location of our target entity (plus offset).
 	 * Returns false if no target entity or no valid position.
 	 */
 	bool ComputeTargetPosition(CFixedVector2D& out) const;
 
 	/**
 	 * Attempts to replace the current path with a straight line to the target,
 	 * if it's close enough and the route is not obstructed.
 	 */
 	bool TryGoingStraightToTarget(const CFixedVector2D& from);
 
 	/**
 	 * Returns whether our we need to recompute a path to reach our target.
 	 */
 	bool PathingUpdateNeeded(const CFixedVector2D& from);
 
 	/**
 	 * Update goal position if moving target
 	 */
 	void UpdateFinalGoal();
 
 	/**
 	 * Returns whether we are close enough to the target to assume it's a good enough
 	 * position to stop.
 	 */
 	bool CloseEnoughFromDestinationToStop(const CFixedVector2D& from) const;
 
 	/**
 	 * Returns whether the length of the given path, plus the distance from
 	 * 'from' to the first waypoints, it shorter than minDistance.
 	 */
 	bool PathIsShort(const WaypointPath& path, const CFixedVector2D& from, entity_pos_t minDistance) const;
 
 	/**
 	 * Rotate to face towards the target point, given the current pos
 	 */
 	void FaceTowardsPointFromPos(const CFixedVector2D& pos, entity_pos_t x, entity_pos_t z);
 
 	/**
 	 * Returns an appropriate obstruction filter for use with path requests.
 	 * noTarget is true only when used inside TryGoingStraightToTarget,
 	 * in which case we do not want the target obstruction otherwise it would always fail
 	 */
 	ControlGroupMovementObstructionFilter GetObstructionFilter(bool noTarget = false) const;
 
 	/**
 	 * Start moving to the given goal, from our current position 'from'.
 	 * Might go in a straight line immediately, or might start an asynchronous
 	 * path request.
 	 */
 	void BeginPathing(const CFixedVector2D& from, const PathGoal& goal);
 
 	/**
 	 * Start an asynchronous long path query.
 	 */
 	void RequestLongPath(const CFixedVector2D& from, const PathGoal& goal);
 
 	/**
 	 * Start an asynchronous short path query.
 	 */
 	void RequestShortPath(const CFixedVector2D& from, const PathGoal& goal, bool avoidMovingUnits);
 
 	/**
 	 * Convert a path into a renderable list of lines
 	 */
 	void RenderPath(const WaypointPath& path, std::vector<SOverlayLine>& lines, CColor color);
 
 	void RenderSubmit(SceneCollector& collector);
 };
 
 REGISTER_COMPONENT_TYPE(UnitMotion)
 
 void CCmpUnitMotion::PathResult(u32 ticket, const WaypointPath& path)
 {
 	// Ignore obsolete path requests
 	if (ticket != m_ExpectedPathTicket)
 		return;
 
 	m_ExpectedPathTicket = 0; // we don't expect to get this result again
 
 	// Check that we are still able to do something with that path
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 	{
 		// We will probably fail to move so inform components but keep on trying anyways.
 		MoveFailed();
 		return;
 	}
 
 	if (m_PathState == PATHSTATE_WAITING_REQUESTING_LONG || m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG)
 	{
 		m_LongPath = path;
 
 		// If we are following a path, leave the old m_ShortPath so we can carry on following it
 		// until a new short path has been computed
 		if (m_PathState == PATHSTATE_WAITING_REQUESTING_LONG)
 			m_ShortPath.m_Waypoints.clear();
 
 		// If there's no waypoints then we couldn't get near the target.
 		// Sort of hack: Just try going directly to the goal point instead
 		// (via the short pathfinder), so if we're stuck and the user clicks
 		// close enough to the unit then we can probably get unstuck
 		if (m_LongPath.m_Waypoints.empty())
 			m_LongPath.m_Waypoints.emplace_back(Waypoint{ m_FinalGoal.x, m_FinalGoal.z });
 
 		m_PathState = PATHSTATE_FOLLOWING;
 	}
 	else if (m_PathState == PATHSTATE_WAITING_REQUESTING_SHORT || m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT)
 	{
 		m_ShortPath = path;
 
 		// If there's no waypoints then we couldn't get near the target
 		if (m_ShortPath.m_Waypoints.empty())
 		{
 			// If we're globally following a long path, try to remove the next waypoint, it might be obstructed
 			// If not, and we are not in a formation, retry
 			// unless we are close to our target and we don't have a target entity.
 			// This makes sure that units don't clump too much when they are not in a formation and tasked to move.
 			if (m_LongPath.m_Waypoints.size() > 1)
 				m_LongPath.m_Waypoints.pop_back();
 			else if (IsFormationMember())
 			{
 				CMessageMotionChanged msg(true);
 				GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
 				return;
 			}
 
 			CMessageMotionChanged msg(false);
 			GetSimContext().GetComponentManager().PostMessage(GetEntityId(), msg);
 
 			CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 			if (!cmpPosition || !cmpPosition->IsInWorld())
 				return;
 
 			CFixedVector2D pos = cmpPosition->GetPosition2D();
 
 			if (CloseEnoughFromDestinationToStop(pos))
 			{
 				MoveSucceeded();
 				return;
 			}
 
 			UpdateFinalGoal();
 			RequestLongPath(pos, m_FinalGoal);
 			m_PathState = PATHSTATE_WAITING_REQUESTING_LONG;
 			return;
 		}
 
 		// else we could, so reset our number of tries.
 		m_Tries = 0;
 
 		m_PathState = PATHSTATE_FOLLOWING;
 	}
 	else
 		LOGWARNING("unexpected PathResult (%u %d)", GetEntityId(), m_PathState);
 }
 
 void CCmpUnitMotion::Move(fixed dt)
 {
 	PROFILE("Move");
 
 	// If we were idle and will still be, we can return.
 	// TODO: this will need to be removed if pushing is implemented.
 	if (m_CurSpeed == fixed::Zero() && m_MoveRequest.m_Type == MoveRequest::NONE)
 		return;
 
 	if (PossiblyAtDestination())
 		MoveSucceeded();
 	else if (!TargetHasValidPosition())
 	{
 		// Scrap waypoints - we don't know where to go.
 		// If the move request remains unchanged and the target again has a valid position later on,
 		// moving will be resumed.
 		// Units may want to move to move to the target's last known position,
 		// but that should be decided by UnitAI (handling MoveFailed), not UnitMotion.
 		m_LongPath.m_Waypoints.clear();
 		m_ShortPath.m_Waypoints.clear();
 
 		MoveFailed();
 	}
 
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 		return;
 
 	CFixedVector2D initialPos = cmpPosition->GetPosition2D();
 
 	// Keep track of the current unit's position during the update
 	CFixedVector2D pos = initialPos;
 
 	// If we're chasing a potentially-moving unit and are currently close
 	// enough to its current position, and we can head in a straight line
 	// to it, then throw away our current path and go straight to it
 	if (m_PathState == PATHSTATE_FOLLOWING ||
 		m_PathState == PATHSTATE_FOLLOWING_REQUESTING_SHORT ||
 		m_PathState == PATHSTATE_FOLLOWING_REQUESTING_LONG)
 		TryGoingStraightToTarget(initialPos);
 
 	bool wasObstructed = PerformMove(dt, m_ShortPath, m_LongPath, pos);
 
 	// Update our speed over this turn so that the visual actor shows the correct animation.
 	if (pos == initialPos)
 		UpdateMovementState(fixed::Zero());
 	else
 	{
 		// Update the Position component after our movement (if we actually moved anywhere)
 		CFixedVector2D offset = pos - initialPos;
 
 		// Face towards the target
 		entity_angle_t angle = atan2_approx(offset.X, offset.Y);
 		cmpPosition->MoveAndTurnTo(pos.X,pos.Y, angle);
 
 		// Calculate the mean speed over this past turn.
 		UpdateMovementState(offset.Length() / dt);
 	}
 
 	if (wasObstructed && HandleObstructedMove())
 		return;
 
 	if (m_PathState == PATHSTATE_FOLLOWING)
 	{
 		// We may need to recompute our path sometimes (e.g. if our target moves).
 		// Since we request paths asynchronously anyways, this does not need to be done before moving.
 		PathingUpdateNeeded(pos);
 	}
 }
 
 bool CCmpUnitMotion::PossiblyAtDestination() const
 {
 	if (m_MoveRequest.m_Type == MoveRequest::NONE)
 		return false;
 
 	if (IsFormationMember())
 	{
 		// We've reached our assigned position. If the controller
 		// is idle, send a notification in case it should disband,
 		// otherwise continue following the formation next turn.
 		CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), m_MoveRequest.m_Entity);
 		return cmpUnitMotion && !cmpUnitMotion->IsMoving();
 	}
 
 	CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSystemEntity());
 	ENSURE(cmpObstructionManager);
 
 	if (m_MoveRequest.m_Type == MoveRequest::POINT)
 		return cmpObstructionManager->IsInPointRange(GetEntityId(), m_MoveRequest.m_Position.X, m_MoveRequest.m_Position.Y, m_MoveRequest.m_MinRange, m_MoveRequest.m_MaxRange, false);
 	if (m_MoveRequest.m_Type == MoveRequest::ENTITY)
 		return cmpObstructionManager->IsInTargetRange(GetEntityId(), m_MoveRequest.m_Entity, m_MoveRequest.m_MinRange, m_MoveRequest.m_MaxRange, false);
 	if (m_MoveRequest.m_Type == MoveRequest::OFFSET)
 	{
 		CFixedVector2D targetPos;
 		ComputeTargetPosition(targetPos);
 		return cmpObstructionManager->IsInPointRange(GetEntityId(), m_MoveRequest.m_Position.X, m_MoveRequest.m_Position.Y, m_MoveRequest.m_MinRange, m_MoveRequest.m_MaxRange, false);
 	}
 	return false;
 }
 
 bool CCmpUnitMotion::PerformMove(fixed dt, WaypointPath& shortPath, WaypointPath& longPath, CFixedVector2D& pos) const
 {
 	if (m_PathState != PATHSTATE_FOLLOWING &&
 	    m_PathState != PATHSTATE_FOLLOWING_REQUESTING_SHORT &&
 	    m_PathState != PATHSTATE_FOLLOWING_REQUESTING_LONG)
 		return false;
 
 	// TODO: there's some asymmetry here when units look at other
 	// units' positions - the result will depend on the order of execution.
 	// Maybe we should split the updates into multiple phases to minimise
 	// that problem.
 
 	CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
 	if (!cmpPathfinder)
 		return false;
 
 	fixed basicSpeed = m_Speed;
 	// If in formation, run to keep up; otherwise just walk
 	if (IsFormationMember())
 		basicSpeed = m_Speed.Multiply(m_RunMultiplier);
 
 	// Find the speed factor of the underlying terrain
 	// (We only care about the tile we start on - it doesn't matter if we're moving
 	// partially onto a much slower/faster tile)
 	// TODO: Terrain-dependent speeds are not currently supported
 	fixed terrainSpeed = fixed::FromInt(1);
 
 	fixed maxSpeed = basicSpeed.Multiply(terrainSpeed);
 
 	// We want to move (at most) maxSpeed*dt units from pos towards the next waypoint
 
 	fixed timeLeft = dt;
 	fixed zero = fixed::Zero();
 
 	while (timeLeft > zero)
 	{
 		// If we ran out of path, we have to stop
 		if (shortPath.m_Waypoints.empty() && longPath.m_Waypoints.empty())
 			break;
 
 		CFixedVector2D target;
 		if (shortPath.m_Waypoints.empty())
 			target = CFixedVector2D(longPath.m_Waypoints.back().x, longPath.m_Waypoints.back().z);
 		else
 			target = CFixedVector2D(shortPath.m_Waypoints.back().x, shortPath.m_Waypoints.back().z);
 
 		CFixedVector2D offset = target - pos;
 
 		// Work out how far we can travel in timeLeft
 		fixed maxdist = maxSpeed.Multiply(timeLeft);
 
 		// If the target is close, we can move there directly
 		fixed offsetLength = offset.Length();
 		if (offsetLength <= maxdist)
 		{
 			if (cmpPathfinder->CheckMovement(GetObstructionFilter(), pos.X, pos.Y, target.X, target.Y, m_Clearance, m_PassClass))
 			{
 				pos = target;
 
 				// Spend the rest of the time heading towards the next waypoint
 				timeLeft = (maxdist - offsetLength) / maxSpeed;
 
 				if (shortPath.m_Waypoints.empty())
 					longPath.m_Waypoints.pop_back();
 				else
 					shortPath.m_Waypoints.pop_back();
 
 				continue;
 			}
 			else
 			{
 				// Error - path was obstructed
 				return true;
 			}
 		}
 		else
 		{
 			// Not close enough, so just move in the right direction
 			offset.Normalize(maxdist);
 			target = pos + offset;
 
 			if (cmpPathfinder->CheckMovement(GetObstructionFilter(), pos.X, pos.Y, target.X, target.Y, m_Clearance, m_PassClass))
 				pos = target;
 			else
 				return true;
 
 			break;
 		}
 	}
 	return false;
 }
 
 bool CCmpUnitMotion::HandleObstructedMove()
 {
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 		return false;
 
 	CFixedVector2D pos = cmpPosition->GetPosition2D();
 
 	// Oops, we hit something (very likely another unit).
 
 	if (CloseEnoughFromDestinationToStop(pos))
 	{
 		// Pretend we're arrived in case other components agree and we end up stopping moving.
 		MoveSucceeded();
 		return true;
 	}
 
 	// If we still have long waypoints, try and compute a short path
 	// This will get us around units, amongst others.
 	// However in some cases a long waypoint will be in located in the obstruction of
 	// an idle unit. In that case, we need to scrap that waypoint or we might never be able to reach it.
 	// I am not sure why this happens but the following code seems to work.
 	if (!m_LongPath.m_Waypoints.empty())
 	{
 		CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSystemEntity());
 		if (cmpObstructionManager)
 		{
 			// create a fake obstruction to represent our waypoint.
 			ICmpObstructionManager::ObstructionSquare square;
 			square.hh = m_Clearance;
 			square.hw = m_Clearance;
 			square.u = CFixedVector2D(entity_pos_t::FromInt(1),entity_pos_t::FromInt(0));
 			square.v = CFixedVector2D(entity_pos_t::FromInt(0),entity_pos_t::FromInt(1));
 			square.x = m_LongPath.m_Waypoints.back().x;
 			square.z = m_LongPath.m_Waypoints.back().z;
 			std::vector<entity_id_t> unitOnGoal;
 			// don't ignore moving units as those might be units like us, ie not really moving.
 			cmpObstructionManager->GetUnitsOnObstruction(square, unitOnGoal, GetObstructionFilter());
 			if (!unitOnGoal.empty())
 				m_LongPath.m_Waypoints.pop_back();
 		}
 		if (!m_LongPath.m_Waypoints.empty())
 		{
 			PathGoal goal;
 			if (m_LongPath.m_Waypoints.size() > 1 || m_FinalGoal.DistanceToPoint(pos) > LONG_PATH_MIN_DIST)
 				goal = { PathGoal::POINT, m_LongPath.m_Waypoints.back().x, m_LongPath.m_Waypoints.back().z };
 			else
 			{
 				UpdateFinalGoal();
 				goal = m_FinalGoal;
 				m_LongPath.m_Waypoints.clear();
 				CFixedVector2D target = goal.NearestPointOnGoal(pos);
 				m_LongPath.m_Waypoints.emplace_back(Waypoint{ target.X, target.Y });
 			}
 			RequestShortPath(pos, goal, true);
 			m_PathState = PATHSTATE_WAITING_REQUESTING_SHORT;
 			return true;
 		}
 	}
 	// Else, just entirely recompute
 	UpdateFinalGoal();
 	BeginPathing(pos, m_FinalGoal);
 
 	// potential TODO: We could switch the short-range pathfinder for something else entirely.
 	return true;
 }
 
 bool CCmpUnitMotion::TargetHasValidPosition() const
 {
 	if (m_MoveRequest.m_Type != MoveRequest::ENTITY)
 		return true;
 
 	CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), m_MoveRequest.m_Entity);
 	return cmpPosition && cmpPosition->IsInWorld();
 }
 
 bool CCmpUnitMotion::ComputeTargetPosition(CFixedVector2D& out) const
 {
 	if (m_MoveRequest.m_Type == MoveRequest::POINT)
 	{
 		out = CFixedVector2D(m_MoveRequest.m_Position.X, m_MoveRequest.m_Position.Y);
 		return true;
 	}
 
 	CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), m_MoveRequest.m_Entity);
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 		return false;
 
 	if (m_MoveRequest.m_Type == MoveRequest::OFFSET)
 	{
 		// There is an offset, so compute it relative to orientation
 		entity_angle_t angle = cmpPosition->GetRotation().Y;
 		CFixedVector2D offset = m_MoveRequest.GetOffset().Rotate(angle);
 		out = cmpPosition->GetPosition2D() + offset;
 	}
 	else
 	{
 		out = cmpPosition->GetPosition2D();
 		// If the target is moving, we might never get in range if we just try to reach its current position,
 		// so we have to try and move to a position where we will be in-range, including their movement.
 		// Since we request paths asynchronously a the end of our turn, we need to account for twice the movement speed.
 		// TODO: be cleverer about this. It fixes fleeing nicely currently, but orthogonal movement should be considered,
 		// and the overall logic could be improved upon.
 		CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), m_MoveRequest.m_Entity);
 		if (cmpUnitMotion && cmpUnitMotion->IsMoving())
 			out += (out - cmpPosition->GetPreviousPosition2D()) * 2;
 	}
 	return true;
 }
 
 bool CCmpUnitMotion::TryGoingStraightToTarget(const CFixedVector2D& from)
 {
 	CFixedVector2D targetPos;
 	if (!ComputeTargetPosition(targetPos))
 		return false;
 
 	// Fail if the target is too far away
 	if ((targetPos - from).CompareLength(DIRECT_PATH_RANGE) > 0)
 		return false;
 
 	CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
 	if (!cmpPathfinder)
 		return false;
 
 	// Move the goal to match the target entity's new position
 	PathGoal goal = m_FinalGoal;
 	goal.x = targetPos.X;
 	goal.z = targetPos.Y;
 	// (we ignore changes to the target's rotation, since only buildings are
 	// square and buildings don't move)
 
 	// Find the point on the goal shape that we should head towards
 	CFixedVector2D goalPos = goal.NearestPointOnGoal(from);
 
 	// Check if there's any collisions on that route
 	if (!cmpPathfinder->CheckMovement(GetObstructionFilter(true), from.X, from.Y, goalPos.X, goalPos.Y, m_Clearance, m_PassClass))
 		return false;
 
 	// That route is okay, so update our path
 	m_FinalGoal = goal;
 	m_LongPath.m_Waypoints.clear();
 	m_ShortPath.m_Waypoints.clear();
 	m_ShortPath.m_Waypoints.emplace_back(Waypoint{ goalPos.X, goalPos.Y });
 
 	return true;
 }
 
 bool CCmpUnitMotion::PathingUpdateNeeded(const CFixedVector2D& from)
 {
 	if (m_MoveRequest.m_Type == MoveRequest::NONE)
 		return false;
 
 	CFixedVector2D targetPos;
 	if (!ComputeTargetPosition(targetPos))
 		return false;
 
 	if (PossiblyAtDestination())
 		return false;
 
 	// Get the obstruction shape and translate it where we estimate the target to be.
 	ICmpObstructionManager::ObstructionSquare estimatedTargetShape;
 	if (m_MoveRequest.m_Type == MoveRequest::ENTITY)
 	{
 		CmpPtr<ICmpObstruction> cmpTargetObstruction(GetSimContext(), m_MoveRequest.m_Entity);
 		if (cmpTargetObstruction)
 			cmpTargetObstruction->GetObstructionSquare(estimatedTargetShape);
 	}
 
 	estimatedTargetShape.x = targetPos.X;
 	estimatedTargetShape.z = targetPos.Y;
 
 	CmpPtr<ICmpObstruction> cmpObstruction(GetEntityHandle());
 	ICmpObstructionManager::ObstructionSquare shape;
 	if (cmpObstruction)
 		cmpObstruction->GetObstructionSquare(shape);
 
 	// Translate our own obstruction shape to our last waypoint or our current position, lacking that.
 	if (m_LongPath.m_Waypoints.empty() && m_ShortPath.m_Waypoints.empty())
 	{
 		shape.x = from.X;
 		shape.z = from.Y;
 	}
 	else
 	{
 		Waypoint& lastWaypoint = m_ShortPath.m_Waypoints.empty() ? m_LongPath.m_Waypoints.front() : m_ShortPath.m_Waypoints.front();
 		shape.x = lastWaypoint.x;
 		shape.z = lastWaypoint.z;
 	}
 
 	CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSystemEntity());
 	ENSURE(cmpObstructionManager);
 
 	if (cmpObstructionManager->AreShapesInRange(shape, estimatedTargetShape,
 	      m_MoveRequest.m_MinRange, m_MoveRequest.m_MaxRange, false))
 		return false;
 
 	// We won't be in-range when we reach our final waypoint : recompute our path.
 	m_FinalGoal.x = estimatedTargetShape.x;
 	m_FinalGoal.z = estimatedTargetShape.z;
 	BeginPathing(from, m_FinalGoal);
 	m_PathState = PATHSTATE_FOLLOWING_REQUESTING_LONG;
 	return true;
 }
 
 void CCmpUnitMotion::UpdateFinalGoal()
 {
 	if (m_MoveRequest.m_Type != MoveRequest::ENTITY || m_MoveRequest.m_Type != MoveRequest::OFFSET)
 		return;
 	CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), m_MoveRequest.m_Entity);
 	if (!cmpUnitMotion)
 		return;
 	if (IsFormationMember())
 		return;
 	CFixedVector2D targetPos;
 	if (!ComputeTargetPosition(targetPos))
 		return;
 	m_FinalGoal.x = targetPos.X;
 	m_FinalGoal.z = targetPos.Y;
 }
 
 bool CCmpUnitMotion::CloseEnoughFromDestinationToStop(const CFixedVector2D& from) const
 {
 	if (m_MoveRequest.m_Type != MoveRequest::POINT || m_FinalGoal.DistanceToPoint(from) > SHORT_PATH_GOAL_RADIUS)
 		return false;
 	return true;
 }
 
 bool CCmpUnitMotion::PathIsShort(const WaypointPath& path, const CFixedVector2D& from, entity_pos_t minDistance) const
 {
 	CFixedVector2D prev = from;
 	entity_pos_t distLeft = minDistance;
 
 	for (ssize_t i = (ssize_t)path.m_Waypoints.size()-1; i >= 0; --i)
 	{
 		// Check if the next path segment is longer than the requested minimum
 		CFixedVector2D waypoint(path.m_Waypoints[i].x, path.m_Waypoints[i].z);
 		CFixedVector2D delta = waypoint - prev;
 		if (delta.CompareLength(distLeft) > 0)
 			return false;
 
 		// Still short enough - prepare to check the next segment
 		distLeft -= delta.Length();
 		prev = waypoint;
 	}
 
 	// Reached the end of the path before exceeding minDistance
 	return true;
 }
 
 void CCmpUnitMotion::FaceTowardsPoint(entity_pos_t x, entity_pos_t z)
 {
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 		return;
 
 	CFixedVector2D pos = cmpPosition->GetPosition2D();
 	FaceTowardsPointFromPos(pos, x, z);
 }
 
 void CCmpUnitMotion::FaceTowardsPointFromPos(const CFixedVector2D& pos, entity_pos_t x, entity_pos_t z)
 {
 	CFixedVector2D target(x, z);
 	CFixedVector2D offset = target - pos;
 	if (!offset.IsZero())
 	{
 		entity_angle_t angle = atan2_approx(offset.X, offset.Y);
 
 		CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 		if (!cmpPosition)
 			return;
 		cmpPosition->TurnTo(angle);
 	}
 }
 
 ControlGroupMovementObstructionFilter CCmpUnitMotion::GetObstructionFilter(bool noTarget) const
 {
 	entity_id_t group = noTarget ? m_MoveRequest.m_Entity : GetGroup();
 	return ControlGroupMovementObstructionFilter(ShouldAvoidMovingUnits(), group);
 }
 
 
 
 void CCmpUnitMotion::BeginPathing(const CFixedVector2D& from, const PathGoal& goal)
 {
 	// reset our state for sanity.
 	m_ExpectedPathTicket = 0;
 
 	m_PathState = PATHSTATE_NONE;
 
 #if DISABLE_PATHFINDER
 	{
 		CmpPtr<ICmpPathfinder> cmpPathfinder (GetSimContext(), SYSTEM_ENTITY);
 		CFixedVector2D goalPos = m_FinalGoal.NearestPointOnGoal(from);
 		m_LongPath.m_Waypoints.clear();
 		m_ShortPath.m_Waypoints.clear();
 		m_ShortPath.m_Waypoints.emplace_back(Waypoint{ goalPos.X, goalPos.Y });
 		m_PathState = PATHSTATE_FOLLOWING;
 		return;
 	}
 #endif
 
 	// If the target is close and we can reach it in a straight line,
 	// then we'll just go along the straight line instead of computing a path.
 	if (TryGoingStraightToTarget(from))
 	{
 		m_PathState = PATHSTATE_FOLLOWING;
 		return;
 	}
 
 	// Otherwise we need to compute a path.
 
 	// If it's close then just do a short path, not a long path
 	// TODO: If it's close on the opposite side of a river then we really
 	// need a long path, so we shouldn't simply check linear distance
 	// the check is arbitrary but should be a reasonably small distance.
 	if (goal.DistanceToPoint(from) < LONG_PATH_MIN_DIST)
 	{
 		// add our final goal as a long range waypoint so we don't forget
 		// where we are going if the short-range pathfinder returns
 		// an aborted path.
 		m_LongPath.m_Waypoints.clear();
 		CFixedVector2D target = m_FinalGoal.NearestPointOnGoal(from);
 		m_LongPath.m_Waypoints.emplace_back(Waypoint{ target.X, target.Y });
 		m_PathState = PATHSTATE_WAITING_REQUESTING_SHORT;
 		RequestShortPath(from, goal, true);
 	}
 	else
 	{
 		m_PathState = PATHSTATE_WAITING_REQUESTING_LONG;
 		RequestLongPath(from, goal);
 	}
 }
 
 void CCmpUnitMotion::RequestLongPath(const CFixedVector2D& from, const PathGoal& goal)
 {
 	CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
 	if (!cmpPathfinder)
 		return;
 
 	// this is by how much our waypoints will be apart at most.
 	// this value here seems sensible enough.
 	PathGoal improvedGoal = goal;
 	improvedGoal.maxdist = SHORT_PATH_MIN_SEARCH_RANGE - entity_pos_t::FromInt(1);
 
 	cmpPathfinder->SetDebugPath(from.X, from.Y, improvedGoal, m_PassClass);
 
 	m_ExpectedPathTicket = cmpPathfinder->ComputePathAsync(from.X, from.Y, improvedGoal, m_PassClass, GetEntityId());
 }
 
 void CCmpUnitMotion::RequestShortPath(const CFixedVector2D &from, const PathGoal& goal, bool avoidMovingUnits)
 {
 	CmpPtr<ICmpPathfinder> cmpPathfinder(GetSystemEntity());
 	if (!cmpPathfinder)
 		return;
 
 	// wrapping around on m_Tries isn't really a problem so don't check for overflow.
 	fixed searchRange = std::max(SHORT_PATH_MIN_SEARCH_RANGE * ++m_Tries, goal.DistanceToPoint(from));
 	if (goal.type != PathGoal::POINT && searchRange < goal.hw && searchRange < SHORT_PATH_MIN_SEARCH_RANGE * 2)
 		searchRange = std::min(goal.hw, SHORT_PATH_MIN_SEARCH_RANGE * 2);
 	if (searchRange > SHORT_PATH_MAX_SEARCH_RANGE)
 		searchRange = SHORT_PATH_MAX_SEARCH_RANGE;
 
 	m_ExpectedPathTicket = cmpPathfinder->ComputeShortPathAsync(from.X, from.Y, m_Clearance, searchRange, goal, m_PassClass, avoidMovingUnits, GetGroup(), GetEntityId());
 }
 
 bool CCmpUnitMotion::MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange)
 {
 	return MoveToPointRange(x, z, minRange, maxRange, INVALID_ENTITY);
 }
 
 bool CCmpUnitMotion::MoveToPointRange(entity_pos_t x, entity_pos_t z, entity_pos_t minRange, entity_pos_t maxRange, entity_id_t target)
 {
 	PROFILE("MoveToPointRange");
 
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 		return false;
 
 	CFixedVector2D pos = cmpPosition->GetPosition2D();
 
 	PathGoal goal;
 	goal.x = x;
 	goal.z = z;
 
 	if (minRange.IsZero() && maxRange.IsZero())
 	{
 		// Non-ranged movement:
 
 		// Head directly for the goal
 		goal.type = PathGoal::POINT;
 	}
 	else
 	{
 		// Ranged movement:
 
 		entity_pos_t distance = (pos - CFixedVector2D(x, z)).Length();
 
 		if (distance < minRange)
 		{
 			// Too close to target - move outwards to a circle
 			// that's slightly larger than the min range.
 			goal.type = PathGoal::INVERTED_CIRCLE;
 
 			// Distance checks are nearest edge to nearest edge, so we need to account for our clearance
 			// and we must make sure diagonals also fit so multiply by slightly more than sqrt(2)
 			goal.hw = minRange + m_Clearance * 3 /2;
 		}
 		else if (maxRange >= entity_pos_t::Zero() && distance > maxRange)
 		{
 			// Too far from target - move inwards to a circle
 			// that's slightly smaller than the max range
 			goal.type = PathGoal::CIRCLE;
 			goal.hw = maxRange;
 
 			// If maxRange was abnormally small,
 			// collapse the circle into a point
 			if (goal.hw <= entity_pos_t::Zero())
 				goal.type = PathGoal::POINT;
 		}
 	}
 
 	m_MoveRequest = MoveRequest(CFixedVector2D(x, z), minRange, maxRange);
 	m_FinalGoal = goal;
 	m_Tries = 0;
 
 	BeginPathing(pos, goal);
 
 	return true;
 }
 
 bool CCmpUnitMotion::ShouldTreatTargetAsCircle(entity_pos_t range, entity_pos_t circleRadius) const
 {
 	// Given a square, plus a target range we should reach, the shape at that distance
 	// is a round-cornered square which we can approximate as either a circle or as a square.
 	// Previously, we used the shape that minimized the worst-case error.
 	// However that is unsage in some situations. So let's be less clever and
 	// just check if our range is at least three times bigger than the circleradius
 	return (range > circleRadius*3);
 }
 
 bool CCmpUnitMotion::MoveToTargetRange(entity_id_t target, entity_pos_t minRange, entity_pos_t maxRange)
 {
 	PROFILE("MoveToTargetRange");
 
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 		return false;
 
 	CFixedVector2D pos = cmpPosition->GetPosition2D();
 
 	CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSystemEntity());
 	if (!cmpObstructionManager)
 		return false;
 
 	bool hasObstruction = false;
 	ICmpObstructionManager::ObstructionSquare obstruction;
 	CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), target);
 	if (cmpObstruction)
 		hasObstruction = cmpObstruction->GetObstructionSquare(obstruction);
 
 	if (!hasObstruction)
 	{
 		// The target didn't have an obstruction or obstruction shape, so treat it as a point instead
 
 		CmpPtr<ICmpPosition> cmpTargetPosition(GetSimContext(), target);
 		if (!cmpTargetPosition || !cmpTargetPosition->IsInWorld())
 			return false;
 
 		CFixedVector2D targetPos = cmpTargetPosition->GetPosition2D();
 
 		return MoveToPointRange(targetPos.X, targetPos.Y, minRange, maxRange);
 	}
 
 	/*
 	* If we're starting outside the maxRange, we need to move closer in.
 	* If we're starting inside the minRange, we need to move further out.
 	* These ranges are measured from the edge of this entity to the edge of the target;
 	* we add the goal range onto the size of the target shape to get the goal shape.
 	* (Then we extend it outwards/inwards by a little bit to be sure we'll end up
 	* within the right range, in case of minor numerical inaccuracies.)
 	*
 	* There's a bit of a problem with large square targets:
 	* the pathfinder only lets us move to goals that are squares, but the points an equal
 	* distance from the target make a rounded square shape instead.
 	*
 	* When moving closer, we could shrink the goal radius to 1/sqrt(2) so the goal shape fits entirely
 	* within the desired rounded square, but that gives an unfair advantage to attackers who approach
 	* the target diagonally.
 	*
 	* If the target is small relative to the range (e.g. archers attacking anything),
 	* then we cheat and pretend the target is actually a circle.
 	* (TODO: that probably looks rubbish for things like walls?)
 	*
 	* If the target is large relative to the range (e.g. melee units attacking buildings),
 	* then we multiply maxRange by approx 1/sqrt(2) to guarantee they'll always aim close enough.
 	* (Those units should set minRange to 0 so they'll never be considered *too* close.)
 	*/
 
 	CFixedVector2D halfSize(obstruction.hw, obstruction.hh);
 	PathGoal goal;
 	goal.x = obstruction.x;
 	goal.z = obstruction.z;
 
 	entity_pos_t distance = Geometry::DistanceToSquare(pos - CFixedVector2D(obstruction.x, obstruction.z), obstruction.u, obstruction.v, halfSize, true);
 
 	// Compare with previous obstruction
 	ICmpObstructionManager::ObstructionSquare previousObstruction;
 	cmpObstruction->GetPreviousObstructionSquare(previousObstruction);
 	entity_pos_t previousDistance = Geometry::DistanceToSquare(pos - CFixedVector2D(previousObstruction.x, previousObstruction.z), obstruction.u, obstruction.v, halfSize, true);
 
 	bool inside = distance.IsZero() && !Geometry::DistanceToSquare(pos - CFixedVector2D(obstruction.x, obstruction.z), obstruction.u, obstruction.v, halfSize).IsZero();
 	if ((distance < minRange && previousDistance < minRange) || inside)
 	{
 		// Too close to the square - need to move away
 
 		// Circumscribe the square
 		entity_pos_t circleRadius = halfSize.Length();
 
 		// Distance checks are nearest edge to nearest edge, so we need to account for our clearance
 		// and we must make sure diagonals also fit so multiply by slightly more than sqrt(2)
 		entity_pos_t goalDistance = minRange + m_Clearance * 3 /2;
 
 		if (ShouldTreatTargetAsCircle(minRange, circleRadius))
 		{
 			// The target is small relative to our range, so pretend it's a circle
 			goal.type = PathGoal::INVERTED_CIRCLE;
 			goal.hw = circleRadius + goalDistance;
 		}
 		else
 		{
 			goal.type = PathGoal::INVERTED_SQUARE;
 			goal.u = obstruction.u;
 			goal.v = obstruction.v;
 			goal.hw = obstruction.hw + goalDistance;
 			goal.hh = obstruction.hh + goalDistance;
 		}
 	}
 	else
 	{
 		// We might need to move closer:
 
 		// Circumscribe the square
 		entity_pos_t circleRadius = halfSize.Length();
 
 		if (ShouldTreatTargetAsCircle(maxRange, circleRadius))
 		{
 			// The target is small relative to our range, so pretend it's a circle
 
 			// Note that the distance to the circle will always be less than
 			// the distance to the square, so the previous "distance < maxRange"
 			// check is still valid (though not sufficient)
 			entity_pos_t circleDistance = (pos - CFixedVector2D(obstruction.x, obstruction.z)).Length() - circleRadius;
 			entity_pos_t previousCircleDistance = (pos - CFixedVector2D(previousObstruction.x, previousObstruction.z)).Length() - circleRadius;
 
 			entity_pos_t goalDistance = maxRange;
 
 			goal.type = PathGoal::CIRCLE;
 			goal.hw = circleRadius + goalDistance;
 		}
 		else
 		{
 			// The target is large relative to our range, so treat it as a square and
 			// get close enough that the diagonals come within range
 
 			entity_pos_t goalDistance = maxRange * 2 / 3; // multiply by slightly less than 1/sqrt(2)
 
 			goal.type = PathGoal::SQUARE;
 			goal.u = obstruction.u;
 			goal.v = obstruction.v;
 			entity_pos_t delta = std::max(goalDistance, m_Clearance + entity_pos_t::FromInt(TERRAIN_TILE_SIZE)/16); // ensure it's far enough to not intersect the building itself
 			goal.hw = obstruction.hw + delta;
 			goal.hh = obstruction.hh + delta;
 		}
 	}
 
 	m_MoveRequest = MoveRequest(target, minRange, maxRange);
 	m_FinalGoal = goal;
 	m_Tries = 0;
 
 	BeginPathing(pos, goal);
 
 	return true;
 }
 
 void CCmpUnitMotion::MoveToFormationOffset(entity_id_t target, entity_pos_t x, entity_pos_t z)
 {
 	CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), target);
 	if (!cmpPosition || !cmpPosition->IsInWorld())
 		return;
 
 	CFixedVector2D pos = cmpPosition->GetPosition2D();
 
 	PathGoal goal;
 	goal.type = PathGoal::POINT;
 	goal.x = pos.X;
 	goal.z = pos.Y;
 
 	m_MoveRequest = MoveRequest(target, CFixedVector2D(x, z));
 	m_FinalGoal = goal;
 	m_Tries = 0;
 
 	BeginPathing(pos, goal);
 }
 
 
 
 
 
 void CCmpUnitMotion::RenderPath(const WaypointPath& path, std::vector<SOverlayLine>& lines, CColor color)
 {
 	bool floating = false;
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (cmpPosition)
 		floating = cmpPosition->CanFloat();
 
 	lines.clear();
 	std::vector<float> waypointCoords;
 	for (size_t i = 0; i < path.m_Waypoints.size(); ++i)
 	{
 		float x = path.m_Waypoints[i].x.ToFloat();
 		float z = path.m_Waypoints[i].z.ToFloat();
 		waypointCoords.push_back(x);
 		waypointCoords.push_back(z);
 		lines.push_back(SOverlayLine());
 		lines.back().m_Color = color;
 		SimRender::ConstructSquareOnGround(GetSimContext(), x, z, 1.0f, 1.0f, 0.0f, lines.back(), floating);
 	}
 	float x = cmpPosition->GetPosition2D().X.ToFloat();
 	float z = cmpPosition->GetPosition2D().Y.ToFloat();
 	waypointCoords.push_back(x);
 	waypointCoords.push_back(z);
 	lines.push_back(SOverlayLine());
 	lines.back().m_Color = color;
 	SimRender::ConstructLineOnGround(GetSimContext(), waypointCoords, lines.back(), floating);
 
 }
 
 void CCmpUnitMotion::RenderSubmit(SceneCollector& collector)
 {
 	if (!m_DebugOverlayEnabled)
 		return;
 
 	RenderPath(m_LongPath, m_DebugOverlayLongPathLines, OVERLAY_COLOR_LONG_PATH);
 	RenderPath(m_ShortPath, m_DebugOverlayShortPathLines, OVERLAY_COLOR_SHORT_PATH);
 
 	for (size_t i = 0; i < m_DebugOverlayLongPathLines.size(); ++i)
 		collector.Submit(&m_DebugOverlayLongPathLines[i]);
 
 	for (size_t i = 0; i < m_DebugOverlayShortPathLines.size(); ++i)
 		collector.Submit(&m_DebugOverlayShortPathLines[i]);
 }
Index: ps/trunk/source/simulation2/components/CCmpVisualActor.cpp
===================================================================
--- ps/trunk/source/simulation2/components/CCmpVisualActor.cpp	(revision 22445)
+++ ps/trunk/source/simulation2/components/CCmpVisualActor.cpp	(revision 22446)
@@ -1,788 +1,740 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "simulation2/system/Component.h"
 #include "ICmpVisual.h"
 
 #include "simulation2/MessageTypes.h"
 
 #include "ICmpFootprint.h"
 #include "ICmpUnitRenderer.h"
 #include "ICmpOwnership.h"
 #include "ICmpPosition.h"
 #include "ICmpTemplateManager.h"
 #include "ICmpTerrain.h"
 #include "ICmpUnitMotion.h"
 #include "ICmpValueModificationManager.h"
 #include "ICmpVisibility.h"
 #include "ICmpSound.h"
 
 #include "simulation2/serialization/SerializeTemplates.h"
 
 #include "graphics/Decal.h"
 #include "graphics/Frustum.h"
 #include "graphics/Model.h"
 #include "graphics/ObjectBase.h"
 #include "graphics/ObjectEntry.h"
 #include "graphics/Unit.h"
 #include "graphics/UnitAnimation.h"
 #include "graphics/UnitManager.h"
 #include "maths/BoundingSphere.h"
 #include "maths/Matrix3D.h"
 #include "maths/Vector3D.h"
 #include "ps/CLogger.h"
 #include "ps/GameSetup/Config.h"
 #include "renderer/Scene.h"
 
 class CCmpVisualActor : public ICmpVisual
 {
 public:
 	static void ClassInit(CComponentManager& componentManager)
 	{
-		componentManager.SubscribeToMessageType(MT_Update_Final);
 		componentManager.SubscribeToMessageType(MT_InterpolatedPositionChanged);
 		componentManager.SubscribeToMessageType(MT_OwnershipChanged);
 		componentManager.SubscribeToMessageType(MT_ValueModification);
 		componentManager.SubscribeToMessageType(MT_TerrainChanged);
 		componentManager.SubscribeToMessageType(MT_Destroy);
 	}
 
 	DEFAULT_COMPONENT_ALLOCATOR(VisualActor)
 
 private:
 	std::wstring m_BaseActorName, m_ActorName;
 	bool m_IsFoundationActor;
 
 	// Not initialized in non-visual mode
 	CUnit* m_Unit;
 
 	fixed m_R, m_G, m_B; // shading color
 
 	// Current animation state
-	fixed m_AnimRunThreshold; // if non-zero this is the special walk/run mode
 	std::string m_AnimName;
 	bool m_AnimOnce;
 	fixed m_AnimSpeed;
 	std::wstring m_SoundGroup;
 	fixed m_AnimDesync;
 	fixed m_AnimSyncRepeatTime; // 0.0 if not synced
 	fixed m_AnimSyncOffsetTime;
 
 	std::map<CStr, CStr> m_VariantSelections;
 
 	u32 m_Seed; // seed used for random variations
 
 	bool m_ConstructionPreview;
 
 	bool m_VisibleInAtlasOnly;
 	bool m_IsActorOnly;	// an in-world entity should not have this or it might not be rendered.
 
 	ICmpUnitRenderer::tag_t m_ModelTag;
 
 public:
 	static std::string GetSchema()
 	{
 		return
 			"<a:help>Display the unit using the engine's actor system.</a:help>"
 			"<a:example>"
 				"<Actor>units/hellenes/infantry_spearman_b.xml</Actor>"
 			"</a:example>"
 			"<a:example>"
 				"<Actor>structures/hellenes/barracks.xml</Actor>"
 				"<FoundationActor>structures/fndn_4x4.xml</FoundationActor>"
 			"</a:example>"
 			"<element name='Actor' a:help='Filename of the actor to be used for this unit'>"
 				"<text/>"
 			"</element>"
 			"<optional>"
 				"<element name='FoundationActor' a:help='Filename of the actor to be used the foundation while this unit is being constructed'>"
 					"<text/>"
 				"</element>"
 			"</optional>"
 			"<optional>"
 				"<element name='Foundation' a:help='Used internally; if present, the unit will be rendered as a foundation'>"
 					"<empty/>"
 				"</element>"
 			"</optional>"
 			"<optional>"
 				"<element name='ConstructionPreview' a:help='If present, the unit should have a construction preview'>"
 					"<empty/>"
 				"</element>"
 			"</optional>"
 			"<optional>"
 				"<element name='DisableShadows' a:help='Used internally; if present, shadows will be disabled'>"
 					"<empty/>"
 				"</element>"
 			"</optional>"
 			"<optional>"
 				"<element name='ActorOnly' a:help='Used internally; if present, the unit will only be rendered if the user has high enough graphical settings.'>"
 					"<empty/>"
 				"</element>"
 			"</optional>"
 			"<element name='SilhouetteDisplay'>"
 				"<data type='boolean'/>"
 			"</element>"
 			"<element name='SilhouetteOccluder'>"
 				"<data type='boolean'/>"
 			"</element>"
 			"<optional>"
 				"<element name='SelectionShape'>"
 					"<choice>"
 						"<element name='Bounds' a:help='Determines the selection box based on the model bounds'>"
 							"<empty/>"
 						"</element>"
 						"<element name='Footprint' a:help='Determines the selection box based on the entity Footprint component'>"
 							"<empty/>"
 						"</element>"
 						"<element name='Box' a:help='Sets the selection shape to a box of specified dimensions'>"
 							"<attribute name='width'>"
 								"<data type='decimal'>"
 									"<param name='minExclusive'>0.0</param>"
 								"</data>"
 							"</attribute>"
 							"<attribute name='height'>"
 								"<data type='decimal'>"
 									"<param name='minExclusive'>0.0</param>"
 								"</data>"
 							"</attribute>"
 							"<attribute name='depth'>"
 								"<data type='decimal'>"
 									"<param name='minExclusive'>0.0</param>"
 								"</data>"
 							"</attribute>"
 						"</element>"
 						"<element name='Cylinder' a:help='Sets the selection shape to a cylinder of specified dimensions'>"
 							"<attribute name='radius'>"
 								"<data type='decimal'>"
 									"<param name='minExclusive'>0.0</param>"
 								"</data>"
 							"</attribute>"
 							"<attribute name='height'>"
 								"<data type='decimal'>"
 									"<param name='minExclusive'>0.0</param>"
 								"</data>"
 							"</attribute>"
 						"</element>"
 					"</choice>"
 				"</element>"
 			"</optional>"
 			"<element name='VisibleInAtlasOnly'>"
 				"<data type='boolean'/>"
 			"</element>";
 	}
 
 	virtual void Init(const CParamNode& paramNode)
 	{
 		m_Unit = NULL;
 		m_R = m_G = m_B = fixed::FromInt(1);
 
 		m_ConstructionPreview = paramNode.GetChild("ConstructionPreview").IsOk();
 
 		m_Seed = GetEntityId();
 
 		m_IsFoundationActor = paramNode.GetChild("Foundation").IsOk() && paramNode.GetChild("FoundationActor").IsOk();
 		if (m_IsFoundationActor)
 			m_BaseActorName = m_ActorName = paramNode.GetChild("FoundationActor").ToString();
 		else
 			m_BaseActorName = m_ActorName = paramNode.GetChild("Actor").ToString();
 
 		m_VisibleInAtlasOnly = paramNode.GetChild("VisibleInAtlasOnly").ToBool();
 		m_IsActorOnly = paramNode.GetChild("ActorOnly").IsOk();
 
 		InitModel(paramNode);
 
 		SelectAnimation("idle");
 	}
 
 	virtual void Deinit()
 	{
 		if (m_Unit)
 		{
 			GetSimContext().GetUnitManager().DeleteUnit(m_Unit);
 			m_Unit = NULL;
 		}
 	}
 
 	template<typename S>
 	void SerializeCommon(S& serialize)
 	{
 		serialize.NumberFixed_Unbounded("r", m_R);
 		serialize.NumberFixed_Unbounded("g", m_G);
 		serialize.NumberFixed_Unbounded("b", m_B);
 
-		serialize.NumberFixed_Unbounded("anim run threshold", m_AnimRunThreshold);
 		serialize.StringASCII("anim name", m_AnimName, 0, 256);
 		serialize.Bool("anim once", m_AnimOnce);
 		serialize.NumberFixed_Unbounded("anim speed", m_AnimSpeed);
 		serialize.String("sound group", m_SoundGroup, 0, 256);
 		serialize.NumberFixed_Unbounded("anim desync", m_AnimDesync);
 		serialize.NumberFixed_Unbounded("anim sync repeat time", m_AnimSyncRepeatTime);
 		serialize.NumberFixed_Unbounded("anim sync offset time", m_AnimSyncOffsetTime);
 
 		SerializeMap<SerializeString, SerializeString>()(serialize, "variation", m_VariantSelections);
 
 		serialize.NumberU32_Unbounded("seed", m_Seed);
 		serialize.String("actor", m_ActorName, 0, 256);
 
 		// TODO: store actor variables?
 	}
 
 	virtual void Serialize(ISerializer& serialize)
 	{
 		// TODO: store the actor name, if !debug and it differs from the template
 
 		if (serialize.IsDebug())
 		{
 			serialize.String("base actor", m_BaseActorName, 0, 256);
 		}
 
 		SerializeCommon(serialize);
 	}
 
 	virtual void Deserialize(const CParamNode& paramNode, IDeserializer& deserialize)
 	{
 		Init(paramNode);
 
 		u32 oldSeed = GetActorSeed();
 
 		SerializeCommon(deserialize);
 
 		// If we serialized a different seed or different actor, reload actor
 		if (oldSeed != GetActorSeed() || m_BaseActorName != m_ActorName)
 			ReloadActor();
 		else
 			ReloadUnitAnimation();
 
 		if (m_Unit)
 		{
 			CmpPtr<ICmpOwnership> cmpOwnership(GetEntityHandle());
 			if (cmpOwnership)
 				m_Unit->GetModel().SetPlayerID(cmpOwnership->GetOwner());
 		}
 	}
 
 	virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
 	{
 		switch (msg.GetType())
 		{
-		case MT_Update_Final:
-		{
-			const CMessageUpdate_Final& msgData = static_cast<const CMessageUpdate_Final&> (msg);
-			Update(msgData.turnLength);
-			break;
-		}
 		case MT_OwnershipChanged:
 		{
 			if (!m_Unit)
 				break;
 
 			const CMessageOwnershipChanged& msgData = static_cast<const CMessageOwnershipChanged&> (msg);
 			m_Unit->GetModel().SetPlayerID(msgData.to);
 			break;
 		}
 		case MT_TerrainChanged:
 		{
 			if (!m_Unit)
 				break;
 
 			const CMessageTerrainChanged& msgData = static_cast<const CMessageTerrainChanged&> (msg);
 			m_Unit->GetModel().SetTerrainDirty(msgData.i0, msgData.j0, msgData.i1, msgData.j1);
 			break;
 		}
 		case MT_ValueModification:
 		{
 			const CMessageValueModification& msgData = static_cast<const CMessageValueModification&> (msg);
 			if (msgData.component != L"VisualActor")
 				break;
 			CmpPtr<ICmpValueModificationManager> cmpValueModificationManager(GetSystemEntity());
 			std::wstring newActorName;
 			if (m_IsFoundationActor)
 				newActorName = cmpValueModificationManager->ApplyModifications(L"VisualActor/FoundationActor", m_BaseActorName, GetEntityId());
 			else
 				newActorName = cmpValueModificationManager->ApplyModifications(L"VisualActor/Actor", m_BaseActorName, GetEntityId());
 			if (newActorName != m_ActorName)
 			{
 				m_ActorName = newActorName;
 				ReloadActor();
 			}
 			break;
 		}
 		case MT_InterpolatedPositionChanged:
 		{
 			const CMessageInterpolatedPositionChanged& msgData = static_cast<const CMessageInterpolatedPositionChanged&> (msg);
 			if (m_ModelTag.valid())
 			{
 				CmpPtr<ICmpUnitRenderer> cmpModelRenderer(GetSystemEntity());
 				cmpModelRenderer->UpdateUnitPos(m_ModelTag, msgData.inWorld, msgData.pos0, msgData.pos1);
 			}
 			break;
 		}
 		case MT_Destroy:
 		{
 			if (m_ModelTag.valid())
 			{
 				CmpPtr<ICmpUnitRenderer> cmpModelRenderer(GetSystemEntity());
 				cmpModelRenderer->RemoveUnit(m_ModelTag);
 				m_ModelTag = ICmpUnitRenderer::tag_t();
 			}
 			break;
 		}
 		}
 	}
 
 	virtual CBoundingBoxAligned GetBounds() const
 	{
 		if (!m_Unit)
 			return CBoundingBoxAligned::EMPTY;
 		return m_Unit->GetModel().GetWorldBounds();
 	}
 
 	virtual CUnit* GetUnit()
 	{
 		return m_Unit;
 	}
 
 	virtual CBoundingBoxOriented GetSelectionBox() const
 	{
 		if (!m_Unit)
 			return CBoundingBoxOriented::EMPTY;
 		return m_Unit->GetModel().GetSelectionBox();
 	}
 
 	virtual CVector3D GetPosition() const
 	{
 		if (!m_Unit)
 			return CVector3D(0, 0, 0);
 		return m_Unit->GetModel().GetTransform().GetTranslation();
 	}
 
 	virtual std::wstring GetActorShortName() const
 	{
 		if (!m_Unit)
 			return L"";
 		return m_Unit->GetObject().m_Base->m_ShortName;
 	}
 
 	virtual std::wstring GetProjectileActor() const
 	{
 		if (!m_Unit)
 			return L"";
 		return m_Unit->GetObject().m_ProjectileModelName;
 	}
 
 	virtual CFixedVector3D GetProjectileLaunchPoint() const
 	{
 		if (!m_Unit)
 			return CFixedVector3D();
 
 		if (m_Unit->GetModel().ToCModel())
 		{
 			// Ensure the prop transforms are correct
 			CmpPtr<ICmpUnitRenderer> cmpUnitRenderer(GetSystemEntity());
 			CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 			if (cmpUnitRenderer && cmpPosition)
 			{
 				float frameOffset = cmpUnitRenderer->GetFrameOffset();
 				CMatrix3D transform(cmpPosition->GetInterpolatedTransform(frameOffset));
 				m_Unit->GetModel().SetTransform(transform);
 				m_Unit->GetModel().ValidatePosition();
 			}
 
 			CModelAbstract* ammo = m_Unit->GetModel().ToCModel()->FindFirstAmmoProp();
 			if (ammo)
 			{
 				CVector3D vector = ammo->GetTransform().GetTranslation();
 				return CFixedVector3D(fixed::FromFloat(vector.X), fixed::FromFloat(vector.Y), fixed::FromFloat(vector.Z));
 			}
 		}
 
 		return CFixedVector3D();
 	}
 
 	virtual void SetVariant(const CStr& key, const CStr& selection)
 	{
 		if (m_VariantSelections[key] == selection)
 			return;
 
 		m_VariantSelections[key] = selection;
 
 		if (m_Unit)
 		{
 			m_Unit->SetEntitySelection(key, selection);
 			if (m_Unit->GetAnimation())
 				m_Unit->GetAnimation()->ReloadAnimation();
 		}
 	}
 
 	virtual std::string GetAnimationName() const
 	{
 		return m_AnimName;
 	}
 
 	virtual void SelectAnimation(const std::string& name, bool once = false, fixed speed = fixed::FromInt(1))
 	{
-		m_AnimRunThreshold = fixed::Zero();
 		m_AnimName = name;
 		m_AnimOnce = once;
 		m_AnimSpeed = speed;
 		m_SoundGroup = L"";
 		m_AnimDesync = fixed::FromInt(1)/20; // TODO: make this an argument
 		m_AnimSyncRepeatTime = fixed::Zero();
 		m_AnimSyncOffsetTime = fixed::Zero();
 
 		SetVariant("animation", m_AnimName);
 
 		CmpPtr<ICmpSound> cmpSound(GetEntityHandle());
 		if (cmpSound)
 			m_SoundGroup = cmpSound->GetSoundGroup(wstring_from_utf8(m_AnimName));
 
 		if (!m_Unit || !m_Unit->GetAnimation() || !m_Unit->GetID())
 			return;
 
 		m_Unit->GetAnimation()->SetAnimationState(m_AnimName, m_AnimOnce, m_AnimSpeed.ToFloat(), m_AnimDesync.ToFloat(), m_SoundGroup.c_str());	
 	}
 
-	virtual void SelectMovementAnimation(fixed runThreshold)
+	virtual void SelectMovementAnimation(const std::string& name, fixed speed)
 	{
-		m_AnimRunThreshold = runThreshold;
+		ENSURE(name == "idle" || name == "walk" || name == "run");
+		if (m_AnimName != "idle" && m_AnimName != "walk" && m_AnimName != "run")
+			return;
+		SelectAnimation(name, false, speed);
 	}
 
 	virtual void SetAnimationSyncRepeat(fixed repeattime)
 	{
 		m_AnimSyncRepeatTime = repeattime;
 
 		if (m_Unit && m_Unit->GetAnimation())
 			m_Unit->GetAnimation()->SetAnimationSyncRepeat(m_AnimSyncRepeatTime.ToFloat());
 	}
 
 	virtual void SetAnimationSyncOffset(fixed actiontime)
 	{
 		m_AnimSyncOffsetTime = actiontime;
 
 		if (m_Unit && m_Unit->GetAnimation())
 			m_Unit->GetAnimation()->SetAnimationSyncOffset(m_AnimSyncOffsetTime.ToFloat());
 	}
 
 	virtual void SetShadingColor(fixed r, fixed g, fixed b, fixed a)
 	{
 		m_R = r;
 		m_G = g;
 		m_B = b;
 		UNUSED2(a); // TODO: why is this even an argument?
 
 		if (m_Unit)
 		{
 			CModelAbstract& model = m_Unit->GetModel();
 			model.SetShadingColor(CColor(m_R.ToFloat(), m_G.ToFloat(), m_B.ToFloat(), 1.0f));
 		}
 	}
 
 	virtual void SetVariable(const std::string& name, float value)
 	{
 		if (m_Unit)
 			m_Unit->GetModel().SetEntityVariable(name, value);
 	}
 
 	virtual u32 GetActorSeed() const
 	{
 		return m_Seed;
 	}
 
 	virtual void SetActorSeed(u32 seed)
 	{
 		if (seed == m_Seed)
 			return;
 
 		m_Seed = seed;
 		ReloadActor();
 	}
 
 	virtual bool HasConstructionPreview() const
 	{
 		return m_ConstructionPreview;
 	}
 
 	virtual void Hotload(const VfsPath& name)
 	{
 		if (!m_Unit)
 			return;
 
 		if (name != m_ActorName)
 			return;
 
 		ReloadActor();
 	}
 
 private:
 	/// Helper function shared by component init and actor reloading
 	void InitModel(const CParamNode& paramNode);
 
 	/// Helper method; initializes the model selection shape descriptor from XML. Factored out for readability of @ref Init.
 	void InitSelectionShapeDescriptor(const CParamNode& paramNode);
 
 	// ReloadActor is used when the actor or seed changes.
 	void ReloadActor();
 	// ReloadUnitAnimation is used for a minimal reloading upon deserialization, when the actor and seed are identical.
 	// It is also used by ReloadActor.
 	void ReloadUnitAnimation();
-
-	void Update(fixed turnLength);
 };
 
 REGISTER_COMPONENT_TYPE(VisualActor)
 
 // ------------------------------------------------------------------------------------------------------------------
 
 void CCmpVisualActor::InitModel(const CParamNode& paramNode)
 {
 	if (!GetSimContext().HasUnitManager())
 		return;
 
 	std::set<CStr> selections;
 	std::wstring actorName = m_ActorName;
 	if (actorName.find(L".xml") == std::wstring::npos)
 		actorName += L".xml";
 	m_Unit = GetSimContext().GetUnitManager().CreateUnit(actorName, GetActorSeed(), selections);
 	if (!m_Unit)
 		return;
 
 	CModelAbstract& model = m_Unit->GetModel();
 	if (model.ToCModel())
 	{
 		u32 modelFlags = 0;
 
 		if (paramNode.GetChild("SilhouetteDisplay").ToBool())
 			modelFlags |= MODELFLAG_SILHOUETTE_DISPLAY;
 
 		if (paramNode.GetChild("SilhouetteOccluder").ToBool())
 			modelFlags |= MODELFLAG_SILHOUETTE_OCCLUDER;
 
 		CmpPtr<ICmpVisibility> cmpVisibility(GetEntityHandle());
 		if (cmpVisibility && cmpVisibility->GetAlwaysVisible())
 			modelFlags |= MODELFLAG_IGNORE_LOS;
 
 		model.ToCModel()->AddFlagsRec(modelFlags);
 	}
 
 	if (paramNode.GetChild("DisableShadows").IsOk())
 	{
 		if (model.ToCModel())
 			model.ToCModel()->RemoveShadowsRec();
 		else if (model.ToCModelDecal())
 			model.ToCModelDecal()->RemoveShadows();
 	}
 
 	// Initialize the model's selection shape descriptor. This currently relies on the component initialization order; the
 	// Footprint component must be initialized before this component (VisualActor) to support the ability to use the footprint
 	// shape for the selection box (instead of the default recursive bounding box). See TypeList.h for the order in
 	// which components are initialized; if for whatever reason you need to get rid of this dependency, you can always just
 	// initialize the selection shape descriptor on-demand.
 	InitSelectionShapeDescriptor(paramNode);
 
 	m_Unit->SetID(GetEntityId());
 
 	bool floating = m_Unit->GetObject().m_Base->m_Properties.m_FloatOnWater;
 	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
 	if (cmpPosition)
 		cmpPosition->SetActorFloating(floating);
 
 	if (!m_ModelTag.valid())
 	{
 		CmpPtr<ICmpUnitRenderer> cmpModelRenderer(GetSystemEntity());
 		if (cmpModelRenderer)
 		{
 			// TODO: this should account for all possible props, animations, etc,
 			// else we might accidentally cull the unit when it should be visible
 			CBoundingBoxAligned bounds = m_Unit->GetModel().GetWorldBoundsRec();
 			CBoundingSphere boundSphere = CBoundingSphere::FromSweptBox(bounds);
 
 			int flags = 0;
 			if (m_IsActorOnly)
 				flags |= ICmpUnitRenderer::ACTOR_ONLY;
 			if (m_VisibleInAtlasOnly)
 				flags |= ICmpUnitRenderer::VISIBLE_IN_ATLAS_ONLY;
 
 			m_ModelTag = cmpModelRenderer->AddUnit(GetEntityHandle(), m_Unit, boundSphere, flags);
 		}
 	}
 }
 
 void CCmpVisualActor::InitSelectionShapeDescriptor(const CParamNode& paramNode)
 {
 	// by default, we don't need a custom selection shape and we can just keep the default behaviour
 	CModelAbstract::CustomSelectionShape* shapeDescriptor = NULL;
 
 	const CParamNode& shapeNode = paramNode.GetChild("SelectionShape");
 	if (shapeNode.IsOk())
 	{
 		if (shapeNode.GetChild("Bounds").IsOk())
 		{
 			// default; no need to take action
 		}
 		else if (shapeNode.GetChild("Footprint").IsOk())
 		{
 			CmpPtr<ICmpFootprint> cmpFootprint(GetEntityHandle());
 			if (cmpFootprint)
 			{
 				ICmpFootprint::EShape fpShape;				// fp stands for "footprint"
 				entity_pos_t fpSize0, fpSize1, fpHeight;	// fp stands for "footprint"
 				cmpFootprint->GetShape(fpShape, fpSize0, fpSize1, fpHeight);
 
 				float size0 = fpSize0.ToFloat();
 				float size1 = fpSize1.ToFloat();
 
 				// TODO: we should properly distinguish between CIRCLE and SQUARE footprint shapes here, but since cylinders
 				// aren't implemented yet and are almost indistinguishable from boxes for small enough sizes anyway,
 				// we'll just use boxes for either case. However, for circular footprints the size0 and size1 values both
 				// represent the radius, so we do have to adjust them to match the size1 and size0's of square footprints
 				// (which represent the full width and depth).
 				if (fpShape == ICmpFootprint::CIRCLE)
 				{
 					size0 *= 2;
 					size1 *= 2;
 				}
 
 				shapeDescriptor = new CModelAbstract::CustomSelectionShape;
 				shapeDescriptor->m_Type = CModelAbstract::CustomSelectionShape::BOX;
 				shapeDescriptor->m_Size0 = size0;
 				shapeDescriptor->m_Size1 = size1;
 				shapeDescriptor->m_Height = fpHeight.ToFloat();
 			}
 			else
 			{
 				LOGERROR("[VisualActor] Cannot apply footprint-based SelectionShape; Footprint component not initialized.");
 			}
 		}
 		else if (shapeNode.GetChild("Box").IsOk())
 		{
 			// TODO: we might need to support the ability to specify a different box center in the future
 			shapeDescriptor = new CModelAbstract::CustomSelectionShape;
 			shapeDescriptor->m_Type = CModelAbstract::CustomSelectionShape::BOX;
 			shapeDescriptor->m_Size0 = shapeNode.GetChild("Box").GetChild("@width").ToFixed().ToFloat();
 			shapeDescriptor->m_Size1 = shapeNode.GetChild("Box").GetChild("@depth").ToFixed().ToFloat();
 			shapeDescriptor->m_Height = shapeNode.GetChild("Box").GetChild("@height").ToFixed().ToFloat();
 		}
 		else if (shapeNode.GetChild("Cylinder").IsOk())
 		{
 			LOGWARNING("[VisualActor] TODO: Cylinder selection shapes are not yet implemented; defaulting to recursive bounding boxes");
 		}
 		else
 		{
 			// shouldn't happen by virtue of validation against schema
 			LOGERROR("[VisualActor] No selection shape specified");
 		}
 	}
 
 	ENSURE(m_Unit);
 	// the model is now responsible for cleaning up the descriptor
 	m_Unit->GetModel().SetCustomSelectionShape(shapeDescriptor);
 }
 
 void CCmpVisualActor::ReloadActor()
 {
 	if (!m_Unit)
 		return;
 
 	// Save some data from the old unit
 	CColor shading = m_Unit->GetModel().GetShadingColor();
 	player_id_t playerID = m_Unit->GetModel().GetPlayerID();
 
 	// Replace with the new unit
 	GetSimContext().GetUnitManager().DeleteUnit(m_Unit);
 
 	// HACK: selection shape needs template data, but rather than storing all that data
 	//	in the component, we load the template here and pass it into a helper function
 	CmpPtr<ICmpTemplateManager> cmpTemplateManager(GetSystemEntity());
 	const CParamNode* node = cmpTemplateManager->LoadLatestTemplate(GetEntityId());
 	ENSURE(node && node->GetChild("VisualActor").IsOk());
 
 	InitModel(node->GetChild("VisualActor"));
 
 	ReloadUnitAnimation();
 
 	m_Unit->GetModel().SetShadingColor(shading);
 
 	m_Unit->GetModel().SetPlayerID(playerID);
 
 	if (m_ModelTag.valid())
 	{
 		CmpPtr<ICmpUnitRenderer> cmpModelRenderer(GetSystemEntity());
 		CBoundingBoxAligned bounds = m_Unit->GetModel().GetWorldBoundsRec();
 		CBoundingSphere boundSphere = CBoundingSphere::FromSweptBox(bounds);
 		cmpModelRenderer->UpdateUnit(m_ModelTag, m_Unit, boundSphere);
 	}
 }
 
 void CCmpVisualActor::ReloadUnitAnimation()
 {
 	if (!m_Unit)
 		return;
 
 	m_Unit->SetEntitySelection(m_VariantSelections);
 
 	if (!m_Unit->GetAnimation())
 		return;
 
 	m_Unit->GetAnimation()->SetAnimationState(m_AnimName, m_AnimOnce, m_AnimSpeed.ToFloat(), m_AnimDesync.ToFloat(), m_SoundGroup.c_str());
 
 	// We'll lose the exact synchronisation but we should at least make sure it's going at the correct rate
 	if (!m_AnimSyncRepeatTime.IsZero())
 		m_Unit->GetAnimation()->SetAnimationSyncRepeat(m_AnimSyncRepeatTime.ToFloat());
 	if (!m_AnimSyncOffsetTime.IsZero())
 		m_Unit->GetAnimation()->SetAnimationSyncOffset(m_AnimSyncOffsetTime.ToFloat());
 }
-
-void CCmpVisualActor::Update(fixed UNUSED(turnLength))
-{
-	// This function is currently only used to update the animation if the speed in
-	// CCmpUnitMotion changes. This also only happens in the "special movement mode"
-	// triggered by SelectMovementAnimation.
-
-	// TODO: This should become event based, in order to save performance and to make the code
-	// far less hacky. We should also take into account the speed when the animation is different
-	// from the "special movement mode" walking animation.
-
-	// If we're not in the special movement mode, nothing to do.
-	if (m_AnimRunThreshold.IsZero())
-		return;
-
-	CmpPtr<ICmpPosition> cmpPosition(GetEntityHandle());
-	if (!cmpPosition || !cmpPosition->IsInWorld())
-		return;
-
-	CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetEntityHandle());
-	if (!cmpUnitMotion)
-		return;
-
-	fixed speed = cmpUnitMotion->GetCurrentSpeed();
-	std::string name;
-
-	if (speed.IsZero())
-	{
-		speed = fixed::FromFloat(1.f);
-		name = "idle";
-	}
-	else
-		name = speed < m_AnimRunThreshold ? "walk" : "run";
-
-	// Selecting the animation is going to reset the anim run threshold, so save it
-	fixed runThreshold = m_AnimRunThreshold;
-	SelectAnimation(name, false, speed);
-	m_AnimRunThreshold = runThreshold;
-}
Index: ps/trunk/source/simulation2/components/ICmpVisual.cpp
===================================================================
--- ps/trunk/source/simulation2/components/ICmpVisual.cpp	(revision 22445)
+++ ps/trunk/source/simulation2/components/ICmpVisual.cpp	(revision 22446)
@@ -1,38 +1,37 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "ICmpVisual.h"
 
 #include "simulation2/system/InterfaceScripted.h"
 
 BEGIN_INTERFACE_WRAPPER(Visual)
 DEFINE_INTERFACE_METHOD_2("SetVariant", void, ICmpVisual, SetVariant, CStr, CStr)
 DEFINE_INTERFACE_METHOD_CONST_0("GetAnimationName", std::string, ICmpVisual, GetAnimationName)
 DEFINE_INTERFACE_METHOD_CONST_0("GetProjectileActor", std::wstring, ICmpVisual, GetProjectileActor)
 DEFINE_INTERFACE_METHOD_CONST_0("GetProjectileLaunchPoint", CFixedVector3D, ICmpVisual, GetProjectileLaunchPoint)
 DEFINE_INTERFACE_METHOD_3("SelectAnimation", void, ICmpVisual, SelectAnimation, std::string, bool, fixed)
-DEFINE_INTERFACE_METHOD_1("SelectMovementAnimation", void, ICmpVisual, SelectMovementAnimation, fixed)
 DEFINE_INTERFACE_METHOD_1("SetAnimationSyncRepeat", void, ICmpVisual, SetAnimationSyncRepeat, fixed)
 DEFINE_INTERFACE_METHOD_1("SetAnimationSyncOffset", void, ICmpVisual, SetAnimationSyncOffset, fixed)
 DEFINE_INTERFACE_METHOD_4("SetShadingColor", void, ICmpVisual, SetShadingColor, fixed, fixed, fixed, fixed)
 DEFINE_INTERFACE_METHOD_2("SetVariable", void, ICmpVisual, SetVariable, std::string, float)
 DEFINE_INTERFACE_METHOD_CONST_0("GetActorSeed", u32, ICmpVisual, GetActorSeed)
 DEFINE_INTERFACE_METHOD_1("SetActorSeed", void, ICmpVisual, SetActorSeed, u32)
 DEFINE_INTERFACE_METHOD_CONST_0("HasConstructionPreview", bool, ICmpVisual, HasConstructionPreview)
 END_INTERFACE_WRAPPER(Visual)
Index: ps/trunk/source/simulation2/components/ICmpVisual.h
===================================================================
--- ps/trunk/source/simulation2/components/ICmpVisual.h	(revision 22445)
+++ ps/trunk/source/simulation2/components/ICmpVisual.h	(revision 22446)
@@ -1,170 +1,172 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_ICMPVISUAL
 #define INCLUDED_ICMPVISUAL
 
 #include "simulation2/system/Interface.h"
 
 #include "ps/CStr.h"
 #include "maths/BoundingBoxOriented.h"
 #include "maths/BoundingBoxAligned.h"
 #include "maths/Fixed.h"
 #include "maths/FixedVector3D.h"
 #include "lib/file/vfs/vfs_path.h"
 
 class CUnit;
 
 /**
  * The visual representation of an entity (typically an actor).
  */
 class ICmpVisual : public IComponent
 {
 public:
 	/**
 	 * Get the world-space bounding box of the object's visual representation.
 	 * (Not safe for use in simulation code.)
 	 */
 	virtual CBoundingBoxAligned GetBounds() const = 0;
 
 	/**
 	 * Get the oriented world-space bounding box of the object's visual representation, clipped at the Y=0 plane in object space
 	 * to prevent it from extending into the terrain. The primary difference with GetBounds is that this bounding box is not aligned
 	 * to the world axes, but arbitrarily rotated according to the model transform.
 	 */
 	virtual CBoundingBoxOriented GetSelectionBox() const = 0;
 
 	/**
 	 * Get the world-space position of the base point of the object's visual representation.
 	 * (Not safe for use in simulation code.)
 	 */
 	virtual CVector3D GetPosition() const = 0;
 
 	/**
 	 * Return the short name of the actor that's being displayed, or the empty string on error.
 	 * (Not safe for use in simulation code.)
 	 */
 	virtual std::wstring GetActorShortName() const = 0;
 
 	/**
 	 * Return the filename of the actor to be used for projectiles from this unit, or the empty string if none.
 	 * (Not safe for use in simulation code.)
 	 */
 	virtual std::wstring GetProjectileActor() const = 0;
 
 	/**
 	 * Return the exact position where a projectile should be launched from (based on the actor's
 	 * ammo prop points).
 	 * Return type is CFixedVector3D because it is exposed to the JS interface.
 	 * Returns (0,0,0) if no point can be found.
 	 */
 	virtual CFixedVector3D GetProjectileLaunchPoint() const = 0;
 
 	/**
 	 * Returns the underlying unit of this visual actor. May return NULL to indicate that no unit exists (e.g. may happen if the
 	 * game is started without graphics rendering).
 	 * Originally intended for introspection purposes in Atlas; for other purposes, consider using a specialized getter first.
 	 */
 	virtual CUnit* GetUnit() = 0;
 
 	/**
 	 * Set the variant selection of the actor for a certain key.
 	 * This overrides a previous selection on that key, so every component
 	 * should use unique keys.
 	 */
 	virtual void SetVariant(const CStr& key, const CStr& selection) = 0;
 
 	/**
 	 * Returns the name of the currently played animation.
 	 */
 	virtual std::string GetAnimationName() const = 0;
 
 	/**
 	 * Start playing the given animation. If there are multiple possible animations then it will
 	 * pick one at random (not network-synchronised).
-	 * If @p soundgroup is specified, then the sound will be played at each 'event' point in the
-	 * animation cycle.
 	 * @param name animation name (e.g. "idle", "walk", "melee"; the names are determined by actor XML files)
 	 * @param once if true then the animation will play once and freeze at the final frame, else it will loop
 	 * @param speed animation speed multiplier (typically 1.0 for the default speed)
-	 * @param soundgroup VFS path of sound group .xml, relative to audio/, or empty string for none
 	 */
 	virtual void SelectAnimation(const std::string& name, bool once, fixed speed) = 0;
 
 	/**
-	 * Start playing the walk/run animations, scaled to the unit's movement speed.
-	 * @param runThreshold movement speed at which to switch to the run animation
+	 * Start playing the given movement animation unless we are currently playing a non-movement animation.
+	 * This is necessary so UnitMotion can set the movement animations without overwriting specific animations
+	 * that might have been set by other components.
+	 * TODO: Non-movement animations should probably be made into variants, defining "idle" (really "default"), "walk" and "run" as appropriate,
+	 * and this would no longer be necessary.
+	 * @param name animation name (i.e. one of "idle", "walk", "run").
+	 * @param speed animation speed multiplier (typically 1.0 for the default speed)
 	 */
-	virtual void SelectMovementAnimation(fixed runThreshold) = 0;
+	virtual void SelectMovementAnimation(const std::string& name, fixed speed) = 0;
 
 	/**
 	 * Adjust the speed of the current animation, so it can match simulation events.
 	 * @param repeattime time for complete loop of animation, in msec
 	 */
 	virtual void SetAnimationSyncRepeat(fixed repeattime) = 0;
 
 	/**
 	 * Adjust the offset of the current animation, so it can match simulation events.
 	 * @param actiontime time between now and when the 'action' event should occur, in msec
 	 */
 	virtual void SetAnimationSyncOffset(fixed actiontime) = 0;
 
 	/**
 	 * Set the shading color that will be modulated with the model's textures.
 	 * Default shading is (1, 1, 1, 1).
 	 * Alpha should probably be 1 else it's unlikely to work properly.
 	 * @param r red component, expected range [0, 1]
 	 * @param g green component, expected range [0, 1]
 	 * @param b blue component, expected range [0, 1]
 	 * @param a alpha component, expected range [0, 1]
 	 */
 	virtual void SetShadingColor(fixed r, fixed g, fixed b, fixed a) = 0;
 
 	/**
 	 * Set an arbitrarily-named variable that the model may use to alter its appearance
 	 * (e.g. in particle emitter parameter computations).
 	 */
 	virtual void SetVariable(const std::string& name, float value) = 0;
 
 	/**
 	 * Get actor seed used for random variations
 	 */
 	virtual u32 GetActorSeed() const = 0;
 
 	/**
 	 * Set actor seed for random variations and reload model
 	 */
 	virtual void SetActorSeed(u32 seed) = 0;
 
 	/**
 	 * Returns true if this entity should have a construction preview
 	 */
 	virtual bool HasConstructionPreview() const = 0;
 
 	/**
 	 * Called when an actor file has been modified and reloaded dynamically.
 	 * If this component uses the named actor file, it should regenerate its actor
 	 * to pick up the new definitions.
 	 */
 	virtual void Hotload(const VfsPath& name) = 0;
 
 	DECLARE_INTERFACE_TYPE(Visual)
 };
 
 // TODO: rename this to VisualActor, because the interface is actor-specific, maybe?
 
 #endif // INCLUDED_ICMPVISUAL