Index: ps/trunk/binaries/data/mods/public/gui/session/menu.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/menu.js	(revision 21541)
+++ ps/trunk/binaries/data/mods/public/gui/session/menu.js	(revision 21542)
@@ -1,1281 +1,1277 @@
 // 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 = {
 	"code": "",
 	"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 initSessionMenuButtons()
 {
 	initMenuPosition();
 	updateGameSpeedControl();
 	resizeDiplomacyDialog();
 	resizeTradeDialog();
 }
 
 function initMenuPosition()
 {
 	Engine.GetGUIObjectByName("menu").size = "100%-164 " + MENU_TOP + " 100% " + MENU_BOTTOM;
 }
 
 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 diplomacyMenuButton()
 {
 	closeOpenDialogs();
 	openDiplomacy();
 }
 
 function pauseMenuButton()
 {
 	togglePause();
 }
 
 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_savegame.xml", {
 		"savedGameData": getSavedGameData(),
 		"callback": "resumeGame"
 	});
 }
 
 function openOptions()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	Engine.PushGuiPage("page_options.xml", {
 		"callback": "optionsPageClosed"
 	});
 }
 
 function optionsPageClosed(data)
 {
 	for (let callback of data)
 		if (global[callback])
 			global[callback]();
 
 	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 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()
 {
 	saveSettingAndWriteToUserConfig("chat.session.extended", String(Engine.GetGUIObjectByName("extendedChat").checked));
 
 	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 r = 0;
 	for (let resCode of resCodes)
 	{
 		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)
 				{
 					inputState = INPUT_MASSTRIBUTING;
 					multiplier += multiplier == 1 ? 4 : 5;
 				}
 
 				let amounts = {};
 				for (let res of resCodes)
 					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)
 					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 tradeSize = Engine.GetGUIObjectByName("tradeResource[0]").size;
 	width += g_ResourceData.GetCodes().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 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);
 	Engine.GetGUIObjectByName("tradeHelp").hidden = false;
 
 	for (let i = 0; i < resCodes.length; ++i)
 	{
 		let resCode = resCodes[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");
 		setPanelObjectPosition(barterResource, i, i + 1);
 
 		// 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";
 
 		let buttonUp = Engine.GetGUIObjectByName("tradeArrowUp[" + i + "]");
 		let buttonDn = Engine.GetGUIObjectByName("tradeArrowDn[" + i + "]");
 
 		button[resCode] = {
 			"up": buttonUp,
 			"dn": buttonDn,
 			"label": Engine.GetGUIObjectByName("tradeResourceText[" + i + "]"),
 			"sel": Engine.GetGUIObjectByName("tradeResourceSelection[" + i + "]")
 		};
 
 		proba[resCode] = proba[resCode] || 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)
 						proba[res] = 0;
 					proba[resource] = 100;
 					Engine.PostNetworkCommand({ "type": "set-trading-goods", "tradingGoods": proba });
 				}
 				currTradeSelection = resource;
 				updateTradeButtons();
 			};
 		})(resCode);
 
 		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);
 
 		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);
 	}
 
 	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);
 }
 
 /**
  * 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)
-		return;
-
-	let resCodes = g_ResourceData.GetCodes();
-	for (let i = 0; i < resCodes.length; ++i)
-		barterUpdateCommon(resCodes[i], i, "barter", g_ViewedPlayer);
+	if (canBarter)
+		g_ResourceData.GetCodes().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()
 {
 	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,
 		"callback": "resumeGameAndSaveSummarySelectedData"
 	});
 }
 
 function openStrucTree()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	// TODO add info about researched techs and unlocked entities
 
 	Engine.PushGuiPage(g_CivInfo.page, {
 		"civ": g_CivInfo.code || g_Players[g_ViewedPlayer].civ,
 		"callback": "storeCivInfoPage"
 	});
 }
 
 function storeCivInfoPage(data)
 {
 	g_CivInfo.code = data.civ;
 	g_CivInfo.page = data.page;
 	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", {
 		"page": "manual/intro",
 		"title": translate("Manual"),
 		"url": "http://trac.wildfiregames.com/wiki/0adManual",
 		"callback": "resumeGame"
 	});
 }
 
 function toggleDeveloperOverlay()
 {
 	if (!g_GameAttributes.settings.CheatsEnabled && !g_IsReplay)
 		return;
 
 	let devCommands = Engine.GetGUIObjectByName("devCommands");
 	devCommands.hidden = !devCommands.hidden;
 
 	let message = devCommands.hidden ?
 		markForTranslation("The Developer Overlay was closed.") :
 		markForTranslation("The Developer Overlay was opened.");
 
 	// Only players can send the simulation chat command
 	if (Engine.GetPlayerID() == -1)
 		submitChatDirectly(message);
 	else
 		Engine.PostNetworkCommand({
 			"type": "aichat",
 			"message": message,
 			"translateMessage": true,
 			"translateParameters": [],
 			"parameters": {}
 		});
 }
 
 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 21541)
+++ ps/trunk/binaries/data/mods/public/gui/session/selection_panels.js	(revision 21542)
@@ -1,1196 +1,1180 @@
 /**
  * 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)
 			return [];
 		return g_ResourceData.GetCodes();
 	},
 	"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;
-		// count on square buttons, so size.bottom is the width too
-		let spacer = size.bottom + 1;
 		// relative to the center ( = 50%)
 		size.rleft = 50;
 		size.rright = 50;
-		// offset from the center calculation
-		size.left = (data.i - data.numberOfItems / 2) * spacer;
+		// 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;
-		// count on square buttons, so size.bottom is the width too
-		let spacer = size.bottom + 1;
 		// relative to the center ( = 50%)
 		size.rleft = 50;
 		size.rright = 50;
-		// offset from the center calculation
-		size.left = (data.i - data.numberOfItems / 2) * spacer;
+		// 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;
 
-		let index = data.i + getNumberOfRightPanelButtons();
-		setPanelObjectPosition(data.button, index, data.rowLength);
+		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": data.unitEntStates.map(state => state.id),
+			"ents": unitIds,
 			"formationTemplate": data.item
 		});
 
 		data.button.onPress = function() {
-			performFormation(data.unitEntStates.map(state => state.id), data.item);
+			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 garrisonedUnitOwner = entState.player;
-
 		let canUngarrison =
 			g_ViewedPlayer == data.player ||
-			g_ViewedPlayer == garrisonedUnitOwner;
+			g_ViewedPlayer == entState.player;
 
 		data.button.enabled = canUngarrison && controlsPlayer(g_ViewedPlayer);
 
-		let tooltip = canUngarrison || g_IsObserver ?
+		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);
-
-		tooltip += "\n" + sprintf(translate("Player: %(playername)s"), {
-			"playername": g_Players[garrisonedUnitOwner].name
-		});
-
-		data.button.tooltip = tooltip;
+			getEntityNames(template)) + "\n" +
+			sprintf(translate("Player: %(playername)s"), {
+				"playername": g_Players[entState.player].name
+			});
 
-		data.guiSelection.sprite = getPlayerHighlightColor(garrisonedUnitOwner);
+		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;
 
-		let index = data.i + getNumberOfRightPanelButtons();
-		setPanelObjectPosition(data.button, index, data.rowLength);
+		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);
 
-		let index = data.i + getNumberOfRightPanelButtons();
-		setPanelObjectPosition(data.button, index, data.rowLength);
+		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;
 		}
-		let techs = data.item.tech.pair ? [data.item.tech.bottom, data.item.tech.top] : [data.item.tech];
 
 		// 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;
-		for (let i in techs)
+		let playerState = GetSimState().players[player];
+		for (let tech of data.item.tech.pair ? [data.item.tech.bottom, data.item.tech.top] : [data.item.tech])
 		{
-			let tech = techs[i];
-			let playerState = GetSimState().players[player];
-
 			// 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 = function() {
 				addResearchToQueue(data.item.researchFacilityId, tech);
 			};
 
 			button.onPressRight = function () {
-				let researcherTemplate;
-				for (let selectedEntity of data.unitEntStates)
-					if (selectedEntity.id == data.item.researchFacilityId)
-						researcherTemplate = selectedEntity.template;
-				showTemplateDetails(tech, GetTemplateData(researcherTemplate).nativeCiv);
+				showTemplateDetails(
+					tech,
+					GetTemplateData(data.unitEntStates.find(state => state.id == data.item.researchFacilityId).template).nativeCiv);
 			};
 
 			if (data.item.tech.pair)
 			{
 				// On mouse enter, show a cross over the other icon
-				let otherPosition = (position + data.rowLength) % (2 * data.rowLength);
-				let unchosenIcon = Engine.GetGUIObjectByName("unitResearchUnchosenIcon[" + otherPosition + "]");
+				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)
 	{
-		data.button.onPress = function() { performStance(data.unitEntStates.map(state => state.id), data.item); };
+		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": data.unitEntStates.map(state => state.id),
+			"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(data.unitEntStates.map(status => status.id), data.item, data.playerState);
+			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(data.unitEntStates.map(state => state.id), data.item, data.playerState);
+				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, data.unitEntStates[0].id, buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch)
+			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 into a %(name)s. %(tooltip)s"), {
 					"name": template.name.generic,
 					"tooltip": translate(data.item.tooltip)
 				}));
 			else
 				tooltips.push(sprintf(translate("Upgrade into a %(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;
 
-		let index = data.i + getNumberOfRightPanelButtons();
-		setPanelObjectPosition(data.button, index, data.rowLength);
+		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,
 		"callback": "resumeGame",
 		"civ": civCode
 	});
 }
 
 /**
  * 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/unit_commands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/unit_commands.js	(revision 21541)
+++ ps/trunk/binaries/data/mods/public/gui/session/unit_commands.js	(revision 21542)
@@ -1,230 +1,230 @@
 // The number of currently visible buttons (used to optimise showing/hiding)
 var g_unitPanelButtons = {
 	"Selection": 0,
 	"Queue": 0,
 	"Formation": 0,
 	"Garrison": 0,
 	"Training": 0,
 	"Research": 0,
 	"Alert": 0,
 	"Barter": 0,
 	"Construction": 0,
 	"Command": 0,
 	"AllyCommand": 0,
 	"Stance": 0,
 	"Gate": 0,
 	"Pack": 0,
 	"Upgrade": 0
 };
 
 /**
  * Set the position of a panel object according to the index,
  * from left to right, from top to bottom.
  * Will wrap around to subsequent rows if the index
  * is larger than rowLength.
  */
 function setPanelObjectPosition(object, index, rowLength, vMargin = 1, hMargin = 1)
 {
 	var size = object.size;
 	// horizontal position
 	var oWidth = size.right - size.left;
 	var hIndex = index % rowLength;
 	size.left = hIndex * (oWidth + vMargin);
 	size.right = size.left + oWidth;
 	// vertical position
 	var oHeight = size.bottom - size.top;
 	var vIndex = Math.floor(index / rowLength);
 	size.top = vIndex * (oHeight + hMargin);
 	size.bottom = size.top + oHeight;
 	object.size = size;
 }
 
 /**
  * Helper function for updateUnitCommands; sets up "unit panels"
  * (i.e. panels with rows of icons) for the currently selected unit.
  *
  * @param guiName Short identifier string of this panel. See g_SelectionPanels.
  * @param unitEntStates Entity states of the selected units
  * @param playerState Player state
  */
 function setupUnitPanel(guiName, unitEntStates, playerState)
 {
 	if (!g_SelectionPanels[guiName])
 	{
 		error("unknown guiName used '" + guiName + "'");
 		return;
 	}
 
-	let selection = g_Selection.toList();
 	let items = g_SelectionPanels[guiName].getItems(unitEntStates);
 
 	if (!items || !items.length)
 		return;
 
 	let numberOfItems = Math.min(items.length, g_SelectionPanels[guiName].getMaxNumberOfItems());
 	let rowLength = g_SelectionPanels[guiName].rowLength || 8;
 
 	if (g_SelectionPanels[guiName].resizePanel)
 		g_SelectionPanels[guiName].resizePanel(numberOfItems, rowLength);
 
 	for (let i = 0; i < numberOfItems; ++i)
 	{
 		let data = {
 			"i": i,
 			"item": items[i],
 			"playerState": playerState,
 			"player": unitEntStates[0].player,
 			"unitEntStates": unitEntStates,
 			"rowLength": rowLength,
 			"numberOfItems": numberOfItems,
 			// depending on the XML, some of the GUI objects may be undefined
 			"button": Engine.GetGUIObjectByName("unit" + guiName + "Button[" + i + "]"),
 			"icon": Engine.GetGUIObjectByName("unit" + guiName + "Icon[" + i + "]"),
 			"guiSelection": Engine.GetGUIObjectByName("unit" + guiName + "Selection[" + i + "]"),
 			"countDisplay": Engine.GetGUIObjectByName("unit" + guiName + "Count[" + i + "]")
 		};
 
 		if (data.button)
 		{
 			data.button.hidden = false;
 			data.button.enabled = true;
 			data.button.tooltip = "";
 			data.button.caption = "";
 		}
 
 		if (g_SelectionPanels[guiName].setupButton &&
 		    !g_SelectionPanels[guiName].setupButton(data))
 			continue;
 
 		// TODO: we should require all entities to have icons, so this case never occurs
 		if (data.icon && !data.icon.sprite)
 			data.icon.sprite = "BackgroundBlack";
 	}
 
 	// Hide any buttons we're no longer using
 	for (let i = numberOfItems; i < g_unitPanelButtons[guiName]; ++i)
 		if (g_SelectionPanels[guiName].hideItem)
 			g_SelectionPanels[guiName].hideItem(i, rowLength);
 		else
 			Engine.GetGUIObjectByName("unit" + guiName + "Button[" + i + "]").hidden = true;
 
 	g_unitPanelButtons[guiName] = numberOfItems;
 	g_SelectionPanels[guiName].used = true;
 }
 
 /**
  * Updates the selection panels where buttons are supposed to
  * depend on the context.
  * Runs in the main session loop via updateSelectionDetails().
  * Delegates to setupUnitPanel to set up individual subpanels,
  * appropriately activated depending on the selected unit's state.
  *
  * @param entStates Entity states of the selected units
  * @param supplementalDetailsPanel Reference to the
  *        "supplementalSelectionDetails" GUI Object
  * @param commandsPanel Reference to the "commandsPanel" GUI Object
  */
 function updateUnitCommands(entStates, supplementalDetailsPanel, commandsPanel)
 {
 	for (let panel in g_SelectionPanels)
 		g_SelectionPanels[panel].used = false;
 
 	// If the selection is friendly units, add the command panels
 
 	// Get player state to check some constraints
 	// e.g. presence of a hero or build limits
 	let playerStates = GetSimState().players;
 	let playerState = playerStates[Engine.GetPlayerID()];
 
 	if (g_IsObserver || entStates.every(entState => controlsPlayer(entState.player)))
 	{
-		for (var guiName of g_PanelsOrder)
+		for (let guiName of g_PanelsOrder)
 		{
+
 			if (g_SelectionPanels[guiName].conflictsWith &&
 			    g_SelectionPanels[guiName].conflictsWith.some(p => g_SelectionPanels[p].used))
 				continue;
 
 			setupUnitPanel(guiName, entStates, playerStates[entStates[0].player]);
 		}
 
 		supplementalDetailsPanel.hidden = false;
 		commandsPanel.hidden = false;
 	}
 	else if (playerState.isMutualAlly[entStates[0].player]) // owned by allied player
 	{
 		// TODO if there's a second panel needed for a different player
 		// we should consider adding the players list to g_SelectionPanels
 		setupUnitPanel("Garrison", entStates, playerState);
 		setupUnitPanel("AllyCommand", entStates, playerState);
 
 		supplementalDetailsPanel.hidden = !g_SelectionPanels.Garrison.used;
 
 		commandsPanel.hidden = true;
 	}
 	else // owned by another player
 	{
 		supplementalDetailsPanel.hidden = true;
 		commandsPanel.hidden = true;
 	}
 
 	// Hides / unhides Unit Panels (panels should be grouped by type, not by order, but we will leave that for another time)
-	for (var panelName in g_SelectionPanels)
+	for (let panelName in g_SelectionPanels)
 		Engine.GetGUIObjectByName("unit" + panelName + "Panel").hidden = !g_SelectionPanels[panelName].used;
 }
 
 // Force hide commands panels
 function hideUnitCommands()
 {
 	for (var panelName in g_SelectionPanels)
 		Engine.GetGUIObjectByName("unit" + panelName + "Panel").hidden = true;
 }
 
 // Get all of the available entities which can be trained by the selected entities
 function getAllTrainableEntities(selection)
 {
 	let trainableEnts = [];
 	// Get all buildable and trainable entities
 	for (let ent of selection)
 	{
 		let state = GetEntityState(ent);
 		if (state && state.production && state.production.entities.length)
 			trainableEnts = trainableEnts.concat(state.production.entities);
 	}
 
 	// Remove duplicates
 	removeDupes(trainableEnts);
 	return trainableEnts;
 }
 
 function getAllTrainableEntitiesFromSelection()
 {
 	if (!g_allTrainableEntities)
 		g_allTrainableEntities = getAllTrainableEntities(g_Selection.toList());
 
 	return g_allTrainableEntities;
 }
 
 // Get all of the available entities which can be built by the selected entities
 function getAllBuildableEntities(selection)
 {
 	return Engine.GuiInterfaceCall("GetAllBuildableEntities", { "entities": selection });
 }
 
 function getAllBuildableEntitiesFromSelection()
 {
 	if (!g_allBuildableEntities)
 		g_allBuildableEntities = getAllBuildableEntities(g_Selection.toList());
 
 	return g_allBuildableEntities;
 }
 
 function getNumberOfRightPanelButtons()
 {
 	var sum = 0;
 
 	for (let prop of ["Construction", "Training", "Pack", "Gate", "Upgrade"])
 		if (g_SelectionPanels[prop].used)
 			sum += g_unitPanelButtons[prop];
 
 	return sum;
 }