Index: ps/trunk/binaries/data/mods/public/globalscripts/Resources.js
===================================================================
--- ps/trunk/binaries/data/mods/public/globalscripts/Resources.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/globalscripts/Resources.js	(revision 22970)
@@ -1,85 +1,122 @@
 /**
  * This class provides a cache to all resource names and properties defined by the JSON files.
  */
 function Resources()
 {
 	this.resourceData = [];
 	this.resourceDataObj = {};
 	this.resourceCodes = [];
 	this.resourceNames = {};
+	this.resourceCodesByProperty = {};
 
 	for (let filename of Engine.ListDirectoryFiles("simulation/data/resources/", "*.json", false))
 	{
 		let data = Engine.ReadJSONFile(filename);
 		if (!data)
 			continue;
 
 		if (data.code != data.code.toLowerCase())
 			warn("Resource codes should use lower case: " + data.code);
 
 		// Treasures are supported for every specified resource
 		if (data.code == "treasure")
 		{
 			error("Encountered resource with reserved keyword: " + data.code);
 			continue;
 		}
 
 		this.resourceData.push(data);
 		this.resourceDataObj[data.code] = data;
 		this.resourceCodes.push(data.code);
 		this.resourceNames[data.code] = data.name;
 		for (let subres in data.subtypes)
 			this.resourceNames[subres] = data.subtypes[subres];
+
+		for (let property in data.properties)
+		{
+			if (!this.resourceCodesByProperty[data.properties[property]])
+				this.resourceCodesByProperty[data.properties[property]] = [];
+			this.resourceCodesByProperty[data.properties[property]].push(data.code);
+		}
 	}
 
 	// Sort arrays by specified order
-	let resSort = (a, b) =>
-		a.order < b.order ? -1 :
-		a.order > b.order ? +1 : 0;
-
-	this.resourceData.sort(resSort);
-	this.resourceCodes.sort((a, b) => resSort(
+	let resDataSort = (a, b) => a.order < b.order ? -1 : a.order > b.order ? +1 : 0;
+	let resSort = (a, b) => resDataSort(
 		this.resourceData.find(resource => resource.code == a),
 		this.resourceData.find(resource => resource.code == b)
-	));
+	);
+
+	this.resourceData.sort(resDataSort);
+	this.resourceCodes.sort(resSort);
+	for (let property in this.resourceCodesByProperty)
+		this.resourceCodesByProperty[property].sort(resSort);
 
 	deepfreeze(this.resourceData);
 	deepfreeze(this.resourceDataObj);
 	deepfreeze(this.resourceCodes);
 	deepfreeze(this.resourceNames);
+	deepfreeze(this.resourceCodesByProperty);
 }
 
 /**
- * Returns the objects defined in the JSON files for all availbale resources,
+ * Returns the objects defined in the JSON files for all available resources,
  * ordered as defined in these files.
  */
 Resources.prototype.GetResources = function()
 {
 	return this.resourceData;
 };
 
 /**
  * Returns the object defined in the JSON file for the given resource.
  */
 Resources.prototype.GetResource = function(type)
 {
 	return this.resourceDataObj[type];
 };
 
 /**
  * Returns an array containing all resource codes ordered as defined in the resource files.
- * For example ["food", "wood", "stone", "metal"].
+ * @return {string[]} - Data of the form [ "food", "wood", ... ].
  */
 Resources.prototype.GetCodes = function()
 {
 	return this.resourceCodes;
 };
 
 /**
+ * Returns an array containing all barterable resource codes ordered as defined in the resource files.
+ * @return {string[]} - Data of the form [ "food", "wood", ... ].
+ */
+Resources.prototype.GetBarterableCodes = function()
+{
+	return this.resourceCodesByProperty.barterable || [];
+};
+
+/**
+ * Returns an array containing all tradable resource codes ordered as defined in the resource files.
+ * @return {string[]} - Data of the form [ "food", "wood", ... ].
+ */
+Resources.prototype.GetTradableCodes = function()
+{
+	return this.resourceCodesByProperty.tradable || [];
+};
+
+/**
+ * Returns an array containing all tributable resource codes ordered as defined in the resource files.
+ * @return {string[]} - Data of the form [ "food", "wood", ... ].
+ */
+Resources.prototype.GetTributableCodes = function()
+{
+	return this.resourceCodesByProperty.tributable || [];
+};
+
+/**
  * Returns an object mapping resource codes to translatable resource names. Includes subtypes.
  * For example { "food": "Food", "fish": "Fish", "fruit": "Fruit", "metal": "Metal", ... }
  */
 Resources.prototype.GetNames = function()
 {
 	return this.resourceNames;
 };
Index: ps/trunk/binaries/data/mods/public/globalscripts/tests/test_resources.js
===================================================================
--- ps/trunk/binaries/data/mods/public/globalscripts/tests/test_resources.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/public/globalscripts/tests/test_resources.js	(revision 22970)
@@ -0,0 +1,46 @@
+let resources = {
+	"res_A": {
+		"code": "a",
+		"name": "A",
+		"subtypes": {
+			"aa": "AA",
+			"aaa": "AAA"
+		},
+		"order": 2,
+		"properties": ["barterable", "tributable"]
+	},
+	"res_B": {
+		"code": "b",
+		"name": "B",
+		"subtypes": {
+			"bb": "BB",
+			"bbb": "BBB"
+		},
+		"order": 1,
+		"properties": ["tributable"]
+	}
+};
+
+Engine.ListDirectoryFiles = () => Object.keys(resources);
+Engine.ReadJSONFile = (file) => resources[file];
+
+let res = new Resources();
+
+TS_ASSERT_EQUALS(res.GetResources().length, 2);
+TS_ASSERT_EQUALS(res.GetResources()[0].code, "b");
+
+TS_ASSERT_EQUALS(res.GetResource("b").order, 1);
+
+TS_ASSERT_UNEVAL_EQUALS(res.GetCodes(), ["b", "a"]);
+TS_ASSERT_UNEVAL_EQUALS(res.GetTributableCodes(), ["b", "a"]);
+TS_ASSERT_UNEVAL_EQUALS(res.GetBarterableCodes(), ["a"]);
+TS_ASSERT_UNEVAL_EQUALS(res.GetTradableCodes(), []);
+
+TS_ASSERT_UNEVAL_EQUALS(res.GetNames(), {
+	"a": "A",
+	"aa": "AA",
+	"aaa": "AAA",
+	"b": "B",
+	"bb": "BB",
+	"bbb": "BBB"
+});

Property changes on: ps/trunk/binaries/data/mods/public/globalscripts/tests/test_resources.js
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/public/gui/session/menu.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/menu.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/gui/session/menu.js	(revision 22970)
@@ -1,1246 +1,1267 @@
 // Menu / panel border size
 var MARGIN = 4;
 
 // Includes the main menu button
 const NUM_BUTTONS = 10;
 
 // Regular menu buttons
 var BUTTON_HEIGHT = 32;
 
 // The position where the bottom of the menu will end up (currently 228)
 const END_MENU_POSITION = (BUTTON_HEIGHT * NUM_BUTTONS) + MARGIN;
 
 // Menu starting position: bottom
 const MENU_BOTTOM = 0;
 
 // Menu starting position: top
 const MENU_TOP = MENU_BOTTOM - END_MENU_POSITION;
 
 // Number of pixels per millisecond to move
 var MENU_SPEED = 1.2;
 
 // Trade menu: step for probability changes
 var STEP = 5;
 
 // Shown in the trade dialog.
 var g_IdleTraderTextColor = "orange";
 
 /**
  * Store civilization code and page (structree or history) opened in civilization info.
  */
 var g_CivInfo = {
 	"civ": "",
 	"page": "page_structree.xml"
 };
 
 /**
  * The barter constants should match with the simulation
  * Quantity of goods to sell per click.
  */
 const g_BarterResourceSellQuantity = 100;
 
 /**
  * Multiplier to be applied when holding the massbarter hotkey.
  */
 const g_BarterMultiplier = 5;
 
 /**
  * Barter actions, as mapped to the names of GUI Buttons.
  */
 const g_BarterActions = ["Buy", "Sell"];
 
 /**
  * Currently selected resource type to sell in the barter GUI.
  */
 var g_BarterSell;
 
 var g_IsMenuOpen = false;
 
 var g_IsDiplomacyOpen = false;
 var g_IsTradeOpen = false;
 var g_IsObjectivesOpen = false;
 
 /**
  * Used to disable a specific bribe button for the time we are waiting for the result of the bribe after it was clicked.
  * It contains an array per viewedPlayer. This array is a list of the players that were bribed.
  */
 var g_BribeButtonsWaiting = {};
 
 /**
  * Remember last viewed summary panel and charts.
  */
 var g_SummarySelectedData;
 
 // Redefined every time someone makes a tribute (so we can save some data in a closure). Called in input.js handleInputBeforeGui.
 var g_FlushTributing = function() {};
 
 function initMenu()
 {
 	Engine.GetGUIObjectByName("menu").size = "100%-164 " + MENU_TOP + " 100% " + MENU_BOTTOM;
 
 	// TODO: Atlas should pass g_GameAttributes.settings
 	for (let button of ["menuExitButton", "summaryButton", "objectivesButton", "diplomacyButton"])
 		Engine.GetGUIObjectByName(button).enabled = !Engine.IsAtlasRunning();
 }
 
 function updateMenuPosition(dt)
 {
 	let menu = Engine.GetGUIObjectByName("menu");
 
 	let maxOffset = g_IsMenuOpen ?
 		END_MENU_POSITION - menu.size.bottom :
 		menu.size.top - MENU_TOP;
 
 	if (maxOffset <= 0)
 		return;
 
 	let offset = Math.min(MENU_SPEED * dt, maxOffset) * (g_IsMenuOpen ? +1 : -1);
 
 	let size = menu.size;
 	size.top += offset;
 	size.bottom += offset;
 	menu.size = size;
 }
 
 // Opens the menu by revealing the screen which contains the menu
 function openMenu()
 {
 	g_IsMenuOpen = true;
 }
 
 // Closes the menu and resets position
 function closeMenu()
 {
 	g_IsMenuOpen = false;
 }
 
 function toggleMenu()
 {
 	g_IsMenuOpen = !g_IsMenuOpen;
 }
 
 function optionsMenuButton()
 {
 	closeOpenDialogs();
 	openOptions();
 }
 
 function lobbyDialogButton()
 {
 	if (!Engine.HasXmppClient())
 		return;
 
 	closeOpenDialogs();
 	Engine.PushGuiPage("page_lobby.xml", { "dialog": true });
 }
 
 function chatMenuButton()
 {
 	closeOpenDialogs();
 	openChat();
 }
 
 function resignMenuButton()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	messageBox(
 		400, 200,
 		translate("Are you sure you want to resign?"),
 		translate("Confirmation"),
 		[translate("No"), translate("Yes")],
 		[resumeGame, resignGame]
 	);
 }
 
 function exitMenuButton()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	let messageTypes = {
 		"host": {
 			"caption": translate("Are you sure you want to quit? Leaving will disconnect all other players."),
 			"buttons": [resumeGame, leaveGame]
 		},
 		"client": {
 			"caption": translate("Are you sure you want to quit?"),
 			"buttons": [resumeGame, resignQuestion]
 		},
 		"singleplayer": {
 			"caption": translate("Are you sure you want to quit?"),
 			"buttons": [resumeGame, leaveGame]
 		}
 	};
 
 	let messageType = g_IsNetworked && g_IsController ? "host" :
 		(g_IsNetworked && !g_IsObserver ? "client" : "singleplayer");
 
 	messageBox(
 		400, 200,
 		messageTypes[messageType].caption,
 		translate("Confirmation"),
 		[translate("No"), translate("Yes")],
 		messageTypes[messageType].buttons
 	);
 }
 
 function resignQuestion()
 {
 	messageBox(
 		400, 200,
 		translate("Do you want to resign or will you return soon?"),
 		translate("Confirmation"),
 		[translate("I will return"), translate("I resign")],
 		[leaveGame, resignGame],
 		[true, false]
 	);
 }
 
 function openDeleteDialog(selection)
 {
 	closeOpenDialogs();
 
 	let deleteSelectedEntities = function(selectionArg)
 	{
 		Engine.PostNetworkCommand({
 			"type": "delete-entities",
 			"entities": selectionArg
 		});
 	};
 
 	messageBox(
 		400, 200,
 		translate("Destroy everything currently selected?"),
 		translate("Delete"),
 		[translate("No"), translate("Yes")],
 		[resumeGame, deleteSelectedEntities],
 		[null, selection]
 	);
 }
 
 function openSave()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	Engine.PushGuiPage(
 		"page_loadgame.xml",
 		{ "savedGameData": getSavedGameData() },
 		resumeGame);
 }
 
 function openOptions()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	Engine.PushGuiPage(
 		"page_options.xml",
 		{},
 		callbackFunctionNames => {
 			for (let functionName of callbackFunctionNames)
 				if (global[functionName])
 					global[functionName]();
 
 			resumeGame();
 		});
 }
 
 function openChat(command = "")
 {
 	if (g_Disconnected)
 		return;
 
 	closeOpenDialogs();
 
 	let chatAddressee = Engine.GetGUIObjectByName("chatAddressee");
 	chatAddressee.selected = chatAddressee.list_data.indexOf(command);
 
 	Engine.GetGUIObjectByName("chatInput").focus();
 	Engine.GetGUIObjectByName("chatDialogPanel").hidden = false;
 
 	updateChatHistory();
 }
 
 function closeChat()
 {
 	Engine.GetGUIObjectByName("chatInput").caption = "";
 	Engine.GetGUIObjectByName("chatInput").blur(); // Remove focus
 	Engine.GetGUIObjectByName("chatDialogPanel").hidden = true;
 }
 
 function resizeDiplomacyDialog()
 {
 	let dialog = Engine.GetGUIObjectByName("diplomacyDialogPanel");
 	let size = dialog.size;
 
-	let tribSize = Engine.GetGUIObjectByName("diplomacyPlayer[0]_tribute[0]").size;
-	let widthOffset = g_ResourceData.GetCodes().length * (tribSize.right - tribSize.left) / 2;
-	size.left -= widthOffset;
-	size.right += widthOffset;
+	let resTribCodesLength = g_ResourceData.GetTributableCodes().length;
+	if (resTribCodesLength)
+	{
+		let tribSize = Engine.GetGUIObjectByName("diplomacyPlayer[0]_tribute[0]").size;
+		let widthOffset = resTribCodesLength * (tribSize.right - tribSize.left) / 2;
+		size.left -= widthOffset;
+		size.right += widthOffset;
+	}
+	else
+		Engine.GetGUIObjectByName("diplomacyHeaderTribute").hidden = true;
 
 	let firstRow = Engine.GetGUIObjectByName("diplomacyPlayer[0]").size;
 	let heightOffset = (g_Players.length - 1) * (firstRow.bottom - firstRow.top) / 2;
 	size.top -= heightOffset;
 	size.bottom += heightOffset;
 
 	dialog.size = size;
 }
 
 function initChatWindow()
 {
 	let filters = prepareForDropdown(g_ChatHistoryFilters);
 	let chatHistoryFilter = Engine.GetGUIObjectByName("chatHistoryFilter");
 	chatHistoryFilter.list = filters.text;
 	chatHistoryFilter.list_data = filters.key;
 	chatHistoryFilter.selected = 0;
 
 	Engine.GetGUIObjectByName("extendedChat").checked =
 		Engine.ConfigDB_GetValue("user", "chat.session.extended") == "true";
 
 	resizeChatWindow();
 }
 
 function resizeChatWindow()
 {
 	// Hide/show the panel
 	let chatHistoryPage = Engine.GetGUIObjectByName("chatHistoryPage");
 	let extended = Engine.GetGUIObjectByName("extendedChat").checked;
 	chatHistoryPage.hidden = !extended;
 
 	// Resize the window
 	let chatDialogPanel = Engine.GetGUIObjectByName("chatDialogPanel");
 	if (extended)
 	{
 		chatDialogPanel.size = Engine.GetGUIObjectByName("chatDialogPanelLarge").size;
 		// Adjust the width so that the chat history is in the golden ratio
 		let chatHistory = Engine.GetGUIObjectByName("chatHistory");
 		let height = chatHistory.getComputedSize().bottom - chatHistory.getComputedSize().top;
 		let width = (1 + Math.sqrt(5)) / 2 * height;
 		let size = chatDialogPanel.size;
 		size.left = -width / 2 - chatHistory.size.left;
 		size.right = width / 2 + chatHistory.size.left;
 		chatDialogPanel.size = size;
 	}
 	else
 		chatDialogPanel.size = Engine.GetGUIObjectByName("chatDialogPanelSmall").size;
 }
 
 function updateChatHistory()
 {
 	if (Engine.GetGUIObjectByName("chatDialogPanel").hidden ||
 	    !Engine.GetGUIObjectByName("extendedChat").checked)
 		return;
 
 	let chatHistoryFilter = Engine.GetGUIObjectByName("chatHistoryFilter");
 	let selected = chatHistoryFilter.list_data[chatHistoryFilter.selected];
 
 	Engine.GetGUIObjectByName("chatHistory").caption =
 		g_ChatHistory.filter(msg => msg.filter[selected]).map(msg =>
 			Engine.ConfigDB_GetValue("user", "chat.timestamp") == "true" ?
 				sprintf(translate("%(time)s %(message)s"), {
 					"time": msg.timePrefix,
 					"message": msg.txt
 				}) :
 				msg.txt
 		).join("\n");
 }
 
 function onToggleChatWindowExtended()
 {
 	Engine.ConfigDB_CreateAndWriteValueToFile("user", "chat.session.extended", String(Engine.GetGUIObjectByName("extendedChat").checked), "config/user.cfg");
 
 	resizeChatWindow();
 
 	Engine.GetGUIObjectByName("chatInput").focus();
 }
 
 function openDiplomacy()
 {
 	closeOpenDialogs();
 
 	if (g_ViewedPlayer < 1)
 		return;
 
 	g_IsDiplomacyOpen = true;
 
 	updateDiplomacy(true);
 
 	Engine.GetGUIObjectByName("diplomacyDialogPanel").hidden = false;
 }
 
 function closeDiplomacy()
 {
 	g_IsDiplomacyOpen = false;
 	Engine.GetGUIObjectByName("diplomacyDialogPanel").hidden = true;
 }
 
 function toggleDiplomacy()
 {
 	let open = g_IsDiplomacyOpen;
 	closeOpenDialogs();
 
 	if (!open)
 		openDiplomacy();
 }
 
 function updateDiplomacy(opening = false)
 {
 	if (g_ViewedPlayer < 1 || !g_IsDiplomacyOpen)
 		return;
 
 	let simState = GetSimState();
 	let isCeasefireActive = simState.ceasefireActive;
 	let hasSharedLos = GetSimState().players[g_ViewedPlayer].hasSharedLos;
 
 	// Get offset for one line
 	let onesize = Engine.GetGUIObjectByName("diplomacyPlayer[0]").size;
 	let rowsize = onesize.bottom - onesize.top;
 
 	// We don't include gaia
 	for (let i = 1; i < g_Players.length; ++i)
 	{
 		let myself = i == g_ViewedPlayer;
 		let playerInactive = isPlayerObserver(g_ViewedPlayer) || isPlayerObserver(i);
 		let hasAllies = g_Players.filter(player => player.isMutualAlly[g_ViewedPlayer]).length > 1;
 
 		diplomacySetupTexts(i, rowsize);
 		diplomacyFormatStanceButtons(i, myself || playerInactive || isCeasefireActive || g_Players[g_ViewedPlayer].teamsLocked);
 		// Tribute buttons do not need to be updated onTick, and should not because of massTributing
 		if (opening)
 			diplomacyFormatTributeButtons(i, myself || playerInactive);
 		diplomacyFormatAttackRequestButton(i, myself || playerInactive || isCeasefireActive || !hasAllies || !g_Players[i].isEnemy[g_ViewedPlayer]);
 		diplomacyFormatSpyRequestButton(i, myself || playerInactive || g_Players[i].isMutualAlly[g_ViewedPlayer] && hasSharedLos);
 	}
 
 	let diplomacyCeasefireCounter = Engine.GetGUIObjectByName("diplomacyCeasefireCounter");
 	diplomacyCeasefireCounter.caption = sprintf(
 		translateWithContext("ceasefire", "Remaining ceasefire time: %(time)s."),
 		{ "time": timeToString(simState.ceasefireTimeRemaining) }
 	);
 	diplomacyCeasefireCounter.hidden = !isCeasefireActive;
 }
 
 function diplomacySetupTexts(i, rowsize)
 {
 	// Apply offset
 	let row = Engine.GetGUIObjectByName("diplomacyPlayer[" + (i - 1) + "]");
 	let size = row.size;
 	size.top = rowsize * (i - 1);
 	size.bottom = rowsize * i;
 	row.size = size;
 	row.hidden = false;
 
 	row.sprite = "color:" + rgbToGuiColor(g_DisplayedPlayerColors[i], 32);
 
 	setOutcomeIcon(g_Players[i].state, "diplomacyPlayerOutcome[" + (i - 1) + "]");
 
 	let diplomacyPlayerName = Engine.GetGUIObjectByName("diplomacyPlayerName[" + (i - 1) + "]");
 	diplomacyPlayerName.caption = colorizePlayernameByID(i);
 	diplomacyPlayerName.tooltip = translateAISettings(g_GameAttributes.settings.PlayerData[i]);
 
 	Engine.GetGUIObjectByName("diplomacyPlayerCiv[" + (i - 1) + "]").caption = g_CivData[g_Players[i].civ].Name;
 
 	Engine.GetGUIObjectByName("diplomacyPlayerTeam[" + (i - 1) + "]").caption =
 		g_Players[i].team < 0 ? translateWithContext("team", "None") : g_Players[i].team + 1;
 
 	Engine.GetGUIObjectByName("diplomacyPlayerTheirs[" + (i - 1) + "]").caption =
 		i == g_ViewedPlayer ? "" :
 			g_Players[i].isAlly[g_ViewedPlayer] ?
 				translate("Ally") :
 				g_Players[i].isNeutral[g_ViewedPlayer] ? translate("Neutral") : translate("Enemy");
 }
 
 function diplomacyFormatStanceButtons(i, hidden)
 {
 	for (let stance of ["Ally", "Neutral", "Enemy"])
 	{
 		let button = Engine.GetGUIObjectByName("diplomacyPlayer" + stance + "[" + (i - 1) + "]");
 		button.hidden = hidden;
 		if (hidden)
 			continue;
 
 		let isCurrentStance = g_Players[g_ViewedPlayer]["is" + stance][i];
 		button.caption = isCurrentStance ? translate("x") : "";
 		button.enabled = controlsPlayer(g_ViewedPlayer) && !isCurrentStance;
 
 		button.onPress = (function(player, stance) { return function() {
 			Engine.PostNetworkCommand({
 				"type": "diplomacy",
 				"player": i,
 				"to": stance.toLowerCase()
 			});
 		}; })(i, stance);
 	}
 }
 
 function diplomacyFormatTributeButtons(i, hidden)
 {
-	let resCodes = g_ResourceData.GetCodes();
+	let resTribCodes = g_ResourceData.GetTributableCodes();
 	let r = 0;
-	for (let resCode of resCodes)
+	for (let resCode of resTribCodes)
 	{
 		let button = Engine.GetGUIObjectByName("diplomacyPlayer[" + (i - 1) + "]_tribute[" + r + "]");
 		if (!button)
 		{
 			warn("Current GUI limits prevent displaying more than " + r + " tribute buttons!");
 			break;
 		}
 
 		Engine.GetGUIObjectByName("diplomacyPlayer[" + (i - 1) + "]_tribute[" + r + "]_image").sprite = "stretched:session/icons/resources/" + resCode + ".png";
 		button.hidden = hidden;
 		setPanelObjectPosition(button, r, r + 1, 0);
 		++r;
 		if (hidden)
 			continue;
 
 		button.enabled = controlsPlayer(g_ViewedPlayer);
 		button.tooltip = formatTributeTooltip(i, resCode, 100);
 		button.onPress = (function(i, resCode, button) {
 			// Shift+click to send 500, shift+click+click to send 1000, etc.
 			// See INPUT_MASSTRIBUTING in input.js
 			let multiplier = 1;
 			return function() {
-				let isBatchTrainPressed = Engine.HotkeyIsPressed("session.masstribute");
-				if (isBatchTrainPressed)
+				let isMassTributePressed = Engine.HotkeyIsPressed("session.masstribute");
+				if (isMassTributePressed)
 				{
 					inputState = INPUT_MASSTRIBUTING;
 					multiplier += multiplier == 1 ? 4 : 5;
 				}
 
 				let amounts = {};
-				for (let res of resCodes)
+				for (let res of resTribCodes)
 					amounts[res] = 0;
 				amounts[resCode] = 100 * multiplier;
 
 				button.tooltip = formatTributeTooltip(i, resCode, amounts[resCode]);
 
 				// This is in a closure so that we have access to `player`, `amounts`, and `multiplier` without some
 				// evil global variable hackery.
 				g_FlushTributing = function() {
 					Engine.PostNetworkCommand({ "type": "tribute", "player": i, "amounts": amounts });
 					multiplier = 1;
 					button.tooltip = formatTributeTooltip(i, resCode, 100);
 				};
 
-				if (!isBatchTrainPressed)
+				if (!isMassTributePressed)
 					g_FlushTributing();
 			};
 		})(i, resCode, button);
 	}
 }
 
 function diplomacyFormatAttackRequestButton(i, hidden)
 {
 	let button = Engine.GetGUIObjectByName("diplomacyAttackRequest[" + (i - 1) + "]");
 	button.hidden = hidden;
 	if (hidden)
 		return;
 
 	button.enabled = controlsPlayer(g_ViewedPlayer);
 	button.tooltip = translate("Request your allies to attack this enemy");
 	button.onPress = (function(i) { return function() {
 		Engine.PostNetworkCommand({ "type": "attack-request", "source": g_ViewedPlayer, "player": i });
 	}; })(i);
 }
 
 function diplomacyFormatSpyRequestButton(i, hidden)
 {
 	let button = Engine.GetGUIObjectByName("diplomacySpyRequest[" + (i - 1) + "]");
 	let template = GetTemplateData("special/spy");
 	button.hidden = hidden || !template || !!GetSimState().players[g_ViewedPlayer].disabledTemplates["special/spy"];
 	if (button.hidden)
 		return;
 
 	button.enabled = controlsPlayer(g_ViewedPlayer) &&
 	                 !(g_BribeButtonsWaiting[g_ViewedPlayer] && g_BribeButtonsWaiting[g_ViewedPlayer].indexOf(i) != -1);
 	let modifier = "";
 	let tooltips = [translate("Bribe a random unit from this player and share its vision during a limited period.")];
 	if (!button.enabled)
 		modifier = "color:0 0 0 127:grayscale:";
 	else
 	{
 		if (template.requiredTechnology)
 		{
 			let technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", {
 				"tech": template.requiredTechnology,
 				"player": g_ViewedPlayer
 			});
 			if (!technologyEnabled)
 			{
 				modifier = "color:0 0 0 127:grayscale:";
 				button.enabled = false;
 				tooltips.push(getRequiredTechnologyTooltip(technologyEnabled, template.requiredTechnology, GetSimState().players[g_ViewedPlayer].civ));
 			}
 		}
 
 		if (template.cost)
 		{
 			let modifiedTemplate = clone(template);
 			for (let res in template.cost)
 				modifiedTemplate.cost[res] = Math.floor(GetSimState().players[i].spyCostMultiplier * template.cost[res]);
 			tooltips.push(getEntityCostTooltip(modifiedTemplate));
 			let neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
 				"cost": modifiedTemplate.cost,
 				"player": g_ViewedPlayer
 			});
 			let costRatio = Engine.GetTemplate("special/spy").VisionSharing.FailureCostRatio;
 			if (costRatio > 0)
 			{
 				tooltips.push(translate("A failed bribe will cost you:"));
 				for (let res in modifiedTemplate.cost)
 					modifiedTemplate.cost[res] = Math.floor(costRatio * modifiedTemplate.cost[res]);
 				tooltips.push(getEntityCostTooltip(modifiedTemplate));
 			}
 
 			if (neededResources)
 			{
 				if (button.enabled)
 					modifier = resourcesToAlphaMask(neededResources) + ":";
 				button.enabled = false;
 				tooltips.push(getNeededResourcesTooltip(neededResources));
 			}
 		}
 	}
 	let icon = Engine.GetGUIObjectByName("diplomacySpyRequestImage[" + (i - 1) + "]");
 	icon.sprite = modifier + "stretched:session/icons/bribes.png";
 	button.tooltip = tooltips.filter(tip => tip).join("\n");
 	button.onPress = (function(i, button) { return function() {
 		Engine.PostNetworkCommand({ "type": "spy-request", "source": g_ViewedPlayer, "player": i });
 		if (!g_BribeButtonsWaiting[g_ViewedPlayer])
 			g_BribeButtonsWaiting[g_ViewedPlayer] = [];
 		// Don't push i twice
 		if (g_BribeButtonsWaiting[g_ViewedPlayer].indexOf(i) == -1)
 			g_BribeButtonsWaiting[g_ViewedPlayer].push(i);
 		diplomacyFormatSpyRequestButton(i, false);
 	}; })(i, button);
 }
 
 function resizeTradeDialog()
 {
 	let dialog = Engine.GetGUIObjectByName("tradeDialogPanel");
 	let size = dialog.size;
 	let width = size.right - size.left;
 
+	let resTradCodesLength = g_ResourceData.GetTradableCodes().length;
+	Engine.GetGUIObjectByName("tradeDialogPanelTrade").hidden = !resTradCodesLength;
+
+	let resBarterCodesLength = g_ResourceData.GetBarterableCodes().length;
+	Engine.GetGUIObjectByName("tradeDialogPanelBarter").hidden = !resBarterCodesLength;
+
 	let tradeSize = Engine.GetGUIObjectByName("tradeResource[0]").size;
-	width += g_ResourceData.GetCodes().length * (tradeSize.right - tradeSize.left);
+	let length = Math.max(resTradCodesLength, resBarterCodesLength);
+	width += length * (tradeSize.right - tradeSize.left);
 
 	size.left = -width / 2;
 	size.right = width / 2;
 	dialog.size = size;
 }
 
 function openTrade()
 {
 	closeOpenDialogs();
 
 	if (g_ViewedPlayer < 1)
 		return;
 
 	g_IsTradeOpen = true;
 
 	let proba = Engine.GuiInterfaceCall("GetTradingGoods", g_ViewedPlayer);
 	let button = {};
-	let resCodes = g_ResourceData.GetCodes();
-	let currTradeSelection = resCodes[0];
+	let resTradeCodes = g_ResourceData.GetTradableCodes();
+	let resBarterCodes = g_ResourceData.GetBarterableCodes();
+	let currTradeSelection = resTradeCodes[0];
 
 	let updateTradeButtons = function()
 	{
 		for (let res in button)
 		{
 			button[res].label.caption = proba[res] + "%";
 
 			button[res].sel.hidden = !controlsPlayer(g_ViewedPlayer) || res != currTradeSelection;
 			button[res].up.hidden = !controlsPlayer(g_ViewedPlayer) || res == currTradeSelection || proba[res] == 100 || proba[currTradeSelection] == 0;
 			button[res].dn.hidden = !controlsPlayer(g_ViewedPlayer) || res == currTradeSelection || proba[res] == 0 || proba[currTradeSelection] == 100;
 		}
 	};
 
-	hideRemaining("tradeResources", resCodes.length);
+	hideRemaining("tradeResources", resTradeCodes.length);
 	Engine.GetGUIObjectByName("tradeHelp").hidden = false;
 
-	for (let i = 0; i < resCodes.length; ++i)
+
+	for (let i = 0; i < resBarterCodes.length; ++i)
 	{
-		let resCode = resCodes[i];
+		let resBarterCode = resBarterCodes[i];
 
 		let barterResource = Engine.GetGUIObjectByName("barterResource[" + i + "]");
 		if (!barterResource)
 		{
 			 warn("Current GUI limits prevent displaying more than " + i + " resources in the barter dialog!");
 			 break;
 		}
 
-		// Barter:
-		barterOpenCommon(resCode, i, "barter");
+		barterOpenCommon(resBarterCode, i, "barter");
 		setPanelObjectPosition(barterResource, i, i + 1);
+	}
+
+	for (let i = 0; i < resTradeCodes.length; ++i)
+	{
+		let resTradeCode = resTradeCodes[i];
 
-		// Trade:
 		let tradeResource = Engine.GetGUIObjectByName("tradeResource[" + i + "]");
 		if (!tradeResource)
 		{
 			 warn("Current GUI limits prevent displaying more than " + i + " resources in the trading goods selection dialog!");
 			 break;
 		}
 
 		setPanelObjectPosition(tradeResource, i, i + 1);
 
 		let icon = Engine.GetGUIObjectByName("tradeResourceIcon[" + i + "]");
-		icon.sprite = "stretched:session/icons/resources/" + resCode + ".png";
+		icon.sprite = "stretched:session/icons/resources/" + resTradeCode + ".png";
 
 		let buttonUp = Engine.GetGUIObjectByName("tradeArrowUp[" + i + "]");
 		let buttonDn = Engine.GetGUIObjectByName("tradeArrowDn[" + i + "]");
 
-		button[resCode] = {
+		button[resTradeCode] = {
 			"up": buttonUp,
 			"dn": buttonDn,
 			"label": Engine.GetGUIObjectByName("tradeResourceText[" + i + "]"),
 			"sel": Engine.GetGUIObjectByName("tradeResourceSelection[" + i + "]")
 		};
 
-		proba[resCode] = proba[resCode] || 0;
+		proba[resTradeCode] = proba[resTradeCode] || 0;
 
 		let buttonResource = Engine.GetGUIObjectByName("tradeResourceButton[" + i + "]");
 		buttonResource.enabled = controlsPlayer(g_ViewedPlayer);
 		buttonResource.onPress = (resource => {
 			return () => {
 				if (Engine.HotkeyIsPressed("session.fulltradeswap"))
 				{
-					for (let res of resCodes)
+					for (let res of resTradeCodes)
 						proba[res] = 0;
 					proba[resource] = 100;
 					Engine.PostNetworkCommand({ "type": "set-trading-goods", "tradingGoods": proba });
 				}
 				currTradeSelection = resource;
 				updateTradeButtons();
 			};
-		})(resCode);
+		})(resTradeCode);
 
 		buttonUp.enabled = controlsPlayer(g_ViewedPlayer);
 		buttonUp.onPress = (resource => {
 			return () => {
 				proba[resource] += Math.min(STEP, proba[currTradeSelection]);
 				proba[currTradeSelection] -= Math.min(STEP, proba[currTradeSelection]);
 				Engine.PostNetworkCommand({ "type": "set-trading-goods", "tradingGoods": proba });
 				updateTradeButtons();
 			};
-		})(resCode);
+		})(resTradeCode);
 
 		buttonDn.enabled = controlsPlayer(g_ViewedPlayer);
 		buttonDn.onPress = (resource => {
 			return () => {
 				proba[currTradeSelection] += Math.min(STEP, proba[resource]);
 				proba[resource] -= Math.min(STEP, proba[resource]);
 				Engine.PostNetworkCommand({ "type": "set-trading-goods", "tradingGoods": proba });
 				updateTradeButtons();
 			};
-		})(resCode);
+		})(resTradeCode);
 	}
 
 	updateTradeButtons();
 	updateTraderTexts();
 
 	Engine.GetGUIObjectByName("tradeDialogPanel").hidden = false;
 }
 
 function updateTraderTexts()
 {
 	let traderNumber = Engine.GuiInterfaceCall("GetTraderNumber", g_ViewedPlayer);
 	Engine.GetGUIObjectByName("traderCountText").caption = getIdleLandTradersText(traderNumber) + "\n\n" + getIdleShipTradersText(traderNumber);
 }
 
 function initBarterButtons()
 {
-	g_BarterSell = g_ResourceData.GetCodes()[0];
+	let resBartCodes = g_ResourceData.GetBarterableCodes();
+	g_BarterSell = resBartCodes.length ? resBartCodes[0] : undefined;
 }
 
 /**
  * Code common to both the Barter Panel and the Trade/Barter Dialog, that
  * only needs to be run when the panel or dialog is opened by the player.
  *
  * @param {string} resourceCode
  * @param {number} idx - Element index within its set
  * @param {string} prefix - Common prefix of the gui elements to be worked upon
  */
 function barterOpenCommon(resourceCode, idx, prefix)
 {
 	let barterButton = {};
 	for (let action of g_BarterActions)
 		barterButton[action] = Engine.GetGUIObjectByName(prefix + action + "Button[" + idx + "]");
 
 	let resource = resourceNameWithinSentence(resourceCode);
 	barterButton.Buy.tooltip = sprintf(translate("Buy %(resource)s"), { "resource": resource });
 	barterButton.Sell.tooltip = sprintf(translate("Sell %(resource)s"), { "resource": resource });
 
 	barterButton.Sell.onPress = function() {
 		g_BarterSell = resourceCode;
 		updateSelectionDetails();
 		updateBarterButtons();
 	};
 }
 
 /**
  * Code common to both the Barter Panel and the Trade/Barter Dialog, that
  * needs to be run on simulation update and when relevant hotkeys
  * (i.e. massbarter) are pressed.
  *
  * @param {string} resourceCode
  * @param {number} idx - Element index within its set
  * @param {string} prefix - Common prefix of the gui elements to be worked upon
  * @param {number} player
  */
 function barterUpdateCommon(resourceCode, idx, prefix, player)
 {
 	let barterButton = {};
 	let barterIcon = {};
 	let barterAmount = {};
 	for (let action of g_BarterActions)
 	{
 		barterButton[action] = Engine.GetGUIObjectByName(prefix + action + "Button[" + idx + "]");
 		barterIcon[action] = Engine.GetGUIObjectByName(prefix + action + "Icon[" + idx + "]");
 		barterAmount[action] = Engine.GetGUIObjectByName(prefix + action + "Amount[" + idx + "]");
 	}
 	let selectionIcon = Engine.GetGUIObjectByName(prefix + "SellSelection[" + idx + "]");
 
 	let amountToSell = g_BarterResourceSellQuantity;
 	if (Engine.HotkeyIsPressed("session.massbarter"))
 		amountToSell *= g_BarterMultiplier;
 
 	let isSelected = resourceCode == g_BarterSell;
 	let grayscale = isSelected ? "color:0 0 0 100:grayscale:" : "";
 
 	// Select color of the sell button
 	let neededRes = {};
 	neededRes[resourceCode] = amountToSell;
 	let canSellCurrent = Engine.GuiInterfaceCall("GetNeededResources", {
 		"cost": neededRes,
 		"player": player
 	}) ? "color:255 0 0 80:" : "";
 
 	// Select color of the buy button
 	neededRes = {};
 	neededRes[g_BarterSell] = amountToSell;
 	let canBuyAny = Engine.GuiInterfaceCall("GetNeededResources", {
 		"cost": neededRes,
 		"player": player
 	}) ? "color:255 0 0 80:" : "";
 
 	barterIcon.Sell.sprite = canSellCurrent + "stretched:" + grayscale + "session/icons/resources/" + resourceCode + ".png";
 	barterIcon.Buy.sprite = canBuyAny + "stretched:" + grayscale + "session/icons/resources/" + resourceCode + ".png";
 
 	barterAmount.Sell.caption = "-" + amountToSell;
 	let prices = GetSimState().players[player].barterPrices;
 	barterAmount.Buy.caption = "+" + Math.round(prices.sell[g_BarterSell] / prices.buy[resourceCode] * amountToSell);
 
 	barterButton.Buy.onPress = function() {
 		Engine.PostNetworkCommand({
 			"type": "barter",
 			"sell": g_BarterSell,
 			"buy": resourceCode,
 			"amount": amountToSell
 		});
 	};
 
 	barterButton.Buy.hidden = isSelected;
 	barterButton.Buy.enabled = controlsPlayer(player);
 	barterButton.Sell.hidden = false;
 	selectionIcon.hidden = !isSelected;
 }
 
 function updateBarterButtons()
 {
 	let playerState = GetSimState().players[g_ViewedPlayer];
 	if (!playerState)
 		return;
 
 	let canBarter = playerState.canBarter;
 	Engine.GetGUIObjectByName("barterNoMarketsMessage").hidden = canBarter;
 	Engine.GetGUIObjectByName("barterResources").hidden = !canBarter;
 	Engine.GetGUIObjectByName("barterHelp").hidden = !canBarter;
 
 	if (canBarter)
-		g_ResourceData.GetCodes().forEach((resCode, i) => { barterUpdateCommon(resCode, i, "barter", g_ViewedPlayer); });
+		g_ResourceData.GetBarterableCodes().forEach((resCode, i) => {
+			barterUpdateCommon(resCode, i, "barter", g_ViewedPlayer);
+		});
 }
 
 function getIdleLandTradersText(traderNumber)
 {
 	let active = traderNumber.landTrader.trading;
 	let garrisoned = traderNumber.landTrader.garrisoned;
 	let inactive = traderNumber.landTrader.total - active - garrisoned;
 
 	let messageTypes = {
 		"active": {
 			"garrisoned": {
 				"no-inactive": translate("%(openingTradingString)s, and %(garrisonedString)s."),
 				"inactive": translate("%(openingTradingString)s, %(garrisonedString)s, and %(inactiveString)s.")
 			},
 			"no-garrisoned": {
 				"no-inactive": translate("%(openingTradingString)s."),
 				"inactive": translate("%(openingTradingString)s, and %(inactiveString)s.")
 			}
 		},
 		"no-active": {
 			"garrisoned": {
 				"no-inactive": translate("%(openingGarrisonedString)s."),
 				"inactive": translate("%(openingGarrisonedString)s, and %(inactiveString)s.")
 			},
 			"no-garrisoned": {
 				"inactive": translatePlural("There is %(inactiveString)s.", "There are %(inactiveString)s.", inactive),
 				"no-inactive": translate("There are no land traders.")
 			}
 		}
 	};
 
 	let message = messageTypes[active ? "active" : "no-active"][garrisoned ? "garrisoned" : "no-garrisoned"][inactive ? "inactive" : "no-inactive"];
 
 	let activeString = sprintf(
 		translatePlural(
 			"There is %(numberTrading)s land trader trading",
 			"There are %(numberTrading)s land traders trading",
 			active
 		),
 		{ "numberTrading": active }
 	);
 
 	let inactiveString = sprintf(
 		active || garrisoned ?
 			translatePlural(
 				"%(numberOfLandTraders)s inactive",
 				"%(numberOfLandTraders)s inactive",
 				inactive
 			) :
 			translatePlural(
 				"%(numberOfLandTraders)s land trader inactive",
 				"%(numberOfLandTraders)s land traders inactive",
 				inactive
 			),
 		{ "numberOfLandTraders": inactive }
 	);
 
 	let garrisonedString = sprintf(
 		active || inactive ?
 			translatePlural(
 				"%(numberGarrisoned)s garrisoned on a trading merchant ship",
 				"%(numberGarrisoned)s garrisoned on a trading merchant ship",
 				garrisoned
 			) :
 			translatePlural(
 				"There is %(numberGarrisoned)s land trader garrisoned on a trading merchant ship",
 				"There are %(numberGarrisoned)s land traders garrisoned on a trading merchant ship",
 				garrisoned
 			),
 		{ "numberGarrisoned": garrisoned }
 	);
 
 	return sprintf(message, {
 		"openingTradingString": activeString,
 		"openingGarrisonedString": garrisonedString,
 		"garrisonedString": garrisonedString,
 		"inactiveString": coloredText(inactiveString, g_IdleTraderTextColor)
 	});
 }
 
 function getIdleShipTradersText(traderNumber)
 {
 	let active = traderNumber.shipTrader.trading;
 	let inactive = traderNumber.shipTrader.total - active;
 
 	let messageTypes = {
 		"active": {
 			"inactive": translate("%(openingTradingString)s, and %(inactiveString)s."),
 			"no-inactive": translate("%(openingTradingString)s.")
 		},
 		"no-active": {
 			"inactive": translatePlural("There is %(inactiveString)s.", "There are %(inactiveString)s.", inactive),
 			"no-inactive": translate("There are no merchant ships.")
 		}
 	};
 
 	let message = messageTypes[active ? "active" : "no-active"][inactive ? "inactive" : "no-inactive"];
 
 	let activeString = sprintf(
 		translatePlural(
 			"There is %(numberTrading)s merchant ship trading",
 			"There are %(numberTrading)s merchant ships trading",
 			active
 		),
 		{ "numberTrading": active }
 	);
 
 	let inactiveString = sprintf(
 		active ?
 			translatePlural(
 				"%(numberOfShipTraders)s inactive",
 				"%(numberOfShipTraders)s inactive",
 				inactive
 			) :
 			translatePlural(
 				"%(numberOfShipTraders)s merchant ship inactive",
 				"%(numberOfShipTraders)s merchant ships inactive",
 				inactive
 			),
 		{ "numberOfShipTraders": inactive }
 	);
 
 	return sprintf(message, {
 		"openingTradingString": activeString,
 		"inactiveString": coloredText(inactiveString, g_IdleTraderTextColor)
 	});
 }
 
 function closeTrade()
 {
 	g_IsTradeOpen = false;
 	Engine.GetGUIObjectByName("tradeDialogPanel").hidden = true;
 }
 
 function toggleTrade()
 {
 	let open = g_IsTradeOpen;
 	closeOpenDialogs();
 
 	if (!open)
 		openTrade();
 }
 
 function toggleTutorial()
 {
 	let tutorialPanel = Engine.GetGUIObjectByName("tutorialPanel");
 	tutorialPanel.hidden = !tutorialPanel.hidden ||
 	                       !Engine.GetGUIObjectByName("tutorialText").caption;
 }
 
 function updateGameSpeedControl()
 {
 	Engine.GetGUIObjectByName("gameSpeedButton").hidden = g_IsNetworked;
 
 	let player = g_Players[Engine.GetPlayerID()];
 	g_GameSpeeds = getGameSpeedChoices(!player || player.state != "active");
 
 	let gameSpeed = Engine.GetGUIObjectByName("gameSpeed");
 	gameSpeed.list = g_GameSpeeds.Title;
 	gameSpeed.list_data = g_GameSpeeds.Speed;
 
 	let simRate = Engine.GetSimRate();
 
 	let gameSpeedIdx = g_GameSpeeds.Speed.indexOf(+simRate.toFixed(2));
 	if (gameSpeedIdx == -1)
 		warn("Unknown gamespeed:" + simRate);
 
 	gameSpeed.selected = gameSpeedIdx != -1 ? gameSpeedIdx : g_GameSpeeds.Default;
 	gameSpeed.onSelectionChange = function() {
 		changeGameSpeed(+this.list_data[this.selected]);
 	};
 }
 
 function toggleGameSpeed()
 {
 	let gameSpeed = Engine.GetGUIObjectByName("gameSpeed");
 	gameSpeed.hidden = !gameSpeed.hidden;
 }
 
 function toggleObjectives()
 {
 	let open = g_IsObjectivesOpen;
 	closeOpenDialogs();
 
 	if (!open)
 		openObjectives();
 }
 
 function openObjectives()
 {
 	g_IsObjectivesOpen = true;
 
 	let player = g_Players[Engine.GetPlayerID()];
 	let playerState = player && player.state;
 	let isActive = !playerState || playerState == "active";
 
 	Engine.GetGUIObjectByName("gameDescriptionText").caption = getGameDescription();
 
 	let objectivesPlayerstate = Engine.GetGUIObjectByName("objectivesPlayerstate");
 	objectivesPlayerstate.hidden = isActive;
 	objectivesPlayerstate.caption = g_PlayerStateMessages[playerState] || "";
 
 	let gameDescription = Engine.GetGUIObjectByName("gameDescription");
 	let gameDescriptionSize = gameDescription.size;
 	gameDescriptionSize.top = Engine.GetGUIObjectByName(
 		isActive ? "objectivesTitle" : "objectivesPlayerstate").size.bottom;
 	gameDescription.size = gameDescriptionSize;
 
 	Engine.GetGUIObjectByName("objectivesPanel").hidden = false;
 }
 
 function closeObjectives()
 {
 	g_IsObjectivesOpen = false;
 	Engine.GetGUIObjectByName("objectivesPanel").hidden = true;
 }
 
 /**
  * Allows players to see their own summary.
  * If they have shared ally vision researched, they are able to see the summary of there allies too.
  */
 function openGameSummary()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 	Engine.PushGuiPage(
 		"page_summary.xml",
 		{
 			"sim": {
 				"mapSettings": g_GameAttributes.settings,
 				"playerStates": extendedSimState.players.filter((state, player) =>
 					g_IsObserver || player == 0 || player == g_ViewedPlayer ||
 					extendedSimState.players[g_ViewedPlayer].hasSharedLos && g_Players[player].isMutualAlly[g_ViewedPlayer]),
 				"timeElapsed": extendedSimState.timeElapsed
 			},
 			"gui": {
 				"dialog": true,
 				"isInGame": true
 			},
 			"selectedData": g_SummarySelectedData
 		},
 		resumeGameAndSaveSummarySelectedData);
 }
 
 function openStrucTree(page)
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	Engine.PushGuiPage(
 		page,
 		{
 			"civ": g_CivInfo.civ || g_Players[g_ViewedPlayer].civ
 			// TODO add info about researched techs and unlocked entities
 		},
 		storeCivInfoPage);
 }
 
 function storeCivInfoPage(data)
 {
 	if (data.nextPage)
 		Engine.PushGuiPage(
 			data.nextPage,
 			{ "civ": data.civ },
 			storeCivInfoPage);
 	else
 	{
 		g_CivInfo = data;
 		resumeGame();
 	}
 }
 
 /**
  * Pause or resume the game.
  *
  * @param explicit - true if the player explicitly wants to pause or resume.
  * If this argument isn't set, a multiplayer game won't be paused and the pause overlay
  * won't be shown in single player.
  */
 function pauseGame(pause = true, explicit = false)
 {
 	// The NetServer only supports pausing after all clients finished loading the game.
 	if (g_IsNetworked && (!explicit || !g_IsNetworkedActive))
 		return;
 
 	if (explicit)
 		g_Paused = pause;
 
 	Engine.SetPaused(g_Paused || pause, !!explicit);
 
 	if (g_IsNetworked)
 	{
 		setClientPauseState(Engine.GetPlayerGUID(), g_Paused);
 		return;
 	}
 
 	updatePauseOverlay();
 }
 
 function resumeGame(explicit = false)
 {
 	pauseGame(false, explicit);
 }
 
 function resumeGameAndSaveSummarySelectedData(data)
 {
 	g_SummarySelectedData = data.summarySelectedData;
 	resumeGame(data.explicitResume);
 }
 
 /**
  * Called when the current player toggles a pause button.
  */
 function togglePause()
 {
 	if (!Engine.GetGUIObjectByName("pauseButton").enabled)
 		return;
 
 	closeOpenDialogs();
 
 	pauseGame(!g_Paused, true);
 }
 
 /**
  * Called when a client pauses or resumes in a multiplayer game.
  */
 function setClientPauseState(guid, paused)
 {
 	// Update the list of pausing clients.
 	let index = g_PausingClients.indexOf(guid);
 	if (paused && index == -1)
 		g_PausingClients.push(guid);
 	else if (!paused && index != -1)
 		g_PausingClients.splice(index, 1);
 
 	updatePauseOverlay();
 
 	Engine.SetPaused(!!g_PausingClients.length, false);
 }
 
 /**
  * Update the pause overlay.
  */
 function updatePauseOverlay()
 {
 	Engine.GetGUIObjectByName("pauseButton").caption = g_Paused ? translate("Resume") : translate("Pause");
 	Engine.GetGUIObjectByName("resumeMessage").hidden = !g_Paused;
 
 	Engine.GetGUIObjectByName("pausedByText").hidden = !g_IsNetworked;
 	Engine.GetGUIObjectByName("pausedByText").caption = sprintf(translate("Paused by %(players)s"),
 		{ "players": g_PausingClients.map(guid => colorizePlayernameByGUID(guid)).join(translateWithContext("Separator for a list of players", ", ")) });
 
 	Engine.GetGUIObjectByName("pauseOverlay").hidden = !(g_Paused || g_PausingClients.length);
 	Engine.GetGUIObjectByName("pauseOverlay").onPress = g_Paused ? togglePause : function() {};
 }
 
 function openManual()
 {
 	closeOpenDialogs();
 	pauseGame();
 	Engine.PushGuiPage("page_manual.xml", {}, resumeGame);
 }
 
 function closeOpenDialogs()
 {
 	closeMenu();
 	closeChat();
 	closeDiplomacy();
 	closeTrade();
 	closeObjectives();
 }
 
 function formatTributeTooltip(playerID, resourceCode, amount)
 {
 	return sprintf(translate("Tribute %(resourceAmount)s %(resourceType)s to %(playerName)s. Shift-click to tribute %(greaterAmount)s."), {
 		"resourceAmount": amount,
 		"resourceType": resourceNameWithinSentence(resourceCode),
 		"playerName": colorizePlayernameByID(playerID),
 		"greaterAmount": amount < 500 ? 500 : amount + 500
 	});
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/selection_panels.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/selection_panels.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/gui/session/selection_panels.js	(revision 22970)
@@ -1,1182 +1,1182 @@
 /**
  * Contains the layout and button settings per selection panel
  *
  * getItems returns a list of basic items used to fill the panel.
  * This method is obligated. If the items list is empty, the panel
  * won't be rendered.
  *
  * Then there's a loop over all items provided. In the loop,
  * the item and some other standard data is added to a data object.
  *
  * The standard data is
  * {
  *   "i":              index
  *   "item":           item coming from the getItems function
  *   "playerState":    playerState
  *   "unitEntStates":  states of the selected entities
  *   "rowLength":      rowLength
  *   "numberOfItems":  number of items that will be processed
  *   "button":         gui Button object
  *   "icon":           gui Icon object
  *   "guiSelection":   gui button Selection overlay
  *   "countDisplay":   gui caption space
  * }
  *
  * Then for every data object, the setupButton function is called which
  * sets the view and handlers of the button.
  */
 
 // Cache some formation info
 // Available formations per player
 let g_AvailableFormations = new Map();
 let g_FormationsInfo = new Map();
 
 let g_SelectionPanels = {};
 
 g_SelectionPanels.Alert = {
 	"getMaxNumberOfItems": function()
 	{
 		return 2;
 	},
 	"getItems": function(unitEntStates)
 	{
 		return unitEntStates.some(state => !!state.alertRaiser) ? ["raise", "end"] : [];
 	},
 	"setupButton": function(data)
 	{
 		data.button.onPress = function() {
 			switch (data.item)
 			{
 			case "raise":
 				raiseAlert();
 				return;
 			case "end":
 				endOfAlert();
 				return;
 			}
 		};
 
 		switch (data.item)
 		{
 		case "raise":
 			data.icon.sprite = "stretched:session/icons/bell_level1.png";
 			data.button.tooltip = translate("Raise an alert!");
 			break;
 		case "end":
 			data.button.tooltip = translate("End of alert.");
 			data.icon.sprite = "stretched:session/icons/bell_level0.png";
 			break;
 		}
 		data.button.enabled = controlsPlayer(data.player);
 
 		setPanelObjectPosition(data.button, this.getMaxNumberOfItems() - data.i, data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Barter = {
 	"getMaxNumberOfItems": function()
 	{
 		return 4;
 	},
 	"rowLength": 4,
 	"conflictsWith": ["Garrison"],
 	"getItems": function(unitEntStates)
 	{
 		// If more than `rowLength` resources, don't display icons.
-		if (unitEntStates.every(state => !state.isBarterMarket) || g_ResourceData.GetCodes().length > this.rowLength)
+		if (unitEntStates.every(state => !state.isBarterMarket) || g_ResourceData.GetBarterableCodes().length > this.rowLength)
 			return [];
-		return g_ResourceData.GetCodes();
+		return g_ResourceData.GetBarterableCodes();
 	},
 	"setupButton": function(data)
 	{
 		barterOpenCommon(data.item, data.i, "unitBarter");
 		barterUpdateCommon(data.item, data.i, "unitBarter", data.player);
 
 		let button = {};
 		for (let action of g_BarterActions)
 			button[action] = Engine.GetGUIObjectByName("unitBarter" + action + "Button[" + data.i + "]");
 
 		setPanelObjectPosition(button.Sell, data.i, data.rowLength);
 		setPanelObjectPosition(button.Buy, data.i + data.rowLength, data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Command = {
 	"getMaxNumberOfItems": function()
 	{
 		return 6;
 	},
 	"getItems": function(unitEntStates)
 	{
 		let commands = [];
 
 		for (let command in g_EntityCommands)
 		{
 			let info = g_EntityCommands[command].getInfo(unitEntStates);
 			if (info)
 			{
 				info.name = command;
 				commands.push(info);
 			}
 		}
 		return commands;
 	},
 	"setupButton": function(data)
 	{
 		data.button.tooltip = data.item.tooltip;
 
 		data.button.onPress = function() {
 			if (data.item.callback)
 				data.item.callback(data.item);
 			else
 				performCommand(data.unitEntStates, data.item.name);
 		};
 
 		data.countDisplay.caption = data.item.count || "";
 
 		data.button.enabled =
 			g_IsObserver && data.item.name == "focus-rally" ||
 			controlsPlayer(data.player) && (data.item.name != "delete" ||
 				data.unitEntStates.some(state => !isUndeletable(state)));
 
 		data.icon.sprite = "stretched:session/icons/" + data.item.icon;
 
 		let size = data.button.size;
 		// relative to the center ( = 50%)
 		size.rleft = 50;
 		size.rright = 50;
 		// offset from the center calculation, count on square buttons, so size.bottom is the width too
 		size.left = (data.i - data.numberOfItems / 2) * (size.bottom + 1);
 		size.right = size.left + size.bottom;
 		data.button.size = size;
 		return true;
 	}
 };
 
 g_SelectionPanels.AllyCommand = {
 	"getMaxNumberOfItems": function()
 	{
 		return 2;
 	},
 	"conflictsWith": ["Command"],
 	"getItems": function(unitEntStates)
 	{
 		let commands = [];
 		for (let command in g_AllyEntityCommands)
 			for (let state of unitEntStates)
 			{
 				let info = g_AllyEntityCommands[command].getInfo(state);
 				if (info)
 				{
 					info.name = command;
 					commands.push(info);
 					break;
 				}
 			}
 		return commands;
 	},
 	"setupButton": function(data)
 	{
 		data.button.tooltip = data.item.tooltip;
 
 		data.button.onPress = function() {
 			if (data.item.callback)
 				data.item.callback(data.item);
 			else
 				performAllyCommand(data.unitEntStates[0].id, data.item.name);
 		};
 
 		data.countDisplay.caption = data.item.count || "";
 
 		data.button.enabled = !!data.item.count;
 
 		let grayscale = data.button.enabled ? "" : "grayscale:";
 		data.icon.sprite = "stretched:" + grayscale + "session/icons/" + data.item.icon;
 
 		let size = data.button.size;
 		// relative to the center ( = 50%)
 		size.rleft = 50;
 		size.rright = 50;
 		// offset from the center calculation, count on square buttons, so size.bottom is the width too
 		size.left = (data.i - data.numberOfItems / 2) * (size.bottom + 1);
 		size.right = size.left + size.bottom;
 		data.button.size = size;
 
 		return true;
 	}
 };
 
 g_SelectionPanels.Construction = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function()
 	{
 		return getAllBuildableEntitiesFromSelection();
 	},
 	"setupButton": function(data)
 	{
 		let template = GetTemplateData(data.item);
 		if (!template)
 			return false;
 
 		let technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", {
 			"tech": template.requiredTechnology,
 			"player": data.player
 		});
 
 		let neededResources;
 		if (template.cost)
 			neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
 				"cost": multiplyEntityCosts(template, 1),
 				"player": data.player
 			});
 
 		data.button.onPress = function() { startBuildingPlacement(data.item, data.playerState); };
 		data.button.onPressRight = function() { showTemplateDetails(data.item); };
 
 		let tooltips = [
 			getEntityNamesFormatted,
 			getVisibleEntityClassesFormatted,
 			getAurasTooltip,
 			getEntityTooltip,
 			getEntityCostTooltip,
 			getGarrisonTooltip,
 			getPopulationBonusTooltip,
 			showTemplateViewerOnRightClickTooltip
 		].map(func => func(template));
 
 		let limits = getEntityLimitAndCount(data.playerState, data.item);
 		tooltips.push(
 			formatLimitString(limits.entLimit, limits.entCount, limits.entLimitChangers),
 			getRequiredTechnologyTooltip(technologyEnabled, template.requiredTechnology, GetSimState().players[data.player].civ),
 			getNeededResourcesTooltip(neededResources));
 
 		data.button.tooltip = tooltips.filter(tip => tip).join("\n");
 
 		let modifier = "";
 		if (!technologyEnabled || limits.canBeAddedCount == 0)
 		{
 			data.button.enabled = false;
 			modifier += "color:0 0 0 127:grayscale:";
 		}
 		else if (neededResources)
 		{
 			data.button.enabled = false;
 			modifier += resourcesToAlphaMask(neededResources) + ":";
 		}
 		else
 			data.button.enabled = controlsPlayer(data.player);
 
 		if (template.icon)
 			data.icon.sprite = modifier + "stretched:session/portraits/" + template.icon;
 
 		setPanelObjectPosition(data.button, data.i + getNumberOfRightPanelButtons(), data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Formation = {
 	"getMaxNumberOfItems": function()
 	{
 		return 16;
 	},
 	"rowLength": 4,
 	"conflictsWith": ["Garrison"],
 	"getItems": function(unitEntStates)
 	{
 		if (unitEntStates.some(state => !hasClass(state, "Unit")))
 			return [];
 
 		if (!g_AvailableFormations.has(unitEntStates[0].player))
 			g_AvailableFormations.set(unitEntStates[0].player, Engine.GuiInterfaceCall("GetAvailableFormations", unitEntStates[0].player));
 
 		let availableFormations = g_AvailableFormations.get(unitEntStates[0].player);
 
 		// Hide the panel if all formations are disabled
 		if (availableFormations.some(formation => canMoveSelectionIntoFormation(formation)))
 			return availableFormations;
 
 		return [];
 	},
 	"setupButton": function(data)
 	{
 		if (!g_FormationsInfo.has(data.item))
 			g_FormationsInfo.set(data.item, Engine.GuiInterfaceCall("GetFormationInfoFromTemplate", { "templateName": data.item }));
 
 		let formationInfo = g_FormationsInfo.get(data.item);
 		let formationOk = canMoveSelectionIntoFormation(data.item);
 		let unitIds = data.unitEntStates.map(state => state.id);
 		let formationSelected = Engine.GuiInterfaceCall("IsFormationSelected", {
 			"ents": unitIds,
 			"formationTemplate": data.item
 		});
 
 		data.button.onPress = function() {
 			performFormation(unitIds, data.item);
 		};
 
 		let tooltip = translate(formationInfo.name);
 		if (!formationOk && formationInfo.tooltip)
 			tooltip += "\n" + coloredText(translate(formationInfo.tooltip), "red");
 		data.button.tooltip = tooltip;
 
 		data.button.enabled = formationOk && controlsPlayer(data.player);
 		let grayscale = formationOk ? "" : "grayscale:";
 		data.guiSelection.hidden = !formationSelected;
 		data.icon.sprite = "stretched:" + grayscale + "session/icons/" + formationInfo.icon;
 
 		setPanelObjectPosition(data.button, data.i, data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Garrison = {
 	"getMaxNumberOfItems": function()
 	{
 		return 12;
 	},
 	"rowLength": 4,
 	"conflictsWith": ["Barter"],
 	"getItems": function(unitEntStates)
 	{
 		if (unitEntStates.every(state => !state.garrisonHolder))
 			return [];
 
 		let groups = new EntityGroups();
 
 		for (let state of unitEntStates)
 			if (state.garrisonHolder)
 				groups.add(state.garrisonHolder.entities);
 
 		return groups.getEntsGrouped();
 	},
 	"setupButton": function(data)
 	{
 		let entState = GetEntityState(data.item.ents[0]);
 
 		let template = GetTemplateData(entState.template);
 		if (!template)
 			return false;
 
 		data.button.onPress = function() {
 			unloadTemplate(template.selectionGroupName || entState.template, entState.player);
 		};
 
 		data.countDisplay.caption = data.item.ents.length || "";
 
 		let canUngarrison =
 			g_ViewedPlayer == data.player ||
 			g_ViewedPlayer == entState.player;
 
 		data.button.enabled = canUngarrison && controlsPlayer(g_ViewedPlayer);
 
 		data.button.tooltip = (canUngarrison || g_IsObserver ?
 			sprintf(translate("Unload %(name)s"), { "name": getEntityNames(template) }) + "\n" +
 			translate("Single-click to unload 1. Shift-click to unload all of this type.") :
 			getEntityNames(template)) + "\n" +
 			sprintf(translate("Player: %(playername)s"), {
 				"playername": g_Players[entState.player].name
 			});
 
 		data.guiSelection.sprite = getPlayerHighlightColor(entState.player);
 		data.button.sprite_disabled = data.button.sprite;
 
 		// Selection panel buttons only appear disabled if they
 		// also appear disabled to the owner of the building.
 		data.icon.sprite =
 			(canUngarrison || g_IsObserver ? "" : "grayscale:") +
 			"stretched:session/portraits/" + template.icon;
 
 		setPanelObjectPosition(data.button, data.i, data.rowLength);
 
 		return true;
 	}
 };
 
 g_SelectionPanels.Gate = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function(unitEntStates)
 	{
 		let hideLocked = unitEntStates.every(state => !state.gate || !state.gate.locked);
 		let hideUnlocked = unitEntStates.every(state => !state.gate || state.gate.locked);
 
 		if (hideLocked && hideUnlocked)
 			return [];
 
 		return [
 			{
 				"hidden": hideLocked,
 				"tooltip": translate("Lock Gate"),
 				"icon": "session/icons/lock_locked.png",
 				"locked": true
 			},
 			{
 				"hidden": hideUnlocked,
 				"tooltip": translate("Unlock Gate"),
 				"icon": "session/icons/lock_unlocked.png",
 				"locked": false
 			}
 		];
 	},
 	"setupButton": function(data)
 	{
 		data.button.onPress = function() { lockGate(data.item.locked); };
 		data.button.tooltip = data.item.tooltip;
 		data.button.enabled = controlsPlayer(data.player);
 		data.guiSelection.hidden = data.item.hidden;
 		data.icon.sprite = "stretched:" + data.item.icon;
 
 		setPanelObjectPosition(data.button, data.i + getNumberOfRightPanelButtons(), data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Pack = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function(unitEntStates)
 	{
 		let checks = {};
 		for (let state of unitEntStates)
 		{
 			if (!state.pack)
 				continue;
 
 			if (state.pack.progress == 0)
 			{
 				if (state.pack.packed)
 					checks.unpackButton = true;
 				else
 					checks.packButton = true;
 			}
 			else if (state.pack.packed)
 				checks.unpackCancelButton = true;
 			else
 				checks.packCancelButton = true;
 		}
 
 		let items = [];
 		if (checks.packButton)
 			items.push({
 				"packing": false,
 				"packed": false,
 				"tooltip": translate("Pack"),
 				"callback": function() { packUnit(true); }
 			});
 
 		if (checks.unpackButton)
 			items.push({
 				"packing": false,
 				"packed": true,
 				"tooltip": translate("Unpack"),
 				"callback": function() { packUnit(false); }
 			});
 
 		if (checks.packCancelButton)
 			items.push({
 				"packing": true,
 				"packed": false,
 				"tooltip": translate("Cancel Packing"),
 				"callback": function() { cancelPackUnit(true); }
 			});
 
 		if (checks.unpackCancelButton)
 			items.push({
 				"packing": true,
 				"packed": true,
 				"tooltip": translate("Cancel Unpacking"),
 				"callback": function() { cancelPackUnit(false); }
 			});
 
 		return items;
 	},
 	"setupButton": function(data)
 	{
 		data.button.onPress = function() {data.item.callback(data.item); };
 
 		data.button.tooltip = data.item.tooltip;
 
 		if (data.item.packing)
 			data.icon.sprite = "stretched:session/icons/cancel.png";
 		else if (data.item.packed)
 			data.icon.sprite = "stretched:session/icons/unpack.png";
 		else
 			data.icon.sprite = "stretched:session/icons/pack.png";
 
 		data.button.enabled = controlsPlayer(data.player);
 
 		setPanelObjectPosition(data.button, data.i + getNumberOfRightPanelButtons(), data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Queue = {
 	"getMaxNumberOfItems": function()
 	{
 		return 16;
 	},
 	/**
 	 * Returns a list of all items in the productionqueue of the selection
 	 * The first entry of every entity's production queue will come before
 	 * the second entry of every entity's production queue
 	 */
 	"getItems": function(unitEntStates)
 	{
 		let queue = [];
 		let foundNew = true;
 		for (let i = 0; foundNew; ++i)
 		{
 			foundNew = false;
 			for (let state of unitEntStates)
 			{
 				if (!state.production || !state.production.queue[i])
 					continue;
 				queue.push({
 					"producingEnt": state.id,
 					"queuedItem": state.production.queue[i]
 				});
 				foundNew = true;
 			}
 		}
 		return queue;
 	},
 	"resizePanel": function(numberOfItems, rowLength)
 	{
 		let numRows = Math.ceil(numberOfItems / rowLength);
 		let panel = Engine.GetGUIObjectByName("unitQueuePanel");
 		let size = panel.size;
 		let buttonSize = Engine.GetGUIObjectByName("unitQueueButton[0]").size.bottom;
 		let margin = 4;
 		size.top = size.bottom - numRows * buttonSize - (numRows + 2) * margin;
 		panel.size = size;
 	},
 	"setupButton": function(data)
 	{
 		let queuedItem = data.item.queuedItem;
 
 		// Differentiate between units and techs
 		let template;
 		if (queuedItem.unitTemplate)
 			template = GetTemplateData(queuedItem.unitTemplate);
 		else if (queuedItem.technologyTemplate)
 			template = GetTechnologyData(queuedItem.technologyTemplate, GetSimState().players[data.player].civ);
 		else
 		{
 			warning("Unknown production queue template " + uneval(queuedItem));
 			return false;
 		}
 
 		data.button.onPress = function() { removeFromProductionQueue(data.item.producingEnt, queuedItem.id); };
 
 		let tooltip = getEntityNames(template);
 		if (queuedItem.neededSlots)
 		{
 			tooltip += "\n" + coloredText(translate("Insufficient population capacity:"), "red");
 			tooltip += "\n" + sprintf(translate("%(population)s %(neededSlots)s"), {
 				"population": resourceIcon("population"),
 				"neededSlots": queuedItem.neededSlots
 			});
 		}
 		data.button.tooltip = tooltip;
 
 		data.countDisplay.caption = queuedItem.count > 1 ? queuedItem.count : "";
 
 		// Show the time remaining to finish the first item
 		if (data.i == 0)
 			Engine.GetGUIObjectByName("queueTimeRemaining").caption =
 				Engine.FormatMillisecondsIntoDateStringGMT(queuedItem.timeRemaining, translateWithContext("countdown format", "m:ss"));
 
 		let guiObject = Engine.GetGUIObjectByName("unitQueueProgressSlider[" + data.i + "]");
 		let size = guiObject.size;
 
 		// Buttons are assumed to be square, so left/right offsets can be used for top/bottom.
 		size.top = size.left + Math.round(queuedItem.progress * (size.right - size.left));
 		guiObject.size = size;
 
 		if (template.icon)
 			data.icon.sprite = "stretched:session/portraits/" + template.icon;
 
 		data.button.enabled = controlsPlayer(data.player);
 
 		setPanelObjectPosition(data.button, data.i, data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Research = {
 	"getMaxNumberOfItems": function()
 	{
 		return 8;
 	},
 	"getItems": function(unitEntStates)
 	{
 		let ret = [];
 		if (unitEntStates.length == 1)
 			return !unitEntStates[0].production || !unitEntStates[0].production.technologies ? ret :
 				unitEntStates[0].production.technologies.map(tech => ({
 					"tech": tech,
 					"techCostMultiplier": unitEntStates[0].production.techCostMultiplier,
 					"researchFacilityId": unitEntStates[0].id
 				}));
 
 		for (let state of unitEntStates)
 		{
 			if (!state.production || !state.production.technologies)
 				continue;
 			// Remove the techs we already have in ret (with the same name and techCostMultiplier)
 			let filteredTechs = state.production.technologies.filter(
 				tech => tech != null && !ret.some(
 					item =>
 						(item.tech == tech ||
 							item.tech.pair &&
 							tech.pair &&
 							item.tech.bottom == tech.bottom &&
 							item.tech.top == tech.top) &&
 						Object.keys(item.techCostMultiplier).every(
 							k => item.techCostMultiplier[k] == state.production.techCostMultiplier[k])
 				));
 
 			if (filteredTechs.length + ret.length <= this.getMaxNumberOfItems() &&
 			    getNumberOfRightPanelButtons() <= this.getMaxNumberOfItems() * (filteredTechs.some(tech => !!tech.pair) ? 1 : 2))
 				ret = ret.concat(filteredTechs.map(tech => ({
 					"tech": tech,
 					"techCostMultiplier": state.production.techCostMultiplier,
 					"researchFacilityId": state.id
 				})));
 		}
 		return ret;
 	},
 	"hideItem": function(i, rowLength) // Called when no item is found
 	{
 		Engine.GetGUIObjectByName("unitResearchButton[" + i + "]").hidden = true;
 		// We also remove the paired tech and the pair symbol
 		Engine.GetGUIObjectByName("unitResearchButton[" + (i + rowLength) + "]").hidden = true;
 		Engine.GetGUIObjectByName("unitResearchPair[" + i + "]").hidden = true;
 	},
 	"setupButton": function(data)
 	{
 		if (!data.item.tech)
 		{
 			g_SelectionPanels.Research.hideItem(data.i, data.rowLength);
 			return false;
 		}
 
 		// Start position (start at the bottom)
 		let position = data.i + data.rowLength;
 
 		// Only show the top button for pairs
 		if (!data.item.tech.pair)
 			Engine.GetGUIObjectByName("unitResearchButton[" + data.i + "]").hidden = true;
 
 		// Set up the tech connector
 		let pair = Engine.GetGUIObjectByName("unitResearchPair[" + data.i + "]");
 		pair.hidden = data.item.tech.pair == null;
 		setPanelObjectPosition(pair, data.i, data.rowLength);
 
 		// Handle one or two techs (tech pair)
 		let player = data.player;
 		let playerState = GetSimState().players[player];
 		for (let tech of data.item.tech.pair ? [data.item.tech.bottom, data.item.tech.top] : [data.item.tech])
 		{
 			// Don't change the object returned by GetTechnologyData
 			let template = clone(GetTechnologyData(tech, playerState.civ));
 			if (!template)
 				return false;
 
 			for (let res in template.cost)
 				template.cost[res] *= data.item.techCostMultiplier[res];
 
 			let neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
 				"cost": template.cost,
 				"player": player
 			});
 
 			let requirementsPassed = Engine.GuiInterfaceCall("CheckTechnologyRequirements", {
 				"tech": tech,
 				"player": player
 			});
 
 			let button = Engine.GetGUIObjectByName("unitResearchButton[" + position + "]");
 			let icon = Engine.GetGUIObjectByName("unitResearchIcon[" + position + "]");
 
 			let tooltips = [
 				getEntityNamesFormatted,
 				getEntityTooltip,
 				getEntityCostTooltip,
 				showTemplateViewerOnRightClickTooltip
 			].map(func => func(template));
 
 			if (!requirementsPassed)
 			{
 				let tip = template.requirementsTooltip;
 				let reqs = template.reqs;
 				for (let req of reqs)
 				{
 					if (!req.entities)
 						continue;
 
 					let entityCounts = [];
 					for (let entity of req.entities)
 					{
 						let current = 0;
 						switch (entity.check)
 						{
 						case "count":
 							current = playerState.classCounts[entity.class] || 0;
 							break;
 
 						case "variants":
 							current = playerState.typeCountsByClass[entity.class] ?
 								Object.keys(playerState.typeCountsByClass[entity.class]).length : 0;
 							break;
 						}
 
 						let remaining = entity.number - current;
 						if (remaining < 1)
 							continue;
 
 						entityCounts.push(sprintf(translatePlural("%(number)s entity of class %(class)s", "%(number)s entities of class %(class)s", remaining), {
 							"number": remaining,
 							"class": entity.class
 						}));
 					}
 
 					tip += " " + sprintf(translate("Remaining: %(entityCounts)s"), {
 						"entityCounts": entityCounts.join(translateWithContext("Separator for a list of entity counts", ", "))
 					});
 				}
 				tooltips.push(tip);
 			}
 			tooltips.push(getNeededResourcesTooltip(neededResources));
 			button.tooltip = tooltips.filter(tip => tip).join("\n");
 
 			button.onPress = (t => function() {
 				addResearchToQueue(data.item.researchFacilityId, t);
 			})(tech);
 
 			button.onPressRight = (t => function () {
 				showTemplateDetails(
 					t,
 					GetTemplateData(data.unitEntStates.find(state => state.id == data.item.researchFacilityId).template).nativeCiv);
 			})(tech);
 
 			if (data.item.tech.pair)
 			{
 				// On mouse enter, show a cross over the other icon
 				let unchosenIcon = Engine.GetGUIObjectByName("unitResearchUnchosenIcon[" + (position + data.rowLength) % (2 * data.rowLength) + "]");
 				button.onMouseEnter = function() {
 					unchosenIcon.hidden = false;
 				};
 				button.onMouseLeave = function() {
 					unchosenIcon.hidden = true;
 				};
 			}
 
 			button.hidden = false;
 			let modifier = "";
 			if (!requirementsPassed)
 			{
 				button.enabled = false;
 				modifier += "color:0 0 0 127:grayscale:";
 			}
 			else if (neededResources)
 			{
 				button.enabled = false;
 				modifier += resourcesToAlphaMask(neededResources) + ":";
 			}
 			else
 				button.enabled = controlsPlayer(data.player);
 
 			if (template.icon)
 				icon.sprite = modifier + "stretched:session/portraits/" + template.icon;
 
 			setPanelObjectPosition(button, position, data.rowLength);
 
 			// Prepare to handle the top button (if any)
 			position -= data.rowLength;
 		}
 
 		return true;
 	}
 };
 
 g_SelectionPanels.Selection = {
 	"getMaxNumberOfItems": function()
 	{
 		return 16;
 	},
 	"rowLength": 4,
 	"getItems": function(unitEntStates)
 	{
 		if (unitEntStates.length < 2)
 			return [];
 		return g_Selection.groups.getEntsGrouped();
 	},
 	"setupButton": function(data)
 	{
 		let entState = GetEntityState(data.item.ents[0]);
 		let template = GetTemplateData(entState.template);
 		if (!template)
 			return false;
 
 		for (let ent of data.item.ents)
 		{
 			let state = GetEntityState(ent);
 
 			if (state.resourceCarrying && state.resourceCarrying.length !== 0)
 			{
 				if (!data.carried)
 					data.carried = {};
 				let carrying = state.resourceCarrying[0];
 				if (data.carried[carrying.type])
 					data.carried[carrying.type] += carrying.amount;
 				else
 					data.carried[carrying.type] = carrying.amount;
 			}
 
 			if (state.trader && state.trader.goods && state.trader.goods.amount)
 			{
 				if (!data.carried)
 					data.carried = {};
 				let amount = state.trader.goods.amount;
 				let type = state.trader.goods.type;
 				let totalGain = amount.traderGain;
 				if (amount.market1Gain)
 					totalGain += amount.market1Gain;
 				if (amount.market2Gain)
 					totalGain += amount.market2Gain;
 				if (data.carried[type])
 					data.carried[type] += totalGain;
 				else
 					data.carried[type] = totalGain;
 			}
 		}
 
 		let unitOwner = GetEntityState(data.item.ents[0]).player;
 		let tooltip = getEntityNames(template);
 		if (data.carried)
 			tooltip += "\n" + Object.keys(data.carried).map(res =>
 				resourceIcon(res) + data.carried[res]
 			).join(" ");
 		if (g_IsObserver)
 			tooltip += "\n" + sprintf(translate("Player: %(playername)s"), {
 				"playername": g_Players[unitOwner].name
 			});
 		data.button.tooltip = tooltip;
 
 		data.guiSelection.sprite = getPlayerHighlightColor(unitOwner);
 		data.guiSelection.hidden = !g_IsObserver;
 
 		data.countDisplay.caption = data.item.ents.length || "";
 
 		data.button.onPress = function() { changePrimarySelectionGroup(data.item.key, false); };
 		data.button.onPressRight = function() { changePrimarySelectionGroup(data.item.key, true); };
 
 		if (template.icon)
 			data.icon.sprite = "stretched:session/portraits/" + template.icon;
 
 		setPanelObjectPosition(data.button, data.i, data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Stance = {
 	"getMaxNumberOfItems": function()
 	{
 		return 5;
 	},
 	"getItems": function(unitEntStates)
 	{
 		if (unitEntStates.some(state => !state.unitAI || !hasClass(state, "Unit") || hasClass(state, "Animal")))
 			return [];
 
 		return unitEntStates[0].unitAI.selectableStances;
 	},
 	"setupButton": function(data)
 	{
 		let unitIds = data.unitEntStates.map(state => state.id);
 		data.button.onPress = function() { performStance(unitIds, data.item); };
 
 		data.button.tooltip = getStanceDisplayName(data.item) + "\n" +
 			"[font=\"sans-13\"]" + getStanceTooltip(data.item) + "[/font]";
 
 		data.guiSelection.hidden = !Engine.GuiInterfaceCall("IsStanceSelected", {
 			"ents": unitIds,
 			"stance": data.item
 		});
 		data.icon.sprite = "stretched:session/icons/stances/" + data.item + ".png";
 		data.button.enabled = controlsPlayer(data.player);
 
 		setPanelObjectPosition(data.button, data.i, data.rowLength);
 		return true;
 	}
 };
 
 g_SelectionPanels.Training = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function()
 	{
 		return getAllTrainableEntitiesFromSelection();
 	},
 	"setupButton": function(data)
 	{
 		let template = GetTemplateData(data.item);
 		if (!template)
 			return false;
 
 		let technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", {
 			"tech": template.requiredTechnology,
 			"player": data.player
 		});
 
 		let unitIds = data.unitEntStates.map(status => status.id);
 		let [buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch] =
 			getTrainingStatus(unitIds, data.item, data.playerState);
 
 		let trainNum = buildingsCountToTrainFullBatch * fullBatchSize + remainderBatch;
 
 		let neededResources;
 		if (template.cost)
 			neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
 				"cost": multiplyEntityCosts(template, trainNum),
 				"player": data.player
 			});
 
 		data.button.onPress = function() {
 			if (!neededResources)
 				addTrainingToQueue(unitIds, data.item, data.playerState);
 		};
 		data.button.onPressRight = function() {
 			showTemplateDetails(data.item);
 		};
 
 		data.countDisplay.caption = trainNum > 1 ? trainNum : "";
 
 		let tooltips = [
 			"[font=\"sans-bold-16\"]" +
 				colorizeHotkey("%(hotkey)s", "session.queueunit." + (data.i + 1)) +
 				"[/font]" + " " + getEntityNamesFormatted(template),
 			getVisibleEntityClassesFormatted(template),
 			getAurasTooltip(template),
 			getEntityTooltip(template),
 			getEntityCostTooltip(template, unitIds[0], buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch)
 		];
 
 		let limits = getEntityLimitAndCount(data.playerState, data.item);
 		tooltips.push(formatLimitString(limits.entLimit, limits.entCount, limits.entLimitChangers));
 
 		if (Engine.ConfigDB_GetValue("user", "showdetailedtooltips") === "true")
 			tooltips = tooltips.concat([
 				getHealthTooltip,
 				getAttackTooltip,
 				getSplashDamageTooltip,
 				getHealerTooltip,
 				getArmorTooltip,
 				getGarrisonTooltip,
 				getProjectilesTooltip,
 				getSpeedTooltip
 			].map(func => func(template)));
 
 		tooltips.push(showTemplateViewerOnRightClickTooltip());
 		tooltips.push(
 			formatBatchTrainingString(buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch),
 			getRequiredTechnologyTooltip(technologyEnabled, template.requiredTechnology, GetSimState().players[data.player].civ),
 			getNeededResourcesTooltip(neededResources));
 
 		data.button.tooltip = tooltips.filter(tip => tip).join("\n");
 
 		let modifier = "";
 		if (!technologyEnabled || limits.canBeAddedCount == 0)
 		{
 			data.button.enabled = false;
 			modifier = "color:0 0 0 127:grayscale:";
 		}
 		else
 		{
 			data.button.enabled = controlsPlayer(data.player);
 			if (neededResources)
 				modifier = resourcesToAlphaMask(neededResources) + ":";
 		}
 
 		if (template.icon)
 			data.icon.sprite = modifier + "stretched:session/portraits/" + template.icon;
 
 		let index = data.i + getNumberOfRightPanelButtons();
 		setPanelObjectPosition(data.button, index, data.rowLength);
 
 		return true;
 	}
 };
 
 g_SelectionPanels.Upgrade = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function(unitEntStates)
 	{
 		// Interface becomes complicated with multiple different units and this is meant per-entity, so prevent it if the selection has multiple different units.
 		if (unitEntStates.some(state => state.template != unitEntStates[0].template))
 			return false;
 
 		return unitEntStates[0].upgrade && unitEntStates[0].upgrade.upgrades;
 	},
 	"setupButton": function(data)
 	{
 		let template = GetTemplateData(data.item.entity);
 		if (!template)
 			return false;
 
 		let technologyEnabled = true;
 
 		if (data.item.requiredTechnology)
 			technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", {
 				"tech": data.item.requiredTechnology,
 				"player": data.player
 			});
 
 		let neededResources = data.item.cost && Engine.GuiInterfaceCall("GetNeededResources", {
 			"cost": multiplyEntityCosts(data.item, data.unitEntStates.length),
 			"player": data.player
 		});
 
 		let limits = getEntityLimitAndCount(data.playerState, data.item.entity);
 		let progress = data.unitEntStates[0].upgrade.progress || 0;
 		let isUpgrading = data.unitEntStates[0].upgrade.template == data.item.entity;
 
 		let tooltip;
 		if (!progress)
 		{
 			let tooltips = [];
 			if (data.item.tooltip)
 				tooltips.push(sprintf(translate("Upgrade to %(name)s. %(tooltip)s"), {
 					"name": template.name.generic,
 					"tooltip": translate(data.item.tooltip)
 				}));
 			else
 				tooltips.push(sprintf(translate("Upgrade to %(name)s."), {
 					"name": template.name.generic
 				}));
 
 			tooltips.push(
 				getEntityCostComponentsTooltipString(data.item, undefined, data.unitEntStates.length),
 				formatLimitString(limits.entLimit, limits.entCount, limits.entLimitChangers),
 				getRequiredTechnologyTooltip(technologyEnabled, data.item.requiredTechnology, GetSimState().players[data.player].civ),
 				getNeededResourcesTooltip(neededResources),
 				showTemplateViewerOnRightClickTooltip());
 
 			tooltip = tooltips.filter(tip => tip).join("\n");
 
 			data.button.onPress = function() { upgradeEntity(data.item.entity); };
 		}
 		else if (isUpgrading)
 		{
 			tooltip = translate("Cancel Upgrading");
 			data.button.onPress = function() { cancelUpgradeEntity(); };
 		}
 		else
 		{
 			tooltip = translate("Cannot upgrade when the entity is already upgrading.");
 			data.button.onPress = function() {};
 		}
 		data.button.enabled = controlsPlayer(data.player);
 		data.button.tooltip = tooltip;
 
 		data.button.onPressRight = function() {
 			showTemplateDetails(data.item.entity);
 		};
 
 		let modifier = "";
 		if (!isUpgrading)
 			if (progress || !technologyEnabled || limits.canBeAddedCount == 0 &&
 				!hasSameRestrictionCategory(data.item.entity, data.unitEntStates[0].template))
 			{
 				data.button.enabled = false;
 				modifier = "color:0 0 0 127:grayscale:";
 			}
 			else if (neededResources)
 			{
 				data.button.enabled = false;
 				modifier = resourcesToAlphaMask(neededResources) + ":";
 			}
 
 		data.icon.sprite = modifier + "stretched:session/" +
 			(data.item.icon || "portraits/" + template.icon);
 
 		data.countDisplay.caption = data.unitEntStates.length > 1 ? data.unitEntStates.length : "";
 
 		let progressOverlay = Engine.GetGUIObjectByName("unitUpgradeProgressSlider[" + data.i + "]");
 		if (isUpgrading)
 		{
 			let size = progressOverlay.size;
 			size.top = size.left + Math.round(progress * (size.right - size.left));
 			progressOverlay.size = size;
 		}
 		progressOverlay.hidden = !isUpgrading;
 
 		setPanelObjectPosition(data.button, data.i + getNumberOfRightPanelButtons(), data.rowLength);
 		return true;
 	}
 };
 
 /**
  * Pauses game and opens the template details viewer for a selected entity or technology.
  *
  * Technologies don't have a set civ, so we pass along the native civ of
  * the template of the entity that's researching it.
  *
  * @param {string} [civCode] - The template name of the entity that researches the selected technology.
  */
 function showTemplateDetails(templateName, civCode)
 {
 	pauseGame();
 
 	Engine.PushGuiPage(
 		"page_viewer.xml",
 		{
 			"templateName": templateName,
 			"civ": civCode
 		},
 		resumeGame);
 }
 
 /**
  * If two panels need the same space, so they collide,
  * the one appearing first in the order is rendered.
  *
  * Note that the panel needs to appear in the list to get rendered.
  */
 let g_PanelsOrder = [
 	// LEFT PANE
 	"Barter", // Must always be visible on markets
 	"Garrison", // More important than Formation, as you want to see the garrisoned units in ships
 	"Alert",
 	"Formation",
 	"Stance", // Normal together with formation
 
 	// RIGHT PANE
 	"Gate", // Must always be shown on gates
 	"Pack", // Must always be shown on packable entities
 	"Upgrade", // Must always be shown on upgradable entities
 	"Training",
 	"Construction",
 	"Research", // Normal together with training
 
 	// UNIQUE PANES (importance doesn't matter)
 	"Command",
 	"AllyCommand",
 	"Queue",
 	"Selection",
 ];
Index: ps/trunk/binaries/data/mods/public/gui/session/session.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 22970)
@@ -1,1719 +1,1720 @@
 const g_IsReplay = Engine.IsVisualReplay();
 
 const g_CivData = loadCivData(false, true);
 
 const g_Ceasefire = prepareForDropdown(g_Settings && g_Settings.Ceasefire);
 const g_MapSizes = prepareForDropdown(g_Settings && g_Settings.MapSizes);
 const g_MapTypes = prepareForDropdown(g_Settings && g_Settings.MapTypes);
 const g_PopulationCapacities = prepareForDropdown(g_Settings && g_Settings.PopulationCapacities);
 const g_StartingResources = prepareForDropdown(g_Settings && g_Settings.StartingResources);
 const g_VictoryDurations = prepareForDropdown(g_Settings && g_Settings.VictoryDurations);
 const g_VictoryConditions = g_Settings && g_Settings.VictoryConditions;
 
 var g_GameSpeeds;
 
 /**
  * Whether to display diplomacy colors (where players see self/ally/neutral/enemy each in different colors and
  * observers see each team in a different color) or regular player colors.
  */
 var g_DiplomacyColorsToggle = false;
 
 /**
  * The array of displayed player colors (either the diplomacy color or regular color for each player).
  */
 var g_DisplayedPlayerColors;
 
 /**
  * Colors to flash when pop limit reached.
  */
 var g_DefaultPopulationColor = "white";
 var g_PopulationAlertColor = "orange";
 
 /**
  * Seen in the tooltip of the top panel.
  */
 var g_ResourceTitleFont = "sans-bold-16";
 
 /**
  * A random file will be played. TODO: more variety
  */
 var g_Ambient = ["audio/ambient/dayscape/day_temperate_gen_03.ogg"];
 
 /**
  * Map, player and match settings set in gamesetup.
  */
 const g_GameAttributes = deepfreeze(Engine.GetInitAttributes());
 
 /**
  * True if this is a multiplayer game.
  */
 const g_IsNetworked = Engine.HasNetClient();
 
 /**
  * Is this user in control of game settings (i.e. is a network server, or offline player).
  */
 var g_IsController = !g_IsNetworked || Engine.HasNetServer();
 
 /**
  * Whether we have finished the synchronization and
  * can start showing simulation related message boxes.
  */
 var g_IsNetworkedActive = false;
 
 /**
  * True if the connection to the server has been lost.
  */
 var g_Disconnected = false;
 
 /**
  * True if the current user has observer capabilities.
  */
 var g_IsObserver = false;
 
 /**
  * True if the current user has rejoined (or joined the game after it started).
  */
 var g_HasRejoined = false;
 
 /**
  * Shows a message box asking the user to leave if "won" or "defeated".
  */
 var g_ConfirmExit = false;
 
 /**
  * True if the current player has paused the game explicitly.
  */
 var g_Paused = false;
 
 /**
  * The list of GUIDs of players who have currently paused the game, if the game is networked.
  */
 var g_PausingClients = [];
 
 /**
  * The playerID selected in the change perspective tool.
  */
 var g_ViewedPlayer = Engine.GetPlayerID();
 
 /**
  * True if the camera should focus on attacks and player commands
  * and select the affected units.
  */
 var g_FollowPlayer = false;
 
 /**
  * Cache the basic player data (name, civ, color).
  */
 var g_Players = [];
 
 /**
  * Last time when onTick was called().
  * Used for animating the main menu.
  */
 var g_LastTickTime = Date.now();
 
 /**
  * Recalculate which units have their status bars shown with this frequency in milliseconds.
  */
 var g_StatusBarUpdate = 200;
 
 /**
  * For restoring selection, order and filters when returning to the replay menu
  */
 var g_ReplaySelectionData;
 
 /**
  * Remembers which clients are assigned to which player slots.
  * The keys are guids or "local" in Singleplayer.
  */
 var g_PlayerAssignments;
 
 var g_DeveloperOverlay;
 
 /**
  * Whether the entire UI should be hidden (useful for promotional screenshots).
  * Can be toggled with a hotkey.
  */
 var g_ShowGUI = true;
 
 /**
  * Whether status bars should be shown for all of the player's units.
  */
 var g_ShowAllStatusBars = false;
 
 /**
  * Blink the population counter if the player can't train more units.
  */
 var g_IsTrainingBlocked = false;
 
 /**
  * Cache of simulation state and template data (apart from TechnologyData, updated on every simulation update).
  */
 var g_SimState;
 var g_EntityStates = {};
 var g_TemplateData = {};
 var g_TechnologyData = {};
 
 var g_ResourceData = new Resources();
 
 /**
  * Top coordinate of the research list.
  * Changes depending on the number of displayed counters.
  */
 var g_ResearchListTop = 4;
 
 /**
  * List of additional entities to highlight.
  */
 var g_ShowGuarding = false;
 var g_ShowGuarded = false;
 var g_AdditionalHighlight = [];
 
 /**
  * Display data of the current players entities shown in the top panel.
  */
 var g_PanelEntities = [];
 
 /**
  * Order in which the panel entities are shown.
  */
 var g_PanelEntityOrder = ["Hero", "Relic"];
 
 /**
  * Unit classes to be checked for the idle-worker-hotkey.
  */
 var g_WorkerTypes = ["FemaleCitizen", "Trader", "FishingBoat", "Citizen"];
 
 /**
  * Unit classes to be checked for the military-only-selection modifier and for the idle-warrior-hotkey.
  */
 var g_MilitaryTypes = ["Melee", "Ranged"];
 
 function GetSimState()
 {
 	if (!g_SimState)
 		g_SimState = deepfreeze(Engine.GuiInterfaceCall("GetSimulationState"));
 
 	return g_SimState;
 }
 
 function GetMultipleEntityStates(ents)
 {
 	if (!ents.length)
 		return null;
 	let entityStates = Engine.GuiInterfaceCall("GetMultipleEntityStates", ents);
 	for (let item of entityStates)
 		g_EntityStates[item.entId] = item.state && deepfreeze(item.state);
 	return entityStates;
 }
 
 function GetEntityState(entId)
 {
 	if (!g_EntityStates[entId])
 	{
 		let entityState = Engine.GuiInterfaceCall("GetEntityState", entId);
 		g_EntityStates[entId] = entityState && deepfreeze(entityState);
 	}
 
 	return g_EntityStates[entId];
 }
 
 function GetTemplateData(templateName)
 {
 	if (!(templateName in g_TemplateData))
 	{
 		let template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		translateObjectKeys(template, ["specific", "generic", "tooltip"]);
 		g_TemplateData[templateName] = deepfreeze(template);
 	}
 
 	return g_TemplateData[templateName];
 }
 
 function GetTechnologyData(technologyName, civ)
 {
 	if (!g_TechnologyData[civ])
 		g_TechnologyData[civ] = {};
 
 	if (!(technologyName in g_TechnologyData[civ]))
 	{
 		let template = GetTechnologyDataHelper(TechnologyTemplates.Get(technologyName), civ, g_ResourceData);
 		translateObjectKeys(template, ["specific", "generic", "description", "tooltip", "requirementsTooltip"]);
 		g_TechnologyData[civ][technologyName] = deepfreeze(template);
 	}
 
 	return g_TechnologyData[civ][technologyName];
 }
 
 function init(initData, hotloadData)
 {
 	if (!g_Settings)
 	{
 		Engine.EndGame();
 		Engine.SwitchGuiPage("page_pregame.xml");
 		return;
 	}
 
 	// Fallback used by atlas
 	g_PlayerAssignments = initData ? initData.playerAssignments : { "local": { "player": 1 } };
 
 	// Fallback used by atlas and autostart games
 	if (g_PlayerAssignments.local && !g_PlayerAssignments.local.name)
 		g_PlayerAssignments.local.name = singleplayerName();
 
 	if (initData)
 	{
 		g_ReplaySelectionData = initData.replaySelectionData;
 		g_HasRejoined = initData.isRejoining;
 
 		if (initData.savedGUIData)
 			restoreSavedGameData(initData.savedGUIData);
 	}
 
 	g_DeveloperOverlay = new DeveloperOverlay();
 	LoadModificationTemplates();
 	updatePlayerData();
 	initializeMusic(); // before changing the perspective
 	initGUIObjects();
 
 	if (hotloadData)
 		g_Selection.selected = hotloadData.selection;
 
 	sendLobbyPlayerlistUpdate();
 	onSimulationUpdate();
 	setTimeout(displayGamestateNotifications, 1000);
 }
 
 function initGUIObjects()
 {
 	initMenu();
 	updateGameSpeedControl();
 	resizeDiplomacyDialog();
 	resizeTradeDialog();
 	initBarterButtons();
 	initPanelEntities();
 	initViewedPlayerDropdown();
 	initChatWindow();
 	Engine.SetBoundingBoxDebugOverlay(false);
 	updateEnabledRangeOverlayTypes();
 }
 
 function updatePlayerData()
 {
 	let simState = GetSimState();
 	if (!simState)
 		return;
 
 	let playerData = [];
 
 	for (let i = 0; i < simState.players.length; ++i)
 	{
 		let playerState = simState.players[i];
 
 		playerData.push({
 			"name": playerState.name,
 			"civ": playerState.civ,
 			"color": {
 				"r": playerState.color.r * 255,
 				"g": playerState.color.g * 255,
 				"b": playerState.color.b * 255,
 				"a": playerState.color.a * 255
 			},
 			"team": playerState.team,
 			"teamsLocked": playerState.teamsLocked,
 			"cheatsEnabled": playerState.cheatsEnabled,
 			"state": playerState.state,
 			"isAlly": playerState.isAlly,
 			"isMutualAlly": playerState.isMutualAlly,
 			"isNeutral": playerState.isNeutral,
 			"isEnemy": playerState.isEnemy,
 			"guid": undefined, // network guid for players controlled by hosts
 			"offline": g_Players[i] && !!g_Players[i].offline
 		});
 	}
 
 	for (let guid in g_PlayerAssignments)
 	{
 		let playerID = g_PlayerAssignments[guid].player;
 
 		if (!playerData[playerID])
 			continue;
 
 		playerData[playerID].guid = guid;
 		playerData[playerID].name = g_PlayerAssignments[guid].name;
 	}
 
 	g_Players = playerData;
 }
 
 function updateDiplomacyColorsButton()
 {
 	g_DiplomacyColorsToggle = !g_DiplomacyColorsToggle;
 
 	let diplomacyColorsButton = Engine.GetGUIObjectByName("diplomacyColorsButton");
 
 	diplomacyColorsButton.sprite = g_DiplomacyColorsToggle ?
 		"stretched:session/minimap-diplomacy-on.png" :
 		"stretched:session/minimap-diplomacy-off.png";
 
 	diplomacyColorsButton.sprite_over = g_DiplomacyColorsToggle ?
 		"stretched:session/minimap-diplomacy-on-highlight.png" :
 		"stretched:session/minimap-diplomacy-off-highlight.png";
 
 	Engine.GetGUIObjectByName("diplomacyColorsWindowButtonIcon").sprite = g_DiplomacyColorsToggle ?
 		"stretched:session/icons/diplomacy-on.png" :
 		"stretched:session/icons/diplomacy.png";
 
 	updateDisplayedPlayerColors();
 }
 
 /**
  * Updates the displayed colors of players in the simulation and GUI.
  */
 function updateDisplayedPlayerColors()
 {
 	if (g_DiplomacyColorsToggle)
 	{
 		let getDiplomacyColor = stance =>
 			guiToRgbColor(Engine.ConfigDB_GetValue("user", "gui.session.diplomacycolors." + stance)) ||
 			guiToRgbColor(Engine.ConfigDB_GetValue("default", "gui.session.diplomacycolors." + stance));
 
 		let teamRepresentatives = {};
 		for (let i = 1; i < g_Players.length; ++i)
 			if (g_ViewedPlayer <= 0)
 			{
 				// Observers and gaia see team colors
 				let team = g_Players[i].team;
 				g_DisplayedPlayerColors[i] = g_Players[teamRepresentatives[team] || i].color;
 				if (team != -1 && !teamRepresentatives[team])
 					teamRepresentatives[team] = i;
 			}
 			else
 				// Players see colors depending on diplomacy
 				g_DisplayedPlayerColors[i] =
 					g_ViewedPlayer == i ? getDiplomacyColor("self") :
 					g_Players[g_ViewedPlayer].isAlly[i] ? getDiplomacyColor("ally") :
 					g_Players[g_ViewedPlayer].isNeutral[i] ? getDiplomacyColor("neutral") :
 					getDiplomacyColor("enemy");
 
 		g_DisplayedPlayerColors[0] = g_Players[0].color;
 	}
 	else
 		g_DisplayedPlayerColors = g_Players.map(player => player.color);
 
 	Engine.GuiInterfaceCall("UpdateDisplayedPlayerColors", {
 		"displayedPlayerColors": g_DisplayedPlayerColors,
 		"displayDiplomacyColors": g_DiplomacyColorsToggle,
 		"showAllStatusBars": g_ShowAllStatusBars,
 		"selected": g_Selection.toList()
 	});
 
 	updateGUIObjects();
 }
 
 /**
  * Depends on the current player (g_IsObserver).
  */
 function updateHotkeyTooltips()
 {
 	Engine.GetGUIObjectByName("chatInput").tooltip =
 		translateWithContext("chat input", "Type the message to send.") + "\n" +
 		colorizeAutocompleteHotkey() +
 		colorizeHotkey("\n" + translate("Press %(hotkey)s to open the public chat."), "chat") +
 		colorizeHotkey(
 			"\n" + (g_IsObserver ?
 				translate("Press %(hotkey)s to open the observer chat.") :
 				translate("Press %(hotkey)s to open the ally chat.")),
 			"teamchat") +
 		colorizeHotkey("\n" + translate("Press %(hotkey)s to open the previously selected private chat."), "privatechat");
 
 	Engine.GetGUIObjectByName("idleWorkerButton").tooltip =
 		colorizeHotkey("%(hotkey)s" + " ", "selection.idleworker") +
 		translate("Find idle worker");
 
 	Engine.GetGUIObjectByName("diplomacyColorsButton").tooltip =
 		colorizeHotkey("%(hotkey)s" + " ", "session.diplomacycolors") +
 		translate("Toggle Diplomacy Colors");
 
 	Engine.GetGUIObjectByName("diplomacyColorsWindowButton").tooltip =
 		colorizeHotkey("%(hotkey)s" + " ", "session.diplomacycolors") +
 		translate("Toggle Diplomacy Colors");
 
 	Engine.GetGUIObjectByName("diplomacyButton").tooltip =
 		colorizeHotkey("%(hotkey)s" + " ", "session.gui.diplomacy.toggle") +
 		translate("Diplomacy");
 
 	Engine.GetGUIObjectByName("tradeButton").tooltip =
 		colorizeHotkey("%(hotkey)s" + " ", "session.gui.barter.toggle") +
 		translate("Barter & Trade");
 
 	Engine.GetGUIObjectByName("tradeHelp").tooltip = colorizeHotkey(
 		translate("Select one type of goods you want to modify by clicking on it, and then use the arrows of the other types to modify their shares. You can also press %(hotkey)s while selecting one type of goods to bring its share to 100%%."),
 		"session.fulltradeswap");
 
 	Engine.GetGUIObjectByName("barterHelp").tooltip = sprintf(
 		translate("Start by selecting the resource you wish to sell from the upper row. For each time the lower buttons are pressed, %(quantity)s of the upper resource will be sold for the displayed quantity of the lower. Press and hold %(hotkey)s to temporarily multiply the traded amount by %(multiplier)s."), {
 			"quantity": g_BarterResourceSellQuantity,
 			"hotkey": colorizeHotkey("%(hotkey)s", "session.massbarter"),
 			"multiplier": g_BarterMultiplier
 		});
 
 	Engine.GetGUIObjectByName("objectivesButton").tooltip =
 		colorizeHotkey("%(hotkey)s" + " ", "session.gui.objectives.toggle") +
 		translate("Objectives");
 }
 
 function initPanelEntities()
 {
 	Engine.GetGUIObjectByName("panelEntityPanel").children.forEach((button, slot) => {
 
 		button.onPress = function() {
 			let panelEnt = g_PanelEntities.find(ent => ent.slot !== undefined && ent.slot == slot);
 			if (!panelEnt)
 				return;
 
 			if (!Engine.HotkeyIsPressed("selection.add"))
 				g_Selection.reset();
 
 			g_Selection.addList([panelEnt.ent]);
 		};
 
 		button.onDoublePress = function() {
 			let panelEnt = g_PanelEntities.find(ent => ent.slot !== undefined && ent.slot == slot);
 			if (panelEnt)
 				selectAndMoveTo(getEntityOrHolder(panelEnt.ent));
 		};
 	});
 }
 
 /**
  * Returns the entity itself except when garrisoned where it returns its garrisonHolder
  */
 function getEntityOrHolder(ent)
 {
 	let entState = GetEntityState(ent);
 	if (entState && !entState.position && entState.unitAI && entState.unitAI.orders.length &&
 			entState.unitAI.orders[0].type == "Garrison")
 		return getEntityOrHolder(entState.unitAI.orders[0].data.target);
 
 	return ent;
 }
 
 function initializeMusic()
 {
 	initMusic();
 	if (g_ViewedPlayer != -1 && g_CivData[g_Players[g_ViewedPlayer].civ].Music)
 		global.music.storeTracks(g_CivData[g_Players[g_ViewedPlayer].civ].Music);
 	global.music.setState(global.music.states.PEACE);
 	playAmbient();
 }
 
 function initViewedPlayerDropdown()
 {
 	g_DisplayedPlayerColors = g_Players.map(player => player.color);
 	updateViewedPlayerDropdown();
 
 	// Select "observer" in the view player dropdown when rejoining as a defeated player
 	let player = g_Players[Engine.GetPlayerID()];
 	Engine.GetGUIObjectByName("viewPlayer").selected = player && player.state == "defeated" ? 0 : Engine.GetPlayerID() + 1;
 }
 
 function updateViewedPlayerDropdown()
 {
 	let viewPlayer = Engine.GetGUIObjectByName("viewPlayer");
 	viewPlayer.list_data = [-1].concat(g_Players.map((player, i) => i));
 	viewPlayer.list = [translate("Observer")].concat(g_Players.map(
 		(player, i) => colorizePlayernameHelper("■", i) + " " + player.name
 	));
 }
 
 /**
  * Change perspective tool.
  * Shown to observers or when enabling the developers option.
  */
 function selectViewPlayer(playerID)
 {
 	if (playerID < -1 || playerID > g_Players.length - 1)
 		return;
 
 	if (g_ShowAllStatusBars)
 		recalculateStatusBarDisplay(true);
 
 	g_IsObserver = isPlayerObserver(Engine.GetPlayerID());
 
 	if (g_IsObserver || g_DeveloperOverlay.isChangePerspective())
 	{
 		if (g_ViewedPlayer != playerID)
 			clearSelection();
 		g_ViewedPlayer = playerID;
 	}
 
 	if (g_DeveloperOverlay.isChangePerspective())
 	{
 		Engine.SetPlayerID(g_ViewedPlayer);
 		g_IsObserver = isPlayerObserver(g_ViewedPlayer);
 	}
 
 	Engine.SetViewedPlayer(g_ViewedPlayer);
 	updateDisplayedPlayerColors();
 	updateTopPanel();
 	updateChatAddressees();
 	updateHotkeyTooltips();
 
 	// Update GUI and clear player-dependent cache
 	g_TemplateData = {};
 	Engine.GuiInterfaceCall("ResetTemplateModified");
 	onSimulationUpdate();
 
 	if (g_IsDiplomacyOpen)
 		openDiplomacy();
 
 	if (g_IsTradeOpen)
 		openTrade();
 }
 
 /**
  * Returns true if the player with that ID is in observermode.
  */
 function isPlayerObserver(playerID)
 {
 	let playerStates = GetSimState().players;
 	return !playerStates[playerID] || playerStates[playerID].state != "active";
 }
 
 /**
  * Returns true if the current user can issue commands for that player.
  */
 function controlsPlayer(playerID)
 {
 	let playerStates = GetSimState().players;
 
 	return !!playerStates[Engine.GetPlayerID()] &&
 		playerStates[Engine.GetPlayerID()].controlsAll ||
 		Engine.GetPlayerID() == playerID &&
 		!!playerStates[playerID] &&
 		playerStates[playerID].state != "defeated";
 }
 
 /**
  * Called when one or more players have won or were defeated.
  *
  * @param {array} - IDs of the players who have won or were defeated.
  * @param {object} - a plural string stating the victory reason.
  * @param {boolean} - whether these players have won or lost.
  */
 function playersFinished(players, victoryString, won)
 {
 	addChatMessage({
 		"type": "defeat-victory",
 		"message": victoryString,
 		"players": players
 	});
 
 	if (players.indexOf(Engine.GetPlayerID()) != -1)
 		reportGame();
 
 	sendLobbyPlayerlistUpdate();
 
 	updatePlayerData();
 	updateChatAddressees();
 	updateGameSpeedControl();
 
 	if (players.indexOf(g_ViewedPlayer) == -1)
 		return;
 
 	// Select "observer" item on loss. On win enable observermode without changing perspective
 	Engine.GetGUIObjectByName("viewPlayer").selected = won ? g_ViewedPlayer + 1 : 0;
 
 	if (players.indexOf(Engine.GetPlayerID()) == -1 || Engine.IsAtlasRunning())
 		return;
 
 	global.music.setState(
 		won ?
 			global.music.states.VICTORY :
 			global.music.states.DEFEAT
 	);
 
 	g_ConfirmExit = won ? "won" : "defeated";
 }
 
 /**
  * Sets civ icon for the currently viewed player.
  * Hides most gui objects for observers.
  */
 function updateTopPanel()
 {
 	let isPlayer = g_ViewedPlayer > 0;
 
 	let civIcon = Engine.GetGUIObjectByName("civIcon");
 	civIcon.hidden = !isPlayer;
 	if (isPlayer)
 	{
 		civIcon.sprite = "stretched:" + g_CivData[g_Players[g_ViewedPlayer].civ].Emblem;
 		Engine.GetGUIObjectByName("civIconOverlay").tooltip =
 			sprintf(
 				translate("%(civ)s\n%(hotkey_civinfo)s / %(hotkey_structree)s: View History / Structure Tree\nLast opened will be reopened on click."), {
 					"civ": setStringTags(g_CivData[g_Players[g_ViewedPlayer].civ].Name, { "font": "sans-bold-stroke-14" }),
 					"hotkey_civinfo": colorizeHotkey("%(hotkey)s", "civinfo"),
 					"hotkey_structree": colorizeHotkey("%(hotkey)s", "structree")
 			});
 	}
 
 	// Following gaia can be interesting on scripted maps
 	Engine.GetGUIObjectByName("optionFollowPlayer").hidden = !g_IsObserver || g_ViewedPlayer == -1;
 
 	let viewPlayer = Engine.GetGUIObjectByName("viewPlayer");
 	viewPlayer.hidden = !g_IsObserver && !g_DeveloperOverlay.isChangePerspective();
 
 	let followPlayerLabel = Engine.GetGUIObjectByName("followPlayerLabel");
 	followPlayerLabel.hidden = Engine.GetTextWidth(followPlayerLabel.font, followPlayerLabel.caption + "  ") +
 		followPlayerLabel.getComputedSize().left > viewPlayer.getComputedSize().left;
 
 	let resCodes = g_ResourceData.GetCodes();
 	let r = 0;
 	for (let res of resCodes)
 	{
 		if (!Engine.GetGUIObjectByName("resource[" + r + "]"))
 		{
 			warn("Current GUI limits prevent displaying more than " + r + " resources in the top panel!");
 			break;
 		}
 		Engine.GetGUIObjectByName("resource[" + r + "]_icon").sprite = "stretched:session/icons/resources/" + res + ".png";
 		Engine.GetGUIObjectByName("resource[" + r + "]").hidden = !isPlayer;
 		++r;
 	}
 	horizontallySpaceObjects("resourceCounts", 5);
 	hideRemaining("resourceCounts", r);
 
 	let resPop = Engine.GetGUIObjectByName("population");
 	let resPopSize = resPop.size;
 	resPopSize.left = Engine.GetGUIObjectByName("resource[" + (r - 1) + "]").size.right;
 	resPop.size = resPopSize;
 
 	Engine.GetGUIObjectByName("population").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("diplomacyButton").hidden = !isPlayer;
-	Engine.GetGUIObjectByName("tradeButton").hidden = !isPlayer;
+	Engine.GetGUIObjectByName("tradeButton").hidden = !isPlayer ||
+		(!g_ResourceData.GetTradableCodes().length && !g_ResourceData.GetBarterableCodes().length);
 	Engine.GetGUIObjectByName("observerText").hidden = isPlayer;
 
 	let alphaLabel = Engine.GetGUIObjectByName("alphaLabel");
 	alphaLabel.hidden = isPlayer && !viewPlayer.hidden;
 	alphaLabel.size = isPlayer ? "50%+44 0 100%-283 100%" : "155 0 85%-279 100%";
 
 	Engine.GetGUIObjectByName("pauseButton").enabled = !g_IsObserver || !g_IsNetworked || g_IsController;
 	Engine.GetGUIObjectByName("menuResignButton").enabled = !g_IsObserver;
 	Engine.GetGUIObjectByName("lobbyButton").enabled = Engine.HasXmppClient();
 }
 
 /**
  * Resign a player.
  * @param leaveGameAfterResign If player is quitting after resignation.
  */
 function resignGame(leaveGameAfterResign)
 {
 	if (g_IsObserver || g_Disconnected)
 		return;
 
 	Engine.PostNetworkCommand({
 		"type": "resign"
 	});
 
 	if (!leaveGameAfterResign)
 		resumeGame(true);
 }
 
 /**
  * Leave the game
  * @param willRejoin If player is going to be rejoining a networked game.
  */
 function leaveGame(willRejoin)
 {
 	if (!willRejoin && !g_IsObserver)
 		resignGame(true);
 
 	// Before ending the game
 	let replayDirectory = Engine.GetCurrentReplayDirectory();
 	let simData = getReplayMetadata();
 	let playerID = Engine.GetPlayerID();
 
 	Engine.EndGame();
 
 	// After the replay file was closed in EndGame
 	// Done here to keep EndGame small
 	if (!g_IsReplay)
 		Engine.AddReplayToCache(replayDirectory);
 
 	if (g_IsController && Engine.HasXmppClient())
 		Engine.SendUnregisterGame();
 
 	Engine.SwitchGuiPage("page_summary.xml", {
 		"sim": simData,
 		"gui": {
 			"dialog": false,
 			"assignedPlayer": playerID,
 			"disconnected": g_Disconnected,
 			"isReplay": g_IsReplay,
 			"replayDirectory": !g_HasRejoined && replayDirectory,
 			"replaySelectionData": g_ReplaySelectionData
 		}
 	});
 }
 
 // Return some data that we'll use when hotloading this file after changes
 function getHotloadData()
 {
 	return { "selection": g_Selection.selected };
 }
 
 function getSavedGameData()
 {
 	return {
 		"groups": g_Groups.groups
 	};
 }
 
 function restoreSavedGameData(data)
 {
 	// Restore camera if any
 	if (data.camera)
 		Engine.SetCameraData(data.camera.PosX, data.camera.PosY, data.camera.PosZ,
 			data.camera.RotX, data.camera.RotY, data.camera.Zoom);
 
 	// Clear selection when loading a game
 	g_Selection.reset();
 
 	// Restore control groups
 	for (let groupNumber in data.groups)
 	{
 		g_Groups.groups[groupNumber].groups = data.groups[groupNumber].groups;
 		g_Groups.groups[groupNumber].ents = data.groups[groupNumber].ents;
 	}
 	updateGroups();
 }
 
 /**
  * Called every frame.
  */
 function onTick()
 {
 	if (!g_Settings)
 		return;
 
 	let now = Date.now();
 	let tickLength = now - g_LastTickTime;
 	g_LastTickTime = now;
 
 	handleNetMessages();
 
 	updateCursorAndTooltip();
 
 	if (g_Selection.dirty)
 	{
 		g_Selection.dirty = false;
 		// When selection changed, get the entityStates of new entities
 		GetMultipleEntityStates(g_Selection.toList().filter(entId => !g_EntityStates[entId]));
 
 		updateGUIObjects();
 
 		// Display rally points for selected buildings
 		if (Engine.GetPlayerID() != -1)
 			Engine.GuiInterfaceCall("DisplayRallyPoint", { "entities": g_Selection.toList() });
 	}
 	else if (g_ShowAllStatusBars && now % g_StatusBarUpdate <= tickLength)
 		recalculateStatusBarDisplay();
 
 	updateTimers();
 
 	updateMenuPosition(tickLength);
 
 	// When training is blocked, flash population (alternates color every 500msec)
 	Engine.GetGUIObjectByName("resourcePop").textcolor = g_IsTrainingBlocked && now % 1000 < 500 ? g_PopulationAlertColor : g_DefaultPopulationColor;
 
 	Engine.GuiInterfaceCall("ClearRenamedEntities");
 }
 
 function onWindowResized()
 {
 	// Update followPlayerLabel
 	updateTopPanel();
 
 	resizeChatWindow();
 }
 
 function changeGameSpeed(speed)
 {
 	if (!g_IsNetworked)
 		Engine.SetSimRate(speed);
 }
 
 function updateIdleWorkerButton()
 {
 	Engine.GetGUIObjectByName("idleWorkerButton").enabled = Engine.GuiInterfaceCall("HasIdleUnits", {
 		"viewedPlayer": g_ViewedPlayer,
 		"idleClasses": g_WorkerTypes,
 		"excludeUnits": []
 	});
 }
 
 function onSimulationUpdate()
 {
 	// Templates change depending on technologies and auras, so they have to be reloaded after such a change.
 	// g_TechnologyData data never changes, so it shouldn't be deleted.
 	g_EntityStates = {};
 	if (Engine.GuiInterfaceCall("IsTemplateModified"))
 	{
 		g_TemplateData = {};
 		Engine.GuiInterfaceCall("ResetTemplateModified");
 	}
 	g_SimState = undefined;
 
 	if (!GetSimState())
 		return;
 
 	GetMultipleEntityStates(g_Selection.toList());
 
 	updateCinemaPath();
 	handleNotifications();
 	updateGUIObjects();
 
 	if (g_ConfirmExit)
 		confirmExit();
 }
 
 /**
  * Don't show the message box before all playerstate changes are processed.
  */
 function confirmExit()
 {
 	if (g_IsNetworked && !g_IsNetworkedActive)
 		return;
 
 	closeOpenDialogs();
 
 	// Don't ask for exit if other humans are still playing
 	let askExit = !Engine.HasNetServer() || g_Players.every((player, i) =>
 		i == 0 ||
 		player.state != "active" ||
 		g_GameAttributes.settings.PlayerData[i].AI != "");
 
 	let subject = g_PlayerStateMessages[g_ConfirmExit];
 	if (askExit)
 		subject += "\n" + translate("Do you want to quit?");
 
 	messageBox(
 		400, 200,
 		subject,
 		g_ConfirmExit == "won" ?
 			translate("VICTORIOUS!") :
 			translate("DEFEATED!"),
 		askExit ? [translate("No"), translate("Yes")] : [translate("OK")],
 		askExit ? [resumeGame, leaveGame] : [resumeGame]
 	);
 
 	g_ConfirmExit = false;
 }
 
 function toggleGUI()
 {
 	g_ShowGUI = !g_ShowGUI;
 	updateCinemaPath();
 }
 
 function updateCinemaPath()
 {
 	let isPlayingCinemaPath = GetSimState().cinemaPlaying && !g_Disconnected;
 
 	Engine.GetGUIObjectByName("session").hidden = !g_ShowGUI || isPlayingCinemaPath;
 	Engine.Renderer_SetSilhouettesEnabled(!isPlayingCinemaPath && Engine.ConfigDB_GetValue("user", "silhouettes") == "true");
 }
 
 function updateGUIObjects()
 {
 	g_Selection.update();
 
 	if (g_ShowAllStatusBars)
 		recalculateStatusBarDisplay();
 
 	if (g_ShowGuarding || g_ShowGuarded)
 		updateAdditionalHighlight();
 
 	updatePanelEntities();
 	displayPanelEntities();
 
 	updateGroups();
 	updatePlayerDisplay();
 	updateResearchDisplay();
 	updateSelectionDetails();
 	updateBuildingPlacementPreview();
 	updateTimeNotifications();
 	updateIdleWorkerButton();
 
 	if (g_IsTradeOpen)
 	{
 		updateTraderTexts();
 		updateBarterButtons();
 	}
 
 	if (g_ViewedPlayer > 0)
 	{
 		let playerState = GetSimState().players[g_ViewedPlayer];
 		g_DeveloperOverlay.setControlAll(playerState && playerState.controlsAll);
 	}
 
 	if (!g_IsObserver)
 	{
 		// Update music state on basis of battle state.
 		let battleState = Engine.GuiInterfaceCall("GetBattleState", g_ViewedPlayer);
 		if (battleState)
 			global.music.setState(global.music.states[battleState]);
 	}
 
 	updateViewedPlayerDropdown();
 	updateDiplomacy();
 	g_DeveloperOverlay.update();
 }
 
 function saveResPopTooltipSort()
 {
 	Engine.ConfigDB_CreateAndWriteValueToFile("user", "gui.session.respoptooltipsort", String((+Engine.ConfigDB_GetValue("user", "gui.session.respoptooltipsort") + 2) % 3 - 1), "config/user.cfg");
 }
 
 function onReplayFinished()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	messageBox(400, 200,
 		translateWithContext("replayFinished", "The replay has finished. Do you want to quit?"),
 		translateWithContext("replayFinished", "Confirmation"),
 		[translateWithContext("replayFinished", "No"), translateWithContext("replayFinished", "Yes")],
 		[resumeGame, leaveGame]);
 }
 
 /**
 * updates a status bar on the GUI
 * nameOfBar: name of the bar
 * points: points to show
 * maxPoints: max points
 * direction: gets less from (right to left) 0; (top to bottom) 1; (left to right) 2; (bottom to top) 3;
 */
 function updateGUIStatusBar(nameOfBar, points, maxPoints, direction)
 {
 	// check, if optional direction parameter is valid.
 	if (!direction || !(direction >= 0 && direction < 4))
 		direction = 0;
 
 	// get the bar and update it
 	let statusBar = Engine.GetGUIObjectByName(nameOfBar);
 	if (!statusBar)
 		return;
 
 	let healthSize = statusBar.size;
 	let value = 100 * Math.max(0, Math.min(1, points / maxPoints));
 
 	// inverse bar
 	if (direction == 2 || direction == 3)
 		value = 100 - value;
 
 	if (direction == 0)
 		healthSize.rright = value;
 	else if (direction == 1)
 		healthSize.rbottom = value;
 	else if (direction == 2)
 		healthSize.rleft = value;
 	else if (direction == 3)
 		healthSize.rtop = value;
 
 	statusBar.size = healthSize;
 }
 
 function updatePanelEntities()
 {
 	let panelEnts =
 		g_ViewedPlayer == -1 ?
 			GetSimState().players.reduce((ents, pState) => ents.concat(pState.panelEntities), []) :
 			GetSimState().players[g_ViewedPlayer].panelEntities;
 
 	g_PanelEntities = g_PanelEntities.filter(panelEnt => panelEnts.find(ent => ent == panelEnt.ent));
 
 	for (let ent of panelEnts)
 	{
 		let panelEntState = GetEntityState(ent);
 		let template = GetTemplateData(panelEntState.template);
 
 		let panelEnt = g_PanelEntities.find(pEnt => ent == pEnt.ent);
 
 		if (!panelEnt)
 		{
 			panelEnt = {
 				"ent": ent,
 				"tooltip": undefined,
 				"sprite": "stretched:session/portraits/" + template.icon,
 				"maxHitpoints": undefined,
 				"currentHitpoints": panelEntState.hitpoints,
 				"previousHitpoints": undefined
 			};
 			g_PanelEntities.push(panelEnt);
 		}
 
 		panelEnt.tooltip = createPanelEntityTooltip(panelEntState, template);
 		panelEnt.previousHitpoints = panelEnt.currentHitpoints;
 		panelEnt.currentHitpoints = panelEntState.hitpoints;
 		panelEnt.maxHitpoints = panelEntState.maxHitpoints;
 	}
 
 	let panelEntIndex = ent => g_PanelEntityOrder.findIndex(entClass =>
 		GetEntityState(ent).identity.classes.indexOf(entClass) != -1);
 
 	g_PanelEntities = g_PanelEntities.sort((panelEntA, panelEntB) => panelEntIndex(panelEntA.ent) - panelEntIndex(panelEntB.ent));
 }
 
 function createPanelEntityTooltip(panelEntState, template)
 {
 	let getPanelEntNameTooltip = panelEntState => "[font=\"sans-bold-16\"]" + template.name.specific + "[/font]";
 
 	return [
 		getPanelEntNameTooltip,
 		getCurrentHealthTooltip,
 		getAttackTooltip,
 		getArmorTooltip,
 		getEntityTooltip,
 		getAurasTooltip
 	].map(tooltip => tooltip(panelEntState)).filter(tip => tip).join("\n");
 }
 
 function displayPanelEntities()
 {
 	let buttons = Engine.GetGUIObjectByName("panelEntityPanel").children;
 
 	buttons.forEach((button, slot) => {
 
 		if (button.hidden || g_PanelEntities.some(ent => ent.slot !== undefined && ent.slot == slot))
 			return;
 
 		button.hidden = true;
 		stopColorFade("panelEntityHitOverlay[" + slot + "]");
 	});
 
 	// The slot identifies the button, displayIndex determines its position.
 	for (let displayIndex = 0; displayIndex < Math.min(g_PanelEntities.length, buttons.length); ++displayIndex)
 	{
 		let panelEnt = g_PanelEntities[displayIndex];
 
 		// Find the first unused slot if new, otherwise reuse previous.
 		let slot = panelEnt.slot === undefined ?
 			buttons.findIndex(button => button.hidden) :
 			panelEnt.slot;
 
 		let panelEntButton = Engine.GetGUIObjectByName("panelEntityButton[" + slot + "]");
 		panelEntButton.tooltip = panelEnt.tooltip;
 
 		updateGUIStatusBar("panelEntityHealthBar[" + slot + "]", panelEnt.currentHitpoints, panelEnt.maxHitpoints);
 
 		if (panelEnt.slot === undefined)
 		{
 			let panelEntImage = Engine.GetGUIObjectByName("panelEntityImage[" + slot + "]");
 			panelEntImage.sprite = panelEnt.sprite;
 
 			panelEntButton.hidden = false;
 			panelEnt.slot = slot;
 		}
 
 		// If the health of the panelEnt changed since the last update, trigger the animation.
 		if (panelEnt.previousHitpoints > panelEnt.currentHitpoints)
 			startColorFade("panelEntityHitOverlay[" + slot + "]", 100, 0,
 				colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
 
 		// TODO: Instead of instant position changes, animate button movement.
 		setPanelObjectPosition(panelEntButton, displayIndex, buttons.length);
 	}
 }
 
 function updateGroups()
 {
 	g_Groups.update();
 
 	// Determine the sum of the costs of a given template
 	let getCostSum = (ent) => {
 		let cost = GetTemplateData(GetEntityState(ent).template).cost;
 		return cost ? Object.keys(cost).map(key => cost[key]).reduce((sum, cur) => sum + cur) : 0;
 	};
 
 	for (let i in Engine.GetGUIObjectByName("unitGroupPanel").children)
 	{
 		Engine.GetGUIObjectByName("unitGroupLabel[" + i + "]").caption = i;
 
 		let button = Engine.GetGUIObjectByName("unitGroupButton[" + i + "]");
 		button.hidden = g_Groups.groups[i].getTotalCount() == 0;
 		button.onpress = (function(i) { return function() { performGroup((Engine.HotkeyIsPressed("selection.add") ? "add" : "select"), i); }; })(i);
 		button.ondoublepress = (function(i) { return function() { performGroup("snap", i); }; })(i);
 		button.onpressright = (function(i) { return function() { performGroup("breakUp", i); }; })(i);
 
 		// Choose the icon of the most common template (or the most costly if it's not unique)
 		if (g_Groups.groups[i].getTotalCount() > 0)
 		{
 			let icon = GetTemplateData(GetEntityState(g_Groups.groups[i].getEntsGrouped().reduce((pre, cur) => {
 				if (pre.ents.length == cur.ents.length)
 					return getCostSum(pre.ents[0]) > getCostSum(cur.ents[0]) ? pre : cur;
 				return pre.ents.length > cur.ents.length ? pre : cur;
 			}).ents[0]).template).icon;
 
 			Engine.GetGUIObjectByName("unitGroupIcon[" + i + "]").sprite =
 				icon ? ("stretched:session/portraits/" + icon) : "groupsIcon";
 		}
 
 		setPanelObjectPosition(button, i, 1);
 	}
 }
 
 /**
  * Create ally player stat tooltip.
  * @param {string} resource - Resource type, on which values will be sorted.
  * @param {object} playerStates - Playerstates from players whos stats are viewed in the tooltip.
  * @param {number} sort - 0 no order, -1 descending, 1 ascending order.
  * @returns {string} Tooltip string.
  */
 function getAllyStatTooltip(resource, playerStates, sort)
 {
 	let tooltip = [];
 
 	for (let player in playerStates)
 		tooltip.push({
 			"playername": colorizePlayernameHelper("■", player) + " " + g_Players[player].name,
 			"statValue": resource == "pop" ?
 				sprintf(translate("%(popCount)s/%(popLimit)s/%(popMax)s"), playerStates[player]) :
 				Math.round(playerStates[player].resourceCounts[resource]),
 			"orderValue": resource == "pop" ? playerStates[player].popCount :
 				Math.round(playerStates[player].resourceCounts[resource])
 		});
 	if (sort)
 		tooltip.sort((a, b) => sort * (b.orderValue - a.orderValue));
 	return "\n" + tooltip.map(stat => sprintf(translate("%(playername)s: %(statValue)s"), stat)).join("\n");
 }
 
 function updatePlayerDisplay()
 {
 	let allPlayerStates = GetSimState().players;
 	let viewedPlayerState = allPlayerStates[g_ViewedPlayer];
 	let viewablePlayerStates = {};
 	for (let player in allPlayerStates)
 		if (player != 0 &&
 			player != g_ViewedPlayer &&
 			g_Players[player].state != "defeated" &&
 			(g_IsObserver ||
 				viewedPlayerState.hasSharedLos &&
 				g_Players[player].isMutualAlly[g_ViewedPlayer]))
 			viewablePlayerStates[player] = allPlayerStates[player];
 
 	if (!viewedPlayerState)
 		return;
 
 	let tooltipSort = +Engine.ConfigDB_GetValue("user", "gui.session.respoptooltipsort");
 
 	let orderHotkeyTooltip = Object.keys(viewablePlayerStates).length <= 1 ? "" :
 		"\n" + sprintf(translate("%(order)s: %(hotkey)s to change order."), {
 		"hotkey": setStringTags("\\[Click]", g_HotkeyTags),
 		"order": tooltipSort == 0 ? translate("Unordered") : tooltipSort == 1 ? translate("Descending") : translate("Ascending")
 	});
 
 	let resCodes = g_ResourceData.GetCodes();
 	for (let r = 0; r < resCodes.length; ++r)
 	{
 		let resourceObj = Engine.GetGUIObjectByName("resource[" + r + "]");
 		if (!resourceObj)
 			break;
 
 		let res = resCodes[r];
 
 		let tooltip = '[font="' + g_ResourceTitleFont + '"]' +
 			resourceNameFirstWord(res) + '[/font]';
 
 		let descr = g_ResourceData.GetResource(res).description;
 		if (descr)
 			tooltip += "\n" + translate(descr);
 
 		tooltip += orderHotkeyTooltip + getAllyStatTooltip(res, viewablePlayerStates, tooltipSort);
 
 		resourceObj.tooltip = tooltip;
 
 		Engine.GetGUIObjectByName("resource[" + r + "]_count").caption = Math.floor(viewedPlayerState.resourceCounts[res]);
 	}
 
 	Engine.GetGUIObjectByName("resourcePop").caption = sprintf(translate("%(popCount)s/%(popLimit)s"), viewedPlayerState);
 	Engine.GetGUIObjectByName("population").tooltip = translate("Population (current / limit)") + "\n" +
 		sprintf(translate("Maximum population: %(popCap)s"), { "popCap": viewedPlayerState.popMax }) +
 		orderHotkeyTooltip +
 		getAllyStatTooltip("pop", viewablePlayerStates, tooltipSort);
 
 	g_IsTrainingBlocked = viewedPlayerState.trainingBlocked;
 }
 
 function selectAndMoveTo(ent)
 {
 	let entState = GetEntityState(ent);
 	if (!entState || !entState.position)
 		return;
 
 	g_Selection.reset();
 	g_Selection.addList([ent]);
 
 	let position = entState.position;
 	Engine.CameraMoveTo(position.x, position.z);
 }
 
 function updateResearchDisplay()
 {
 	let researchStarted = Engine.GuiInterfaceCall("GetStartedResearch", g_ViewedPlayer);
 
 	// Set up initial positioning.
 	let buttonSideLength = Engine.GetGUIObjectByName("researchStartedButton[0]").size.right;
 	for (let i = 0; i < 10; ++i)
 	{
 		let button = Engine.GetGUIObjectByName("researchStartedButton[" + i + "]");
 		let size = button.size;
 		size.top = g_ResearchListTop + (4 + buttonSideLength) * i;
 		size.bottom = size.top + buttonSideLength;
 		button.size = size;
 	}
 
 	let numButtons = 0;
 	for (let tech in researchStarted)
 	{
 		// Show at most 10 in-progress techs.
 		if (numButtons >= 10)
 			break;
 
 		let template = GetTechnologyData(tech, g_Players[g_ViewedPlayer].civ);
 		let button = Engine.GetGUIObjectByName("researchStartedButton[" + numButtons + "]");
 		button.hidden = false;
 		button.tooltip = getEntityNames(template);
 		button.onpress = (function(e) { return function() { selectAndMoveTo(e); }; })(researchStarted[tech].researcher);
 
 		let icon = "stretched:session/portraits/" + template.icon;
 		Engine.GetGUIObjectByName("researchStartedIcon[" + numButtons + "]").sprite = icon;
 
 		// Scale the progress indicator.
 		let size = Engine.GetGUIObjectByName("researchStartedProgressSlider[" + numButtons + "]").size;
 
 		// Buttons are assumed to be square, so left/right offsets can be used for top/bottom.
 		size.top = size.left + Math.round(researchStarted[tech].progress * (size.right - size.left));
 		Engine.GetGUIObjectByName("researchStartedProgressSlider[" + numButtons + "]").size = size;
 
 		Engine.GetGUIObjectByName("researchStartedTimeRemaining[" + numButtons + "]").caption =
 			Engine.FormatMillisecondsIntoDateStringGMT(researchStarted[tech].timeRemaining, translateWithContext("countdown format", "m:ss"));
 
 		++numButtons;
 	}
 
 	// Hide unused buttons.
 	for (let i = numButtons; i < 10; ++i)
 		Engine.GetGUIObjectByName("researchStartedButton[" + i + "]").hidden = true;
 }
 
 /**
  * Toggles the display of status bars for all of the player's entities.
  *
  * @param {Boolean} remove - Whether to hide all previously shown status bars.
  */
 function recalculateStatusBarDisplay(remove = false)
 {
 	let entities;
 	if (g_ShowAllStatusBars && !remove)
 		entities = g_ViewedPlayer == -1 ?
 			Engine.PickNonGaiaEntitiesOnScreen() :
 			Engine.PickPlayerEntitiesOnScreen(g_ViewedPlayer);
 	else
 	{
 		let selected = g_Selection.toList();
 		for (let ent in g_Selection.highlighted)
 			selected.push(g_Selection.highlighted[ent]);
 
 		// Remove selected entities from the 'all entities' array,
 		// to avoid disabling their status bars.
 		entities = Engine.GuiInterfaceCall(
 			g_ViewedPlayer == -1 ? "GetNonGaiaEntities" : "GetPlayerEntities", {
 				"viewedPlayer": g_ViewedPlayer
 			}).filter(idx => selected.indexOf(idx) == -1);
 	}
 
 	Engine.GuiInterfaceCall("SetStatusBars", {
 		"entities": entities,
 		"enabled": g_ShowAllStatusBars && !remove,
 		"showRank": Engine.ConfigDB_GetValue("user", "gui.session.rankabovestatusbar") == "true",
 		"showExperience": Engine.ConfigDB_GetValue("user", "gui.session.experiencestatusbar") == "true"
 	});
 }
 
 /**
  * Inverts the given configuration boolean and returns the current state.
  * For example "silhouettes".
  */
 function toggleConfigBool(configName)
 {
 	let enabled = Engine.ConfigDB_GetValue("user", configName) != "true";
 	Engine.ConfigDB_CreateAndWriteValueToFile("user", configName, String(enabled), "config/user.cfg");
 	return enabled;
 }
 
 /**
  * Toggles the display of range overlays of selected entities for the given range type.
  * @param {string} type - for example "Auras"
  */
 function toggleRangeOverlay(type)
 {
 	let enabled = toggleConfigBool("gui.session." + type.toLowerCase() + "range");
 
 	Engine.GuiInterfaceCall("EnableVisualRangeOverlayType", {
 		"type": type,
 		"enabled": enabled
 	});
 
 	let selected = g_Selection.toList();
 	for (let ent in g_Selection.highlighted)
 		selected.push(g_Selection.highlighted[ent]);
 
 	Engine.GuiInterfaceCall("SetRangeOverlays", {
 		"entities": selected,
 		"enabled": enabled
 	});
 }
 
 function updateEnabledRangeOverlayTypes()
 {
 	for (let type of ["Attack", "Auras", "Heal"])
 		Engine.GuiInterfaceCall("EnableVisualRangeOverlayType", {
 			"type": type,
 			"enabled": Engine.ConfigDB_GetValue("user", "gui.session." + type.toLowerCase() + "range") == "true"
 		});
 }
 
 // Update the additional list of entities to be highlighted.
 function updateAdditionalHighlight()
 {
 	let entsAdd = []; // list of entities units to be highlighted
 	let entsRemove = [];
 	let highlighted = g_Selection.toList();
 	for (let ent in g_Selection.highlighted)
 		highlighted.push(g_Selection.highlighted[ent]);
 
 	if (g_ShowGuarding)
 		// flag the guarding entities to add in this additional highlight
 		for (let sel in g_Selection.selected)
 		{
 			let state = GetEntityState(g_Selection.selected[sel]);
 			if (!state.guard || !state.guard.entities.length)
 				continue;
 
 			for (let ent of state.guard.entities)
 				if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
 					entsAdd.push(ent);
 		}
 
 	if (g_ShowGuarded)
 		// flag the guarded entities to add in this additional highlight
 		for (let sel in g_Selection.selected)
 		{
 			let state = GetEntityState(g_Selection.selected[sel]);
 			if (!state.unitAI || !state.unitAI.isGuarding)
 				continue;
 			let ent = state.unitAI.isGuarding;
 			if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
 				entsAdd.push(ent);
 		}
 
 	// flag the entities to remove (from the previously added) from this additional highlight
 	for (let ent of g_AdditionalHighlight)
 		if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1 && entsRemove.indexOf(ent) == -1)
 			entsRemove.push(ent);
 
 	_setHighlight(entsAdd, g_HighlightedAlpha, true);
 	_setHighlight(entsRemove, 0, false);
 	g_AdditionalHighlight = entsAdd;
 }
 
 function playAmbient()
 {
 	Engine.PlayAmbientSound(pickRandom(g_Ambient), true);
 }
 
 /**
  * Adds the ingame time and ceasefire counter to the global FPS and
  * realtime counters shown in the top right corner.
  */
 function appendSessionCounters(counters)
 {
 	let simState = GetSimState();
 
 	if (Engine.ConfigDB_GetValue("user", "gui.session.timeelapsedcounter") === "true")
 	{
 		let currentSpeed = Engine.GetSimRate();
 		if (currentSpeed != 1.0)
 			// Translation: The "x" means "times", with the mathematical meaning of multiplication.
 			counters.push(sprintf(translate("%(time)s (%(speed)sx)"), {
 				"time": timeToString(simState.timeElapsed),
 				"speed": Engine.FormatDecimalNumberIntoString(currentSpeed)
 			}));
 		else
 			counters.push(timeToString(simState.timeElapsed));
 	}
 
 	if (simState.ceasefireActive && Engine.ConfigDB_GetValue("user", "gui.session.ceasefirecounter") === "true")
 		counters.push(timeToString(simState.ceasefireTimeRemaining));
 
 	g_ResearchListTop = 4 + 14 * counters.length;
 }
 
 /**
  * Send the current list of players, teams, AIs, observers and defeated/won and offline states to the lobby.
  * The playerData format from g_GameAttributes is kept to reuse the GUI function presenting the data.
  */
 function sendLobbyPlayerlistUpdate()
 {
 	if (!g_IsController || !Engine.HasXmppClient())
 		return;
 
 	// Extract the relevant player data and minimize packet load
 	let minPlayerData = [];
 	for (let playerID in g_GameAttributes.settings.PlayerData)
 	{
 		if (+playerID == 0)
 			continue;
 
 		let pData = g_GameAttributes.settings.PlayerData[playerID];
 
 		let minPData = { "Name": pData.Name, "Civ": pData.Civ };
 
 		if (g_GameAttributes.settings.LockTeams)
 			minPData.Team = pData.Team;
 
 		if (pData.AI)
 		{
 			minPData.AI = pData.AI;
 			minPData.AIDiff = pData.AIDiff;
 			minPData.AIBehavior = pData.AIBehavior;
 		}
 
 		if (g_Players[playerID].offline)
 			minPData.Offline = true;
 
 		// Whether the player has won or was defeated
 		let state = g_Players[playerID].state;
 		if (state != "active")
 			minPData.State = state;
 
 		minPlayerData.push(minPData);
 	}
 
 	// Add observers
 	let connectedPlayers = 0;
 	for (let guid in g_PlayerAssignments)
 	{
 		let pData = g_GameAttributes.settings.PlayerData[g_PlayerAssignments[guid].player];
 
 		if (pData)
 			++connectedPlayers;
 		else
 			minPlayerData.push({
 				"Name": g_PlayerAssignments[guid].name,
 				"Team": "observer"
 			});
 	}
 
 	Engine.SendChangeStateGame(connectedPlayers, playerDataToStringifiedTeamList(minPlayerData));
 }
 
 /**
  * Send a report on the gamestatus to the lobby.
  * Keep in sync with source/tools/XpartaMuPP/LobbyRanking.py
  */
 function reportGame()
 {
 	// Only 1v1 games are rated (and Gaia is part of g_Players)
 	if (!Engine.HasXmppClient() || !Engine.IsRankedGame() ||
 	    g_Players.length != 3 || Engine.GetPlayerID() == -1)
 		return;
 
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 
 	let unitsClasses = [
 		"total",
 		"Infantry",
 		"Worker",
 		"FemaleCitizen",
 		"Cavalry",
 		"Champion",
 		"Hero",
 		"Siege",
 		"Ship",
 		"Trader"
 	];
 
 	let unitsCountersTypes = [
 		"unitsTrained",
 		"unitsLost",
 		"enemyUnitsKilled"
 	];
 
 	let buildingsClasses = [
 		"total",
 		"CivCentre",
 		"House",
 		"Economic",
 		"Outpost",
 		"Military",
 		"Fortress",
 		"Wonder"
 	];
 
 	let buildingsCountersTypes = [
 		"buildingsConstructed",
 		"buildingsLost",
 		"enemyBuildingsDestroyed"
 	];
 
 	let resourcesTypes = [
 		"wood",
 		"food",
 		"stone",
 		"metal"
 	];
 
 	let resourcesCounterTypes = [
 		"resourcesGathered",
 		"resourcesUsed",
 		"resourcesSold",
 		"resourcesBought"
 	];
 
 	let misc = [
 		"tradeIncome",
 		"tributesSent",
 		"tributesReceived",
 		"treasuresCollected",
 		"lootCollected",
 		"percentMapExplored"
 	];
 
 	let playerStatistics = {};
 
 	// Unit Stats
 	for (let unitCounterType of unitsCountersTypes)
 	{
 		if (!playerStatistics[unitCounterType])
 			playerStatistics[unitCounterType] = { };
 		for (let unitsClass of unitsClasses)
 			playerStatistics[unitCounterType][unitsClass] = "";
 	}
 
 	playerStatistics.unitsLostValue = "";
 	playerStatistics.unitsKilledValue = "";
 	// Building stats
 	for (let buildingCounterType of buildingsCountersTypes)
 	{
 		if (!playerStatistics[buildingCounterType])
 			playerStatistics[buildingCounterType] = { };
 		for (let buildingsClass of buildingsClasses)
 			playerStatistics[buildingCounterType][buildingsClass] = "";
 	}
 
 	playerStatistics.buildingsLostValue = "";
 	playerStatistics.enemyBuildingsDestroyedValue = "";
 	// Resources
 	for (let resourcesCounterType of resourcesCounterTypes)
 	{
 		if (!playerStatistics[resourcesCounterType])
 			playerStatistics[resourcesCounterType] = { };
 		for (let resourcesType of resourcesTypes)
 			playerStatistics[resourcesCounterType][resourcesType] = "";
 	}
 	playerStatistics.resourcesGathered.vegetarianFood = "";
 
 	for (let type of misc)
 		playerStatistics[type] = "";
 
 	// Total
 	playerStatistics.economyScore = "";
 	playerStatistics.militaryScore = "";
 	playerStatistics.totalScore = "";
 
 	let mapName = g_GameAttributes.settings.Name;
 	let playerStates = "";
 	let playerCivs = "";
 	let teams = "";
 	let teamsLocked = true;
 
 	// Serialize the statistics for each player into a comma-separated list.
 	// Ignore gaia
 	for (let i = 1; i < extendedSimState.players.length; ++i)
 	{
 		let player = extendedSimState.players[i];
 		let maxIndex = player.sequences.time.length - 1;
 
 		playerStates += player.state + ",";
 		playerCivs += player.civ + ",";
 		teams += player.team + ",";
 		teamsLocked = teamsLocked && player.teamsLocked;
 		for (let resourcesCounterType of resourcesCounterTypes)
 			for (let resourcesType of resourcesTypes)
 				playerStatistics[resourcesCounterType][resourcesType] += player.sequences[resourcesCounterType][resourcesType][maxIndex] + ",";
 		playerStatistics.resourcesGathered.vegetarianFood += player.sequences.resourcesGathered.vegetarianFood[maxIndex] + ",";
 
 		for (let unitCounterType of unitsCountersTypes)
 			for (let unitsClass of unitsClasses)
 				playerStatistics[unitCounterType][unitsClass] += player.sequences[unitCounterType][unitsClass][maxIndex] + ",";
 
 		for (let buildingCounterType of buildingsCountersTypes)
 			for (let buildingsClass of buildingsClasses)
 				playerStatistics[buildingCounterType][buildingsClass] += player.sequences[buildingCounterType][buildingsClass][maxIndex] + ",";
 		let total = 0;
 		for (let type in player.sequences.resourcesGathered)
 			total += player.sequences.resourcesGathered[type][maxIndex];
 
 		playerStatistics.economyScore += total + ",";
 		playerStatistics.militaryScore += Math.round((player.sequences.enemyUnitsKilledValue[maxIndex] +
 			player.sequences.enemyBuildingsDestroyedValue[maxIndex]) / 10) + ",";
 		playerStatistics.totalScore += (total + Math.round((player.sequences.enemyUnitsKilledValue[maxIndex] +
 			player.sequences.enemyBuildingsDestroyedValue[maxIndex]) / 10)) + ",";
 
 		for (let type of misc)
 			playerStatistics[type] += player.sequences[type][maxIndex] + ",";
 	}
 
 	// Send the report with serialized data
 	let reportObject = {};
 	reportObject.timeElapsed = extendedSimState.timeElapsed;
 	reportObject.playerStates = playerStates;
 	reportObject.playerID = Engine.GetPlayerID();
 	reportObject.matchID = g_GameAttributes.matchID;
 	reportObject.civs = playerCivs;
 	reportObject.teams = teams;
 	reportObject.teamsLocked = String(teamsLocked);
 	reportObject.ceasefireActive = String(extendedSimState.ceasefireActive);
 	reportObject.ceasefireTimeRemaining = String(extendedSimState.ceasefireTimeRemaining);
 	reportObject.mapName = mapName;
 	reportObject.economyScore = playerStatistics.economyScore;
 	reportObject.militaryScore = playerStatistics.militaryScore;
 	reportObject.totalScore = playerStatistics.totalScore;
 	for (let rct of resourcesCounterTypes)
 		for (let rt of resourcesTypes)
 			reportObject[rt + rct.substr(9)] = playerStatistics[rct][rt];
 			// eg. rt = food rct.substr = Gathered rct = resourcesGathered
 
 	reportObject.vegetarianFoodGathered = playerStatistics.resourcesGathered.vegetarianFood;
 	for (let type of unitsClasses)
 	{
 		// eg. type = Infantry (type.substr(0,1)).toLowerCase()+type.substr(1) = infantry
 		reportObject[(type.substr(0, 1)).toLowerCase() + type.substr(1) + "UnitsTrained"] = playerStatistics.unitsTrained[type];
 		reportObject[(type.substr(0, 1)).toLowerCase() + type.substr(1) + "UnitsLost"] = playerStatistics.unitsLost[type];
 		reportObject["enemy" + type + "UnitsKilled"] = playerStatistics.enemyUnitsKilled[type];
 	}
 	for (let type of buildingsClasses)
 	{
 		reportObject[(type.substr(0, 1)).toLowerCase() + type.substr(1) + "BuildingsConstructed"] = playerStatistics.buildingsConstructed[type];
 		reportObject[(type.substr(0, 1)).toLowerCase() + type.substr(1) + "BuildingsLost"] = playerStatistics.buildingsLost[type];
 		reportObject["enemy" + type + "BuildingsDestroyed"] = playerStatistics.enemyBuildingsDestroyed[type];
 	}
 	for (let type of misc)
 		reportObject[type] = playerStatistics[type];
 
 	Engine.SendGameReport(reportObject);
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/trade_window.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/trade_window.xml	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/gui/session/trade_window.xml	(revision 22970)
@@ -1,112 +1,112 @@
 <?xml version="1.0" encoding="utf-8"?>
 <object name="tradeDialogPanel"
 	size="50%-80 50%-270 50%+80 50%+130"
 	type="image"
 	hidden="true"
 	sprite="ModernDialog"
 >
 	<object type="text" size="50%-96 -16 50%+96 16" style="TitleText">
 		<translatableAttribute id="caption">Barter &amp; Trade Goods</translatableAttribute>
 	</object>
 
 	<!-- Barter Goods -->
-	<object size="24 24 100%-24 33%">
+	<object size="24 24 100%-24 33%" name="tradeDialogPanelBarter">
 
 		<object type="text" size="8 0 100% 32" style="ModernLeftLabelText">
 			<translatableAttribute id="caption">Barter</translatableAttribute>
 		</object>
 		<object type="image" size="0 28 100% 29" sprite="ModernGoldLine"/>
 
 		<object size="0 38 100% 122">
 
 			<object type="text" size="0 0 60 41" style="ModernRightLabelText">
 				<translatableAttribute id="caption">Sell:</translatableAttribute>
 			</object>
 
 			<object type="text" size="0 100%-41 60 100%" style="ModernRightLabelText">
 				<translatableAttribute id="caption">Buy:</translatableAttribute>
 			</object>
 
 			<object name="barterNoMarketsMessage" type="text" size="72 0 100% 100%" style="ModernLabelText">
 				<translatableAttribute id="caption">No Markets Available</translatableAttribute>
 			</object>
 
 			<object name="barterResources" size="72 0 100% 100%">
 				<repeat count="10">
 					<object name="barterResource[n]" size="0 0 58 100%">
 
 						<!-- Sell -->
 						<object name="barterSellButton[n]" type="button" size="0 0 41 41" style="iconButton" tooltip_style="sessionToolTipBottomBold" hidden="true">
 							<object name="barterSellIcon[n]" type="image" size="3 3 100%-3 100%-3" ghost="true"/>
 							<object name="barterSellAmount[n]" type="text" size="0 0 100% 50%" style="resourceText" ghost="true"/>
 							<object name="barterSellSelection[n]" type="image" size="3 3 100%-3 100%-3" sprite="stretched:session/icons/corners.png" hidden="true" ghost="true"/>
 						</object>
 
 						<!-- Buy -->
 						<object name="barterBuyButton[n]" type="button" size="0 100%-41 41 100%" style="iconButton" tooltip_style="sessionToolTipBottomBold" hidden="true">
 							<object name="barterBuyIcon[n]" type="image" size="3 3 100%-3 100%-3" ghost="true"/>
 							<object name="barterBuyAmount[n]" type="text" size="0 0 100% 50%" style="resourceText" ghost="true"/>
 						</object>
 
 					</object>
 				</repeat>
 			</object>
 
 			<object name="barterHelp" type="button" size="100%-24 50%-12 100% 50%+12" style="StoneButton" tooltip_style="sessionToolTipBold" enabled="false">
 				<object type="image" size="20% 15% 80% 75%" sprite="iconInfoWhite" ghost="true"/>
 			</object>
 
 		</object>
 	</object>
 
 	<!-- Trading goods -->
-	<object size="24 33%+32 100%-24 100%-64">
+	<object size="24 33%+32 100%-24 100%-64" name="tradeDialogPanelTrade">
 
 		<object type="text" size="8 0 100% 32" style="ModernLeftLabelText">
 			<translatableAttribute id="caption">Trade</translatableAttribute>
 		</object>
 		<object type="image" size="0 28 100% 29" sprite="ModernGoldLine"/>
 
 		<object name="tradeGoods" size="0 38 100% 70">
 
 			<object type="text" size="0 0 60 100%" style="ModernRightLabelText">
 				<!-- Translation: Used in the Trade Dialog -->
 				<translatableAttribute id="caption">Goods:</translatableAttribute>
 			</object>
 
 			<object name="tradeResources" size="72 0 100% 100%">
 				<repeat count="8">
 					<object name="tradeResource[n]" size="0 0 58 32">
 
 						<object name="tradeResourceButton[n]" type="button" size="4 0 36 100%" style="StoneButton">
 							<object name="tradeResourceIcon[n]" type="image" ghost="true"/>
 							<object name="tradeResourceSelection[n]" type="image" sprite="stretched:session/icons/corners.png" ghost="true"/>
 							<object name="tradeResourceText[n]" type="text" style="ModernLabelText" ghost="true"/>
 						</object>
 						<object name="tradeArrowUp[n]" type="button" size="36 0 52 50%" style="iconButton">
 							<object type="image" sprite="StoneArrowUp" ghost="true"/>
 						</object>
 						<object name="tradeArrowDn[n]" type="button" size="36 50% 52 100%" style="iconButton">
 							<object type="image" sprite="StoneArrowDn" ghost="true"/>
 						</object>
 
 					</object>
 				</repeat>
 			</object>
 
 			<object name="tradeHelp" type="button" size="100%-24 4 100% 28" style="StoneButton" tooltip_style="sessionToolTipBold" enabled="false">
 				<object type="image" size="20% 15% 80% 75%" sprite="iconInfoWhite" ghost="true"/>
 			</object>
 
 		</object>
 
 		<object name="traderCountText" type="text" size="8 88 100% 100%" style="ModernLeftTopLabelText"/>
 
 	</object>
 
 	<object type="button" size="50%-64 100%-50 50%+64 100%-22" style="StoneButton">
 		<translatableAttribute id="caption">Close</translatableAttribute>
 		<action on="Press">closeTrade();</action>
 	</object>
 </object>
 
Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/diplomacyManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/diplomacyManager.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/diplomacyManager.js	(revision 22970)
@@ -1,553 +1,568 @@
 /**
  * Manage the diplomacy:
  *     update our cooperative trait
  *     sent tribute to allies
  *     decide which player to turn against in "Last Man Standing" mode
  *     respond to diplomacy requests
  *     send diplomacy requests to other players (rarely)
  */
 
 /**
  * If a player sends us an ally or neutral request, an Object in this.receivedDiplomacyRequests will be created
  * that includes the request status, and the amount and type of the resource tribute (if any)
  * that they must send in order for us to accept their request.
  * In addition, a message will be sent if the player has not sent us a tribute within a minute.
  * If two minutes pass without a tribute, we will decline their request.
  *
  * If we send a diplomacy request to another player, an Object in this.sentDiplomacyRequests will be created,
  * which consists of the requestType (i.e. "ally" or "neutral") and the timeSent. A chat message will be sent
  * to the other player, and AI players will actually be informed of the request by a DiplomacyRequest event
  * sent through AIInterface. It is expected that the other player will change their diplomacy stance to the stance
  * that we suggested within a period of time, or else the request will be deleted from this.sentDiplomacyRequests.
  */
 PETRA.DiplomacyManager = function(Config)
 {
 	this.Config = Config;
 	this.nextTributeUpdate = 90;
 	this.nextTributeRequest = new Map();
 	this.nextTributeRequest.set("all", 240);
 	this.betrayLapseTime = -1;
 	this.waitingToBetray = false;
 	this.betrayWeighting = 150;
 	this.receivedDiplomacyRequests = new Map();
 	this.sentDiplomacyRequests = new Map();
 	this.sentDiplomacyRequestLapseTime = 120 + randFloat(10, 100);
 };
 
 /**
  * If there are any players that are allied/neutral with us but we are not allied/neutral with them,
  * treat this situation like an ally/neutral request.
  */
 PETRA.DiplomacyManager.prototype.init = function(gameState)
 {
 	this.lastManStandingCheck(gameState);
 
 	for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
 	{
 		if (i === PlayerID)
 			continue;
 
 		if (gameState.isPlayerMutualAlly(i))
 			this.receivedDiplomacyRequests.set(i, { "requestType": "ally", "status": "accepted" });
 		else if (gameState.sharedScript.playersData[i].isAlly[PlayerID])
 			this.handleDiplomacyRequest(gameState, i, "ally");
 		else if (gameState.sharedScript.playersData[i].isNeutral[PlayerID] && gameState.isPlayerEnemy(i))
 			this.handleDiplomacyRequest(gameState, i, "neutral");
 	}
 };
 
 /**
  * Check if any allied needs help (tribute) and sent it if we have enough resource
  * or ask for a tribute if we are in need and one ally can help
  */
 PETRA.DiplomacyManager.prototype.tributes = function(gameState)
 {
 	this.nextTributeUpdate = gameState.ai.elapsedTime + 30;
+	let resTribCodes = Resources.GetTributableCodes();
+	if (!resTribCodes.length)
+		return;
 	let totalResources = gameState.getResources();
 	let availableResources = gameState.ai.queueManager.getAvailableResources(gameState);
 	let mostNeeded;
 	for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
 	{
 		if (i === PlayerID || !gameState.isPlayerAlly(i) || gameState.ai.HQ.attackManager.defeated[i])
 			continue;
 		let donor = gameState.getAlliedVictory() || gameState.getEntities(i).length < gameState.getOwnEntities().length;
 		let allyResources = gameState.sharedScript.playersData[i].resourceCounts;
 		let allyPop = gameState.sharedScript.playersData[i].popCount;
 		let tribute = {};
 		let toSend = false;
-		for (let res in allyResources)
+		for (let res in resTribCodes)
 		{
 			if (donor && availableResources[res] > 200 && allyResources[res] < 0.2 * availableResources[res])
 			{
 				tribute[res] = Math.floor(0.3*availableResources[res] - allyResources[res]);
 				toSend = true;
 			}
 			else if (donor && allyPop < Math.min(30, 0.5*gameState.getPopulation()) && totalResources[res] > 500 && allyResources[res] < 100)
 			{
 				tribute[res] = 100;
 				toSend = true;
 			}
 			else if (this.Config.chat && availableResources[res] === 0 && allyResources[res] > totalResources[res] + 600)
 			{
 				if (gameState.ai.elapsedTime < this.nextTributeRequest.get("all"))
 					continue;
 				if (this.nextTributeRequest.has(res) && gameState.ai.elapsedTime < this.nextTributeRequest.get(res))
 					continue;
 				if (!mostNeeded)
-					mostNeeded = gameState.ai.HQ.pickMostNeededResources(gameState);
-				for (let k = 0; k < 2; ++k)
+					mostNeeded = gameState.ai.HQ.pickMostNeededResources(gameState, resTribCodes);
+				for (let k = 0; k < mostNeeded.length; ++k)
 				{
 					if (mostNeeded[k].type == res && mostNeeded[k].wanted > 0)
 					{
 						this.nextTributeRequest.set("all", gameState.ai.elapsedTime + 90);
 						this.nextTributeRequest.set(res, gameState.ai.elapsedTime + 240);
 						PETRA.chatRequestTribute(gameState, res);
 						if (this.Config.debug > 1)
 							API3.warn("Tribute on " + res + " requested to player " + i);
 						break;
 					}
 				}
 			}
 		}
 		if (!toSend)
 			continue;
 		if (this.Config.debug > 1)
 			API3.warn("Tribute " + uneval(tribute) + " sent to player " + i);
 		if (this.Config.chat)
 			PETRA.chatSentTribute(gameState, i);
 		Engine.PostCommand(PlayerID, { "type": "tribute", "player": i, "amounts": tribute });
 	}
 };
 
 PETRA.DiplomacyManager.prototype.checkEvents = function(gameState, events)
 {
 	// Increase slowly the cooperative personality trait either when we receive tribute from our allies
 	// or if our allies attack enemies inside our territory
 	for (let evt of events.TributeExchanged)
 	{
 		if (evt.to === PlayerID && !gameState.isPlayerAlly(evt.from) && this.receivedDiplomacyRequests.has(evt.from))
 		{
 			let request = this.receivedDiplomacyRequests.get(evt.from);
 			if (request.status === "waitingForTribute")
 			{
 				request.wanted -= evt.amounts[request.type];
 
 				if (request.wanted <= 0)
 				{
 					if (this.Config.debug > 1)
 						API3.warn("Player " + uneval(evt.from) + " has sent the required tribute amount");
 
 					this.changePlayerDiplomacy(gameState, evt.from, request.requestType);
 					request.status = "accepted";
 				}
 				else if (evt.amounts[request.type] > 0)
 				{
 					// Reset the warning sent to the player that reminds them to speed up the tributes
 					request.warnTime = gameState.ai.elapsedTime + 60;
 					request.sentWarning = false;
 				}
 			}
 		}
 
 		if (evt.to !== PlayerID || !gameState.isPlayerAlly(evt.from))
 			continue;
 		let tributes = 0;
 		for (let key in evt.amounts)
 		{
 			if (key === "food")
 				tributes += evt.amounts[key];
 			else
 				tributes += 2*evt.amounts[key];
 		}
 		this.Config.personality.cooperative = Math.min(1, this.Config.personality.cooperative + 0.0001 * tributes);
 	}
 
 	for (let evt of events.Attacked)
 	{
 		let target = gameState.getEntityById(evt.target);
 		if (!target || !target.position() ||
 			gameState.ai.HQ.territoryMap.getOwner(target.position()) !== PlayerID ||
 			!gameState.isPlayerEnemy(target.owner()))
 			continue;
 		let attacker = gameState.getEntityById(evt.attacker);
 		if (!attacker || attacker.owner() === PlayerID || !gameState.isPlayerAlly(attacker.owner()))
 			continue;
 		this.Config.personality.cooperative = Math.min(1, this.Config.personality.cooperative + 0.003);
 	}
 
 	if (events.DiplomacyChanged.length || events.PlayerDefeated.length || events.CeasefireEnded.length)
 		this.lastManStandingCheck(gameState);
 
 	for (let evt of events.DiplomacyChanged)
 	{
 		if (evt.otherPlayer !== PlayerID)
 			continue;
 
 		if (this.sentDiplomacyRequests.has(evt.player)) // If another player has accepted a diplomacy request we sent
 		{
 			let sentRequest = this.sentDiplomacyRequests.get(evt.player);
 			if (gameState.sharedScript.playersData[evt.player].isAlly[PlayerID] && sentRequest.requestType === "ally" ||
 			    gameState.sharedScript.playersData[evt.player].isNeutral[PlayerID] && sentRequest.requestType === "neutral")
 				this.changePlayerDiplomacy(gameState, evt.player, sentRequest.requestType);
 
 			// Just remove the request if the other player switched their stance to a different and/or more negative state
 			// TODO: Keep this send request and take it into account for later diplomacy changes (maybe be less inclined to offer to this player)
 			this.sentDiplomacyRequests.delete(evt.player);
 			continue;
 		}
 
 		let request = this.receivedDiplomacyRequests.get(evt.player);
 		if (request !== undefined &&
 		   (!gameState.sharedScript.playersData[evt.player].isAlly[PlayerID] && request.requestType === "ally" ||
 		     gameState.sharedScript.playersData[evt.player].isEnemy[PlayerID] && request.requestType === "neutral"))
 		{
 			// a player that had requested to be allies changed their stance with us
 			if (request.status === "accepted")
 				request.status = "allianceBroken";
 			else if (request.status !== "allianceBroken")
 				request.status = "declinedRequest";
 		}
 		else if (gameState.sharedScript.playersData[evt.player].isAlly[PlayerID] && gameState.isPlayerEnemy(evt.player))
 		{
 			let response = request !== undefined && (request.status === "declinedRequest" || request.status === "allianceBroken") ?
 				"decline" : "declineSuggestNeutral";
 			PETRA.chatAnswerRequestDiplomacy(gameState, evt.player, "ally", response);
 		}
 		else if (gameState.sharedScript.playersData[evt.player].isAlly[PlayerID] && gameState.isPlayerNeutral(evt.player))
 			this.handleDiplomacyRequest(gameState, evt.player, "ally");
 		else if (gameState.sharedScript.playersData[evt.player].isNeutral[PlayerID] && gameState.isPlayerEnemy(evt.player))
 			this.handleDiplomacyRequest(gameState, evt.player, "neutral");
 	}
 
 	// These events will only be sent by other AI players
 	for (let evt of events.DiplomacyRequest)
 	{
 		if (evt.player !== PlayerID)
 			continue;
 
 		this.handleDiplomacyRequest(gameState, evt.source, evt.to);
 		let request = this.receivedDiplomacyRequests.get(evt.source);
 		if (this.Config.debug > 0)
 			API3.warn("Responding to diplomacy request from AI player " + evt.source + " with " + uneval(request));
 
 		// Our diplomacy will have changed already if the response was "accept"
 		if (request.status === "waitingForTribute")
 		{
 			Engine.PostCommand(PlayerID, {
 				"type": "tribute-request",
 				"source": PlayerID,
 				"player": evt.source,
 				"resourceWanted": request.wanted,
 				"resourceType": request.type
 			});
 		}
 	}
 
 	// An AI player we sent a diplomacy request to demanded we send them a tribute
 	for (let evt of events.TributeRequest)
 	{
 		if (evt.player !== PlayerID)
 			continue;
 
 		let availableResources = gameState.ai.queueManager.getAvailableResources(gameState);
 		// TODO: Save this event and wait until we get more resources if we don't have enough
 		if (evt.resourceWanted < availableResources[evt.resourceType])
 		{
 			let responseTribute = {};
 			responseTribute[evt.resourceType] = evt.resourceWanted;
 			if (this.Config.debug > 0)
 				API3.warn("Responding to tribute request from AI player " + evt.source + " with " + uneval(responseTribute));
 			Engine.PostCommand(PlayerID, { "type": "tribute", "player": evt.source, "amounts": responseTribute });
 			this.nextTributeUpdate = gameState.ai.elapsedTime + 15;
 		}
 	}
 };
 
 /**
  * If the "Last Man Standing" option is enabled, check if the only remaining players are allies or neutral.
  * If so, turn against the strongest first, but be more likely to first turn against neutral players, if there are any.
  */
 PETRA.DiplomacyManager.prototype.lastManStandingCheck = function(gameState)
 {
 	if (gameState.sharedScript.playersData[PlayerID].teamsLocked || gameState.isCeasefireActive() ||
 	    gameState.getAlliedVictory() && gameState.hasAllies())
 		return;
 
 	if (gameState.hasEnemies())
 	{
 		this.waitingToBetray = false;
 		return;
 	}
 
 	if (!gameState.hasAllies() && !gameState.hasNeutrals())
 		return;
 
 	// wait a bit before turning
 	if (!this.waitingToBetray)
 	{
 		this.betrayLapseTime = gameState.ai.elapsedTime + randFloat(10, 110);
 		this.waitingToBetray = true;
 		return;
 	}
 
 	// do not turn against a player yet if we are not strong enough
 	if (gameState.getOwnUnits().length < 50)
 	{
 		this.betrayLapseTime += 60;
 		return;
 	}
 
 	let playerToTurnAgainst;
 	let turnFactor = 0;
 	let max = 0;
 
 	// count the amount of entities remaining players have
 	for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
 	{
 		if (i === PlayerID || gameState.ai.HQ.attackManager.defeated[i])
 			continue;
 
 		turnFactor = gameState.getEntities(i).length;
 
 		if (gameState.isPlayerNeutral(i)) // be more inclined to turn against neutral players
 			turnFactor += this.betrayWeighting;
 
 		if (gameState.getVictoryConditions().has("wonder"))
 		{
 			let wonder = gameState.getEnemyStructures(i).filter(API3.Filters.byClass("Wonder"))[0];
 			if (wonder)
 			{
 				let wonderProgess = wonder.foundationProgress();
 				if (wonderProgess === undefined)
 				{
 					playerToTurnAgainst = i;
 					break;
 				}
 				turnFactor += wonderProgess * 2.5 + this.betrayWeighting;
 			}
 		}
 
 		if (gameState.getVictoryConditions().has("capture_the_relic"))
 		{
 			let relicsCount = gameState.updatingGlobalCollection("allRelics", API3.Filters.byClass("Relic"))
 				.filter(relic => relic.owner() === i).length;
 			turnFactor += relicsCount * this.betrayWeighting;
 		}
 
 		if (turnFactor < max)
 			continue;
 
 		max = turnFactor;
 		playerToTurnAgainst = i;
 	}
 
 	if (playerToTurnAgainst)
 	{
 		this.changePlayerDiplomacy(gameState, playerToTurnAgainst, "enemy");
 		let request = this.receivedDiplomacyRequests.get(playerToTurnAgainst);
 		if (request && request.status !== "allianceBroken")
 		{
 			if (request.status === "waitingForTribute")
 				PETRA.chatAnswerRequestDiplomacy(gameState, player, request.requestType, "decline");
 			request.status = request.status === "accepted" ? "allianceBroken" : "declinedRequest";
 		}
 		// If we had sent this player a diplomacy request, just rescind it
 		this.sentDiplomacyRequests.delete(playerToTurnAgainst);
 	}
 	this.betrayLapseTime = -1;
 	this.waitingToBetray = false;
 };
 
 /**
  * Do not become allies with a player if the game would be over.
  * Overall, be reluctant to become allies with any one player, but be more likely to accept neutral requests.
  */
 PETRA.DiplomacyManager.prototype.handleDiplomacyRequest = function(gameState, player, requestType)
 {
 	if (gameState.sharedScript.playersData[PlayerID].teamsLocked)
 		return;
 	let response;
 	let requiredTribute;
 	let request = this.receivedDiplomacyRequests.get(player);
 	let moreEnemiesThanAllies = gameState.getEnemies().length > gameState.getMutualAllies().length;
 
 	// For any given diplomacy request be likely to permanently decline
 	if (!request && gameState.getPlayerCiv() !== gameState.getPlayerCiv(player) && randBool(0.6) ||
 	    !moreEnemiesThanAllies || gameState.ai.HQ.attackManager.currentEnemyPlayer === player)
 	{
 		this.receivedDiplomacyRequests.set(player, { "requestType": requestType, "status": "declinedRequest" });
 		response = "decline";
 	}
 	else if (request && request.status !== "accepted" && request.requestType !== "ally")
 	{
 		if (request.status === "declinedRequest")
 			response = "decline";
 		else if (request.status === "allianceBroken") // Previous alliance was broken, so decline
 			response = "declineRepeatedOffer";
 		else if (request.status === "waitingForTribute")
 		{
 			response = "waitingForTribute";
 			requiredTribute = request;
 		}
 	}
 	else if (requestType === "ally" && gameState.getEntities(player).length < gameState.getOwnEntities().length && randBool(0.4) ||
 	         requestType === "neutral" && moreEnemiesThanAllies && randBool(0.8))
 	{
 		response = "accept";
 		this.changePlayerDiplomacy(gameState, player, requestType);
 		this.receivedDiplomacyRequests.set(player, { "requestType": requestType, "status": "accepted" });
 	}
 	else
 	{
-		response = "acceptWithTribute";
-		requiredTribute = gameState.ai.HQ.pickMostNeededResources(gameState)[0];
-		requiredTribute.wanted = Math.max(1000, gameState.getOwnUnits().length * (requestType === "ally" ? 10 : 5));
-		this.receivedDiplomacyRequests.set(player, {
-			"status": "waitingForTribute",
-			"wanted": requiredTribute.wanted,
-			"type": requiredTribute.type,
-			"warnTime": gameState.ai.elapsedTime + 60,
-			"sentWarning": false,
-			"requestType": requestType
-		});
+		// Try to request a tribute.
+		// If a resource is not tributable, do not request it.
+		// If no resources are tributable, decline.
+		let resTribCodes = Resources.GetTributableCodes();
+		if (resTribCodes.length)
+		{
+			requiredTribute = gameState.ai.HQ.pickMostNeededResources(gameState, resTribCodes)[0];
+			response = "acceptWithTribute";
+			requiredTribute.wanted = Math.max(1000, gameState.getOwnUnits().length * (requestType === "ally" ? 10 : 5));
+			this.receivedDiplomacyRequests.set(player, {
+				"status": "waitingForTribute",
+				"wanted": requiredTribute.wanted,
+				"type": requiredTribute.type,
+				"warnTime": gameState.ai.elapsedTime + 60,
+				"sentWarning": false,
+				"requestType": requestType
+			});
+		}
+		else
+		{
+			this.receivedDiplomacyRequests.set(player, { "requestType": requestType, "status": "declinedRequest" });
+			response = "decline";
+		}
 	}
 	PETRA.chatAnswerRequestDiplomacy(gameState, player, requestType, response, requiredTribute);
 };
 
 PETRA.DiplomacyManager.prototype.changePlayerDiplomacy = function(gameState, player, newDiplomaticStance)
 {
 	if (gameState.isPlayerEnemy(player) && (newDiplomaticStance === "ally" || newDiplomaticStance === "neutral"))
 		gameState.ai.HQ.attackManager.cancelAttacksAgainstPlayer(gameState, player);
 	Engine.PostCommand(PlayerID, { "type": "diplomacy", "player": player, "to": newDiplomaticStance });
 	if (this.Config.debug > 1)
 		API3.warn("diplomacy stance with player " + player + " is now " + newDiplomaticStance);
 	if (this.Config.chat)
 		PETRA.chatNewDiplomacy(gameState, player, newDiplomaticStance);
 };
 
 PETRA.DiplomacyManager.prototype.checkRequestedTributes = function(gameState)
 {
 	for (let [player, data] of this.receivedDiplomacyRequests)
 		if (data.status === "waitingForTribute" && gameState.ai.elapsedTime > data.warnTime)
 		{
 			if (data.sentWarning)
 			{
 				this.receivedDiplomacyRequests.delete(player);
 				PETRA.chatAnswerRequestDiplomacy(gameState, player, data.requestType, "decline");
 			}
 			else
 			{
 				data.sentWarning = true;
 				data.warnTime = gameState.ai.elapsedTime + 60;
 				PETRA.chatAnswerRequestDiplomacy(gameState, player, data.requestType, "waitingForTribute", {
 					"wanted": data.wanted,
 					"type": data.type
 				});
 			}
 		}
 };
 
 /**
  * Try to become allies with a player who has a lot of mutual enemies in common with us.
  * TODO: Possibly let human players demand tributes from AIs who send diplomacy requests.
  */
 PETRA.DiplomacyManager.prototype.sendDiplomacyRequest = function(gameState)
 {
 	let player;
 	let max = 0;
 	for (let i = 1; i < gameState.sharedScript.playersData.length; ++i)
 	{
 		let mutualEnemies = 0;
 		let request = this.receivedDiplomacyRequests.get(i); // Do not send to players we have already rejected before
 		if (i === PlayerID || gameState.isPlayerMutualAlly(i) || gameState.ai.HQ.attackManager.defeated[i] ||
 		    gameState.ai.HQ.attackManager.currentEnemyPlayer === i ||
 		    this.sentDiplomacyRequests.get(i) !== undefined || request && request.status === "declinedRequest")
 			continue;
 
 		for (let j = 1; j < gameState.sharedScript.playersData.length; ++j)
 		{
 			if (gameState.sharedScript.playersData[i].isEnemy[j] && gameState.isPlayerEnemy(j) &&
 			    !gameState.ai.HQ.attackManager.defeated[j])
 				++mutualEnemies;
 
 			if (mutualEnemies < max)
 				continue;
 
 			max = mutualEnemies;
 			player = i;
 		}
 	}
 	if (!player)
 		return;
 
 	let requestType = gameState.isPlayerNeutral(player) ? "ally" : "neutral";
 
 	this.sentDiplomacyRequests.set(player, {
 		"requestType": requestType,
 		"timeSent": gameState.ai.elapsedTime
 	});
 
 	if (this.Config.debug > 0)
 		API3.warn("Sending diplomacy request to player " + player + " with " + requestType);
 	Engine.PostCommand(PlayerID, { "type": "diplomacy-request", "source": PlayerID, "player": player, "to": requestType });
 	PETRA.chatNewRequestDiplomacy(gameState, player, requestType, "sendRequest");
 };
 
 PETRA.DiplomacyManager.prototype.checkSentDiplomacyRequests = function(gameState)
 {
 	for (let [player, data] of this.sentDiplomacyRequests)
 		if (gameState.ai.elapsedTime > data.timeSent + 60 && !gameState.ai.HQ.saveResources &&
 		    gameState.getPopulation() > 70)
 		{
 			PETRA.chatNewRequestDiplomacy(gameState, player, data.requestType, "requestExpired");
 			this.sentDiplomacyRequests.delete(player);
 		}
 };
 
 PETRA.DiplomacyManager.prototype.update = function(gameState, events)
 {
 	this.checkEvents(gameState, events);
 
-	if (!gameState.ai.HQ.saveResources && gameState.ai.elapsedTime > this.nextTributeUpdate)
+	if (Resources.GetTributableCodes().length && !gameState.ai.HQ.saveResources && gameState.ai.elapsedTime > this.nextTributeUpdate)
 		this.tributes(gameState);
 
 	if (this.waitingToBetray && gameState.ai.elapsedTime > this.betrayLapseTime)
 		this.lastManStandingCheck(gameState);
 
 	this.checkRequestedTributes(gameState);
 
 	if (gameState.sharedScript.playersData[PlayerID].teamsLocked || gameState.isCeasefireActive())
 		return;
 
 	// Be unlikely to send diplomacy requests to other players
 	if (gameState.ai.elapsedTime > this.sentDiplomacyRequestLapseTime)
 	{
 		this.sentDiplomacyRequestLapseTime = gameState.ai.elapsedTime + 300 + randFloat(10, 100);
 		let numEnemies = gameState.getEnemies().length;
 		// Don't consider gaia
 		if (numEnemies > 2 && gameState.getMutualAllies().length < numEnemies - 1 && randBool(0.1))
 			this.sendDiplomacyRequest(gameState);
 	}
 
 	this.checkSentDiplomacyRequests(gameState);
 };
 
 PETRA.DiplomacyManager.prototype.Serialize = function()
 {
 	return {
 		"nextTributeUpdate": this.nextTributeUpdate,
 		"nextTributeRequest": this.nextTributeRequest,
 		"betrayLapseTime": this.betrayLapseTime,
 		"waitingToBetray": this.waitingToBetray,
 		"betrayWeighting": this.betrayWeighting,
 		"receivedDiplomacyRequests": this.receivedDiplomacyRequests,
 		"sentDiplomacyRequests": this.sentDiplomacyRequests,
 		"sentDiplomacyRequestLapseTime": this.sentDiplomacyRequestLapseTime
 	};
 };
 
 PETRA.DiplomacyManager.prototype.Deserialize = function(data)
 {
 	for (let key in data)
 		this[key] = data[key];
 };
Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/headquarters.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/headquarters.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/headquarters.js	(revision 22970)
@@ -1,2890 +1,2896 @@
 /**
  * Headquarters
  * Deal with high level logic for the AI. Most of the interesting stuff gets done here.
  * Some tasks:
  *  -defining RESS needs
  *  -BO decisions.
  *     > training workers
  *     > building stuff (though we'll send that to bases)
  *  -picking strategy (specific manager?)
  *  -diplomacy -> diplomacyManager
  *  -planning attacks -> attackManager
  *  -picking new CC locations.
  */
 PETRA.HQ = function(Config)
 {
 	this.Config = Config;
 	this.phasing = 0;	// existing values: 0 means no, i > 0 means phasing towards phase i
 
 	// Cache various quantities.
 	this.turnCache = {};
 	this.lastFailedGather = {};
 
 	this.firstBaseConfig = false;
 	this.currentBase = 0;	// Only one base (from baseManager) is run every turn.
 
 	// Workers configuration
 	this.targetNumWorkers = this.Config.Economy.targetNumWorkers;
 	this.supportRatio = this.Config.Economy.supportRatio;
 
 	this.fortStartTime = 180;	// sentry defense towers, will start at fortStartTime + towerLapseTime
 	this.towerStartTime = 0;	// stone defense towers, will start as soon as available
 	this.towerLapseTime = this.Config.Military.towerLapseTime;
 	this.fortressStartTime = 0;	// will start as soon as available
 	this.fortressLapseTime = this.Config.Military.fortressLapseTime;
 	this.extraTowers = Math.round(Math.min(this.Config.difficulty, 3) * this.Config.personality.defensive);
 	this.extraFortresses = Math.round(Math.max(Math.min(this.Config.difficulty - 1, 2), 0) * this.Config.personality.defensive);
 
 	this.baseManagers = [];
 	this.attackManager = new PETRA.AttackManager(this.Config);
 	this.buildManager = new PETRA.BuildManager();
 	this.defenseManager = new PETRA.DefenseManager(this.Config);
 	this.tradeManager = new PETRA.TradeManager(this.Config);
 	this.navalManager = new PETRA.NavalManager(this.Config);
 	this.researchManager = new PETRA.ResearchManager(this.Config);
 	this.diplomacyManager = new PETRA.DiplomacyManager(this.Config);
 	this.garrisonManager = new PETRA.GarrisonManager(this.Config);
 	this.victoryManager = new PETRA.VictoryManager(this.Config);
 
 	this.capturableTargets = new Map();
 	this.capturableTargetsTime = 0;
 };
 
 /** More initialisation for stuff that needs the gameState */
 PETRA.HQ.prototype.init = function(gameState, queues)
 {
 	this.territoryMap = PETRA.createTerritoryMap(gameState);
 	// initialize base map. Each pixel is a base ID, or 0 if not or not accessible
 	this.basesMap = new API3.Map(gameState.sharedScript, "territory");
 	// create borderMap: flag cells on the border of the map
 	// then this map will be completed with our frontier in updateTerritories
 	this.borderMap = PETRA.createBorderMap(gameState);
 	// list of allowed regions
 	this.landRegions = {};
 	// try to determine if we have a water map
 	this.navalMap = false;
 	this.navalRegions = {};
 
 	this.treasures = gameState.getEntities().filter(ent => {
 		let type = ent.resourceSupplyType();
 		return type && type.generic == "treasure";
 	});
 	this.treasures.registerUpdates();
 	this.currentPhase = gameState.currentPhase();
 	this.decayingStructures = new Set();
 };
 
 /**
  * initialization needed after deserialization (only called when deserialization)
  */
 PETRA.HQ.prototype.postinit = function(gameState)
 {
 	// Rebuild the base maps from the territory indices of each base
 	this.basesMap = new API3.Map(gameState.sharedScript, "territory");
 	for (let base of this.baseManagers)
 		for (let j of base.territoryIndices)
 			this.basesMap.map[j] = base.ID;
 
 	for (let ent of gameState.getOwnEntities().values())
 	{
 		if (!ent.resourceDropsiteTypes() || !ent.hasClass("Structure"))
 			continue;
 		// Entities which have been built or have changed ownership after the last AI turn have no base.
 		// they will be dealt with in the next checkEvents
 		let baseID = ent.getMetadata(PlayerID, "base");
 		if (baseID === undefined)
 			continue;
 		let base = this.getBaseByID(baseID);
 		base.assignResourceToDropsite(gameState, ent);
 	}
 
 	this.updateTerritories(gameState);
 };
 
 /**
  * Create a new base in the baseManager:
  * If an existing one without anchor already exist, use it.
  * Otherwise create a new one.
  * TODO when buildings, criteria should depend on distance
  * allowedType: undefined       => new base with an anchor
  *              "unconstructed" => new base with a foundation anchor
  *              "captured"      => captured base with an anchor
  *              "anchorless"    => anchorless base, currently with dock
  */
 PETRA.HQ.prototype.createBase = function(gameState, ent, type)
 {
 	let access = PETRA.getLandAccess(gameState, ent);
 	let newbase;
 	for (let base of this.baseManagers)
 	{
 		if (base.accessIndex != access)
 			continue;
 		if (type != "anchorless" && base.anchor)
 			continue;
 		if (type != "anchorless")
 		{
 			// TODO we keep the fisrt one, we should rather use the nearest if buildings
 			// and possibly also cut on distance
 			newbase = base;
 			break;
 		}
 		else
 		{
 			// TODO here also test on distance instead of first
 			if (newbase && !base.anchor)
 				continue;
 			newbase = base;
 			if (newbase.anchor)
 				break;
 		}
 	}
 
 	if (this.Config.debug > 0)
 	{
 		API3.warn(" ----------------------------------------------------------");
 		API3.warn(" HQ createBase entrance avec access " + access + " and type " + type);
 		API3.warn(" with access " + uneval(this.baseManagers.map(base => base.accessIndex)) +
 			  " and base nbr " + uneval(this.baseManagers.map(base => base.ID)) +
 			  " and anchor " + uneval(this.baseManagers.map(base => !!base.anchor)));
 	}
 
 	if (!newbase)
 	{
 		newbase = new PETRA.BaseManager(gameState, this.Config);
 		newbase.init(gameState, type);
 		this.baseManagers.push(newbase);
 	}
 	else
 		newbase.reset(type);
 
 	if (type != "anchorless")
 		newbase.setAnchor(gameState, ent);
 	else
 		newbase.setAnchorlessEntity(gameState, ent);
 
 	return newbase;
 };
 
 /**
  * returns the sea index linking regions 1 and region 2 (supposed to be different land region)
  * otherwise return undefined
  * for the moment, only the case land-sea-land is supported
  */
 PETRA.HQ.prototype.getSeaBetweenIndices = function(gameState, index1, index2)
 {
 	let path = gameState.ai.accessibility.getTrajectToIndex(index1, index2);
 	if (path && path.length == 3 && gameState.ai.accessibility.regionType[path[1]] == "water")
 		return path[1];
 
 	if (this.Config.debug > 1)
 	{
 		API3.warn("bad path from " + index1 + " to " + index2 + " ??? " + uneval(path));
 		API3.warn(" regionLinks start " + uneval(gameState.ai.accessibility.regionLinks[index1]));
 		API3.warn(" regionLinks end   " + uneval(gameState.ai.accessibility.regionLinks[index2]));
 	}
 	return undefined;
 };
 
 /** TODO check if the new anchorless bases should be added to addBase */
 PETRA.HQ.prototype.checkEvents = function(gameState, events)
 {
 	let addBase = false;
 
 	this.buildManager.checkEvents(gameState, events);
 
 	if (events.TerritoriesChanged.length || events.DiplomacyChanged.length)
 		this.updateTerritories(gameState);
 
 	for (let evt of events.DiplomacyChanged)
 	{
 		if (evt.player != PlayerID && evt.otherPlayer != PlayerID)
 			continue;
 		// Reset the entities collections which depend on diplomacy
 		gameState.resetOnDiplomacyChanged();
 		break;
 	}
 
 	for (let evt of events.Destroy)
 	{
 		// Let's check we haven't lost an important building here.
 		if (evt && !evt.SuccessfulFoundation && evt.entityObj && evt.metadata && evt.metadata[PlayerID] &&
 			evt.metadata[PlayerID].base)
 		{
 			let ent = evt.entityObj;
 			if (ent.owner() != PlayerID)
 				continue;
 			// A new base foundation was created and destroyed on the same (AI) turn
 			if (evt.metadata[PlayerID].base == -1 || evt.metadata[PlayerID].base == -2)
 				continue;
 			let base = this.getBaseByID(evt.metadata[PlayerID].base);
 			if (ent.resourceDropsiteTypes() && ent.hasClass("Structure"))
 				base.removeDropsite(gameState, ent);
 			if (evt.metadata[PlayerID].baseAnchor && evt.metadata[PlayerID].baseAnchor === true)
 				base.anchorLost(gameState, ent);
 		}
 	}
 
 	for (let evt of events.EntityRenamed)
 	{
 		let ent = gameState.getEntityById(evt.newentity);
 		if (!ent || ent.owner() != PlayerID || ent.getMetadata(PlayerID, "base") === undefined)
 			continue;
 		let base = this.getBaseByID(ent.getMetadata(PlayerID, "base"));
 		if (!base.anchorId || base.anchorId != evt.entity)
 			continue;
 		base.anchorId = evt.newentity;
 		base.anchor = ent;
 	}
 
 	for (let evt of events.Create)
 	{
 		// Let's check if we have a valuable foundation needing builders quickly
 		// (normal foundations are taken care in baseManager.assignToFoundations)
 		let ent = gameState.getEntityById(evt.entity);
 		if (!ent || ent.owner() != PlayerID || ent.foundationProgress() === undefined)
 			continue;
 
 		if (ent.getMetadata(PlayerID, "base") == -1)	// Standard base around a cc
 		{
 			// Okay so let's try to create a new base around this.
 			let newbase = this.createBase(gameState, ent, "unconstructed");
 			// Let's get a few units from other bases there to build this.
 			let builders = this.bulkPickWorkers(gameState, newbase, 10);
 			if (builders !== false)
 			{
 				builders.forEach(worker => {
 					worker.setMetadata(PlayerID, "base", newbase.ID);
 					worker.setMetadata(PlayerID, "subrole", "builder");
 					worker.setMetadata(PlayerID, "target-foundation", ent.id());
 				});
 			}
 		}
 		else if (ent.getMetadata(PlayerID, "base") == -2)	// anchorless base around a dock
 		{
 			let newbase = this.createBase(gameState, ent, "anchorless");
 			// Let's get a few units from other bases there to build this.
 			let builders = this.bulkPickWorkers(gameState, newbase, 4);
 			if (builders != false)
 			{
 				builders.forEach(worker => {
 					worker.setMetadata(PlayerID, "base", newbase.ID);
 					worker.setMetadata(PlayerID, "subrole", "builder");
 					worker.setMetadata(PlayerID, "target-foundation", ent.id());
 				});
 			}
 		}
 	}
 
 	for (let evt of events.ConstructionFinished)
 	{
 		if (evt.newentity == evt.entity)  // repaired building
 			continue;
 		let ent = gameState.getEntityById(evt.newentity);
 		if (!ent || ent.owner() != PlayerID)
 			continue;
 		if (ent.hasClass("BarterMarket") && this.maxFields)
 			this.maxFields = false;
 		if (ent.getMetadata(PlayerID, "base") === undefined)
 			continue;
 		let base = this.getBaseByID(ent.getMetadata(PlayerID, "base"));
 		base.buildings.updateEnt(ent);
 		if (ent.resourceDropsiteTypes())
 			base.assignResourceToDropsite(gameState, ent);
 
 		if (ent.getMetadata(PlayerID, "baseAnchor") === true)
 		{
 			if (base.constructing)
 				base.constructing = false;
 			addBase = true;
 		}
 	}
 
 	for (let evt of events.OwnershipChanged)   // capture events
 	{
 		if (evt.from == PlayerID)
 		{
 			let ent = gameState.getEntityById(evt.entity);
 			if (!ent || ent.getMetadata(PlayerID, "base") === undefined)
 				continue;
 			let base = this.getBaseByID(ent.getMetadata(PlayerID, "base"));
 			if (ent.resourceDropsiteTypes() && ent.hasClass("Structure"))
 				base.removeDropsite(gameState, ent);
 			if (ent.getMetadata(PlayerID, "baseAnchor") === true)
 				base.anchorLost(gameState, ent);
 		}
 
 		if (evt.to != PlayerID)
 			continue;
 		let ent = gameState.getEntityById(evt.entity);
 		if (!ent)
 			continue;
 		if (ent.hasClass("Unit"))
 		{
 			PETRA.getBestBase(gameState, ent).assignEntity(gameState, ent);
 			ent.setMetadata(PlayerID, "role", undefined);
 			ent.setMetadata(PlayerID, "subrole", undefined);
 			ent.setMetadata(PlayerID, "plan", undefined);
 			ent.setMetadata(PlayerID, "PartOfArmy", undefined);
 			if (ent.hasClass("Trader"))
 			{
 				ent.setMetadata(PlayerID, "role", "trader");
 				ent.setMetadata(PlayerID, "route", undefined);
 			}
 			if (ent.hasClass("Worker"))
 			{
 				ent.setMetadata(PlayerID, "role", "worker");
 				ent.setMetadata(PlayerID, "subrole", "idle");
 			}
 			if (ent.hasClass("Ship"))
 				PETRA.setSeaAccess(gameState, ent);
 			if (!ent.hasClass("Support") && !ent.hasClass("Ship") && ent.attackTypes() !== undefined)
 				ent.setMetadata(PlayerID, "plan", -1);
 			continue;
 		}
 		if (ent.hasClass("CivCentre"))   // build a new base around it
 		{
 			let newbase;
 			if (ent.foundationProgress() !== undefined)
 				newbase = this.createBase(gameState, ent, "unconstructed");
 			else
 			{
 				newbase = this.createBase(gameState, ent, "captured");
 				addBase = true;
 			}
 			newbase.assignEntity(gameState, ent);
 		}
 		else
 		{
 			let base;
 			// If dropsite on new island, create a base around it
 			if (!ent.decaying() && ent.resourceDropsiteTypes())
 				base = this.createBase(gameState, ent, "anchorless");
 			else
 				base = PETRA.getBestBase(gameState, ent) || this.baseManagers[0];
 			base.assignEntity(gameState, ent);
 			if (ent.decaying())
 			{
 				if (ent.isGarrisonHolder() && this.garrisonManager.addDecayingStructure(gameState, evt.entity, true))
 					continue;
 				if (!this.decayingStructures.has(evt.entity))
 					this.decayingStructures.add(evt.entity);
 			}
 		}
 	}
 
 	// deal with the different rally points of training units: the rally point is set when the training starts
 	// for the time being, only autogarrison is used
 
 	for (let evt of events.TrainingStarted)
 	{
 		let ent = gameState.getEntityById(evt.entity);
 		if (!ent || !ent.isOwn(PlayerID))
 			continue;
 
 		if (!ent._entity.trainingQueue || !ent._entity.trainingQueue.length)
 			continue;
 		let metadata = ent._entity.trainingQueue[0].metadata;
 		if (metadata && metadata.garrisonType)
 			ent.setRallyPoint(ent, "garrison");  // trained units will autogarrison
 		else
 			ent.unsetRallyPoint();
 	}
 
 	for (let evt of events.TrainingFinished)
 	{
 		for (let entId of evt.entities)
 		{
 			let ent = gameState.getEntityById(entId);
 			if (!ent || !ent.isOwn(PlayerID))
 				continue;
 
 			if (!ent.position())
 			{
 				// we are autogarrisoned, check that the holder is registered in the garrisonManager
 				let holderId = ent.unitAIOrderData()[0].target;
 				let holder = gameState.getEntityById(holderId);
 				if (holder)
 					this.garrisonManager.registerHolder(gameState, holder);
 			}
 			else if (ent.getMetadata(PlayerID, "garrisonType"))
 			{
 				// we were supposed to be autogarrisoned, but this has failed (may-be full)
 				ent.setMetadata(PlayerID, "garrisonType", undefined);
 			}
 
 			// Check if this unit is no more needed in its attack plan
 			// (happen when the training ends after the attack is started or aborted)
 			let plan = ent.getMetadata(PlayerID, "plan");
 			if (plan !== undefined && plan >= 0)
 			{
 				let attack = this.attackManager.getPlan(plan);
 				if (!attack || attack.state != "unexecuted")
 					ent.setMetadata(PlayerID, "plan", -1);
 			}
 			// Assign it immediately to something useful to do
 			if (ent.getMetadata(PlayerID, "role") == "worker")
 			{
 				let base;
 				if (ent.getMetadata(PlayerID, "base") === undefined)
 				{
 					base = PETRA.getBestBase(gameState, ent);
 					base.assignEntity(gameState, ent);
 				}
 				else
 					base = this.getBaseByID(ent.getMetadata(PlayerID, "base"));
 				base.reassignIdleWorkers(gameState, [ent]);
 				base.workerObject.update(gameState, ent);
 			}
 			else if (ent.resourceSupplyType() && ent.position())
 			{
 				let type = ent.resourceSupplyType();
 				if (!type.generic)
 					continue;
 				let dropsites = gameState.getOwnDropsites(type.generic);
 				let pos = ent.position();
 				let access = PETRA.getLandAccess(gameState, ent);
 				let distmin = Math.min();
 				let goal;
 				for (let dropsite of dropsites.values())
 				{
 					if (!dropsite.position() || PETRA.getLandAccess(gameState, dropsite) != access)
 						continue;
 					let dist = API3.SquareVectorDistance(pos, dropsite.position());
 					if (dist > distmin)
 						continue;
 					distmin = dist;
 					goal = dropsite.position();
 				}
 				if (goal)
 					ent.moveToRange(goal[0], goal[1]);
 			}
 		}
 	}
 
 	for (let evt of events.TerritoryDecayChanged)
 	{
 		let ent = gameState.getEntityById(evt.entity);
 		if (!ent || !ent.isOwn(PlayerID) || ent.foundationProgress() !== undefined)
 			continue;
 		if (evt.to)
 		{
 			if (ent.isGarrisonHolder() && this.garrisonManager.addDecayingStructure(gameState, evt.entity))
 				continue;
 			if (!this.decayingStructures.has(evt.entity))
 				this.decayingStructures.add(evt.entity);
 		}
 		else if (ent.isGarrisonHolder())
 			this.garrisonManager.removeDecayingStructure(evt.entity);
 	}
 
 	if (addBase)
 	{
 		if (!this.firstBaseConfig)
 		{
 			// This is our first base, let us configure our starting resources
 			this.configFirstBase(gameState);
 		}
 		else
 		{
 			// Let us hope this new base will fix our possible resource shortage
 			this.saveResources = undefined;
 			this.saveSpace = undefined;
 			this.maxFields = false;
 		}
 	}
 
 	// Then deals with decaying structures: destroy them if being lost to enemy (except in easier difficulties)
 	if (this.Config.difficulty < 2)
 		return;
 	for (let entId of this.decayingStructures)
 	{
 		let ent = gameState.getEntityById(entId);
 		if (ent && ent.decaying() && ent.isOwn(PlayerID))
 		{
 			let capture = ent.capturePoints();
 			if (!capture)
 				continue;
 			let captureRatio = capture[PlayerID] / capture.reduce((a, b) => a + b);
 			if (captureRatio < 0.50)
 				continue;
 			let decayToGaia = true;
 			for (let i = 1; i < capture.length; ++i)
 			{
 				if (gameState.isPlayerAlly(i) || !capture[i])
 					continue;
 				decayToGaia = false;
 				break;
 			}
 			if (decayToGaia)
 				continue;
 			let ratioMax = 0.7 + randFloat(0, 0.1);
 			for (let evt of events.Attacked)
 			{
 				if (ent.id() != evt.target)
 					continue;
 				ratioMax = 0.85 + randFloat(0, 0.1);
 				break;
 			}
 			if (captureRatio > ratioMax)
 				continue;
 			ent.destroy();
 		}
 		this.decayingStructures.delete(entId);
 	}
 };
 
 /** Ensure that all requirements are met when phasing up*/
 PETRA.HQ.prototype.checkPhaseRequirements = function(gameState, queues)
 {
 	if (gameState.getNumberOfPhases() == this.currentPhase)
 		return;
 
 	let requirements = gameState.getPhaseEntityRequirements(this.currentPhase + 1);
 	let plan;
 	let queue;
 	for (let entityReq of requirements)
 	{
 		// Village requirements are met elsewhere by constructing more houses
 		if (entityReq.class == "Village" || entityReq.class == "NotField")
 			continue;
 		if (gameState.getOwnEntitiesByClass(entityReq.class, true).length >= entityReq.count)
 			continue;
 		switch (entityReq.class)
 		{
 		case "Town":
 			if (!queues.economicBuilding.hasQueuedUnits() &&
 			    !queues.militaryBuilding.hasQueuedUnits() &&
 			    !queues.defenseBuilding.hasQueuedUnits())
 			{
 				if (!gameState.getOwnEntitiesByClass("BarterMarket", true).hasEntities() &&
 				    this.canBuild(gameState, "structures/{civ}_market"))
 				{
 					plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_market", { "phaseUp": true });
 					queue = "economicBuilding";
 					break;
 				}
 				if (!gameState.getOwnEntitiesByClass("Temple", true).hasEntities() &&
 				    this.canBuild(gameState, "structures/{civ}_temple"))
 				{
 					plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_temple", { "phaseUp": true });
 					queue = "economicBuilding";
 					break;
 				}
 				if (!gameState.getOwnEntitiesByClass("Blacksmith", true).hasEntities() &&
 				    this.canBuild(gameState, "structures/{civ}_blacksmith"))
 				{
 					plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_blacksmith", { "phaseUp": true });
 					queue = "militaryBuilding";
 					break;
 				}
 				if (this.canBuild(gameState, "structures/{civ}_defense_tower"))
 				{
 					plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_defense_tower", { "phaseUp": true });
 					queue = "defenseBuilding";
 					break;
 				}
 			}
 			break;
 		default:
 			// All classes not dealt with inside vanilla game.
 			// We put them for the time being on the economic queue, except if wonder
 			queue = entityReq.class == "Wonder" ? "wonder" : "economicBuilding";
 			if (!queues[queue].hasQueuedUnits())
 			{
 				let structure = this.buildManager.findStructureWithClass(gameState, [entityReq.class]);
 				if (structure && this.canBuild(gameState, structure))
 					plan = new PETRA.ConstructionPlan(gameState, structure, { "phaseUp": true });
 			}
 		}
 
 		if (plan)
 		{
 			if (queue == "wonder")
 			{
 				gameState.ai.queueManager.changePriority("majorTech", 400, { "phaseUp": true });
 				plan.queueToReset = "majorTech";
 			}
 			else
 			{
 				gameState.ai.queueManager.changePriority(queue, 1000, { "phaseUp": true });
 				plan.queueToReset = queue;
 			}
 			queues[queue].addPlan(plan);
 			return;
 		}
 	}
 };
 
 /** Called by any "phase" research plan once it's started */
 PETRA.HQ.prototype.OnPhaseUp = function(gameState, phase)
 {
 };
 
 /** This code trains citizen workers, trying to keep close to a ratio of worker/soldiers */
 PETRA.HQ.prototype.trainMoreWorkers = function(gameState, queues)
 {
 	// default template
 	let requirementsDef = [ ["costsResource", 1, "food"] ];
 	let classesDef = ["Support", "Worker"];
 	let templateDef = this.findBestTrainableUnit(gameState, classesDef, requirementsDef);
 
 	// counting the workers that aren't part of a plan
 	let numberOfWorkers = 0;   // all workers
 	let numberOfSupports = 0;  // only support workers (i.e. non fighting)
 	gameState.getOwnUnits().forEach(ent => {
 		if (ent.getMetadata(PlayerID, "role") == "worker" && ent.getMetadata(PlayerID, "plan") === undefined)
 		{
 			++numberOfWorkers;
 			if (ent.hasClass("Support"))
 				++numberOfSupports;
 		}
 	});
 	let numberInTraining = 0;
 	gameState.getOwnTrainingFacilities().forEach(function(ent) {
 		for (let item of ent.trainingQueue())
 		{
 			numberInTraining += item.count;
 			if (item.metadata && item.metadata.role && item.metadata.role == "worker" &&
 			    item.metadata.plan === undefined)
 			{
 				numberOfWorkers += item.count;
 				if (item.metadata.support)
 					numberOfSupports += item.count;
 			}
 		}
 	});
 
 	// Anticipate the optimal batch size when this queue will start
 	// and adapt the batch size of the first and second queued workers to the present population
 	// to ease a possible recovery if our population was drastically reduced by an attack
 	// (need to go up to second queued as it is accounted in queueManager)
 	let size = numberOfWorkers < 12 ? 1 : Math.min(5, Math.ceil(numberOfWorkers / 10));
 	if (queues.villager.plans[0])
 	{
 		queues.villager.plans[0].number = Math.min(queues.villager.plans[0].number, size);
 		if (queues.villager.plans[1])
 			queues.villager.plans[1].number = Math.min(queues.villager.plans[1].number, size);
 	}
 	if (queues.citizenSoldier.plans[0])
 	{
 		queues.citizenSoldier.plans[0].number = Math.min(queues.citizenSoldier.plans[0].number, size);
 		if (queues.citizenSoldier.plans[1])
 			queues.citizenSoldier.plans[1].number = Math.min(queues.citizenSoldier.plans[1].number, size);
 	}
 
 	let numberOfQueuedSupports = queues.villager.countQueuedUnits();
 	let numberOfQueuedSoldiers = queues.citizenSoldier.countQueuedUnits();
 	let numberQueued = numberOfQueuedSupports + numberOfQueuedSoldiers;
 	let numberTotal = numberOfWorkers + numberQueued;
 
 	if (this.saveResources && numberTotal > this.Config.Economy.popPhase2 + 10)
 		return;
 	if (numberTotal > this.targetNumWorkers || (numberTotal >= this.Config.Economy.popPhase2 &&
 		this.currentPhase == 1 && !gameState.isResearching(gameState.getPhaseName(2))))
 		return;
 	if (numberQueued > 50 || (numberOfQueuedSupports > 20 && numberOfQueuedSoldiers > 20) || numberInTraining > 15)
 		return;
 
 	// Choose whether we want soldiers or support units: when full pop, we aim at targetNumWorkers workers
 	// with supportRatio fraction of support units. But we want to have more support (less cost) at startup.
 	// So we take: supportRatio*targetNumWorkers*(1 - exp(-alfa*currentWorkers/supportRatio/targetNumWorkers))
 	// This gives back supportRatio*targetNumWorkers when currentWorkers >> supportRatio*targetNumWorkers
 	// and gives a ratio alfa at startup.
 
 	let supportRatio = this.supportRatio;
 	let alpha = 0.85;
 	if (!gameState.isTemplateAvailable(gameState.applyCiv("structures/{civ}_field")))
 		supportRatio = Math.min(this.supportRatio, 0.1);
 	if (this.attackManager.rushNumber < this.attackManager.maxRushes || this.attackManager.upcomingAttacks.Rush.length)
 		alpha = 0.7;
 	if (gameState.isCeasefireActive())
 		alpha += (1 - alpha) * Math.min(Math.max(gameState.ceasefireTimeRemaining - 120, 0), 180) / 180;
 	let supportMax = supportRatio * this.targetNumWorkers;
 	let supportNum = supportMax * (1 - Math.exp(-alpha*numberTotal/supportMax));
 
 	let template;
 	if (!templateDef || numberOfSupports + numberOfQueuedSupports > supportNum)
 	{
 		let requirements;
 		if (numberTotal < 45)
 			requirements = [ ["speed", 0.5], ["costsResource", 0.5, "stone"], ["costsResource", 0.5, "metal"] ];
 		else
 			requirements = [ ["strength", 1] ];
 
 		let classes = ["CitizenSoldier", "Infantry"];
 		//  We want at least 33% ranged and 33% melee
 		classes.push(pickRandom(["Ranged", "Melee", "Infantry"]));
 
 		template = this.findBestTrainableUnit(gameState, classes, requirements);
 	}
 
 	// If the template variable is empty, the default unit (Support unit) will be used
 	// base "0" means automatic choice of base
 	if (!template && templateDef)
 		queues.villager.addPlan(new PETRA.TrainingPlan(gameState, templateDef, { "role": "worker", "base": 0, "support": true }, size, size));
 	else if (template)
 		queues.citizenSoldier.addPlan(new PETRA.TrainingPlan(gameState, template, { "role": "worker", "base": 0 }, size, size));
 };
 
 /** picks the best template based on parameters and classes */
 PETRA.HQ.prototype.findBestTrainableUnit = function(gameState, classes, requirements)
 {
 	let units;
 	if (classes.indexOf("Hero") != -1)
 		units = gameState.findTrainableUnits(classes, []);
 	else if (classes.indexOf("Siege") != -1)	// We do not want siege tower as AI does not know how to use it
 		units = gameState.findTrainableUnits(classes, ["SiegeTower"]);
 	else						// We do not want hero when not explicitely specified
 		units = gameState.findTrainableUnits(classes, ["Hero"]);
 
 	if (!units.length)
 		return undefined;
 
 	let parameters = requirements.slice();
 	let remainingResources = this.getTotalResourceLevel(gameState);    // resources (estimation) still gatherable in our territory
 	let availableResources = gameState.ai.queueManager.getAvailableResources(gameState); // available (gathered) resources
 	for (let type in remainingResources)
 	{
 		if (availableResources[type] > 800)
 			continue;
 		if (remainingResources[type] > 800)
 			continue;
 		let costsResource = remainingResources[type] > 400 ? 0.6 : 0.2;
 		let toAdd = true;
 		for (let param of parameters)
 		{
 			if (param[0] != "costsResource" || param[2] != type)
 				continue;
 			param[1] = Math.min(param[1], costsResource);
 			toAdd = false;
 			break;
 		}
 		if (toAdd)
 			parameters.push(["costsResource", costsResource, type]);
 	}
 
 	units.sort((a, b) => {
 		let aCost = 1 + a[1].costSum();
 		let bCost = 1 + b[1].costSum();
 		let aValue = 0.1;
 		let bValue = 0.1;
 		for (let param of parameters)
 		{
 			if (param[0] == "strength")
 			{
 				aValue += PETRA.getMaxStrength(a[1], gameState.ai.Config.debug, gameState.ai.Config.DamageTypeImportance) * param[1];
 				bValue += PETRA.getMaxStrength(b[1], gameState.ai.Config.debug, gameState.ai.Config.DamageTypeImportance) * param[1];
 			}
 			else if (param[0] == "siegeStrength")
 			{
 				aValue += PETRA.getMaxStrength(a[1], gameState.ai.Config.debug, gameState.ai.Config.DamageTypeImportance, "Structure") * param[1];
 				bValue += PETRA.getMaxStrength(b[1], gameState.ai.Config.debug, gameState.ai.Config.DamageTypeImportance, "Structure") * param[1];
 			}
 			else if (param[0] == "speed")
 			{
 				aValue += a[1].walkSpeed() * param[1];
 				bValue += b[1].walkSpeed() * param[1];
 			}
 			else if (param[0] == "costsResource")
 			{
 				// requires a third parameter which is the resource
 				if (a[1].cost()[param[2]])
 					aValue *= param[1];
 				if (b[1].cost()[param[2]])
 					bValue *= param[1];
 			}
 			else if (param[0] == "canGather")
 			{
 				// checking against wood, could be anything else really.
 				if (a[1].resourceGatherRates() && a[1].resourceGatherRates()["wood.tree"])
 					aValue *= param[1];
 				if (b[1].resourceGatherRates() && b[1].resourceGatherRates()["wood.tree"])
 					bValue *= param[1];
 			}
 			else
 				API3.warn(" trainMoreUnits avec non prevu " + uneval(param));
 		}
 		return -aValue/aCost + bValue/bCost;
 	});
 	return units[0][0];
 };
 
 /**
  * returns an entity collection of workers through BaseManager.pickBuilders
  * TODO: when same accessIndex, sort by distance
  */
 PETRA.HQ.prototype.bulkPickWorkers = function(gameState, baseRef, number)
 {
 	let accessIndex = baseRef.accessIndex;
 	if (!accessIndex)
 		return false;
 	// sorting bases by whether they are on the same accessindex or not.
 	let baseBest = this.baseManagers.slice().sort((a, b) => {
 		if (a.accessIndex == accessIndex && b.accessIndex != accessIndex)
 			return -1;
 		else if (b.accessIndex == accessIndex && a.accessIndex != accessIndex)
 			return 1;
 		return 0;
 	});
 
 	let needed = number;
 	let workers = new API3.EntityCollection(gameState.sharedScript);
 	for (let base of baseBest)
 	{
 		if (base.ID == baseRef.ID)
 			continue;
 		base.pickBuilders(gameState, workers, needed);
 		if (workers.length >= number)
 			break;
 		needed = number - workers.length;
 	}
 	if (!workers.length)
 		return false;
 	return workers;
 };
 
 PETRA.HQ.prototype.getTotalResourceLevel = function(gameState)
 {
 	let total = {};
 	for (let res of Resources.GetCodes())
 		total[res] = 0;
 	for (let base of this.baseManagers)
 		for (let res in total)
 			total[res] += base.getResourceLevel(gameState, res);
 
 	return total;
 };
 
 /**
  * Returns the current gather rate
  * This is not per-se exact, it performs a few adjustments ad-hoc to account for travel distance, stuffs like that.
  */
 PETRA.HQ.prototype.GetCurrentGatherRates = function(gameState)
 {
 	if (!this.turnCache.currentRates)
 	{
 		let currentRates = {};
 		for (let res of Resources.GetCodes())
 			currentRates[res] = 0.5 * this.GetTCResGatherer(res);
 
 		for (let base of this.baseManagers)
 			base.addGatherRates(gameState, currentRates);
 
 		for (let res of Resources.GetCodes())
 			currentRates[res] = Math.max(currentRates[res], 0);
 
 		this.turnCache.currentRates = currentRates;
 	}
 
 	return this.turnCache.currentRates;
 };
 
 /**
  * Returns the wanted gather rate.
  */
 PETRA.HQ.prototype.GetWantedGatherRates = function(gameState)
 {
 	if (!this.turnCache.wantedRates)
 		this.turnCache.wantedRates = gameState.ai.queueManager.wantedGatherRates(gameState);
 
 	return this.turnCache.wantedRates;
 };
 
 /**
  * Pick the resource which most needs another worker
  * How this works:
  * We get the rates we would want to have to be able to deal with our plans
  * We get our current rates
  * We compare; we pick the one where the discrepancy is highest.
  * Need to balance long-term needs and possible short-term needs.
  */
-PETRA.HQ.prototype.pickMostNeededResources = function(gameState)
+PETRA.HQ.prototype.pickMostNeededResources = function(gameState, allowedResources = [])
 {
 	let wantedRates = this.GetWantedGatherRates(gameState);
 	let currentRates = this.GetCurrentGatherRates(gameState);
+	if (!allowedResources.length)
+		allowedResources = Resources.GetCodes();
 
 	let needed = [];
-	for (let res in wantedRates)
+	for (let res of allowedResources)
 		needed.push({ "type": res, "wanted": wantedRates[res], "current": currentRates[res] });
 
 	needed.sort((a, b) => {
 		if (a.current < a.wanted && b.current < b.wanted)
 		{
 			if (a.current && b.current)
 				return b.wanted / b.current - a.wanted / a.current;
 			if (a.current)
 				return 1;
 			if (b.current)
 				return -1;
 			return b.wanted - a.wanted;
 		}
 		if (a.current < a.wanted || a.wanted && !b.wanted)
 			return -1;
 		if (b.current < b.wanted || b.wanted && !a.wanted)
 			return 1;
 		return a.current - a.wanted - b.current + b.wanted;
 	});
 	return needed;
 };
 
 /**
  * Returns the best position to build a new Civil Center
  * Whose primary function would be to reach new resources of type "resource".
  */
 PETRA.HQ.prototype.findEconomicCCLocation = function(gameState, template, resource, proximity, fromStrategic)
 {
 	// This builds a map. The procedure is fairly simple. It adds the resource maps
 	//	(which are dynamically updated and are made so that they will facilitate DP placement)
 	// Then look for a good spot.
 
 	Engine.ProfileStart("findEconomicCCLocation");
 
 	// obstruction map
 	let obstructions = PETRA.createObstructionMap(gameState, 0, template);
 	let halfSize = 0;
 	if (template.get("Footprint/Square"))
 		halfSize = Math.max(+template.get("Footprint/Square/@depth"), +template.get("Footprint/Square/@width")) / 2;
 	else if (template.get("Footprint/Circle"))
 		halfSize = +template.get("Footprint/Circle/@radius");
 
 	let ccEnts = gameState.updatingGlobalCollection("allCCs", API3.Filters.byClass("CivCentre"));
 	let dpEnts = gameState.getOwnDropsites().filter(API3.Filters.not(API3.Filters.byClassesOr(["CivCentre", "Elephant"])));
 	let ccList = [];
 	for (let cc of ccEnts.values())
 		ccList.push({ "ent": cc, "pos": cc.position(), "ally": gameState.isPlayerAlly(cc.owner()) });
 	let dpList = [];
 	for (let dp of dpEnts.values())
 		dpList.push({ "ent": dp, "pos": dp.position(), "territory": this.territoryMap.getOwner(dp.position()) });
 
 	let bestIdx;
 	let bestVal;
 	let radius = Math.ceil(template.obstructionRadius().max / obstructions.cellSize);
 	let scale = 250 * 250;
 	let proxyAccess;
 	let nbShips = this.navalManager.transportShips.length;
 	if (proximity)	// this is our first base
 	{
 		// if our first base, ensure room around
 		radius = Math.ceil((template.obstructionRadius().max + 8) / obstructions.cellSize);
 		// scale is the typical scale at which we want to find a location for our first base
 		// look for bigger scale if we start from a ship (access < 2) or from a small island
 		let cellArea = gameState.getPassabilityMap().cellSize * gameState.getPassabilityMap().cellSize;
 		proxyAccess = gameState.ai.accessibility.getAccessValue(proximity);
 		if (proxyAccess < 2 || cellArea*gameState.ai.accessibility.regionSize[proxyAccess] < 24000)
 			scale = 400 * 400;
 	}
 
 	let width = this.territoryMap.width;
 	let cellSize = this.territoryMap.cellSize;
 
 	// DistanceSquare cuts to other ccs (bigger or no cuts on inaccessible ccs to allow colonizing other islands).
 	let reduce = (template.hasClass("Colony") ? 30 : 0) + 30 * this.Config.personality.defensive;
 	let nearbyRejected = Math.square(120);			// Reject if too near from any cc
 	let nearbyAllyRejected = Math.square(200);		// Reject if too near from an allied cc
 	let nearbyAllyDisfavored = Math.square(250);		// Disfavor if quite near an allied cc
 	let maxAccessRejected = Math.square(410);		// Reject if too far from an accessible ally cc
 	let maxAccessDisfavored = Math.square(360 - reduce);	// Disfavor if quite far from an accessible ally cc
 	let maxNoAccessDisfavored = Math.square(500);		// Disfavor if quite far from an inaccessible ally cc
 
 	let cut = 60;
 	if (fromStrategic || proximity)  // be less restrictive
 		cut = 30;
 
 	for (let j = 0; j < this.territoryMap.length; ++j)
 	{
 		if (this.territoryMap.getOwnerIndex(j) != 0)
 			continue;
 		// With enough room around to build the cc
 		let i = this.territoryMap.getNonObstructedTile(j, radius, obstructions);
 		if (i < 0)
 			continue;
 		// We require that it is accessible
 		let index = gameState.ai.accessibility.landPassMap[i];
 		if (!this.landRegions[index])
 			continue;
 		if (proxyAccess && nbShips == 0 && proxyAccess != index)
 			continue;
 
 		let norm = 0.5;   // TODO adjust it, knowing that we will sum 5 maps
 		// Checking distance to other cc
 		let pos = [cellSize * (j%width+0.5), cellSize * (Math.floor(j/width)+0.5)];
 		// We will be more tolerant for cc around our oversea docks
 		let oversea = false;
 
 		if (proximity)	// This is our first cc, let's do it near our units
 			norm /= 1 + API3.SquareVectorDistance(proximity, pos) / scale;
 		else
 		{
 			let minDist = Math.min();
 			let accessible = false;
 
 			for (let cc of ccList)
 			{
 				let dist = API3.SquareVectorDistance(cc.pos, pos);
 				if (dist < nearbyRejected)
 				{
 					norm = 0;
 					break;
 				}
 				if (!cc.ally)
 					continue;
 				if (dist < nearbyAllyRejected)
 				{
 					norm = 0;
 					break;
 				}
 				if (dist < nearbyAllyDisfavored)
 					norm *= 0.5;
 
 				if (dist < minDist)
 					minDist = dist;
 				accessible = accessible || index == PETRA.getLandAccess(gameState, cc.ent);
 			}
 			if (norm == 0)
 				continue;
 
 			if (accessible && minDist > maxAccessRejected)
 				continue;
 
 			if (minDist > maxAccessDisfavored)     // Disfavor if quite far from any allied cc
 			{
 				if (!accessible)
 				{
 					if (minDist > maxNoAccessDisfavored)
 						norm *= 0.5;
 					else
 						norm *= 0.8;
 				}
 				else
 					norm *= 0.5;
 			}
 
 			// Not near any of our dropsite, except for oversea docks
 			oversea = !accessible && dpList.some(dp => PETRA.getLandAccess(gameState, dp.ent) == index);
 			if (!oversea)
 			{
 				for (let dp of dpList)
 				{
 					let dist = API3.SquareVectorDistance(dp.pos, pos);
 					if (dist < 3600)
 					{
 						norm = 0;
 						break;
 					}
 					else if (dist < 6400)
 						norm *= 0.5;
 				}
 			}
 			if (norm == 0)
 				continue;
 		}
 
 		if (this.borderMap.map[j] & PETRA.fullBorder_Mask)	// disfavor the borders of the map
 			norm *= 0.5;
 
 		let val = 2*gameState.sharedScript.ccResourceMaps[resource].map[j];
 		for (let res in gameState.sharedScript.resourceMaps)
 			if (res != "food")
 				val += gameState.sharedScript.ccResourceMaps[res].map[j];
 		val *= norm;
 
 		// If oversea, be just above threshold to be accepted if nothing else
 		if (oversea)
 			val = Math.max(val, cut + 0.1);
 
 		if (bestVal !== undefined && val < bestVal)
 			continue;
 		if (this.isDangerousLocation(gameState, pos, halfSize))
 			continue;
 		bestVal = val;
 		bestIdx = i;
 	}
 
 	Engine.ProfileStop();
 
 	if (bestVal === undefined)
 		return false;
 	if (this.Config.debug > 1)
 		API3.warn("we have found a base for " + resource + " with best (cut=" + cut + ") = " + bestVal);
 	// not good enough.
 	if (bestVal < cut)
 		return false;
 
 	let x = (bestIdx % obstructions.width + 0.5) * obstructions.cellSize;
 	let z = (Math.floor(bestIdx / obstructions.width) + 0.5) * obstructions.cellSize;
 
 	// Define a minimal number of wanted ships in the seas reaching this new base
 	let indexIdx = gameState.ai.accessibility.landPassMap[bestIdx];
 	for (let base of this.baseManagers)
 	{
 		if (!base.anchor || base.accessIndex == indexIdx)
 			continue;
 		let sea = this.getSeaBetweenIndices(gameState, base.accessIndex, indexIdx);
 		if (sea !== undefined)
 			this.navalManager.setMinimalTransportShips(gameState, sea, 1);
 	}
 
 	return [x, z];
 };
 
 /**
  * Returns the best position to build a new Civil Center
  * Whose primary function would be to assure territorial continuity with our allies
  */
 PETRA.HQ.prototype.findStrategicCCLocation = function(gameState, template)
 {
 	// This builds a map. The procedure is fairly simple.
 	// We minimize the Sum((dist-300)**2) where the sum is on the three nearest allied CC
 	// with the constraints that all CC have dist > 200 and at least one have dist < 400
 	// This needs at least 2 CC. Otherwise, go back to economic CC.
 
 	let ccEnts = gameState.updatingGlobalCollection("allCCs", API3.Filters.byClass("CivCentre"));
 	let ccList = [];
 	let numAllyCC = 0;
 	for (let cc of ccEnts.values())
 	{
 		let ally = gameState.isPlayerAlly(cc.owner());
 		ccList.push({ "pos": cc.position(), "ally": ally });
 		if (ally)
 			++numAllyCC;
 	}
 	if (numAllyCC < 2)
 		return this.findEconomicCCLocation(gameState, template, "wood", undefined, true);
 
 	Engine.ProfileStart("findStrategicCCLocation");
 
 	// obstruction map
 	let obstructions = PETRA.createObstructionMap(gameState, 0, template);
 	let halfSize = 0;
 	if (template.get("Footprint/Square"))
 		halfSize = Math.max(+template.get("Footprint/Square/@depth"), +template.get("Footprint/Square/@width")) / 2;
 	else if (template.get("Footprint/Circle"))
 		halfSize = +template.get("Footprint/Circle/@radius");
 
 	let bestIdx;
 	let bestVal;
 	let radius = Math.ceil(template.obstructionRadius().max / obstructions.cellSize);
 
 	let width = this.territoryMap.width;
 	let cellSize = this.territoryMap.cellSize;
 	let currentVal, delta;
 	let distcc0, distcc1, distcc2;
 	let favoredDistance = (template.hasClass("Colony") ? 220 : 280) - 40 * this.Config.personality.defensive;
 
 	for (let j = 0; j < this.territoryMap.length; ++j)
 	{
 		if (this.territoryMap.getOwnerIndex(j) != 0)
 			continue;
 		// with enough room around to build the cc
 		let i = this.territoryMap.getNonObstructedTile(j, radius, obstructions);
 		if (i < 0)
 			continue;
 		// we require that it is accessible
 		let index = gameState.ai.accessibility.landPassMap[i];
 		if (!this.landRegions[index])
 			continue;
 
 		// checking distances to other cc
 		let pos = [cellSize * (j%width+0.5), cellSize * (Math.floor(j/width)+0.5)];
 		let minDist = Math.min();
 		distcc0 = undefined;
 
 		for (let cc of ccList)
 		{
 			let dist = API3.SquareVectorDistance(cc.pos, pos);
 			if (dist < 14000)    // Reject if too near from any cc
 			{
 				minDist = 0;
 				break;
 			}
 			if (!cc.ally)
 				continue;
 			if (dist < 62000)    // Reject if quite near from ally cc
 			{
 				minDist = 0;
 				break;
 			}
 			if (dist < minDist)
 				minDist = dist;
 
 			if (!distcc0 || dist < distcc0)
 			{
 				distcc2 = distcc1;
 				distcc1 = distcc0;
 				distcc0 = dist;
 			}
 			else if (!distcc1 || dist < distcc1)
 			{
 				distcc2 = distcc1;
 				distcc1 = dist;
 			}
 			else if (!distcc2 || dist < distcc2)
 				distcc2 = dist;
 		}
 		if (minDist < 1 || minDist > 170000 && !this.navalMap)
 			continue;
 
 		delta = Math.sqrt(distcc0) - favoredDistance;
 		currentVal = delta*delta;
 		delta = Math.sqrt(distcc1) - favoredDistance;
 		currentVal += delta*delta;
 		if (distcc2)
 		{
 			delta = Math.sqrt(distcc2) - favoredDistance;
 			currentVal += delta*delta;
 		}
 		// disfavor border of the map
 		if (this.borderMap.map[j] & PETRA.fullBorder_Mask)
 			currentVal += 10000;
 
 		if (bestVal !== undefined && currentVal > bestVal)
 			continue;
 		if (this.isDangerousLocation(gameState, pos, halfSize))
 			continue;
 		bestVal = currentVal;
 		bestIdx = i;
 	}
 
 	if (this.Config.debug > 1)
 		API3.warn("We've found a strategic base with bestVal = " + bestVal);
 
 	Engine.ProfileStop();
 
 	if (bestVal === undefined)
 		return undefined;
 
 	let x = (bestIdx % obstructions.width + 0.5) * obstructions.cellSize;
 	let z = (Math.floor(bestIdx / obstructions.width) + 0.5) * obstructions.cellSize;
 
 	// Define a minimal number of wanted ships in the seas reaching this new base
 	let indexIdx = gameState.ai.accessibility.landPassMap[bestIdx];
 	for (let base of this.baseManagers)
 	{
 		if (!base.anchor || base.accessIndex == indexIdx)
 			continue;
 		let sea = this.getSeaBetweenIndices(gameState, base.accessIndex, indexIdx);
 		if (sea !== undefined)
 			this.navalManager.setMinimalTransportShips(gameState, sea, 1);
 	}
 
 	return [x, z];
 };
 
 /**
  * Returns the best position to build a new market: if the allies already have a market, build it as far as possible
  * from it, although not in our border to be able to defend it easily. If no allied market, our second market will
  * follow the same logic.
  * To do so, we suppose that the gain/distance is an increasing function of distance and look for the max distance
  * for performance reasons.
  */
 PETRA.HQ.prototype.findMarketLocation = function(gameState, template)
 {
 	let markets = gameState.updatingCollection("diplo-ExclusiveAllyMarkets", API3.Filters.byClass("Market"), gameState.getExclusiveAllyEntities()).toEntityArray();
 	if (!markets.length)
 		markets = gameState.updatingCollection("OwnMarkets", API3.Filters.byClass("Market"), gameState.getOwnStructures()).toEntityArray();
 
 	if (!markets.length)	// this is the first market. For the time being, place it arbitrarily by the ConstructionPlan
 		return [-1, -1, -1, 0];
 
+	// No need for more than one market when we cannot trade.
+	if (!Resources.GetTradableCodes().length)
+		return false;
+
 	// obstruction map
 	let obstructions = PETRA.createObstructionMap(gameState, 0, template);
 	let halfSize = 0;
 	if (template.get("Footprint/Square"))
 		halfSize = Math.max(+template.get("Footprint/Square/@depth"), +template.get("Footprint/Square/@width")) / 2;
 	else if (template.get("Footprint/Circle"))
 		halfSize = +template.get("Footprint/Circle/@radius");
 
 	let bestIdx;
 	let bestJdx;
 	let bestVal;
 	let bestDistSq;
 	let bestGainMult;
 	let radius = Math.ceil(template.obstructionRadius().max / obstructions.cellSize);
 	let isNavalMarket = template.hasClass("NavalMarket");
 
 	let width = this.territoryMap.width;
 	let cellSize = this.territoryMap.cellSize;
 
 	let traderTemplatesGains = gameState.getTraderTemplatesGains();
 
 	for (let j = 0; j < this.territoryMap.length; ++j)
 	{
 		// do not try on the narrow border of our territory
 		if (this.borderMap.map[j] & PETRA.narrowFrontier_Mask)
 			continue;
 		if (this.basesMap.map[j] == 0)   // only in our territory
 			continue;
 		// with enough room around to build the market
 		let i = this.territoryMap.getNonObstructedTile(j, radius, obstructions);
 		if (i < 0)
 			continue;
 		let index = gameState.ai.accessibility.landPassMap[i];
 		if (!this.landRegions[index])
 			continue;
 		let pos = [cellSize * (j%width+0.5), cellSize * (Math.floor(j/width)+0.5)];
 		// checking distances to other markets
 		let maxVal = 0;
 		let maxDistSq;
 		let maxGainMult;
 		let gainMultiplier;
 		for (let market of markets)
 		{
 			if (isNavalMarket && market.hasClass("NavalMarket"))
 			{
 				if (PETRA.getSeaAccess(gameState, market) != gameState.ai.accessibility.getAccessValue(pos, true))
 					continue;
 				gainMultiplier = traderTemplatesGains.navalGainMultiplier;
 			}
 			else if (PETRA.getLandAccess(gameState, market) == index &&
 				!PETRA.isLineInsideEnemyTerritory(gameState, market.position(), pos))
 				gainMultiplier = traderTemplatesGains.landGainMultiplier;
 			else
 				continue;
 			if (!gainMultiplier)
 				continue;
 			let distSq = API3.SquareVectorDistance(market.position(), pos);
 			if (gainMultiplier * distSq > maxVal)
 			{
 				maxVal = gainMultiplier * distSq;
 				maxDistSq = distSq;
 				maxGainMult = gainMultiplier;
 			}
 		}
 		if (maxVal == 0)
 			continue;
 		if (bestVal !== undefined && maxVal < bestVal)
 			continue;
 		if (this.isDangerousLocation(gameState, pos, halfSize))
 			continue;
 		bestVal = maxVal;
 		bestDistSq = maxDistSq;
 		bestGainMult = maxGainMult;
 		bestIdx = i;
 		bestJdx = j;
 	}
 
 	if (this.Config.debug > 1)
 		API3.warn("We found a market position with bestVal = " + bestVal);
 
 	if (bestVal === undefined)  // no constraints. For the time being, place it arbitrarily by the ConstructionPlan
 		return [-1, -1, -1, 0];
 	let expectedGain = Math.round(bestGainMult * TradeGain(bestDistSq, gameState.sharedScript.mapSize));
 	if (this.Config.debug > 1)
 		API3.warn("this would give a trading gain of " + expectedGain);
 	// do not keep it if gain is too small, except if this is our first BarterMarket
 	let idx;
 	if (expectedGain < this.tradeManager.minimalGain)
 	{
 		if (template.hasClass("BarterMarket") &&
 		    !gameState.getOwnEntitiesByClass("BarterMarket", true).hasEntities())
 			idx = -1;	// needed by queueplanBuilding manager to keep that market
 		else
 			return false;
 	}
 	else
 		idx = this.basesMap.map[bestJdx];
 
 	let x = (bestIdx % obstructions.width + 0.5) * obstructions.cellSize;
 	let z = (Math.floor(bestIdx / obstructions.width) + 0.5) * obstructions.cellSize;
 	return [x, z, idx, expectedGain];
 };
 
 /**
  * Returns the best position to build defensive buildings (fortress and towers)
  * Whose primary function is to defend our borders
  */
 PETRA.HQ.prototype.findDefensiveLocation = function(gameState, template)
 {
 	// We take the point in our territory which is the nearest to any enemy cc
 	// but requiring a minimal distance with our other defensive structures
 	// and not in range of any enemy defensive structure to avoid building under fire.
 
 	let ownStructures = gameState.getOwnStructures().filter(API3.Filters.byClassesOr(["Fortress", "Tower"])).toEntityArray();
 	let enemyStructures = gameState.getEnemyStructures().filter(API3.Filters.not(API3.Filters.byOwner(0))).
 		filter(API3.Filters.byClassesOr(["CivCentre", "Fortress", "Tower"]));
 	if (!enemyStructures.hasEntities())	// we may be in cease fire mode, build defense against neutrals
 	{
 		enemyStructures = gameState.getNeutralStructures().filter(API3.Filters.not(API3.Filters.byOwner(0))).
 			filter(API3.Filters.byClassesOr(["CivCentre", "Fortress", "Tower"]));
 		if (!enemyStructures.hasEntities() && !gameState.getAlliedVictory())
 			enemyStructures = gameState.getAllyStructures().filter(API3.Filters.not(API3.Filters.byOwner(PlayerID))).
 				filter(API3.Filters.byClassesOr(["CivCentre", "Fortress", "Tower"]));
 		if (!enemyStructures.hasEntities())
 			return undefined;
 	}
 	enemyStructures = enemyStructures.toEntityArray();
 
 	let wonderMode = gameState.getVictoryConditions().has("wonder");
 	let wonderDistmin;
 	let wonders;
 	if (wonderMode)
 	{
 		wonders = gameState.getOwnStructures().filter(API3.Filters.byClass("Wonder")).toEntityArray();
 		wonderMode = wonders.length != 0;
 		if (wonderMode)
 			wonderDistmin = (50 + wonders[0].footprintRadius()) * (50 + wonders[0].footprintRadius());
 	}
 
 	// obstruction map
 	let obstructions = PETRA.createObstructionMap(gameState, 0, template);
 	let halfSize = 0;
 	if (template.get("Footprint/Square"))
 		halfSize = Math.max(+template.get("Footprint/Square/@depth"), +template.get("Footprint/Square/@width")) / 2;
 	else if (template.get("Footprint/Circle"))
 		halfSize = +template.get("Footprint/Circle/@radius");
 
 	let bestIdx;
 	let bestJdx;
 	let bestVal;
 	let width = this.territoryMap.width;
 	let cellSize = this.territoryMap.cellSize;
 
 	let isTower = template.hasClass("Tower");
 	let isFortress = template.hasClass("Fortress");
 	let radius;
 	if (isFortress)
 		radius = Math.floor((template.obstructionRadius().max + 8) / obstructions.cellSize);
 	else
 		radius = Math.ceil(template.obstructionRadius().max / obstructions.cellSize);
 
 	for (let j = 0; j < this.territoryMap.length; ++j)
 	{
 		if (!wonderMode)
 		{
 			// do not try if well inside or outside territory
 			if (!(this.borderMap.map[j] & PETRA.fullFrontier_Mask))
 				continue;
 			if (this.borderMap.map[j] & PETRA.largeFrontier_Mask && isTower)
 				continue;
 		}
 		if (this.basesMap.map[j] == 0)   // inaccessible cell
 			continue;
 		// with enough room around to build the cc
 		let i = this.territoryMap.getNonObstructedTile(j, radius, obstructions);
 		if (i < 0)
 			continue;
 
 		let pos = [cellSize * (j%width+0.5), cellSize * (Math.floor(j/width)+0.5)];
 		// checking distances to other structures
 		let minDist = Math.min();
 
 		let dista = 0;
 		if (wonderMode)
 		{
 			dista = API3.SquareVectorDistance(wonders[0].position(), pos);
 			if (dista < wonderDistmin)
 				continue;
 			dista *= 200;   // empirical factor (TODO should depend on map size) to stay near the wonder
 		}
 
 		for (let str of enemyStructures)
 		{
 			if (str.foundationProgress() !== undefined)
 				continue;
 			let strPos = str.position();
 			if (!strPos)
 				continue;
 			let dist = API3.SquareVectorDistance(strPos, pos);
 			if (dist < 6400) //  TODO check on true attack range instead of this 80*80
 			{
 				minDist = -1;
 				break;
 			}
 			if (str.hasClass("CivCentre") && dist + dista < minDist)
 				minDist = dist + dista;
 		}
 		if (minDist < 0)
 			continue;
 
 		let cutDist = 900;  //  30*30   TODO maybe increase it
 		for (let str of ownStructures)
 		{
 			let strPos = str.position();
 			if (!strPos)
 				continue;
 			if (API3.SquareVectorDistance(strPos, pos) < cutDist)
 			{
 				minDist = -1;
 				break;
 			}
 		}
 		if (minDist < 0 || minDist == Math.min())
 			continue;
 		if (bestVal !== undefined && minDist > bestVal)
 			continue;
 		if (this.isDangerousLocation(gameState, pos, halfSize))
 			continue;
 		bestVal = minDist;
 		bestIdx = i;
 		bestJdx = j;
 	}
 
 	if (bestVal === undefined)
 		return undefined;
 
 	let x = (bestIdx % obstructions.width + 0.5) * obstructions.cellSize;
 	let z = (Math.floor(bestIdx / obstructions.width) + 0.5) * obstructions.cellSize;
 	return [x, z, this.basesMap.map[bestJdx]];
 };
 
 PETRA.HQ.prototype.buildTemple = function(gameState, queues)
 {
 	// at least one market (which have the same queue) should be build before any temple
 	if (queues.economicBuilding.hasQueuedUnits() ||
 		gameState.getOwnEntitiesByClass("Temple", true).hasEntities() ||
 		!gameState.getOwnEntitiesByClass("BarterMarket", true).hasEntities())
 		return;
 	// Try to build a temple earlier if in regicide to recruit healer guards
 	if (this.currentPhase < 3 && !gameState.getVictoryConditions().has("regicide"))
 		return;
 
 	let templateName = "structures/{civ}_temple";
 	if (this.canBuild(gameState, "structures/{civ}_temple_vesta"))
 		templateName = "structures/{civ}_temple_vesta";
 	else if (!this.canBuild(gameState, templateName))
 		return;
 	queues.economicBuilding.addPlan(new PETRA.ConstructionPlan(gameState, templateName));
 };
 
 PETRA.HQ.prototype.buildMarket = function(gameState, queues)
 {
 	if (gameState.getOwnEntitiesByClass("BarterMarket", true).hasEntities() ||
 		!this.canBuild(gameState, "structures/{civ}_market"))
 		return;
 
 	if (queues.economicBuilding.hasQueuedUnitsWithClass("BarterMarket"))
 	{
 		if (!queues.economicBuilding.paused)
 		{
 			// Put available resources in this market
 			let queueManager = gameState.ai.queueManager;
 			let cost = queues.economicBuilding.plans[0].getCost();
 			queueManager.setAccounts(gameState, cost, "economicBuilding");
 			if (!queueManager.canAfford("economicBuilding", cost))
 			{
 				for (let q in queueManager.queues)
 				{
 					if (q == "economicBuilding")
 						continue;
 					queueManager.transferAccounts(cost, q, "economicBuilding");
 					if (queueManager.canAfford("economicBuilding", cost))
 						break;
 				}
 			}
 		}
 		return;
 	}
 
 	gameState.ai.queueManager.changePriority("economicBuilding", 3*this.Config.priorities.economicBuilding);
 	let plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_market");
 	plan.queueToReset = "economicBuilding";
 	queues.economicBuilding.addPlan(plan);
 };
 
 /** Build a farmstead */
 PETRA.HQ.prototype.buildFarmstead = function(gameState, queues)
 {
 	// Only build one farmstead for the time being ("DropsiteFood" does not refer to CCs)
 	if (gameState.getOwnEntitiesByClass("Farmstead", true).hasEntities())
 		return;
 	// Wait to have at least one dropsite and house before the farmstead
 	if (!gameState.getOwnEntitiesByClass("Storehouse", true).hasEntities())
 		return;
 	if (!gameState.getOwnEntitiesByClass("House", true).hasEntities())
 		return;
 	if (queues.economicBuilding.hasQueuedUnitsWithClass("DropsiteFood"))
 		return;
 	if (!this.canBuild(gameState, "structures/{civ}_farmstead"))
 		return;
 
 	queues.economicBuilding.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}_farmstead"));
 };
 
 /**
  * Try to build a wonder when required
  * force = true when called from the victoryManager in case of Wonder victory condition.
  */
 PETRA.HQ.prototype.buildWonder = function(gameState, queues, force = false)
 {
 	if (queues.wonder && queues.wonder.hasQueuedUnits() ||
 	    gameState.getOwnEntitiesByClass("Wonder", true).hasEntities() ||
 	    !this.canBuild(gameState, "structures/{civ}_wonder"))
 		return;
 
 	if (!force)
 	{
 		let template = gameState.getTemplate(gameState.applyCiv("structures/{civ}_wonder"));
 		// Check that we have enough resources to start thinking to build a wonder
 		let cost = template.cost();
 		let resources = gameState.getResources();
 		let highLevel = 0;
 		let lowLevel = 0;
 		for (let res in cost)
 		{
 			if (resources[res] && resources[res] > 0.7 * cost[res])
 				++highLevel;
 			else if (!resources[res] || resources[res] < 0.3 * cost[res])
 				++lowLevel;
 		}
 		if (highLevel == 0 || lowLevel > 1)
 			return;
 	}
 
 	queues.wonder.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}_wonder"));
 };
 
 /** Build a corral, and train animals there */
 PETRA.HQ.prototype.manageCorral = function(gameState, queues)
 {
 	if (queues.corral.hasQueuedUnits())
 		return;
 
 	let nCorral = gameState.getOwnEntitiesByClass("Corral", true).length;
 	if (!nCorral || !gameState.isTemplateAvailable(gameState.applyCiv("structures/{civ}_field")) &&
 	                nCorral < this.currentPhase && gameState.getPopulation() > 30*nCorral)
 	{
 		if (this.canBuild(gameState, "structures/{civ}_corral"))
 		{
 			queues.corral.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}_corral"));
 			return;
 		}
 		if (!nCorral)
 			return;
 	}
 
 	// And train some animals
 	let civ = gameState.getPlayerCiv();
 	for (let corral of gameState.getOwnEntitiesByClass("Corral", true).values())
 	{
 		if (corral.foundationProgress() !== undefined)
 			continue;
 		let trainables = corral.trainableEntities(civ);
 		for (let trainable of trainables)
 		{
 			if (gameState.isTemplateDisabled(trainable))
 				continue;
 			let template = gameState.getTemplate(trainable);
 			if (!template || !template.isHuntable())
 				continue;
 			let count = gameState.countEntitiesByType(trainable, true);
 			for (let item of corral.trainingQueue())
 				count += item.count;
 			if (count > nCorral)
 				continue;
 			queues.corral.addPlan(new PETRA.TrainingPlan(gameState, trainable, { "trainer": corral.id() }));
 			return;
 		}
 	}
 };
 
 /**
  * build more houses if needed.
  * kinda ugly, lots of special cases to both build enough houses but not tooo many…
  */
 PETRA.HQ.prototype.buildMoreHouses = function(gameState, queues)
 {
 	if (!gameState.isTemplateAvailable(gameState.applyCiv("structures/{civ}_house")) ||
 	    gameState.getPopulationMax() <= gameState.getPopulationLimit())
 		return;
 
 	let numPlanned = queues.house.length();
 	if (numPlanned < 3 || numPlanned < 5 && gameState.getPopulation() > 80)
 	{
 		let plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_house");
 		// change the starting condition according to the situation.
 		plan.goRequirement = "houseNeeded";
 		queues.house.addPlan(plan);
 	}
 
 	if (numPlanned > 0 && this.phasing && gameState.getPhaseEntityRequirements(this.phasing).length)
 	{
 		let houseTemplateName = gameState.applyCiv("structures/{civ}_house");
 		let houseTemplate = gameState.getTemplate(houseTemplateName);
 
 		let needed = 0;
 		for (let entityReq of gameState.getPhaseEntityRequirements(this.phasing))
 		{
 			if (!houseTemplate.hasClass(entityReq.class))
 				continue;
 
 			let count = gameState.getOwnStructures().filter(API3.Filters.byClass(entityReq.class)).length;
 			if (count < entityReq.count && this.buildManager.isUnbuildable(gameState, houseTemplateName))
 			{
 				if (this.Config.debug > 1)
 					API3.warn("no room to place a house ... try to be less restrictive");
 				this.buildManager.setBuildable(houseTemplateName);
 				this.requireHouses = true;
 			}
 			needed = Math.max(needed, entityReq.count - count);
 		}
 
 		let houseQueue = queues.house.plans;
 		for (let i = 0; i < numPlanned; ++i)
 			if (houseQueue[i].isGo(gameState))
 				--needed;
 			else if (needed > 0)
 			{
 				houseQueue[i].goRequirement = undefined;
 				--needed;
 			}
 	}
 
 	if (this.requireHouses)
 	{
 		let houseTemplate = gameState.getTemplate(gameState.applyCiv("structures/{civ}_house"));
 		if (!this.phasing || gameState.getPhaseEntityRequirements(this.phasing).every(req =>
 			!houseTemplate.hasClass(req.class) || gameState.getOwnStructures().filter(API3.Filters.byClass(req.class)).length >= req.count))
 			this.requireHouses = undefined;
 	}
 
 	// When population limit too tight
 	//    - if no room to build, try to improve with technology
 	//    - otherwise increase temporarily the priority of houses
 	let house = gameState.applyCiv("structures/{civ}_house");
 	let HouseNb = gameState.getOwnFoundations().filter(API3.Filters.byClass("House")).length;
 	let popBonus = gameState.getTemplate(house).getPopulationBonus();
 	let freeSlots = gameState.getPopulationLimit() + HouseNb*popBonus - this.getAccountedPopulation(gameState);
 	let priority;
 	if (freeSlots < 5)
 	{
 		if (this.buildManager.isUnbuildable(gameState, house))
 		{
 			if (this.Config.debug > 1)
 				API3.warn("no room to place a house ... try to improve with technology");
 			this.researchManager.researchPopulationBonus(gameState, queues);
 		}
 		else
 			priority = 2*this.Config.priorities.house;
 	}
 	else
 		priority = this.Config.priorities.house;
 
 	if (priority && priority != gameState.ai.queueManager.getPriority("house"))
 		gameState.ai.queueManager.changePriority("house", priority);
 };
 
 /** Checks the status of the territory expansion. If no new economic bases created, build some strategic ones. */
 PETRA.HQ.prototype.checkBaseExpansion = function(gameState, queues)
 {
 	if (queues.civilCentre.hasQueuedUnits())
 		return;
 	// First build one cc if all have been destroyed
 	if (this.numPotentialBases() == 0)
 	{
 		this.buildFirstBase(gameState);
 		return;
 	}
 	// Then expand if we have not enough room available for buildings
 	if (this.buildManager.numberMissingRoom(gameState) > 1)
 	{
 		if (this.Config.debug > 2)
 			API3.warn("try to build a new base because not enough room to build ");
 		this.buildNewBase(gameState, queues);
 		return;
 	}
 	// If we've already planned to phase up, wait a bit before trying to expand
 	if (this.phasing)
 		return;
 	// Finally expand if we have lots of units (threshold depending on the aggressivity value)
 	let activeBases = this.numActiveBases();
 	let numUnits = gameState.getOwnUnits().length;
 	let numvar = 10 * (1 - this.Config.personality.aggressive);
 	if (numUnits > activeBases * (65 + numvar + (10 + numvar)*(activeBases-1)) || this.saveResources && numUnits > 50)
 	{
 		if (this.Config.debug > 2)
 			API3.warn("try to build a new base because of population " + numUnits + " for " + activeBases + " CCs");
 		this.buildNewBase(gameState, queues);
 	}
 };
 
 PETRA.HQ.prototype.buildNewBase = function(gameState, queues, resource)
 {
 	if (this.numPotentialBases() > 0 && this.currentPhase == 1 && !gameState.isResearching(gameState.getPhaseName(2)))
 		return false;
 	if (gameState.getOwnFoundations().filter(API3.Filters.byClass("CivCentre")).hasEntities() || queues.civilCentre.hasQueuedUnits())
 		return false;
 
 	let template;
 	// We require at least one of this civ civCentre as they may allow specific units or techs
 	let hasOwnCC = false;
 	for (let ent of gameState.updatingGlobalCollection("allCCs", API3.Filters.byClass("CivCentre")).values())
 	{
 		if (ent.owner() != PlayerID || ent.templateName() != gameState.applyCiv("structures/{civ}_civil_centre"))
 			continue;
 		hasOwnCC = true;
 		break;
 	}
 	if (hasOwnCC && this.canBuild(gameState, "structures/{civ}_military_colony"))
 		template = "structures/{civ}_military_colony";
 	else if (this.canBuild(gameState, "structures/{civ}_civil_centre"))
 		template = "structures/{civ}_civil_centre";
 	else if (!hasOwnCC && this.canBuild(gameState, "structures/{civ}_military_colony"))
 		template = "structures/{civ}_military_colony";
 	else
 		return false;
 
 	// base "-1" means new base.
 	if (this.Config.debug > 1)
 		API3.warn("new base " + gameState.applyCiv(template) + " planned with resource " + resource);
 	queues.civilCentre.addPlan(new PETRA.ConstructionPlan(gameState, template, { "base": -1, "resource": resource }));
 	return true;
 };
 
 /** Deals with building fortresses and towers along our border with enemies. */
 PETRA.HQ.prototype.buildDefenses = function(gameState, queues)
 {
 	if (this.saveResources && !this.canBarter || queues.defenseBuilding.hasQueuedUnits())
 		return;
 
 	if (!this.saveResources && (this.currentPhase > 2 || gameState.isResearching(gameState.getPhaseName(3))))
 	{
 		// try to build fortresses
 		if (this.canBuild(gameState, "structures/{civ}_fortress"))
 		{
 			let numFortresses = gameState.getOwnEntitiesByClass("Fortress", true).length;
 			if ((!numFortresses || gameState.ai.elapsedTime > (1 + 0.10*numFortresses)*this.fortressLapseTime + this.fortressStartTime) &&
 				numFortresses < this.numActiveBases() + 1 + this.extraFortresses &&
 				numFortresses < Math.floor(gameState.getPopulation() / 25) &&
 				gameState.getOwnFoundationsByClass("Fortress").length < 2)
 			{
 				this.fortressStartTime = gameState.ai.elapsedTime;
 				if (!numFortresses)
 					gameState.ai.queueManager.changePriority("defenseBuilding", 2*this.Config.priorities.defenseBuilding);
 				let plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_fortress");
 				plan.queueToReset = "defenseBuilding";
 				queues.defenseBuilding.addPlan(plan);
 				return;
 			}
 		}
 	}
 
 	if (this.Config.Military.numSentryTowers && this.currentPhase < 2 && this.canBuild(gameState, "structures/{civ}_sentry_tower"))
 	{
 		let numTowers = gameState.getOwnEntitiesByClass("Tower", true).length;	// we count all towers, including wall towers
 		let towerLapseTime = this.saveResource ? (1 + 0.5*numTowers) * this.towerLapseTime : this.towerLapseTime;
 		if (numTowers < this.Config.Military.numSentryTowers && gameState.ai.elapsedTime > towerLapseTime + this.fortStartTime)
 		{
 			this.fortStartTime = gameState.ai.elapsedTime;
 			queues.defenseBuilding.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}_sentry_tower"));
 		}
 		return;
 	}
 
 	if (this.currentPhase < 2 || !this.canBuild(gameState, "structures/{civ}_defense_tower"))
 		return;
 
 	let numTowers = gameState.getOwnEntitiesByClass("StoneTower", true).length;
 	let towerLapseTime = this.saveResource ? (1 + numTowers) * this.towerLapseTime : this.towerLapseTime;
 	if ((!numTowers || gameState.ai.elapsedTime > (1 + 0.1*numTowers)*towerLapseTime + this.towerStartTime) &&
 		numTowers < 2 * this.numActiveBases() + 3 + this.extraTowers &&
 		numTowers < Math.floor(gameState.getPopulation() / 8) &&
 		gameState.getOwnFoundationsByClass("DefenseTower").length < 3)
 	{
 		this.towerStartTime = gameState.ai.elapsedTime;
 		if (numTowers > 2 * this.numActiveBases() + 3)
 			gameState.ai.queueManager.changePriority("defenseBuilding", Math.round(0.7*this.Config.priorities.defenseBuilding));
 		let plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_defense_tower");
 		plan.queueToReset = "defenseBuilding";
 		queues.defenseBuilding.addPlan(plan);
 	}
 };
 
 PETRA.HQ.prototype.buildBlacksmith = function(gameState, queues)
 {
 	if (this.getAccountedPopulation(gameState) < this.Config.Military.popForBlacksmith ||
 		queues.militaryBuilding.hasQueuedUnits() || gameState.getOwnEntitiesByClass("Blacksmith", true).length)
 		return;
 	// build a market before the blacksmith
 	if (!gameState.getOwnEntitiesByClass("BarterMarket", true).hasEntities())
 		return;
 
 	if (this.canBuild(gameState, "structures/{civ}_blacksmith"))
 		queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}_blacksmith"));
 };
 
 /**
  * Deals with constructing military buildings (barracks, stables…)
  * They are mostly defined by Config.js. This is unreliable since changes could be done easily.
  */
 PETRA.HQ.prototype.constructTrainingBuildings = function(gameState, queues)
 {
 	if (this.saveResources && !this.canBarter || queues.militaryBuilding.hasQueuedUnits())
 		return;
 
 	let numBarracks = gameState.getOwnEntitiesByClass("Barracks", true).length;
 	if (this.saveResources && numBarracks != 0)
 		return;
 
 	let barracksTemplate = this.canBuild(gameState, "structures/{civ}_barracks") ? "structures/{civ}_barracks" : undefined;
 
 	let rangeTemplate = this.canBuild(gameState, "structures/{civ}_range") ? "structures/{civ}_range" : undefined;
 	let numRanges = gameState.getOwnEntitiesByClass("Range", true).length;
 
 	let stableTemplate = this.canBuild(gameState, "structures/{civ}_stable") ? "structures/{civ}_stable" : undefined;
 	let numStables = gameState.getOwnEntitiesByClass("Stable", true).length;
 
 	if (this.getAccountedPopulation(gameState) > this.Config.Military.popForBarracks1 ||
 	    this.phasing == 2 && gameState.getOwnStructures().filter(API3.Filters.byClass("Village")).length < 5)
 	{
 		// first barracks/range and stables.
 		if (numBarracks + numRanges == 0)
 		{
 			let template = barracksTemplate || rangeTemplate;
 			if (template)
 			{
 				gameState.ai.queueManager.changePriority("militaryBuilding", 2 * this.Config.priorities.militaryBuilding);
 				let plan = new PETRA.ConstructionPlan(gameState, template, { "militaryBase": true });
 				plan.queueToReset = "militaryBuilding";
 				queues.militaryBuilding.addPlan(plan);
 				return;
 			}
 		}
 		if (numStables == 0 && stableTemplate)
 		{
 			queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, stableTemplate, { "militaryBase": true }));
 			return;
 		}
 
 		// Second range/barracks and stables
 		if (numBarracks + numRanges == 1 && this.getAccountedPopulation(gameState) > this.Config.Military.popForBarracks2)
 		{
 			let template = numBarracks == 0 ? (barracksTemplate || rangeTemplate) : (rangeTemplate || barracksTemplate);
 			if (template)
 			{
 				queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, template, { "militaryBase": true }));
 				return;
 			}
 		}
 		if (numStables == 1 && stableTemplate && this.getAccountedPopulation(gameState) > this.Config.Military.popForBarracks2)
 		{
 			queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, stableTemplate, { "militaryBase": true }));
 			return;
 		}
 
 		// Then 3rd barracks/range/stables if needed
 		if (numBarracks + numRanges + numStables == 2 && this.getAccountedPopulation(gameState) > this.Config.Military.popForBarracks2 + 30)
 		{
 			let template = barracksTemplate || stableTemplate || rangeTemplate;
 			if (template)
 			{
 				queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, template, { "militaryBase": true }));
 				return;
 			}
 		}
 	}
 
 	if (this.saveResources)
 		return;
 
 	if (this.currentPhase < 3)
 		return;
 
 	if (this.canBuild(gameState, "structures/{civ}_elephant_stables") && !gameState.getOwnEntitiesByClass("ElephantStable", true).hasEntities())
 	{
 		queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}_elephant_stables", { "militaryBase": true }));
 		return;
 	}
 
 	if (this.canBuild(gameState, "structures/{civ}_workshop") && !gameState.getOwnEntitiesByClass("Workshop", true).hasEntities())
 	{
 		queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, "structures/{civ}_workshop", { "militaryBase": true }));
 		return;
 	}
 
 	if (this.getAccountedPopulation(gameState) < 80 || !this.bAdvanced.length)
 		return;
 
 	// Build advanced military buildings
 	let nAdvanced = 0;
 	for (let advanced of this.bAdvanced)
 		nAdvanced += gameState.countEntitiesAndQueuedByType(advanced, true);
 
 	if (!nAdvanced || nAdvanced < this.bAdvanced.length && this.getAccountedPopulation(gameState) > 110)
 	{
 		for (let advanced of this.bAdvanced)
 		{
 			if (gameState.countEntitiesAndQueuedByType(advanced, true) > 0 || !this.canBuild(gameState, advanced))
 				continue;
 			let template = gameState.getTemplate(advanced);
 			if (!template)
 				continue;
 			let civ = gameState.getPlayerCiv();
 			if (template.hasDefensiveFire() || template.trainableEntities(civ))
 				queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, advanced, { "militaryBase": true }));
 			else	// not a military building, but still use this queue
 				queues.militaryBuilding.addPlan(new PETRA.ConstructionPlan(gameState, advanced));
 			return;
 		}
 	}
 };
 
 /**
  *  Find base nearest to ennemies for military buildings.
  */
 PETRA.HQ.prototype.findBestBaseForMilitary = function(gameState)
 {
 	let ccEnts = gameState.updatingGlobalCollection("allCCs", API3.Filters.byClass("CivCentre")).toEntityArray();
 	let bestBase;
 	let enemyFound = false;
 	let distMin = Math.min();
 	for (let cce of ccEnts)
 	{
 		if (gameState.isPlayerAlly(cce.owner()))
 			continue;
 		if (enemyFound && !gameState.isPlayerEnemy(cce.owner()))
 			continue;
 		let access = PETRA.getLandAccess(gameState, cce);
 		let isEnemy = gameState.isPlayerEnemy(cce.owner());
 		for (let cc of ccEnts)
 		{
 			if (cc.owner() != PlayerID)
 				continue;
 			if (PETRA.getLandAccess(gameState, cc) != access)
 				continue;
 			let dist = API3.SquareVectorDistance(cc.position(), cce.position());
 			if (!enemyFound && isEnemy)
 				enemyFound = true;
 			else if (dist > distMin)
 				continue;
 			bestBase = cc.getMetadata(PlayerID, "base");
 			distMin = dist;
 		}
 	}
 	return bestBase;
 };
 
 /**
  * train with highest priority ranged infantry in the nearest civil center from a given set of positions
  * and garrison them there for defense
  */
 PETRA.HQ.prototype.trainEmergencyUnits = function(gameState, positions)
 {
 	if (gameState.ai.queues.emergency.hasQueuedUnits())
 		return false;
 
 	let civ = gameState.getPlayerCiv();
 	// find nearest base anchor
 	let distcut = 20000;
 	let nearestAnchor;
 	let distmin;
 	for (let pos of positions)
 	{
 		let access = gameState.ai.accessibility.getAccessValue(pos);
 		// check nearest base anchor
 		for (let base of this.baseManagers)
 		{
 			if (!base.anchor || !base.anchor.position())
 				continue;
 			if (PETRA.getLandAccess(gameState, base.anchor) != access)
 				continue;
 			if (!base.anchor.trainableEntities(civ))	// base still in construction
 				continue;
 			let queue = base.anchor._entity.trainingQueue;
 			if (queue)
 			{
 				let time = 0;
 				for (let item of queue)
 					if (item.progress > 0 || item.metadata && item.metadata.garrisonType)
 						time += item.timeRemaining;
 				if (time/1000 > 5)
 					continue;
 			}
 			let dist = API3.SquareVectorDistance(base.anchor.position(), pos);
 			if (nearestAnchor && dist > distmin)
 				continue;
 			distmin = dist;
 			nearestAnchor = base.anchor;
 		}
 	}
 	if (!nearestAnchor || distmin > distcut)
 		return false;
 
 	// We will choose randomly ranged and melee units, except when garrisonHolder is full
 	// in which case we prefer melee units
 	let numGarrisoned = this.garrisonManager.numberOfGarrisonedUnits(nearestAnchor);
 	if (nearestAnchor._entity.trainingQueue)
 	{
 		for (let item of nearestAnchor._entity.trainingQueue)
 		{
 			if (item.metadata && item.metadata.garrisonType)
 				numGarrisoned += item.count;
 			else if (!item.progress && (!item.metadata || !item.metadata.trainer))
 				nearestAnchor.stopProduction(item.id);
 		}
 	}
 	let autogarrison = numGarrisoned < nearestAnchor.garrisonMax() &&
 	                   nearestAnchor.hitpoints() > nearestAnchor.garrisonEjectHealth() * nearestAnchor.maxHitpoints();
 	let rangedWanted = randBool() && autogarrison;
 
 	let total = gameState.getResources();
 	let templateFound;
 	let trainables = nearestAnchor.trainableEntities(civ);
 	let garrisonArrowClasses = nearestAnchor.getGarrisonArrowClasses();
 	for (let trainable of trainables)
 	{
 		if (gameState.isTemplateDisabled(trainable))
 			continue;
 		let template = gameState.getTemplate(trainable);
 		if (!template || !template.hasClass("Infantry") || !template.hasClass("CitizenSoldier"))
 			continue;
 		if (autogarrison && !MatchesClassList(template.classes(), garrisonArrowClasses))
 			continue;
 		if (!total.canAfford(new API3.Resources(template.cost())))
 			continue;
 		templateFound = [trainable, template];
 		if (template.hasClass("Ranged") == rangedWanted)
 			break;
 	}
 	if (!templateFound)
 		return false;
 
 	// Check first if we can afford it without touching the other accounts
 	// and if not, take some of other accounted resources
 	// TODO sort the queues to be substracted
 	let queueManager = gameState.ai.queueManager;
 	let cost = new API3.Resources(templateFound[1].cost());
 	queueManager.setAccounts(gameState, cost, "emergency");
 	if (!queueManager.canAfford("emergency", cost))
 	{
 		for (let q in queueManager.queues)
 		{
 			if (q == "emergency")
 				continue;
 			queueManager.transferAccounts(cost, q, "emergency");
 			if (queueManager.canAfford("emergency", cost))
 				break;
 		}
 	}
 	let metadata = { "role": "worker", "base": nearestAnchor.getMetadata(PlayerID, "base"), "plan": -1, "trainer": nearestAnchor.id() };
 	if (autogarrison)
 		metadata.garrisonType = "protection";
 	gameState.ai.queues.emergency.addPlan(new PETRA.TrainingPlan(gameState, templateFound[0], metadata, 1, 1));
 	return true;
 };
 
 PETRA.HQ.prototype.canBuild = function(gameState, structure)
 {
 	let type = gameState.applyCiv(structure);
 	if (this.buildManager.isUnbuildable(gameState, type))
 		return false;
 
 	if (gameState.isTemplateDisabled(type))
 	{
 		this.buildManager.setUnbuildable(gameState, type, Infinity, "disabled");
 		return false;
 	}
 
 	let template = gameState.getTemplate(type);
 	if (!template)
 	{
 		this.buildManager.setUnbuildable(gameState, type, Infinity, "notemplate");
 		return false;
 	}
 
 	if (!template.available(gameState))
 	{
 		this.buildManager.setUnbuildable(gameState, type, 30, "tech");
 		return false;
 	}
 
 	if (!this.buildManager.hasBuilder(type))
 	{
 		this.buildManager.setUnbuildable(gameState, type, 120, "nobuilder");
 		return false;
 	}
 
 	if (this.numActiveBases() < 1)
 	{
 		// if no base, check that we can build outside our territory
 		let buildTerritories = template.buildTerritories();
 		if (buildTerritories && (!buildTerritories.length || buildTerritories.length == 1 && buildTerritories[0] == "own"))
 		{
 			this.buildManager.setUnbuildable(gameState, type, 180, "room");
 			return false;
 		}
 	}
 
 	// build limits
 	let limits = gameState.getEntityLimits();
 	let category = template.buildCategory();
 	if (category && limits[category] !== undefined && gameState.getEntityCounts()[category] >= limits[category])
 	{
 		this.buildManager.setUnbuildable(gameState, type, 90, "limit");
 		return false;
 	}
 
 	return true;
 };
 
 PETRA.HQ.prototype.updateTerritories = function(gameState)
 {
 	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 alliedVictory = gameState.getAlliedVictory();
 	let passabilityMap = gameState.getPassabilityMap();
 	let width = this.territoryMap.width;
 	let cellSize = this.territoryMap.cellSize;
 	let insideSmall = Math.round(45 / cellSize);
 	let insideLarge = Math.round(80 / cellSize);	// should be about the range of towers
 	let expansion = 0;
 
 	for (let j = 0; j < this.territoryMap.length; ++j)
 	{
 		if (this.borderMap.map[j] & PETRA.outside_Mask)
 			continue;
 		if (this.borderMap.map[j] & PETRA.fullFrontier_Mask)
 			this.borderMap.map[j] &= ~PETRA.fullFrontier_Mask;	// reset the frontier
 
 		if (this.territoryMap.getOwnerIndex(j) != PlayerID)
 		{
 			// If this tile was already accounted, remove it
 			if (this.basesMap.map[j] == 0)
 				continue;
 			let base = this.getBaseByID(this.basesMap.map[j]);
 			if (base)
 			{
 				let index = base.territoryIndices.indexOf(j);
 				if (index != -1)
 					base.territoryIndices.splice(index, 1);
 				else
 					API3.warn(" problem in headquarters::updateTerritories for base " + this.basesMap.map[j]);
 			}
 			else
 				API3.warn(" problem in headquarters::updateTerritories without base " + this.basesMap.map[j]);
 			this.basesMap.map[j] = 0;
 		}
 		else
 		{
 			// Update the frontier
 			let ix = j%width;
 			let iz = Math.floor(j/width);
 			let onFrontier = false;
 			for (let a of around)
 			{
 				let jx = ix + Math.round(insideSmall*a[0]);
 				if (jx < 0 || jx >= width)
 					continue;
 				let jz = iz + Math.round(insideSmall*a[1]);
 				if (jz < 0 || jz >= width)
 					continue;
 				if (this.borderMap.map[jx+width*jz] & PETRA.outside_Mask)
 					continue;
 				let territoryOwner = this.territoryMap.getOwnerIndex(jx+width*jz);
 				if (territoryOwner != PlayerID && !(alliedVictory && gameState.isPlayerAlly(territoryOwner)))
 				{
 					this.borderMap.map[j] |= PETRA.narrowFrontier_Mask;
 					break;
 				}
 				jx = ix + Math.round(insideLarge*a[0]);
 				if (jx < 0 || jx >= width)
 					continue;
 				jz = iz + Math.round(insideLarge*a[1]);
 				if (jz < 0 || jz >= width)
 					continue;
 				if (this.borderMap.map[jx+width*jz] & PETRA.outside_Mask)
 					continue;
 				territoryOwner = this.territoryMap.getOwnerIndex(jx+width*jz);
 				if (territoryOwner != PlayerID && !(alliedVictory && gameState.isPlayerAlly(territoryOwner)))
 					onFrontier = true;
 			}
 			if (onFrontier && !(this.borderMap.map[j] & PETRA.narrowFrontier_Mask))
 				this.borderMap.map[j] |= PETRA.largeFrontier_Mask;
 
 			// If this tile was not already accounted, add it.
 			if (this.basesMap.map[j] != 0)
 				continue;
 			let landPassable = false;
 			let ind = API3.getMapIndices(j, this.territoryMap, passabilityMap);
 			let access;
 			for (let k of ind)
 			{
 				if (!this.landRegions[gameState.ai.accessibility.landPassMap[k]])
 					continue;
 				landPassable = true;
 				access = gameState.ai.accessibility.landPassMap[k];
 				break;
 			}
 			if (!landPassable)
 				continue;
 			let distmin = Math.min();
 			let baseID;
 			let pos = [cellSize * (j%width+0.5), cellSize * (Math.floor(j/width)+0.5)];
 			for (let base of this.baseManagers)
 			{
 				if (!base.anchor || !base.anchor.position())
 					continue;
 				if (base.accessIndex != access)
 					continue;
 				let dist = API3.SquareVectorDistance(base.anchor.position(), pos);
 				if (dist >= distmin)
 					continue;
 				distmin = dist;
 				baseID = base.ID;
 			}
 			if (!baseID)
 				continue;
 			this.getBaseByID(baseID).territoryIndices.push(j);
 			this.basesMap.map[j] = baseID;
 			expansion++;
 		}
 	}
 
 	if (!expansion)
 		return;
 	// We've increased our territory, so we may have some new room to build
 	this.buildManager.resetMissingRoom(gameState);
 	// And if sufficient expansion, check if building a new market would improve our present trade routes
 	let cellArea = this.territoryMap.cellSize * this.territoryMap.cellSize;
 	if (expansion * cellArea > 960)
 		this.tradeManager.routeProspection = true;
 };
 
 /** Reassign territories when a base is going to be deleted */
 PETRA.HQ.prototype.reassignTerritories = function(deletedBase)
 {
 	let cellSize = this.territoryMap.cellSize;
 	let width = this.territoryMap.width;
 	for (let j = 0; j < this.territoryMap.length; ++j)
 	{
 		if (this.basesMap.map[j] != deletedBase.ID)
 			continue;
 		if (this.territoryMap.getOwnerIndex(j) != PlayerID)
 		{
 			API3.warn("Petra reassignTerritories: should never happen");
 			this.basesMap.map[j] = 0;
 			continue;
 		}
 
 		let distmin = Math.min();
 		let baseID;
 		let pos = [cellSize * (j%width+0.5), cellSize * (Math.floor(j/width)+0.5)];
 		for (let base of this.baseManagers)
 		{
 			if (!base.anchor || !base.anchor.position())
 				continue;
 			if (base.accessIndex != deletedBase.accessIndex)
 				continue;
 			let dist = API3.SquareVectorDistance(base.anchor.position(), pos);
 			if (dist >= distmin)
 				continue;
 			distmin = dist;
 			baseID = base.ID;
 		}
 		if (baseID)
 		{
 			this.getBaseByID(baseID).territoryIndices.push(j);
 			this.basesMap.map[j] = baseID;
 		}
 		else
 			this.basesMap.map[j] = 0;
 	}
 };
 
 /**
  * returns the base corresponding to baseID
  */
 PETRA.HQ.prototype.getBaseByID = function(baseID)
 {
 	for (let base of this.baseManagers)
 		if (base.ID == baseID)
 			return base;
 
 	return undefined;
 };
 
 /**
  * returns the number of bases with a cc
  * ActiveBases includes only those with a built cc
  * PotentialBases includes also those with a cc in construction
  */
 PETRA.HQ.prototype.numActiveBases = function()
 {
 	if (!this.turnCache.base)
 		this.updateBaseCache();
 	return this.turnCache.base.active;
 };
 
 PETRA.HQ.prototype.numPotentialBases = function()
 {
 	if (!this.turnCache.base)
 		this.updateBaseCache();
 	return this.turnCache.base.potential;
 };
 
 PETRA.HQ.prototype.updateBaseCache = function()
 {
 	this.turnCache.base = { "active": 0, "potential": 0 };
 	for (let base of this.baseManagers)
 	{
 		if (!base.anchor)
 			continue;
 		++this.turnCache.base.potential;
 		if (base.anchor.foundationProgress() === undefined)
 			++this.turnCache.base.active;
 	}
 };
 
 PETRA.HQ.prototype.resetBaseCache = function()
 {
 	this.turnCache.base = undefined;
 };
 
 /**
  * Count gatherers returning resources in the number of gatherers of resourceSupplies
  * to prevent the AI always reassigning idle workers to these resourceSupplies (specially in naval maps).
  */
 PETRA.HQ.prototype.assignGatherers = function()
 {
 	for (let base of this.baseManagers)
 	{
 		for (let worker of base.workers.values())
 		{
 			if (worker.unitAIState().split(".")[1] != "RETURNRESOURCE")
 				continue;
 			let orders = worker.unitAIOrderData();
 			if (orders.length < 2 || !orders[1].target || orders[1].target != worker.getMetadata(PlayerID, "supply"))
 				continue;
 			this.AddTCGatherer(orders[1].target);
 		}
 	}
 };
 
 PETRA.HQ.prototype.isDangerousLocation = function(gameState, pos, radius)
 {
 	return this.isNearInvadingArmy(pos) || this.isUnderEnemyFire(gameState, pos, radius);
 };
 
 /** Check that the chosen position is not too near from an invading army */
 PETRA.HQ.prototype.isNearInvadingArmy = function(pos)
 {
 	for (let army of this.defenseManager.armies)
 		if (army.foePosition && API3.SquareVectorDistance(army.foePosition, pos) < 12000)
 			return true;
 	return false;
 };
 
 PETRA.HQ.prototype.isUnderEnemyFire = function(gameState, pos, radius = 0)
 {
 	if (!this.turnCache.firingStructures)
 		this.turnCache.firingStructures = gameState.updatingCollection("diplo-FiringStructures", API3.Filters.hasDefensiveFire(), gameState.getEnemyStructures());
 	for (let ent of this.turnCache.firingStructures.values())
 	{
 		let range = radius + ent.attackRange("Ranged").max;
 		if (API3.SquareVectorDistance(ent.position(), pos) < range*range)
 			return true;
 	}
 	return false;
 };
 
 /** Compute the capture strength of all units attacking a capturable target */
 PETRA.HQ.prototype.updateCaptureStrength = function(gameState)
 {
 	this.capturableTargets.clear();
 	for (let ent of gameState.getOwnUnits().values())
 	{
 		if (!ent.canCapture())
 			continue;
 		let state = ent.unitAIState();
 		if (!state || !state.split(".")[1] || state.split(".")[1] != "COMBAT")
 			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.isCapturable() || !ent.canCapture(target))
 			continue;
 		if (!this.capturableTargets.has(targetId))
 			this.capturableTargets.set(targetId, {
 				"strength": ent.captureStrength() * PETRA.getAttackBonus(ent, target, "Capture"),
 				"ents": new Set([ent.id()])
 			});
 		else
 		{
 			let capturableTarget = this.capturableTargets.get(target.id());
 			capturableTarget.strength += ent.captureStrength() * PETRA.getAttackBonus(ent, target, "Capture");
 			capturableTarget.ents.add(ent.id());
 		}
 	}
 
 	for (let [targetId, capturableTarget] of this.capturableTargets)
 	{
 		let target = gameState.getEntityById(targetId);
 		let allowCapture;
 		for (let entId of capturableTarget.ents)
 		{
 			let ent = gameState.getEntityById(entId);
 			if (allowCapture === undefined)
 				allowCapture = PETRA.allowCapture(gameState, ent, target);
 			let orderData = ent.unitAIOrderData();
 			if (!orderData || !orderData.length || !orderData[0].attackType)
 				continue;
 			if ((orderData[0].attackType == "Capture") !== allowCapture)
 				ent.attack(targetId, allowCapture);
 		}
 	}
 
 	this.capturableTargetsTime = gameState.ai.elapsedTime;
 };
 
 /** Some functions that register that we assigned a gatherer to a resource this turn */
 
 /** add a gatherer to the turn cache for this supply. */
 PETRA.HQ.prototype.AddTCGatherer = function(supplyID)
 {
 	if (this.turnCache.resourceGatherer && this.turnCache.resourceGatherer[supplyID] !== undefined)
 		++this.turnCache.resourceGatherer[supplyID];
 	else
 	{
 		if (!this.turnCache.resourceGatherer)
 			this.turnCache.resourceGatherer = {};
 		this.turnCache.resourceGatherer[supplyID] = 1;
 	}
 };
 
 /** remove a gatherer to the turn cache for this supply. */
 PETRA.HQ.prototype.RemoveTCGatherer = function(supplyID)
 {
 	if (this.turnCache.resourceGatherer && this.turnCache.resourceGatherer[supplyID])
 		--this.turnCache.resourceGatherer[supplyID];
 	else
 	{
 		if (!this.turnCache.resourceGatherer)
 			this.turnCache.resourceGatherer = {};
 		this.turnCache.resourceGatherer[supplyID] = -1;
 	}
 };
 
 PETRA.HQ.prototype.GetTCGatherer = function(supplyID)
 {
 	if (this.turnCache.resourceGatherer && this.turnCache.resourceGatherer[supplyID])
 		return this.turnCache.resourceGatherer[supplyID];
 
 	return 0;
 };
 
 /** The next two are to register that we assigned a gatherer to a resource this turn. */
 PETRA.HQ.prototype.AddTCResGatherer = function(resource)
 {
 	if (this.turnCache["resourceGatherer-" + resource])
 		++this.turnCache["resourceGatherer-" + resource];
 	else
 		this.turnCache["resourceGatherer-" + resource] = 1;
 
 	if (this.turnCache.currentRates)
 		this.turnCache.currentRates[resource] += 0.5;
 };
 
 PETRA.HQ.prototype.GetTCResGatherer = function(resource)
 {
 	if (this.turnCache["resourceGatherer-" + resource])
 		return this.turnCache["resourceGatherer-" + resource];
 
 	return 0;
 };
 
 /**
  * flag a resource as exhausted
  */
 PETRA.HQ.prototype.isResourceExhausted = function(resource)
 {
 	if (this.turnCache["exhausted-" + resource] == undefined)
 		this.turnCache["exhausted-" + resource] = this.baseManagers.every(base =>
 			!base.dropsiteSupplies[resource].nearby.length &&
 			!base.dropsiteSupplies[resource].medium.length &&
 			!base.dropsiteSupplies[resource].faraway.length);
 
 	return this.turnCache["exhausted-" + resource];
 };
 
 /**
  * Check if a structure in blinking territory should/can be defended (currently if it has some attacking armies around)
  */
 PETRA.HQ.prototype.isDefendable = function(ent)
 {
 	if (!this.turnCache.numAround)
 		this.turnCache.numAround = {};
 	if (this.turnCache.numAround[ent.id()] === undefined)
 		this.turnCache.numAround[ent.id()] = this.attackManager.numAttackingUnitsAround(ent.position(), 130);
 	return +this.turnCache.numAround[ent.id()] > 8;
 };
 
 /**
  * Get the number of population already accounted for
  */
 PETRA.HQ.prototype.getAccountedPopulation = function(gameState)
 {
 	if (this.turnCache.accountedPopulation == undefined)
 	{
 		let pop = gameState.getPopulation();
 		for (let ent of gameState.getOwnTrainingFacilities().values())
 		{
 			for (let item of ent.trainingQueue())
 			{
 				if (!item.unitTemplate)
 					continue;
 				let unitPop = gameState.getTemplate(item.unitTemplate).get("Cost/Population");
 				if (unitPop)
 					pop += item.count * unitPop;
 			}
 		}
 		this.turnCache.accountedPopulation = pop;
 	}
 	return this.turnCache.accountedPopulation;
 };
 
 /**
  * Get the number of workers already accounted for
  */
 PETRA.HQ.prototype.getAccountedWorkers = function(gameState)
 {
 	if (this.turnCache.accountedWorkers == undefined)
 	{
 		let workers = gameState.getOwnEntitiesByRole("worker", true).length;
 		for (let ent of gameState.getOwnTrainingFacilities().values())
 		{
 			for (let item of ent.trainingQueue())
 			{
 				if (!item.metadata || !item.metadata.role || item.metadata.role != "worker")
 					continue;
 				workers += item.count;
 			}
 		}
 		this.turnCache.accountedWorkers = workers;
 	}
 	return this.turnCache.accountedWorkers;
 };
 
 /**
  * Some functions are run every turn
  * Others once in a while
  */
 PETRA.HQ.prototype.update = function(gameState, queues, events)
 {
 	Engine.ProfileStart("Headquarters update");
 	this.turnCache = {};
 	this.territoryMap = PETRA.createTerritoryMap(gameState);
 	this.canBarter = gameState.getOwnEntitiesByClass("BarterMarket", true).filter(API3.Filters.isBuilt()).hasEntities();
 	// TODO find a better way to update
 	if (this.currentPhase != gameState.currentPhase())
 	{
 		if (this.Config.debug > 0)
 			API3.warn(" civ " + gameState.getPlayerCiv() + " has phasedUp from " + this.currentPhase +
 			          " to " + gameState.currentPhase() + " at time " + gameState.ai.elapsedTime +
 				  " phasing " + this.phasing);
 		this.currentPhase = gameState.currentPhase();
 
 		// In principle, this.phasing should be already reset to 0 when starting the research
 		// but this does not work in case of an autoResearch tech
 		if (this.phasing)
 			this.phasing = 0;
 	}
 
 	/*
 	if (this.Config.debug > 1)
 	{
 		gameState.getOwnUnits().forEach (function (ent) {
 			if (!ent.position())
 				return;
 			PETRA.dumpEntity(ent);
 		});
 	}
 	*/
 
 	this.checkEvents(gameState, events);
 	this.navalManager.checkEvents(gameState, queues, events);
 
 	if (this.phasing)
 		this.checkPhaseRequirements(gameState, queues);
 	else
 		this.researchManager.checkPhase(gameState, queues);
 
 	if (this.numActiveBases() > 0)
 	{
 		if (gameState.ai.playedTurn % 4 == 0)
 			this.trainMoreWorkers(gameState, queues);
 
 		if (gameState.ai.playedTurn % 4 == 1)
 			this.buildMoreHouses(gameState, queues);
 
 		if ((!this.saveResources || this.canBarter) && gameState.ai.playedTurn % 4 == 2)
 			this.buildFarmstead(gameState, queues);
 
 		if (this.needCorral && gameState.ai.playedTurn % 4 == 3)
 			this.manageCorral(gameState, queues);
 
 		if (!queues.minorTech.hasQueuedUnits() && gameState.ai.playedTurn % 5 == 1)
 			this.researchManager.update(gameState, queues);
 	}
 
 	if (this.numPotentialBases() < 1 ||
 	    this.canExpand && gameState.ai.playedTurn % 10 == 7 && this.currentPhase > 1)
 		this.checkBaseExpansion(gameState, queues);
 
 	if (this.currentPhase > 1 && gameState.ai.playedTurn % 3 == 0)
 	{
 		if (!this.canBarter)
 			this.buildMarket(gameState, queues);
 
 		if (!this.saveResources)
 		{
 			this.buildBlacksmith(gameState, queues);
 			this.buildTemple(gameState, queues);
 		}
 
 		if (gameState.ai.playedTurn % 30 == 0 &&
 		    gameState.getPopulation() > 0.9 * gameState.getPopulationMax())
 			this.buildWonder(gameState, queues, false);
 	}
 
 	this.tradeManager.update(gameState, events, queues);
 
 	this.garrisonManager.update(gameState, events);
 	this.defenseManager.update(gameState, events);
 
 	if (gameState.ai.playedTurn % 3 == 0)
 	{
 		this.constructTrainingBuildings(gameState, queues);
 		if (this.Config.difficulty > 0)
 			this.buildDefenses(gameState, queues);
 	}
 
 	this.assignGatherers();
 	let nbBases = this.baseManagers.length;
 	let activeBase;	// We will loop only on 1 active base per turn
 	do
 	{
 		this.currentBase %= this.baseManagers.length;
 		activeBase = this.baseManagers[this.currentBase++].update(gameState, queues, events);
 		--nbBases;
 		// TODO what to do with this.reassignTerritories(this.baseManagers[this.currentBase]);
 	}
 	while (!activeBase && nbBases != 0);
 
 	this.navalManager.update(gameState, queues, events);
 
 	if (this.Config.difficulty > 0 && (this.numActiveBases() > 0 || !this.canBuildUnits))
 		this.attackManager.update(gameState, queues, events);
 
 	this.diplomacyManager.update(gameState, events);
 
 	this.victoryManager.update(gameState, events, queues);
 
 	// We update the capture strength at the end as it can change attack orders
 	if (gameState.ai.elapsedTime - this.capturableTargetsTime > 3)
 		this.updateCaptureStrength(gameState);
 
 	Engine.ProfileStop();
 };
 
 PETRA.HQ.prototype.Serialize = function()
 {
 	let properties = {
 		"phasing": this.phasing,
 		"currentBase": this.currentBase,
 		"lastFailedGather": this.lastFailedGather,
 		"firstBaseConfig": this.firstBaseConfig,
 		"supportRatio": this.supportRatio,
 		"targetNumWorkers": this.targetNumWorkers,
 		"fortStartTime": this.fortStartTime,
 		"towerStartTime": this.towerStartTime,
 		"fortressStartTime": this.fortressStartTime,
 		"bAdvanced": this.bAdvanced,
 		"saveResources": this.saveResources,
 		"saveSpace": this.saveSpace,
 		"needCorral": this.needCorral,
 		"needFarm": this.needFarm,
 		"needFish": this.needFish,
 		"maxFields": this.maxFields,
 		"canExpand": this.canExpand,
 		"canBuildUnits": this.canBuildUnits,
 		"navalMap": this.navalMap,
 		"landRegions": this.landRegions,
 		"navalRegions": this.navalRegions,
 		"decayingStructures": this.decayingStructures,
 		"capturableTargets": this.capturableTargets,
 		"capturableTargetsTime": this.capturableTargetsTime
 	};
 
 	let baseManagers = [];
 	for (let base of this.baseManagers)
 		baseManagers.push(base.Serialize());
 
 	if (this.Config.debug == -100)
 	{
 		API3.warn(" HQ serialization ---------------------");
 		API3.warn(" properties " + uneval(properties));
 		API3.warn(" baseManagers " + uneval(baseManagers));
 		API3.warn(" attackManager " + uneval(this.attackManager.Serialize()));
 		API3.warn(" buildManager " + uneval(this.buildManager.Serialize()));
 		API3.warn(" defenseManager " + uneval(this.defenseManager.Serialize()));
 		API3.warn(" tradeManager " + uneval(this.tradeManager.Serialize()));
 		API3.warn(" navalManager " + uneval(this.navalManager.Serialize()));
 		API3.warn(" researchManager " + uneval(this.researchManager.Serialize()));
 		API3.warn(" diplomacyManager " + uneval(this.diplomacyManager.Serialize()));
 		API3.warn(" garrisonManager " + uneval(this.garrisonManager.Serialize()));
 		API3.warn(" victoryManager " + uneval(this.victoryManager.Serialize()));
 	}
 
 	return {
 		"properties": properties,
 
 		"baseManagers": baseManagers,
 		"attackManager": this.attackManager.Serialize(),
 		"buildManager": this.buildManager.Serialize(),
 		"defenseManager": this.defenseManager.Serialize(),
 		"tradeManager": this.tradeManager.Serialize(),
 		"navalManager": this.navalManager.Serialize(),
 		"researchManager": this.researchManager.Serialize(),
 		"diplomacyManager": this.diplomacyManager.Serialize(),
 		"garrisonManager": this.garrisonManager.Serialize(),
 		"victoryManager": this.victoryManager.Serialize(),
 	};
 };
 
 PETRA.HQ.prototype.Deserialize = function(gameState, data)
 {
 	for (let key in data.properties)
 		this[key] = data.properties[key];
 
 	this.baseManagers = [];
 	for (let base of data.baseManagers)
 	{
 		// the first call to deserialize set the ID base needed by entitycollections
 		let newbase = new PETRA.BaseManager(gameState, this.Config);
 		newbase.Deserialize(gameState, base);
 		newbase.init(gameState);
 		newbase.Deserialize(gameState, base);
 		this.baseManagers.push(newbase);
 	}
 
 	this.navalManager = new PETRA.NavalManager(this.Config);
 	this.navalManager.init(gameState, true);
 	this.navalManager.Deserialize(gameState, data.navalManager);
 
 	this.attackManager = new PETRA.AttackManager(this.Config);
 	this.attackManager.Deserialize(gameState, data.attackManager);
 	this.attackManager.init(gameState);
 	this.attackManager.Deserialize(gameState, data.attackManager);
 
 	this.buildManager = new PETRA.BuildManager();
 	this.buildManager.Deserialize(data.buildManager);
 
 	this.defenseManager = new PETRA.DefenseManager(this.Config);
 	this.defenseManager.Deserialize(gameState, data.defenseManager);
 
 	this.tradeManager = new PETRA.TradeManager(this.Config);
 	this.tradeManager.init(gameState);
 	this.tradeManager.Deserialize(gameState, data.tradeManager);
 
 	this.researchManager = new PETRA.ResearchManager(this.Config);
 	this.researchManager.Deserialize(data.researchManager);
 
 	this.diplomacyManager = new PETRA.DiplomacyManager(this.Config);
 	this.diplomacyManager.Deserialize(data.diplomacyManager);
 
 	this.garrisonManager = new PETRA.GarrisonManager(this.Config);
 	this.garrisonManager.Deserialize(data.garrisonManager);
 
 	this.victoryManager = new PETRA.VictoryManager(this.Config);
 	this.victoryManager.Deserialize(data.victoryManager);
 };
Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/tradeManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/tradeManager.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/tradeManager.js	(revision 22970)
@@ -1,716 +1,732 @@
 /**
  * Manage the trade
  */
 PETRA.TradeManager = function(Config)
 {
 	this.Config = Config;
 	this.tradeRoute = undefined;
 	this.potentialTradeRoute = undefined;
 	this.routeProspection = false;
 	this.targetNumTraders = this.Config.Economy.targetNumTraders;
 	this.warnedAllies = {};
 };
 
 PETRA.TradeManager.prototype.init = function(gameState)
 {
 	this.traders = gameState.getOwnUnits().filter(API3.Filters.byMetadata(PlayerID, "role", "trader"));
 	this.traders.registerUpdates();
 	this.minimalGain = gameState.ai.HQ.navalMap ? 3 : 5;
 };
 
 PETRA.TradeManager.prototype.hasTradeRoute = function()
 {
 	return this.tradeRoute !== undefined;
 };
 
 PETRA.TradeManager.prototype.assignTrader = function(ent)
 {
 	ent.setMetadata(PlayerID, "role", "trader");
 	this.traders.updateEnt(ent);
 };
 
 PETRA.TradeManager.prototype.trainMoreTraders = function(gameState, queues)
 {
 	if (!this.hasTradeRoute() || queues.trader.hasQueuedUnits())
 		return;
 
 	let numTraders = this.traders.length;
 	let numSeaTraders = this.traders.filter(API3.Filters.byClass("Ship")).length;
 	let numLandTraders = numTraders - numSeaTraders;
 	// add traders already in training
 	gameState.getOwnTrainingFacilities().forEach(function(ent) {
 		for (let item of ent.trainingQueue())
 		{
 			if (!item.metadata || !item.metadata.role || item.metadata.role != "trader")
 				continue;
 			numTraders += item.count;
 			if (item.metadata.sea !== undefined)
 				numSeaTraders += item.count;
 			else
 				numLandTraders += item.count;
 		}
 	});
 	if (numTraders >= this.targetNumTraders &&
 		(!this.tradeRoute.sea && numLandTraders >= Math.floor(this.targetNumTraders/2) ||
 		  this.tradeRoute.sea && numSeaTraders >= Math.floor(this.targetNumTraders/2)))
 		return;
 
 	let template;
 	let metadata = { "role": "trader" };
 	if (this.tradeRoute.sea)
 	{
 		// if we have some merchand ships assigned to transport, try first to reassign them
 		// May-be, there were produced at an early stage when no other ship were available
 		// and the naval manager will train now more appropriate ships.
 		let already = false;
 		let shipToSwitch;
 		gameState.ai.HQ.navalManager.seaTransportShips[this.tradeRoute.sea].forEach(function(ship) {
 			if (already || !ship.hasClass("Trader"))
 				return;
 			if (ship.getMetadata(PlayerID, "role") == "switchToTrader")
 			{
 				already = true;
 				return;
 			}
 			shipToSwitch = ship;
 		});
 		if (already)
 			return;
 		if (shipToSwitch)
 		{
 			if (shipToSwitch.getMetadata(PlayerID, "transporter") === undefined)
 				shipToSwitch.setMetadata(PlayerID, "role", "trader");
 			else
 				shipToSwitch.setMetadata(PlayerID, "role", "switchToTrader");
 			return;
 		}
 
 		template = gameState.applyCiv("units/{civ}_ship_merchant");
 		metadata.sea = this.tradeRoute.sea;
 	}
 	else
 	{
 		template = gameState.applyCiv("units/{civ}_support_trader");
 		if (!this.tradeRoute.source.hasClass("NavalMarket"))
 			metadata.base = this.tradeRoute.source.getMetadata(PlayerID, "base");
 		else
 			metadata.base = this.tradeRoute.target.getMetadata(PlayerID, "base");
 	}
 
 	if (!gameState.getTemplate(template))
 	{
 		if (this.Config.debug > 0)
 			API3.warn("Petra error: trying to train " + template + " for civ " +
 			          gameState.getPlayerCiv() + " but no template found.");
 		return;
 	}
 	queues.trader.addPlan(new PETRA.TrainingPlan(gameState, template, metadata, 1, 1));
 };
 
 PETRA.TradeManager.prototype.updateTrader = function(gameState, ent)
 {
 	if (ent.hasClass("Ship") && gameState.ai.playedTurn % 5 == 0 &&
 	    !ent.unitAIState().startsWith("INDIVIDUAL.GATHER") &&
 	    PETRA.gatherTreasure(gameState, ent, true))
 		return;
 
 	if (!this.hasTradeRoute() || !ent.isIdle() || !ent.position())
 		return;
 	if (ent.getMetadata(PlayerID, "transport") !== undefined)
 		return;
 
 	// TODO if the trader is idle and has workOrders, restore them to avoid losing the current gain
 
 	Engine.ProfileStart("Trade Manager");
 	let access = ent.hasClass("Ship") ? PETRA.getSeaAccess(gameState, ent) : PETRA.getLandAccess(gameState, ent);
 	let route = this.checkRoutes(gameState, access);
 	if (!route)
 	{
 		// TODO try to garrison land trader inside merchant ship when only sea routes available
 		if (this.Config.debug > 0)
 			API3.warn(" no available route for " + ent.genericName() + " " + ent.id());
 		Engine.ProfileStop();
 		return;
 	}
 
 	let nearerSource = true;
 	if (API3.SquareVectorDistance(route.target.position(), ent.position()) < API3.SquareVectorDistance(route.source.position(), ent.position()))
 		nearerSource = false;
 
 	if (!ent.hasClass("Ship") && route.land != access)
 	{
 		if (nearerSource)
 			gameState.ai.HQ.navalManager.requireTransport(gameState, ent, access, route.land, route.source.position());
 		else
 			gameState.ai.HQ.navalManager.requireTransport(gameState, ent, access, route.land, route.target.position());
 		Engine.ProfileStop();
 		return;
 	}
 
 	if (nearerSource)
 		ent.tradeRoute(route.target, route.source);
 	else
 		ent.tradeRoute(route.source, route.target);
 	ent.setMetadata(PlayerID, "route", this.routeEntToId(route));
 	Engine.ProfileStop();
 };
 
 PETRA.TradeManager.prototype.setTradingGoods = function(gameState)
 {
+	let resTradeCodes = Resources.GetTradableCodes();
+	if (!resTradeCodes.length)
+		return;
 	let tradingGoods = {};
-	for (let res of Resources.GetCodes())
+	for (let res of resTradeCodes)
 		tradingGoods[res] = 0;
 	// first, try to anticipate future needs
 	let stocks = gameState.ai.HQ.getTotalResourceLevel(gameState);
-	let mostNeeded = gameState.ai.HQ.pickMostNeededResources(gameState);
+	let mostNeeded = gameState.ai.HQ.pickMostNeededResources(gameState, resTradeCodes);
 	let wantedRates = gameState.ai.HQ.GetWantedGatherRates(gameState);
 	let remaining = 100;
 	let targetNum = this.Config.Economy.targetNumTraders;
-	for (let res in stocks)
+	for (let res of resTradeCodes)
 	{
 		if (res == "food")
 			continue;
 		let wantedRate = wantedRates[res];
 		if (stocks[res] < 200)
 		{
 			tradingGoods[res] = wantedRate > 0 ? 20 : 10;
 			targetNum += Math.min(5, 3 + Math.ceil(wantedRate/30));
 		}
 		else if (stocks[res] < 500)
 		{
 			tradingGoods[res] = wantedRate > 0 ? 15 : 10;
 			targetNum += 2;
 		}
 		else if (stocks[res] < 1000)
 		{
 			tradingGoods[res] = 10;
 			targetNum += 1;
 		}
 		remaining -= tradingGoods[res];
 	}
 	this.targetNumTraders = Math.round(this.Config.popScaling * targetNum);
 
 
 	// then add what is needed now
 	let mainNeed = Math.floor(remaining * 70 / 100);
 	let nextNeed = remaining - mainNeed;
 
 	tradingGoods[mostNeeded[0].type] += mainNeed;
-	if (mostNeeded[1].wanted > 0)
+	if (mostNeeded[1] && mostNeeded[1].wanted > 0)
 		tradingGoods[mostNeeded[1].type] += nextNeed;
 	else
 		tradingGoods[mostNeeded[0].type] += nextNeed;
 	Engine.PostCommand(PlayerID, { "type": "set-trading-goods", "tradingGoods": tradingGoods });
 	if (this.Config.debug > 2)
 		API3.warn(" trading goods set to " + uneval(tradingGoods));
 };
 
 /**
  * Try to barter unneeded resources for needed resources.
  * only once per turn because the info is not updated within a turn
  */
 PETRA.TradeManager.prototype.performBarter = function(gameState)
 {
 	let barterers = gameState.getOwnEntitiesByClass("BarterMarket", true).filter(API3.Filters.isBuilt()).toEntityArray();
 	if (barterers.length == 0)
 		return false;
+	let resBarterCodes = Resources.GetBarterableCodes();
+	if (!resBarterCodes.length)
+		return false;
 
 	// Available resources after account substraction
 	let available = gameState.ai.queueManager.getAvailableResources(gameState);
 	let needs = gameState.ai.queueManager.currentNeeds(gameState);
 
 	let rates = gameState.ai.HQ.GetCurrentGatherRates(gameState);
 
 	let barterPrices = gameState.getBarterPrices();
 	// calculates conversion rates
 	let getBarterRate = (prices, buy, sell) => Math.round(100 * prices.sell[sell] / prices.buy[buy]);
 
 	// loop through each missing resource checking if we could barter and help finishing a queue quickly.
-	for (let buy of Resources.GetCodes())
+	for (let buy of resBarterCodes)
 	{
 		// Check if our rate allows to gather it fast enough
 		if (needs[buy] == 0 || needs[buy] < rates[buy] * 30)
 			continue;
 
 		// Pick the best resource to barter.
 		let bestToSell;
 		let bestRate = 0;
-		for (let sell of Resources.GetCodes())
+		for (let sell of resBarterCodes)
 		{
 			if (sell == buy)
 				continue;
 			// Do not sell if we need it or do not have enough buffer
 			if (needs[sell] > 0 || available[sell] < 500)
 				continue;
 
 			let barterRateMin;
 			if (sell == "food")
 			{
 				barterRateMin = 30;
 				if (available[sell] > 40000)
 					barterRateMin = 0;
 				else if (available[sell] > 15000)
 					barterRateMin = 5;
 				else if (available[sell] > 1000)
 					barterRateMin = 10;
 			}
 			else
 			{
 				barterRateMin = 70;
 				if (available[sell] > 5000)
 					barterRateMin = 30;
 				else if (available[sell] > 1000)
 					barterRateMin = 50;
 				if (buy == "food")
 					barterRateMin += 20;
 			}
 
 			let barterRate = getBarterRate(barterPrices, buy, sell);
 			if (barterRate > bestRate && barterRate > barterRateMin)
 			{
 				bestRate = barterRate;
 				bestToSell = sell;
 			}
 		}
 		if (bestToSell !== undefined)
 		{
 			let amount = available[bestToSell] > 5000 ? 500 : 100;
 			barterers[0].barter(buy, bestToSell, amount);
 			if (this.Config.debug > 2)
 				API3.warn("Necessity bartering: sold " + bestToSell +" for " + buy +
 				          " >> need sell " + needs[bestToSell] + " need buy " + needs[buy] +
 				          " rate buy " + rates[buy] + " available sell " + available[bestToSell] +
 				          " available buy " + available[buy] + " barterRate " + bestRate +
 				          " amount " + amount);
 			return true;
 		}
 	}
 
 	// now do contingency bartering, selling food to buy finite resources (and annoy our ennemies by increasing prices)
-	if (available.food < 1000 || needs.food > 0)
+	if (available.food < 1000 || needs.food > 0 || resBarterCodes.indexOf("food") == -1)
 		return false;
 	let bestToBuy;
 	let bestChoice = 0;
-	for (let buy of Resources.GetCodes())
+	for (let buy of resBarterCodes)
 	{
 		if (buy == "food")
 			continue;
 		let barterRateMin = 80;
 		if (available[buy] < 5000 && available.food > 5000)
 			barterRateMin -= 20 - Math.floor(available[buy]/250);
 		let barterRate = getBarterRate(barterPrices, buy, "food");
 		if (barterRate < barterRateMin)
 			continue;
 		let choice = barterRate / (100 + available[buy]);
 		if (choice > bestChoice)
 		{
 			bestChoice = choice;
 			bestToBuy = buy;
 		}
 	}
 	if (bestToBuy !== undefined)
 	{
 		let amount = available.food > 5000 ? 500 : 100;
 		barterers[0].barter(bestToBuy, "food", amount);
 		if (this.Config.debug > 2)
 			API3.warn("Contingency bartering: sold food for " + bestToBuy +
 			          " available sell " + available.food + " available buy " + available[bestToBuy] +
 			          " barterRate " + getBarterRate(barterPrices, bestToBuy, "food") +
 			          " amount " + amount);
 		return true;
 	}
 
 	return false;
 };
 
 PETRA.TradeManager.prototype.checkEvents = function(gameState, events)
 {
 	// check if one market from a traderoute is renamed, change the route accordingly
 	for (let evt of events.EntityRenamed)
 	{
 		let ent = gameState.getEntityById(evt.newentity);
 		if (!ent || !ent.hasClass("Market"))
 			continue;
 		for (let trader of this.traders.values())
 		{
 			let route = trader.getMetadata(PlayerID, "route");
 			if (!route)
 				continue;
 			if (route.source == evt.entity)
 				route.source = evt.newentity;
 			else if (route.target == evt.entity)
 				route.target = evt.newentity;
 			else
 				continue;
 			trader.setMetadata(PlayerID, "route", route);
 		}
 	}
 
 	// if one market (or market-foundation) is destroyed, we should look for a better route
 	for (let evt of events.Destroy)
 	{
 		if (!evt.entityObj)
 			continue;
 		let ent = evt.entityObj;
 		if (!ent || !ent.hasClass("Market") || !gameState.isPlayerAlly(ent.owner()))
 			continue;
 		this.activateProspection(gameState);
 		return true;
 	}
 
 	// same thing if one market is built
 	for (let evt of events.Create)
 	{
 		let ent = gameState.getEntityById(evt.entity);
 		if (!ent || ent.foundationProgress() !== undefined || !ent.hasClass("Market") ||
 		    !gameState.isPlayerAlly(ent.owner()))
 			continue;
 		this.activateProspection(gameState);
 		return true;
 	}
 
 
 	// and same thing for captured markets
 	for (let evt of events.OwnershipChanged)
 	{
 		if (!gameState.isPlayerAlly(evt.from) && !gameState.isPlayerAlly(evt.to))
 			continue;
 		let ent = gameState.getEntityById(evt.entity);
 		if (!ent || ent.foundationProgress() !== undefined || !ent.hasClass("Market"))
 			continue;
 		this.activateProspection(gameState);
 		return true;
 	}
 
 	// or if diplomacy changed
 	if (events.DiplomacyChanged.length)
 	{
 		this.activateProspection(gameState);
 		return true;
 	}
 
 	return false;
 };
 
 PETRA.TradeManager.prototype.activateProspection = function(gameState)
 {
 	this.routeProspection = true;
 	gameState.ai.HQ.buildManager.setBuildable(gameState.applyCiv("structures/{civ}_market"));
 	gameState.ai.HQ.buildManager.setBuildable(gameState.applyCiv("structures/{civ}_dock"));
 };
 
 /**
  * fills the best trade route in this.tradeRoute and the best potential route in this.potentialTradeRoute
  * If an index is given, it returns the best route with this index or the best land route if index is a land index
  */
 PETRA.TradeManager.prototype.checkRoutes = function(gameState, accessIndex)
 {
+	// If we cannot trade, do not bother checking routes.
+	if (!Resources.GetTradableCodes().length)
+	{
+		this.tradeRoute = undefined;
+		this.potentialTradeRoute = undefined;
+		return false;
+	}
+
 	let market1 = gameState.updatingCollection("OwnMarkets", API3.Filters.byClass("Market"), gameState.getOwnStructures());
 	let market2 = gameState.updatingCollection("diplo-ExclusiveAllyMarkets", API3.Filters.byClass("Market"), gameState.getExclusiveAllyEntities());
 	if (market1.length + market2.length < 2)  // We have to wait  ... markets will be built soon
 	{
 		this.tradeRoute = undefined;
 		this.potentialTradeRoute = undefined;
 		return false;
 	}
 
 	let onlyOurs = !market2.hasEntities();
 	if (onlyOurs)
 		market2 = market1;
 	let candidate = { "gain": 0 };
 	let potential = { "gain": 0 };
 	let bestIndex = { "gain": 0 };
 	let bestLand = { "gain": 0 };
 
 	let mapSize = gameState.sharedScript.mapSize;
 	let traderTemplatesGains = gameState.getTraderTemplatesGains();
 
 	for (let m1 of market1.values())
 	{
 		if (!m1.position())
 			continue;
 		let access1 = PETRA.getLandAccess(gameState, m1);
 		let sea1 = m1.hasClass("NavalMarket") ? PETRA.getSeaAccess(gameState, m1) : undefined;
 		for (let m2 of market2.values())
 		{
 			if (onlyOurs && m1.id() >= m2.id())
 				continue;
 			if (!m2.position())
 				continue;
 			let access2 = PETRA.getLandAccess(gameState, m2);
 			let sea2 = m2.hasClass("NavalMarket") ? PETRA.getSeaAccess(gameState, m2) : undefined;
 			let land = access1 == access2 ? access1 : undefined;
 			let sea = sea1 && sea1 == sea2 ? sea1 : undefined;
 			if (!land && !sea)
 				continue;
 			if (land && PETRA.isLineInsideEnemyTerritory(gameState, m1.position(), m2.position()))
 				continue;
 			let gainMultiplier;
 			if (land && traderTemplatesGains.landGainMultiplier)
 				gainMultiplier = traderTemplatesGains.landGainMultiplier;
 			else if (sea && traderTemplatesGains.navalGainMultiplier)
 				gainMultiplier = traderTemplatesGains.navalGainMultiplier;
 			else
 				continue;
 			let gain = Math.round(gainMultiplier * TradeGain(API3.SquareVectorDistance(m1.position(), m2.position()), mapSize));
 			if (gain < this.minimalGain)
 				continue;
 			if (m1.foundationProgress() === undefined && m2.foundationProgress() === undefined)
 			{
 				if (accessIndex)
 				{
 					if (gameState.ai.accessibility.regionType[accessIndex] == "water" && sea == accessIndex)
 					{
 						if (gain < bestIndex.gain)
 							continue;
 						bestIndex = { "source": m1, "target": m2, "gain": gain, "land": land, "sea": sea };
 					}
 					else if (gameState.ai.accessibility.regionType[accessIndex] == "land" && land == accessIndex)
 					{
 						if (gain < bestIndex.gain)
 							continue;
 						bestIndex = { "source": m1, "target": m2, "gain": gain, "land": land, "sea": sea };
 					}
 					else if (gameState.ai.accessibility.regionType[accessIndex] == "land")
 					{
 						if (gain < bestLand.gain)
 							continue;
 						bestLand = { "source": m1, "target": m2, "gain": gain, "land": land, "sea": sea };
 					}
 				}
 				if (gain < candidate.gain)
 					continue;
 				candidate = { "source": m1, "target": m2, "gain": gain, "land": land, "sea": sea };
 			}
 			if (gain < potential.gain)
 				continue;
 			potential = { "source": m1, "target": m2, "gain": gain, "land": land, "sea": sea };
 		}
 	}
 
 	if (potential.gain < 1)
 		this.potentialTradeRoute = undefined;
 	else
 		this.potentialTradeRoute = potential;
 
 	if (candidate.gain < 1)
 	{
 		if (this.Config.debug > 2)
 			API3.warn("no better trade route possible");
 		this.tradeRoute = undefined;
 		return false;
 	}
 
 	if (this.Config.debug > 1 && this.tradeRoute)
 	{
 		if (candidate.gain > this.tradeRoute.gain)
 			API3.warn("one better trade route set with gain " + candidate.gain + " instead of " + this.tradeRoute.gain);
 	}
 	else if (this.Config.debug > 1)
 		API3.warn("one trade route set with gain " + candidate.gain);
 	this.tradeRoute = candidate;
 
 	if (this.Config.chat)
 	{
 		let owner = this.tradeRoute.source.owner();
 		if (owner == PlayerID)
 			owner = this.tradeRoute.target.owner();
 		if (owner != PlayerID && !this.warnedAllies[owner])
 		{	// Warn an ally that we have a trade route with him
 			PETRA.chatNewTradeRoute(gameState, owner);
 			this.warnedAllies[owner] = true;
 		}
 	}
 
 	if (accessIndex)
 	{
 		if (bestIndex.gain > 0)
 			return bestIndex;
 		else if (gameState.ai.accessibility.regionType[accessIndex] == "land" && bestLand.gain > 0)
 			return bestLand;
 		return false;
 	}
 	return true;
 };
 
 /** Called when a market was built or destroyed, and checks if trader orders should be changed */
 PETRA.TradeManager.prototype.checkTrader = function(gameState, ent)
 {
 	let presentRoute = ent.getMetadata(PlayerID, "route");
 	if (!presentRoute)
 		return;
 
 	if (!ent.position())
 	{
 		// This trader is garrisoned, we will decide later (when ungarrisoning) what to do
 		ent.setMetadata(PlayerID, "route", undefined);
 		return;
 	}
 
 	let access = ent.hasClass("Ship") ? PETRA.getSeaAccess(gameState, ent) : PETRA.getLandAccess(gameState, ent);
 	let possibleRoute = this.checkRoutes(gameState, access);
 	// Warning:  presentRoute is from metadata, so contains entity ids
 	if (!possibleRoute ||
 	    possibleRoute.source.id() != presentRoute.source && possibleRoute.source.id() != presentRoute.target ||
 	    possibleRoute.target.id() != presentRoute.source && possibleRoute.target.id() != presentRoute.target)
 	{
 		// Trader will be assigned in updateTrader
 		ent.setMetadata(PlayerID, "route", undefined);
 		if (!possibleRoute && !ent.hasClass("Ship"))
 		{
 			let closestBase = PETRA.getBestBase(gameState, ent, true);
 			if (closestBase.accessIndex == access)
 			{
 				let closestBasePos = closestBase.anchor.position();
 				ent.moveToRange(closestBasePos[0], closestBasePos[1], 0, 15);
 				return;
 			}
 		}
 		ent.stopMoving();
 	}
 };
 
 PETRA.TradeManager.prototype.prospectForNewMarket = function(gameState, queues)
 {
 	if (queues.economicBuilding.hasQueuedUnitsWithClass("Market") || queues.dock.hasQueuedUnitsWithClass("Market"))
 		return;
 	if (!gameState.ai.HQ.canBuild(gameState, "structures/{civ}_market"))
 		return;
 	if (!gameState.updatingCollection("OwnMarkets", API3.Filters.byClass("Market"), gameState.getOwnStructures()).hasEntities() &&
 	    !gameState.updatingCollection("diplo-ExclusiveAllyMarkets", API3.Filters.byClass("Market"), gameState.getExclusiveAllyEntities()).hasEntities())
 		return;
 	let template = gameState.getTemplate(gameState.applyCiv("structures/{civ}_market"));
 	if (!template)
 		return;
 	this.checkRoutes(gameState);
 	let marketPos = gameState.ai.HQ.findMarketLocation(gameState, template);
 	if (!marketPos || marketPos[3] == 0)   // marketPos[3] is the expected gain
 	{	// no position found
 		if (gameState.getOwnEntitiesByClass("BarterMarket", true).hasEntities())
 			gameState.ai.HQ.buildManager.setUnbuildable(gameState, gameState.applyCiv("structures/{civ}_market"));
 		else
 			this.routeProspection = false;
 		return;
 	}
 	this.routeProspection = false;
 	if (!this.isNewMarketWorth(marketPos[3]))
 		return;	// position found, but not enough gain compared to our present route
 
 	if (this.Config.debug > 1)
 	{
 		if (this.potentialTradeRoute)
 			API3.warn("turn " + gameState.ai.playedTurn + "we could have a new route with gain " +
 				marketPos[3] + " instead of the present " + this.potentialTradeRoute.gain);
 		else
 			API3.warn("turn " + gameState.ai.playedTurn + "we could have a first route with gain " +
 				marketPos[3]);
 	}
 
 	if (!this.tradeRoute)
 		gameState.ai.queueManager.changePriority("economicBuilding", 2*this.Config.priorities.economicBuilding);
 	let plan = new PETRA.ConstructionPlan(gameState, "structures/{civ}_market");
 	if (!this.tradeRoute)
 		plan.queueToReset = "economicBuilding";
 	queues.economicBuilding.addPlan(plan);
 };
 
 PETRA.TradeManager.prototype.isNewMarketWorth = function(expectedGain)
 {
+	if (!Resources.GetTradableCodes().length)
+		return false;
 	if (expectedGain < this.minimalGain)
 		return false;
 	if (this.potentialTradeRoute && expectedGain < 2*this.potentialTradeRoute.gain &&
 		expectedGain < this.potentialTradeRoute.gain + 20)
 		return false;
 	return true;
 };
 
 PETRA.TradeManager.prototype.update = function(gameState, events, queues)
 {
-	if (gameState.ai.HQ.canBarter)
+	if (gameState.ai.HQ.canBarter && Resources.GetBarterableCodes().length)
 		this.performBarter(gameState);
 
 	if (this.Config.difficulty <= 1)
 		return;
 
 	if (this.checkEvents(gameState, events))  // true if one market was built or destroyed
 	{
 		this.traders.forEach(ent => { this.checkTrader(gameState, ent); });
 		this.checkRoutes(gameState);
 	}
 
 	if (this.tradeRoute)
 	{
 		this.traders.forEach(ent => { this.updateTrader(gameState, ent); });
 		if (gameState.ai.playedTurn % 5 == 0)
 			this.trainMoreTraders(gameState, queues);
 		if (gameState.ai.playedTurn % 20 == 0 && this.traders.length >= 2)
 			gameState.ai.HQ.researchManager.researchTradeBonus(gameState, queues);
 		if (gameState.ai.playedTurn % 60 == 0)
 			this.setTradingGoods(gameState);
 	}
 
 	if (this.routeProspection)
 		this.prospectForNewMarket(gameState, queues);
 };
 
 PETRA.TradeManager.prototype.routeEntToId = function(route)
 {
 	if (!route)
 		return undefined;
 
 	let ret = {};
 	for (let key in route)
 	{
 		if (key == "source" || key == "target")
 		{
 			if (!route[key])
 				return undefined;
 			ret[key] = route[key].id();
 		}
 		else
 			ret[key] = route[key];
 	}
 	return ret;
 };
 
 PETRA.TradeManager.prototype.routeIdToEnt = function(gameState, route)
 {
 	if (!route)
 		return undefined;
 
 	let ret = {};
 	for (let key in route)
 	{
 		if (key == "source" || key == "target")
 		{
 			ret[key] = gameState.getEntityById(route[key]);
 			if (!ret[key])
 				return undefined;
 		}
 		else
 			ret[key] = route[key];
 	}
 	return ret;
 };
 
 PETRA.TradeManager.prototype.Serialize = function()
 {
 	return {
 		"tradeRoute": this.routeEntToId(this.tradeRoute),
 		"potentialTradeRoute": this.routeEntToId(this.potentialTradeRoute),
 		"routeProspection": this.routeProspection,
 		"targetNumTraders": this.targetNumTraders,
 		"warnedAllies": this.warnedAllies
 	};
 };
 
 PETRA.TradeManager.prototype.Deserialize = function(gameState, data)
 {
 	for (let key in data)
 	{
 		if (key == "tradeRoute" || key == "potentialTradeRoute")
 			this[key] = this.routeIdToEnt(gameState, data[key]);
 		else
 			this[key] = data[key];
 	}
 };
Index: ps/trunk/binaries/data/mods/public/simulation/components/Barter.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Barter.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Barter.js	(revision 22970)
@@ -1,158 +1,158 @@
 function Barter() {}
 
 Barter.prototype.Schema =
 	"<a:component type='system'/><empty/>";
 
 /**
  * The "true price" is a base price of 100 units of resource (for the case of some resources being of more worth than others).
  * With current bartering system only relative values makes sense so if for example stone is two times more expensive than wood,
  * there will 2:1 exchange rate.
  *
  * Constant part of price percentage difference between true price and buy/sell price.
  * Buy price equal to true price plus constant difference.
  * Sell price equal to true price minus constant difference.
  */
 Barter.prototype.CONSTANT_DIFFERENCE = 10;
 /**
  * Additional difference of prices in percents, added after each deal to specified resource price.
  */
 Barter.prototype.DIFFERENCE_PER_DEAL = 2;
 /**
  * Price difference percentage which restored each restore timer tick
  */
 Barter.prototype.DIFFERENCE_RESTORE = 0.5;
 /**
  * Interval of timer which slowly restore prices after deals
  */
 Barter.prototype.RESTORE_TIMER_INTERVAL = 5000;
 
 Barter.prototype.Init = function()
 {
 	this.priceDifferences = {};
-	for (let resource of Resources.GetCodes())
+	for (let resource of Resources.GetBarterableCodes())
 		this.priceDifferences[resource] = 0;
 	this.restoreTimer = undefined;
 };
 
 Barter.prototype.GetPrices = function(playerID)
 {
-	var prices = { "buy": {}, "sell": {} };
+	let prices = { "buy": {}, "sell": {} };
 	let multiplier = QueryPlayerIDInterface(playerID).GetBarterMultiplier();
-	for (let resource of Resources.GetCodes())
+	for (let resource of Resources.GetBarterableCodes())
 	{
 		let truePrice = Resources.GetResource(resource).truePrice;
 		prices.buy[resource] = truePrice * (100 + this.CONSTANT_DIFFERENCE + this.priceDifferences[resource]) * multiplier.buy[resource] / 100;
 		prices.sell[resource] = truePrice * (100 - this.CONSTANT_DIFFERENCE + this.priceDifferences[resource]) * multiplier.sell[resource] / 100;
 	}
 	return prices;
 };
 
 Barter.prototype.PlayerHasMarket = function(playerID)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	var entities = cmpRangeManager.GetEntitiesByPlayer(playerID);
 	for (var entity of entities)
 	{
 		var cmpFoundation = Engine.QueryInterface(entity, IID_Foundation);
 		var cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
 		if (!cmpFoundation && cmpIdentity && cmpIdentity.HasClass("BarterMarket"))
 			return true;
 	}
 	return false;
 };
 
 Barter.prototype.ExchangeResources = function(playerID, resourceToSell, resourceToBuy, amount)
 {
 	if (amount <= 0)
 	{
 		warn("ExchangeResources: incorrect amount: " + uneval(amount));
 		return;
 	}
 
-	let availResources = Resources.GetCodes();
+	let availResources = Resources.GetBarterableCodes();
 	if (availResources.indexOf(resourceToSell) == -1)
 	{
 		warn("ExchangeResources: incorrect resource to sell: " + uneval(resourceToSell));
 		return;
 	}
 
 	if (availResources.indexOf(resourceToBuy) == -1)
 	{
 		warn("ExchangeResources: incorrect resource to buy: " + uneval(resourceToBuy));
 		return;
 	}
 
 	// This can occur when the player issues the order just before the market is destroyed or captured
 	if (!this.PlayerHasMarket(playerID))
 		return;
 
 	if (amount != 100 && amount != 500)
 		return;
 
 	var cmpPlayer = QueryPlayerIDInterface(playerID);
 	var prices = this.GetPrices(playerID);
 	var amountsToSubtract = {};
 	amountsToSubtract[resourceToSell] = amount;
 	if (cmpPlayer.TrySubtractResources(amountsToSubtract))
 	{
 		var amountToAdd = Math.round(prices["sell"][resourceToSell] / prices["buy"][resourceToBuy] * amount);
 		cmpPlayer.AddResource(resourceToBuy, amountToAdd);
 
 		// Display chat message to observers
 		var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		if (cmpGUIInterface)
 			cmpGUIInterface.PushNotification({
 				"type": "barter",
 				"players": [playerID],
 				"amountsSold": amount,
 				"amountsBought": amountToAdd,
 				"resourceSold": resourceToSell,
 				"resourceBought": resourceToBuy
 			});
 
 		var cmpStatisticsTracker = QueryPlayerIDInterface(playerID, IID_StatisticsTracker);
 		if (cmpStatisticsTracker)
 		{
 			cmpStatisticsTracker.IncreaseResourcesSoldCounter(resourceToSell, amount);
 			cmpStatisticsTracker.IncreaseResourcesBoughtCounter(resourceToBuy, amountToAdd);
 		}
 
 		let difference = this.DIFFERENCE_PER_DEAL * amount / 100;
 		// Increase price difference for both exchange resources.
 		// Overall price difference (dynamic +/- constant) can't exceed +-99%.
 		this.priceDifferences[resourceToSell] -= difference;
 		this.priceDifferences[resourceToSell] = Math.min(99 - this.CONSTANT_DIFFERENCE, Math.max(this.CONSTANT_DIFFERENCE - 99, this.priceDifferences[resourceToSell]));
 		this.priceDifferences[resourceToBuy] += difference;
 		this.priceDifferences[resourceToBuy] = Math.min(99 - this.CONSTANT_DIFFERENCE, Math.max(this.CONSTANT_DIFFERENCE - 99, this.priceDifferences[resourceToBuy]));
 	}
 
 	if (this.restoreTimer === undefined)
 	{
 		var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		this.restoreTimer = cmpTimer.SetInterval(this.entity, IID_Barter, "ProgressTimeout", this.RESTORE_TIMER_INTERVAL, this.RESTORE_TIMER_INTERVAL, {});
 	}
 };
 
 Barter.prototype.ProgressTimeout = function(data)
 {
-	var needRestore = false;
-	for (let resource of Resources.GetCodes())
+	let needRestore = false;
+	for (let resource of Resources.GetBarterableCodes())
 	{
 		// Calculate value to restore, it should be limited to [-DIFFERENCE_RESTORE; DIFFERENCE_RESTORE] interval
-		var differenceRestore = Math.min(this.DIFFERENCE_RESTORE, Math.max(-this.DIFFERENCE_RESTORE, this.priceDifferences[resource]));
+		let differenceRestore = Math.min(this.DIFFERENCE_RESTORE, Math.max(-this.DIFFERENCE_RESTORE, this.priceDifferences[resource]));
 		differenceRestore = -differenceRestore;
 		this.priceDifferences[resource] += differenceRestore;
 		// If price difference still exists then set flag to run timer again
 		if (this.priceDifferences[resource] != 0)
 			needRestore = true;
 	}
 
 	if (!needRestore)
 	{
-		var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		cmpTimer.CancelTimer(this.restoreTimer);
 		this.restoreTimer = undefined;
 	}
 };
 
 Engine.RegisterSystemComponentType(IID_Barter, "Barter", Barter);
Index: ps/trunk/binaries/data/mods/public/simulation/components/Player.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Player.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Player.js	(revision 22970)
@@ -1,937 +1,940 @@
 function Player() {}
 
 Player.prototype.Schema =
 	"<element name='BarterMultiplier' a:help='Multipliers for barter prices.'>" +
 		"<interleave>" +
 			"<element name='Buy' a:help='Multipliers for the buy prices.'>" +
 				Resources.BuildSchema("positiveDecimal") +
 			"</element>" +
 			"<element name='Sell' a:help='Multipliers for the sell prices.'>" +
 				Resources.BuildSchema("positiveDecimal") +
 			"</element>" +
 		"</interleave>" +
 	"</element>" +
 	"<element name='SharedLosTech' a:help='Allies will share los when this technology is researched. Leave empty to never share LOS.'>" +
 		"<text/>" +
 	"</element>" +
 	"<element name='SharedDropsitesTech' a:help='Allies will share dropsites when this technology is researched. Leave empty to never share dropsites.'>" +
 		"<text/>" +
 	"</element>" +
 	"<element name='SpyCostMultiplier'>" +
 		"<ref name='nonNegativeDecimal'/>" +
 	"</element>";
 
 /**
  * Don't serialize diplomacyColor or displayDiplomacyColor since they're modified by the GUI.
  */
 Player.prototype.Serialize = function()
 {
 	let state = {};
 	for (let key in this)
 		if (this.hasOwnProperty(key))
 			state[key] = this[key];
 
 	state.diplomacyColor = undefined;
 	state.displayDiplomacyColor = false;
 	return state;
 };
 
 /**
  * Which units will be shown with special icons at the top.
  */
 var panelEntityClasses = "Hero Relic";
 
 Player.prototype.Init = function()
 {
 	this.playerID = undefined;
 	this.name = undefined;	// define defaults elsewhere (supporting other languages)
 	this.civ = undefined;
 	this.color = undefined;
 	this.diplomacyColor = undefined;
 	this.displayDiplomacyColor = false;
 	this.popUsed = 0; // population of units owned or trained by this player
 	this.popBonuses = 0; // sum of population bonuses of player's entities
 	this.maxPop = 300; // maximum population
 	this.trainingBlocked = false; // indicates whether any training queue is currently blocked
 	this.resourceCount = {};
 	this.tradingGoods = []; // goods for next trade-route and its proba in % (the sum of probas must be 100)
 	this.team = -1;	// team number of the player, players on the same team will always have ally diplomatic status - also this is useful for team emblems, scoring, etc.
 	this.teamsLocked = false;
 	this.state = "active"; // game state - one of "active", "defeated", "won"
 	this.diplomacy = [];	// array of diplomatic stances for this player with respect to other players (including gaia and self)
 	this.sharedDropsites = false;
 	this.formations = [];
 	this.startCam = undefined;
 	this.controlAllUnits = false;
 	this.isAI = false;
 	this.cheatsEnabled = false;
 	this.panelEntities = [];
 	this.resourceNames = {};
 	this.disabledTemplates = {};
 	this.disabledTechnologies = {};
 	this.startingTechnologies = [];
 	this.spyCostMultiplier = +this.template.SpyCostMultiplier;
 	this.barterMultiplier = {
 		"buy": clone(this.template.BarterMultiplier.Buy),
 		"sell": clone(this.template.BarterMultiplier.Sell)
 	};
 
-	// Initial resources and trading goods probability in steps of 5
+	// Initial resources
 	let resCodes = Resources.GetCodes();
-	let quotient = Math.floor(20 / resCodes.length);
-	let remainder = 20 % resCodes.length;
-	for (let i in resCodes)
+	for (let res of resCodes)
 	{
-		let res = resCodes[i];
 		this.resourceCount[res] = 300;
 		this.resourceNames[res] = Resources.GetResource(res).name;
+	}
+	// Trading goods probability in steps of 5
+	let resTradeCodes = Resources.GetTradableCodes();
+	let quotient = Math.floor(20 / resTradeCodes.length);
+	let remainder = 20 % resTradeCodes.length;
+	for (let i in resTradeCodes)
 		this.tradingGoods.push({
-			"goods": res,
+			"goods": resTradeCodes[i],
 			"proba": 5 * (quotient + (+i < remainder ? 1 : 0))
 		});
-	}
 };
 
 Player.prototype.SetPlayerID = function(id)
 {
 	this.playerID = id;
 };
 
 Player.prototype.GetPlayerID = function()
 {
 	return this.playerID;
 };
 
 Player.prototype.SetName = function(name)
 {
 	this.name = name;
 };
 
 Player.prototype.GetName = function()
 {
 	return this.name;
 };
 
 Player.prototype.SetCiv = function(civcode)
 {
 	var oldCiv = this.civ;
 	this.civ = civcode;
 	// Normally, the civ is only set once
 	// But in Atlas, the map designers can change civs at any time
 	var playerID = this.GetPlayerID();
 	if (oldCiv && playerID && oldCiv != civcode)
 		Engine.BroadcastMessage(MT_CivChanged, {
 			"player": playerID,
 			"from": oldCiv,
 			"to": civcode
 		});
 };
 
 Player.prototype.GetCiv = function()
 {
 	return this.civ;
 };
 
 Player.prototype.SetColor = function(r, g, b)
 {
 	var colorInitialized = !!this.color;
 
 	this.color = { "r": r / 255, "g": g / 255, "b": b / 255, "a": 1 };
 
 	// Used in Atlas
 	if (colorInitialized)
 		Engine.BroadcastMessage(MT_PlayerColorChanged, {
 			"player": this.playerID
 		});
 };
 
 Player.prototype.SetDiplomacyColor = function(color)
 {
 	this.diplomacyColor = { "r": color.r / 255, "g": color.g / 255, "b": color.b / 255, "a": 1 };
 };
 
 Player.prototype.SetDisplayDiplomacyColor = function(displayDiplomacyColor)
 {
 	this.displayDiplomacyColor = displayDiplomacyColor;
 };
 
 Player.prototype.GetColor = function()
 {
 	return this.color;
 };
 
 Player.prototype.GetDisplayedColor = function()
 {
 	return this.displayDiplomacyColor ? this.diplomacyColor : this.color;
 };
 
 // Try reserving num population slots. Returns 0 on success or number of missing slots otherwise.
 Player.prototype.TryReservePopulationSlots = function(num)
 {
 	if (num != 0 && num > (this.GetPopulationLimit() - this.GetPopulationCount()))
 		return num - (this.GetPopulationLimit() - this.GetPopulationCount());
 
 	this.popUsed += num;
 	return 0;
 };
 
 Player.prototype.UnReservePopulationSlots = function(num)
 {
 	this.popUsed -= num;
 };
 
 Player.prototype.GetPopulationCount = function()
 {
 	return this.popUsed;
 };
 
 Player.prototype.AddPopulation = function(num)
 {
 	this.popUsed += num;
 };
 
 Player.prototype.SetPopulationBonuses = function(num)
 {
 	this.popBonuses = num;
 };
 
 Player.prototype.AddPopulationBonuses = function(num)
 {
 	this.popBonuses += num;
 };
 
 Player.prototype.GetPopulationLimit = function()
 {
 	return Math.min(this.GetMaxPopulation(), this.popBonuses);
 };
 
 Player.prototype.SetMaxPopulation = function(max)
 {
 	this.maxPop = max;
 };
 
 Player.prototype.GetMaxPopulation = function()
 {
 	return Math.round(ApplyValueModificationsToEntity("Player/MaxPopulation", this.maxPop, this.entity));
 };
 
 Player.prototype.GetBarterMultiplier = function()
 {
 	return this.barterMultiplier;
 };
 
 Player.prototype.GetSpyCostMultiplier = function()
 {
 	return this.spyCostMultiplier;
 };
 
 /**
  * Setters currently used by the AI to set the difficulty level
  */
 
 Player.prototype.GetPanelEntities = function()
 {
 	return this.panelEntities;
 };
 
 Player.prototype.IsTrainingBlocked = function()
 {
 	return this.trainingBlocked;
 };
 
 Player.prototype.BlockTraining = function()
 {
 	this.trainingBlocked = true;
 };
 
 Player.prototype.UnBlockTraining = function()
 {
 	this.trainingBlocked = false;
 };
 
 Player.prototype.SetResourceCounts = function(resources)
 {
 	for (let res in resources)
 		this.resourceCount[res] = resources[res];
 };
 
 Player.prototype.GetResourceCounts = function()
 {
 	return this.resourceCount;
 };
 
 /**
  * Add resource of specified type to player
  * @param type Generic type of resource (string)
  * @param amount Amount of resource, which should be added (integer)
  */
 Player.prototype.AddResource = function(type, amount)
 {
 	this.resourceCount[type] += +amount;
 };
 
 /**
  * Add resources to player
  */
 Player.prototype.AddResources = function(amounts)
 {
 	for (var type in amounts)
 		this.resourceCount[type] += +amounts[type];
 };
 
 Player.prototype.GetNeededResources = function(amounts)
 {
 	// Check if we can afford it all
 	var amountsNeeded = {};
 	for (var type in amounts)
 		if (this.resourceCount[type] != undefined && amounts[type] > this.resourceCount[type])
 			amountsNeeded[type] = amounts[type] - Math.floor(this.resourceCount[type]);
 
 	if (Object.keys(amountsNeeded).length == 0)
 		return undefined;
 	return amountsNeeded;
 };
 
 Player.prototype.SubtractResourcesOrNotify = function(amounts)
 {
 	var amountsNeeded = this.GetNeededResources(amounts);
 
 	// If we don't have enough resources, send a notification to the player
 	if (amountsNeeded)
 	{
 		var parameters = {};
 		var i = 0;
 		for (var type in amountsNeeded)
 		{
 			++i;
 			parameters["resourceType"+i] = this.resourceNames[type];
 			parameters["resourceAmount"+i] = amountsNeeded[type];
 		}
 
 		var msg = "";
 		// when marking strings for translations, you need to include the actual string,
 		// not some way to derive the string
 		if (i < 1)
 			warn("Amounts needed but no amounts given?");
 		else if (i == 1)
 			msg = markForTranslation("Insufficient resources - %(resourceAmount1)s %(resourceType1)s");
 		else if (i == 2)
 			msg = markForTranslation("Insufficient resources - %(resourceAmount1)s %(resourceType1)s, %(resourceAmount2)s %(resourceType2)s");
 		else if (i == 3)
 			msg = markForTranslation("Insufficient resources - %(resourceAmount1)s %(resourceType1)s, %(resourceAmount2)s %(resourceType2)s, %(resourceAmount3)s %(resourceType3)s");
 		else if (i == 4)
 			msg = markForTranslation("Insufficient resources - %(resourceAmount1)s %(resourceType1)s, %(resourceAmount2)s %(resourceType2)s, %(resourceAmount3)s %(resourceType3)s, %(resourceAmount4)s %(resourceType4)s");
 		else
 			warn("Localisation: Strings are not localised for more than 4 resources");
 
 		// Send as time-notification
 		let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGUIInterface.PushNotification({
 			"players": [this.playerID],
 			"message": msg,
 			"parameters": parameters,
 			"translateMessage": true,
 			"translateParameters": {
 				"resourceType1": "withinSentence",
 				"resourceType2": "withinSentence",
 				"resourceType3": "withinSentence",
 				"resourceType4": "withinSentence",
 			},
 		});
 		return false;
 	}
 
 	for (var type in amounts)
 		this.resourceCount[type] -= amounts[type];
 
 	return true;
 };
 
 Player.prototype.TrySubtractResources = function(amounts)
 {
 	if (!this.SubtractResourcesOrNotify(amounts))
 		return false;
 
 	var cmpStatisticsTracker = QueryPlayerIDInterface(this.playerID, IID_StatisticsTracker);
 	if (cmpStatisticsTracker)
 		for (var type in amounts)
 			cmpStatisticsTracker.IncreaseResourceUsedCounter(type, amounts[type]);
 
 	return true;
 };
 
 Player.prototype.GetNextTradingGoods = function()
 {
 	var value = randFloat(0, 100);
 	var last = this.tradingGoods.length - 1;
 	var sumProba = 0;
 	for (var i = 0; i < last; ++i)
 	{
 		sumProba += this.tradingGoods[i].proba;
 		if (value < sumProba)
 			return this.tradingGoods[i].goods;
 	}
 	return this.tradingGoods[last].goods;
 };
 
 Player.prototype.GetTradingGoods = function()
 {
 	var tradingGoods = {};
 	for (let resource of this.tradingGoods)
 		tradingGoods[resource.goods] = resource.proba;
 
 	return tradingGoods;
 };
 
 Player.prototype.SetTradingGoods = function(tradingGoods)
 {
-	let resCodes = Resources.GetCodes();
+	let resTradeCodes = Resources.GetTradableCodes();
 	let sumProba = 0;
 	for (let resource in tradingGoods)
 	{
-		if (resCodes.indexOf(resource) == -1 || tradingGoods[resource] < 0)
+		if (resTradeCodes.indexOf(resource) == -1 || tradingGoods[resource] < 0)
 		{
 			error("Invalid trading goods: " + uneval(tradingGoods));
 			return;
 		}
 		sumProba += tradingGoods[resource];
 	}
 
 	if (sumProba != 100)
 	{
-		error("Invalid trading goods: " + uneval(tradingGoods));
+		error("Invalid trading goods probability: " + uneval(sumProba));
 		return;
 	}
 
 	this.tradingGoods = [];
 	for (let resource in tradingGoods)
 		this.tradingGoods.push({
 			"goods": resource,
 			"proba": tradingGoods[resource]
 		});
 };
 
 Player.prototype.GetState = function()
 {
 	return this.state;
 };
 
 /**
  * @param {string} newState - Either "defeated" or "won".
  * @param {string|undefined} message - A string to be shown in chat, for example
  *     markForTranslation("%(player)s has been defeated (failed objective).").
  *     If it is undefined, the caller MUST send that GUI notification manually.
  */
 Player.prototype.SetState = function(newState, message)
 {
 	if (this.state != "active")
 		return;
 
 	if (newState != "won" && newState != "defeated")
 	{
 		warn("Can't change playerstate to " + this.state);
 		return;
 	}
 
 	this.state = newState;
 
 	let won = newState == "won";
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (won)
 		cmpRangeManager.SetLosRevealAll(this.playerID, true);
 	else
 	{
 		// Reassign all player's entities to Gaia
 		let entities = cmpRangeManager.GetEntitiesByPlayer(this.playerID);
 
 		// The ownership change is done in two steps so that entities don't hit idle
 		// (and thus possibly look for "enemies" to attack) before nearby allies get
 		// converted to Gaia as well.
 		for (let entity of entities)
 		{
 			let cmpOwnership = Engine.QueryInterface(entity, IID_Ownership);
 			cmpOwnership.SetOwnerQuiet(0);
 		}
 
 		// With the real ownership change complete, send OwnershipChanged messages.
 		for (let entity of entities)
 			Engine.PostMessage(entity, MT_OwnershipChanged, {
 				"entity": entity,
 				"from": this.playerID,
 				"to": 0
 			});
 	}
 
 	Engine.PostMessage(this.entity, won ? MT_PlayerWon : MT_PlayerDefeated, { "playerId": this.playerID });
 
 	if (message)
 	{
 		let cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 		cmpGUIInterface.PushNotification({
 			"type": won ? "won" : "defeat",
 			"players": [this.playerID],
 			"allies": [this.playerID],
 			"message": message
 		});
 	}
 };
 
 Player.prototype.GetTeam = function()
 {
 	return this.team;
 };
 
 Player.prototype.SetTeam = function(team)
 {
 	if (this.teamsLocked)
 		return;
 
 	this.team = team;
 
 	// Set all team members as allies
 	if (this.team != -1)
 	{
 		let numPlayers = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetNumPlayers();
 		for (let i = 0; i < numPlayers; ++i)
 		{
 			let cmpPlayer = QueryPlayerIDInterface(i);
 			if (this.team != cmpPlayer.GetTeam())
 				continue;
 
 			this.SetAlly(i);
 			cmpPlayer.SetAlly(this.playerID);
 		}
 	}
 
 	Engine.BroadcastMessage(MT_DiplomacyChanged, {
 		"player": this.playerID,
 		"otherPlayer": null
 	});
 };
 
 Player.prototype.SetLockTeams = function(value)
 {
 	this.teamsLocked = value;
 };
 
 Player.prototype.GetLockTeams = function()
 {
 	return this.teamsLocked;
 };
 
 Player.prototype.GetDiplomacy = function()
 {
 	return this.diplomacy.slice();
 };
 
 Player.prototype.SetDiplomacy = function(dipl)
 {
 	this.diplomacy = dipl.slice();
 
 	Engine.BroadcastMessage(MT_DiplomacyChanged, {
 		"player": this.playerID,
 		"otherPlayer": null
 	});
 };
 
 Player.prototype.SetDiplomacyIndex = function(idx, value)
 {
 	let cmpPlayer = QueryPlayerIDInterface(idx);
 	if (!cmpPlayer)
 		return;
 
 	if (this.state != "active" || cmpPlayer.state != "active")
 		return;
 
 	this.diplomacy[idx] = value;
 
 	Engine.BroadcastMessage(MT_DiplomacyChanged, {
 		"player": this.playerID,
 		"otherPlayer": cmpPlayer.GetPlayerID()
 	});
 
 	// Mutual worsening of relations
 	if (cmpPlayer.diplomacy[this.playerID] > value)
 		cmpPlayer.SetDiplomacyIndex(this.playerID, value);
 };
 
 Player.prototype.UpdateSharedLos = function()
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let cmpTechnologyManager = Engine.QueryInterface(this.entity, IID_TechnologyManager);
 	if (!cmpRangeManager || !cmpTechnologyManager)
 		return;
 
 	if (!cmpTechnologyManager.IsTechnologyResearched(this.template.SharedLosTech))
 	{
 		cmpRangeManager.SetSharedLos(this.playerID, [this.playerID]);
 		return;
 	}
 
 	cmpRangeManager.SetSharedLos(this.playerID, this.GetMutualAllies());
 };
 
 Player.prototype.GetFormations = function()
 {
 	return this.formations;
 };
 
 Player.prototype.SetFormations = function(formations)
 {
 	this.formations = formations;
 };
 
 Player.prototype.GetStartingCameraPos = function()
 {
 	return this.startCam.position;
 };
 
 Player.prototype.GetStartingCameraRot = function()
 {
 	return this.startCam.rotation;
 };
 
 Player.prototype.SetStartingCamera = function(pos, rot)
 {
 	this.startCam = { "position": pos, "rotation": rot };
 };
 
 Player.prototype.HasStartingCamera = function()
 {
 	return this.startCam !== undefined;
 };
 
 Player.prototype.HasSharedLos = function()
 {
 	let cmpTechnologyManager = Engine.QueryInterface(this.entity, IID_TechnologyManager);
 	return cmpTechnologyManager && cmpTechnologyManager.IsTechnologyResearched(this.template.SharedLosTech);
 };
 Player.prototype.HasSharedDropsites = function()
 {
 	return this.sharedDropsites;
 };
 
 Player.prototype.SetControlAllUnits = function(c)
 {
 	this.controlAllUnits = c;
 };
 
 Player.prototype.CanControlAllUnits = function()
 {
 	return this.controlAllUnits;
 };
 
 Player.prototype.SetAI = function(flag)
 {
 	this.isAI = flag;
 };
 
 Player.prototype.IsAI = function()
 {
 	return this.isAI;
 };
 
 Player.prototype.GetPlayersByDiplomacy = function(func)
 {
 	var players = [];
 	for (var i = 0; i < this.diplomacy.length; ++i)
 		if (this[func](i))
 			players.push(i);
 	return players;
 };
 
 Player.prototype.SetAlly = function(id)
 {
 	this.SetDiplomacyIndex(id, 1);
 };
 
 /**
  * Check if given player is our ally
  */
 Player.prototype.IsAlly = function(id)
 {
 	return this.diplomacy[id] > 0;
 };
 
 Player.prototype.GetAllies = function()
 {
 	return this.GetPlayersByDiplomacy("IsAlly");
 };
 
 /**
  * Check if given player is our ally excluding ourself
  */
 Player.prototype.IsExclusiveAlly = function(id)
 {
 	return this.playerID != id && this.IsAlly(id);
 };
 
 /**
  * Check if given player is our ally, and we are its ally
  */
 Player.prototype.IsMutualAlly = function(id)
 {
 	var cmpPlayer = QueryPlayerIDInterface(id);
 	return this.IsAlly(id) && cmpPlayer && cmpPlayer.IsAlly(this.playerID);
 };
 
 Player.prototype.GetMutualAllies = function()
 {
 	return this.GetPlayersByDiplomacy("IsMutualAlly");
 };
 
 /**
  * Check if given player is our ally, and we are its ally, excluding ourself
  */
 Player.prototype.IsExclusiveMutualAlly = function(id)
 {
 	return this.playerID != id && this.IsMutualAlly(id);
 };
 
 Player.prototype.SetEnemy = function(id)
 {
 	this.SetDiplomacyIndex(id, -1);
 };
 
 /**
  * Check if given player is our enemy
  */
 Player.prototype.IsEnemy = function(id)
 {
 	return this.diplomacy[id] < 0;
 };
 
 Player.prototype.GetEnemies = function()
 {
 	return this.GetPlayersByDiplomacy("IsEnemy");
 };
 
 Player.prototype.SetNeutral = function(id)
 {
 	this.SetDiplomacyIndex(id, 0);
 };
 
 /**
  * Check if given player is neutral
  */
 Player.prototype.IsNeutral = function(id)
 {
 	return this.diplomacy[id] == 0;
 };
 
 /**
  * Do some map dependant initializations
  */
 Player.prototype.OnGlobalInitGame = function(msg)
 {
 	let cmpTechnologyManager = Engine.QueryInterface(this.entity, IID_TechnologyManager);
 	if (cmpTechnologyManager)
 		for (let tech of this.startingTechnologies)
 			cmpTechnologyManager.ResearchTechnology(tech);
 
 	// Replace the "{civ}" code with this civ ID
 	let disabledTemplates = this.disabledTemplates;
 	this.disabledTemplates = {};
 	for (let template in disabledTemplates)
 		if (disabledTemplates[template])
 			this.disabledTemplates[template.replace(/\{civ\}/g, this.civ)] = true;
 };
 
 /**
  * Keep track of population effects of all entities that
  * become owned or unowned by this player
  */
 Player.prototype.OnGlobalOwnershipChanged = function(msg)
 {
 	if (msg.from != this.playerID && msg.to != this.playerID)
 		return;
 
 	var cmpIdentity = Engine.QueryInterface(msg.entity, IID_Identity);
 	var cmpCost = Engine.QueryInterface(msg.entity, IID_Cost);
 
 	if (msg.from == this.playerID)
 	{
 		if (cmpCost)
 			this.popUsed -= cmpCost.GetPopCost();
 
 		if (cmpIdentity && MatchesClassList(cmpIdentity.GetClassesList(), panelEntityClasses))
 		{
 			let index = this.panelEntities.indexOf(msg.entity);
 			if (index >= 0)
 				this.panelEntities.splice(index, 1);
 		}
 	}
 	if (msg.to == this.playerID)
 	{
 		if (cmpCost)
 			this.popUsed += cmpCost.GetPopCost();
 
 		if (cmpIdentity && MatchesClassList(cmpIdentity.GetClassesList(), panelEntityClasses))
 			this.panelEntities.push(msg.entity);
 	}
 };
 
 Player.prototype.OnResearchFinished = function(msg)
 {
 	if (msg.tech == this.template.SharedLosTech)
 		this.UpdateSharedLos();
 	else if (msg.tech == this.template.SharedDropsitesTech)
 		this.sharedDropsites = true;
 };
 
 Player.prototype.OnDiplomacyChanged = function()
 {
 	this.UpdateSharedLos();
 };
 
 Player.prototype.OnValueModification = function(msg)
 {
 	if (msg.component != "Player")
 		return;
 
 	if (msg.valueNames.indexOf("Player/SpyCostMultiplier") != -1)
 		this.spyCostMultiplier = ApplyValueModificationsToEntity("Player/SpyCostMultiplier", +this.template.SpyCostMultiplier, this.entity);
 
 	if (msg.valueNames.some(mod => mod.startsWith("Player/BarterMultiplier/")))
 		for (let res in this.template.BarterMultiplier.Buy)
 		{
 			this.barterMultiplier.buy[res] = ApplyValueModificationsToEntity("Player/BarterMultiplier/Buy/"+res, +this.template.BarterMultiplier.Buy[res], this.entity);
 			this.barterMultiplier.sell[res] = ApplyValueModificationsToEntity("Player/BarterMultiplier/Sell/"+res, +this.template.BarterMultiplier.Sell[res], this.entity);
 		}
 };
 
 Player.prototype.SetCheatsEnabled = function(flag)
 {
 	this.cheatsEnabled = flag;
 };
 
 Player.prototype.GetCheatsEnabled = function()
 {
 	return this.cheatsEnabled;
 };
 
 Player.prototype.TributeResource = function(player, amounts)
 {
-	var cmpPlayer = QueryPlayerIDInterface(player);
+	let cmpPlayer = QueryPlayerIDInterface(player);
 	if (!cmpPlayer)
 		return;
 
 	if (this.state != "active" || cmpPlayer.state != "active")
 		return;
 
+	let resTribCodes = Resources.GetTributableCodes();
 	for (let resCode in amounts)
-		if (Resources.GetCodes().indexOf(resCode) == -1 ||
+		if (resTribCodes.indexOf(resCode) == -1 ||
 		    !Number.isInteger(amounts[resCode]) ||
 		    amounts[resCode] < 0)
 		{
-			warn("Invalid tribute amounts: " + uneval(amounts));
+			warn("Invalid tribute amounts: " + uneval(resCode) + ": " + uneval(amounts));
 			return;
 		}
 
 	if (!this.SubtractResourcesOrNotify(amounts))
 		return;
 	cmpPlayer.AddResources(amounts);
 
 	var total = Object.keys(amounts).reduce((sum, type) => sum + amounts[type], 0);
 	var cmpOurStatisticsTracker = QueryPlayerIDInterface(this.playerID, IID_StatisticsTracker);
 	if (cmpOurStatisticsTracker)
 		cmpOurStatisticsTracker.IncreaseTributesSentCounter(total);
 	var cmpTheirStatisticsTracker = QueryPlayerIDInterface(player, IID_StatisticsTracker);
 	if (cmpTheirStatisticsTracker)
 		cmpTheirStatisticsTracker.IncreaseTributesReceivedCounter(total);
 
 	var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	if (cmpGUIInterface)
 		cmpGUIInterface.PushNotification({
 			"type": "tribute",
 			"players": [player],
 			"donator": this.playerID,
 			"amounts": amounts
 		});
 
 	Engine.BroadcastMessage(MT_TributeExchanged, {
 		"to": player,
 		"from": this.playerID,
 		"amounts": amounts
 	});
 };
 
 Player.prototype.AddDisabledTemplate = function(template)
 {
 	this.disabledTemplates[template] = true;
 	Engine.BroadcastMessage(MT_DisabledTemplatesChanged, {});
 	var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	cmpGuiInterface.PushNotification({
 		"type": "resetselectionpannel",
 		"players": [this.GetPlayerID()]
 	});
 };
 
 Player.prototype.RemoveDisabledTemplate = function(template)
 {
 	this.disabledTemplates[template] = false;
 	Engine.BroadcastMessage(MT_DisabledTemplatesChanged, {});
 
 	var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	cmpGuiInterface.PushNotification({
 		"type": "resetselectionpannel",
 		"players": [this.GetPlayerID()]
 	});
 };
 
 Player.prototype.SetDisabledTemplates = function(templates)
 {
 	this.disabledTemplates = {};
 	for (let template of templates)
 		this.disabledTemplates[template] = true;
 	Engine.BroadcastMessage(MT_DisabledTemplatesChanged, {});
 
 	var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
 	cmpGuiInterface.PushNotification({
 		"type": "resetselectionpannel",
 		"players": [this.GetPlayerID()]
 	});
 };
 
 Player.prototype.GetDisabledTemplates = function()
 {
 	return this.disabledTemplates;
 };
 
 Player.prototype.AddDisabledTechnology = function(tech)
 {
 	this.disabledTechnologies[tech] = true;
 	Engine.BroadcastMessage(MT_DisabledTechnologiesChanged, {});
 };
 
 Player.prototype.RemoveDisabledTechnology = function(tech)
 {
 	this.disabledTechnologies[tech] = false;
 	Engine.BroadcastMessage(MT_DisabledTechnologiesChanged, {});
 };
 
 Player.prototype.SetDisabledTechnologies = function(techs)
 {
 	this.disabledTechnologies = {};
 	for (let tech of techs)
 		this.disabledTechnologies[tech] = true;
 	Engine.BroadcastMessage(MT_DisabledTechnologiesChanged, {});
 };
 
 Player.prototype.GetDisabledTechnologies = function()
 {
 	return this.disabledTechnologies;
 };
 
 Player.prototype.AddStartingTechnology = function(tech)
 {
 	if (this.startingTechnologies.indexOf(tech) == -1)
 		this.startingTechnologies.push(tech);
 };
 
 Player.prototype.SetStartingTechnologies = function(techs)
 {
 	this.startingTechnologies = techs;
 };
 
 Engine.RegisterComponentType(IID_Player, "Player", Player);
Index: ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Barter.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Barter.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Barter.js	(revision 22970)
@@ -1,193 +1,193 @@
 Engine.LoadHelperScript("Player.js");
 Engine.LoadComponentScript("interfaces/Barter.js");
 Engine.LoadComponentScript("interfaces/Foundation.js");
 Engine.LoadComponentScript("interfaces/Player.js");
 Engine.LoadComponentScript("interfaces/StatisticsTracker.js");
 Engine.LoadComponentScript("interfaces/Timer.js");
 Engine.LoadComponentScript("Barter.js");
 
 // truePrice. Use the same for each resource for those tests.
 const truePrice = 110;
 
 Resources = {
-	"GetCodes": () => ["wood", "stone", "metal"],
+	"GetBarterableCodes": () => ["wood", "stone", "metal"],
 	"GetResource": (resource) => ({ "truePrice": truePrice })
 };
 
 const playerID = 1;
 const playerEnt = 11;
 
 AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
 	"GetPlayerByID": id => playerEnt
 });
 
 let timerActivated = false;
 let bought = 0;
 let sold = 0;
 let multiplier = {
 	"buy": {
 		"wood": 1.0,
 		"stone": 1.0,
 		"metal": 1.0
 	},
 	"sell": {
 		"wood": 1.0,
 		"stone": 1.0,
 		"metal": 1.0
 	}
 };
 let cmpBarter = ConstructComponent(SYSTEM_ENTITY, "Barter");
 
 AddMock(SYSTEM_ENTITY, IID_Timer, {
 	"CancelTimer": id => { timerActivated = false; },
 	"SetInterval": (ent, iid, funcname, time, repeattime, data) => {
 		TS_ASSERT_EQUALS(time, cmpBarter.RESTORE_TIMER_INTERVAL);
 		TS_ASSERT_EQUALS(repeattime, cmpBarter.RESTORE_TIMER_INTERVAL);
 		timerActivated = true;
 		return 7;
 	}
 });
 
 // Init
 TS_ASSERT_EQUALS(cmpBarter.restoreTimer, undefined);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": 0, "stone": 0, "metal": 0 });
 
 AddMock(playerEnt, IID_Player, {
 	"TrySubtractResources": amounts => {
 		sold = amounts[Object.keys(amounts)[0]];
 		return true;
 	},
 	"AddResource": (type, amount) => {
 		bought = amount;
 		return true;
 	},
 	"GetBarterMultiplier": () => multiplier
 });
 
 AddMock(SYSTEM_ENTITY, IID_RangeManager, {
 	"GetEntitiesByPlayer": (id) => id == playerID ? [62, 60, 61, 63] : []
 });
 
 AddMock(60, IID_Identity, {
 	"HasClass": (cl) => true
 });
 
 AddMock(60, IID_Foundation, {});
 
 // GetPrices
 cmpBarter.priceDifferences = { "wood": 8, "stone": 0, "metal": 0 };
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.GetPrices(playerID).buy, {
 	"wood": truePrice * (100 + 8 + cmpBarter.CONSTANT_DIFFERENCE) / 100,
 	"stone": truePrice * (100 + cmpBarter.CONSTANT_DIFFERENCE) / 100,
 	"metal": truePrice * (100 + cmpBarter.CONSTANT_DIFFERENCE) / 100
 });
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.GetPrices(playerID).sell, {
 	"wood": truePrice * (100 + 8 - cmpBarter.CONSTANT_DIFFERENCE) / 100,
 	"stone": truePrice * (100 - cmpBarter.CONSTANT_DIFFERENCE) / 100,
 	"metal": truePrice * (100 - cmpBarter.CONSTANT_DIFFERENCE) / 100
 });
 
 multiplier.buy.stone = 2.0;
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.GetPrices(playerID).buy, {
 	"wood": truePrice * (100 + 8 + cmpBarter.CONSTANT_DIFFERENCE) / 100,
 	"stone": truePrice * (100 + cmpBarter.CONSTANT_DIFFERENCE) * 2.0 / 100,
 	"metal": truePrice * (100 + cmpBarter.CONSTANT_DIFFERENCE) / 100
 });
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.GetPrices(playerID).sell, {
 	"wood": truePrice * (100 + 8 - cmpBarter.CONSTANT_DIFFERENCE) / 100,
 	"stone": truePrice * (100 - cmpBarter.CONSTANT_DIFFERENCE) / 100,
 	"metal": truePrice * (100 - cmpBarter.CONSTANT_DIFFERENCE) / 100
 });
 multiplier.buy.stone = 1.0;
 
 // PlayerHasMarket
 TS_ASSERT(!cmpBarter.PlayerHasMarket(playerID));
 
 AddMock(61, IID_Identity, {
 	"HasClass": (cl) => true
 });
 
 TS_ASSERT(cmpBarter.PlayerHasMarket(playerID));
 
 // ExchangeResources
 // Price differences magnitude are caped by 99 - CONSTANT_DIFFERENCE.
 // If we have a bigger DIFFERENCE_PER_DEAL than 99 - CONSTANT_DIFFERENCE at each deal we reach the cap.
 TS_ASSERT(cmpBarter.DIFFERENCE_PER_DEAL < 99 - cmpBarter.CONSTANT_DIFFERENCE);
 
 cmpBarter.priceDifferences = { "wood": 0, "stone": 0, "metal": 0 };
 cmpBarter.ExchangeResources(playerID, "wood", "stone", 100);
 TS_ASSERT_EQUALS(cmpBarter.restoreTimer, 7);
 TS_ASSERT(timerActivated);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": -cmpBarter.DIFFERENCE_PER_DEAL, "stone": cmpBarter.DIFFERENCE_PER_DEAL, "metal": 0 });
 TS_ASSERT_EQUALS(sold, 100);
 TS_ASSERT_EQUALS(bought, Math.round(100 * (100 - cmpBarter.CONSTANT_DIFFERENCE + 0) / (100 + cmpBarter.CONSTANT_DIFFERENCE + 0)));
 
 // Amount which is not 100 or 500 is invalid.
 cmpBarter.priceDifferences = { "wood": 0, "stone": 0, "metal": 0 };
 cmpBarter.ExchangeResources(playerID, "wood", "stone", 40);
 bought = 0;
 sold = 0;
 timerActivated = false;
 TS_ASSERT(!timerActivated);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": 0, "stone": 0, "metal": 0 });
 TS_ASSERT_EQUALS(sold, 0);
 TS_ASSERT_EQUALS(bought, 0);
 
 // Amount which is NaN is invalid.
 cmpBarter.priceDifferences = { "wood": 0, "stone": 0, "metal": 0 };
 cmpBarter.ExchangeResources(playerID, "wood", "stone", NaN);
 TS_ASSERT(!timerActivated);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": 0, "stone": 0, "metal": 0 });
 TS_ASSERT_EQUALS(sold, 0);
 TS_ASSERT_EQUALS(bought, 0);
 
 cmpBarter.priceDifferences = { "wood": 0, "stone": 99 - cmpBarter.CONSTANT_DIFFERENCE, "metal": 0 };
 cmpBarter.ExchangeResources(playerID, "wood", "stone", 100);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": -cmpBarter.DIFFERENCE_PER_DEAL, "stone": 99 - cmpBarter.CONSTANT_DIFFERENCE, "metal": 0 });
 TS_ASSERT_EQUALS(bought, Math.round(100 * (100 - cmpBarter.CONSTANT_DIFFERENCE + 0) / (100 + cmpBarter.CONSTANT_DIFFERENCE + 99 - cmpBarter.CONSTANT_DIFFERENCE)));
 
 cmpBarter.priceDifferences = { "wood": -99 + cmpBarter.CONSTANT_DIFFERENCE, "stone": 0, "metal": 0 };
 cmpBarter.ExchangeResources(playerID, "wood", "stone", 100);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": -99 + cmpBarter.CONSTANT_DIFFERENCE, "stone": cmpBarter.DIFFERENCE_PER_DEAL, "metal": 0 });
 TS_ASSERT_EQUALS(bought, Math.round(100 * (100 - cmpBarter.CONSTANT_DIFFERENCE - 99 + cmpBarter.CONSTANT_DIFFERENCE) / (100 + cmpBarter.CONSTANT_DIFFERENCE + 0)));
 
 cmpBarter.priceDifferences = { "wood": 0, "stone": 0, "metal": 0 };
 cmpBarter.restoreTimer = undefined;
 timerActivated = false;
 AddMock(playerEnt, IID_Player, {
 	"TrySubtractResources": () => false,
 	"AddResource": () => {},
 	"GetBarterMultiplier": () => multiplier
 });
 cmpBarter.ExchangeResources(playerID, "wood", "stone", 100);
 
 // It seems useless to try to activate the timer if we don't barter any resources.
 TS_ASSERT_EQUALS(cmpBarter.restoreTimer, 7);
 TS_ASSERT(timerActivated);
 
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": 0, "stone": 0, "metal": 0 });
 
 DeleteMock(playerEnt, IID_Player);
 
 // ProgressTimeout
 // Price difference restoration magnitude is capped by DIFFERENCE_RESTORE.
 
 AddMock(playerEnt, IID_Player, {
 	"TrySubtractResources": () => true,
 	"AddResource": () => {}
 });
 
 timerActivated = true;
 cmpBarter.restoreTimer = 7;
 cmpBarter.priceDifferences = { "wood": -cmpBarter.DIFFERENCE_RESTORE, "stone": -1 - cmpBarter.DIFFERENCE_RESTORE, "metal": cmpBarter.DIFFERENCE_RESTORE };
 cmpBarter.ProgressTimeout();
 TS_ASSERT_EQUALS(cmpBarter.restoreTimer, 7);
 TS_ASSERT(timerActivated);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": 0, "stone": -1, "metal": 0 });
 
 cmpBarter.restoreTimer = 7;
 cmpBarter.priceDifferences = { "wood": -cmpBarter.DIFFERENCE_RESTORE, "stone": cmpBarter.DIFFERENCE_RESTORE / 2, "metal": cmpBarter.DIFFERENCE_RESTORE };
 cmpBarter.ProgressTimeout();
 TS_ASSERT_EQUALS(cmpBarter.restoreTimer, undefined);
 TS_ASSERT(!timerActivated);
 TS_ASSERT_UNEVAL_EQUALS(cmpBarter.priceDifferences, { "wood": 0, "stone": 0, "metal": 0 });
Index: ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Player.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Player.js	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Player.js	(revision 22970)
@@ -1,66 +1,68 @@
 Resources = {
 	"GetCodes": () => ["food", "metal", "stone", "wood"],
+	"GetTradableCodes": () => ["food", "metal", "stone", "wood"],
+	"GetBarterableCodes": () => ["food", "metal", "stone", "wood"],
 	"GetResource": () => ({}),
 	"BuildSchema": (type) => {
 		let schema = "";
 		for (let res of Resources.GetCodes())
 			schema +=
 				"<optional>" +
 					"<element name='" + res + "'>" +
 						"<ref name='" + type + "'/>" +
 					"</element>" +
 				"</optional>";
 		return "<interleave>" + schema + "</interleave>";
 	}
 };
 
 Engine.LoadHelperScript("ValueModification.js");
 Engine.LoadComponentScript("interfaces/Player.js");
 Engine.LoadComponentScript("interfaces/ModifiersManager.js");
 Engine.LoadComponentScript("Player.js");
 
 var cmpPlayer = ConstructComponent(10, "Player", {
 	"SpyCostMultiplier": 1,
 	"BarterMultiplier": {
 		"Buy": {
 			"wood": 1.0,
 			"stone": 1.0,
 			"metal": 1.0
 		},
 		"Sell": {
 			"wood": 1.0,
 			"stone": 1.0,
 			"metal": 1.0
 		}
 	},
 });
 
 TS_ASSERT_EQUALS(cmpPlayer.GetPopulationCount(), 0);
 TS_ASSERT_EQUALS(cmpPlayer.GetPopulationLimit(), 0);
 
 cmpPlayer.SetDiplomacy([-1, 1, 0, 1, -1]);
 TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetAllies(), [1, 3]);
 TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetEnemies(), [0, 4]);
 
 var diplo = cmpPlayer.GetDiplomacy();
 diplo[0] = 1;
 TS_ASSERT(cmpPlayer.IsEnemy(0));
 
 diplo = [1, 1, 0];
 cmpPlayer.SetDiplomacy(diplo);
 diplo[1] = -1;
 TS_ASSERT(cmpPlayer.IsAlly(1));
 
 TS_ASSERT_EQUALS(cmpPlayer.GetSpyCostMultiplier(), 1);
 TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetBarterMultiplier(), {
 	"buy": {
 		"wood": 1.0,
 		"stone": 1.0,
 		"metal": 1.0
 	},
 	"sell": {
 		"wood": 1.0,
 		"stone": 1.0,
 		"metal": 1.0
 	}
 });
Index: ps/trunk/binaries/data/mods/public/simulation/data/resources/food.json
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/data/resources/food.json	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/data/resources/food.json	(revision 22970)
@@ -1,14 +1,15 @@
 {
 	"code": "food",
 	"name": "Food",
 	"description": "Harvest from animals, berry bushes, fish, or fields.",
 	"order": 1,
 	"subtypes": {
 		"fish": "Fish",
 		"fruit": "Fruit",
 		"grain": "Grain",
 		"meat": "Meat"
 	},
+	"properties": ["barterable", "tradable", "tributable"],
 	"truePrice": 100,
 	"aiAnalysisInfluenceGroup": "ignore"
 }
Index: ps/trunk/binaries/data/mods/public/simulation/data/resources/metal.json
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/data/resources/metal.json	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/data/resources/metal.json	(revision 22970)
@@ -1,11 +1,12 @@
 {
 	"code": "metal",
 	"name": "Metal",
 	"description": "Mine from metal mines or quarries.",
 	"order": 4,
 	"subtypes": {
 		"ore": "Ore"
 	},
+	"properties": ["barterable", "tradable", "tributable"],
 	"truePrice": 100,
 	"aiAnalysisInfluenceGroup": "sparse"
 }
Index: ps/trunk/binaries/data/mods/public/simulation/data/resources/stone.json
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/data/resources/stone.json	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/data/resources/stone.json	(revision 22970)
@@ -1,12 +1,13 @@
 {
 	"code": "stone",
 	"name": "Stone",
 	"description": "Mine from rocks, stone quarries or ruins.",
 	"order": 3,
 	"subtypes": {
 		"rock": "Rock",
 		"ruins": "Ruins"
 	},
+	"properties": ["barterable", "tradable", "tributable"],
 	"truePrice": 100,
 	"aiAnalysisInfluenceGroup": "sparse"
 }
Index: ps/trunk/binaries/data/mods/public/simulation/data/resources/wood.json
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/data/resources/wood.json	(revision 22969)
+++ ps/trunk/binaries/data/mods/public/simulation/data/resources/wood.json	(revision 22970)
@@ -1,12 +1,13 @@
 {
 	"code": "wood",
 	"name": "Wood",
 	"description": "Cut down from trees or groves.",
 	"order": 2,
 	"subtypes": {
 		"tree": "Tree",
 		"ruins": "Ruins"
 	},
+	"properties": ["barterable", "tradable", "tributable"],
 	"truePrice": 100,
 	"aiAnalysisInfluenceGroup": "abundant"
 }
Index: ps/trunk/source/simulation2/components/tests/test_scripts.h
===================================================================
--- ps/trunk/source/simulation2/components/tests/test_scripts.h	(revision 22969)
+++ ps/trunk/source/simulation2/components/tests/test_scripts.h	(revision 22970)
@@ -1,87 +1,100 @@
-/* Copyright (C) 2017 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "simulation2/system/ComponentTest.h"
 
 #include "ps/Filesystem.h"
 
 class TestComponentScripts : public CxxTest::TestSuite
 {
 public:
 	void setUp()
 	{
 		g_VFS = CreateVfs();
 		g_VFS->Mount(L"", DataDir()/"mods"/"mod", VFS_MOUNT_MUST_EXIST);
 		g_VFS->Mount(L"", DataDir()/"mods"/"public", VFS_MOUNT_MUST_EXIST, 1); // ignore directory-not-found errors
 		CXeromyces::Startup();
 	}
 
 	void tearDown()
 	{
 		CXeromyces::Terminate();
 		g_VFS.reset();
 	}
 
 	static void load_script(const ScriptInterface& scriptInterface, const VfsPath& pathname)
 	{
 		CVFSFile file;
 		TS_ASSERT_EQUALS(file.Load(g_VFS, pathname), PSRETURN_OK);
 		CStr content = file.DecodeUTF8(); // assume it's UTF-8
 		TSM_ASSERT(L"Running script "+pathname.string(), scriptInterface.LoadScript(pathname, content));
 	}
 
 	static void Script_LoadComponentScript(ScriptInterface::CxPrivate* pCxPrivate, const VfsPath& pathname)
 	{
 		CComponentManager* componentManager = static_cast<CComponentManager*> (pCxPrivate->pCBData);
 		TS_ASSERT(componentManager->LoadScript(VfsPath(L"simulation/components") / pathname));
 	}
 
 	static void Script_LoadHelperScript(ScriptInterface::CxPrivate* pCxPrivate, const VfsPath& pathname)
 	{
 		CComponentManager* componentManager = static_cast<CComponentManager*> (pCxPrivate->pCBData);
 		TS_ASSERT(componentManager->LoadScript(VfsPath(L"simulation/helpers") / pathname));
 	}
 
+	void test_global_scripts()
+	{
+		VfsPaths paths;
+		TS_ASSERT_OK(vfs::GetPathnames(g_VFS, L"globalscripts/tests/", L"test_*.js", paths));
+		for (const VfsPath& path : paths)
+		{
+			CSimContext context;
+			CComponentManager componentManager(context, g_ScriptRuntime, true);
+			ScriptTestSetup(componentManager.GetScriptInterface());
+			load_script(componentManager.GetScriptInterface(), path);
+		}
+	}
+
 	void test_scripts()
 	{
 		if (!VfsFileExists(L"simulation/components/tests/setup.js"))
 		{
 			debug_printf("WARNING: Skipping component scripts tests (can't find binaries/data/mods/public/simulation/components/tests/setup.js)\n");
 			return;
 		}
 
 		VfsPaths paths;
 		TS_ASSERT_OK(vfs::GetPathnames(g_VFS, L"simulation/components/tests/", L"test_*.js", paths));
 		TS_ASSERT_OK(vfs::GetPathnames(g_VFS, L"simulation/helpers/tests/", L"test_*.js", paths));
 		paths.push_back(VfsPath(L"simulation/components/tests/setup_test.js"));
 		for (const VfsPath& path : paths)
 		{
 			CSimContext context;
 			CComponentManager componentManager(context, g_ScriptRuntime, true);
 
 			ScriptTestSetup(componentManager.GetScriptInterface());
 
 			componentManager.GetScriptInterface().RegisterFunction<void, VfsPath, Script_LoadComponentScript> ("LoadComponentScript");
 			componentManager.GetScriptInterface().RegisterFunction<void, VfsPath, Script_LoadHelperScript> ("LoadHelperScript");
 
 			componentManager.LoadComponentTypes();
 
 			load_script(componentManager.GetScriptInterface(), L"simulation/components/tests/setup.js");
 			load_script(componentManager.GetScriptInterface(), path);
 		}
 	}
 };