Source: navalManager.js

/**
* @class
 * Naval Manager
 * Will deal with anything ships.
 * -Basically trade over water (with fleets and goals commissioned by the economy manager)
 * -Defense over water (commissioned by the defense manager)
 * -Transport of units over water (a few units).
 * -Scouting, ultimately.
 * Also deals with handling docks, making sure we have access and stuffs like that.
 */
PETRA.NavalManager = function(Config)
{
	this.Config = Config;

	// ship subCollections. Also exist for land zones, idem, not caring.
	this.seaShips = [];
	this.seaTransportShips = [];
	this.seaWarShips = [];
	this.seaFishShips = [];

	// wanted NB per zone.
	this.wantedTransportShips = [];
	this.wantedWarShips = [];
	this.wantedFishShips = [];
	// needed NB per zone.
	this.neededTransportShips = [];
	this.neededWarShips = [];

	this.transportPlans = [];

	// shore-line regions where we can load and unload units
	this.landingZones = {};
};

/** More initialisation for stuff that needs the gameState */
PETRA.NavalManager.prototype.init = function(gameState, deserializing)
{
	// docks
	this.docks = gameState.getOwnStructures().filter(API3.Filters.byClasses(["Dock", "Shipyard"]));
	this.docks.registerUpdates();

	this.ships = gameState.getOwnUnits().filter(API3.Filters.and(API3.Filters.byClass("Ship"), API3.Filters.not(API3.Filters.byMetadata(PlayerID, "role", "trader"))));
	// note: those two can overlap (some transport ships are warships too and vice-versa).
	this.transportShips = this.ships.filter(API3.Filters.and(API3.Filters.byCanGarrison(), API3.Filters.not(API3.Filters.byClass("FishingBoat"))));
	this.warShips = this.ships.filter(API3.Filters.byClass("Warship"));
	this.fishShips = this.ships.filter(API3.Filters.byClass("FishingBoat"));

	this.ships.registerUpdates();
	this.transportShips.registerUpdates();
	this.warShips.registerUpdates();
	this.fishShips.registerUpdates();

	let availableFishes = {};
	for (let fish of gameState.getFishableSupplies().values())
	{
		let sea = this.getFishSea(gameState, fish);
		if (sea && availableFishes[sea])
			availableFishes[sea] += fish.resourceSupplyAmount();
		else if (sea)
			availableFishes[sea] = fish.resourceSupplyAmount();
	}

	for (let i = 0; i < gameState.ai.accessibility.regionSize.length; ++i)
	{
		if (!gameState.ai.HQ.navalRegions[i])
		{
			// push dummies
			this.seaShips.push(undefined);
			this.seaTransportShips.push(undefined);
			this.seaWarShips.push(undefined);
			this.seaFishShips.push(undefined);
			this.wantedTransportShips.push(0);
			this.wantedWarShips.push(0);
			this.wantedFishShips.push(0);
			this.neededTransportShips.push(0);
			this.neededWarShips.push(0);
		}
		else
		{
			let collec = this.ships.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
			collec.registerUpdates();
			this.seaShips.push(collec);
			collec = this.transportShips.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
			collec.registerUpdates();
			this.seaTransportShips.push(collec);
			collec = this.warShips.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
			collec.registerUpdates();
			this.seaWarShips.push(collec);
			collec = this.fishShips.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
			collec.registerUpdates();
			this.seaFishShips.push(collec);
			this.wantedTransportShips.push(0);
			this.wantedWarShips.push(0);
			if (availableFishes[i] && availableFishes[i] > 1000)
				this.wantedFishShips.push(this.Config.Economy.targetNumFishers);
			else
				this.wantedFishShips.push(0);
			this.neededTransportShips.push(0);
			this.neededWarShips.push(0);
		}
	}

	if (deserializing)
		return;

	// determination of the possible landing zones
	let width = gameState.getPassabilityMap().width;
	let length = width * gameState.getPassabilityMap().height;
	for (let i = 0; i < length; ++i)
	{
		let land = gameState.ai.accessibility.landPassMap[i];
		if (land < 2)
			continue;
		let naval = gameState.ai.accessibility.navalPassMap[i];
		if (naval < 2)
			continue;
		if (!this.landingZones[land])
			this.landingZones[land] = {};
		if (!this.landingZones[land][naval])
		    this.landingZones[land][naval] = new Set();
		this.landingZones[land][naval].add(i);
	}
	// and keep only thoses with enough room around when possible
	for (let land in this.landingZones)
	{
		for (let sea in this.landingZones[land])
		{
			let landing = this.landingZones[land][sea];
			let nbaround = {};
			let nbcut = 0;
			for (let i of landing)
			{
				let nb = 0;
				if (landing.has(i-1))
					nb++;
				if (landing.has(i+1))
					nb++;
				if (landing.has(i+width))
					nb++;
				if (landing.has(i-width))
					nb++;
				nbaround[i] = nb;
				nbcut = Math.max(nb, nbcut);
			}
			nbcut = Math.min(2, nbcut);
			for (let i of landing)
			{
				if (nbaround[i] < nbcut)
					landing.delete(i);
			}
		}
	}

	// Assign our initial docks and ships
	for (let ship of this.ships.values())
		PETRA.setSeaAccess(gameState, ship);
	for (let dock of this.docks.values())
		PETRA.setSeaAccess(gameState, dock);
};

PETRA.NavalManager.prototype.updateFishingBoats = function(sea, num)
{
	if (this.wantedFishShips[sea])
		this.wantedFishShips[sea] = num;
};

PETRA.NavalManager.prototype.resetFishingBoats = function(gameState, sea)
{
	if (sea !== undefined)
		this.wantedFishShips[sea] = 0;
	else
		this.wantedFishShips.fill(0);
};

/** Get the sea, cache it if not yet done and check if in opensea */
PETRA.NavalManager.prototype.getFishSea = function(gameState, fish)
{
	let sea = fish.getMetadata(PlayerID, "sea");
	if (sea)
		return sea;
	const ntry = 4;
	const around = [[-0.7, 0.7], [0, 1], [0.7, 0.7], [1, 0], [0.7, -0.7], [0, -1], [-0.7, -0.7], [-1, 0]];
	let pos = gameState.ai.accessibility.gamePosToMapPos(fish.position());
	let width = gameState.ai.accessibility.width;
	let k = pos[0] + pos[1]*width;
	sea = gameState.ai.accessibility.navalPassMap[k];
	fish.setMetadata(PlayerID, "sea", sea);
	let radius = 120 / gameState.ai.accessibility.cellSize / ntry;
	if (around.every(a => {
		for (let t = 0; t < ntry; ++t)
		{
			let i = pos[0] + Math.round(a[0]*radius*(ntry-t));
			let j = pos[1] + Math.round(a[1]*radius*(ntry-t));
			if (i < 0 || i >= width || j < 0 || j >= width)
				continue;
			if (gameState.ai.accessibility.landPassMap[i + j*width] === 1)
			{
				let navalPass = gameState.ai.accessibility.navalPassMap[i + j*width];
				if (navalPass == sea)
					return true;
				else if (navalPass == 1)  // we could be outside the map
					continue;
			}
			return false;
		}
		return true;
	}))
		fish.setMetadata(PlayerID, "opensea", true);
	return sea;
};

/** check if we can safely fish at the fish position */
PETRA.NavalManager.prototype.canFishSafely = function(gameState, fish)
{
	if (fish.getMetadata(PlayerID, "opensea"))
		return true;
	const ntry = 2;
	const around = [[-0.7, 0.7], [0, 1], [0.7, 0.7], [1, 0], [0.7, -0.7], [0, -1], [-0.7, -0.7], [-1, 0]];
	let territoryMap = gameState.ai.HQ.territoryMap;
	let width = territoryMap.width;
	let radius = 120 / territoryMap.cellSize / ntry;
	let pos = territoryMap.gamePosToMapPos(fish.position());
	return around.every(a => {
		for (let t = 0; t < ntry; ++t)
		{
			let i = pos[0] + Math.round(a[0]*radius*(ntry-t));
			let j = pos[1] + Math.round(a[1]*radius*(ntry-t));
			if (i < 0 || i >= width || j < 0 || j >= width)
				continue;
			let owner = territoryMap.getOwnerIndex(i + j*width);
			if (owner != 0 && gameState.isPlayerEnemy(owner))
				return false;
		}
		return true;
	});
};

/** get the list of seas (or lands) around this region not connected by a dock */
PETRA.NavalManager.prototype.getUnconnectedSeas = function(gameState, region)
{
	let seas = gameState.ai.accessibility.regionLinks[region].slice();
	this.docks.forEach(dock => {
		if (!dock.hasClass("Dock") || PETRA.getLandAccess(gameState, dock) != region)
			return;
		let i = seas.indexOf(PETRA.getSeaAccess(gameState, dock));
		if (i != -1)
			seas.splice(i--, 1);
	});
	return seas;
};

PETRA.NavalManager.prototype.checkEvents = function(gameState, queues, events)
{
	for (let evt of events.Create)
	{
		if (!evt.entity)
			continue;
		let ent = gameState.getEntityById(evt.entity);
		if (ent && ent.isOwn(PlayerID) && ent.foundationProgress() !== undefined && ent.hasClasses(["Dock", "Shipyard"]))
			PETRA.setSeaAccess(gameState, ent);
	}

	for (let evt of events.TrainingFinished)
	{
		if (!evt.entities)
			continue;
		for (let entId of evt.entities)
		{
			let ent = gameState.getEntityById(entId);
			if (!ent || !ent.hasClass("Ship") || !ent.isOwn(PlayerID))
				continue;
			PETRA.setSeaAccess(gameState, ent);
		}
	}

	for (let evt of events.Destroy)
	{
		if (!evt.entityObj || evt.entityObj.owner() !== PlayerID || !evt.metadata || !evt.metadata[PlayerID])
			continue;
		if (!evt.entityObj.hasClass("Ship") || !evt.metadata[PlayerID].transporter)
			continue;
		let plan = this.getPlan(evt.metadata[PlayerID].transporter);
		if (!plan)
			continue;

		let shipId = evt.entityObj.id();
		if (this.Config.debug > 1)
			API3.warn("one ship " + shipId + " from plan " + plan.ID + " destroyed during " + plan.state);
		if (plan.state == "boarding")
		{
			// just reset the units onBoard metadata and wait for a new ship to be assigned to this plan
			plan.units.forEach(ent => {
				if (ent.getMetadata(PlayerID, "onBoard") == "onBoard" && ent.position() ||
				    ent.getMetadata(PlayerID, "onBoard") == shipId)
					ent.setMetadata(PlayerID, "onBoard", undefined);
			});
			plan.needTransportShips = !plan.transportShips.hasEntities();
		}
		else if (plan.state == "sailing")
		{
			let endIndex = plan.endIndex;
			for (let ent of plan.units.values())
			{
				if (!ent.position())  // unit from another ship of this plan ... do nothing
					continue;
				let access = PETRA.getLandAccess(gameState, ent);
				let endPos = ent.getMetadata(PlayerID, "endPos");
				ent.setMetadata(PlayerID, "transport", undefined);
				ent.setMetadata(PlayerID, "onBoard", undefined);
				ent.setMetadata(PlayerID, "endPos", undefined);
				// nothing else to do if access = endIndex as already at destination
				// otherwise, we should require another transport
				// TODO if attacking and no more ships available, remove the units from the attack
				// to avoid delaying it too much
				if (access != endIndex)
					this.requireTransport(gameState, ent, access, endIndex, endPos);
			}
		}
	}

	for (let evt of events.OwnershipChanged)	// capture events
	{
		if (evt.to !== PlayerID)
			continue;
		let ent = gameState.getEntityById(evt.entity);
		if (ent && ent.hasClasses(["Dock", "Shipyard"]))
			PETRA.setSeaAccess(gameState, ent);
	}
};


PETRA.NavalManager.prototype.getPlan = function(ID)
{
	for (let plan of this.transportPlans)
		if (plan.ID === ID)
			return plan;
	return undefined;
};

PETRA.NavalManager.prototype.addPlan = function(plan)
{
	this.transportPlans.push(plan);
};

/**
 * complete already existing plan or create a new one for this requirement
 * (many units can then call this separately and end up in the same plan)
 * TODO  check garrison classes
 */
PETRA.NavalManager.prototype.requireTransport = function(gameState, ent, startIndex, endIndex, endPos)
{
	if (!ent.canGarrison())
		return false;

	if (ent.getMetadata(PlayerID, "transport") !== undefined)
	{
		if (this.Config.debug > 0)
			API3.warn("Petra naval manager error: unit " + ent.id() + " has already required a transport");
		return false;
	}

	let plans = [];
	for (let plan of this.transportPlans)
	{
		if (plan.startIndex != startIndex || plan.endIndex != endIndex || plan.state != "boarding")
			continue;
		// Limit the number of siege units per transport to avoid problems when ungarrisoning
		if (PETRA.isSiegeUnit(ent) && plan.units.filter(unit => PETRA.isSiegeUnit(unit)).length > 3)
			continue;
		plans.push(plan);
	}

	if (plans.length)
	{
		plans.sort(plan => plan.units.length);
		plans[0].addUnit(ent, endPos);
		return true;
	}

	let plan = new PETRA.TransportPlan(gameState, [ent], startIndex, endIndex, endPos);
	if (plan.failed)
	{
		if (this.Config.debug > 1)
			API3.warn(">>>> transport plan aborted <<<<");
		return false;
	}
	plan.init(gameState);
	this.transportPlans.push(plan);
	return true;
};

/** split a transport plan in two, moving all entities not yet affected to a ship in the new plan */
PETRA.NavalManager.prototype.splitTransport = function(gameState, plan)
{
	if (this.Config.debug > 1)
		API3.warn(">>>> split of transport plan started <<<<");
	let newplan = new PETRA.TransportPlan(gameState, [], plan.startIndex, plan.endIndex, plan.endPos);
	if (newplan.failed)
	{
		if (this.Config.debug > 1)
			API3.warn(">>>> split of transport plan aborted <<<<");
		return false;
	}
	newplan.init(gameState);

	for (let ent of plan.needSplit)
	{
		if (ent.getMetadata(PlayerID, "onBoard"))	// Should never happen.
			continue;
		newplan.addUnit(ent, ent.getMetadata(PlayerID, "endPos"));
		plan.units.updateEnt(ent);
	}

	if (newplan.units.length)
		this.transportPlans.push(newplan);
	return newplan.units.length != 0;
};

/**
 * create a transport from a garrisoned ship to a land location
 * needed at start game when starting with a garrisoned ship
 */
PETRA.NavalManager.prototype.createTransportIfNeeded = function(gameState, fromPos, toPos, toAccess)
{
	let fromAccess = gameState.ai.accessibility.getAccessValue(fromPos);
	if (fromAccess !== 1)
		return;
	if (toAccess < 2)
		return;

	for (let ship of this.ships.values())
	{
		if (!ship.isGarrisonHolder() || !ship.garrisoned().length)
			continue;
		if (ship.getMetadata(PlayerID, "transporter") !== undefined)
			continue;
		let units = [];
		for (let entId of ship.garrisoned())
			units.push(gameState.getEntityById(entId));
		// TODO check that the garrisoned units have not another purpose
		let plan = new PETRA.TransportPlan(gameState, units, fromAccess, toAccess, toPos, ship);
		if (plan.failed)
			continue;
		plan.init(gameState);
		this.transportPlans.push(plan);
	}
};

// set minimal number of needed ships when a new event (new base or new attack plan)
PETRA.NavalManager.prototype.setMinimalTransportShips = function(gameState, sea, number)
{
	if (!sea)
		return;
	if (this.wantedTransportShips[sea] < number)
		this.wantedTransportShips[sea] = number;
};

// bumps up the number of ships we want if we need more.
PETRA.NavalManager.prototype.checkLevels = function(gameState, queues)
{
	if (queues.ships.hasQueuedUnits())
		return;

	for (let sea = 0; sea < this.neededTransportShips.length; sea++)
		this.neededTransportShips[sea] = 0;

	for (let plan of this.transportPlans)
	{
		if (!plan.needTransportShips || plan.units.length < 2)
			continue;
		let sea = plan.sea;
		if (gameState.countOwnQueuedEntitiesWithMetadata("sea", sea) > 0 ||
			this.seaTransportShips[sea].length < this.wantedTransportShips[sea])
			continue;
		++this.neededTransportShips[sea];
		if (this.wantedTransportShips[sea] === 0 || this.seaTransportShips[sea].length < plan.transportShips.length + 2)
		{
			++this.wantedTransportShips[sea];
			return;
		}
	}

	for (let sea = 0; sea < this.neededTransportShips.length; sea++)
		if (this.neededTransportShips[sea] > 2)
			++this.wantedTransportShips[sea];
};

PETRA.NavalManager.prototype.maintainFleet = function(gameState, queues)
{
	if (queues.ships.hasQueuedUnits())
		return;
	if (!this.docks.filter(API3.Filters.isBuilt()).hasEntities())
		return;
	// check if we have enough transport ships per region.
	for (let sea = 0; sea < this.seaShips.length; ++sea)
	{
		if (this.seaShips[sea] === undefined)
			continue;
		if (gameState.countOwnQueuedEntitiesWithMetadata("sea", sea) > 0)
			continue;

		if (this.seaTransportShips[sea].length < this.wantedTransportShips[sea])
		{
			let template = this.getBestShip(gameState, sea, "transport");
			if (template)
			{
				queues.ships.addPlan(new PETRA.TrainingPlan(gameState, template, { "sea": sea }, 1, 1));
				continue;
			}
		}


		if (this.seaFishShips[sea].length < this.wantedFishShips[sea])
		{
			let template = this.getBestShip(gameState, sea, "fishing");
			if (template)
			{
				queues.ships.addPlan(new PETRA.TrainingPlan(gameState, template, { "base": 0, "role": "worker", "sea": sea }, 1, 1));
				continue;
			}
		}
	}
};

/** assigns free ships to plans that need some */
PETRA.NavalManager.prototype.assignShipsToPlans = function(gameState)
{
	for (let plan of this.transportPlans)
		if (plan.needTransportShips)
			plan.assignShip(gameState);
};

/** Return true if this ship is likeky (un)garrisoning units */
PETRA.NavalManager.prototype.isShipBoarding = function(ship)
{
	if (!ship.position())
		return false;
	let plan = this.getPlan(ship.getMetadata(PlayerID, "transporter"));
	if (!plan || !plan.boardingPos[ship.id()])
		return false;
	return API3.SquareVectorDistance(plan.boardingPos[ship.id()], ship.position()) < plan.boardingRange;
};

/** let blocking ships move apart from active ships (waiting for a better pathfinder)
 * TODO Ships entity collections are currently in two parts as the trader ships are dealt with
 * in the tradeManager. That should be modified to avoid dupplicating all the code here.
 */
PETRA.NavalManager.prototype.moveApart = function(gameState)
{
	let blockedShips = [];
	let blockedIds = [];

	for (let ship of this.ships.values())
	{
		let shipPosition = ship.position();
		if (!shipPosition)
			continue;
		if (ship.getMetadata(PlayerID, "transporter") !== undefined && this.isShipBoarding(ship))
			continue;

		let unitAIState = ship.unitAIState();
		if (ship.getMetadata(PlayerID, "transporter") !== undefined ||
		    unitAIState == "INDIVIDUAL.GATHER.APPROACHING" ||
		    unitAIState == "INDIVIDUAL.GATHER.RETURNINGRESOURCE.APPROACHING")
		{
			let previousPosition = ship.getMetadata(PlayerID, "previousPosition");
			if (!previousPosition || previousPosition[0] != shipPosition[0] ||
			                         previousPosition[1] != shipPosition[1])
			{
				ship.setMetadata(PlayerID, "previousPosition", shipPosition);
				ship.setMetadata(PlayerID, "turnPreviousPosition", gameState.ai.playedTurn);
				continue;
			}
			// New transport ships receive boarding commands only on the following turn.
			if (gameState.ai.playedTurn < ship.getMetadata(PlayerID, "turnPreviousPosition") + 2)
				continue;
			ship.moveToRange(shipPosition[0] + randFloat(-1, 1), shipPosition[1] + randFloat(-1, 1), 30, 35);
			blockedShips.push(ship);
			blockedIds.push(ship.id());
		}
		else if (ship.isIdle())
		{
			let previousIdlePosition = ship.getMetadata(PlayerID, "previousIdlePosition");
			if (!previousIdlePosition || previousIdlePosition[0] != shipPosition[0] ||
			                             previousIdlePosition[1] != shipPosition[1])
			{
				ship.setMetadata(PlayerID, "previousIdlePosition", shipPosition);
				ship.setMetadata(PlayerID, "stationnary", undefined);
				continue;
			}
			if (ship.getMetadata(PlayerID, "stationnary"))
				continue;
			ship.setMetadata(PlayerID, "stationnary", true);
			// Check if there are some treasure around
			if (PETRA.gatherTreasure(gameState, ship, true))
				continue;
			// Do not stay idle near a dock to not disturb other ships
			let sea = ship.getMetadata(PlayerID, "sea");
			for (let dock of gameState.getAllyStructures().filter(API3.Filters.byClass("Dock")).values())
			{
				if (PETRA.getSeaAccess(gameState, dock) != sea)
					continue;
				if (API3.SquareVectorDistance(shipPosition, dock.position()) > 4900)
					continue;
				ship.moveToRange(dock.position()[0], dock.position()[1], 70, 75);
			}

		}
	}

	for (let ship of gameState.ai.HQ.tradeManager.traders.filter(API3.Filters.byClass("Ship")).values())
	{
		let shipPosition = ship.position();
		if (!shipPosition)
			continue;
		let role = ship.getMetadata(PlayerID, "role");
		if (!role || role != "trader")	// already accounted before
			continue;

		let unitAIState = ship.unitAIState();
		if (unitAIState == "INDIVIDUAL.TRADE.APPROACHINGMARKET")
		{
			let previousPosition = ship.getMetadata(PlayerID, "previousPosition");
			if (!previousPosition || previousPosition[0] != shipPosition[0] ||
			                         previousPosition[1] != shipPosition[1])
			{
				ship.setMetadata(PlayerID, "previousPosition", shipPosition);
				ship.setMetadata(PlayerID, "turnPreviousPosition", gameState.ai.playedTurn);
				continue;
			}
			// New transport ships receives boarding commands only on the following turn.
			if (gameState.ai.playedTurn < ship.getMetadata(PlayerID, "turnPreviousPosition") + 2)
				continue;
			ship.moveToRange(shipPosition[0] + randFloat(-1, 1), shipPosition[1] + randFloat(-1, 1), 30, 35);
			blockedShips.push(ship);
			blockedIds.push(ship.id());
		}
		else if (ship.isIdle())
		{
			let previousIdlePosition = ship.getMetadata(PlayerID, "previousIdlePosition");
			if (!previousIdlePosition || previousIdlePosition[0] != shipPosition[0] ||
			                             previousIdlePosition[1] != shipPosition[1])
			{
				ship.setMetadata(PlayerID, "previousIdlePosition", shipPosition);
				ship.setMetadata(PlayerID, "stationnary", undefined);
				continue;
			}
			if (ship.getMetadata(PlayerID, "stationnary"))
				continue;
			ship.setMetadata(PlayerID, "stationnary", true);
			// Check if there are some treasure around
			if (PETRA.gatherTreasure(gameState, ship, true))
				continue;
			// Do not stay idle near a dock to not disturb other ships
			let sea = ship.getMetadata(PlayerID, "sea");
			for (let dock of gameState.getAllyStructures().filter(API3.Filters.byClass("Dock")).values())
			{
				if (PETRA.getSeaAccess(gameState, dock) != sea)
					continue;
				if (API3.SquareVectorDistance(shipPosition, dock.position()) > 4900)
					continue;
				ship.moveToRange(dock.position()[0], dock.position()[1], 70, 75);
			}
		}
	}

	for (let ship of blockedShips)
	{
		let shipPosition = ship.position();
		let sea = ship.getMetadata(PlayerID, "sea");
		for (let blockingShip of this.seaShips[sea].values())
		{
			if (blockedIds.indexOf(blockingShip.id()) != -1 || !blockingShip.position())
				continue;
			let distSquare = API3.SquareVectorDistance(shipPosition, blockingShip.position());
			let unitAIState = blockingShip.unitAIState();
			if (blockingShip.getMetadata(PlayerID, "transporter") === undefined &&
			    unitAIState != "INDIVIDUAL.GATHER.APPROACHING" &&
			    unitAIState != "INDIVIDUAL.GATHER.RETURNINGRESOURCE.APPROACHING")
			{
				if (distSquare < 1600)
					blockingShip.moveToRange(shipPosition[0], shipPosition[1], 40, 45);
			}
			else if (distSquare < 900)
				blockingShip.moveToRange(shipPosition[0], shipPosition[1], 30, 35);
		}

		for (let blockingShip of gameState.ai.HQ.tradeManager.traders.filter(API3.Filters.byClass("Ship")).values())
		{
			if (blockingShip.getMetadata(PlayerID, "sea") != sea)
				continue;
			if (blockedIds.indexOf(blockingShip.id()) != -1 || !blockingShip.position())
				continue;
			let role = blockingShip.getMetadata(PlayerID, "role");
			if (!role || role != "trader")	// already accounted before
				continue;
			let distSquare = API3.SquareVectorDistance(shipPosition, blockingShip.position());
			let unitAIState = blockingShip.unitAIState();
			if (unitAIState != "INDIVIDUAL.TRADE.APPROACHINGMARKET")
			{
				if (distSquare < 1600)
					blockingShip.moveToRange(shipPosition[0], shipPosition[1], 40, 45);
			}
			else if (distSquare < 900)
				blockingShip.moveToRange(shipPosition[0], shipPosition[1], 30, 35);
		}
	}
};

PETRA.NavalManager.prototype.buildNavalStructures = function(gameState, queues)
{
	if (!gameState.ai.HQ.navalMap || !gameState.ai.HQ.baseManagers[1])
		return;

	if (gameState.ai.HQ.getAccountedPopulation(gameState) > this.Config.Economy.popForDock)
	{
		if (queues.dock.countQueuedUnitsWithClass("Dock") === 0 &&
			!gameState.getOwnStructures().filter(API3.Filters.and(API3.Filters.byClass("Dock"), API3.Filters.isFoundation())).hasEntities() &&
			gameState.ai.HQ.canBuild(gameState, "structures/{civ}/dock"))
		{
			let dockStarted = false;
			for (let base of gameState.ai.HQ.baseManagers)
			{
				if (dockStarted)
					break;
				if (!base.anchor || base.constructing)
					continue;
				let remaining = this.getUnconnectedSeas(gameState, base.accessIndex);
				for (let sea of remaining)
				{
					if (!gameState.ai.HQ.navalRegions[sea])
						continue;
					let wantedLand = {};
					wantedLand[base.accessIndex] = true;
					queues.dock.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}/dock", { "land": wantedLand, "sea": sea }));
					dockStarted = true;
					break;
				}
			}
		}
	}

	if (gameState.currentPhase() < 2 || gameState.ai.HQ.getAccountedPopulation(gameState) < this.Config.Economy.popPhase2 + 15 ||
	    queues.militaryBuilding.hasQueuedUnits())
		return;
	if (!this.docks.filter(API3.Filters.byClass("Dock")).hasEntities() ||
	     this.docks.filter(API3.Filters.byClass("Shipyard")).hasEntities())
		return;
	// Use in priority resources to build a Market.
	if (!gameState.getOwnEntitiesByClass("Market", true).hasEntities() &&
	    gameState.ai.HQ.canBuild(gameState, "structures/{civ}/market"))
		return;
	let template;
	if (gameState.ai.HQ.canBuild(gameState, "structures/{civ}/super_dock"))
		template = "structures/{civ}/super_dock";
	else if (gameState.ai.HQ.canBuild(gameState, "structures/{civ}/shipyard"))
		template = "structures/{civ}/shipyard";
	else
		return;
	let wantedLand = {};
	for (let base of gameState.ai.HQ.baseManagers)
		if (base.anchor)
			wantedLand[base.accessIndex] = true;
	let sea = this.docks.toEntityArray()[0].getMetadata(PlayerID, "sea");
	queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, template, { "land": wantedLand, "sea": sea }));
};

/** goal can be either attack (choose ship with best arrowCount) or transport (choose ship with best capacity) */
PETRA.NavalManager.prototype.getBestShip = function(gameState, sea, goal)
{
	let civ = gameState.getPlayerCiv();
	let trainableShips = [];
	gameState.getOwnTrainingFacilities().filter(API3.Filters.byMetadata(PlayerID, "sea", sea)).forEach(function(ent) {
		let trainables = ent.trainableEntities(civ);
		for (let trainable of trainables)
		{
			if (gameState.isTemplateDisabled(trainable))
				continue;
			let template = gameState.getTemplate(trainable);
			if (template && template.hasClass("Ship") && trainableShips.indexOf(trainable) === -1)
				trainableShips.push(trainable);
		}
	});

	let best = 0;
	let bestShip;
	let limits = gameState.getEntityLimits();
	let current = gameState.getEntityCounts();
	for (let trainable of trainableShips)
	{
		let template = gameState.getTemplate(trainable);
		if (!template.available(gameState))
			continue;

		let category = template.trainingCategory();
		if (category && limits[category] && current[category] >= limits[category])
			continue;

		let arrows = +(template.getDefaultArrow() || 0);
		if (goal === "attack")    // choose the maximum default arrows
		{
			if (best > arrows)
				continue;
			best = arrows;
		}
		else if (goal === "transport")   // choose the maximum capacity, with a bonus if arrows or if siege transport
		{
			let capacity = +(template.garrisonMax() || 0);
			if (capacity < 2)
				continue;
			capacity += 10*arrows;
			if (MatchesClassList(template.garrisonableClasses(), "Siege"))
				capacity += 50;
			if (best > capacity)
				continue;
			best = capacity;
		}
		else if (goal === "fishing")
			if (!template.hasClass("FishingBoat"))
				continue;
		bestShip = trainable;
	}
	return bestShip;
};

PETRA.NavalManager.prototype.update = function(gameState, queues, events)
{
	Engine.ProfileStart("Naval Manager update");

	// close previous transport plans if finished
	for (let i = 0; i < this.transportPlans.length; ++i)
	{
		let remaining = this.transportPlans[i].update(gameState);
		if (remaining)
			continue;
		if (this.Config.debug > 1)
			API3.warn("no more units on transport plan " + this.transportPlans[i].ID);
		this.transportPlans[i].releaseAll();
		this.transportPlans.splice(i--, 1);
	}
	// assign free ships to plans which need them
	this.assignShipsToPlans(gameState);

	// and require for more ships/structures if needed
	if (gameState.ai.playedTurn % 3 === 0)
	{
		this.checkLevels(gameState, queues);
		this.maintainFleet(gameState, queues);
		this.buildNavalStructures(gameState, queues);
	}
	// let inactive ships move apart from active ones (waiting for a better pathfinder)
	this.moveApart(gameState);

	Engine.ProfileStop();
};

PETRA.NavalManager.prototype.Serialize = function()
{
	let properties = {
		"wantedTransportShips": this.wantedTransportShips,
		"wantedWarShips": this.wantedWarShips,
		"wantedFishShips": this.wantedFishShips,
		"neededTransportShips": this.neededTransportShips,
		"neededWarShips": this.neededWarShips,
		"landingZones": this.landingZones
	};

	let transports = {};
	for (let plan in this.transportPlans)
		transports[plan] = this.transportPlans[plan].Serialize();

	return { "properties": properties, "transports": transports };
};

PETRA.NavalManager.prototype.Deserialize = function(gameState, data)
{
	for (let key in data.properties)
		this[key] = data.properties[key];

	this.transportPlans = [];
	for (let i in data.transports)
	{
		let dataPlan = data.transports[i];
		let plan = new PETRA.TransportPlan(gameState, [], dataPlan.startIndex, dataPlan.endIndex, dataPlan.endPos);
		plan.Deserialize(dataPlan);
		plan.init(gameState);
		this.transportPlans.push(plan);
	}
};