Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/attackManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/attackManager.js	(revision 19755)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/attackManager.js	(revision 19756)
@@ -1,622 +1,634 @@
 var PETRA = function(m)
 {
 
 /** Attack Manager */
 
 m.AttackManager = function(Config)
 {
 	this.Config = Config;
 
 	this.totalNumber = 0;
 	this.attackNumber = 0;
 	this.rushNumber = 0;
 	this.raidNumber = 0;
 	this.upcomingAttacks = { "Rush": [], "Raid": [], "Attack": [], "HugeAttack": [] };
 	this.startedAttacks = { "Rush": [], "Raid": [], "Attack": [], "HugeAttack": [] };
 	this.debugTime = 0;
 	this.maxRushes = 0;
 	this.rushSize = [];
 	this.currentEnemyPlayer = undefined; // enemy player we are currently targeting
 	this.defeated = {};
 };
 
 /** More initialisation for stuff that needs the gameState */
 m.AttackManager.prototype.init = function(gameState)
 {
 	this.outOfPlan = gameState.getOwnUnits().filter(API3.Filters.byMetadata(PlayerID, "plan", -1));
 	this.outOfPlan.registerUpdates();
 };
 
 m.AttackManager.prototype.setRushes = function(allowed)
 {
 	if (this.Config.personality.aggressive > 0.8 && allowed > 2)
 	{
 		this.maxRushes = 3;
 		this.rushSize = [ 16, 20, 24 ];
 	}
 	else if (this.Config.personality.aggressive > 0.6 && allowed > 1)
 	{
 		this.maxRushes = 2;
 		this.rushSize = [ 18, 22 ];
 	}
 	else if (this.Config.personality.aggressive > 0.3 && allowed > 0)
 	{
 		this.maxRushes = 1;
 		this.rushSize = [ 20 ];
 	}
 };
 
 m.AttackManager.prototype.checkEvents = function(gameState, events)
 {
 	for (let evt of events.PlayerDefeated)
 		this.defeated[evt.playerId] = true;
 
 	let answer = "decline";
 	let other;
 	let targetPlayer;
 	for (let evt of events.AttackRequest)
 	{
 		if (evt.source === PlayerID || !gameState.isPlayerAlly(evt.source) || !gameState.isPlayerEnemy(evt.player))
 			continue;
 		targetPlayer = evt.player;
 		let available = 0;
 		for (let attackType in this.upcomingAttacks)
 		{
 			for (let attack of this.upcomingAttacks[attackType])
 			{
 				if (attack.state === "completing")
 				{
 					if (attack.targetPlayer === targetPlayer)
 						available += attack.unitCollection.length;
 					else if (attack.targetPlayer !== undefined && attack.targetPlayer !== targetPlayer)
 						other = attack.targetPlayer;
 					continue;
 				}
 
 				attack.targetPlayer = targetPlayer;
 
 				if (attack.unitCollection.length > 2)
 					available += attack.unitCollection.length;
 			}
 		}
 
 		if (available > 12)	// launch the attack immediately
 		{
 			for (let attackType in this.upcomingAttacks)
 			{
 				for (let attack of this.upcomingAttacks[attackType])
 				{
 					if (attack.state === "completing" ||
 						attack.targetPlayer !== targetPlayer ||
 						attack.unitCollection.length < 3)
 						continue;
 					attack.forceStart();
 					attack.requested = true;
 				}
 			}
 			answer = "join";
 		}
 		else if (other !== undefined)
 			answer = "other";
 		break;  // take only the first attack request into account
 	}
 	if (targetPlayer !== undefined)
 		m.chatAnswerRequestAttack(gameState, targetPlayer, answer, other);
 };
 
 /**
  * Some functions are run every turn
  * Others once in a while
  */
 m.AttackManager.prototype.update = function(gameState, queues, events)
 {
 	if (this.Config.debug > 2 && gameState.ai.elapsedTime > this.debugTime + 60)
 	{
 		this.debugTime = gameState.ai.elapsedTime;
 		API3.warn(" upcoming attacks =================");
 		for (let attackType in this.upcomingAttacks)
 			for (let attack of this.upcomingAttacks[attackType])
 				API3.warn(" plan " + attack.name + " type " + attackType + " state " + attack.state + " units " + attack.unitCollection.length);
 		API3.warn(" started attacks ==================");
 		for (let attackType in this.startedAttacks)
 			for (let attack of this.startedAttacks[attackType])
 				API3.warn(" plan " + attack.name + " type " + attackType + " state " + attack.state + " units " + attack.unitCollection.length);
 		API3.warn(" ==================================");
 	}
 
 	this.checkEvents(gameState, events);
 
 	let unexecutedAttacks = {"Rush": 0, "Raid": 0, "Attack": 0, "HugeAttack": 0};
 	for (let attackType in this.upcomingAttacks)
 	{
 		for (let i = 0; i < this.upcomingAttacks[attackType].length; ++i)
 		{
 			let attack = this.upcomingAttacks[attackType][i];
 			attack.checkEvents(gameState, events);
 
 			if (attack.isStarted())
 				API3.warn("Petra problem in attackManager: attack in preparation has already started ???");
 
 			let updateStep = attack.updatePreparation(gameState);
 			// now we're gonna check if the preparation time is over
 			if (updateStep === 1 || attack.isPaused() )
 			{
 				// just chillin'
 				if (attack.state === "unexecuted")
 					++unexecutedAttacks[attackType];
 			}
 			else if (updateStep === 0)
 			{
 				if (this.Config.debug > 1)
 					API3.warn("Attack Manager: " + attack.getType() + " plan " + attack.getName() + " aborted.");
 				attack.Abort(gameState);
 				this.upcomingAttacks[attackType].splice(i--,1);
 			}
 			else if (updateStep === 2)
 			{
 				if (attack.StartAttack(gameState))
 				{
 					if (this.Config.debug > 1)
 						API3.warn("Attack Manager: Starting " + attack.getType() + " plan " + attack.getName());
 					if (this.Config.chat)
 						m.chatLaunchAttack(gameState, attack.targetPlayer, attack.getType());
 					this.startedAttacks[attackType].push(attack);
 				}
 				else
 					attack.Abort(gameState);
 				this.upcomingAttacks[attackType].splice(i--,1);
 			}
 		}
 	}
 
 	for (let attackType in this.startedAttacks)
 	{
 		for (let i = 0; i < this.startedAttacks[attackType].length; ++i)
 		{
 			let attack = this.startedAttacks[attackType][i];
 			attack.checkEvents(gameState, events);
 			// okay so then we'll update the attack.
 			if (attack.isPaused())
 				continue;
 			let remaining = attack.update(gameState, events);
 			if (!remaining)
 			{
 				if (this.Config.debug > 1)
 					API3.warn("Military Manager: " + attack.getType() + " plan " + attack.getName() + " is finished with remaining " + remaining);
 				attack.Abort(gameState);
 				this.startedAttacks[attackType].splice(i--,1);
 			}
 		}
 	}
 
 	// creating plans after updating because an aborted plan might be reused in that case.
 
 	let barracksNb = gameState.getOwnEntitiesByClass("Barracks", true).filter(API3.Filters.isBuilt()).length;
 	if (this.rushNumber < this.maxRushes && barracksNb >= 1)
 	{
 		if (unexecutedAttacks.Rush === 0)
 		{
 			// we have a barracks and we want to rush, rush.
 			let data = { "targetSize": this.rushSize[this.rushNumber] };
 			let attackPlan = new m.AttackPlan(gameState, this.Config, this.totalNumber, "Rush", data);
 			if (!attackPlan.failed)
 			{
 				if (this.Config.debug > 1)
 					API3.warn("Headquarters: Rushing plan " + this.totalNumber + " with maxRushes " + this.maxRushes);
 				this.totalNumber++;
 				attackPlan.init(gameState);
 				this.upcomingAttacks.Rush.push(attackPlan);
 			}
 			this.rushNumber++;
 		}
 	}
 	else if (unexecutedAttacks.Attack === 0 && unexecutedAttacks.HugeAttack === 0 &&
 		this.startedAttacks.Attack.length + this.startedAttacks.HugeAttack.length < Math.min(2, 1 + Math.round(gameState.getPopulationMax()/100)))
 	{
 		if ((barracksNb >= 1 && (gameState.currentPhase() > 1 || gameState.isResearching(gameState.townPhase()))) ||
 			!gameState.ai.HQ.baseManagers[1])	// if we have no base ... nothing else to do than attack
 		{
 			let type = this.attackNumber < 2 || this.startedAttacks.HugeAttack.length > 0 ? "Attack" : "HugeAttack";
 			let attackPlan = new m.AttackPlan(gameState, this.Config, this.totalNumber, type);
 			if (attackPlan.failed)
 				this.attackPlansEncounteredWater = true; // hack
 			else
 			{
 				if (this.Config.debug > 1)
 					API3.warn("Military Manager: Creating the plan " + type + "  " + this.totalNumber);
 				this.totalNumber++;
 				attackPlan.init(gameState);
 				this.upcomingAttacks[type].push(attackPlan);
 			}
 			this.attackNumber++;
 		}
 	}
 
 	if (unexecutedAttacks.Raid === 0 && gameState.ai.HQ.defenseManager.targetList.length)
 	{
 		let target;
 		for (let targetId of gameState.ai.HQ.defenseManager.targetList)
 		{
 			target = gameState.getEntityById(targetId);
 			if (!target)
 				continue;
 			if (gameState.isPlayerEnemy(target.owner()))
 				break;
 			target = undefined;
 		}
 		if (target) // prepare a raid against this target
 			this.raidTargetEntity(gameState, target);
 	}
 };
 
 m.AttackManager.prototype.getPlan = function(planName)
 {
 	for (let attackType in this.upcomingAttacks)
 	{
 		for (let attack of this.upcomingAttacks[attackType])
 			if (attack.getName() == planName)
 				return attack;
 	}
 	for (let attackType in this.startedAttacks)
 	{
 		for (let attack of this.startedAttacks[attackType])
 			if (attack.getName() == planName)
 				return attack;
 	}
 	return undefined;
 };
 
 m.AttackManager.prototype.pausePlan = function(planName)
 {
 	let attack = this.getPlan(planName);
 	if (attack)
 		attack.setPaused(true);
 };
 
 m.AttackManager.prototype.unpausePlan = function(planName)
 {
 	let attack = this.getPlan(planName);
 	if (attack)
 		attack.setPaused(false);
 };
 
 m.AttackManager.prototype.pauseAllPlans = function()
 {
 	for (let attackType in this.upcomingAttacks)
 		for (let attack of this.upcomingAttacks[attackType])
 			attack.setPaused(true);
 
 	for (let attackType in this.startedAttacks)
 		for (let attack of this.startedAttacks[attackType])
 			attack.setPaused(true);
 };
 
 m.AttackManager.prototype.unpauseAllPlans = function()
 {
 	for (let attackType in this.upcomingAttacks)
 		for (let attack of this.upcomingAttacks[attackType])
 			attack.setPaused(false);
 
 	for (let attackType in this.startedAttacks)
 		for (let attack of this.startedAttacks[attackType])
 			attack.setPaused(false);
 };
 
 m.AttackManager.prototype.getAttackInPreparation = function(type)
 {
 	if (!this.upcomingAttacks[type].length)
 		return undefined;
 	return this.upcomingAttacks[type][0];
 };
 
 /**
  * determine which player should be attacked: when called when starting the attack,
  * attack.targetPlayer is undefined and in that case, we keep track of the chosen target
  * for future attacks.
  */
 m.AttackManager.prototype.getEnemyPlayer = function(gameState, attack)
 {
 	let enemyPlayer;
 
 	// first check if there is a preferred enemy based on our victory conditions
 	if (gameState.getGameType() === "wonder")
 	{
 		let moreAdvanced;
 		let enemyWonder;
 		let wonders = gameState.getEnemyStructures().filter(API3.Filters.byClass("Wonder"));
 		for (let wonder of wonders.values())
 		{
 			if (wonder.owner() === 0)
 				continue;
 			let progress = wonder.foundationProgress();
 			if (progress === undefined)
 			{
 				enemyWonder = wonder;
 				break;
 			}
 			if (enemyWonder && moreAdvanced > progress)
 				continue;
 			enemyWonder = wonder;
 			moreAdvanced = progress;
 		}
 		if (enemyWonder)
 		{
 			enemyPlayer = enemyWonder.owner();
 			if (attack.targetPlayer === undefined)
 				this.currentEnemyPlayer = enemyPlayer;
 			return enemyPlayer;
 		}
 	}
 	else if (gameState.getGameType() === "capture_the_relic")
 	{
 		// Target the player with the most relics (including gaia)
 		let allRelics = gameState.updatingGlobalCollection("allRelics", API3.Filters.byClass("Relic"));
 		let maxRelicsOwned = 0;
 		for (let i = 0; i < gameState.sharedScript.playersData.length; ++i)
 		{
 			if (!gameState.isPlayerEnemy(i) || this.defeated[i] ||
 			    i === 0 && !gameState.ai.HQ.gameTypeManager.tryCaptureGaiaRelic)
 				continue;
 
 			let relicsCount = allRelics.filter(relic => relic.owner() === i).length;
 			if (relicsCount <= maxRelicsOwned)
 				continue;
 			maxRelicsOwned = relicsCount;
 			enemyPlayer = i;
 		}
 		if (enemyPlayer !== undefined)
 		{
 			if (attack.targetPlayer === undefined)
 				this.currentEnemyPlayer = enemyPlayer;
 			if (enemyPlayer === 0)
 				gameState.ai.HQ.gameTypeManager.resetCaptureGaiaRelic(gameState);
 			return enemyPlayer;
 		}
 	}
 
 	let veto = {};
 	for (let i in this.defeated)
 		veto[i] = true;
 	// No rush if enemy too well defended (i.e. iberians)
 	if (attack.type === "Rush")
 	{
 		for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
 		{
 			if (!gameState.isPlayerEnemy(i) || veto[i])
 				continue;
 			if (this.defeated[i])
 				continue;
 			let enemyDefense = 0;
 			for (let ent of gameState.getEnemyStructures(i).values())
 				if (ent.hasClass("Tower") || ent.hasClass("Fortress"))
 					enemyDefense++;
 			if (enemyDefense > 6)
 				veto[i] = true;
 		}
 	}
 
 	// then if not a huge attack, continue attacking our previous target as long as it has some entities,
 	// otherwise target the most accessible one
 	if (attack.type !== "HugeAttack")
 	{
 		if (attack.targetPlayer === undefined && this.currentEnemyPlayer !== undefined &&
 			!this.defeated[this.currentEnemyPlayer] &&
 			gameState.isPlayerEnemy(this.currentEnemyPlayer) &&
 			gameState.getEntities(this.currentEnemyPlayer).hasEntities())
 			return this.currentEnemyPlayer;
 
 		let distmin;
 		let ccmin;
 		let ccEnts = gameState.updatingGlobalCollection("allCCs", API3.Filters.byClass("CivCentre"));
 		for (let ourcc of ccEnts.values())
 		{
 			if (ourcc.owner() !== PlayerID)
 				continue;
 			let ourPos = ourcc.position();
 			let access = gameState.ai.accessibility.getAccessValue(ourPos);
 			for (let enemycc of ccEnts.values())
 			{
 				if (veto[enemycc.owner()])
 					continue;
 				if (!gameState.isPlayerEnemy(enemycc.owner()))
 					continue;
 				let enemyPos = enemycc.position();
 				if (access !== gameState.ai.accessibility.getAccessValue(enemyPos))
 					continue;
 				let dist = API3.SquareVectorDistance(ourPos, enemyPos);
 				if (distmin && dist > distmin)
 					continue;
 				ccmin = enemycc;
 				distmin = dist;
 			}
 		}
 		if (ccmin)
 		{
 			enemyPlayer = ccmin.owner();
 			if (attack.targetPlayer === undefined)
 				this.currentEnemyPlayer = enemyPlayer;
 			return enemyPlayer;
 		}
 	}
 
 	// then let's target our strongest enemy (basically counting enemies units)
 	// with priority to enemies with civ center
 	let max = 0;
 	for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
 	{
 		if (veto[i])
 			continue;
 		if (!gameState.isPlayerEnemy(i))
 			continue;
 		let enemyCount = 0;
 		let enemyCivCentre = false;
 		for (let ent of gameState.getEntities(i).values())
 		{
 			enemyCount++;
 			if (ent.hasClass("CivCentre"))
 				enemyCivCentre = true;
 		}
 		if (enemyCivCentre)
 			enemyCount += 500;
 		if (enemyCount < max)
 			continue;
 		max = enemyCount;
 		enemyPlayer = i;
 	}
 	if (attack.targetPlayer === undefined)
 		this.currentEnemyPlayer = enemyPlayer;
 	return enemyPlayer;
 };
 
 /** f.e. if we have changed diplomacy with another player. */
 m.AttackManager.prototype.cancelAttacksAgainstPlayer = function(gameState, player)
 {
 	for (let attackType in this.upcomingAttacks)
 		for (let attack of this.upcomingAttacks[attackType])
 			if (attack.targetPlayer === player)
 				attack.targetPlayer = undefined;
 
 	for (let attackType in this.startedAttacks)
 		for (let i = 0; i < this.startedAttacks[attackType].length; ++i)
 		{
 			let attack = this.startedAttacks[attackType][i];
 			if (attack.targetPlayer === player)
 			{
 				attack.Abort(gameState);
 				this.startedAttacks[attackType].splice(i--, 1);
 			}
 		}
 };
 
 m.AttackManager.prototype.raidTargetEntity = function(gameState, ent)
 {
 	let data = { "target": ent };
 	let attackPlan = new m.AttackPlan(gameState, this.Config, this.totalNumber, "Raid", data);
 	if (!attackPlan.failed)
 	{
 		if (this.Config.debug > 1)
 			API3.warn("Headquarters: Raiding plan " + this.totalNumber);
 		this.totalNumber++;
 		attackPlan.init(gameState);
 		this.upcomingAttacks.Raid.push(attackPlan);
 	}
 	this.raidNumber++;
 };
 
 /**
- * Response to the capture of one of our structure:
- * transform all defense armies around into a new attack army and target this structure
+ * Switch defense armies into an attack one against the given target
+ * data.range: transform all defense armies inside range of the target into a new attack
+ * data.armyID: transform only the defense army ID into a new attack
+ * data.uniqueTarget: the attack will stop when the target is destroyed or captured
  */
-m.AttackManager.prototype.counterAttack = function(gameState, ent, range=150)
+m.AttackManager.prototype.switchDefenseToAttack = function(gameState, target, data)
 {
-	if (!ent || !ent.position())
+	if (!target || !target.position())
 		return false;
-	let pos = ent.position();
+	if (!data.range && !data.armyID)
+	{
+		API3.warn(" attackManager.switchToAttack inconsistent data " + uneval(data));
+		return false;
+	}
+	attackData = data.uniqueTarget ? { "uniqueTargetId": target.id() } : undefined;
+	let pos = target.position();
 	let attackType = "Attack";
-	let attackPlan = new m.AttackPlan(gameState, this.Config, this.totalNumber, attackType);
+	let attackPlan = new m.AttackPlan(gameState, this.Config, this.totalNumber, attackType, attackData);
 	if (attackPlan.failed)
 		return false;
 	this.totalNumber++;
 	attackPlan.init(gameState);
 	this.startedAttacks[attackType].push(attackPlan);
 
-	for (let i = 0; i < gameState.ai.HQ.defenseManager.armies.length; ++i)
+	for (let army of gameState.ai.HQ.defenseManager.armies)
 	{
-		let army = gameState.ai.HQ.defenseManager.armies[i];
-		army.recalculatePosition(gameState);
-		if (API3.SquareVectorDistance(pos, army.foePosition) > range*range)
+		if (data.range)
+		{
+			army.recalculatePosition(gameState);
+			if (API3.SquareVectorDistance(pos, army.foePosition) > data.range * data.range)
+				continue;
+		}
+		else if (army.ID != +data.armyID)
 			continue;
+
 		while (army.foeEntities.length > 0)
 			army.removeFoe(gameState, army.foeEntities[0]);
 		while (army.ownEntities.length > 0)
 		{
 			let unitId = army.ownEntities[0];
 			army.removeOwn(gameState, unitId);
 			let unit = gameState.getEntityById(unitId);
 			if (unit && attackPlan.isAvailableUnit(gameState, unit))
 			{
 				unit.setMetadata(PlayerID, "plan", attackPlan.name);
 				attackPlan.unitCollection.updateEnt(unit);
 			}
 		}
-		gameState.ai.HQ.defenseManager.armies.splice(i--, 1);
 	}
 	if (!attackPlan.unitCollection.hasEntities())
 	{
 		attackPlan.Abort(gameState);
 		return false;
 	}
-	attackPlan.targetPlayer = ent.owner();
+	attackPlan.targetPlayer = target.owner();
 	attackPlan.targetPos = pos;
-	attackPlan.target = ent;
+	attackPlan.target = target;
 	attackPlan.state = "arrived";
 	return true;
 };
 
 m.AttackManager.prototype.Serialize = function()
 {
 	let properties = {
 		"totalNumber": this.totalNumber,
 		"attackNumber": this.attackNumber,
 		"rushNumber": this.rushNumber,
 		"raidNumber": this.raidNumber,
 		"debugTime": this.debugTime,
 		"maxRushes": this.maxRushes,
 		"rushSize": this.rushSize,
 		"currentEnemyPlayer": this.currentEnemyPlayer,
 		"defeated": this.defeated
 	};
 
 	let upcomingAttacks = {};
 	for (let key in this.upcomingAttacks)
 	{
 		upcomingAttacks[key] = [];
 		for (let attack of this.upcomingAttacks[key])
 			upcomingAttacks[key].push(attack.Serialize());
 	}
 
 	let startedAttacks = {};
 	for (let key in this.startedAttacks)
 	{
 		startedAttacks[key] = [];
 		for (let attack of this.startedAttacks[key])
 			startedAttacks[key].push(attack.Serialize());
 	}
 
 	return { "properties": properties, "upcomingAttacks": upcomingAttacks, "startedAttacks": startedAttacks };
 };
 
 m.AttackManager.prototype.Deserialize = function(gameState, data)
 {
 	for (let key in data.properties)
 		this[key] = data.properties[key];
 
 	this.upcomingAttacks = {};
 	for (let key in data.upcomingAttacks)
 	{
 		this.upcomingAttacks[key] = [];
 		for (let dataAttack of data.upcomingAttacks[key])
 		{
 			let attack = new m.AttackPlan(gameState, this.Config, dataAttack.properties.name);
 			attack.Deserialize(gameState, dataAttack);
 			attack.init(gameState);
 			this.upcomingAttacks[key].push(attack);
 		}
 	}
 
 	this.startedAttacks = {};
 	for (let key in data.startedAttacks)
 	{
 		this.startedAttacks[key] = [];
 		for (let dataAttack of data.startedAttacks[key])
 		{
 			let attack = new m.AttackPlan(gameState, this.Config, dataAttack.properties.name);
 			attack.Deserialize(gameState, dataAttack);
 			attack.init(gameState);
 			this.startedAttacks[key].push(attack);
 		}
 	}
 };
 
 return m;
 }(PETRA);
Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/attackPlan.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/attackPlan.js	(revision 19755)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/attackPlan.js	(revision 19756)
@@ -1,1999 +1,2018 @@
 var PETRA = function(m)
 {
 
 /**
  * This is an attack plan:
  * It deals with everything in an attack, from picking a target to picking a path to it
  * To making sure units are built, and pushing elements to the queue manager otherwise
  * It also handles the actual attack, though much work is needed on that.
  */
 
 m.AttackPlan = function(gameState, Config, uniqueID, type, data)
 {
 	this.Config = Config;
 	this.name = uniqueID;
 	this.type = type || "Attack";
 	this.state = "unexecuted";
 
 	if (data && data.target)
 	{
 		this.target = data.target;
 		this.targetPos = this.target.position();
 		this.targetPlayer = this.target.owner();
 	}
 	else
 	{
 		this.target = undefined;
 		this.targetPos = undefined;
 		this.targetPlayer = undefined;
 	}
 
+	this.uniqueTargetId = data && data.uniqueTargetId || undefined;
+
 	// get a starting rallyPoint ... will be improved later
 	let rallyPoint;
 	let rallyAccess;
 	let allAccesses = {};
 	for (let base of gameState.ai.HQ.baseManagers)
 	{
 		if (!base.anchor || !base.anchor.position())
 			continue;
 		let access = gameState.ai.accessibility.getAccessValue(base.anchor.position());
 		if (!rallyPoint)
 		{
 			rallyPoint = base.anchor.position();
 			rallyAccess = access;
 		}
 		if (!allAccesses[access])
 			allAccesses[access] = base.anchor.position();
 	}
 	if (!rallyPoint)	// no base ?  take the position of any of our entities
 	{
 		for (let ent of gameState.getOwnEntities().values())
 		{
 			if (!ent.position())
 				continue;
 			let access = gameState.ai.accessibility.getAccessValue(ent.position());
 			rallyPoint = ent.position();
 			rallyAccess = access;
 			allAccesses[access] = rallyPoint;
 			break;
 		}
 		if (!rallyPoint)
 		{
 			this.failed = true;
 			return false;
 		}
 	}
 	this.rallyPoint = rallyPoint;
 	this.overseas = 0;
 	if (gameState.ai.HQ.navalMap)
 	{
 		for (let structure of gameState.getEnemyStructures().values())
 		{
 			if (!structure.position())
 				continue;
 			let access = gameState.ai.accessibility.getAccessValue(structure.position());
 			if (access in allAccesses)
 			{
 				this.overseas = 0;
 				this.rallyPoint = allAccesses[access];
 				break;
 			}
 			else if (!this.overseas)
 			{
 				let sea = gameState.ai.HQ.getSeaBetweenIndices(gameState, rallyAccess, access);
 				if (!sea)
 					continue;
 				this.overseas = sea;
 				gameState.ai.HQ.navalManager.setMinimalTransportShips(gameState, sea, 1);
 			}
 		}
 	}
 	this.paused = false;
 	this.maxCompletingTime = 0;
 
 	// priority of the queues we'll create.
 	let priority = 70;
 
 	// unitStat priority is relative. If all are 0, the only relevant criteria is "currentsize/targetsize".
 	// if not, this is a "bonus". The higher the priority, the faster this unit will get built.
 	// Should really be clamped to [0.1-1.5] (assuming 1 is default/the norm)
 	// Eg: if all are priority 1, and the siege is 0.5, the siege units will get built
 	// only once every other category is at least 50% of its target size.
 	// note: siege build order is currently added by the military manager if a fortress is there.
 	this.unitStat = {};
 
 	// neededShips is the minimal number of ships which should be available for transport
 	if (type === "Rush")
 	{
 		priority = 250;
 		this.unitStat.Infantry = { "priority": 1, "minSize": 10, "targetSize": 20, "batchSize": 2, "classes": ["Infantry"],
 			"interests": [ ["strength",1], ["cost",1], ["costsResource", 0.5, "stone"], ["costsResource", 0.6, "metal"] ] };
 		this.unitStat.Cavalry = { "priority": 1, "minSize": 2, "targetSize": 4, "batchSize": 2, "classes": ["Cavalry", "CitizenSoldier"],
 			"interests": [ ["strength",1], ["cost",1] ] };
 		if (data && data.targetSize)
 			this.unitStat.Infantry.targetSize = data.targetSize;
 		this.neededShips = 1;
 	}
 	else if (type === "Raid")
 	{
 		priority = 150;
 		this.unitStat.Cavalry = { "priority": 1, "minSize": 3, "targetSize": 4, "batchSize": 2, "classes": ["Cavalry", "CitizenSoldier"],
 			"interests": [ ["strength",1], ["cost",1] ] };
 		this.neededShips = 1;
 	}
 	else if (type === "HugeAttack")
 	{
 		priority = 90;
 		// basically we want a mix of citizen soldiers so our barracks have a purpose, and champion units.
 		this.unitStat.RangedInfantry    = { "priority": 0.7, "minSize": 5, "targetSize": 20, "batchSize": 5, "classes": ["Infantry", "Ranged", "CitizenSoldier"],
 			"interests": [["strength",3], ["cost",1] ] };
 		this.unitStat.MeleeInfantry     = { "priority": 0.7, "minSize": 5, "targetSize": 20, "batchSize": 5, "classes": ["Infantry", "Melee", "CitizenSoldier"],
 			"interests": [ ["strength",3], ["cost",1] ] };
 		this.unitStat.ChampRangedInfantry = { "priority": 1, "minSize": 3, "targetSize": 18, "batchSize": 3, "classes": ["Infantry", "Ranged", "Champion"],
 			"interests": [["strength",3], ["cost",1] ] };
 		this.unitStat.ChampMeleeInfantry  = { "priority": 1, "minSize": 3, "targetSize": 18, "batchSize": 3, "classes": ["Infantry", "Melee", "Champion"],
 			"interests": [ ["strength",3], ["cost",1] ] };
 		this.unitStat.RangedCavalry     = { "priority": 0.7, "minSize": 4, "targetSize": 20, "batchSize": 4, "classes": ["Cavalry", "Ranged", "CitizenSoldier"],
 			"interests": [ ["strength",2], ["cost",1] ] };
 		this.unitStat.MeleeCavalry      = { "priority": 0.7, "minSize": 4, "targetSize": 20, "batchSize": 4, "classes": ["Cavalry", "Melee", "CitizenSoldier"],
 			"interests": [ ["strength",2], ["cost",1] ] };
 		this.unitStat.ChampRangedCavalry  = { "priority": 1, "minSize": 3, "targetSize": 15, "batchSize": 3, "classes": ["Cavalry", "Ranged", "Champion"],
 			"interests": [ ["strength",3], ["cost",1] ] };
 		this.unitStat.ChampMeleeCavalry   = { "priority": 1, "minSize": 3, "targetSize": 15, "batchSize": 3, "classes": ["Cavalry", "Melee", "Champion"],
 			"interests": [ ["strength",2], ["cost",1] ] };
 		this.unitStat.Hero                = { "priority": 1, "minSize": 0, "targetSize":  1, "batchSize": 1, "classes": ["Hero"],
 			"interests": [ ["strength",2], ["cost",1] ] };
 		this.neededShips = 5;
 	}
 	else
 	{
 		priority = 70;
 		this.unitStat.RangedInfantry = { "priority": 1, "minSize": 6, "targetSize": 16, "batchSize": 3, "classes": ["Infantry","Ranged"],
 			"interests": [ ["canGather", 1], ["strength",1.6], ["cost",1.5], ["costsResource", 0.3, "stone"], ["costsResource", 0.3, "metal"] ] };
 		this.unitStat.MeleeInfantry  = { "priority": 1, "minSize": 6, "targetSize": 16, "batchSize": 3, "classes": ["Infantry","Melee"],
 			"interests": [ ["canGather", 1], ["strength",1.6], ["cost",1.5], ["costsResource", 0.3, "stone"], ["costsResource", 0.3, "metal"] ] };
 	    	this.unitStat.Cavalry = { "priority": 1, "minSize": 2, "targetSize": 6, "batchSize": 2, "classes": ["Cavalry", "CitizenSoldier"],
 			"interests": [ ["strength",1], ["cost",1] ] };
 		this.neededShips = 3;
 	}
 
 	// Put some randomness on the attack size
 	let variation = randFloat(0.8, 1.2);
 	// and lower priority and smaller sizes for easier difficulty levels
 	if (this.Config.difficulty < 2)
 	{
 		priority *= 0.6;
 		variation *= 0.6;
 	}
 	else if (this.Config.difficulty < 3)
 	{
 		priority *= 0.8;
 		variation *= 0.8;
 	}
 	for (let cat in this.unitStat)
 	{
 		this.unitStat[cat].targetSize = Math.round(variation * this.unitStat[cat].targetSize);
 		this.unitStat[cat].minSize = Math.min(this.unitStat[cat].minSize, this.unitStat[cat].targetSize);
 	}
 
 	// change the sizes according to max population
 	this.neededShips = Math.ceil(this.Config.popScaling * this.neededShips);
 	for (let cat in this.unitStat)
 	{
 		this.unitStat[cat].targetSize = Math.round(this.Config.popScaling * this.unitStat[cat].targetSize);
 		this.unitStat[cat].minSize = Math.floor(this.Config.popScaling * this.unitStat[cat].minSize);
 	}
 
 	// TODO: there should probably be one queue per type of training building
 	gameState.ai.queueManager.addQueue("plan_" + this.name, priority);
 	gameState.ai.queueManager.addQueue("plan_" + this.name +"_champ", priority+1);
 	gameState.ai.queueManager.addQueue("plan_" + this.name +"_siege", priority);
 
 	// each array is [ratio, [associated classes], associated EntityColl, associated unitStat, name ]
 	this.buildOrder = [];
 	this.canBuildUnits = gameState.ai.HQ.canBuildUnits;
 
 	// some variables used during the attack
 	this.position5TurnsAgo = [0,0];
 	this.lastPosition = [0,0];
 	this.position = [0,0];
 	this.isBlocked = false;	     // true when this attack faces walls
 
 	return true;
 };
 
 m.AttackPlan.prototype.init = function(gameState)
 {
 	this.queue = gameState.ai.queues["plan_" + this.name];
 	this.queueChamp = gameState.ai.queues["plan_" + this.name +"_champ"];
 	this.queueSiege = gameState.ai.queues["plan_" + this.name +"_siege"];
 
 	this.unitCollection = gameState.getOwnUnits().filter(API3.Filters.byMetadata(PlayerID, "plan", this.name));
 	this.unitCollection.registerUpdates();
 
 	this.unit = {};
 
 	// defining the entity collections. Will look for units I own, that are part of this plan.
 	// Also defining the buildOrders.
 	for (let cat in this.unitStat)
 	{
 		let Unit = this.unitStat[cat];
 		this.unit[cat] = this.unitCollection.filter(API3.Filters.byClassesAnd(Unit.classes));
 		this.unit[cat].registerUpdates();
 		if (this.canBuildUnits)
 			this.buildOrder.push([0, Unit.classes, this.unit[cat], Unit, cat]);
 	}
 };
 
 m.AttackPlan.prototype.getName = function()
 {
 	return this.name;
 };
 
 m.AttackPlan.prototype.getType = function()
 {
 	return this.type;
 };
 
 m.AttackPlan.prototype.isStarted = function()
 {
 	return this.state !== "unexecuted" && this.state !== "completing";
 };
 
 m.AttackPlan.prototype.isPaused = function()
 {
 	return this.paused;
 };
 
 m.AttackPlan.prototype.setPaused = function(boolValue)
 {
 	this.paused = boolValue;
 };
 
 /**
  * Returns true if the attack can be executed at the current time
  * Basically it checks we have enough units.
  */
 m.AttackPlan.prototype.canStart = function()
 {
 	if (!this.canBuildUnits)
 		return true;
 
 	for (let unitCat in this.unitStat)
 		if (this.unit[unitCat].length < this.unitStat[unitCat].minSize)
 			return false;
 
 	return true;
 };
 
 m.AttackPlan.prototype.mustStart = function()
 {
 	if (this.isPaused())
 		return false;
 
 	if (!this.canBuildUnits)
 		return this.unitCollection.hasEntities();
 
 	let MaxReachedEverywhere = true;
 	let MinReachedEverywhere = true;
 	for (let unitCat in this.unitStat)
 	{
 		let Unit = this.unitStat[unitCat];
 		if (this.unit[unitCat].length < Unit.targetSize)
 			MaxReachedEverywhere = false;
 		if (this.unit[unitCat].length < Unit.minSize)
 		{
 			MinReachedEverywhere = false;
 			break;
 		}
 	}
 
 	if (MaxReachedEverywhere)
 		return true;
 	if (MinReachedEverywhere)
 	{
 		if (this.type === "Raid" && this.target && this.target.foundationProgress() && this.target.foundationProgress() > 60)
 			return true;
 	}
 	return false;
 };
 
 m.AttackPlan.prototype.forceStart = function()
 {
 	for (let unitCat in this.unitStat)
 	{
 		let Unit = this.unitStat[unitCat];
 		Unit.targetSize = 0;
 		Unit.minSize = 0;
 	}
 };
 
 /** Adds a build order. If resetQueue is true, this will reset the queue. */
 m.AttackPlan.prototype.addBuildOrder = function(gameState, name, unitStats, resetQueue)
 {
 	if (!this.isStarted())
 	{
 		// no minsize as we don't want the plan to fail at the last minute though.
 		this.unitStat[name] = unitStats;
 		let Unit = this.unitStat[name];
 		this.unit[name] = this.unitCollection.filter(API3.Filters.byClassesAnd(Unit.classes));
 		this.unit[name].registerUpdates();
 		this.buildOrder.push([0, Unit.classes, this.unit[name], Unit, name]);
 		if (resetQueue)
 		{
 			this.queue.empty();
 			this.queueChamp.empty();
 			this.queueSiege.empty();
 		}
 	}
 };
 
 m.AttackPlan.prototype.addSiegeUnits = function(gameState)
 {
 	if (this.unitStat.Siege || this.state !== "unexecuted")
 		return false;
 	// no minsize as we don't want the plan to fail at the last minute though.
 	let stat = { "priority": 1, "minSize": 0, "targetSize": 4, "batchSize": 2, "classes": ["Siege"],
 		"interests": [ ["siegeStrength", 3], ["cost",1] ] };
 	if (gameState.getPlayerCiv() === "maur")
 		stat.classes = ["Elephant", "Champion"];
 	if (this.Config.difficulty < 2)
 		stat.targetSize = 1;
 	else if (this.Config.difficulty < 3)
 		stat.targetSize = 2;
         stat.targetSize = Math.round(this.Config.popScaling * stat.targetSize);
 	this.addBuildOrder(gameState, "Siege", stat, true);
 	return true;
 };
 
 /** Three returns possible: 1 is "keep going", 0 is "failed plan", 2 is "start". */
 m.AttackPlan.prototype.updatePreparation = function(gameState)
 {
 	// the completing step is used to return resources and regroup the units
 	// so we check that we have no more forced order before starting the attack
 	if (this.state === "completing")
 	{
 		// if our target was destroyed, go back to "unexecuted" state
 		if (this.targetPlayer === undefined || !this.target || !gameState.getEntityById(this.target.id()))
 		{
 			this.state = "unexecuted";
 			this.target = undefined;
 		}
 		else
 		{
 			// check that all units have finished with their transport if needed
 			if (this.waitingForTransport())
 				return 1;
 			// bloqued units which cannot finish their order should not stop the attack
 			if (gameState.ai.elapsedTime < this.maxCompletingTime && this.hasForceOrder())
 				return 1;
 			return 2;
 		}
 	}
 
 	if (this.Config.debug > 3 && gameState.ai.playedTurn % 50 === 0)
 		this.debugAttack();
 
 	// if we need a transport, wait for some transport ships
 	if (this.overseas && !gameState.ai.HQ.navalManager.seaTransportShips[this.overseas].length)
 		return 1;
 
 	this.assignUnits(gameState);
 	if (this.type !== "Raid" && gameState.ai.HQ.attackManager.getAttackInPreparation("Raid") !== undefined)
 		this.reassignCavUnit(gameState);    // reassign some cav (if any) to fasten raid preparations
 
 	// special case: if we've reached max pop, and we can start the plan, start it.
 	if (gameState.getPopulationMax() - gameState.getPopulation() < 5)
 	{
 		let lengthMin = 16;
 		if (gameState.getPopulationMax() < 300)
 			lengthMin -= Math.floor(8 * (300 - gameState.getPopulationMax()) / 300);
 		if (this.canStart() || this.unitCollection.length > lengthMin)
 		{
 			this.queue.empty();
 			this.queueChamp.empty();
 			this.queueSiege.empty();
 		}
 		else	// Abort the plan so that its units will be reassigned to other plans.
 		{
 			if (this.Config.debug > 1)
 			{
 				let am = gameState.ai.HQ.attackManager;
 				API3.warn(" attacks upcoming: raid " + am.upcomingAttacks.Raid.length +
 					  " rush " + am.upcomingAttacks.Rush.length +
 					  " attack " + am.upcomingAttacks.Attack.length +
 					  " huge " + am.upcomingAttacks.HugeAttack.length);
 				API3.warn(" attacks started: raid " + am.startedAttacks.Raid.length +
 					  " rush " + am.startedAttacks.Rush.length +
 					  " attack " + am.startedAttacks.Attack.length +
 					  " huge " + am.startedAttacks.HugeAttack.length);
 			}
 			return 0;
 	    }
 	}
 	else if (this.mustStart() && gameState.countOwnQueuedEntitiesWithMetadata("plan", +this.name) > 0)
 	{
 		// keep on while the units finish being trained, then we'll start
 		this.queue.empty();
 		this.queueChamp.empty();
 		this.queueSiege.empty();
 		return 1;
 	}
 	else if (!this.mustStart())
 	{
 		if (this.canBuildUnits)
 		{
 			// We still have time left to recruit units and do stuffs.
 			if (!this.unitStat.Siege)
 			{
 				let numSiegeBuilder = 0;
 				let playerCiv = gameState.getPlayerCiv();
 				if (playerCiv !== "mace" && playerCiv !== "maur")
 					numSiegeBuilder += gameState.getOwnEntitiesByClass("Fortress", true).filter(API3.Filters.isBuilt()).length;
 				if (playerCiv === "mace" || playerCiv === "maur" || playerCiv === "rome")
 					numSiegeBuilder += gameState.countEntitiesByType(gameState.ai.HQ.bAdvanced[0], true);
 				if (numSiegeBuilder > 0)
 					this.addSiegeUnits(gameState);
 			}
 			this.trainMoreUnits(gameState);
 			// may happen if we have no more training facilities and build orders are canceled
 			if (!this.buildOrder.length)
 				return 0;	// will abort the plan
 		}
 		return 1;
 	}
 
 	// if we're here, it means we must start
 	this.state = "completing";
 
 	if (!this.chooseTarget(gameState))
 		return 0;
 	if (!this.overseas)
 		this.getPathToTarget(gameState);
 
 	if (this.type === "Raid")
 		this.maxCompletingTime = gameState.ai.elapsedTime + 20;
 	else
 	{
 		if (this.type === "Rush")
 			this.maxCompletingTime = gameState.ai.elapsedTime + 40;
 		else
 			this.maxCompletingTime = gameState.ai.elapsedTime + 60;
 		// warn our allies so that they can help if possible
 		if (!this.requested)
 			Engine.PostCommand(PlayerID, {"type": "attack-request", "source": PlayerID, "player": this.targetPlayer});
 	}
 
 	let rallyPoint = this.rallyPoint;
 	let rallyIndex = gameState.ai.accessibility.getAccessValue(rallyPoint);
 	for (let ent of this.unitCollection.values())
 	{
 		// For the time being, if occupied in a transport, remove the unit from this plan   TODO improve that
 		if (ent.getMetadata(PlayerID, "transport") !== undefined || ent.getMetadata(PlayerID, "transporter") !== undefined)
 		{
 			ent.setMetadata(PlayerID, "plan", -1);
 			continue;
 		}
 		ent.setMetadata(PlayerID, "role", "attack");
 		ent.setMetadata(PlayerID, "subrole", "completing");
 		let queued = false;
 		if (ent.resourceCarrying() && ent.resourceCarrying().length)
 			queued = m.returnResources(gameState, ent);
 		let index = gameState.ai.accessibility.getAccessValue(ent.position());
 		if (index === rallyIndex)
 			ent.moveToRange(rallyPoint[0], rallyPoint[1], 0, 15, queued);
 		else
 			gameState.ai.HQ.navalManager.requireTransport(gameState, ent, index, rallyIndex, rallyPoint);
 	}
 
 	// reset all queued units
 	let plan = this.name;
 	gameState.ai.queueManager.removeQueue("plan_" + plan);
 	gameState.ai.queueManager.removeQueue("plan_" + plan + "_champ");
 	gameState.ai.queueManager.removeQueue("plan_" + plan + "_siege");
 	return	1;
 };
 
 
 m.AttackPlan.prototype.trainMoreUnits = function(gameState)
 {
 	// let's sort by training advancement, ie 'current size / target size'
 	// count the number of queued units too.
 	// substract priority.
 	for (let i = 0; i < this.buildOrder.length; ++i)
 	{
 		let special = "Plan_" + this.name + "_" + this.buildOrder[i][4];
 		let aQueued = gameState.countOwnQueuedEntitiesWithMetadata("special", special);
 		aQueued += this.queue.countQueuedUnitsWithMetadata("special", special);
 		aQueued += this.queueChamp.countQueuedUnitsWithMetadata("special", special);
 		aQueued += this.queueSiege.countQueuedUnitsWithMetadata("special", special);
 		this.buildOrder[i][0] = this.buildOrder[i][2].length + aQueued;
 	}
 	this.buildOrder.sort(function (a,b) {
 		let va = a[0]/a[3].targetSize - a[3].priority;
 		if (a[0] >= a[3].targetSize)
 			va += 1000;
 		let vb = b[0]/b[3].targetSize - b[3].priority;
 		if (b[0] >= b[3].targetSize)
 			vb += 1000;
 		return va - vb;
 	});
 
 	if (this.Config.debug > 1 && gameState.ai.playedTurn%50 === 0)
 	{
 		API3.warn("====================================");
 		API3.warn("======== build order for plan " + this.name);
 		for (let order of this.buildOrder)
 		{
 			let specialData = "Plan_"+this.name+"_"+order[4];
 			let inTraining = gameState.countOwnQueuedEntitiesWithMetadata("special", specialData);
 			let queue1 = this.queue.countQueuedUnitsWithMetadata("special", specialData);
 			let queue2 = this.queueChamp.countQueuedUnitsWithMetadata("special", specialData);
 			let queue3 = this.queueSiege.countQueuedUnitsWithMetadata("special", specialData);
 			API3.warn(" >>> " + order[4] + " done " + order[2].length + " training " + inTraining +
 				  " queue " + queue1 + " champ " + queue2 + " siege " + queue3 + " >> need " + order[3].targetSize);
 		}
 		API3.warn("====================================");
 	}
 
 	let firstOrder = this.buildOrder[0];
 	if (firstOrder[0] < firstOrder[3].targetSize)
 	{
 		// find the actual queue we want
 		let queue = this.queue;
 		if (firstOrder[3].classes.indexOf("Siege") !== -1 ||
 			(gameState.getPlayerCiv() == "maur" && firstOrder[3].classes.indexOf("Elephant") !== -1 &&
 			                                       firstOrder[3].classes.indexOf("Champion") !== -1))
 			queue = this.queueSiege;
 		else if (firstOrder[3].classes.indexOf("Hero") !== -1)
 			queue = this.queueSiege;
 		else if (firstOrder[3].classes.indexOf("Champion") !== -1)
 			queue = this.queueChamp;
 
 		if (queue.length() <= 5)
 		{
 			let template = gameState.ai.HQ.findBestTrainableUnit(gameState, firstOrder[1], firstOrder[3].interests);
 			// HACK (TODO replace) : if we have no trainable template... Then we'll simply remove the buildOrder,
 			// effectively removing the unit from the plan.
 			if (template === undefined)
 			{
 				if (this.Config.debug > 1)
 					API3.warn("attack no template found " + firstOrder[1]);
 				delete this.unitStat[firstOrder[4]];	// deleting the associated unitstat.
 				this.buildOrder.splice(0,1);
 			}
 			else
 			{
 				if (this.Config.debug > 2)
 					API3.warn("attack template " + template + " added for plan " + this.name);
 				let max = firstOrder[3].batchSize;
 				let specialData = "Plan_" + this.name + "_" + firstOrder[4];
 				let data = { "plan": this.name, "special": specialData, "base": 0 };
 				data.role = gameState.getTemplate(template).hasClass("CitizenSoldier") ? "worker" : "attack";
 				let trainingPlan = new m.TrainingPlan(gameState, template, data, max, max);
 				if (trainingPlan.template)
 					queue.addPlan(trainingPlan);
 				else if (this.Config.debug > 1)
 					API3.warn("training plan canceled because no template for " + template + "   build1 " + uneval(firstOrder[1]) +
 						  " build3 " + uneval(firstOrder[3].interests));
 			}
 		}
 	}
 };
 
 m.AttackPlan.prototype.assignUnits = function(gameState)
 {
 	let plan = this.name;
 	let added = false;
 	// If we can not build units, assign all available except those affected to allied defense to the current attack
 	if (!this.canBuildUnits)
 	{
 		for (let ent of gameState.getOwnUnits().values())
 		{
 			if (ent.getMetadata(PlayerID, "allied") || !this.isAvailableUnit(gameState, ent))
 				continue;
 			ent.setMetadata(PlayerID, "plan", plan);
 			this.unitCollection.updateEnt(ent);
 			added = true;
 		}
 		return added;
 	}
 
 	if (this.type === "Raid")
 	{
 		// Raid are fast cavalry attack: assign all cav except some for hunting
 		let num = 0;
 		for (let ent of gameState.getOwnUnits().values())
 		{
 			if (!ent.hasClass("Cavalry") || !this.isAvailableUnit(gameState, ent))
 				continue;
 			if (num++ < 2)
 				continue;
 			ent.setMetadata(PlayerID, "plan", plan);
 			this.unitCollection.updateEnt(ent);
 			added = true;
 		}
 		return added;
 	}
 
 	// Assign all units without specific role
 	for (let ent of gameState.getOwnEntitiesByRole(undefined, true).values())
 	{
 		if (!ent.hasClass("Unit") || !this.isAvailableUnit(gameState, ent))
 			continue;
 		if (ent.hasClass("Ship") || ent.hasClass("Support") || ent.attackTypes() === undefined)
 			continue;
 		ent.setMetadata(PlayerID, "plan", plan);
 		this.unitCollection.updateEnt(ent);
 		added = true;
 	}
 	// Add units previously in a plan, but which left it because needed for defense or attack finished
 	for (let ent of gameState.ai.HQ.attackManager.outOfPlan.values())
 	{
 		if (!this.isAvailableUnit(gameState, ent))
 			continue;
 		ent.setMetadata(PlayerID, "plan", plan);
 		this.unitCollection.updateEnt(ent);
 		added = true;
 	}
 
 	// Finally add also some workers,
 	// If Rush, assign all kind of workers, keeping only a minimum number of defenders
 	// Otherwise, assign only some idle workers if too much of them
 	let num = 0;
 	let numbase = {};
 	let keep = this.type === "Rush" ? Math.round(this.Config.popScaling * (12 + 4*this.Config.personality.defensive)) : 6;
 	for (let ent of gameState.getOwnEntitiesByRole("worker", true).values())
 	{
 		if (!ent.hasClass("CitizenSoldier") || !this.isAvailableUnit(gameState, ent))
 			continue;
 		let baseID = ent.getMetadata(PlayerID, "base");
 		if (baseID)
 			numbase[baseID] = numbase[baseID] ? ++numbase[baseID] : 1;
 		else
 		{
 			API3.warn("Petra problem ent without base ");
 			m.dumpEntity(ent);
 			continue;
 		}
 		if (this.type !== "Rush" && ent.getMetadata(PlayerID, "subrole") !== "idle")
 			continue;
 		if (num++ < keep || numbase[baseID] < 5)
 			continue;
 		ent.setMetadata(PlayerID, "plan", plan);
 		this.unitCollection.updateEnt(ent);
 		added = true;
 	}
 	return added;
 };
 
 m.AttackPlan.prototype.isAvailableUnit = function(gameState, ent)
 {
 	if (!ent.position())
 		return false;
 	if (ent.getMetadata(PlayerID, "plan") !== undefined && ent.getMetadata(PlayerID, "plan") !== -1 ||
 	    ent.getMetadata(PlayerID, "transport") !== undefined || ent.getMetadata(PlayerID, "transporter") !== undefined)
 		return false;
 	if (gameState.ai.HQ.gameTypeManager.criticalEnts.has(ent.id()) && (this.overseas || ent.healthLevel() < 0.8))
 		return false;
 	return true;
 };
 
 /** Reassign one (at each turn) Cav unit to fasten raid preparation. */
 m.AttackPlan.prototype.reassignCavUnit = function(gameState)
 {
 	let found;
 	for (let ent of this.unitCollection.values())
 	{
 		if (!ent.position() || ent.getMetadata(PlayerID, "transport") !== undefined)
 			continue;
 		if (!ent.hasClass("Cavalry") || !ent.hasClass("CitizenSoldier"))
 			continue;
 		found = ent;
 		break;
 	}
 	if (!found)
 		return;
 	let raid = gameState.ai.HQ.attackManager.getAttackInPreparation("Raid");
 	found.setMetadata(PlayerID, "plan", raid.name);
 	this.unitCollection.updateEnt(found);
 	raid.unitCollection.updateEnt(found);
 };
 
 m.AttackPlan.prototype.chooseTarget = function(gameState)
 {
 	if (this.targetPlayer === undefined)
 	{
 		this.targetPlayer = gameState.ai.HQ.attackManager.getEnemyPlayer(gameState, this);
 		if (this.targetPlayer === undefined)
 			return false;
 	}
 
 	this.target = this.getNearestTarget(gameState, this.rallyPoint);
 	if (!this.target)
 	{
+		if (this.uniqueTargetId)
+			return false;
+
 		// may-be all our previous enemey target (if not recomputed here) have been destroyed ?
 		this.targetPlayer = gameState.ai.HQ.attackManager.getEnemyPlayer(gameState, this);
 		if (this.targetPlayer !== undefined)
 			this.target = this.getNearestTarget(gameState, this.rallyPoint);
 		if (!this.target)
 			return false;
 	}
 	this.targetPos = this.target.position();
 	// redefine a new rally point for this target if we have a base on the same land
 	// find a new one on the pseudo-nearest base (dist weighted by the size of the island)
 	let targetIndex = gameState.ai.accessibility.getAccessValue(this.targetPos);
 	let rallyIndex = gameState.ai.accessibility.getAccessValue(this.rallyPoint);
 	if (targetIndex !== rallyIndex)
 	{
 		let distminSame = Math.min();
 		let rallySame;
 		let distminDiff = Math.min();
 		let rallyDiff;
 		for (let base of gameState.ai.HQ.baseManagers)
 		{
 			let anchor = base.anchor;
 			if (!anchor || !anchor.position())
 				continue;
 			let dist = API3.SquareVectorDistance(anchor.position(), this.targetPos);
 			if (base.accessIndex === targetIndex)
 			{
 				if (dist >= distminSame)
 					continue;
 				distminSame = dist;
 				rallySame = anchor.position();
 			}
 			else
 			{
 				dist = dist / Math.sqrt(gameState.ai.accessibility.regionSize[base.accessIndex]);
 				if (dist >= distminDiff)
 					continue;
 				distminDiff = dist;
 				rallyDiff = anchor.position();
 			}
 		}
 
 		if (rallySame)
 		{
 			this.rallyPoint = rallySame;
 			this.overseas = 0;
 		}
 		else if (rallyDiff)
 		{
 			rallyIndex = gameState.ai.accessibility.getAccessValue(rallyDiff);
 			this.rallyPoint = rallyDiff;
 			this.overseas = gameState.ai.HQ.getSeaBetweenIndices(gameState, rallyIndex, targetIndex);
 			if (this.overseas)
 				gameState.ai.HQ.navalManager.setMinimalTransportShips(gameState, this.overseas, this.neededShips);
 			else
 				return false;
 		}
 	}
 	else if (this.overseas)
 		this.overseas = 0;
 
 	return true;
 };
 /**
  * sameLand true means that we look for a target for which we do not need to take a transport
  */
 m.AttackPlan.prototype.getNearestTarget = function(gameState, position, sameLand)
 {
 	this.isBlocked = false;
 
 	let targets;
-	if (this.type === "Raid")
-		targets = this.raidTargetFinder(gameState);
-	else if (this.type === "Rush" || this.type === "Attack")
-		targets = this.rushTargetFinder(gameState, this.targetPlayer);
+	if (this.uniqueTargetId)
+	{
+		targets = new API3.EntityCollection(gameState.sharedScript);
+		let ent = gameState.getEntityById(this.uniqueTargetId);
+		if (ent)
+			targets.addEnt(ent);
+	}
 	else
-		targets = this.defaultTargetFinder(gameState, this.targetPlayer);
+	{
+		if (this.type === "Raid")
+			targets = this.raidTargetFinder(gameState);
+		else if (this.type === "Rush" || this.type === "Attack")
+			targets = this.rushTargetFinder(gameState, this.targetPlayer);
+		else
+			targets = this.defaultTargetFinder(gameState, this.targetPlayer);
+	}
 	if (!targets.hasEntities())
 		return undefined;
 
 	let land = gameState.ai.accessibility.getAccessValue(position);
 
 	// picking the nearest target
 	let target;
 	let minDist = Math.min();
 	for (let ent of targets.values())
 	{
 		if (this.targetPlayer === 0 && gameState.getGameType() === "capture_the_relic" &&
 		   (!ent.hasClass("Relic") || gameState.ai.HQ.gameTypeManager.targetedGaiaRelics.has(ent.id())))
 			continue;
 		if (!ent.position())
 			continue;
 		if (sameLand && gameState.ai.accessibility.getAccessValue(ent.position()) !== land)
 			continue;
 		let dist = API3.SquareVectorDistance(ent.position(), position);
 		// Do not bother with decaying structure if they are not dangerous
 		if (ent.decaying() && !ent.getDefaultArrow() && (!ent.isGarrisonHolder() || !ent.garrisoned().length))
 			continue;
 		// In normal attacks, disfavor fields
 		if (this.type !== "Rush" && this.type !== "Raid" && ent.hasClass("Field"))
 			dist += 100000;
 		if (dist < minDist)
 		{
 			minDist = dist;
 			target = ent;
 		}
 	}
 	if (!target)
 		return undefined;
 
 	// Check that we can reach this target
 	target = this.checkTargetObstruction(gameState, target, position);
 
 	if (!target)
 		return undefined;
 	if (this.targetPlayer === 0 && gameState.getGameType() === "capture_the_relic" && target.hasClass("Relic"))
 		gameState.ai.HQ.gameTypeManager.targetedGaiaRelics.add(target.id());
 	// Rushes can change their enemy target if nothing found with the preferred enemy
 	// Obstruction also can change the enemy target
 	this.targetPlayer = target.owner();
 	return target;
 };
 
 /** Default target finder aims for conquest critical targets */
 m.AttackPlan.prototype.defaultTargetFinder = function(gameState, playerEnemy)
 {
 	let targets;
 	if (gameState.getGameType() === "wonder")
 		targets = gameState.getEnemyStructures(playerEnemy).filter(API3.Filters.byClass("Wonder"));
 	else if (gameState.getGameType() === "regicide")
 		targets = gameState.getEnemyUnits(playerEnemy).filter(API3.Filters.byClass("Hero"));
 	else if (gameState.getGameType() === "capture_the_relic")
 		targets = gameState.updatingGlobalCollection("allRelics", API3.Filters.byClass("Relic")).filter(relic => relic.owner() === playerEnemy);
 	if (targets && targets.hasEntities())
 		return targets;
 
 	targets = gameState.getEnemyStructures(playerEnemy).filter(API3.Filters.byClass("CivCentre"));
 	if (!targets.hasEntities())
 		targets = gameState.getEnemyStructures(playerEnemy).filter(API3.Filters.byClass("ConquestCritical"));
 	// If there's nothing, attack anything else that's less critical
 	if (!targets.hasEntities())
 		targets = gameState.getEnemyStructures(playerEnemy).filter(API3.Filters.byClass("Town"));
 	if (!targets.hasEntities())
 		targets = gameState.getEnemyStructures(playerEnemy).filter(API3.Filters.byClass("Village"));
 	// no buildings, attack anything conquest critical, even units
 	if (!targets.hasEntities())
 		targets = gameState.getEntities(playerEnemy).filter(API3.Filters.byClass("ConquestCritical"));
 	return targets;
 };
 
 /** Rush target finder aims at isolated non-defended buildings */
 m.AttackPlan.prototype.rushTargetFinder = function(gameState, playerEnemy)
 {
 	let targets = new API3.EntityCollection(gameState.sharedScript);
 	let buildings;
 	if (playerEnemy !== undefined)
 		buildings = gameState.getEnemyStructures(playerEnemy).toEntityArray();
 	else
 		buildings = gameState.getEnemyStructures().toEntityArray();
 	if (!buildings.length)
 		return targets;
 
 	this.position = this.unitCollection.getCentrePosition();
 	if (!this.position)
 		this.position = this.rallyPoint;
 
 	let target;
 	let minDist = Math.min();
 	for (let building of buildings)
 	{
 		if (building.owner() === 0)
 			continue;
 		if (building.hasDefensiveFire())
 			continue;
 		let pos = building.position();
 		let defended = false;
 		for (let defense of buildings)
 		{
 			if (!defense.hasDefensiveFire())
 				continue;
 			let dist = API3.SquareVectorDistance(pos, defense.position());
 			if (dist < 6400)   // TODO check on defense range rather than this fixed 80*80
 			{
 				defended = true;
 				break;
 			}
 		}
 		if (defended)
 			continue;
 		let dist = API3.SquareVectorDistance(pos, this.position);
 		if (dist > minDist)
 			continue;
 		minDist = dist;
 		target = building;
 	}
 	if (target)
 		targets.addEnt(target);
 
 	if (!targets.hasEntities())
 	{
 		if (this.type === "Attack")
 			targets = this.defaultTargetFinder(gameState, playerEnemy);
 		else if (this.type === "Rush" && playerEnemy)
 			targets = this.rushTargetFinder(gameState);
 	}
 
 	return targets;
 };
 
 /** Raid target finder aims at destructing foundations from which our defenseManager has attacked the builders */
 m.AttackPlan.prototype.raidTargetFinder = function(gameState)
 {
 	let targets = new API3.EntityCollection(gameState.sharedScript);
 	for (let targetId of gameState.ai.HQ.defenseManager.targetList)
 	{
 		let target = gameState.getEntityById(targetId);
 		if (target && target.position())
 			targets.addEnt(target);
 	}
 	return targets;
 };
 
 /**
  * Check that we can have a path to this target
  * otherwise we may be blocked by walls and try to react accordingly
  * This is done only when attacker and target are on the same land
  */
 m.AttackPlan.prototype.checkTargetObstruction = function(gameState, target, position)
 {
 
 	let targetPos = target.position();
 	if (gameState.ai.accessibility.getAccessValue(targetPos) !== gameState.ai.accessibility.getAccessValue(position))
 		return target;
 
 	let startPos = { "x": position[0], "y": position[1] };
 	let endPos = { "x": targetPos[0], "y": targetPos[1] };
 	let blocker;
 	let path = Engine.ComputePath(startPos, endPos, gameState.getPassabilityClassMask("default"));
 	if (!path.length)
 		return undefined;
 
 	let pathPos = [path[0].x, path[0].y];
 	let dist = API3.VectorDistance(pathPos, targetPos);
 	let radius = target.obstructionRadius();
 	for (let struct of gameState.getEnemyStructures().values())
 	{
 		if (!struct.position() || !struct.get("Obstruction") || struct.hasClass("Field"))
 			continue;
 		// we consider that we can reach the target, but nonetheless check that we did not cross any enemy gate
 		if (dist < radius + 10 && !struct.hasClass("Gates"))
 			continue;
 		// Check that we are really blocked by this structure, i.e. advancing by 1+0.8(clearance)m
 		// in the target direction would bring us inside its obstruction.
 		let structPos = struct.position();
 		let x = pathPos[0] - structPos[0] + 1.8 * (targetPos[0] - pathPos[0]) / dist;
 		let y = pathPos[1] - structPos[1] + 1.8 * (targetPos[1] - pathPos[1]) / dist;
 
 		if (struct.get("Obstruction/Static"))
 		{
 			if (!struct.angle())
 				continue;
 			let angle = struct.angle();
 			let width = +struct.get("Obstruction/Static/@width");
 			let depth = +struct.get("Obstruction/Static/@depth");
 			let cosa = Math.cos(angle);
 			let sina = Math.sin(angle);
 			let u = x * cosa - y * sina;
 			let v = x * sina + y * cosa;
 			if (Math.abs(u) < width/2 && Math.abs(v) < depth/2)
 			{
 				blocker = struct;
 				break;
 			}
 		}
 		else if (struct.get("Obstruction/Obstructions"))
 		{
 			if (!struct.angle())
 				continue;
 			let angle = struct.angle();
 			let width = +struct.get("Obstruction/Obstructions/Door/@width");
 			let depth = +struct.get("Obstruction/Obstructions/Door/@depth");
 			let doorHalfWidth = width / 2;
 			width += +struct.get("Obstruction/Obstructions/Left/@width");
 			depth = Math.max(depth, +struct.get("Obstruction/Obstructions/Left/@depth"));
 			width += +struct.get("Obstruction/Obstructions/Right/@width");
 			depth = Math.max(depth, +struct.get("Obstruction/Obstructions/Right/@depth"));
 			let cosa = Math.cos(angle);
 			let sina = Math.sin(angle);
 			let u = x * cosa - y * sina;
 			let v = x * sina + y * cosa;
 			if (Math.abs(u) < width/2 && Math.abs(v) < depth/2)
 			{
 				blocker = struct;
 				break;
 			}
 			// check that the path does not cross this gate (could happen if not locked)
 			for (let i = 1; i < path.length; ++i)
 			{
 				let u1 = (path[i-1].x - structPos[0]) * cosa - (path[i-1].y - structPos[1]) * sina;
 				let v1 = (path[i-1].x - structPos[0]) * sina + (path[i-1].y - structPos[1]) * cosa;
 				let u2 = (path[i].x - structPos[0]) * cosa - (path[i].y - structPos[1]) * sina;
 				let v2 = (path[i].x - structPos[0]) * sina + (path[i].y - structPos[1]) * cosa;
 				if (v1 * v2 < 0)
 				{
 					let u0 = (u1*v2 - u2*v1) / (v2-v1);
 					if (Math.abs(u0) > doorHalfWidth)
 						continue;
 					blocker = struct;
 					break;
 				}
 			}
 			if (blocker)
 				break;
 		}
 		else if (struct.get("Obstruction/Unit"))
 		{
 			let r = +this.get("Obstruction/Unit/@radius");
 			if (x*x + y*y < r*r)
 			{
 				blocker = struct;
 				break;
 			}
 		}
 	}
 
 	if (blocker && blocker.hasClass("StoneWall"))
 	{
 /*		if (this.hasSiegeUnits())
 		{ */
 			this.isBlocked = true;
 			return blocker;
 /*		}
 		return undefined; */
 	}
 	else if (blocker)
 	{
 		this.isBlocked = true;
 		return blocker;
 	}
 
 	return target;
 };
 
 m.AttackPlan.prototype.getPathToTarget = function(gameState)
 {
 	let startAccess = gameState.ai.accessibility.getAccessValue(this.rallyPoint);
 	let endAccess = gameState.ai.accessibility.getAccessValue(this.targetPos);
 	if (startAccess != endAccess)
 		return false;
 
 	Engine.ProfileStart("AI Compute path");
 	let startPos = { "x": this.rallyPoint[0], "y": this.rallyPoint[1] };
 	let endPos = { "x": this.targetPos[0], "y": this.targetPos[1] };
 	let path = Engine.ComputePath(startPos, endPos, gameState.getPassabilityClassMask("large"));
 	this.path = [];
 	this.path.push(this.targetPos);
 	for (let p in path)
 		this.path.push([path[p].x, path[p].y]);
 	this.path.push(this.rallyPoint);
 	this.path.reverse();
 	// Change the rally point to something useful
 	this.setRallyPoint(gameState);
 	Engine.ProfileStop();
 
 	return true;
 };
 
 /** Set rally point at the border of our territory */
 m.AttackPlan.prototype.setRallyPoint = function(gameState)
 {
 	for (let i = 0; i < this.path.length; ++i)
 	{
 		if (gameState.ai.HQ.territoryMap.getOwner(this.path[i]) === PlayerID)
 			continue;
 
 		if (i === 0)
 			this.rallyPoint = this.path[0];
 		else if (i > 1 && gameState.ai.HQ.isDangerousLocation(gameState, this.path[i-1], 20))
 		{
 			this.rallyPoint = this.path[i-2];
 			this.path.splice(0, i-2);
 		}
 		else
 		{
 			this.rallyPoint = this.path[i-1];
 			this.path.splice(0, i-1);
 		}
 		break;
 	}
 };
 
 /**
  * Executes the attack plan, after this is executed the update function will be run every turn
  * If we're here, it's because we have enough units.
  */
 m.AttackPlan.prototype.StartAttack = function(gameState)
 {
 	if (this.Config.debug > 1)
 		API3.warn("start attack " + this.name + " with type " + this.type);
 
 	// if our target was destroyed during preparation, choose a new one
 	if (this.targetPlayer === undefined || !this.target || !gameState.getEntityById(this.target.id()))
 	{
 		if (!this.chooseTarget(gameState))
 			return false;
 	}
 
 	// check we have a target and a path.
 	if (this.targetPos && (this.overseas || this.path))
 	{
 		// erase our queue. This will stop any leftover unit from being trained.
 		gameState.ai.queueManager.removeQueue("plan_" + this.name);
 		gameState.ai.queueManager.removeQueue("plan_" + this.name + "_champ");
 		gameState.ai.queueManager.removeQueue("plan_" + this.name + "_siege");
 
 		for (let ent of this.unitCollection.values())
 			ent.setMetadata(PlayerID, "subrole", "walking");
 		this.unitCollection.setStance("aggressive");
 
 		if (gameState.ai.accessibility.getAccessValue(this.targetPos) === gameState.ai.accessibility.getAccessValue(this.rallyPoint))
 		{
 			if (!this.path[0][0] || !this.path[0][1])
 			{
 				if (this.Config.debug > 1)
 					API3.warn("StartAttack: Problem with path " + uneval(this.path));
 				return false;
 			}
 			this.state = "walking";
 			this.unitCollection.move(this.path[0][0], this.path[0][1]);
 		}
 		else
 		{
 			this.state = "transporting";
 			let startIndex = gameState.ai.accessibility.getAccessValue(this.rallyPoint);
 			let endIndex = gameState.ai.accessibility.getAccessValue(this.targetPos);
 			let endPos = this.targetPos;
 			// TODO require a global transport for the collection,
 			// and put back its state to "walking" when the transport is finished
 			for (let ent of this.unitCollection.values())
 				gameState.ai.HQ.navalManager.requireTransport(gameState, ent, startIndex, endIndex, endPos);
 		}
 	}
 	else
 	{
 		gameState.ai.gameFinished = true;
 		API3.warn("I do not have any target. So I'll just assume I won the game.");
 		return false;
 	}
 	return true;
 };
 
 /** Runs every turn after the attack is executed */
 m.AttackPlan.prototype.update = function(gameState, events)
 {
 	if (!this.unitCollection.hasEntities())
 		return 0;
 
 	Engine.ProfileStart("Update Attack");
 
 	this.position = this.unitCollection.getCentrePosition();
 
 	let self = this;
 
 	// we are transporting our units, let's wait
 	// TODO instead of state "arrived", made a state "walking" with a new path
 	if (this.state === "transporting")
 		this.UpdateTransporting(gameState, events);
 
 	if (this.state === "walking" && !this.UpdateWalking(gameState, events))
 	{
 		Engine.ProfileStop();
 		return 0;
 	}
 
 	if (this.state === "arrived")
 	{
 		// let's proceed on with whatever happens now.
 		this.state = "";
 		this.startingAttack = true;
 		this.unitCollection.forEach( function (ent) {
 			ent.stopMoving();
 			ent.setMetadata(PlayerID, "subrole", "attacking");
 		});
 		if (this.type === "Rush")   // try to find a better target for rush
 		{
 			let newtarget = this.getNearestTarget(gameState, this.position);
 			if (newtarget)
 			{
 				this.target = newtarget;
 				this.targetPos = this.target.position();
 			}
 		}
 	}
 
 	// basic state of attacking.
 	if (this.state === "")
 	{
 		// First update the target and/or its position if needed
 		if (!this.UpdateTarget(gameState, events))
 		{
 			Engine.ProfileStop();
 			return false;
 		}
 
 		let time = gameState.ai.elapsedTime;
 		for (let evt of events.Attacked)
 		{
 			if (!this.unitCollection.hasEntId(evt.target))
 				continue;
 			let attacker = gameState.getEntityById(evt.attacker);
 			let ourUnit = gameState.getEntityById(evt.target);
 			if (!ourUnit || !attacker || !attacker.position() || !attacker.hasClass("Unit"))
 				continue;
 			if (m.isSiegeUnit(ourUnit))
 			{	// if our siege units are attacked, we'll send some units to deal with enemies.
 				let collec = this.unitCollection.filter(API3.Filters.not(API3.Filters.byClass("Siege"))).filterNearest(ourUnit.position(), 5);
 				for (let ent of collec.values())
 				{
 					if (m.isSiegeUnit(ent))	// needed as mauryan elephants are not filtered out
 						continue;
 					ent.attack(attacker.id(), m.allowCapture(gameState, ent, attacker));
 					ent.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
 				}
 				// And if this attacker is a non-ranged siege unit and our unit also, attack it
 				if (m.isSiegeUnit(attacker) && attacker.hasClass("Melee") && ourUnit.hasClass("Melee"))
 				{
 					ourUnit.attack(attacker.id(), m.allowCapture(gameState, ourUnit, attacker));
 					ourUnit.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
 				}
 			}
 			else
 			{
 				if (this.isBlocked && !ourUnit.hasClass("Ranged") && attacker.hasClass("Ranged"))
 				{
 					// do not react if our melee units are attacked by ranged one and we are blocked by walls
 					// TODO check that the attacker is from behind the wall
 					continue;
 				}
 				else if (m.isSiegeUnit(attacker))
 				{	// if our unit is attacked by a siege unit, we'll send some melee units to help it.
 					let collec = this.unitCollection.filter(API3.Filters.byClass("Melee")).filterNearest(ourUnit.position(), 5);
 					for (let ent of collec.values())
 					{
 						ent.attack(attacker.id(), m.allowCapture(gameState, ent, attacker));
 						ent.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
 					}
 				}
 				else
 				{	// if units are attacked, abandon their target (if it was a structure or a support) and retaliate
 					// also if our unit is attacking a range unit and the attacker is a melee unit, retaliate
 					let orderData = ourUnit.unitAIOrderData();
 					if (orderData && orderData.length && orderData[0].target)
 					{
 						if (orderData[0].target === attacker.id())
 							continue;
 						let target = gameState.getEntityById(orderData[0].target);
 						if (target && !target.hasClass("Structure") && !target.hasClass("Support"))
 						{
 							if (!target.hasClass("Ranged") || !attacker.hasClass("Melee"))
 								continue;
 						}
 					}
 					ourUnit.attack(attacker.id(), m.allowCapture(gameState, ourUnit, attacker));
 					ourUnit.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
 				}
 			}
 		}
 
 		let enemyUnits = gameState.getEnemyUnits(this.targetPlayer);
 		let enemyStructures = gameState.getEnemyStructures(this.targetPlayer);
 
 		// Count the number of times an enemy is targeted, to prevent all units to follow the same target
 		let unitTargets = {};
 		for (let ent of this.unitCollection.values())
 		{
 			if (ent.hasClass("Ship"))	// TODO What to do with ships
 				continue;
 			let orderData = ent.unitAIOrderData();
 			if (!orderData || !orderData.length || !orderData[0].target)
 				continue;
 			let targetId = orderData[0].target;
 			let target = gameState.getEntityById(targetId);
 			if (!target || target.hasClass("Structure"))
 				continue;
 			if (!(targetId in unitTargets))
 			{
 				if (m.isSiegeUnit(target) || target.hasClass("Hero"))
 					unitTargets[targetId] = -8;
 				else if (target.hasClass("Champion") || target.hasClass("Ship"))
 					unitTargets[targetId] = -5;
 				else
 					unitTargets[targetId] = -3;
 			}
 			++unitTargets[targetId];
 		}
 		let veto = {};
 		for (let target in unitTargets)
 			if (unitTargets[target] > 0)
 				veto[target] = true;
 
 		let targetClassesUnit;
 		let targetClassesSiege;
 		if (this.type === "Rush")
 			targetClassesUnit = {"attack": ["Unit", "Structure"], "avoid": ["Palisade", "StoneWall", "Tower", "Fortress"], "vetoEntities": veto};
 		else
 		{
 			if (this.target.hasClass("Fortress"))
 				targetClassesUnit = {"attack": ["Unit", "Structure"], "avoid": ["Palisade", "StoneWall"], "vetoEntities": veto};
 			else if (this.target.hasClass("Palisade") || this.target.hasClass("StoneWall"))
 				targetClassesUnit = {"attack": ["Unit", "Structure"], "avoid": ["Fortress"], "vetoEntities": veto};
 			else
 				targetClassesUnit = {"attack": ["Unit", "Structure"], "avoid": ["Palisade", "StoneWall", "Fortress"], "vetoEntities": veto};
 		}
 		if (this.target.hasClass("Structure"))
 			targetClassesSiege = {"attack": ["Structure"], "avoid": [], "vetoEntities": veto};
 		else
 			targetClassesSiege = {"attack": ["Unit", "Structure"], "avoid": [], "vetoEntities": veto};
 
 		// do not loose time destroying buildings which do not help enemy's defense and can be easily captured later
 		if (this.target.hasDefensiveFire())
 		{
 			targetClassesUnit.avoid = targetClassesUnit.avoid.concat("House", "Storehouse", "Farmstead", "Field", "Blacksmith");
 			targetClassesSiege.avoid = targetClassesSiege.avoid.concat("House", "Storehouse", "Farmstead", "Field", "Blacksmith");
 		}
 
 		if (this.unitCollUpdateArray === undefined || !this.unitCollUpdateArray.length)
 			this.unitCollUpdateArray = this.unitCollection.toIdArray();
 
 		// Let's check a few units each time we update (currently 10) except when attack starts
 		let lgth = this.unitCollUpdateArray.length < 15 || this.startingAttack ? this.unitCollUpdateArray.length : 10;
 		for (let check = 0; check < lgth; check++)
 		{
 			let ent = gameState.getEntityById(this.unitCollUpdateArray[check]);
 			if (!ent || !ent.position())
 				continue;
 
 			let targetId;
 			let orderData = ent.unitAIOrderData();
 			if (orderData && orderData.length && orderData[0].target)
 				targetId = orderData[0].target;
 
 			// update the order if needed
 			let needsUpdate = false;
 			let maybeUpdate = false;
 			let siegeUnit = m.isSiegeUnit(ent);
 			if (ent.isIdle())
 				needsUpdate = true;
 			else if (siegeUnit && targetId)
 			{
 				let target = gameState.getEntityById(targetId);
 				if (!target || gameState.isPlayerAlly(target.owner()))
 					needsUpdate = true;
 				else if (unitTargets[targetId] && unitTargets[targetId] > 0)
 				{
 					needsUpdate = true;
 					--unitTargets[targetId];
 				}
 				else if (!target.hasClass("Structure"))
 					maybeUpdate = true;
 			}
 			else if (targetId)
 			{
 				let target = gameState.getEntityById(targetId);
 				if (!target || gameState.isPlayerAlly(target.owner()))
 					needsUpdate = true;
 				else if (unitTargets[targetId] && unitTargets[targetId] > 0)
 				{
 					needsUpdate = true;
 					--unitTargets[targetId];
 				}
 				else if (target.hasClass("Ship") && !ent.hasClass("Ship"))
 					maybeUpdate = true;
 				else if (!ent.hasClass("Cavalry") && !ent.hasClass("Ranged") &&
 					 target.hasClass("FemaleCitizen") && target.unitAIState().split(".")[1] == "FLEEING")
 					maybeUpdate = true;
 			}
 
 			// don't update too soon if not necessary
 			if (!needsUpdate)
 			{
 				if (!maybeUpdate)
 					continue;
 				let deltat = ent.unitAIState() === "INDIVIDUAL.COMBAT.APPROACHING" ? 10 : 5;
 				let lastAttackPlanUpdateTime = ent.getMetadata(PlayerID, "lastAttackPlanUpdateTime");
 				if (lastAttackPlanUpdateTime && time - lastAttackPlanUpdateTime < deltat)
 					continue;
 			}
 			ent.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
 			let range = 60;
 			let attackTypes = ent.attackTypes();
 			if (this.isBlocked)
 			{
 				if (attackTypes && attackTypes.indexOf("Ranged") !== -1)
 					range = ent.attackRange("Ranged").max;
 				else if (attackTypes && attackTypes.indexOf("Melee") !== -1)
 					range = ent.attackRange("Melee").max;
 				else
 					range = 10;
 			}
 			else if (attackTypes && attackTypes.indexOf("Ranged") !== -1)
 				range = 30 + ent.attackRange("Ranged").max;
 			else if (ent.hasClass("Cavalry"))
 				range += 30;
 			range = range * range;
 			let entIndex = gameState.ai.accessibility.getAccessValue(ent.position());
 			// Checking for gates if we're a siege unit.
 			if (siegeUnit)
 			{
 				let mStruct = enemyStructures.filter(function (enemy) {
 					if (!enemy.position() || (enemy.hasClass("StoneWall") && !ent.canAttackClass("StoneWall")))
 						return false;
 					if (API3.SquareVectorDistance(enemy.position(), ent.position()) > range)
 						return false;
 					if (enemy.foundationProgress() === 0)
 						return false;
 					if (gameState.ai.accessibility.getAccessValue(enemy.position()) !== entIndex)
 						return false;
 					return true;
 				}).toEntityArray();
 				if (mStruct.length)
 				{
 					mStruct.sort(function (structa, structb)
 					{
 						let vala = structa.costSum();
 						if (structa.hasClass("Gates") && ent.canAttackClass("StoneWall"))
 							vala += 10000;
 						else if (structa.hasDefensiveFire())
 							vala += 1000;
 						else if (structa.hasClass("ConquestCritical"))
 							vala += 200;
 						let valb = structb.costSum();
 						if (structb.hasClass("Gates") && ent.canAttackClass("StoneWall"))
 							valb += 10000;
 						else if (structb.hasDefensiveFire())
 							valb += 1000;
 						else if (structb.hasClass("ConquestCritical"))
 							valb += 200;
 						return valb - vala;
 					});
 					if (mStruct[0].hasClass("Gates"))
 						ent.attack(mStruct[0].id(), m.allowCapture(gameState, ent, mStruct[0]));
 					else
 					{
 						let rand = randIntExclusive(0, mStruct.length * 0.2);
 						ent.attack(mStruct[rand].id(), m.allowCapture(gameState, ent, mStruct[rand]));
 					}
 				}
 				else
 				{
 					if (!ent.hasClass("Ranged"))
 					{
 						let targetClasses = {"attack": targetClassesSiege.attack, "avoid": targetClassesSiege.avoid.concat("Ship"), "vetoEntities": veto};
 						ent.attackMove(this.targetPos[0], this.targetPos[1], targetClasses);
 					}
 					else
 						ent.attackMove(this.targetPos[0], this.targetPos[1], targetClassesSiege);
 				}
 			}
 			else
 			{
 				let nearby = !ent.hasClass("Cavalry") && !ent.hasClass("Ranged");
 				let mUnit = enemyUnits.filter(function (enemy) {
 					if (!enemy.position())
 						return false;
 					if (enemy.hasClass("Animal"))
 						return false;
 					if (nearby && enemy.hasClass("FemaleCitizen") && enemy.unitAIState().split(".")[1] == "FLEEING")
 						return false;
 					let dist = API3.SquareVectorDistance(enemy.position(), ent.position());
 					if (dist > range)
 						return false;
 					if (gameState.ai.accessibility.getAccessValue(enemy.position()) !== entIndex)
 						return false;
 					// if already too much units targeting this enemy, let's continue towards our main target
 					if (veto[enemy.id()] && API3.SquareVectorDistance(self.targetPos, ent.position()) > 2500)
 						return false;
 					enemy.setMetadata(PlayerID, "distance", Math.sqrt(dist));
 					return true;
 				}).toEntityArray();
 				if (mUnit.length !== 0)
 				{
 					mUnit.sort(function (unitA,unitB) {
 						let vala = unitA.hasClass("Support") ? 50 : 0;
 						if (ent.countersClasses(unitA.classes()))
 							vala += 100;
 						let valb = unitB.hasClass("Support") ? 50 : 0;
 						if (ent.countersClasses(unitB.classes()))
 							valb += 100;
 						let distA = unitA.getMetadata(PlayerID, "distance");
 						let distB = unitB.getMetadata(PlayerID, "distance");
 						if( distA && distB)
 						{
 							vala -= distA;
 							valb -= distB;
 						}
 						if (veto[unitA.id()])
 							vala -= 20000;
 						if (veto[unitB.id()])
 							valb -= 20000;
 						return valb - vala;
 					});
 					let rand = randIntExclusive(0, mUnit.length * 0.1);
 					ent.attack(mUnit[rand].id(), m.allowCapture(gameState, ent, mUnit[rand]));
 				}
 				else if (this.isBlocked)
 					ent.attack(this.target.id(), false);
 				else if (API3.SquareVectorDistance(this.targetPos, ent.position()) > 2500 )
 				{
 					let targetClasses = targetClassesUnit;
 					if (maybeUpdate && ent.unitAIState() === "INDIVIDUAL.COMBAT.APPROACHING")	// we may be blocked by walls, attack everything
 					{
 						if (!ent.hasClass("Ranged") && !ent.hasClass("Ship"))
 							targetClasses = {"attack": ["Unit", "Structure"], "avoid": ["Ship"], "vetoEntities": veto};
 						else
 							targetClasses = {"attack": ["Unit", "Structure"], "vetoEntities": veto};
 					}
 					else if (!ent.hasClass("Ranged") && !ent.hasClass("Ship"))
 						targetClasses = {"attack": targetClassesUnit.attack, "avoid": targetClassesUnit.avoid.concat("Ship"), "vetoEntities": veto};
 					ent.attackMove(this.targetPos[0], this.targetPos[1], targetClasses);
 				}
 				else
 				{
 					let mStruct = enemyStructures.filter(function (enemy) {
 						if (self.isBlocked && enemy.id() !== this.target.id())
 							return false;
 						if (!enemy.position() || (enemy.hasClass("StoneWall") && !ent.canAttackClass("StoneWall")))
 							return false;
 						if (API3.SquareVectorDistance(enemy.position(), ent.position()) > range)
 							return false;
 						if (gameState.ai.accessibility.getAccessValue(enemy.position()) !== entIndex)
 							return false;
 						return true;
 					}).toEntityArray();
 					if (mStruct.length !== 0)
 					{
 						mStruct.sort(function (structa,structb) {
 							let vala = structa.costSum();
 							if (structa.hasClass("Gates") && ent.canAttackClass("StoneWall"))
 								vala += 10000;
 							else if (structa.hasClass("ConquestCritical"))
 								vala += 100;
 							let valb = structb.costSum();
 							if (structb.hasClass("Gates") && ent.canAttackClass("StoneWall"))
 								valb += 10000;
 							else if (structb.hasClass("ConquestCritical"))
 								valb += 100;
 							return valb - vala;
 						});
 						if (mStruct[0].hasClass("Gates"))
 							ent.attack(mStruct[0].id(), false);
 						else
 						{
 							let rand = randIntExclusive(0, mStruct.length * 0.2);
 							ent.attack(mStruct[rand].id(), m.allowCapture(gameState, ent, mStruct[rand]));
 						}
 					}
 					else if (needsUpdate)  // really nothing   let's try to help our nearest unit
 					{
 						let distmin = Math.min();
 						let attacker;
 						this.unitCollection.forEach( function (unit) {
 							if (!unit.position())
 								return;
 							if (unit.unitAIState().split(".")[1] !== "COMBAT" || !unit.unitAIOrderData().length ||
 								!unit.unitAIOrderData()[0].target)
 								return;
 							if (!gameState.getEntityById(unit.unitAIOrderData()[0].target))
 								return;
 							let dist = API3.SquareVectorDistance(unit.position(), ent.position());
 							if (dist > distmin)
 								return;
 							distmin = dist;
 							attacker = gameState.getEntityById(unit.unitAIOrderData()[0].target);
 						});
 						if (attacker)
 							ent.attack(attacker.id(), m.allowCapture(gameState, ent, attacker));
 					}
 				}
 			}
 		}
 		this.unitCollUpdateArray.splice(0, lgth);
 		this.startingAttack = false;
 
 		// check if this enemy has resigned
 		if (this.target && this.target.owner() === 0 && this.targetPlayer !== 0)
 			this.target = undefined;
 	}
 	this.lastPosition = this.position;
 	Engine.ProfileStop();
 
 	return this.unitCollection.length;
 };
 
 m.AttackPlan.prototype.UpdateTransporting = function(gameState, events)
 {
 	let done = true;
 	for (let ent of this.unitCollection.values())
 	{
 		if (this.Config.debug > 1 && ent.getMetadata(PlayerID, "transport") !== undefined)
 			Engine.PostCommand(PlayerID,{"type": "set-shading-color", "entities": [ent.id()], "rgb": [2,2,0]});
 		else if (this.Config.debug > 1)
 			Engine.PostCommand(PlayerID,{"type": "set-shading-color", "entities": [ent.id()], "rgb": [1,1,1]});
 		if (!done)
 			continue;
 		if (ent.getMetadata(PlayerID, "transport") !== undefined)
 			done = false;
 	}
 
 	if (done)
 	{
 		this.state = "arrived";
 		return;
 	}
 
 	// if we are attacked while waiting the rest of the army, retaliate
 	for (let evt of events.Attacked)
 	{
 		if (!this.unitCollection.hasEntId(evt.target))
 			continue;
 		let attacker = gameState.getEntityById(evt.attacker);
 		if (!attacker || !gameState.getEntityById(evt.target))
 			continue;
 		for (let ent of this.unitCollection.values())
 		{
 			if (ent.getMetadata(PlayerID, "transport") !== undefined)
 				continue;
 			if (!ent.isIdle())
 				continue;
 			ent.attack(attacker.id(), m.allowCapture(gameState, ent, attacker));
 		}
 		break;
 	}
 };
 
 m.AttackPlan.prototype.UpdateWalking = function(gameState, events)
 {
 	// we're marching towards the target
 	// Let's check if any of our unit has been attacked.
 	// In case yes, we'll determine if we're simply off against an enemy army, a lone unit/building
 	// or if we reached the enemy base. Different plans may react differently.
 	let attackedNB = 0;
 	let attackedUnitNB = 0;
 	for (let evt of events.Attacked)
 	{
 		if (!this.unitCollection.hasEntId(evt.target))
 			continue;
 		let attacker = gameState.getEntityById(evt.attacker);
 		if (attacker && (attacker.owner() !== 0 || this.targetPlayer === 0))
 		{
 			attackedNB++;
 			if (attacker.hasClass("Unit"))
 				attackedUnitNB++;
 		}
 	}
 	// Are we arrived at destination ?
 	if (attackedNB > 1 && (attackedUnitNB || this.hasSiegeUnits()))
 	{
 		if (gameState.ai.HQ.territoryMap.getOwner(this.position) === this.targetPlayer || attackedNB > 3)
 		{
 			this.state = "arrived";
 			return true;
 		}
 	}
 
 	// basically haven't moved an inch: very likely stuck)
 	if (API3.SquareVectorDistance(this.position, this.position5TurnsAgo) < 10 && this.path.length > 0 && gameState.ai.playedTurn % 5 === 0)
 	{
 		// check for stuck siege units
 		let farthest = 0;
 		let farthestEnt;
 		for (let ent of this.unitCollection.filter(API3.Filters.byClass("Siege")).values())
 		{
 			let dist = API3.SquareVectorDistance(ent.position(), this.position);
 			if (dist < farthest)
 				continue;
 			farthest = dist;
 			farthestEnt = ent;
 		}
 		if (farthestEnt)
 			farthestEnt.destroy();
 	}
 	if (gameState.ai.playedTurn % 5 === 0)
 		this.position5TurnsAgo = this.position;
 
 	if (this.lastPosition && API3.SquareVectorDistance(this.position, this.lastPosition) < 20 && this.path.length > 0)
 	{
 		if (!this.path[0][0] || !this.path[0][1])
 			API3.warn("Start: Problem with path " + uneval(this.path));
 		// We're stuck, presumably. Check if there are no walls just close to us. If so, we're arrived, and we're gonna tear down some serious stone.
 		let nexttoWalls = false;
 		for (let ent of gameState.getEnemyStructures().filter(API3.Filters.byClass("StoneWall")).values())
 		{
 			if (!nexttoWalls && API3.SquareVectorDistance(this.position, ent.position()) < 800)
 				nexttoWalls = true;
 		}
 		// there are walls but we can attack
 		if (nexttoWalls && this.unitCollection.filter(API3.Filters.byCanAttackClass("StoneWall")).hasEntities())
 		{
 			if (this.Config.debug > 1)
 				API3.warn("Attack Plan " + this.type + " " + this.name + " has met walls and is not happy.");
 			this.state = "arrived";
 			return true;
 		}
 		else if (nexttoWalls)	// abort plan
 		{
 			if (this.Config.debug > 1)
 				API3.warn("Attack Plan " + this.type + " " + this.name + " has met walls and gives up.");
 			return false;
 		}
 
 		//this.unitCollection.move(this.path[0][0], this.path[0][1]);
 		this.unitCollection.moveIndiv(this.path[0][0], this.path[0][1]);
 	}
 
 	// check if our units are close enough from the next waypoint.
 	if (API3.SquareVectorDistance(this.position, this.targetPos) < 10000)
 	{
 		if (this.Config.debug > 1)
 			API3.warn("Attack Plan " + this.type + " " + this.name + " has arrived to destination.");
 		this.state = "arrived";
 		return true;
 	}
 	else if (this.path.length && API3.SquareVectorDistance(this.position, this.path[0]) < 1600)
 	{
 		this.path.shift();
 		if (this.path.length)
 			this.unitCollection.move(this.path[0][0], this.path[0][1]);
 		else
 		{
 			if (this.Config.debug > 1)
 				API3.warn("Attack Plan " + this.type + " " + this.name + " has arrived to destination.");
 			this.state = "arrived";
 			return true;
 		}
 	}
 
 	return true;
 };
 
 m.AttackPlan.prototype.UpdateTarget = function(gameState, events)
 {
 	// First update the target position in case it's a unit (and check if it has garrisoned)
 	if (this.target && this.target.hasClass("Unit"))
 	{
 		this.targetPos = this.target.position();
 		if (!this.targetPos)
 		{
 			let holder = m.getHolder(gameState, this.target);
 			if (holder && gameState.isPlayerEnemy(holder.owner()))
 			{
 				this.target = holder;
 				this.targetPos = holder.position();
 			}
 			else
 				this.target = undefined;
 		}
 	}
 	// Then update the target if needed:
 	if (this.targetPlayer === undefined || !gameState.isPlayerEnemy(this.targetPlayer))
 	{
 		this.targetPlayer = gameState.ai.HQ.attackManager.getEnemyPlayer(gameState, this);
 		if (this.targetPlayer === undefined)
 			return false;
 
 		if (this.target && this.target.owner() !== this.targetPlayer)
 			this.target = undefined;
 	}
 	if (this.target && this.target.owner() === 0 && this.targetPlayer !== 0)  // this enemy has resigned
 		this.target = undefined;
 
 	if (!this.target || !gameState.getEntityById(this.target.id()))
 	{
 		if (this.Config.debug > 1)
 			API3.warn("Seems like our target has been destroyed. Switching.");
 		this.target = this.getNearestTarget(gameState, this.position, true);
 		if (!this.target)
 		{
+			if (this.uniqueTargetId)
+				return false;
+
 			// Check if we could help any current attack
 			let attackManager = gameState.ai.HQ.attackManager;
 			let accessIndex = gameState.ai.accessibility.getAccessValue(this.position);
 			for (let attackType in attackManager.startedAttacks)
 			{
 				for (let attack of attackManager.startedAttacks[attackType])
 				{
 					if (attack.name === this.name)
 						continue;
 					if (!attack.target || !gameState.getEntityById(attack.target.id()))
 						continue;
 					if (accessIndex !== gameState.ai.accessibility.getAccessValue(attack.targetPos))
 						continue;
 					if (attack.target.owner() === 0 && attack.targetPlayer !== 0)	// looks like it has resigned
 						continue;
 					if (!gameState.isPlayerEnemy(attack.targetPlayer))
 						continue;
 					this.target = attack.target;
 					this.targetPlayer = attack.targetPlayer;
 					this.targetPos = this.target.position();
 					return true;
 				}
 			}
 
 			// If not, let's look for another enemy
 			if (!this.target)
 			{
 				this.targetPlayer = gameState.ai.HQ.attackManager.getEnemyPlayer(gameState, this);
 				if (this.targetPlayer !== undefined)
 					this.target = this.getNearestTarget(gameState, this.position, true);
 				if (!this.target)
 				{
 					if (this.Config.debug > 1)
 						API3.warn("No new target found. Remaining units " + this.unitCollection.length);
 					return false;
 				}
 			}
 			if (this.Config.debug > 1)
 				API3.warn("We will help one of our other attacks");
 		}
 		this.targetPos = this.target.position();
 	}
 	return true;
 };
 
 /** reset any units */
 m.AttackPlan.prototype.Abort = function(gameState)
 {
 	this.unitCollection.unregister();
 	if (this.unitCollection.hasEntities())
 	{
 		// If the attack was started, and we are on the same land as the rallyPoint, go back there
 		let rallyPoint = this.rallyPoint;
 		let withdrawal = this.isStarted() && !this.overseas;
 		for (let ent of this.unitCollection.values())
 		{
 			if (ent.getMetadata(PlayerID, "role") === "attack")
 				ent.stopMoving();
 			if (withdrawal)
 				ent.move(rallyPoint[0], rallyPoint[1]);
 			this.removeUnit(ent);
 		}
 	}
 
 	for (let unitCat in this.unitStat)
 		this.unit[unitCat].unregister();
 
 	gameState.ai.queueManager.removeQueue("plan_" + this.name);
 	gameState.ai.queueManager.removeQueue("plan_" + this.name + "_champ");
 	gameState.ai.queueManager.removeQueue("plan_" + this.name + "_siege");
 };
 
 m.AttackPlan.prototype.removeUnit = function(ent, update)
 {
 	if (ent.hasClass("CitizenSoldier") && ent.getMetadata(PlayerID, "role") !== "worker")
 	{
 		ent.setMetadata(PlayerID, "role", "worker");
 		ent.setMetadata(PlayerID, "subrole", undefined);
 	}
 	ent.setMetadata(PlayerID, "plan", -1);
 	if (update)
 		this.unitCollection.updateEnt(ent);
 };
 
 m.AttackPlan.prototype.checkEvents = function(gameState, events)
 {
 	for (let evt of events.EntityRenamed)
 	{
 		if (!this.target || this.target.id() != evt.entity)
 			continue;
 		this.target = gameState.getEntityById(evt.newentity);
 		if (this.target)
 			this.targetPos = this.target.position();
 	}
 
 	for (let evt of events.OwnershipChanged)	// capture event
 		if (this.target && this.target.id() == evt.entity && gameState.isPlayerAlly(evt.to))
 			this.target = undefined;
 
 	for (let evt of events.PlayerDefeated)
 	{
 		if (this.targetPlayer !== evt.playerId)
 			continue;
 		this.targetPlayer = gameState.ai.HQ.attackManager.getEnemyPlayer(gameState, this);
 		this.target = undefined;
 	}
 
 	if (!this.overseas || this.state !== "unexecuted")
 		return;
 	// let's check if an enemy has built a structure at our access
 	for (let evt of events.Create)
 	{
 		let ent = gameState.getEntityById(evt.entity);
 		if (!ent || !ent.position() || !ent.hasClass("Structure"))
 			continue;
 		if (!gameState.isPlayerEnemy(ent.owner()))
 			continue;
 		let access = gameState.ai.accessibility.getAccessValue(ent.position());
 		for (let base of gameState.ai.HQ.baseManagers)
 		{
 			if (!base.anchor || !base.anchor.position())
 				continue;
 			if (base.accessIndex !== access)
 				continue;
 			this.overseas = 0;
 			this.rallyPoint = base.anchor.position();
 		}
 	}
 };
 
 m.AttackPlan.prototype.waitingForTransport = function()
 {
 	for (let ent of this.unitCollection.values())
 		if (ent.getMetadata(PlayerID, "transport") !== undefined)
 			return true;
 	return false;
 };
 
 m.AttackPlan.prototype.hasSiegeUnits = function()
 {
 	for (let ent of this.unitCollection.values())
 		if (m.isSiegeUnit(ent))
 			return true;
 	return false;
 };
 
 m.AttackPlan.prototype.hasForceOrder = function(data, value)
 {
 	for (let ent of this.unitCollection.values())
 	{
 		if (data && +ent.getMetadata(PlayerID, data) !== value)
 			continue;
 		let orders = ent.unitAIOrderData();
 		for (let order of orders)
 			if (order.force)
 				return true;
 	}
 	return false;
 };
 
 m.AttackPlan.prototype.debugAttack = function()
 {
 	API3.warn("---------- attack " + this.name);
 	for (let unitCat in this.unitStat)
 	{
 		let Unit = this.unitStat[unitCat];
 		API3.warn(unitCat + " num=" + this.unit[unitCat].length + " min=" + Unit.minSize + " need=" + Unit.targetSize);
 	}
 	API3.warn("------------------------------");
 };
 
 m.AttackPlan.prototype.Serialize = function()
 {
 	let properties = {
 		"name": this.name,
 		"type": this.type,
 		"state": this.state,
 		"rallyPoint": this.rallyPoint,
 		"overseas": this.overseas,
 		"paused": this.paused,
 		"maxCompletingTime": this.maxCompletingTime,
 		"neededShips": this.neededShips,
 		"unitStat": this.unitStat,
 		"position5TurnsAgo": this.position5TurnsAgo,
 		"lastPosition": this.lastPosition,
 		"position": this.position,
 		"isBlocked": this.isBlocked,
 		"targetPlayer": this.targetPlayer,
 		"target": this.target !== undefined ? this.target.id() : undefined,
 		"targetPos": this.targetPos,
+		"uniqueTargetId": this.uniqueTargetId,
 		"path": this.path
 	};
 
 	return { "properties": properties};
 };
 
 m.AttackPlan.prototype.Deserialize = function(gameState, data)
 {
 	for (let key in data.properties)
 		this[key] = data.properties[key];
 
 	if (this.target)
 		this.target = gameState.getEntityById(this.target);
 
 	this.failed = undefined;
 };
 
 return m;
 }(PETRA);
Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/defenseManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/defenseManager.js	(revision 19755)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/defenseManager.js	(revision 19756)
@@ -1,760 +1,792 @@
 var PETRA = function(m)
 {
 
 m.DefenseManager = function(Config)
 {
 	this.armies = [];	// array of "army" Objects
 	this.Config = Config;
 	this.targetList = [];
 	this.armyMergeSize = this.Config.Defense.armyMergeSize;
 	this.attackingArmies = {};	// stats on how many enemies are currently attacking our allies
 	this.attackingUnits = {};
 	this.attackedAllies = {};
 };
 
 m.DefenseManager.prototype.update = function(gameState, events)
 {
 	Engine.ProfileStart("Defense Manager");
 
 	this.territoryMap = gameState.ai.HQ.territoryMap;
 
 	this.checkEvents(gameState, events);
 
 	// Check if our potential targets are still valid
 	for (let i = 0; i < this.targetList.length; ++i)
 	{
 		let target = gameState.getEntityById(this.targetList[i]);
 		if (!target || !target.position() || !gameState.isPlayerEnemy(target.owner()))
 			this.targetList.splice(i--, 1);
 	}
 
 	// Count the number of enemies attacking our allies in the previous turn
 	// We'll be more cooperative if several enemies are attacking him simultaneously
 	this.attackedAllies = {};
 	let attackingArmies = clone(this.attackingArmies);
 	for (let enemy in this.attackingUnits)
 	{
 		if (!this.attackingUnits[enemy])
 			continue;
 		for (let ally in this.attackingUnits[enemy])
 		{
 			if (this.attackingUnits[enemy][ally] < 8)
 				continue;
 			if (attackingArmies[enemy] === undefined)
 				attackingArmies[enemy] = {};
 			if (attackingArmies[enemy][ally] === undefined)
 				attackingArmies[enemy][ally] = 0;
 			attackingArmies[enemy][ally] += 1;
 		}
 	}
 	for (let enemy in attackingArmies)
 	{
 		for (let ally in attackingArmies[enemy])
 		{
 			if (this.attackedAllies[ally] === undefined)
 				this.attackedAllies[ally] = 0;
 			this.attackedAllies[ally] += 1;
 		}
 	}
 	this.checkEnemyArmies(gameState);
 	this.checkEnemyUnits(gameState);
 	this.assignDefenders(gameState);
 
 	Engine.ProfileStop();
 };
 
 m.DefenseManager.prototype.makeIntoArmy = function(gameState, entityID)
 {
 	// Try to add it to an existing army.
 	for (let army of this.armies)
 		if (!army.isCapturing(gameState) && army.addFoe(gameState, entityID))
 			return;	// over
 
 	// Create a new army for it.
 	let army = new m.DefenseArmy(gameState, [], [entityID]);
 	this.armies.push(army);
 };
 
 m.DefenseManager.prototype.getArmy = function(partOfArmy)
 {
 	// Find the army corresponding to this ID partOfArmy
 	for (let army of this.armies)
 		if (army.ID === partOfArmy)
 			return army;
 
 	return undefined;
 };
 
 m.DefenseManager.prototype.isDangerous = function(gameState, entity)
 {
 	if (!entity.position())
 		return false;
 
 	let territoryOwner = this.territoryMap.getOwner(entity.position());
 	if (territoryOwner !== 0 && !gameState.isPlayerAlly(territoryOwner))
 		return false;
 	// check if the entity is trying to build a new base near our buildings,
 	// and if yes, add this base in our target list
 	if (entity.unitAIState() && entity.unitAIState() == "INDIVIDUAL.REPAIR.REPAIRING")
 	{
 		let targetId = entity.unitAIOrderData()[0].target;
 		if (this.targetList.indexOf(targetId) !== -1)
 			return true;
 		let target = gameState.getEntityById(targetId);
 		if (target)
 		{
 			let isTargetEnemy = gameState.isPlayerEnemy(target.owner());
 			if (isTargetEnemy && territoryOwner === PlayerID)
 			{
 				if (target.hasClass("Structure"))
 					this.targetList.push(targetId);
 				return true;
 			}
 			else if (isTargetEnemy && target.hasClass("CivCentre"))
 			{
 				let myBuildings = gameState.getOwnStructures();
 				for (let building of myBuildings.values())
 				{
 					if (API3.SquareVectorDistance(building.position(), entity.position()) > 30000)
 						continue;
 					this.targetList.push(targetId);
 					return true;
 				}
 			}
 		}
 	}
 
 	if (entity.attackTypes() === undefined || entity.hasClass("Support"))
 		return false;
 	let dist2Min = 6000;
 	// TODO the 30 is to take roughly into account the structure size in following checks. Can be improved
 	if (entity.attackTypes().indexOf("Ranged") !== -1)
 		dist2Min = (entity.attackRange("Ranged").max + 30) * (entity.attackRange("Ranged").max + 30);
 
 	for (let targetId of this.targetList)
 	{
 		let target = gameState.getEntityById(targetId);
 		if (!target || !target.position())   // the enemy base is either destroyed or built
 			continue;
 		if (API3.SquareVectorDistance(target.position(), entity.position()) < dist2Min)
 			return true;
 	}
 
 	let ccEnts = gameState.updatingGlobalCollection("allCCs", API3.Filters.byClass("CivCentre"));
 	for (let cc of ccEnts.values())
 	{
 		if (!gameState.isEntityExclusiveAlly(cc) || cc.foundationProgress() === 0)
 			continue;
 		let cooperation = this.GetCooperationLevel(cc);
 		if (cooperation < 0.6 && cc.foundationProgress() !== undefined)
 			continue;
 		if (cooperation < 0.3)
 			continue;
 		if (API3.SquareVectorDistance(cc.position(), entity.position()) < dist2Min)
 			return true;
 	}
 
 	let myBuildings = gameState.getOwnStructures();
 	for (let building of myBuildings.values())
 	{
 		if (building.foundationProgress() === 0)
 			continue;
 		if (API3.SquareVectorDistance(building.position(), entity.position()) < dist2Min)
 			return true;
 	}
 
 	// Update the number of enemies attacking this ally
 	if (gameState.isPlayerMutualAlly(territoryOwner))
 	{
 		let enemy = entity.owner();
 		if (this.attackingUnits[enemy] === undefined)
 			this.attackingUnits[enemy] = {};
 		if (this.attackingUnits[enemy][territoryOwner] === undefined)
 			this.attackingUnits[enemy][territoryOwner] = 0;
 		this.attackingUnits[enemy][territoryOwner] += 1;
 	}
 
 	return false;
 };
 
 m.DefenseManager.prototype.checkEnemyUnits = function(gameState)
 {
 	const nbPlayers = gameState.sharedScript.playersData.length;
 	let i = gameState.ai.playedTurn % nbPlayers;
  	this.attackingUnits[i] = undefined;
 
 	if (i === PlayerID)
 	{
 		if (!this.armies.length)
 		{
 			// check if we can recover capture points from any of our notdecaying structures
 			for (let ent of gameState.getOwnStructures().values())
 			{
 				if (ent.decaying())
 					continue;
 				let capture = ent.capturePoints();
 				if (capture === undefined)
 					continue;
 				let lost = 0;
 				for (let j = 0; j < capture.length; ++j)
 					if (gameState.isPlayerEnemy(j))
 						lost += capture[j];
 				if (lost < Math.ceil(0.25 * capture[i]))
 					continue;
 				this.makeIntoArmy(gameState, ent.id());
 				break;
 			}
 		}
 		return;
 	}
 	else if (!gameState.isPlayerEnemy(i))
 		return;
 
 	// loop through enemy units
 	for (let ent of gameState.getEnemyUnits(i).values())
 	{
 		if (ent.getMetadata(PlayerID, "PartOfArmy") !== undefined)
 			continue;
 
 		// keep animals attacking us or our allies
 		if (ent.hasClass("Animal"))
 		{
 			if (!ent.unitAIState() || ent.unitAIState().split(".")[1] !== "COMBAT")
 				continue;
 			let orders = ent.unitAIOrderData();
 			if (!orders || !orders.length || !orders[0].target)
 				continue;
 			let target = gameState.getEntityById(orders[0].target);
 			if (!target || !gameState.isPlayerAlly(target.owner()))
 				continue;
 		}
 
 		// TODO what to do for ships ?
 		if (ent.hasClass("Ship") || ent.hasClass("Trader"))
 			continue;
 
 		// check if unit is dangerous "a priori"
 		if (this.isDangerous(gameState, ent))
 			this.makeIntoArmy(gameState, ent.id());
 	}
 
 	if (i !== 0 || this.armies.length > 1 || gameState.ai.HQ.numActiveBase() === 0)
 		return;
 	// look for possible gaia buildings inside our territory (may happen when enemy resign or after structure decay)
 	// and attack it only if useful (and capturable) or dangereous
 	for (let ent of gameState.getEnemyStructures(i).values())
 	{
 		if (!ent.position() || ent.getMetadata(PlayerID, "PartOfArmy") !== undefined)
 			continue;
 		if (!ent.capturePoints() && !ent.hasDefensiveFire())
 			continue;
 		let owner = this.territoryMap.getOwner(ent.position());
 		if (owner === PlayerID)
 			this.makeIntoArmy(gameState, ent.id());
 	}
 };
 
 m.DefenseManager.prototype.checkEnemyArmies = function(gameState)
 {
 	for (let i = 0; i < this.armies.length; ++i)
 	{
 		let army = this.armies[i];
 		// this returns a list of IDs: the units that broke away from the army for being too far.
 		let breakaways = army.update(gameState);
 		for (let breaker of breakaways)
 			this.makeIntoArmy(gameState, breaker);		// assume dangerosity
 
 		if (army.getState() === 0)
 		{
+			this.switchToAttack(gameState, army);
 			army.clear(gameState);
 			this.armies.splice(i--,1);
 			continue;
 		}
 	}
 	// Check if we can't merge it with another
 	for (let i = 0; i < this.armies.length - 1; ++i)
 	{
 		let army = this.armies[i];
 		if (army.isCapturing(gameState))
 			continue;
 		for (let j = i+1; j < this.armies.length; ++j)
 		{
 			let otherArmy = this.armies[j];
 			if (otherArmy.isCapturing(gameState) ||
 				API3.SquareVectorDistance(army.foePosition, otherArmy.foePosition) > this.armyMergeSize)
 				continue;
 			// no need to clear here.
 			army.merge(gameState, otherArmy);
 			this.armies.splice(j--,1);
 		}
 	}
 
 	if (gameState.ai.playedTurn % 5 !== 0)
 		return;
 	// Check if any army is no more dangerous (possibly because it has defeated us and destroyed our base)
  	this.attackingArmies = {};
 	for (let i = 0; i < this.armies.length; ++i)
 	{
 		let army = this.armies[i];
 		army.recalculatePosition(gameState);
 		let owner = this.territoryMap.getOwner(army.foePosition);
 		if (!gameState.isPlayerEnemy(owner))
 		{
 			if (gameState.isPlayerMutualAlly(owner))
 			{
 				// update the number of enemies attacking this ally
 				for (let id of army.foeEntities)
 				{
 					let ent = gameState.getEntityById(id);
 					if (!ent)
 						continue;
 					let enemy = ent.owner();
 					if (this.attackingArmies[enemy] === undefined)
 						this.attackingArmies[enemy] = {};
 					if (this.attackingArmies[enemy][owner] === undefined)
 						this.attackingArmies[enemy][owner] = 0;
 					this.attackingArmies[enemy][owner] += 1;
 					break;
 				}
 			}
 			continue;
 		}
 		else if (owner !== 0)   // enemy army back in its territory
 		{
 			army.clear(gameState);
 			this.armies.splice(i--,1);
 			continue;
 		}
 
 		// army in neutral territory
 		// TODO check smaller distance with all our buildings instead of only ccs with big distance
 		let stillDangerous = false;
 		let bases = gameState.updatingGlobalCollection("allCCs", API3.Filters.byClass("CivCentre"));
 	 	for (let base of bases.values())
 		{
 			if (!gameState.isEntityAlly(base))
 				continue;
 			let cooperation = this.GetCooperationLevel(base);
 			if (cooperation < 0.3 && !gameState.isEntityOwn(base))
 				continue;
 			if (API3.SquareVectorDistance(base.position(), army.foePosition) > 40000)
 				continue;
 			if(this.Config.debug > 1)
 				API3.warn("army in neutral territory, but still near one of our CC");
 			stillDangerous = true;
 			break;
 		}
 		if (stillDangerous)
 			continue;
 
+		this.switchToAttack(gameState, army);
 		army.clear(gameState);
 		this.armies.splice(i--,1);
 	}
 };
 
 m.DefenseManager.prototype.assignDefenders = function(gameState)
 {
 	if (this.armies.length === 0)
 		return;
 
 	let armiesNeeding = [];
 	// let's add defenders
 	for (let army of this.armies)
 	{
 		let needsDef = army.needsDefenders(gameState);
 		if (needsDef === false)
 			continue;
 
 		// Okay for now needsDef is the total needed strength.
 		// we're dumb so we don't choose if we have a defender shortage.
 		armiesNeeding.push( {"army": army, "need": needsDef} );
 	}
 
 	if (armiesNeeding.length === 0)
 		return;
 
 	// let's get our potential units
 	let potentialDefenders = [];
 	gameState.getOwnUnits().forEach(function(ent) {
 		if (!ent.position())
 			return;
 		if (ent.getMetadata(PlayerID, "plan") === -2 || ent.getMetadata(PlayerID, "plan") === -3)
 			return;
 		if (ent.hasClass("Support") || ent.attackTypes() === undefined)
 			return;
 		if (ent.hasClass("Siege") && !ent.hasClass("Melee"))
 			return;
 		if (ent.hasClass("FishingBoat") || ent.hasClass("Trader"))
 			return;
 		if (ent.getMetadata(PlayerID, "transport") !== undefined || ent.getMetadata(PlayerID, "transporter") !== undefined)
 			return;
 		if (gameState.ai.HQ.gameTypeManager.criticalEnts.has(ent.id()))
 			return;
 		if (ent.getMetadata(PlayerID, "plan") !== undefined && ent.getMetadata(PlayerID, "plan") !== -1)
 		{
 			let subrole = ent.getMetadata(PlayerID, "subrole");
 			if (subrole && (subrole === "completing" || subrole === "walking" || subrole === "attacking"))
 				return;
 		}
 		potentialDefenders.push(ent.id());
 	});
 
 	for (let a = 0; a < armiesNeeding.length; ++a)
 		armiesNeeding[a].army.recalculatePosition(gameState);
 
 	for (let i = 0; i < potentialDefenders.length; ++i)
 	{
 		let ent = gameState.getEntityById(potentialDefenders[i]);
 		if (!ent.position())
 			continue;
 		let aMin;
 		let distMin;
 		for (let a = 0; a < armiesNeeding.length; ++a)
 		{
 			let dist = API3.SquareVectorDistance(ent.position(), armiesNeeding[a].army.foePosition);
 			if (aMin !== undefined && dist > distMin)
 				continue;
 			aMin = a;
 			distMin = dist;
 		}
 
 		// if outside our territory (helping an ally or attacking a cc foundation), keep some troops in backup
 		if (i < 12 && this.territoryMap.getOwner(armiesNeeding[aMin].army.foePosition) !== PlayerID)
 			continue;
 
 		armiesNeeding[aMin].need -= m.getMaxStrength(ent);
 		armiesNeeding[aMin].army.addOwn(gameState, potentialDefenders[i]);
 		armiesNeeding[aMin].army.assignUnit(gameState, potentialDefenders[i]);
 
 		if (armiesNeeding[aMin].need <= 0)
 			armiesNeeding.splice(aMin, 1);
 		if (!armiesNeeding.length)
 			break;
 	}
 
 	if (!armiesNeeding.length)
 		return;
 	// If shortage of defenders, produce infantry garrisoned in nearest civil centre
 	let armiesPos = [];
 	for (let a = 0; a < armiesNeeding.length; ++a)
 		armiesPos.push(armiesNeeding[a].army.foePosition);
 	gameState.ai.HQ.trainEmergencyUnits(gameState, armiesPos);
 };
 
 m.DefenseManager.prototype.abortArmy = function(gameState, army)
 {
 	army.clear(gameState);
 	for (let i = 0; i < this.armies.length; ++i)
 	{
 		if (this.armies[i].ID !== army.ID)
 			continue;
 		this.armies.splice(i, 1);
 		break;
 	}
 };
 
 /**
  * If our defense structures are attacked, garrison soldiers inside when possible
  * and if a support unit is attacked and has less than 55% health, garrison it inside the nearest healing structure
  * and if a ranged siege unit (not used for defense) is attacked, garrison it in the nearest fortress
  * If our hero is attacked in regicide game mode, the gameTypeManager will handle it
  */
 m.DefenseManager.prototype.checkEvents = function(gameState, events)
 {
 	// must be called every turn for all armies
 	for (let army of this.armies)
 		army.checkEvents(gameState, events);
 
 	for (let evt of events.OwnershipChanged)   // capture events
 	{
 		if (gameState.isPlayerMutualAlly(evt.from) && evt.to > 0)
 		{
 			let ent = gameState.getEntityById(evt.entity);
 			if (ent && ent.hasClass("CivCentre")) // one of our cc has been captured
-				gameState.ai.HQ.attackManager.counterAttack(gameState, ent);
+				gameState.ai.HQ.attackManager.switchDefenseToAttack(gameState, ent, { "range": 150 });
 		}
 	}
 
 	for (let evt of events.Attacked)
 	{
 		let target = gameState.getEntityById(evt.target);
 		if (!target || !target.position())
 			continue;
 
 		let attacker = gameState.getEntityById(evt.attacker);
 		if (attacker && gameState.isEntityOwn(attacker) && gameState.isEntityEnemy(target) && !attacker.hasClass("Ship") &&
 		   (!target.hasClass("Structure") || target.attackRange("Ranged")))
 		{
 			// If enemies are in range of one of our defensive structures, garrison it for arrow multiplier
 			// (enemy non-defensive structure are not considered to stay in sync with garrisonManager)
 			if (attacker.position() && attacker.isGarrisonHolder() && attacker.getArrowMultiplier())
 				this.garrisonUnitsInside(gameState, attacker, {"attacker": target});
 		}
 
 		if (!gameState.isEntityOwn(target))
 			continue;
 
 		// If attacked by one of our allies (he must trying to recover capture points), do not react
 		if (attacker && gameState.isEntityAlly(attacker))
 			continue;
 
 		if (target.hasClass("Ship"))    // TODO integrate ships later   need to be sure it is accessible
 			continue;
 
 		// If inside a started attack plan, let the plan deal with this unit
 		let plan = target.getMetadata(PlayerID, "plan");
 		if (plan !== undefined && plan >= 0)
 		{
 			let attack = gameState.ai.HQ.attackManager.getPlan(plan);
 			if (attack && attack.state !== "unexecuted")
 				continue;
 		}
 
 		// Signal this attacker to our defense manager, except if we are in enemy territory
 		// TODO treat ship attack
 		if (attacker && attacker.position() && attacker.getMetadata(PlayerID, "PartOfArmy") === undefined &&
 			!attacker.hasClass("Structure") && !attacker.hasClass("Ship"))
 		{
 			let territoryOwner = this.territoryMap.getOwner(attacker.position());
 			if (territoryOwner === 0 || gameState.isPlayerAlly(territoryOwner))
 				this.makeIntoArmy(gameState, attacker.id());
 		}
 
 		if (target.getMetadata(PlayerID, "PartOfArmy") !== undefined)
 		{
 			let army = this.getArmy(target.getMetadata(PlayerID, "PartOfArmy"));
 			if (army.isCapturing(gameState))
 			{
 				let abort = false;
 				// if one of the units trying to capture a structure is attacked,
 				// abort the army so that the unit can defend itself
 				if (army.ownEntities.indexOf(target.id()) !== -1)
 					abort = true;
 				else if (army.foeEntities[0] === target.id() && target.owner() === PlayerID)
 				{
 					// else we may be trying to regain some capture point from one of our structure
 					abort = true;
 					let capture = target.capturePoints();
 					for (let j = 0; j < capture.length; ++j)
 					{
 						if (!gameState.isPlayerEnemy(j) || capture[j] === 0)
 							continue;
 						abort = false;
 						break;
 					}
 				}
 				if (abort)
 					this.abortArmy(gameState, army);
 			}
 			continue;
 		}
 
 		// try to garrison any attacked support unit if low healthlevel
 		if (target.hasClass("Support") && target.healthLevel() < this.Config.garrisonHealthLevel.medium &&
 			!target.getMetadata(PlayerID, "transport") && plan !== -2 && plan !== -3)
 		{
 			this.garrisonAttackedUnit(gameState, target);
 			continue;
 		}
 
 		// try to garrison any attacked range siege unit
 		if (target.hasClass("Siege") && !target.hasClass("Melee") &&
 			!target.getMetadata(PlayerID, "transport") && plan !== -2 && plan !== -3)
 		{
 			this.garrisonSiegeUnit(gameState, target);
 			continue;
 		}
 
 		if (!attacker || !attacker.position())
 			continue;
 
 		if (target.isGarrisonHolder() && target.getArrowMultiplier())
 			this.garrisonUnitsInside(gameState, target, {"attacker": attacker});
 	}
 };
 
 m.DefenseManager.prototype.garrisonUnitsInside = function(gameState, target, data)
 {
 	let minGarrison = data.min ? data.min : target.garrisonMax();
 	let typeGarrison = data.type ? data.type : "protection";
 	if (gameState.ai.HQ.garrisonManager.numberOfGarrisonedUnits(target) >= minGarrison)
 		return false;
 	if (target.hitpoints() < target.garrisonEjectHealth() * target.maxHitpoints())
 		return false;
 	if (data.attacker)
 	{
 		let attackTypes = target.attackTypes();
 		if (!attackTypes || attackTypes.indexOf("Ranged") === -1)
 			return false;
 		let dist = API3.SquareVectorDistance(data.attacker.position(), target.position());
 		let range = target.attackRange("Ranged").max;
 		if (dist >= range*range)
 			return false;
 	}
 	let index = gameState.ai.accessibility.getAccessValue(target.position());
 	let garrisonManager = gameState.ai.HQ.garrisonManager;
 	let garrisonArrowClasses = target.getGarrisonArrowClasses();
 	let units = gameState.getOwnUnits().filter(ent => MatchesClassList(ent.classes(), garrisonArrowClasses)).filterNearest(target.position());
 	let allowMelee = gameState.ai.HQ.garrisonManager.allowMelee(target);
 	if (allowMelee === undefined)
 	{
 		// Should be kept in sync with garrisonManager to avoid garrisoning-ungarrisoning some units
 		if (data.attacker)
 			allowMelee = data.attacker.hasClass("Structure") ? data.attacker.attackRange("Ranged") : !m.isSiegeUnit(data.attacker);
 		else
 			allowMelee = true;
 	}
 	let ret = false;
 	for (let ent of units.values())
 	{
 		if (garrisonManager.numberOfGarrisonedUnits(target) >= minGarrison)
 			break;
 		if (!ent.position())
 			continue;
 		if (typeGarrison !== "decay" && !allowMelee && ent.attackTypes().indexOf("Melee") !== -1)
 			continue;
 		if (ent.getMetadata(PlayerID, "transport") !== undefined)
 			continue;
 		let army = ent.getMetadata(PlayerID, "PartOfArmy") ? this.getArmy(ent.getMetadata(PlayerID, "PartOfArmy")) : undefined;
 		if (!army && (ent.getMetadata(PlayerID, "plan") === -2 || ent.getMetadata(PlayerID, "plan") === -3))
 			continue;
 		if (ent.getMetadata(PlayerID, "plan") !== undefined && ent.getMetadata(PlayerID, "plan") >= 0)
 		{
 			let subrole = ent.getMetadata(PlayerID, "subrole");
 			// when structure decaying (usually because we've just captured it in enemy territory), also allow units from an attack plan
 			if (typeGarrison !== "decay" && subrole && (subrole === "completing" || subrole === "walking" || subrole === "attacking"))
 				continue;
 		}
 		if (gameState.ai.accessibility.getAccessValue(ent.position()) !== index)
 			continue;
 		if (ent.getMetadata(PlayerID, "plan") !== undefined && ent.getMetadata(PlayerID, "plan") >= 0)
 		{
 			let attackPlan = gameState.ai.HQ.attackManager.getPlan(ent.getMetadata(PlayerID, "plan"));
 			if (attackPlan)
 				attackPlan.removeUnit(ent, true);
 		}
 		if (army)
 			army.removeOwn(gameState, ent.id());
 		garrisonManager.garrison(gameState, ent, target, typeGarrison);
 		ret = true;
 	}
 	return ret;
 };
 
 /** garrison a attacked siege ranged unit inside the nearest fortress */
 m.DefenseManager.prototype.garrisonSiegeUnit = function(gameState, unit)
 {
 	let distmin = Math.min();
 	let nearest;
 	let unitAccess = gameState.ai.accessibility.getAccessValue(unit.position());
 	let garrisonManager = gameState.ai.HQ.garrisonManager;
 	gameState.getAllyStructures().forEach(function(ent) {
 		if (!MatchesClassList(unit.classes(), ent.garrisonableClasses()))
 			return;
 		if (garrisonManager.numberOfGarrisonedUnits(ent) >= ent.garrisonMax())
 			return;
 		if (ent.hitpoints() < ent.garrisonEjectHealth() * ent.maxHitpoints())
 			return;
 		if (m.getLandAccess(gameState, ent) !== unitAccess)
 			return;
 		let dist = API3.SquareVectorDistance(ent.position(), unit.position());
 		if (dist > distmin)
 			return;
 		distmin = dist;
 		nearest = ent;
 	});
 	if (nearest)
 		garrisonManager.garrison(gameState, unit, nearest, "protection");
 	return nearest !== undefined;
 };
 
 /**
  * Garrison a hurt unit inside a player-owned or allied structure
  * If emergency is true, the unit will be garrisoned in the closest possible structure
  * Otherwise, it will garrison in the closest healing structure
  */
 m.DefenseManager.prototype.garrisonAttackedUnit = function(gameState, unit, emergency = false)
 {
 	let distmin = Math.min();
 	let nearest;
 	let unitAccess = gameState.ai.accessibility.getAccessValue(unit.position());
 	let garrisonManager = gameState.ai.HQ.garrisonManager;
 	for (let ent of gameState.getAllyStructures().values())
 	{
 		if (!emergency && !ent.buffHeal())
 			continue;
 		if (!MatchesClassList(unit.classes(), ent.garrisonableClasses()))
 			continue;
 		if (garrisonManager.numberOfGarrisonedUnits(ent) >= ent.garrisonMax() &&
 		    (!emergency || !ent.garrisoned().length))
 			continue;
 		if (ent.hitpoints() < ent.garrisonEjectHealth() * ent.maxHitpoints())
 			continue;
 		if (m.getLandAccess(gameState, ent) !== unitAccess)
 			continue;
 		let dist = API3.SquareVectorDistance(ent.position(), unit.position());
 		if (dist > distmin)
 			continue;
 		distmin = dist;
 		nearest = ent;
 	}
 	if (!nearest)
 		return false;
 
 	if (!emergency)
 	{
 		garrisonManager.garrison(gameState, unit, nearest, "protection");
 		return true;
 	}
 	if (garrisonManager.numberOfGarrisonedUnits(nearest) >= nearest.garrisonMax()) // make room for this ent
 		nearest.unload(nearest.garrisoned()[0]);
 
 	garrisonManager.garrison(gameState, unit, nearest, nearest.buffHeal() ? "protection" : "emergency");
 	return true;
 };
 
 /**
  * Be more inclined to help an ally attacked by several enemies
  */
 m.DefenseManager.prototype.GetCooperationLevel = function(ent)
 {
 	let ally = ent.owner();
 	let cooperation = this.Config.personality.cooperative;
 	if (this.attackedAllies[ally] && this.attackedAllies[ally] > 1)
 		cooperation += 0.2 * (this.attackedAllies[ally] - 1);
 	return cooperation;
 };
 
+/**
+ * Switch a defense army into an attack if needed
+ */
+m.DefenseManager.prototype.switchToAttack = function(gameState, army)
+{
+	if (!army)
+		return;
+	for (let targetId of this.targetList)
+	{
+		let target = gameState.getEntityById(targetId);
+		if (!target || !target.position() || !gameState.isPlayerEnemy(target.owner()))
+			continue;
+		let targetAccess = m.getLandAccess(gameState, target);
+		let targetPos = target.position();
+		for (let entId of army.ownEntities)
+		{
+			let ent = gameState.getEntityById(entId);
+			if (!ent)
+				continue;
+			let pos = ent.position();
+			if (!pos || gameState.ai.accessibility.getAccessValue(pos) !== targetAccess)
+				continue;
+			if (API3.SquareVectorDistance(targetPos, pos) > 14400)
+				continue;
+			gameState.ai.HQ.attackManager.switchDefenseToAttack(gameState, target, { "armyID": army.ID, "uniqueTarget": true });
+			return;
+		}
+	}
+};
+
 m.DefenseManager.prototype.Serialize = function()
 {
 	let properties = {
 		"targetList" : this.targetList,
 		"armyMergeSize": this.armyMergeSize,
 		"attackingUnits": this.attackingUnits,
 		"attackingArmies": this.attackingArmies,
 		"attackedAllies": this.attackedAllies
 	};
 
 	let armies = [];
 	for (let army of this.armies)
 		armies.push(army.Serialize());
 
 	return { "properties": properties, "armies": armies };
 };
 
 m.DefenseManager.prototype.Deserialize = function(gameState, data)
 {
 	for (let key in data.properties)
 		this[key] = data.properties[key];
 
 	this.armies = [];
 	for (let dataArmy of data.armies)
 	{
 		let army = new m.DefenseArmy(gameState, [], []);
 		army.Deserialize(dataArmy);
 		this.armies.push(army);
 	}
 };
 
 return m;
 }(PETRA);