Index: ps/trunk/binaries/data/mods/public/gui/session/input.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/input.js	(revision 17616)
+++ ps/trunk/binaries/data/mods/public/gui/session/input.js	(revision 17617)
@@ -1,1917 +1,1917 @@
 const SDL_BUTTON_LEFT = 1;
 const SDL_BUTTON_MIDDLE = 2;
 const SDL_BUTTON_RIGHT = 3;
 const SDLK_LEFTBRACKET = 91;
 const SDLK_RIGHTBRACKET = 93;
 const SDLK_RSHIFT = 303;
 const SDLK_LSHIFT = 304;
 const SDLK_RCTRL = 305;
 const SDLK_LCTRL = 306;
 const SDLK_RALT = 307;
 const SDLK_LALT = 308;
 // TODO: these constants should be defined somewhere else instead, in
 // case any other code wants to use them too
 
 const ACTION_NONE = 0;
 const ACTION_GARRISON = 1;
 const ACTION_REPAIR = 2;
 const ACTION_GUARD = 3;
 var preSelectedAction = ACTION_NONE;
 
 const INPUT_NORMAL = 0;
 const INPUT_SELECTING = 1;
 const INPUT_BANDBOXING = 2;
 const INPUT_BUILDING_PLACEMENT = 3;
 const INPUT_BUILDING_CLICK = 4;
 const INPUT_BUILDING_DRAG = 5;
 const INPUT_BATCHTRAINING = 6;
 const INPUT_PRESELECTEDACTION = 7;
 const INPUT_BUILDING_WALL_CLICK = 8;
 const INPUT_BUILDING_WALL_PATHING = 9;
 const INPUT_MASSTRIBUTING = 10;
 
 var inputState = INPUT_NORMAL;
 
 const INVALID_ENTITY = 0;
 
 var mouseX = 0;
 var mouseY = 0;
 var mouseIsOverObject = false;
 
 // Number of pixels the mouse can move before the action is considered a drag
 var maxDragDelta = 4;
 
 // Time in milliseconds in which a double click is recognized
 const doubleClickTime = 500;
 var doubleClickTimer = 0;
 var doubleClicked = false;
 // Store the previously clicked entity - ensure a double/triple click happens on the same entity
 var prevClickedEntity = 0;
 
 // Same double-click behaviour for hotkey presses
 const doublePressTime = 500;
 var doublePressTimer = 0;
 var prevHotkey = 0;
 
 function updateCursorAndTooltip()
 {
 	var cursorSet = false;
 	var tooltipSet = false;
 	var informationTooltip = Engine.GetGUIObjectByName("informationTooltip");
 	if (!mouseIsOverObject && (inputState == INPUT_NORMAL || inputState == INPUT_PRESELECTEDACTION))
 	{
 		let action = determineAction(mouseX, mouseY);
 		if (action)
 		{
 			if (action.cursor)
 			{
 				Engine.SetCursor(action.cursor);
 				cursorSet = true;
 			}
 			if (action.tooltip)
 			{
 				tooltipSet = true;
 				informationTooltip.caption = action.tooltip;
 				informationTooltip.hidden = false;
 			}
 		}
 	}
 
 	if (!cursorSet)
 		Engine.SetCursor("arrow-default");
 	if (!tooltipSet)
 		informationTooltip.hidden = true;
 
 	var placementTooltip = Engine.GetGUIObjectByName("placementTooltip");
 	if (placementSupport.tooltipMessage)
 		placementTooltip.sprite = placementSupport.tooltipError ? "BackgroundErrorTooltip" : "BackgroundInformationTooltip";
 
 	placementTooltip.caption = placementSupport.tooltipMessage || "";
 	placementTooltip.hidden = !placementSupport.tooltipMessage;
 }
 
 function updateBuildingPlacementPreview()
 {
 	// The preview should be recomputed every turn, so that it responds to obstructions/fog/etc moving underneath it, or
 	// in the case of the wall previews, in response to new tower foundations getting constructed for it to snap to.
 	// See onSimulationUpdate in session.js.
 
 	if (placementSupport.mode === "building")
 	{
 		if (placementSupport.template && placementSupport.position)
 		{
 			var result = Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
 				"template": placementSupport.template,
 				"x": placementSupport.position.x,
 				"z": placementSupport.position.z,
 				"angle": placementSupport.angle,
 				"actorSeed": placementSupport.actorSeed
 			});
 
 			// Show placement info tooltip if invalid position
 			placementSupport.tooltipError = !result.success;
 			placementSupport.tooltipMessage = "";
 
 			if (!result.success)
 			{
 				if (result.message && result.parameters)
 				{
 					var message = result.message;
 					if (result.translateMessage)
 						if (result.pluralMessage)
 							message = translatePlural(result.message, result.pluralMessage, result.pluralCount);
 						else
 							message = translate(message);
 					var parameters = result.parameters;
 					if (result.translateParameters)
 						translateObjectKeys(parameters, result.translateParameters);
 					placementSupport.tooltipMessage = sprintf(message, parameters);
 				}
 				return false;
 			}
 
 			if (placementSupport.attack && placementSupport.attack.Ranged)
 			{
 				// building can be placed here, and has an attack
 				// show the range advantage in the tooltip
 				var cmd = {
 					"x": placementSupport.position.x,
 					"z": placementSupport.position.z,
 					"range": placementSupport.attack.Ranged.maxRange,
 					"elevationBonus": placementSupport.attack.Ranged.elevationBonus,
 				};
 				var averageRange = Math.round(Engine.GuiInterfaceCall("GetAverageRangeForBuildings", cmd) - cmd.range);
 				var range = Math.round(cmd.range);
 				placementSupport.tooltipMessage = sprintf(translatePlural("Basic range: %(range)s meter", "Basic range: %(range)s meters", range), { "range": range }) + "\n" +
 					sprintf(translatePlural("Average bonus range: %(range)s meter", "Average bonus range: %(range)s meters", averageRange), { "range": averageRange });
 			}
 			return true;
 		}
 	}
 	else if (placementSupport.mode === "wall")
 	{
 		if (placementSupport.wallSet && placementSupport.position)
 		{
 			// Fetch an updated list of snapping candidate entities
 			placementSupport.wallSnapEntities = Engine.PickSimilarFriendlyEntities(
 				placementSupport.wallSet.templates.tower,
 				placementSupport.wallSnapEntitiesIncludeOffscreen,
 				true, // require exact template match
 				true  // include foundations
 			);
 
 			return Engine.GuiInterfaceCall("SetWallPlacementPreview", {
 				"wallSet": placementSupport.wallSet,
 				"start": placementSupport.position,
 				"end": placementSupport.wallEndPosition,
 				"snapEntities": placementSupport.wallSnapEntities,	// snapping entities (towers) for starting a wall segment
 			});
 		}
 	}
 
 	return false;
 }
 
 function findGatherType(gatherer, supply)
 {
 	if (!("resourceGatherRates" in gatherer) || !gatherer.resourceGatherRates || !supply)
 		return undefined;
 	if (gatherer.resourceGatherRates[supply.type.generic+"."+supply.type.specific])
 		return supply.type.specific;
 	if (gatherer.resourceGatherRates[supply.type.generic])
 		return supply.type.generic;
 	return undefined;
 }
 
 function getActionInfo(action, target)
 {
 	var simState = GetSimState();
 	var selection = g_Selection.toList();
 
 	// If the selection doesn't exist, no action
 	var entState = GetEntityState(selection[0]);
 	if (!entState)
 		return { "possible": false };
 
 	if (!target) // TODO move these non-target actions to an object like unit_actions.js
 	{
 		if (action == "set-rallypoint")
 		{
 			var cursor = "";
 			var data = { "command": "walk" };
 			if (Engine.HotkeyIsPressed("session.attackmove"))
 			{
 				data.command = "attack-walk";
 				data.targetClasses = Engine.HotkeyIsPressed("session.attackmoveUnit") ? { "attack": ["Unit"] } : { "attack": ["Unit", "Structure"] };
 				cursor = "action-attack-move";
 			}
 			return { "possible": true, "data": data, "cursor": cursor };
 		}
 
 		return { "possible": (action == "move" || action == "attack-move" || action == "remove-guard") };
 	}
 
 	// Look at the first targeted entity
 	// (TODO: maybe we eventually want to look at more, and be more context-sensitive?
 	// e.g. prefer to attack an enemy unit, even if some friendly units are closer to the mouse)
 	var targetState = GetExtendedEntityState(target);
 
 	// Check if the target entity is a resource, dropsite, foundation, or enemy unit.
 	// Check if any entities in the selection can gather the requested resource,
 	// can return to the dropsite, can build the foundation, or can attack the enemy
 	for each (var entityID in selection)
 	{
 		var entState = GetExtendedEntityState(entityID);
 		if (!entState)
 			continue;
 
 		if (unitActions[action] && unitActions[action].getActionInfo)
 		{
 			var r = unitActions[action].getActionInfo(entState, targetState, simState);
 			if (r) // return true if it's possible for one of the entities
 				return r;
 		}
 	}
 	return { "possible": false };
 }
 
 /**
  * Determine the context-sensitive action that should be performed when the mouse is at (x,y)
  */
 function determineAction(x, y, fromMinimap)
 {
 	var selection = g_Selection.toList();
 
 	// No action if there's no selection
 	if (!selection.length)
 	{
 		preSelectedAction = ACTION_NONE;
 		return undefined;
 	}
 
 	// If the selection doesn't exist, no action
 	var entState = GetEntityState(selection[0]);
 	if (!entState)
 		return undefined;
 
 	// If the selection isn't friendly units, no action
 	var playerID = Engine.GetPlayerID();
 	var allOwnedByPlayer = selection.every(function(ent) {
 		var entState = GetEntityState(ent);
 		return entState && entState.player == playerID;
 	});
 
 	if (!g_DevSettings.controlAll && !allOwnedByPlayer)
 		return undefined;
 
 	var target = undefined;
 	if (!fromMinimap)
 	{
 		var ent = Engine.PickEntityAtPoint(x, y);
 		if (ent != INVALID_ENTITY)
 			target = ent;
 	}
 
 	// decide between the following ordered actions
 	// if two actions are possible, the first one is taken
 	// so the most specific should appear first
 	var actions = Object.keys(unitActions).slice();
 	actions.sort((a, b) => unitActions[a].specificness - unitActions[b].specificness);
 
 	var actionInfo = undefined;
 	if (preSelectedAction != ACTION_NONE)
 	{
 		for (var action of actions)
 		{
 			if (unitActions[action].preSelectedActionCheck)
 			{
 				var r = unitActions[action].preSelectedActionCheck(target, selection);
 				if (r)
 					return r;
 			}
 		}
 		return { "type": "none", "cursor": "", "target": target };
 	}
 
 	for (var action of actions)
 	{
 		if (unitActions[action].hotkeyActionCheck)
 		{
 			var r = unitActions[action].hotkeyActionCheck(target, selection);
 			if (r)
 				return r;
 		}
 	}
 
 	for (var action of actions)
 	{
 		if (unitActions[action].actionCheck)
 		{
 			var r = unitActions[action].actionCheck(target, selection);
 			if (r)
 				return r;
 		}
 	}
 
 	return { "type": "none", "cursor": "", "target": target };
 }
 
 
 var dragStart; // used for remembering mouse coordinates at start of drag operations
 
 function tryPlaceBuilding(queued)
 {
 	if (placementSupport.mode !== "building")
 	{
 		error(sprintf("[%(functionName)s] Called while in '%(mode)s' placement mode instead of 'building'", {
 			"functionName": "tryPlaceBuilding",
 			"mode": placementSupport.mode
 		}));
 		return false;
 	}
 
 	// Use the preview to check it's a valid build location
 	if (!updateBuildingPlacementPreview())
 	{
 		// invalid location - don't build it
 		// TODO: play a sound?
 		return false;
 	}
 
 	var selection = g_Selection.toList();
 
 	// Start the construction
 	Engine.PostNetworkCommand({
 		"type": "construct",
 		"template": placementSupport.template,
 		"x": placementSupport.position.x,
 		"z": placementSupport.position.z,
 		"angle": placementSupport.angle,
 		"actorSeed": placementSupport.actorSeed,
 		"entities": selection,
 		"autorepair": true,
 		"autocontinue": true,
 		"queued": queued
 	});
 	Engine.GuiInterfaceCall("PlaySound", { "name": "order_repair", "entity": selection[0] });
 
 	if (!queued)
 		placementSupport.Reset();
 	else
 		placementSupport.RandomizeActorSeed();
 
 	return true;
 }
 
 function tryPlaceWall(queued)
 {
 	if (placementSupport.mode !== "wall")
 	{
 		error(sprintf("[%(functionName)s] Called while in '%(mode)s' placement mode; expected 'wall' mode", {
 			functionName: "tryPlaceWall",
 			mode: placementSupport.mode
 		}));
 		return false;
 	}
 
 	var wallPlacementInfo = updateBuildingPlacementPreview(); // entities making up the wall (wall segments, towers, ...)
 	if (!(wallPlacementInfo === false || typeof(wallPlacementInfo) === "object"))
 	{
 		error(sprintf("[%(functionName)s] Unexpected return value from %(function2Name)s: '%(value)s'; expected either 'false' or 'object'", {
 			functionName: "tryPlaceWall",
 			function2Name: "updateBuildingPlacementPreview",
 			value: uneval(placementInfo)
 		}));
 		return false;
 	}
 
 	if (!wallPlacementInfo)
 		return false;
 
 	var selection = g_Selection.toList();
 	var cmd = {
 		"type": "construct-wall",
 		"autorepair": true,
 		"autocontinue": true,
 		"queued": queued,
 		"entities": selection,
 		"wallSet": placementSupport.wallSet,
 		"pieces": wallPlacementInfo.pieces,
 		"startSnappedEntity": wallPlacementInfo.startSnappedEnt,
 		"endSnappedEntity": wallPlacementInfo.endSnappedEnt,
 	};
 
 	// make sure that there's at least one non-tower entity getting built, to prevent silly edge cases where the start and end
 	// point are too close together for the algorithm to place a wall segment inbetween, and only the towers are being previewed
 	// (this is somewhat non-ideal and hardcode-ish)
 	var hasWallSegment = false;
 	for (let piece of cmd.pieces)
 	{
 		if (piece.template != cmd.wallSet.templates.tower) // TODO: hardcode-ish :(
 		{
 			hasWallSegment = true;
 			break;
 		}
 	}
 
 	if (hasWallSegment)
 	{
 		Engine.PostNetworkCommand(cmd);
 		Engine.GuiInterfaceCall("PlaySound", { "name": "order_repair", "entity": selection[0] });
 	}
 
 	return true;
 }
 
 // Updates the bandbox object with new positions and visibility.
 // The coordinates [x0, y0, x1, y1] are returned for further use.
 function updateBandbox(bandbox, ev, hidden)
 {
 	var x0 = dragStart[0];
 	var y0 = dragStart[1];
 	var x1 = ev.x;
 	var y1 = ev.y;
 	// normalize the orientation of the rectangle
 	if (x0 > x1) { let t = x0; x0 = x1; x1 = t; }
 	if (y0 > y1) { let t = y0; y0 = y1; y1 = t; }
 
 	bandbox.size = [x0, y0, x1, y1].join(" ");
 	bandbox.hidden = hidden;
 
 	return [x0, y0, x1, y1];
 }
 
 // Define some useful unit filters for getPreferredEntities
 var unitFilters = {
 	"isUnit": function (entity) {
 		var entState = GetEntityState(entity);
 		if (!entState)
 			return false;
 		return hasClass(entState, "Unit");
 	},
 	"isDefensive": function (entity) {
 		var entState = GetEntityState(entity);
 		if (!entState)
 			return false;
 		return hasClass(entState, "Defensive");
 	},
 	"isNotSupport": function (entity) {
 		var entState = GetEntityState(entity);
 		if (!entState)
 			return false;
 		return hasClass(entState, "Unit") && !hasClass(entState, "Support") && !hasClass(entState, "Domestic");
 	},
 	"isIdle": function (entity) {
 		var entState = GetEntityState(entity);
 		if (!entState)
 			return false;
 		return hasClass(entState, "Unit") && entState.unitAI.isIdle;
 	},
 	"isAnything": function (entity) {
 		return true;
 	}
 };
 
 // Choose, inside a list of entities, which ones will be selected.
 // We may use several entity filters, until one returns at least one element.
 function getPreferredEntities(ents)
 {
 	// Default filters
 	var filters = [unitFilters.isUnit, unitFilters.isDefensive, unitFilters.isAnything];
 
 	// Handle hotkeys
 	if (Engine.HotkeyIsPressed("selection.milonly"))
 		filters = [unitFilters.isNotSupport];
 	if (Engine.HotkeyIsPressed("selection.idleonly"))
 		filters = [unitFilters.isIdle];
 
 	var preferredEnts = [];
 	for (var i = 0; i < filters.length; ++i)
 	{
 		preferredEnts = ents.filter(filters[i]);
 		if (preferredEnts.length > 0)
 			break;
 	}
 	return preferredEnts;
 }
 
 function handleInputBeforeGui(ev, hoveredObject)
 {
 	// Capture mouse position so we can use it for displaying cursors,
 	// and key states
 	switch (ev.type)
 	{
 	case "mousebuttonup":
 	case "mousebuttondown":
 	case "mousemotion":
 		mouseX = ev.x;
 		mouseY = ev.y;
 		break;
 	}
 
 	// Remember whether the mouse is over a GUI object or not
 	mouseIsOverObject = (hoveredObject != null);
 
 	// Close the menu when interacting with the game world
 	if (!mouseIsOverObject && (ev.type =="mousebuttonup" || ev.type == "mousebuttondown")
 		&& (ev.button == SDL_BUTTON_LEFT || ev.button == SDL_BUTTON_RIGHT))
 		closeMenu();
 
 	// State-machine processing:
 	//
 	// (This is for states which should override the normal GUI processing - events will
 	// be processed here before being passed on, and propagation will stop if this function
 	// returns true)
 	//
 	// TODO: it'd probably be nice to have a better state-machine system, with guaranteed
 	// entry/exit functions, since this is a bit broken now
 
 	switch (inputState)
 	{
 	case INPUT_BANDBOXING:
 		var bandbox = Engine.GetGUIObjectByName("bandbox");
 		switch (ev.type)
 		{
 		case "mousemotion":
 			var rect = updateBandbox(bandbox, ev, false);
 
 			var ents = Engine.PickFriendlyEntitiesInRect(rect[0], rect[1], rect[2], rect[3], Engine.GetPlayerID());
 			var preferredEntities = getPreferredEntities(ents);
 			g_Selection.setHighlightList(preferredEntities);
 
 			return false;
 
 		case "mousebuttonup":
 			if (ev.button == SDL_BUTTON_LEFT)
 			{
 				var rect = updateBandbox(bandbox, ev, true);
 
 				// Get list of entities limited to preferred entities
 				var ents = getPreferredEntities(Engine.PickFriendlyEntitiesInRect(rect[0], rect[1], rect[2], rect[3], Engine.GetPlayerID()));
 
 				// Remove the bandbox hover highlighting
 				g_Selection.setHighlightList([]);
 
 				// Update the list of selected units
 				if (Engine.HotkeyIsPressed("selection.add"))
 				{
 					g_Selection.addList(ents);
 				}
 				else if (Engine.HotkeyIsPressed("selection.remove"))
 				{
 					g_Selection.removeList(ents);
 				}
 				else
 				{
 					g_Selection.reset();
 					g_Selection.addList(ents);
 				}
 
 				inputState = INPUT_NORMAL;
 				return true;
 			}
 			else if (ev.button == SDL_BUTTON_RIGHT)
 			{
 				// Cancel selection
 				bandbox.hidden = true;
 
 				g_Selection.setHighlightList([]);
 
 				inputState = INPUT_NORMAL;
 				return true;
 			}
 			break;
 		}
 		break;
 
 	case INPUT_BUILDING_CLICK:
 		switch (ev.type)
 		{
 		case "mousemotion":
 			// If the mouse moved far enough from the original click location,
 			// then switch to drag-orientation mode
 			var dragDeltaX = ev.x - dragStart[0];
 			var dragDeltaY = ev.y - dragStart[1];
 			var maxDragDelta = 16;
 			if (Math.abs(dragDeltaX) >= maxDragDelta || Math.abs(dragDeltaY) >= maxDragDelta)
 			{
 				inputState = INPUT_BUILDING_DRAG;
 				return false;
 			}
 			break;
 
 		case "mousebuttonup":
 			if (ev.button == SDL_BUTTON_LEFT)
 			{
 				// If shift is down, let the player continue placing another of the same building
 				var queued = Engine.HotkeyIsPressed("session.queue");
 				if (tryPlaceBuilding(queued))
 				{
 					if (queued)
 						inputState = INPUT_BUILDING_PLACEMENT;
 					else
 						inputState = INPUT_NORMAL;
 				}
 				else
 				{
 					inputState = INPUT_BUILDING_PLACEMENT;
 				}
 				return true;
 			}
 			break;
 
 		case "mousebuttondown":
 			if (ev.button == SDL_BUTTON_RIGHT)
 			{
 				// Cancel building
 				placementSupport.Reset();
 				inputState = INPUT_NORMAL;
 				return true;
 			}
 			break;
 		}
 		break;
 
 	case INPUT_BUILDING_WALL_CLICK:
 		// User is mid-click in choosing a starting point for building a wall. The build process can still be cancelled at this point
 		// by right-clicking; releasing the left mouse button will 'register' the starting point and commence endpoint choosing mode.
 		switch (ev.type)
 		{
 		case "mousebuttonup":
 			if (ev.button === SDL_BUTTON_LEFT)
 			{
 				inputState = INPUT_BUILDING_WALL_PATHING;
 				return true;
 			}
 			break;
 
 		case "mousebuttondown":
 			if (ev.button == SDL_BUTTON_RIGHT)
 			{
 				// Cancel building
 				placementSupport.Reset();
 				updateBuildingPlacementPreview();
 
 				inputState = INPUT_NORMAL;
 				return true;
 			}
 			break;
 		}
 		break;
 
 	case INPUT_BUILDING_WALL_PATHING:
 		// User has chosen a starting point for constructing the wall, and is now looking to set the endpoint.
 		// Right-clicking cancels wall building mode, left-clicking sets the endpoint and builds the wall and returns to
 		// normal input mode. Optionally, shift + left-clicking does not return to normal input, and instead allows the
 		// user to continue building walls.
 		switch (ev.type)
 		{
 			case "mousemotion":
 				placementSupport.wallEndPosition = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
 
 				// Update the building placement preview, and by extension, the list of snapping candidate entities for both (!)
 				// the ending point and the starting point to snap to.
 				//
 				// TODO: Note that here, we need to fetch all similar entities, including any offscreen ones, to support the case
 				// where the snap entity for the starting point has moved offscreen, or has been deleted/destroyed, or was a
 				// foundation and has been replaced with a completed entity since the user first chose it. Fetching all towers on
 				// the entire map instead of only the current screen might get expensive fast since walls all have a ton of towers
 				// in them. Might be useful to query only for entities within a certain range around the starting point and ending
 				// points.
 
 				placementSupport.wallSnapEntitiesIncludeOffscreen = true;
 				var result = updateBuildingPlacementPreview(); // includes an update of the snap entity candidates
 
 				if (result && result.cost)
 				{
 					placementSupport.tooltipMessage = getEntityCostTooltip(result);
-					var neededResources = Engine.GuiInterfaceCall("GetNeededResources", result.cost);
+					var neededResources = Engine.GuiInterfaceCall("GetNeededResources", { "cost": result.cost });
 					if (neededResources)
 						placementSupport.tooltipMessage += getNeededResourcesTooltip(neededResources);
 				}
 
 				break;
 
 			case "mousebuttondown":
 				if (ev.button == SDL_BUTTON_LEFT)
 				{
 					var queued = Engine.HotkeyIsPressed("session.queue");
 					if (tryPlaceWall(queued))
 					{
 						if (queued)
 						{
 							// continue building, just set a new starting position where we left off
 							placementSupport.position = placementSupport.wallEndPosition;
 							placementSupport.wallEndPosition = undefined;
 
 							inputState = INPUT_BUILDING_WALL_CLICK;
 						}
 						else
 						{
 							placementSupport.Reset();
 							inputState = INPUT_NORMAL;
 						}
 					}
 					else
 					{
 						placementSupport.tooltipMessage = translate("Cannot build wall here!");
 					}
 
 					updateBuildingPlacementPreview();
 					return true;
 				}
 				else if (ev.button == SDL_BUTTON_RIGHT)
 				{
 					// reset to normal input mode
 					placementSupport.Reset();
 					updateBuildingPlacementPreview();
 
 					inputState = INPUT_NORMAL;
 					return true;
 				}
 				break;
 		}
 		break;
 
 	case INPUT_BUILDING_DRAG:
 		switch (ev.type)
 		{
 		case "mousemotion":
 			var dragDeltaX = ev.x - dragStart[0];
 			var dragDeltaY = ev.y - dragStart[1];
 			var maxDragDelta = 16;
 			if (Math.abs(dragDeltaX) >= maxDragDelta || Math.abs(dragDeltaY) >= maxDragDelta)
 			{
 				// Rotate in the direction of the mouse
 				var target = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
 				placementSupport.angle = Math.atan2(target.x - placementSupport.position.x, target.z - placementSupport.position.z);
 			}
 			else
 			{
 				// If the mouse is near the center, snap back to the default orientation
 				placementSupport.SetDefaultAngle();
 			}
 
 			var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
 				"template": placementSupport.template,
 				"x": placementSupport.position.x,
 				"z": placementSupport.position.z
 			});
 			if (snapData)
 			{
 				placementSupport.angle = snapData.angle;
 				placementSupport.position.x = snapData.x;
 				placementSupport.position.z = snapData.z;
 			}
 
 			updateBuildingPlacementPreview();
 			break;
 
 		case "mousebuttonup":
 			if (ev.button == SDL_BUTTON_LEFT)
 			{
 				// If shift is down, let the player continue placing another of the same building
 				var queued = Engine.HotkeyIsPressed("session.queue");
 				if (tryPlaceBuilding(queued))
 				{
 					if (queued)
 						inputState = INPUT_BUILDING_PLACEMENT;
 					else
 						inputState = INPUT_NORMAL;
 				}
 				else
 				{
 					inputState = INPUT_BUILDING_PLACEMENT;
 				}
 				return true;
 			}
 			break;
 
 		case "mousebuttondown":
 			if (ev.button == SDL_BUTTON_RIGHT)
 			{
 				// Cancel building
 				placementSupport.Reset();
 				inputState = INPUT_NORMAL;
 				return true;
 			}
 			break;
 		}
 		break;
 
 	case INPUT_MASSTRIBUTING:
 		if (ev.type == "hotkeyup" && ev.hotkey == "session.masstribute")
 		{
 			g_FlushTributing();
 			inputState = INPUT_NORMAL;
 		}
 		break;
 
 	case INPUT_BATCHTRAINING:
 		if (ev.type == "hotkeyup" && ev.hotkey == "session.batchtrain")
 		{
 			flushTrainingBatch();
 			inputState = INPUT_NORMAL;
 		}
 		break;
 	}
 
 	return false;
 }
 
 function handleInputAfterGui(ev)
 {
 	if (ev.hotkey === undefined)
 		ev.hotkey = null;
 
 	// Handle the time-warp testing features, restricted to single-player
 	if (!g_IsNetworked && Engine.GetGUIObjectByName("devTimeWarp").checked)
 	{
 		if (ev.type == "hotkeydown" && ev.hotkey == "session.timewarp.fastforward")
 			Engine.SetSimRate(20.0);
 		else if (ev.type == "hotkeyup" && ev.hotkey == "session.timewarp.fastforward")
 			Engine.SetSimRate(1.0);
 		else if (ev.type == "hotkeyup" && ev.hotkey == "session.timewarp.rewind")
 			Engine.RewindTimeWarp();
 	}
 
 	if (ev.hotkey == "session.showstatusbars")
 	{
 		g_ShowAllStatusBars = (ev.type == "hotkeydown");
 		recalculateStatusBarDisplay();
 	}
 	else if (ev.hotkey == "session.highlightguarding")
 	{
 		g_ShowGuarding = (ev.type == "hotkeydown");
 		updateAdditionalHighlight();
 	}
 	else if (ev.hotkey == "session.highlightguarded")
 	{
 		g_ShowGuarded = (ev.type == "hotkeydown");
 		updateAdditionalHighlight();
 	}
 
 	// State-machine processing:
 
 	switch (inputState)
 	{
 	case INPUT_NORMAL:
 		switch (ev.type)
 		{
 		case "mousemotion":
 			// Highlight the first hovered entity (if any)
 			var ent = Engine.PickEntityAtPoint(ev.x, ev.y);
 			if (ent != INVALID_ENTITY)
 				g_Selection.setHighlightList([ent]);
 			else
 				g_Selection.setHighlightList([]);
 
 			return false;
 
 		case "mousebuttondown":
 			if (ev.button == SDL_BUTTON_LEFT)
 			{
 				dragStart = [ ev.x, ev.y ];
 				inputState = INPUT_SELECTING;
 				return true;
 			}
 			else if (ev.button == SDL_BUTTON_RIGHT)
 			{
 				var action = determineAction(ev.x, ev.y);
 				if (!action)
 					break;
 				return doAction(action, ev);
 			}
 			break;
 
 		case "hotkeydown":
 				if (ev.hotkey.indexOf("selection.group.") == 0)
 				{
 					var now = new Date();
 					if ((now.getTime() - doublePressTimer < doublePressTime) && (ev.hotkey == prevHotkey))
 					{
 						if (ev.hotkey.indexOf("selection.group.select.") == 0)
 						{
 							var sptr = ev.hotkey.split(".");
 							performGroup("snap", sptr[3]);
 						}
 					}
 					else
 					{
 						var sptr = ev.hotkey.split(".");
 						performGroup(sptr[2], sptr[3]);
 
 						doublePressTimer = now.getTime();
 						prevHotkey = ev.hotkey;
 					}
 				}
 				break;
 		}
 		break;
 
 	case INPUT_PRESELECTEDACTION:
 		switch (ev.type)
 		{
 		case "mousemotion":
 			// Highlight the first hovered entity (if any)
 			var ent = Engine.PickEntityAtPoint(ev.x, ev.y);
 			if (ent != INVALID_ENTITY)
 				g_Selection.setHighlightList([ent]);
 			else
 				g_Selection.setHighlightList([]);
 
 			return false;
 
 		case "mousebuttondown":
 			if (ev.button == SDL_BUTTON_LEFT && preSelectedAction != ACTION_NONE)
 			{
 				var action = determineAction(ev.x, ev.y);
 				if (!action)
 					break;
 				preSelectedAction = ACTION_NONE;
 				inputState = INPUT_NORMAL;
 				return doAction(action, ev);
 			}
 			else if (ev.button == SDL_BUTTON_RIGHT && preSelectedAction != ACTION_NONE)
 			{
 				preSelectedAction = ACTION_NONE;
 				inputState = INPUT_NORMAL;
 				break;
 			}
 			// else
 		default:
 			// Slight hack: If selection is empty, reset the input state
 			if (g_Selection.toList().length == 0)
 			{
 				preSelectedAction = ACTION_NONE;
 				inputState = INPUT_NORMAL;
 				break;
 			}
 		}
 		break;
 
 	case INPUT_SELECTING:
 		switch (ev.type)
 		{
 		case "mousemotion":
 			// If the mouse moved further than a limit, switch to bandbox mode
 			var dragDeltaX = ev.x - dragStart[0];
 			var dragDeltaY = ev.y - dragStart[1];
 
 			if (Math.abs(dragDeltaX) >= maxDragDelta || Math.abs(dragDeltaY) >= maxDragDelta)
 			{
 				inputState = INPUT_BANDBOXING;
 				return false;
 			}
 
 			var ent = Engine.PickEntityAtPoint(ev.x, ev.y);
 			if (ent != INVALID_ENTITY)
 				g_Selection.setHighlightList([ent]);
 			else
 				g_Selection.setHighlightList([]);
 			return false;
 
 		case "mousebuttonup":
 			if (ev.button == SDL_BUTTON_LEFT)
 			{
 				var ents = [];
 				var selectedEntity = Engine.PickEntityAtPoint(ev.x, ev.y);
 				if (selectedEntity == INVALID_ENTITY)
 				{
 					if (!Engine.HotkeyIsPressed("selection.add") && !Engine.HotkeyIsPressed("selection.remove"))
 					{
 						g_Selection.reset();
 						resetIdleUnit();
 					}
 					inputState = INPUT_NORMAL;
 					return true;
 				}
 
 				var now = new Date();
 
 				// If camera following and we select different unit, stop
 				if (Engine.GetFollowedEntity() != selectedEntity)
 				{
 					Engine.CameraFollow(0);
 				}
 
 				if ((now.getTime() - doubleClickTimer < doubleClickTime) && (selectedEntity == prevClickedEntity))
 				{
 					// Double click or triple click has occurred
 					var showOffscreen = Engine.HotkeyIsPressed("selection.offscreen");
 					var matchRank = true;
 					var templateToMatch;
 
 					// Check for double click or triple click
 					if (!doubleClicked)
 					{
 						// If double click hasn't already occurred, this is a double click.
 						// Select similar units regardless of rank
 						templateToMatch = GetEntityState(selectedEntity).identity.selectionGroupName;
 						if (templateToMatch)
 						{
 							matchRank = false;
 						}
 						else
 						{	// No selection group name defined, so fall back to exact match
 							templateToMatch = GetEntityState(selectedEntity).template;
 						}
 
 						doubleClicked = true;
 						// Reset the timer so the user has an extra period 'doubleClickTimer' to do a triple-click
 						doubleClickTimer = now.getTime();
 					}
 					else
 					{
 						// Double click has already occurred, so this is a triple click.
 						// Select units matching exact template name (same rank)
 						templateToMatch = GetEntityState(selectedEntity).template;
 					}
 
 					// TODO: Should we handle "control all units" here as well?
 					ents = Engine.PickSimilarFriendlyEntities(templateToMatch, showOffscreen, matchRank, false);
 				}
 				else
 				{
 					// It's single click right now but it may become double or triple click
 					doubleClicked = false;
 					doubleClickTimer = now.getTime();
 					prevClickedEntity = selectedEntity;
 
 					// We only want to include the first picked unit in the selection
 					ents = [selectedEntity];
 				}
 
 				// Update the list of selected units
 				if (Engine.HotkeyIsPressed("selection.add"))
 				{
 					g_Selection.addList(ents);
 				}
 				else if (Engine.HotkeyIsPressed("selection.remove"))
 				{
 					g_Selection.removeList(ents);
 				}
 				else
 				{
 					g_Selection.reset();
 					g_Selection.addList(ents);
 				}
 
 				inputState = INPUT_NORMAL;
 				return true;
 			}
 			break;
 		}
 		break;
 
 	case INPUT_BUILDING_PLACEMENT:
 		switch (ev.type)
 		{
 		case "mousemotion":
 
 			placementSupport.position = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
 
 			if (placementSupport.mode === "wall")
 			{
 				// Including only the on-screen towers in the next snap candidate list is sufficient here, since the user is
 				// still selecting a starting point (which must necessarily be on-screen). (The update of the snap entities
 				// itself happens in the call to updateBuildingPlacementPreview below).
 				placementSupport.wallSnapEntitiesIncludeOffscreen = false;
 			}
 			else
 			{
 				// cancel if not enough resources
-				if (placementSupport.template && Engine.GuiInterfaceCall("GetNeededResources", GetTemplateData(placementSupport.template).cost))
+				if (placementSupport.template && Engine.GuiInterfaceCall("GetNeededResources", { "cost": GetTemplateData(placementSupport.template).cost }))
 				{
 					placementSupport.Reset();
 					inputState = INPUT_NORMAL;
 					return true;
 				}
 
 				var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
 					"template": placementSupport.template,
 					"x": placementSupport.position.x,
 					"z": placementSupport.position.z,
 				});
 				if (snapData)
 				{
 					placementSupport.angle = snapData.angle;
 					placementSupport.position.x = snapData.x;
 					placementSupport.position.z = snapData.z;
 				}
 			}
 
 			updateBuildingPlacementPreview(); // includes an update of the snap entity candidates
 			return false; // continue processing mouse motion
 
 		case "mousebuttondown":
 			if (ev.button == SDL_BUTTON_LEFT)
 			{
 				if (placementSupport.mode === "wall")
 				{
 					var validPlacement = updateBuildingPlacementPreview();
 					if (validPlacement !== false)
 						inputState = INPUT_BUILDING_WALL_CLICK;
 				}
 				else
 				{
 					placementSupport.position = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
 					dragStart = [ ev.x, ev.y ];
 					inputState = INPUT_BUILDING_CLICK;
 				}
 				return true;
 			}
 			else if (ev.button == SDL_BUTTON_RIGHT)
 			{
 				// Cancel building
 				placementSupport.Reset();
 				inputState = INPUT_NORMAL;
 				return true;
 			}
 			break;
 
 		case "hotkeydown":
 
 			var rotation_step = Math.PI / 12; // 24 clicks make a full rotation
 
 			switch (ev.hotkey)
 			{
 			case "session.rotate.cw":
 				placementSupport.angle += rotation_step;
 				updateBuildingPlacementPreview();
 				break;
 			case "session.rotate.ccw":
 				placementSupport.angle -= rotation_step;
 				updateBuildingPlacementPreview();
 				break;
 			}
 			break;
 
 		}
 		break;
 	}
 	return false;
 }
 
 function doAction(action, ev)
 {
 	var selection = g_Selection.toList();
 
 	// If shift is down, add the order to the unit's order queue instead
 	// of running it immediately
 	var queued = Engine.HotkeyIsPressed("session.queue");
 	var target = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
 
 	if (unitActions[action.type] && unitActions[action.type].execute)
 		return unitActions[action.type].execute(target, action, selection, queued);
 	error("Invalid action.type "+action.type);
 	return false;
 }
 
 function handleMinimapEvent(target)
 {
 	// Partly duplicated from handleInputAfterGui(), but with the input being
 	// world coordinates instead of screen coordinates.
 
 	if (inputState != INPUT_NORMAL)
 		return false;
 
 	var fromMinimap = true;
 	var action = determineAction(undefined, undefined, fromMinimap);
 	if (!action)
 		return false;
 
 	var selection = g_Selection.toList();
 
 	var queued = Engine.HotkeyIsPressed("session.queue");
 	if (unitActions[action.type] && unitActions[action.type].execute)
 		return unitActions[action.type].execute(target, action, selection, queued);
 	error("Invalid action.type "+action.type);
 	return false;
 }
 
 // Called by GUI when user clicks construction button
 // @param buildTemplate Template name of the entity the user wants to build
 function startBuildingPlacement(buildTemplate, playerState)
 {
 	if(getEntityLimitAndCount(playerState, buildTemplate).canBeAddedCount == 0)
 		return;
 
 	// TODO: we should clear any highlight selection rings here. If the mouse was over an entity before going onto the GUI
 	// to start building a structure, then the highlight selection rings are kept during the construction of the building.
 	// Gives the impression that somehow the hovered-over entity has something to do with the building you're constructing.
 
 	placementSupport.Reset();
 
 	// find out if we're building a wall, and change the entity appropriately if so
 	var templateData = GetTemplateData(buildTemplate);
 	if (templateData.wallSet)
 	{
 		placementSupport.mode = "wall";
 		placementSupport.wallSet = templateData.wallSet;
 		inputState = INPUT_BUILDING_PLACEMENT;
 	}
 	else
 	{
 		placementSupport.mode = "building";
 		placementSupport.template = buildTemplate;
 		inputState = INPUT_BUILDING_PLACEMENT;
 	}
 
 	if (templateData.attack &&
 		templateData.attack.Ranged &&
 		templateData.attack.Ranged.maxRange)
 	{
 		// add attack information to display a good tooltip
 		placementSupport.attack = templateData.attack;
 	}
 }
 
 // Called by GUI when user changes required trading goods
 function selectRequiredGoods(data)
 {
 	Engine.PostNetworkCommand({ "type": "select-required-goods", "entities": data.entities, "requiredGoods": data.requiredGoods} );
 }
 
 // Called by GUI when user clicks exchange resources button
 function exchangeResources(command)
 {
 	Engine.PostNetworkCommand({ "type": "barter", "sell": command.sell, "buy": command.buy, "amount": command.amount });
 }
 
 // Camera jumping: when the user presses a hotkey the current camera location is marked.
 // When they press another hotkey the camera jumps back to that position. If the camera is already roughly at that location,
 // jump back to where it was previously.
 var jumpCameraPositions = [];
 var jumpCameraLast;
 var jumpCameraDistanceThreshold = Engine.ConfigDB_GetValue("user", "gui.session.camerajump.threshold");
 
 function jumpCamera(index)
 {
 	var position = jumpCameraPositions[index];
 	if (position)
 	{
 		if (jumpCameraLast &&
 				Math.abs(Engine.CameraGetX() - position.x) < jumpCameraDistanceThreshold &&
 				Math.abs(Engine.CameraGetZ() - position.z) < jumpCameraDistanceThreshold)
 			Engine.CameraMoveTo(jumpCameraLast.x, jumpCameraLast.z);
 		else
 		{
 			jumpCameraLast = {x: Engine.CameraGetX(), z: Engine.CameraGetZ()};
 			Engine.CameraMoveTo(position.x, position.z);
 		}
 	}
 }
 
 function setJumpCamera(index)
 {
 	jumpCameraPositions[index] = {x: Engine.CameraGetX(), z: Engine.CameraGetZ()};
 }
 
 // Batch training:
 // When the user shift-clicks, we set these variables and switch to INPUT_BATCHTRAINING
 // When the user releases shift, or clicks on a different training button, we create the batched units
 var batchTrainingEntities;
 var batchTrainingType;
 var batchTrainingCount;
 var batchTrainingEntityAllowedCount;
 const batchIncrementSize = 5;
 
 function flushTrainingBatch()
 {
 	var appropriateBuildings = getBuildingsWhichCanTrainEntity(batchTrainingEntities, batchTrainingType);
 	// If training limits don't allow us to train batchTrainingCount in each appropriate building
 	if (batchTrainingEntityAllowedCount !== undefined &&
 		batchTrainingEntityAllowedCount < batchTrainingCount * appropriateBuildings.length)
 	{
 		// Train as many full batches as we can
 		var buildingsCountToTrainFullBatch = Math.floor(batchTrainingEntityAllowedCount / batchTrainingCount);
 		var buildingsToTrainFullBatch = appropriateBuildings.slice(0, buildingsCountToTrainFullBatch);
 		Engine.PostNetworkCommand({
 			"type": "train",
 			"entities": buildingsToTrainFullBatch,
 			"template": batchTrainingType,
 			"count": batchTrainingCount
 		});
 
 		// Train remainer in one more building
 		Engine.PostNetworkCommand({
 			"type": "train",
 			"entities": [ appropriateBuildings[buildingsCountToTrainFullBatch] ],
 			"template": batchTrainingType,
 			"count": batchTrainingEntityAllowedCount % batchTrainingCount
 		});
 	}
 	else
 		Engine.PostNetworkCommand({
 			"type": "train",
 			"entities": appropriateBuildings,
 			"template": batchTrainingType,
 			"count": batchTrainingCount
 		});
 }
 
 function getBuildingsWhichCanTrainEntity(entitiesToCheck, trainEntType)
 {
 	return entitiesToCheck.filter(function(entity) {
 		var state = GetEntityState(entity);
 		var canTrain = state && state.production && state.production.entities.length &&
 			state.production.entities.indexOf(trainEntType) != -1;
 		return canTrain;
 	});
 }
 
 function getEntityLimitAndCount(playerState, entType)
 {
 	var r = {
 		"entLimit": undefined,
 		"entCount": undefined,
 		"entLimitChangers": undefined,
 		"canBeAddedCount": undefined
 	};
 	if (!playerState.entityLimits)
 		return r;
 	var template = GetTemplateData(entType);
 	var entCategory = null;
 	if (template.trainingRestrictions)
 		entCategory = template.trainingRestrictions.category;
 	else if (template.buildRestrictions)
 		entCategory = template.buildRestrictions.category;
 	if (entCategory && playerState.entityLimits[entCategory] !== undefined)
 	{
 		r.entLimit = playerState.entityLimits[entCategory] || 0;
 		r.entCount = playerState.entityCounts[entCategory] || 0;
 		r.entLimitChangers = playerState.entityLimitChangers[entCategory];
 		r.canBeAddedCount = Math.max(r.entLimit - r.entCount, 0);
 	}
 	return r;
 }
 
 // Add the unit shown at position to the training queue for all entities in the selection
 function addTrainingByPosition(position)
 {
 	var simState = GetSimState();
 	var playerState = simState.players[Engine.GetPlayerID()];
 	var selection = g_Selection.toList();
 
 	if (!selection.length)
 		return;
 
 	var trainableEnts = getAllTrainableEntitiesFromSelection();
 
 	// Check if the position is valid
 	if (!trainableEnts.length || trainableEnts.length <= position)
 		return;
 
 	var entToTrain = trainableEnts[position];
 
 	addTrainingToQueue(selection, entToTrain, playerState);
 	return;
 }
 
 // Called by GUI when user clicks training button
 function addTrainingToQueue(selection, trainEntType, playerState)
 {
 	// Create list of buildings which can train trainEntType
 	var appropriateBuildings = getBuildingsWhichCanTrainEntity(selection, trainEntType);
 
 	// Check trainEntType entity limit and count
 	var limits = getEntityLimitAndCount(playerState, trainEntType);
 
 	// Batch training possible if we can train at least 2 units
 	var batchTrainingPossible = limits.canBeAddedCount == undefined || limits.canBeAddedCount > 1;
 
 	var decrement = Engine.HotkeyIsPressed("selection.remove");
 	if (!decrement)
 		var template = GetTemplateData(trainEntType);
 
 	if (Engine.HotkeyIsPressed("session.batchtrain") && batchTrainingPossible)
 	{
 		if (inputState == INPUT_BATCHTRAINING)
 		{
 			// Check if we are training in the same building(s) as the last batch
 			var sameEnts = false;
 			if (batchTrainingEntities.length == selection.length)
 			{
 				// NOTE: We just check if the arrays are the same and if the order is the same
 				// If the order changed, we have a new selection and we should create a new batch.
 				for (var i = 0; i < batchTrainingEntities.length; ++i)
 				{
 					if (!(sameEnts = batchTrainingEntities[i] == selection[i]))
 						break;
 				}
 			}
 			// If we're already creating a batch of this unit (in the same building(s)), then just extend it
 			// (if training limits allow)
 			if (sameEnts && batchTrainingType == trainEntType)
 			{
 				if (decrement)
 				{
 					batchTrainingCount -= batchIncrementSize;
 					if (batchTrainingCount <= 0)
 						inputState = INPUT_NORMAL;
 				}
 				else if (limits.canBeAddedCount == undefined ||
 					limits.canBeAddedCount > batchTrainingCount * appropriateBuildings.length)
 				{
-					if (Engine.GuiInterfaceCall("GetNeededResources", multiplyEntityCosts(
-						template, batchTrainingCount + batchIncrementSize)))
+					if (Engine.GuiInterfaceCall("GetNeededResources", { "cost":
+						multiplyEntityCosts(template, batchTrainingCount + batchIncrementSize) }))
 						return;
 
 					batchTrainingCount += batchIncrementSize;
 				}
 				batchTrainingEntityAllowedCount = limits.canBeAddedCount;
 				return;
 			}
 			// Otherwise start a new one
 			else if (!decrement)
 			{
 				flushTrainingBatch();
 				// fall through to create the new batch
 			}
 		}
 
 		// Don't start a new batch if decrementing or unable to afford it.
-		if (decrement || Engine.GuiInterfaceCall("GetNeededResources",
-			multiplyEntityCosts(template, batchIncrementSize)))
+		if (decrement || Engine.GuiInterfaceCall("GetNeededResources", { "cost":
+			multiplyEntityCosts(template, batchIncrementSize) }))
 			return;
 
 		inputState = INPUT_BATCHTRAINING;
 		batchTrainingEntities = selection;
 		batchTrainingType = trainEntType;
 		batchTrainingEntityAllowedCount = limits.canBeAddedCount;
 		batchTrainingCount = batchIncrementSize;
 	}
 	else
 	{
 		// Non-batched - just create a single entity in each building
 		// (but no more than entity limit allows)
 		var buildingsForTraining = appropriateBuildings;
 		if (limits.entLimit)
 			buildingsForTraining = buildingsForTraining.slice(0, limits.canBeAddedCount);
 		Engine.PostNetworkCommand({
 			"type": "train",
 			"template": trainEntType,
 			"count": 1,
 			"entities": buildingsForTraining
 		});
 	}
 }
 
 // Called by GUI when user clicks research button
 function addResearchToQueue(entity, researchType)
 {
 	Engine.PostNetworkCommand({ "type": "research", "entity": entity, "template": researchType });
 }
 
 // Returns the number of units that will be present in a batch if the user clicks
 // the training button with shift down
 function getTrainingBatchStatus(playerState, entity, trainEntType, selection)
 {
 	var appropriateBuildings = [entity];
 	if (selection && selection.indexOf(entity) != -1)
 		appropriateBuildings = getBuildingsWhichCanTrainEntity(selection, trainEntType);
 	var nextBatchTrainingCount = 0;
 	var currentBatchTrainingCount = 0;
 
 	if (inputState == INPUT_BATCHTRAINING && batchTrainingEntities.indexOf(entity) != -1 &&
 		batchTrainingType == trainEntType)
 	{
 		nextBatchTrainingCount = batchTrainingCount;
 		currentBatchTrainingCount = batchTrainingCount;
 		var limits = {
 			"canBeAddedCount": batchTrainingEntityAllowedCount
 		};
 	}
 	else
 	{
 		var limits = getEntityLimitAndCount(playerState, trainEntType);
 	}
 	// We need to calculate count after the next increment if it's possible
 	if (limits.canBeAddedCount == undefined ||
 		limits.canBeAddedCount > nextBatchTrainingCount * appropriateBuildings.length)
 		nextBatchTrainingCount += batchIncrementSize;
 	// If training limits don't allow us to train batchTrainingCount in each appropriate building
 	// train as many full batches as we can and remainer in one more building.
 	var buildingsCountToTrainFullBatch = appropriateBuildings.length;
 	var remainderToTrain = 0;
 	if (limits.canBeAddedCount !== undefined &&
 		limits.canBeAddedCount < nextBatchTrainingCount * appropriateBuildings.length)
 	{
 		buildingsCountToTrainFullBatch = Math.floor(limits.canBeAddedCount / nextBatchTrainingCount);
 		remainderToTrain = limits.canBeAddedCount % nextBatchTrainingCount;
 	}
 	return [buildingsCountToTrainFullBatch, nextBatchTrainingCount, remainderToTrain, currentBatchTrainingCount];
 }
 
 // Called by GUI when user clicks production queue item
 function removeFromProductionQueue(entity, id)
 {
 	Engine.PostNetworkCommand({ "type": "stop-production", "entity": entity, "id": id });
 }
 
 // Called by unit selection buttons
 function changePrimarySelectionGroup(templateName, deselectGroup)
 {
 	g_Selection.makePrimarySelection(templateName, Engine.HotkeyIsPressed("session.deselectgroup") || deselectGroup);
 }
 
 // Performs the specified command (delete, town bell, repair, etc.)
 function performCommand(entity, commandName)
 {
 	if (!entity)
 		return;
 	var entState = GetExtendedEntityState(entity);
 	var playerID = Engine.GetPlayerID();
 
 	if (entState.player != playerID && !g_DevSettings.controlAll)
 		return;
 
 	if (g_EntityCommands[commandName])
 		g_EntityCommands[commandName].execute(entState);
 }
 
 // Performs the specified command for ally unit
 function performAllyCommand(entity, commandName)
 {
 	if (!entity)
 		return;
 	var entState = GetExtendedEntityState(entity);
 	var playerID = Engine.GetPlayerID();
 
 	if (!entState.player == playerID && !g_DevSettings.controlAll)
 		return;
 
 	if (g_AllyEntityCommands[commandName])
 		g_AllyEntityCommands[commandName].execute(entState);
 }
 
 // Performs the specified formation
 function performFormation(entity, formationTemplate)
 {
 	if (entity)
 		Engine.PostNetworkCommand({
 			"type": "formation",
 			"entities": g_Selection.toList(),
 			"name": formationTemplate
 		});
 }
 
 // Performs the specified group
 function performGroup(action, groupId)
 {
 	switch (action)
 	{
 	case "snap":
 	case "select":
 	case "add":
 		var toSelect = [];
 		g_Groups.update();
 		for (var ent in g_Groups.groups[groupId].ents)
 			toSelect.push(+ent);
 
 		if (action != "add")
 			g_Selection.reset();
 
 		g_Selection.addList(toSelect);
 
 		if (action == "snap" && toSelect.length)
 		{
 			let entState = GetEntityState(toSelect[0]);
 			let position = entState.position;
 			if (position && entState.visibility != "hidden")
 				Engine.CameraMoveTo(position.x, position.z);
 		}
 		break;
 	case "save":
 	case "breakUp":
 		g_Groups.groups[groupId].reset();
 
 		if (action == "save")
 			g_Groups.addEntities(groupId, g_Selection.toList());
 
 		updateGroups();
 		break;
 	}
 }
 // Performs the specified stance
 function performStance(entity, stanceName)
 {
 	if (entity)
 	{
 		var selection = g_Selection.toList();
 		Engine.PostNetworkCommand({
 			"type": "stance",
 			"entities": selection,
 			"name": stanceName
 		});
 	}
 }
 
 // Lock / Unlock the gate
 function lockGate(lock)
 {
 	var selection = g_Selection.toList();
 	Engine.PostNetworkCommand({
 		"type": "lock-gate",
 		"entities": selection,
 		"lock": lock,
 	});
 }
 
 // Pack / unpack unit(s)
 function packUnit(pack)
 {
 	var selection = g_Selection.toList();
 	Engine.PostNetworkCommand({
 		"type": "pack",
 		"entities": selection,
 		"pack": pack,
 		"queued": false
 	});
 }
 
 // Cancel un/packing unit(s)
 function cancelPackUnit(pack)
 {
 	var selection = g_Selection.toList();
 	Engine.PostNetworkCommand({
 		"type": "cancel-pack",
 		"entities": selection,
 		"pack": pack,
 		"queued": false
 	});
 }
 
 // Transform a wall to a gate
 function transformWallToGate(template)
 {
 	var selection = g_Selection.toList();
 	Engine.PostNetworkCommand({
 		"type": "wall-to-gate",
 		"entities": selection.filter( function(e) { return getWallGateTemplate(e) == template; } ),
 		"template": template,
 	});
 }
 
 // Gets the gate form (if any) of a given long wall piece
 function getWallGateTemplate(entity)
 {
 	// TODO: find the gate template name in a better way
 	var entState = GetEntityState(entity);
 	var index;
 
 	if (entState && !entState.foundation && hasClass(entState, "LongWall") && (index = entState.template.indexOf("long")) >= 0)
 		return entState.template.substr(0, index) + "gate";
 	return undefined;
 }
 
 // Set the camera to follow the given unit
 function setCameraFollow(entity)
 {
 	// Follow the given entity if it's a unit
 	if (entity)
 	{
 		var entState = GetEntityState(entity);
 		if (entState && hasClass(entState, "Unit"))
 		{
 			Engine.CameraFollow(entity);
 			return;
 		}
 	}
 
 	// Otherwise stop following
 	Engine.CameraFollow(0);
 }
 
 var lastIdleUnit = 0;
 var currIdleClass = 0;
 var lastIdleType = undefined;
 
 function resetIdleUnit()
 {
 	lastIdleUnit = 0;
 	currIdleClass = 0;
 	lastIdleType = undefined;
 }
 
 function findIdleUnit(classes)
 {
 	var append = Engine.HotkeyIsPressed("selection.add");
 	var selectall = Engine.HotkeyIsPressed("selection.offscreen");
 
 	// Reset the last idle unit, etc., if the selection type has changed.
 	var type = classes.join();
 	if (selectall || type != lastIdleType)
 		resetIdleUnit();
 	lastIdleType = type;
 
 	// If selectall is true, there is no limit and it's necessary to iterate
 	// over all of the classes, resetting only when the first match is found.
 	var matched = false;
 
 	for (var i = 0; i < classes.length; ++i)
 	{
 		var data = {
 			"idleClass": classes[currIdleClass],
 			"prevUnit": lastIdleUnit,
 			"limit": 1,
 			"excludeUnits": []
 		};
 		if (append)
 			data.excludeUnits = g_Selection.toList();
 
 		if (selectall)
 			data = { idleClass: classes[currIdleClass] };
 
 		// Check if we have new valid entity
 		var idleUnits = Engine.GuiInterfaceCall("FindIdleUnits", data);
 		if (idleUnits.length && idleUnits[0] != lastIdleUnit)
 		{
 			lastIdleUnit = idleUnits[0];
 			if (!append && (!selectall || selectall && !matched))
 				g_Selection.reset();
 
 			if (selectall)
 				g_Selection.addList(idleUnits);
 			else
 			{
 				g_Selection.addList([lastIdleUnit]);
 				var position = GetEntityState(lastIdleUnit).position;
 				if (position)
 					Engine.CameraMoveTo(position.x, position.z);
 				return;
 			}
 
 			matched = true;
 		}
 
 		lastIdleUnit = 0;
 		currIdleClass = (currIdleClass + 1) % classes.length;
 	}
 
 	// TODO: display a message or play a sound to indicate no more idle units, or something
 	// Reset for next cycle
 	resetIdleUnit();
 }
 
 function stopUnits(entities)
 {
 	Engine.PostNetworkCommand({ "type": "stop", "entities": entities, "queued": false });
 }
 
 function unload(garrisonHolder, entities)
 {
 	if (Engine.HotkeyIsPressed("session.unloadtype"))
 		Engine.PostNetworkCommand({ "type": "unload", "entities": entities, "garrisonHolder": garrisonHolder });
 	else
 		Engine.PostNetworkCommand({ "type": "unload", "entities": [entities[0]], "garrisonHolder": garrisonHolder });
 }
 
 function unloadTemplate(template)
 {
 	// Filter out all entities that aren't garrisonable.
 	var garrisonHolders = g_Selection.toList().filter(function(e) {
 		var state = GetEntityState(e);
 		if (state && state.garrisonHolder)
 			return true;
 		return false;
 	});
 
 	Engine.PostNetworkCommand({
 		"type": "unload-template",
 		"all": Engine.HotkeyIsPressed("session.unloadtype"),
 		"template": template,
 		"garrisonHolders": garrisonHolders
 	});
 }
 
 function unloadSelection()
 {
 	var parent = 0;
 	var ents = [];
 	for each (var ent in g_Selection.selected)
 	{
 		var state = GetExtendedEntityState(ent);
 		if (!state || !state.turretParent)
 			continue;
 		if (!parent)
 		{
 			parent = state.turretParent;
 			ents.push(ent);
 		}
 		else if (state.turretParent == parent)
 			ents.push(ent);
 	}
 	if (parent)
 		Engine.PostNetworkCommand({ "type": "unload", "entities":ents, "garrisonHolder": parent });
 }
 
 function unloadAllByOwner()
 {
 	var garrisonHolders = g_Selection.toList().filter(function(e) {
 		var state = GetEntityState(e);
 		return state && state.garrisonHolder;
 	});
 	Engine.PostNetworkCommand({ "type": "unload-all-by-owner", "garrisonHolders": garrisonHolders });
 }
 
 function unloadAll()
 {
 	// Filter out all entities that aren't garrisonable.
 	var garrisonHolders = g_Selection.toList().filter(function(e) {
 		var state = GetEntityState(e);
 		if (state && state.garrisonHolder)
 			return true;
 		return false;
 	});
 
 	Engine.PostNetworkCommand({ "type": "unload-all", "garrisonHolders": garrisonHolders });
 }
 
 function backToWork()
 {
 	// Filter out all entities that can't go back to work.
 	var workers = g_Selection.toList().filter(function(e) {
 		var state = GetEntityState(e);
 		return (state && state.unitAI && state.unitAI.hasWorkOrders);
 	});
 
 	Engine.PostNetworkCommand({ "type": "back-to-work", "entities": workers });
 }
 
 function removeGuard()
 {
 	// Filter out all entities that are currently guarding/escorting.
 	var entities = g_Selection.toList().filter(function(e) {
 		var state = GetEntityState(e);
 		return (state && state.unitAI && state.unitAI.isGuarding);
 	});
 
 	Engine.PostNetworkCommand({ "type": "remove-guard", "entities": entities });
 }
 
 function increaseAlertLevel()
 {
 	var entities = g_Selection.toList().filter(function(e) {
 		var state = GetEntityState(e);
 		return (state && state.alertRaiser && state.alertRaiser.canIncreaseLevel);
 	});
 
 	Engine.PostNetworkCommand({ "type": "increase-alert-level", "entities": entities });
 }
 
 function endOfAlert()
 {
 	var entities = g_Selection.toList().filter(function(e) {
 		var state = GetEntityState(e);
 		return (state && state.alertRaiser && state.alertRaiser.hasRaisedAlert);
 	});
 
 	Engine.PostNetworkCommand({ "type": "alert-end", "entities": entities });
 }
 
 function clearSelection()
 {
 	if(inputState==INPUT_BUILDING_PLACEMENT || inputState==INPUT_BUILDING_WALL_PATHING)
 	{
 		inputState = INPUT_NORMAL;
 		placementSupport.Reset();
 	}
 	else
 		g_Selection.reset();
 	preSelectedAction = ACTION_NONE;
 }
 
 /**
  * Returns a list of all items in the productionqueue of the selection
  * @param selection List with entity ids
  */
 function getTrainingQueueItems(selection)
 {
 	var entStates = [];
 	for (var ent of selection)
 	{
 		var entState = GetEntityState(ent);
 		if (entState.production)
 			entStates.push(entState);
 	}
 	var queue = [];
 	var i = 0;
 	do
 	{
 		var foundNewItems = false;
 		for (entState of entStates)
 		{
 			if (!entState.production.queue[i])
 				continue;
 			var item = entState.production.queue[i];
 			item.producingEnt = entState.id;
 			queue.push(item);
 			foundNewItems = true;
 		}
 		i++;
 	}
 	while (foundNewItems);
 	return queue;
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/selection_details.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/selection_details.js	(revision 17616)
+++ ps/trunk/binaries/data/mods/public/gui/session/selection_details.js	(revision 17617)
@@ -1,432 +1,423 @@
 function layoutSelectionSingle()
 {
 	Engine.GetGUIObjectByName("detailsAreaSingle").hidden = false;
 	Engine.GetGUIObjectByName("detailsAreaMultiple").hidden = true;
 }
 
 function layoutSelectionMultiple()
 {
 	Engine.GetGUIObjectByName("detailsAreaMultiple").hidden = false;
 	Engine.GetGUIObjectByName("detailsAreaSingle").hidden = true;
 }
 
 function getResourceTypeDisplayName(resourceType)
 {
 	let resourceCode = resourceType.generic;
 	if (resourceCode == "treasure")
 		return getLocalizedResourceName(resourceType.specific, "firstWord");
 	else
 		return getLocalizedResourceName(resourceCode, "firstWord");
 }
 
 // Fills out information that most entities have
 function displaySingle(entState)
 {
 	// Get general unit and player data
 	let template = GetTemplateData(entState.template);
 	let specificName = template.name.specific;
 	let genericName = template.name.generic;
 	// If packed, add that to the generic name (reduces template clutter)
 	if (genericName && template.pack && template.pack.state == "packed")
 		genericName = sprintf(translate("%(genericName)s — Packed"), { "genericName": genericName });
 	let playerState = g_Players[entState.player];
 
 	let civName = g_CivData[playerState.civ].Name;
 	let civEmblem = g_CivData[playerState.civ].Emblem;
 
 	let playerName = playerState.name;
 	let playerColor = playerState.color.r + " " + playerState.color.g + " " + playerState.color.b + " 128";
 
 	// Indicate disconnected players by prefixing their name
 	if (g_Players[entState.player].offline)
 		playerName = sprintf(translate("\\[OFFLINE] %(player)s"), { "player": playerName });
 
 	// Rank
 	if (entState.identity && entState.identity.rank && entState.identity.classes)
 	{
 		Engine.GetGUIObjectByName("rankIcon").tooltip = sprintf(translate("%(rank)s Rank"), {
 			"rank": translateWithContext("Rank", entState.identity.rank)
 		});
 		Engine.GetGUIObjectByName("rankIcon").sprite = getRankIconSprite(entState);
 		Engine.GetGUIObjectByName("rankIcon").hidden = false;
 	}
 	else
 	{
 		Engine.GetGUIObjectByName("rankIcon").hidden = true;
 		Engine.GetGUIObjectByName("rankIcon").tooltip = "";
 	}
 
 	// Hitpoints
 	Engine.GetGUIObjectByName("healthSection").hidden = !entState.hitpoints;
 	if (entState.hitpoints)
 	{
 		let unitHealthBar = Engine.GetGUIObjectByName("healthBar");
 		let healthSize = unitHealthBar.size;
 		healthSize.rright = 100*Math.max(0, Math.min(1, entState.hitpoints / entState.maxHitpoints));
 		unitHealthBar.size = healthSize;
 
 		if (entState.foundation && entState.visibility == "visible" && entState.foundation.numBuilders !== 0)
 		{
 			// logic comes from Foundation component.
 			let speed = Math.pow(entState.foundation.numBuilders, 0.7);
 			let timeLeft = (1.0 - entState.foundation.progress / 100.0) * template.cost.time;
 			let timeToCompletion = Math.ceil(timeLeft/speed);
 			Engine.GetGUIObjectByName("health").tooltip = sprintf(translatePlural("This foundation will be completed in %(seconds)s second.", "This foundation will be completed in %(seconds)s seconds.", timeToCompletion), { "seconds": timeToCompletion });
 		}
 		else
 			Engine.GetGUIObjectByName("health").tooltip = "";
 
 		Engine.GetGUIObjectByName("healthStats").caption = sprintf(translate("%(hitpoints)s / %(maxHitpoints)s"), {
 			"hitpoints": Math.ceil(entState.hitpoints),
 			"maxHitpoints": entState.maxHitpoints
 		});
 	}
 
 	// CapturePoints
 	Engine.GetGUIObjectByName("captureSection").hidden = !entState.capturePoints;
 	if (entState.capturePoints)
 	{
 		let setCaptureBarPart = function(playerID, startSize) {
 			let unitCaptureBar = Engine.GetGUIObjectByName("captureBar["+playerID+"]");
 			let sizeObj = unitCaptureBar.size;
 			sizeObj.rleft = startSize;
 
 			let size = 100*Math.max(0, Math.min(1, entState.capturePoints[playerID] / entState.maxCapturePoints));
 			sizeObj.rright = startSize + size;
 			unitCaptureBar.size = sizeObj;
 			unitCaptureBar.sprite = "color: " + rgbToGuiColor(g_Players[playerID].color, 128);
 			unitCaptureBar.hidden=false;
 			return startSize + size;
 		};
 
 		// first handle the owner's points, to keep those points on the left for clarity
 		let size = setCaptureBarPart(entState.player, 0);
 
 		for (let i in entState.capturePoints)
 			if (i != entState.player)
 				size = setCaptureBarPart(i, size);
 
 		Engine.GetGUIObjectByName("captureStats").caption = sprintf(translate("%(capturePoints)s / %(maxCapturePoints)s"), {
 			"capturePoints": Math.ceil(entState.capturePoints[entState.player]),
 			"maxCapturePoints": entState.maxCapturePoints
 		});
 	}
 
 	// TODO: Stamina
 
 	// Experience
 	Engine.GetGUIObjectByName("experience").hidden = !entState.promotion;
 	if (entState.promotion)
 	{
 		let experienceBar = Engine.GetGUIObjectByName("experienceBar");
 		let experienceSize = experienceBar.size;
 		experienceSize.rtop = 100 - (100 * Math.max(0, Math.min(1, 1.0 * +entState.promotion.curr / +entState.promotion.req)));
 		experienceBar.size = experienceSize;
  
 		if (entState.promotion.curr < entState.promotion.req)
 			Engine.GetGUIObjectByName("experience").tooltip = sprintf(translate("%(experience)s %(current)s / %(required)s"), {
 				"experience": "[font=\"sans-bold-13\"]" + translate("Experience:") + "[/font]",
 				"current": Math.floor(entState.promotion.curr),
 				"required": entState.promotion.req
 			});
 		else
 			Engine.GetGUIObjectByName("experience").tooltip = sprintf(translate("%(experience)s %(current)s"), {
 				"experience": "[font=\"sans-bold-13\"]" + translate("Experience:") + "[/font]",
 				"current": Math.floor(entState.promotion.curr)
 			});
 	}
 
 	// Resource stats
 	Engine.GetGUIObjectByName("resourceSection").hidden = !entState.resourceSupply;
 	if (entState.resourceSupply)
 	{
 		let resources = entState.resourceSupply.isInfinite ? translate("∞") :  // Infinity symbol
 						sprintf(translate("%(amount)s / %(max)s"), {
 							"amount": Math.ceil(+entState.resourceSupply.amount),
 							"max": entState.resourceSupply.max
 						});
 
 		let resourceType = getResourceTypeDisplayName(entState.resourceSupply.type);
 
 		let unitResourceBar = Engine.GetGUIObjectByName("resourceBar");
 		let resourceSize = unitResourceBar.size;
 
 		resourceSize.rright = entState.resourceSupply.isInfinite ? 100 :
 						100 * Math.max(0, Math.min(1, +entState.resourceSupply.amount / +entState.resourceSupply.max));
 		unitResourceBar.size = resourceSize;
 		Engine.GetGUIObjectByName("resourceLabel").caption = sprintf(translate("%(resource)s:"), { "resource": resourceType });
 		Engine.GetGUIObjectByName("resourceStats").caption = resources;
 
 		if (entState.hitpoints)
 			Engine.GetGUIObjectByName("resourceSection").size = Engine.GetGUIObjectByName("captureSection").size;
 		else
 			Engine.GetGUIObjectByName("resourceSection").size = Engine.GetGUIObjectByName("healthSection").size;
 	}
 
 	// Resource carrying
 	if (entState.resourceCarrying && entState.resourceCarrying.length)
 	{
 		// We should only be carrying one resource type at once, so just display the first
 		let carried = entState.resourceCarrying[0];
 
 		Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingIcon").sprite = "stretched:session/icons/resources/"+carried.type+".png";
 		Engine.GetGUIObjectByName("resourceCarryingText").caption = sprintf(translate("%(amount)s / %(max)s"), { "amount": carried.amount, "max": carried.max });
 		Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = "";
 	}
 	// Use the same indicators for traders
 	else if (entState.trader && entState.trader.goods.amount)
 	{
 		Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingIcon").sprite = "stretched:session/icons/resources/"+entState.trader.goods.type+".png";
 		let totalGain = entState.trader.goods.amount.traderGain;
 		if (entState.trader.goods.amount.market1Gain)
 			totalGain += entState.trader.goods.amount.market1Gain;
 		if (entState.trader.goods.amount.market2Gain)
 			totalGain += entState.trader.goods.amount.market2Gain;
 		Engine.GetGUIObjectByName("resourceCarryingText").caption = totalGain;
 		Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = sprintf(translate("Gain: %(gain)s"), { "gain": getTradingTooltip(entState.trader.goods.amount) });
 	}
 	// And for number of workers
 	else if (entState.foundation && entState.visibility == "visible")
 	{
 		Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingIcon").sprite = "stretched:session/icons/repair.png";
 		Engine.GetGUIObjectByName("resourceCarryingText").caption = entState.foundation.numBuilders + "    ";
 		if (entState.foundation.numBuilders !== 0)
 		{
 			let speedup = Math.pow((entState.foundation.numBuilders+1)/entState.foundation.numBuilders, 0.7);
 			let timeLeft = (1.0 - entState.foundation.progress / 100.0) * template.cost.time;
 			let timeSpeedup = Math.ceil(timeLeft - timeLeft/speedup);
 			Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = sprintf(translatePlural("Number of builders.\nTasking another to this foundation would speed construction up by %(speedup)s second.", "Number of builders.\nTasking another to this foundation would speed construction up by %(speedup)s seconds.", timeSpeedup), { "speedup": timeSpeedup });
 		}
 		else
 			Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = translate("Number of builders.");
 	}
 	else if (entState.repairable && entState.repairable.numBuilders > 0 && entState.visibility == "visible")
 	{
 		Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingIcon").sprite = "stretched:session/icons/repair.png";
 		Engine.GetGUIObjectByName("resourceCarryingText").caption = entState.repairable.numBuilders + "    ";
 		Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = translate("Number of builders.");
 	}
 	else if (entState.resourceSupply && (!entState.resourceSupply.killBeforeGather || !entState.hitpoints) && entState.visibility == "visible")
 	{
 		Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;
 		Engine.GetGUIObjectByName("resourceCarryingIcon").sprite = "stretched:session/icons/repair.png";
 		Engine.GetGUIObjectByName("resourceCarryingText").caption = sprintf(translate("%(amount)s / %(max)s"), {
 			"amount": entState.resourceSupply.numGatherers,
 			"max": entState.resourceSupply.maxGatherers
 		}) + "    ";
 		Engine.GetGUIObjectByName("resourceCarryingIcon").tooltip = translate("Current/max gatherers");
 	}
 	else
 	{
 		Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = true;
 		Engine.GetGUIObjectByName("resourceCarryingText").hidden = true;
 	}
 
 	// Set Player details
 	Engine.GetGUIObjectByName("specific").caption = specificName;
 	Engine.GetGUIObjectByName("player").caption = playerName;
 	Engine.GetGUIObjectByName("playerColorBackground").sprite = "color: " + playerColor;
 	
 	if (genericName !== specificName)
 		Engine.GetGUIObjectByName("generic").caption = sprintf(translate("(%(genericName)s)"), { "genericName": genericName });
 	else
 		Engine.GetGUIObjectByName("generic").caption = "";
 
 	if ("gaia" != playerState.civ)
 	{
 		Engine.GetGUIObjectByName("playerCivIcon").sprite = "stretched:grayscale:" + civEmblem;
 		Engine.GetGUIObjectByName("player").tooltip = civName;
 	}
 	else
 	{
 		Engine.GetGUIObjectByName("playerCivIcon").sprite = "";
 		Engine.GetGUIObjectByName("player").tooltip = "";
 	}
 
 	// Icon image
 	// TODO: we should require all entities to have icons
 	Engine.GetGUIObjectByName("icon").sprite = template.icon ? ("stretched:session/portraits/" + template.icon) : "bkFillBlack";
 
 	let armorString = getArmorTooltip(entState.armour);
 
 	// Attack and Armor
 	Engine.GetGUIObjectByName("attackAndArmorStats").tooltip = entState.attack ? (getAttackTooltip(entState) + "\n" + armorString) : armorString;
 
 	// Repair Rate
 	if (entState.repairRate)
 		Engine.GetGUIObjectByName("attackAndArmorStats").tooltip += getRepairRateTooltip(entState.repairRate);
 
 	// Build Rate
 	if (entState.buildRate)
 		Engine.GetGUIObjectByName("attackAndArmorStats").tooltip += getBuildRateTooltip(entState.buildRate);
 
 	// Icon Tooltip
 	let iconTooltip = "";
 
 	if (genericName)
 		iconTooltip = "[font=\"sans-bold-16\"]" + genericName + "[/font]";
 
 	if (template.visibleIdentityClasses && template.visibleIdentityClasses.length)
 	{
 		iconTooltip += "\n[font=\"sans-bold-13\"]" + translate("Classes:") + "[/font] ";
 		iconTooltip += "[font=\"sans-13\"]" + translate(template.visibleIdentityClasses[0]) ;
 		for (let i = 1; i < template.visibleIdentityClasses.length; i++)
 			iconTooltip += ", " + translate(template.visibleIdentityClasses[i]);
 		iconTooltip += "[/font]";
 	}
 
 	if (template.auras)
 		iconTooltip += getAurasTooltip(template);
 
 	if (template.tooltip)
 		iconTooltip += "\n[font=\"sans-13\"]" + template.tooltip + "[/font]";
 
 	Engine.GetGUIObjectByName("iconBorder").tooltip = iconTooltip;
 
 	// Unhide Details Area
 	Engine.GetGUIObjectByName("detailsAreaSingle").hidden = false;
 	Engine.GetGUIObjectByName("detailsAreaMultiple").hidden = true;
 }
 
 // Fills out information for multiple entities
 function displayMultiple(selection)
 {
 	let averageHealth = 0;
 	let maxHealth = 0;
 	let maxCapturePoints = 0;
 	let capturePoints = (new Array(9)).fill(0);
 	let playerID = 0;
 
 	for (let i = 0; i < selection.length; i++)
 	{
 		let entState = GetEntityState(selection[i]);
 		if (!entState)
 			continue;
 		playerID = entState.player; // trust that all selected entities have the same owner
 		if (entState.hitpoints)
 		{
 			averageHealth += entState.hitpoints;
 			maxHealth += entState.maxHitpoints;
 		}
 		if (entState.capturePoints)
 		{
 			maxCapturePoints += entState.maxCapturePoints;
 			capturePoints = entState.capturePoints.map((v, i) => v + capturePoints[i]);
 		}
 	}
 
 	Engine.GetGUIObjectByName("healthMultiple").hidden = averageHealth <= 0;
 	if (averageHealth > 0)
 	{
 		let unitHealthBar = Engine.GetGUIObjectByName("healthBarMultiple");
 		let healthSize = unitHealthBar.size;
 		healthSize.rtop = 100-100*Math.max(0, Math.min(1, averageHealth / maxHealth));
 		unitHealthBar.size = healthSize;
 
 		Engine.GetGUIObjectByName("healthMultiple").tooltip = sprintf(translate("%(label)s %(current)s / %(max)s"), {
 			"label": "[font=\"sans-bold-13\"]" + translate("Hitpoints:") + "[/font]",
 			"current": averageHealth,
 			"max": maxHealth
 		});
 	}
 
 	Engine.GetGUIObjectByName("captureMultiple").hidden = maxCapturePoints <= 0;
 	if (maxCapturePoints > 0)
 	{
 		let setCaptureBarPart = function(playerID, startSize)
 		{
 			let unitCaptureBar = Engine.GetGUIObjectByName("captureBarMultiple["+playerID+"]");
 			let sizeObj = unitCaptureBar.size;
 			sizeObj.rtop = startSize;
 
 			let size = 100*Math.max(0, Math.min(1, capturePoints[playerID] / maxCapturePoints));
 			sizeObj.rbottom = startSize + size;
 			unitCaptureBar.size = sizeObj;
 			unitCaptureBar.sprite = "color: " + rgbToGuiColor(g_Players[playerID].color, 128);
 			unitCaptureBar.hidden=false;
 			return startSize + size;
 		};
 
 		let size = 0;
 		for (let i in capturePoints)
 			if (i != playerID)
 				size = setCaptureBarPart(i, size);
 
 		// last handle the owner's points, to keep those points on the bottom for clarity
 		setCaptureBarPart(playerID, size);
 
 		Engine.GetGUIObjectByName("captureMultiple").tooltip = sprintf(translate("%(label)s %(current)s / %(max)s"), {
 			"label": "[font=\"sans-bold-13\"]" + translate("Capture points:") + "[/font]",
 			"current": Math.ceil(capturePoints[playerID]),
 			"max": Math.ceil(maxCapturePoints)
 		});
 	}
 
 	// TODO: Stamina
 	// Engine.GetGUIObjectByName("staminaBarMultiple");
 
 	Engine.GetGUIObjectByName("numberOfUnits").caption = selection.length;
 
 	// Unhide Details Area
 	Engine.GetGUIObjectByName("detailsAreaMultiple").hidden = false;
 	Engine.GetGUIObjectByName("detailsAreaSingle").hidden = true;
 }
 
 // Updates middle entity Selection Details Panel
 function updateSelectionDetails()
 {
 	let supplementalDetailsPanel = Engine.GetGUIObjectByName("supplementalSelectionDetails");
 	let detailsPanel = Engine.GetGUIObjectByName("selectionDetails");
 	let commandsPanel = Engine.GetGUIObjectByName("unitCommands");
 
 	let selection = g_Selection.toList();
 
 	if (selection.length == 0)
 	{
 		Engine.GetGUIObjectByName("detailsAreaMultiple").hidden = true;
 		Engine.GetGUIObjectByName("detailsAreaSingle").hidden = true;
 		hideUnitCommands();
 
 		supplementalDetailsPanel.hidden = true;
 		detailsPanel.hidden = true;
 		commandsPanel.hidden = true;
 		return;
 	}
 
 	/* If the unit has no data (e.g. it was killed), don't try displaying any
 	 data for it. (TODO: it should probably be removed from the selection too;
 	 also need to handle multi-unit selections) */
 	let entState = GetExtendedEntityState(selection[0]);
 	if (!entState)
 		return;
 
 	// Fill out general info and display it
 	if (selection.length == 1)
 		displaySingle(entState);
 	else
 		displayMultiple(selection);
 
 	// Show basic details.
 	detailsPanel.hidden = false;
 
-	if (g_IsObserver)
-	{
-		// Observers don't need these displayed.
-		supplementalDetailsPanel.hidden = true;
-		commandsPanel.hidden = true;
-	}
-	else
-	{
-		// Fill out commands panel for specific unit selected (or first unit of primary group)
-		updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection);
-	}
+	// Fill out commands panel for specific unit selected (or first unit of primary group)
+	updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection);
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/selection_panels.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/selection_panels.js	(revision 17616)
+++ ps/trunk/binaries/data/mods/public/gui/session/selection_panels.js	(revision 17617)
@@ -1,1142 +1,1179 @@
 /**
  * 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 
  * var data = {
  *   "i":              index
  *   "item":           item coming from the getItems function
  *   "selection":      list of currently selected items
  *   "playerState":    playerState
  *   "unitEntState":   first selected entity state
  *   "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, addData is called, and can be used to abort the processing 
  * of the current item by returning false. 
  * It should return true if you want the panel to be filled.
  *
  * addData is used to add data to the data object on top 
  * (or instead of) the standard data.
  * addData is not obligated, the function will just continue
  * with the content setters if no addData is present.
  * 
  * After the addData, all functions starting with "set" are called. 
  * These are used to set various parts of content.
  */
 
 /* cache some formation info */
 var g_availableFormations = new Map();   // available formations per player
 var g_formationsInfo = new Map();
 
 var g_SelectionPanels = {};
 
 // ALERT
 g_SelectionPanels.Alert = {
 	"getMaxNumberOfItems": function()
 	{
 		return 2;
 	},
 	"getItems": function(unitEntState)
 	{
 		if (!unitEntState.alertRaiser)
 			return [];
 		return ["increase", "end"];
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { 
 			if (data.item == "increase")
 				increaseAlertLevel();
 			else if (data.item == "end")
 				endOfAlert();
 		};
 	},
 	"setTooltip": function(data)
 	{
 		if (data.item == "increase")
 		{
 			if (data.unitEntState.alertRaiser.hasRaisedAlert)
 				data.button.tooltip = translate("Increase the alert level to protect more units");
 			else
 				data.button.tooltip = translate("Raise an alert!");
 		}
 		else if (data.item == "end")
 			data.button.tooltip = translate("End of alert.");
 	},
 	"setGraphics": function(data)
 	{
 		if (data.item == "increase")
 		{
 			data.button.hidden = !data.unitEntState.alertRaiser.canIncreaseLevel;
 			if (data.unitEntState.alertRaiser.hasRaisedAlert)
 				data.icon.sprite = "stretched:session/icons/bell_level2.png";
 			else
 				data.icon.sprite = "stretched:session/icons/bell_level1.png";
 		}
 		else if (data.item == "end")
 		{
 			data.button.hidden = !data.unitEntState.alertRaiser.hasRaisedAlert;
 			data.icon.sprite = "stretched:session/icons/bell_level0.png";
 		}
-		data.button.enabled = !data.button.hidden;
+		data.button.enabled = !data.button.hidden && controlsPlayer(data.unitEntState.player);
 	},
 };
 
 // BARTER
 g_SelectionPanels.Barter = {
 	"getMaxNumberOfItems": function()
 	{
 		return 4;
 	},
 	"rowLength": 4,
 	"getItems": function(unitEntState, selection)
 	{
 		if (!unitEntState.barterMarket)
 			return [];
 		// ["food", "wood", "stone", "metal"]
 		return BARTER_RESOURCES;
 	},
 	"addData": function(data)
 	{
 		// data.item is the resource name in this case
 		data.button = {};
 		data.icon = {};
 		data.amount = {};
 		for (var a of BARTER_ACTIONS)
 		{
 			data.button[a] = Engine.GetGUIObjectByName("unitBarter"+a+"Button["+data.i+"]");
 			data.icon[a] = Engine.GetGUIObjectByName("unitBarter"+a+"Icon["+data.i+"]");
 			data.amount[a] = Engine.GetGUIObjectByName("unitBarter"+a+"Amount["+data.i+"]");
 		}
 		data.selectionIcon = Engine.GetGUIObjectByName("unitBarterSellSelection["+data.i+"]");
 
 		data.amountToSell = BARTER_RESOURCE_AMOUNT_TO_SELL;
 		if (Engine.HotkeyIsPressed("session.massbarter"))
 			data.amountToSell *= BARTER_BUNCH_MULTIPLIER;
 		data.isSelected = data.item == g_barterSell;
 		return true;
 	},
 	"setCountDisplay": function(data)
 	{
 		data.amount.Sell.caption = "-" + data.amountToSell;
 		var sellPrice = data.unitEntState.barterMarket.prices["sell"][g_barterSell];
 		var buyPrice = data.unitEntState.barterMarket.prices["buy"][data.item];
 		data.amount.Buy.caption = "+" + Math.round(sellPrice / buyPrice * data.amountToSell);
 	},
 	"setTooltip": function(data)
 	{
 		var resource = getLocalizedResourceName(data.item, "withinSentence");
 		data.button.Buy.tooltip = sprintf(translate("Buy %(resource)s"), {"resource": resource});
 		data.button.Sell.tooltip = sprintf(translate("Sell %(resource)s"), {"resource": resource});
 	},
 	"setAction": function(data)
 	{
 		data.button.Sell.onPress = function() { g_barterSell = data.item; };
 		var exchangeResourcesParameters = {
 			"sell": g_barterSell,
 			"buy": data.item,
 			"amount": data.amountToSell
 		};
 		data.button.Buy.onPress = function() { exchangeResources(exchangeResourcesParameters); };
 	},
 	"setGraphics": function(data)
 	{
 		var grayscale = data.isSelected ? "color: 0 0 0 100:grayscale:" : "";
 
 		// do we have enough of this resource to sell?
 		var neededRes = {};
 		neededRes[data.item] = data.amountToSell;
-		var canSellCurrent = Engine.GuiInterfaceCall("GetNeededResources", neededRes) != undefined ? "color:255 0 0 80:" : "";
+		var canSellCurrent = Engine.GuiInterfaceCall("GetNeededResources", {
+			"cost": neededRes,
+			"player": data.unitEntState.player
+		}) ? "color:255 0 0 80:" : "";
+
 		// Let's see if we have enough resources to barter.
 		neededRes = {};
 		neededRes[g_barterSell] = data.amountToSell;
-		var canBuyAny = Engine.GuiInterfaceCall("GetNeededResources", neededRes) != undefined ? "color:255 0 0 80:" : "";
+		var canBuyAny = Engine.GuiInterfaceCall("GetNeededResources", {
+			"cost": neededRes,
+			"player": data.unitEntState.player
+		}) ? "color:255 0 0 80:" : "";
 
 		data.icon.Sell.sprite = canSellCurrent + "stretched:"+grayscale+"session/icons/resources/" + data.item + ".png";
 		data.icon.Buy.sprite = canBuyAny + "stretched:"+grayscale+"session/icons/resources/" + data.item + ".png";
 
 		data.button.Buy.hidden = data.isSelected;
+		data.button.Buy.enabled = controlsPlayer(data.unitEntState.player);
 		data.button.Sell.hidden = false;
 		data.selectionIcon.hidden = !data.isSelected;
 	},
 	"setPosition": function(data)
 	{
 		setPanelObjectPosition(data.button.Sell, data.i, data.rowLength);
 		setPanelObjectPosition(data.button.Buy, data.i + data.rowLength, data.rowLength);
 	},
 },
 
 // COMMAND
 g_SelectionPanels.Command = {
 	"getMaxNumberOfItems": function()
 	{
 		return 6;
 	},
 	"getItems": function(unitEntState)
 	{
 		var commands = [];
 		for (var c in g_EntityCommands)
 		{
 			var info = g_EntityCommands[c].getInfo(unitEntState);
 			if (!info)
 				continue;
 			info.name = c;
 			commands.push(info);
 		}
 		return commands;
 	},
 	"setTooltip": function(data)
 	{
 		data.button.tooltip = data.item.tooltip;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { data.item.callback ? data.item.callback(data.item) : performCommand(data.unitEntState.id, data.item.name); };
 	},
 	"setCountDisplay": function(data)
 	{
 		data.countDisplay.caption = data.item.count || "";
 	},
 	"setGraphics": function(data)
 	{
 		data.icon.sprite = "stretched:session/icons/" + data.item.icon;
+		data.button.enabled = controlsPlayer(data.unitEntState.player);
 	},
 	"setPosition": function(data)
 	{
 		var size = data.button.size;
 		// count on square buttons, so size.bottom is the width too
 		var spacer = size.bottom + 1;
 		// relative to the center ( = 50%)
 		size.rleft = size.rright = 50;
 		// offset from the center calculation
 		size.left = (data.i - data.numberOfItems/2) * spacer;
 		size.right = size.left + size.bottom;
 		data.button.size = size;
 	},
 };
 
 //ALLY COMMAND
 g_SelectionPanels.AllyCommand = {
 	"getMaxNumberOfItems": function()
 	{
 		return 2;
 	},
 	"getItems": function(unitEntState)
 	{
 		var commands = [];
 		for (var c in g_AllyEntityCommands)
 		{
 			var info = g_AllyEntityCommands[c].getInfo(unitEntState);
 			if (!info)
 				continue;
 			info.name = c;
 			commands.push(info);
 		}
 		return commands;
 	},
 	"setTooltip": function(data)
 	{
 		data.button.tooltip = data.item.tooltip;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { data.item.callback ? data.item.callback(data.item) : performAllyCommand(data.unitEntState.id, data.item.name); };
 	},
 	"conflictsWith": ["Command"],
 	"setCountDisplay": function(data)
 	{
 		data.countDisplay.caption = data.item.count || "";
 	},
 	"setGraphics": function(data)
 	{
 		data.icon.sprite = "stretched:session/icons/" + data.item.icon;
+		data.button.enabled = data.item.count > 0;
 	},
 	"setPosition": function(data)
 	{
 		var size = data.button.size;
 		// count on square buttons, so size.bottom is the width too
 		var spacer = size.bottom + 1;
 		// relative to the center ( = 50%)
 		size.rleft = size.rright = 50;
 		// offset from the center calculation
 		size.left = (data.i - data.numberOfItems/2) * spacer;
 		size.right = size.left + size.bottom;
 		data.button.size = size;
 	},
 };
 
 // CONSTRUCTION
 g_SelectionPanels.Construction = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function()
 	{
 		return getAllBuildableEntitiesFromSelection();
 	},
 	"addData": function(data)
 	{
 		data.entType = data.item;
 		data.template = GetTemplateData(data.entType);
 		if (!data.template) // abort if no template
 			return false;
-		data.technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", data.template.requiredTechnology);
+
+		data.technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", {
+			"tech": data.template.requiredTechnology,
+			"player": data.unitEntState.player
+		});
+
 		if (data.template.cost)
-		{
-			var totalCost = multiplyEntityCosts(data.template, 1);
-			data.neededResources = Engine.GuiInterfaceCall("GetNeededResources", totalCost);
-		}
+			data.neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
+				"cost": multiplyEntityCosts(data.template, 1),
+				"player": data.unitEntState.player
+			});
+
 		data.limits = getEntityLimitAndCount(data.playerState, data.entType);
 		return true;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function () { startBuildingPlacement(data.item, data.playerState); };
 	},
 	"setTooltip": function(data)
 	{
 		var tooltip = getEntityNamesFormatted(data.template);
 		tooltip += getVisibleEntityClassesFormatted(data.template);
 
 		if (data.template.tooltip)
 			tooltip += "\n[font=\"sans-13\"]" + data.template.tooltip + "[/font]";
 
 		tooltip += "\n" + getEntityCostTooltip(data.template);
 		tooltip += getPopulationBonusTooltip(data.template);
 
 		tooltip += formatLimitString(data.limits.entLimit, data.limits.entCount, data.limits.entLimitChangers);
 		if (!data.technologyEnabled)
 		{
 			var techName = getEntityNames(GetTechnologyData(data.template.requiredTechnology));
 			tooltip += "\n" + sprintf(translate("Requires %(technology)s"), { technology: techName });
 		}
 		if (data.neededResources)
 			tooltip += getNeededResourcesTooltip(data.neededResources);
 		data.button.tooltip = tooltip;
 		return true;
 	},
 	"setGraphics": function(data)
 	{
 		var modifier = "";
 		if (!data.technologyEnabled || data.limits.canBeAddedCount == 0)
 		{
 			data.button.enabled = false;
 			modifier += "color: 0 0 0 127:";
 			modifier += "grayscale:";
 		}
 		else if (data.neededResources)
 		{
 			data.button.enabled = false;
 			modifier += resourcesToAlphaMask(data.neededResources) +":";
 		}
+		else
+			data.button.enabled = controlsPlayer(data.unitEntState.player);
 
 		if (data.template.icon)
 			data.icon.sprite = modifier + "stretched:session/portraits/" + data.template.icon;
 	},
 	"setPosition": function(data)
 	{
 		var index = data.i + getNumberOfRightPanelButtons();
 		setPanelObjectPosition(data.button, index, data.rowLength);
 	},
 };
 
 // FORMATION
 g_SelectionPanels.Formation = {
 	"getMaxNumberOfItems": function()
 	{
 		return 16;
 	},
 	"rowLength": 4,
 	"conflictsWith": ["Garrison"],
 	"getItems": function(unitEntState)
 	{
 		if (!hasClass(unitEntState, "Unit") || hasClass(unitEntState, "Animal"))
 			return [];
 		if (!g_availableFormations.has(unitEntState.player))
 			g_availableFormations.set(unitEntState.player, Engine.GuiInterfaceCall("GetAvailableFormations", unitEntState.player));
 		return g_availableFormations.get(unitEntState.player);
 	},
 	"addData": function(data)
 	{
 		if (!g_formationsInfo.has(data.item))
 			g_formationsInfo.set(data.item, Engine.GuiInterfaceCall("GetFormationInfoFromTemplate", {"templateName": data.item}));
 		data.formationInfo = g_formationsInfo.get(data.item);
 		data.formationOk = canMoveSelectionIntoFormation(data.item);
 		data.formationSelected = Engine.GuiInterfaceCall("IsFormationSelected", {
 			"ents": data.selection,
 			"formationTemplate": data.item
 		});
 		return true;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { performFormation(data.unitEntState.id, data.item); };
 	},
 	"setTooltip": function(data)
 	{
 		var tooltip = translate(data.formationInfo.name);
 		if (!data.formationOk && data.formationInfo.tooltip)
 			tooltip += "\n" + "[color=\"red\"]" + translate(data.formationInfo.tooltip) + "[/color]";
 		data.button.tooltip = tooltip;
 	},
 	"setGraphics": function(data)
 	{
-		data.button.enabled = data.formationOk;
+		data.button.enabled = data.formationOk && controlsPlayer(data.unitEntState.player);
 		var grayscale = data.formationOk ? "" : "grayscale:";
 		data.guiSelection.hidden = !data.formationSelected;
 		data.icon.sprite = "stretched:"+grayscale+"session/icons/"+data.formationInfo.icon;
 	},
 };
 
 // GARRISON
 g_SelectionPanels.Garrison = {
 	"getMaxNumberOfItems": function()
 	{
 		return 12;
 	},
 	"rowLength": 4,
 	"getItems": function(unitEntState, selection)
 	{
 		if (!unitEntState.garrisonHolder)
 			return [];
 		var groups = new EntityGroups();
 		for (var ent of selection)
 		{
 			var state = GetEntityState(ent);
 			if (state.garrisonHolder)
 				groups.add(state.garrisonHolder.entities);
 		}
 		return groups.getEntsGrouped();
 	},
 	"addData": function(data)
 	{
 		data.entType = data.item.template;
 		data.template = GetTemplateData(data.entType);
 		if (!data.template)
 			return false;
 		data.name = getEntityNames(data.template);
 		data.count = data.item.ents.length;
 		return true;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { unloadTemplate(data.item.template); };
 	},
 	"setTooltip": function(data)
 	{
 		var tooltip = sprintf(translate("Unload %(name)s"), { name: data.name }) + "\n";
 		tooltip += translate("Single-click to unload 1. Shift-click to unload all of this type.");
 		data.button.tooltip = tooltip;
 	},
 	"setCountDisplay": function(data)
 	{
 		data.countDisplay.caption = data.count || "";
 	},
 	"setGraphics": function(data)
 	{
 		var grayscale = "";
 		var ents = data.item.ents;
 		var entplayer = GetEntityState(ents[0]).player;
 		data.button.sprite = "color:" + rgbToGuiColor(g_Players[entplayer].color) +":";
 
-		var player = Engine.GetPlayerID();
-		if(player != data.unitEntState.player && !g_DevSettings.controlAll)
+		if (!controlsPlayer(data.unitEntState.player) && !controlsPlayer(entplayer))
 		{
-			if (entplayer != player)
-			{
-				data.button.enabled = false;
-				grayscale = "grayscale:";
-			}
+			data.button.enabled = false;
+			grayscale = "grayscale:";
 		}
+
 		data.icon.sprite = "stretched:" + grayscale + "session/portraits/" + data.template.icon;
 	},
 };
 
 // GATE
 g_SelectionPanels.Gate = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function(unitEntState, selection)
 	{
 		// Allow long wall pieces to be converted to gates
 		var longWallTypes = {};
 		var walls = [];
 		var gates = [];
 		for (var ent of selection)
 		{
 			var state = GetEntityState(ent);
 			if (hasClass(state, "LongWall") && !state.gate && !longWallTypes[state.template])
 			{
 				var gateTemplate = getWallGateTemplate(state.id);
 				if (gateTemplate)
 				{
 					var tooltipString = GetTemplateDataWithoutLocalization(state.template).gateConversionTooltip;
 					if (!tooltipString)
 					{
 						warn(state.template + " is supposed to be convertable to a gate, but it's missing the GateConversionTooltip in the Identity template");
 						tooltipString = "";
 					}
 					walls.push({
 						"tooltip": translate(tooltipString),
 						"template": gateTemplate,
 						"callback": function (item) { transformWallToGate(item.template); }
 					});
 				}
 
 				// We only need one entity per type.
 				longWallTypes[state.template] = true;
 			}
 			else if (state.gate && !gates.length)
 			{
 				gates.push({
 					"gate": state.gate,
 					"tooltip": translate("Lock Gate"),
 					"locked": true,
 					"callback": function (item) { lockGate(item.locked); }
 				});
 				gates.push({
 					"gate": state.gate,
 					"tooltip": translate("Unlock Gate"),
 					"locked": false,
 					"callback": function (item) { lockGate(item.locked); }
 				});
 			}
 			// Show both 'locked' and 'unlocked' as active if the selected gates have both lock states.
 			else if (state.gate && state.gate.locked != gates[0].gate.locked)
 				for (var j = 0; j < gates.length; ++j)
 					delete gates[j].gate.locked;
 		}
 
 		// Place wall conversion options after gate lock/unlock icons.
 		var items = gates.concat(walls);
 		return items;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() {data.item.callback(data.item); };
 	},
 	"setTooltip": function(data)
 	{
 		var tooltip = data.item.tooltip;
 		if (data.item.template)
 		{
 			data.template = GetTemplateData(data.item.template);
 			data.wallCount = data.selection.reduce(function (count, ent) {
 					var state = GetEntityState(ent);
 					if (hasClass(state, "LongWall") && !state.gate)
 						count++;
 					return count;
 				}, 0);
 
 			tooltip += "\n" + getEntityCostTooltip(data.template, data.wallCount);
 
+			data.neededResources = Engine.GuiInterfaceCall("GetNeededResources", { "cost":
+				multiplyEntityCosts(data.template, data.wallCount) });
 
-			data.neededResources = Engine.GuiInterfaceCall("GetNeededResources", multiplyEntityCosts(data.template, data.wallCount));
 			if (data.neededResources)
 				tooltip += getNeededResourcesTooltip(data.neededResources);
 		}
 		data.button.tooltip = tooltip;
 	},
 	"setGraphics": function(data)
 	{
+		data.button.enabled = controlsPlayer(data.unitEntState.player);
 		var gateIcon;
 		if (data.item.gate)
 		{
 			// If already a gate, show locking actions
 			gateIcon = "icons/lock_" + GATE_ACTIONS[data.item.locked ? 0 : 1] + "ed.png";
 			if (data.item.gate.locked === undefined)
 				data.guiSelection.hidden = false;
 			else
 				data.guiSelection.hidden = data.item.gate.locked != data.item.locked;
 		}
 		else
 		{
 			// otherwise show gate upgrade icon
 			var template = GetTemplateData(data.item.template);
 			if (!template)
 				return;
 			gateIcon = data.template.icon ? "portraits/" + data.template.icon : "icons/gate_closed.png";
 			data.guiSelection.hidden = true;
 		}
 
 		data.icon.sprite = (data.neededResources ? resourcesToAlphaMask(data.neededResources) + ":" : "") + "stretched:session/" + gateIcon;
 	},
 	"setPosition": function(data)
 	{
 		var index = data.i + getNumberOfRightPanelButtons();
 		setPanelObjectPosition(data.button, index, data.rowLength);
 	},
 };
 
 // PACK
 g_SelectionPanels.Pack = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function(unitEntState, selection)
 	{
 		var checks = {};
 		for (var ent of selection)
 		{
 			var state = GetEntityState(ent);
 			if (!state.pack)
 				continue;
 			if (state.pack.progress == 0)
 			{
 				if (!state.pack.packed)
 					checks.packButton = true;
 				else if (state.pack.packed)
 					checks.unpackButton = true;
 			}
 			else
 			{
 				// Already un/packing - show cancel button
 				if (!state.pack.packed)
 					checks.packCancelButton = true;
 				else if (state.pack.packed)
 					checks.unpackCancelButton = true;
 			}
 		}
 		var 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;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() {data.item.callback(data.item); };
 	},
 	"setTooltip": function(data)
 	{
 		data.button.tooltip = data.item.tooltip;
 	},
 	"setGraphics": function(data)
 	{
 		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.unitEntState.player);
 	},
 	"setPosition": function(data)
 	{
 		var index = data.i + getNumberOfRightPanelButtons();
 		setPanelObjectPosition(data.button, index, data.rowLength);
 	},
 };
 
 // QUEUE
 g_SelectionPanels.Queue = {
 	"getMaxNumberOfItems": function()
 	{
 		return 16;
 	},
 	"getItems": function(unitEntState, selection)
 	{
 		return getTrainingQueueItems(selection);
 	},
 	"resizePanel": function(numberOfItems, rowLength)
 	{
 		var numRows = Math.ceil(numberOfItems / rowLength);
 		var panel = Engine.GetGUIObjectByName("unitQueuePanel");
 		var size = panel.size;
 		var buttonSize = Engine.GetGUIObjectByName("unitQueueButton[0]").size.bottom;
 		var margin = 4;
 		size.top = size.bottom - numRows*buttonSize - (numRows+2)*margin;
 		panel.size = size;
 	},
 	"addData": function(data)
 	{
 		// differentiate between units and techs
 		if (data.item.unitTemplate)
 		{
 			data.entType = data.item.unitTemplate;
 			data.template = GetTemplateData(data.entType);
 		}
 		else if (data.item.technologyTemplate)
 		{
 			data.entType = data.item.technologyTemplate;
 			data.template = GetTechnologyData(data.entType);
 		}
 		data.progress = Math.round(data.item.progress*100) + "%";
 
 		return data.template;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { removeFromProductionQueue(data.item.producingEnt, data.item.id); };
 	},
 	"setTooltip": function(data)
 	{
 		var tooltip = getEntityNames(data.template);
 		if (data.item.neededSlots)
 		{
 			tooltip += "\n[color=\"red\"]" + translate("Insufficient population capacity:") + "\n[/color]";
 			tooltip += sprintf(translate("%(population)s %(neededSlots)s"), { population: getCostComponentDisplayName("population"), neededSlots: data.item.neededSlots });
 		}
 		data.button.tooltip = tooltip;
 	},
 	"setCountDisplay": function(data)
 	{
 		data.countDisplay.caption = data.item.count > 1 ? data.item.count : "";
 	},
 	"setProgressDisplay": function(data)
 	{
 		// show the progress number for the first item
 		if (data.i == 0)
 			Engine.GetGUIObjectByName("queueProgress").caption = data.progress;
 
 		var guiObject = Engine.GetGUIObjectByName("unitQueueProgressSlider["+data.i+"]");
 		var 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(data.item.progress * (size.right - size.left));
 		guiObject.size = size;
 	},
 	"setGraphics": function(data)
 	{
 		if (data.template.icon)
 			data.icon.sprite = "stretched:session/portraits/" + data.template.icon;
+
+		data.button.enabled = controlsPlayer(data.unitEntState.player);
 	},
 };
 
 // RESEARCH
 g_SelectionPanels.Research = {
 	"getMaxNumberOfItems": function()
 	{
 		return 8;
 	},
 	"getItems": function(unitEntState, selection)
 	{
 		// TODO 8 is the row lenght, make variable
 		if (getNumberOfRightPanelButtons() > 8 && selection.length > 1)
 			return [];
 		for (var ent of selection)
 		{
 			var entState = GetEntityState(ent);
 			if (entState.production && entState.production.technologies.length)
 				return entState.production.technologies;
 		}
 		return [];
 	},
 	"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;
 	},
 	"addData": function(data)
 	{
 		data.entType = data.item.pair ? [data.item.top, data.item.bottom] : [data.item];
 		data.template = data.entType.map(GetTechnologyData);
 		// abort if no template found for any of the techs
 		if (!data.template.every(function(v) { return v; }))
 			return false;
 		// index one row below
 		var shiftedIndex = data.i + data.rowLength;
 		data.positions = data.item.pair ? [data.i, shiftedIndex] : [shiftedIndex];
 		data.positionsToHide = data.item.pair ? [] : [data.i];
 
 		// add top buttons to the data
 		data.button = data.positions.map(function(p) { 
 			return Engine.GetGUIObjectByName("unitResearchButton["+p+"]"); 
 		});
 
 		data.buttonsToHide = data.positionsToHide.map(function(p) { 
 			return Engine.GetGUIObjectByName("unitResearchButton["+p+"]"); 
 		});
 
 		data.icon = data.positions.map(function(p) { 
 			return Engine.GetGUIObjectByName("unitResearchIcon["+p+"]");
 		});
 
 		data.unchosenIcon = data.positions.map(function(p) { 
 			return Engine.GetGUIObjectByName("unitResearchUnchosenIcon["+p+"]");
 		});
 
 		data.neededResources = data.template.map(function(t) { 
-			return Engine.GuiInterfaceCall("GetNeededResources", t.cost);
+			return Engine.GuiInterfaceCall("GetNeededResources", {
+				"cost": t.cost,
+				"player": data.unitEntState.player
+			});
 		});
 
 		data.requirementsPassed = data.entType.map(function(e) { 
-			return Engine.GuiInterfaceCall("CheckTechnologyRequirements",e); 
+			return Engine.GuiInterfaceCall("CheckTechnologyRequirements", {
+				"tech": e,
+				"player": data.unitEntState.player
+			});
 		});
 
 		data.pair = Engine.GetGUIObjectByName("unitResearchPair["+data.i+"]");
 
 		return true;
 	},
 	"setTooltip": function(data)
 	{
 		for (var i in data.entType)
 		{
 			var tooltip = "";
 			var template = data.template[i];
 			tooltip = getEntityNamesFormatted(template);
 			if (template.tooltip)
 				tooltip += "\n[font=\"sans-13\"]" + template.tooltip + "[/font]";
 
 			tooltip += "\n" + getEntityCostTooltip(template);
 			if (!data.requirementsPassed[i])
 			{
 				tooltip += "\n" + template.requirementsTooltip;
 				if (template.classRequirements)
 				{
-					var player = Engine.GetPlayerID();
+					var player = data.unitEntState.player;
 					var current = GetSimState().players[player].classCounts[template.classRequirements.class] || 0;
 					var remaining = template.classRequirements.number - current;
 					tooltip += " " + sprintf(translatePlural("Remaining: %(number)s to build.", "Remaining: %(number)s to build.", remaining), { number: remaining});
 				}
 			}
 			if (data.neededResources[i])
 				tooltip += getNeededResourcesTooltip(data.neededResources[i]);
 			data.button[i].tooltip = tooltip;
 		}
 	},
 	"setAction": function(data)
 	{
 		for (var i in data.entType)
 		{
 			// array containing the indices other buttons
 			var others = Object.keys(data.template);
 			others.splice(i, 1);
 			var button = data.button[i];
 			// as we're in a loop, we need to limit the scope with a closure
 			// else the last value of the loop will be taken, rather than the current one
 			button.onpress = (function(template) { return function () { addResearchToQueue(data.unitEntState.id, template); }; })(data.entType[i]);
 			// on mouse enter, show a cross over the other icons
 			button.onmouseenter = (function(others, icons) {
 				return function() {
 					for (var j of others)
 						icons[j].hidden = false;
 				};
 			})(others, data.unchosenIcon);
 			button.onmouseleave = (function(others, icons) {
 				return function() {
 					for (var j of others)
 						icons[j].hidden = true;
 				};
 			})(others, data.unchosenIcon);
 		}
 	},
 	"setGraphics": function(data)
 	{
 		for (var i in data.entType)
 		{
 			var button = data.button[i];
 			button.hidden = false;
 			var modifier = "";
 			if (!data.requirementsPassed[i])
 			{
 				button.enabled = false;
 				modifier += "color: 0 0 0 127:";
 				modifier += "grayscale:";
 			}
 			else if (data.neededResources[i])
 			{
 				button.enabled = false;
 				modifier += resourcesToAlphaMask(data.neededResources[i]) + ":";
 			}
 			else
-				button.enabled = true; 
+				button.enabled = controlsPlayer(data.unitEntState.player);
 
 			if (data.template[i].icon)
 				data.icon[i].sprite = modifier + "stretched:session/portraits/" + data.template[i].icon;
 		}
 		for (var button of data.buttonsToHide)
 			button.hidden = true;
 		// show the tech connector
 		data.pair.hidden = data.item.pair == null;
 	},
 	"setPosition": function(data)
 	{
 		for (var i in data.button)
 			setPanelObjectPosition(data.button[i], data.positions[i], data.rowLength);
 		setPanelObjectPosition(data.pair, data.i, data.rowLength);
 	},
 };
 
 // SELECTION
 g_SelectionPanels.Selection = {
 	"getMaxNumberOfItems": function()
 	{
 		return 16;
 	},
 	"rowLength": 4,
 	"getItems": function(unitEntState, selection)
 	{
 		if (selection.length < 2)
 			return [];
 		return g_Selection.groups.getTemplateNames();
 	},
 	"addData": function(data)
 	{
 		data.entType = data.item;
 		data.template = GetTemplateData(data.entType);
 		if (!data.template)
 			return false;
 		data.name = getEntityNames(data.template);
 
 		var ents = g_Selection.groups.getEntsByName(data.item);
 		data.count = ents.length;
 		for (var ent of ents)
 		{
 			var state = GetEntityState(ent);
 
 			if (state.resourceCarrying && state.resourceCarrying.length !== 0)
 			{
 				if (!data.carried)
 					data.carried = {};
 				var 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 = {};
 				var amount = state.trader.goods.amount;
 				var type = state.trader.goods.type;
 				var 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;
 			}
 		}
 		return true;
 	},
 	"setTooltip": function(data)
 	{
 		if (data.carried)
 		{
 			var str = data.name + "\n";
 			var ress = ["food", "wood", "stone", "metal"];
 			for (var i = 0; i < 4; ++i)
 			{
 				if (data.carried[ress[i]])
 				{
 					str += getCostComponentDisplayName(ress[i]) + data.carried[ress[i]];
 					if (i !== 3)
 						str += " ";
 				}
 			}
 			data.button.tooltip = str;
 		}
 		else
 			data.button.tooltip = data.name;
 	},
 	"setCountDisplay": function(data)
 	{
 		data.countDisplay.caption = data.count || "";
 	},
 	"setAction": function(data)
 	{
 		data.button.onpressright = function() { changePrimarySelectionGroup(data.item, true); };
 		data.button.onpress = function() { changePrimarySelectionGroup(data.item, false); };
 	},
 	"setGraphics": function(data)
 	{
 		if (data.template.icon)
 			data.icon.sprite = "stretched:session/portraits/" + data.template.icon;
+
+		data.button.enabled = controlsPlayer(data.unitEntState.player);
 	},
 };
 
 // STANCE
 g_SelectionPanels.Stance = {
 	"getMaxNumberOfItems": function()
 	{
 		return 5;
 	},
 	"getItems": function(unitEntState)
 	{
 		if (!unitEntState.unitAI || !hasClass(unitEntState, "Unit") || hasClass(unitEntState, "Animal"))
 			return [];
 		return unitEntState.unitAI.possibleStances;
 	},
 	"addData": function(data)
 	{
 		data.stanceSelected = Engine.GuiInterfaceCall("IsStanceSelected", {
 			"ents": data.selection,
 			"stance": data.item
 		});
 		return true;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { performStance(data.unitEntState, data.item); };
 	},
 	"setTooltip": function(data)
 	{
 		data.button.tooltip = getStanceDisplayName(data.item);
 	},
 	"setGraphics": function(data)
 	{
 		data.guiSelection.hidden = !data.stanceSelected;
 		data.icon.sprite = "stretched:session/icons/stances/"+data.item+".png";
+		data.button.enabled = controlsPlayer(data.unitEntState.player);
 	},
 };
 
 // TRAINING
 g_SelectionPanels.Training = {
 	"getMaxNumberOfItems": function()
 	{
 		return 24 - getNumberOfRightPanelButtons();
 	},
 	"getItems": function()
 	{
 		return getAllTrainableEntitiesFromSelection();
 	},
 	"addData": function(data)
 	{
 		data.entType = data.item;
 		data.template = GetTemplateData(data.entType);
 		if (!data.template)
 			return false;
-		data.technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", data.template.requiredTechnology);
+
+		data.technologyEnabled = Engine.GuiInterfaceCall("IsTechnologyResearched", {
+			"tech": data.template.requiredTechnology,
+			"player": data.unitEntState.player
+		});
 
 		var [buildingsCountToTrainFullBatch, fullBatchSize, remainderBatch] =
 			getTrainingBatchStatus(data.playerState, data.unitEntState.id, data.entType, data.selection);
 		data.buildingsCountToTrainFullBatch = buildingsCountToTrainFullBatch;
 		data.fullBatchSize = fullBatchSize;
 		data.remainderBatch = remainderBatch;
 		data.trainNum = buildingsCountToTrainFullBatch || 1; // train at least one unit
 		if (Engine.HotkeyIsPressed("session.batchtrain"))
 			data.trainNum = buildingsCountToTrainFullBatch * fullBatchSize + remainderBatch;
 
 		if (data.template.cost)
 		{
 			var totalCosts = multiplyEntityCosts(data.template, data.trainNum);
-			data.neededResources = Engine.GuiInterfaceCall("GetNeededResources", totalCosts);
+			data.neededResources = Engine.GuiInterfaceCall("GetNeededResources", {
+				"cost": totalCosts,
+				"player": data.unitEntState.player
+			});
 		}
 
 		return true;
 	},
 	"setAction": function(data)
 	{
 		data.button.onPress = function() { addTrainingToQueue(data.selection, data.item, data.playerState); };
 	},
 	"setCountDisplay": function(data)
 	{
 		var count = data.trainNum > 1 ? data.trainNum : "";
 		data.countDisplay.caption = count;
 	},
 	"setTooltip": function(data)
 	{
 		var tooltip = "";
 		var key = Engine.ConfigDB_GetValue("user", "hotkey.session.queueunit." + (data.i + 1));
 		if (key)
 			tooltip += "[color=\"255 251 131\"][font=\"sans-bold-16\"]\\[" + key + "][/font][/color] ";
 
 		tooltip += getEntityNamesFormatted(data.template);
 		tooltip += getVisibleEntityClassesFormatted(data.template);
 
 		if (data.template.auras)
 		{
 			for (var auraName in data.template.auras)
 			{
 				tooltip += "\n[font=\"sans-bold-13\"]" + translate(auraName) + "[/font]";
 				if (data.template.auras[auraName])
 					tooltip += ": " + translate(data.template.auras[auraName]);
 			}
 		}
 
 		if (data.template.tooltip)
 			tooltip += "\n[font=\"sans-13\"]" + data.template.tooltip + "[/font]";
 
 		tooltip += "\n" + getEntityCostTooltip(data.template, data.trainNum, data.unitEntState.id);
 
 		data.limits = getEntityLimitAndCount(data.playerState, data.entType);
 
 		tooltip += formatLimitString(data.limits.entLimit, data.limits.entCount, data.limits.entLimitChangers);
 		if (Engine.ConfigDB_GetValue("user", "showdetailedtooltips") === "true")
 		{
 			if (data.template.health)
 				tooltip += "\n[font=\"sans-bold-13\"]" + translate("Health:") + "[/font] " + data.template.health;
 			if (data.template.attack)
 				tooltip += "\n" + getAttackTooltip(data.template);
 			if (data.template.armour)
 				tooltip += "\n" + getArmorTooltip(data.template.armour);
 			if (data.template.speed)
 				tooltip += "\n" + getSpeedTooltip(data.template);
 		}
 		tooltip += "[color=\"255 251 131\"]" + formatBatchTrainingString(data.buildingsCountToTrainFullBatch, data.fullBatchSize, data.remainderBatch) + "[/color]";
 		if (!data.technologyEnabled)
 		{
 			var techName = getEntityNames(GetTechnologyData(data.template.requiredTechnology));
 			tooltip += "\n" + sprintf(translate("Requires %(technology)s"), { technology: techName });
 		}
 		if (data.neededResources)
 			tooltip += getNeededResourcesTooltip(data.neededResources);
 
 		data.button.tooltip = tooltip;
 	},
 	// disable and enable buttons in the same way as when you do for the construction
 	"setGraphics": g_SelectionPanels.Construction.setGraphics,
 	"setPosition": function(data)
 	{
 		var index = data.i + getNumberOfRightPanelButtons();
 		setPanelObjectPosition(data.button, index, data.rowLength);
 	},
 };
 
 
 
 /**
  * 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.
  */
 var 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
 	"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 17616)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 17617)
@@ -1,1092 +1,1100 @@
 const g_IsReplay = Engine.IsVisualReplay();
 const g_GameSpeeds = prepareForDropdown(g_Settings ? g_Settings.GameSpeeds.filter(speed => !speed.ReplayOnly || g_IsReplay) : undefined);
 
 /**
  * Colors to flash when pop limit reached.
  */
 const g_DefaultPopulationColor = "white";
 const g_PopulationAlertColor = "orange";
 
 /**
  * A random file will be played. TODO: more variety
  */
 const g_Ambient = [ "audio/ambient/dayscape/day_temperate_gen_03.ogg" ];
 
 var g_IsNetworked = false;
 
 // Is this user in control of game settings (i.e. is a network server, or offline player)
 var g_IsController;
 
 /**
  * Unique ID for lobby reports
  */
 var g_MatchID;
 
 var g_IsObserver = false;
 
 // Cache the basic player data (name, civ, color)
 var g_Players = [];
 
 var lastTickTime = new Date();
 
 /**
  * Not constant as we add "gaia".
  **/
 var g_CivData = {};
 
 var g_PlayerAssignments = { "local": { "name": translate("You"), "player": 1 } };
 
 // Cache dev-mode settings that are frequently or widely used
 var g_DevSettings = {
 	"controlAll": false
 };
 
 // Whether status bars should be shown for all of the player's units.
 var g_ShowAllStatusBars = false;
 
 // Indicate when one of the current player's training queues is blocked
 // (this is used to support population counter blinking)
 var g_IsTrainingBlocked = false;
 
 // Cache simulation state (updated on every simulation update)
 var g_SimState;
 
 // Cache EntityStates
 var g_EntityStates = {}; // {id:entState}
 
 /**
  * Whether the current player has lost/won and reached the end of their game.
  */
 var g_GameEnded = false;
 
 var g_Disconnected = false; // Lost connection to server
 
 // Holds player states from the last tick
 var g_CachedLastStates = "";
 
 // Top coordinate of the research list
 var g_ResearchListTop = 4;
 
 // List of additional entities to highlight
 var g_ShowGuarding = false;
 var g_ShowGuarded = false;
 var g_AdditionalHighlight = [];
 
 // for saving the hitpoins of the hero (is there a better way to do that?) 
 // Should be possible with AttackDetection but might be an overkill because it would have to loop
 // always through the list of all ongoing attacks...
 var g_PreviousHeroHitPoints = undefined;
 
 var g_TemplateData = {}; // {id:template}
 var g_TemplateDataWithoutLocalization = {};
 var g_TechnologyData = {}; // {id:template}
 
 function GetSimState()
 {
 	if (!g_SimState)
 		g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	return g_SimState;
 }
 
 function GetEntityState(entId)
 {
 	if (!g_EntityStates[entId])
 		g_EntityStates[entId] = Engine.GuiInterfaceCall("GetEntityState", entId);
 
 	return g_EntityStates[entId];
 }
 
 function GetExtendedEntityState(entId)
 {
 	let entState = GetEntityState(entId);
 	if (!entState || entState.extended)
 		return entState;
 
 	let extension = Engine.GuiInterfaceCall("GetExtendedEntityState", entId);
 	for (let prop in extension)
 		entState[prop] = extension[prop];
 	entState.extended = true;
 	g_EntityStates[entId] = entState;
 	return entState;
 }
 
 function GetTemplateData(templateName)
 {
 	if (!(templateName in g_TemplateData))
 	{
 		let template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		translateObjectKeys(template, ["specific", "generic", "tooltip"]);
 		g_TemplateData[templateName] = template;
 	}
 
 	return g_TemplateData[templateName];
 }
 
 function GetTemplateDataWithoutLocalization(templateName)
 {
 	if (!(templateName in g_TemplateDataWithoutLocalization))
 	{
 		let template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		g_TemplateDataWithoutLocalization[templateName] = template;
 	}
 
 	return g_TemplateDataWithoutLocalization[templateName];
 }
 
 function GetTechnologyData(technologyName)
 {
 	if (!(technologyName in g_TechnologyData))
 	{
 		let template = Engine.GuiInterfaceCall("GetTechnologyData", technologyName);
 		translateObjectKeys(template, ["specific", "generic", "description", "tooltip", "requirementsTooltip"]);
 		g_TechnologyData[technologyName] = template;
 	}
 
 	return g_TechnologyData[technologyName];
 }
 
 function init(initData, hotloadData)
 {
 	if (!g_Settings)
 	{
 		Engine.EndGame();
 		Engine.SwitchGuiPage("page_pregame.xml");
 		return;
 	}
 
 	if (initData)
 	{
 		g_IsNetworked = initData.isNetworked;
 		g_IsController = initData.isController;
 		g_PlayerAssignments = initData.playerAssignments;
 		g_MatchID = initData.attribs.matchID;
 
 		// Cache the player data
 		// (This may be updated at runtime by handleNetMessage)
 		g_Players = getPlayerData(g_PlayerAssignments);
 
 		if (initData.savedGUIData)
 			restoreSavedGameData(initData.savedGUIData);
 
 		Engine.GetGUIObjectByName("gameSpeedButton").hidden = g_IsNetworked;
 	}
 	else // Needed for autostart loading option
 	{
 		if (g_IsReplay)
 			g_PlayerAssignments.local.player = -1;
 
 		g_Players = getPlayerData(null);
 	}
 
 	g_CivData = loadCivData();
 	g_CivData.gaia = { "Code": "gaia", "Name": translate("Gaia") };
 
 	if (Engine.GetPlayerID() <= 0)
 		g_IsObserver = true;
 
 	updateTopPanel();
 
 	let gameSpeed = Engine.GetGUIObjectByName("gameSpeed");
 	gameSpeed.list = g_GameSpeeds.Title;
 	gameSpeed.list_data = g_GameSpeeds.Speed;
 	let gameSpeedIdx = g_GameSpeeds.Speed.indexOf(Engine.GetSimRate());
 	gameSpeed.selected = gameSpeedIdx != -1 ? gameSpeedIdx : g_GameSpeeds.Default;
 	gameSpeed.onSelectionChange = function() { changeGameSpeed(+this.list_data[this.selected]); };
 	initMenuPosition();
 
 	// Populate player selection dropdown
 	let playerNames = [];
 	let playerIDs = [];
 	for (let player in g_Players)
 	{
 		playerNames.push(g_Players[player].name);
 		playerIDs.push(player);
 	}
 
 	let viewPlayerDropdown = Engine.GetGUIObjectByName("viewPlayer");
 	viewPlayerDropdown.list = playerNames;
 	viewPlayerDropdown.list_data = playerIDs;
 	viewPlayerDropdown.selected = Engine.GetPlayerID();
 
 	// If in Atlas editor, disable the exit button
 	if (Engine.IsAtlasRunning())
 		Engine.GetGUIObjectByName("menuExitButton").enabled = false;
 
 	if (hotloadData)
 		g_Selection.selected = hotloadData.selection;
 
 	// Starting for the first time:
 	initMusic();
 	if (!g_IsObserver)
 		global.music.storeTracks(g_CivData[g_Players[Engine.GetPlayerID()].civ].Music);
 	global.music.setState(global.music.states.PEACE);
 	playAmbient();
 
 	onSimulationUpdate();
 
 	// Report the performance after 5 seconds (when we're still near
 	// the initial camera view) and a minute (when the profiler will
 	// have settled down if framerates as very low), to give some
 	// extremely rough indications of performance
 	//
 	// DISABLED: this information isn't currently useful for anything much,
 	// and it generates a massive amount of data to transmit and store
 	//setTimeout(function() { reportPerformance(5); }, 5000);
 	//setTimeout(function() { reportPerformance(60); }, 60000);
 }
 
 function selectViewPlayer(playerID)
 {
 	Engine.SetPlayerID(playerID);
 	updateTopPanel();
 
 	if (g_IsDiplomacyOpen)
 		openDiplomacy();
 
 	if (g_IsTradeOpen)
 		openTrade();
 }
 
+/**
+ * Returns true if the current user can issue commands for that player.
+ */
+function controlsPlayer(playerID)
+{
+	return Engine.GetPlayerID() == playerID || g_DevSettings.controlAll;
+}
+
 function updateTopPanel()
 {
 	let playerID = Engine.GetPlayerID();
 	let isPlayer =  playerID > 0;
 	if (isPlayer)
 	{
 		let civName = g_CivData[g_Players[playerID].civ].Name;
 		Engine.GetGUIObjectByName("civIcon").sprite = "stretched:" + g_CivData[g_Players[playerID].civ].Emblem;
 		Engine.GetGUIObjectByName("civIconOverlay").tooltip = sprintf(translate("%(civ)s - Structure Tree"), { "civ": civName });
 	}
 	
 	// Hide stuff gaia/observers don't use.
 	Engine.GetGUIObjectByName("food").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("wood").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("stone").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("metal").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("population").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("civIcon").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("diplomacyButton1").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("tradeButton1").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("observerText").hidden = playerID >= 0;
 
 	// Disable stuff observers shouldn't use
 	let isActive = isPlayer && GetSimState().players[playerID].state == "active";
 	Engine.GetGUIObjectByName("pauseButton").enabled = isActive || !g_IsNetworked;
 	Engine.GetGUIObjectByName("menuResignButton").enabled = isActive;
 
 	// Enable observer-only "summary" button.
 	Engine.GetGUIObjectByName("summaryButton").enabled = !isActive;
 }
 
 function reportPerformance(time)
 {
 	let settings = Engine.GetMapSettings();
 	Engine.SubmitUserReport("profile", 3, JSON.stringify({
 		"time": time,
 		"map": settings.Name,
 		"seed": settings.Seed, // only defined for random maps
 		"size": settings.Size, // only defined for random maps
 		"profiler": Engine.GetProfilerState()
 	}));
 }
 
 /**
  * Resign a player.
  * @param leaveGameAfterResign If player is quitting after resignation.
  */
 function resignGame(leaveGameAfterResign)
 {
 	let simState = GetSimState();
 
 	// Players can't resign if they've already won or lost.
 	if (simState.players[Engine.GetPlayerID()].state != "active" || g_Disconnected)
 		return;
 
 	// Tell other players that we have given up and been defeated
 	Engine.PostNetworkCommand({
 		"type": "defeat-player",
 		"playerId": Engine.GetPlayerID()
 	});
 	
 	updateTopPanel();
 	
 	global.music.setState(global.music.states.DEFEAT);
 	
 	// Resume the game if not resigning.
 	if (!leaveGameAfterResign)
 		resumeGame();
 }
 
 /**
  * Leave the game
  * @param willRejoin If player is going to be rejoining a networked game.
  */
 function leaveGame(willRejoin)
 {
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 	let mapSettings = Engine.GetMapSettings();
 	let gameResult;
 
 	if (g_IsObserver)
 	{
 		// Observers don't win/lose.
 		gameResult = translate("You have left the game.");
 		global.music.setState(global.music.states.VICTORY);
 	}
 	else
 	{
 		let playerState = extendedSimState.players[Engine.GetPlayerID()];
 		if (g_Disconnected)
 			gameResult = translate("You have been disconnected.");
 		else if (playerState.state == "won")
 			gameResult = translate("You have won the battle!");
 		else if (playerState.state == "defeated")
 			gameResult = translate("You have been defeated...");
 		else // "active"
 		{
 			global.music.setState(global.music.states.DEFEAT);
 			if (willRejoin)
 				gameResult = translate("You have left the game.");
 			else
 			{
 				gameResult = translate("You have abandoned the game.");
 				resignGame(true);
 			}
 		}
 	}
 
 	let summary = {
 		"timeElapsed" : extendedSimState.timeElapsed,
 		"playerStates": extendedSimState.players,
 		"players": g_Players,
 		"mapSettings": Engine.GetMapSettings(),
 	};
 
 	if (!g_IsReplay)
 		Engine.SaveReplayMetadata(JSON.stringify(summary));
 
 	Engine.EndGame();
 
 	if (g_IsController && Engine.HasXmppClient())
 		Engine.SendUnregisterGame();
 
 	summary.gameResult = gameResult;
 	summary.isReplay = g_IsReplay;
 	Engine.SwitchGuiPage("page_summary.xml", summary);
 }
 
 // Return some data that we'll use when hotloading this file after changes
 function getHotloadData()
 {
 	return { "selection": g_Selection.selected };
 }
 
 // Return some data that will be stored in saved game files
 function getSavedGameData()
 {
 	// TODO: any other gui state?
 	return {
 		"playerAssignments": g_PlayerAssignments,
 		"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 = new Date();
 	let tickLength = new Date() - lastTickTime;
 	lastTickTime = now;
 
 	checkPlayerState();
 	while (true)
 	{
 		let message = Engine.PollNetworkClient();
 		if (!message)
 			break;
 		handleNetMessage(message);
 	}
 
 	updateCursorAndTooltip();
 
 	// If the selection changed, we need to regenerate the sim display (the display depends on both the
 	// simulation state and the current selection).
 	if (g_Selection.dirty)
 	{
 		g_Selection.dirty = false;
 
 		onSimulationUpdate();
 
 		// Display rally points for selected buildings
 		if (!g_IsObserver)
 			Engine.GuiInterfaceCall("DisplayRallyPoint", { "entities": g_Selection.toList() });
 	}
 
 	updateTimers();
 
 	updateMenuPosition(tickLength);
 
 	// When training is blocked, flash population (alternates color every 500msec)
 	Engine.GetGUIObjectByName("resourcePop").textcolor = g_IsTrainingBlocked && Date.now() % 1000 < 500 ? g_PopulationAlertColor : g_DefaultPopulationColor;
 
 	Engine.GuiInterfaceCall("ClearRenamedEntities");
 }
 
 function checkPlayerState()
 {
 	if (g_GameEnded || g_IsObserver)
 		return;
 
 	// Send a game report for each player in this game.
 	let m_simState = GetSimState();
 	let playerState = m_simState.players[Engine.GetPlayerID()];
 	let tempStates = "";
 	for (let player of m_simState.players)
 		tempStates += player.state + ",";
 
 	if (g_CachedLastStates != tempStates)
 	{
 		g_CachedLastStates = tempStates;
 		reportGame();
 	}
 
 	if (playerState.state == "active")
 		return;
 
 	// Disable the resign- and pausebutton
 	updateTopPanel();
 	
 	// Make sure nothing is open to avoid stacking.
 	closeMenu();
 	closeOpenDialogs();
 
 	// Make sure this doesn't run again.
 	g_GameEnded = true;
 
 	let btCaptions;
 	let btCode;
 	let message;
 	let title;
 	if (Engine.IsAtlasRunning())
 	{
 		// If we're in Atlas, we can't leave the game
 		btCaptions = [translate("OK")];
 		btCode = [null];
 		message = translate("Press OK to continue");
 	}
 	else
 	{
 		btCaptions = [translate("No"), translate("Yes")];
 		btCode = [null, leaveGame];
 		message = translate("Do you want to quit?");
 	}
 
 	if (playerState.state == "defeated")
 	{
 		title = translate("DEFEATED!");
 		global.music.setState(global.music.states.DEFEAT);
 	}
 	else if (playerState.state == "won")
 	{
 		title = translate("VICTORIOUS!");
 		global.music.setState(global.music.states.VICTORY);
 		// TODO: Reveal map directly instead of this silly proxy.
 		if (!Engine.GetGUIObjectByName("devCommandsRevealMap").checked)
 			Engine.GetGUIObjectByName("devCommandsRevealMap").checked = true;
 	}
 
 	messageBox(400, 200, message, title, 0, btCaptions, btCode);
 }
 
 function changeGameSpeed(speed)
 {
 	if (!g_IsNetworked)
 		Engine.SetSimRate(speed);
 }
 
 /**
  * Recomputes GUI state that depends on simulation state or selection state. Called directly every simulation
  * update (see session.xml), or from onTick when the selection has changed.
  */
 function onSimulationUpdate()
 {
 	g_EntityStates = {};
 	g_TemplateData = {};
 	g_TechnologyData = {};
 
 	g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	// If we're called during init when the game is first loading, there will be no simulation yet, so do nothing
 	if (!g_SimState)
 		return;
 
 	handleNotifications();
 
 	g_Selection.update();
 
 	if (g_ShowAllStatusBars)
 		recalculateStatusBarDisplay();
 
 	if (g_ShowGuarding || g_ShowGuarded)
 		updateAdditionalHighlight();
 
 	updateHero();
 	updateGroups();
 	updateDebug();
 	updatePlayerDisplay();
 	updateSelectionDetails();
 	updateBuildingPlacementPreview();
 	updateTimeNotifications();
 
 	if (!g_IsObserver)
 		updateResearchDisplay();
 
 	if (!g_IsObserver && !g_GameEnded)
 	{
 		// Update music state on basis of battle state.
 		let battleState = Engine.GuiInterfaceCall("GetBattleState", Engine.GetPlayerID());
 		if (battleState)
 			global.music.setState(global.music.states[battleState]);
 	}
 }
 
 function onReplayFinished()
 {
 	closeMenu();
 	closeOpenDialogs();
 	pauseGame();
 
 	messageBox(400, 200,
 		translateWithContext("replayFinished", "The replay has finished. Do you want to quit?"),
 		translateWithContext("replayFinished", "Confirmation"),
 		0,
 		[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 updateHero()
 {
 	let playerState = GetSimState().players[Engine.GetPlayerID()];
 	let unitHeroPanel = Engine.GetGUIObjectByName("unitHeroPanel");
 	let heroButton = Engine.GetGUIObjectByName("unitHeroButton");
 
 	if (!playerState || playerState.heroes.length <= 0)
 	{
 		g_PreviousHeroHitPoints = undefined;
 		unitHeroPanel.hidden = true;
 		return;
 	}
 
 	let heroImage = Engine.GetGUIObjectByName("unitHeroImage");
 	let heroState = GetExtendedEntityState(playerState.heroes[0]);
 	let template = GetTemplateData(heroState.template);
 	heroImage.sprite = "stretched:session/portraits/" + template.icon;
 	let hero = playerState.heroes[0];
 
 	heroButton.onpress = function()
 	{
 		if (!Engine.HotkeyIsPressed("selection.add"))
 			g_Selection.reset();
 		g_Selection.addList([hero]);
 	};
 	heroButton.ondoublepress = function() { selectAndMoveTo(getEntityOrHolder(hero)); };
 	unitHeroPanel.hidden = false;
 
 	// Setup tooltip
 	let tooltip = "[font=\"sans-bold-16\"]" + template.name.specific + "[/font]";
 	let healthLabel = "[font=\"sans-bold-13\"]" + translate("Health:") + "[/font]";
 	tooltip += "\n" + sprintf(translate("%(label)s %(current)s / %(max)s"), { label: healthLabel, current: heroState.hitpoints, max: heroState.maxHitpoints });
 	if (heroState.attack)
 		tooltip += "\n" + getAttackTooltip(heroState);
 
 	tooltip += "\n" + getArmorTooltip(heroState.armour);
 	if (template.tooltip)
 		tooltip += "\n" + template.tooltip;
 
 	heroButton.tooltip = tooltip;
 	
 	// update heros health bar
 	updateGUIStatusBar("heroHealthBar", heroState.hitpoints, heroState.maxHitpoints);
 	
 	// define the hit points if not defined
 	if (!g_PreviousHeroHitPoints)
 		g_PreviousHeroHitPoints = heroState.hitpoints;
 	
 	// if the health of the hero changed since the last update, trigger the animation
 	if (heroState.hitpoints < g_PreviousHeroHitPoints)
 		startColorFade("heroHitOverlay", 100, 0, colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
 
 	g_PreviousHeroHitPoints = heroState.hitpoints;
 }
 
 
 function updateGroups()
 {
 	let guiName = "Group";
 	g_Groups.update();
 	for (let i = 0; i < 10; ++i)
 	{
 		let button = Engine.GetGUIObjectByName("unit"+guiName+"Button["+i+"]");
 		let label = Engine.GetGUIObjectByName("unit"+guiName+"Label["+i+"]").caption = 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);
 		setPanelObjectPosition(button, i, 1);
 	}
 }
 
 function updateDebug()
 {
 	let debug = Engine.GetGUIObjectByName("debug");
 
 	if (!Engine.GetGUIObjectByName("devDisplayState").checked)
 	{
 		debug.hidden = true;
 		return;
 	}
 
 	debug.hidden = false;
 
 	let conciseSimState = deepcopy(GetSimState());
 	conciseSimState.players = "<<<omitted>>>";
 	let text = "simulation: " + uneval(conciseSimState);
 
 	let selection = g_Selection.toList();
 	if (selection.length)
 	{
 		let entState = GetExtendedEntityState(selection[0]);
 		if (entState)
 		{
 			let template = GetTemplateData(entState.template);
 			text += "\n\nentity: {\n";
 			for (let k in entState)
 				text += "  "+k+":"+uneval(entState[k])+"\n";
 			text += "}\n\ntemplate: " + uneval(template);
 		}
 	}
 
 	debug.caption = text.replace(/\[/g, "\\[");
 }
 
 function updatePlayerDisplay()
 {
 	let playerState = GetSimState().players[Engine.GetPlayerID()];
 	if (!playerState)
 		return;
 
 	Engine.GetGUIObjectByName("resourceFood").caption = Math.floor(playerState.resourceCounts.food);
 	Engine.GetGUIObjectByName("resourceWood").caption = Math.floor(playerState.resourceCounts.wood);
 	Engine.GetGUIObjectByName("resourceStone").caption = Math.floor(playerState.resourceCounts.stone);
 	Engine.GetGUIObjectByName("resourceMetal").caption = Math.floor(playerState.resourceCounts.metal);
 	Engine.GetGUIObjectByName("resourcePop").caption = playerState.popCount + "/" + playerState.popLimit;
 	Engine.GetGUIObjectByName("population").tooltip = translate("Population (current / limit)") + "\n" +
 					sprintf(translate("Maximum population: %(popCap)s"), { "popCap": playerState.popMax });
 
 	g_IsTrainingBlocked = playerState.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", Engine.GetPlayerID());
 	if (!researchStarted)
 		return;
 
 	// 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);
 		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;
 
 		++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.
 function recalculateStatusBarDisplay()
 {
 	let entities;
 	if (g_ShowAllStatusBars)
 		entities = Engine.PickFriendlyEntitiesOnScreen(Engine.GetPlayerID());
 	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("GetPlayerEntities").filter(idx => selected.indexOf(idx) == -1);
 	}
 
 	Engine.GuiInterfaceCall("SetStatusBars", { "entities": entities, "enabled": g_ShowAllStatusBars });
 }
 
 // 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(g_Ambient[Math.floor(Math.random() * g_Ambient.length)], true);
 }
 
 function getBuildString()
 {
 	return sprintf(translate("Build: %(buildDate)s (%(revision)s)"), { "buildDate": Engine.GetBuildTimestamp(0), revision: Engine.GetBuildTimestamp(2) });
 }
 
 function showTimeWarpMessageBox()
 {
 	messageBox(500, 250,
 			translate("Note: time warp mode is a developer option, and not intended for use over long periods of time. Using it incorrectly may cause the game to run out of memory or crash."),
 			translate("Time warp mode"), 2);
 }
 
 /**
  * Send a report on the gamestatus to the lobby.
  */
 function reportGame()
 {
 	if (!Engine.HasXmppClient() || !Engine.IsRankedGame())
 		return;
 
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 
 	let unitsClasses = [
 		"total",
 		"Infantry",
 		"Worker",
 		"Female",
 		"Cavalry",
 		"Champion",
 		"Hero",
 		"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 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 = "";
 
 	playerStatistics.tradeIncome = "";
 	// Tribute
 	playerStatistics.tributesSent = "";
 	playerStatistics.tributesReceived = "";
 	// Total
 	playerStatistics.economyScore = "";
 	playerStatistics.militaryScore = "";
 	playerStatistics.totalScore = "";
 	// Various
 	playerStatistics.treasuresCollected = "";
 	playerStatistics.lootCollected = "";
 	playerStatistics.feminisation = "";
 	playerStatistics.percentMapExplored = "";
 
 	let mapName = Engine.GetMapSettings().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];
 
 		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.statistics[resourcesCounterType][resourcesType] + ",";
 		playerStatistics.resourcesGathered.vegetarianFood += player.statistics.resourcesGathered.vegetarianFood + ",";
 
 		for (let unitCounterType of unitsCountersTypes)
 			for (let unitsClass of unitsClasses)
 				playerStatistics[unitCounterType][unitsClass] += player.statistics[unitCounterType][unitsClass] + ",";
 
 		for (let buildingCounterType of buildingsCountersTypes)
 			for (let buildingsClass of buildingsClasses)
 				playerStatistics[buildingCounterType][buildingsClass] += player.statistics[buildingCounterType][buildingsClass] + ",";
 		let total = 0;
 		for (let res of player.statistics.resourcesGathered)
 			total += res;
 
 		playerStatistics.economyScore += total + ",";
 		playerStatistics.militaryScore += Math.round((player.statistics.enemyUnitsKilledValue +
 			player.statistics.enemyBuildingsDestroyedValue) / 10)  + ",";
 		playerStatistics.totalScore += (total + Math.round((player.statistics.enemyUnitsKilledValue +
 			player.statistics.enemyBuildingsDestroyedValue) / 10)) + ",";
 		playerStatistics.tradeIncome += player.statistics.tradeIncome + ",";
 		playerStatistics.tributesSent += player.statistics.tributesSent + ",";
 		playerStatistics.tributesReceived += player.statistics.tributesReceived + ",";
 		playerStatistics.percentMapExplored += player.statistics.percentMapExplored + ",";
 		playerStatistics.treasuresCollected += player.statistics.treasuresCollected + ",";
 		playerStatistics.lootCollected += player.statistics.lootCollected + ",";
 	}
 
 	// Send the report with serialized data
 	let reportObject = {};
 	reportObject.timeElapsed = extendedSimState.timeElapsed;
 	reportObject.playerStates = playerStates;
 	reportObject.playerID = Engine.GetPlayerID();
 	reportObject.matchID = g_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];
 	}
 	reportObject.tributesSent = playerStatistics.tributesSent;
 	reportObject.tributesReceived = playerStatistics.tributesReceived;
 	reportObject.percentMapExplored = playerStatistics.percentMapExplored;
 	reportObject.treasuresCollected = playerStatistics.treasuresCollected;
 	reportObject.lootCollected = playerStatistics.lootCollected;
 	reportObject.tradeIncome = playerStatistics.tradeIncome;
 
 	Engine.SendGameReport(reportObject);
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/unit_commands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/unit_commands.js	(revision 17616)
+++ ps/trunk/binaries/data/mods/public/gui/session/unit_commands.js	(revision 17617)
@@ -1,269 +1,269 @@
 // 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};
 
 /**
  * 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 unitEntState Entity state of the (first) selected unit.
  * @param payerState Player state
  */
 function setupUnitPanel(guiName, unitEntState, playerState)
 {
 	if (!g_SelectionPanels[guiName])
 	{
 		error("unknown guiName used '" + guiName + "'");
 		return;
 	}
 	var selection = g_Selection.toList();
 
 	var items = g_SelectionPanels[guiName].getItems(unitEntState, selection);
 
 	if (!items || !items.length)
 		return;
 
 	var numberOfItems = items.length;
 	var garrisonGroups = new EntityGroups();
 
 	// Determine how many buttons there should be
 	var maxNumberOfItems = g_SelectionPanels[guiName].getMaxNumberOfItems();
 	if (maxNumberOfItems < numberOfItems)
 		numberOfItems = maxNumberOfItems;
 
 	if (g_SelectionPanels[guiName].rowLength)
 		var rowLength = g_SelectionPanels[guiName].rowLength;
 	else
 		var rowLength = 8;
 
 	if (g_SelectionPanels[guiName].resizePanel)
 		g_SelectionPanels[guiName].resizePanel(numberOfItems, rowLength);
 
 	// Make buttons
 	for (var i = 0; i < numberOfItems; i++)
 	{
 		var item = items[i];
 
 		// If a tech has been researched it leaves an empty slot
 		if (!item)
 		{
 			if (g_SelectionPanels[guiName].hideItem)
 				g_SelectionPanels[guiName].hideItem(i, rowLength);
 			continue;
 		}
 
 		// STANDARD DATA
 		// add standard data 
 		var data = {
 			"i": i,
 			"item": item,
 			"selection": selection,
 			"playerState": playerState,
 			"unitEntState": unitEntState,
 			"rowLength": rowLength,
 			"numberOfItems": numberOfItems,
 		};
 
 		// add standard gui objects to the data
 		// depending on the actual XML, some of this may be undefined
 		data.button = Engine.GetGUIObjectByName("unit"+guiName+"Button["+i+"]");
 		data.icon = Engine.GetGUIObjectByName("unit"+guiName+"Icon["+i+"]");
 		data.guiSelection = Engine.GetGUIObjectByName("unit"+guiName+"Selection["+i+"]");
 		data.countDisplay = Engine.GetGUIObjectByName("unit"+guiName+"Count["+i+"]");
 
 
 		// DEFAULTS
 		if (data.button)
 		{
 			data.button.hidden = false;
 			data.button.enabled = true;
 			data.button.tooltip = "";
 			data.button.caption = "";
 		}
 
 		// GENERAL DATA
 		// add general data, and a chance to abort on faulty data
 		if (g_SelectionPanels[guiName].addData)
 		{
 			var success = g_SelectionPanels[guiName].addData(data);
 			if (!success)
 				continue; // ignore faulty data
 		}
 
 		// SET CONTENT
 		// run all content setters
 		for (var f in g_SelectionPanels[guiName])
 		{
 			if (f.match(/^set/))
 				g_SelectionPanels[guiName][f](data);
 		}
 
 		// Special case: position
 		if (!g_SelectionPanels[guiName].setPosition)
 			setPanelObjectPosition(data.button, i, rowLength);
 
 		// TODO: we should require all entities to have icons, so this case never occurs
 		if (data.icon && !data.icon.sprite)
 			data.icon.sprite = "bkFillBlack";
 		
 	}
 
 	// Hide any buttons we're no longer using
 	for (var 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;
 
 	// remember the number of items
 	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 entState Entity state of the (first) selected unit.
  * @param supplementalDetailsPanel Reference to the 
  *        "supplementalSelectionDetails" GUI Object
  * @param commandsPanel Reference to the "commandsPanel" GUI Object
  * @param selection Array of currently selected entity IDs.
  */
 function updateUnitCommands(entState, supplementalDetailsPanel, commandsPanel, selection)
 {
 	for each (var panel in g_SelectionPanels)
 		panel.used = false;
 
 	// If the selection is friendly units, add the command panels
 	var player = Engine.GetPlayerID();
 
 	// Get player state to check some constraints
 	// e.g. presence of a hero or build limits
 	var simState = GetSimState();
 	var playerState = simState.players[player];
 
-	if (entState.player == player || g_DevSettings.controlAll)
+	if (controlsPlayer(entState.player) || player == -1)
 	{
 		for (var guiName of g_PanelsOrder)
 		{
 			if (
 				g_SelectionPanels[guiName].conflictsWith && 
 				g_SelectionPanels[guiName].conflictsWith.some(function (p) { return g_SelectionPanels[p].used; })
 			)
 				continue;
 
-			setupUnitPanel(guiName, entState, playerState);
+			setupUnitPanel(guiName, entState, simState.players[entState.player]);
 		}
 
 		supplementalDetailsPanel.hidden = false;
 		commandsPanel.hidden = false;
 	}
 	else if (playerState.isMutualAlly[entState.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", entState, playerState);
 		setupUnitPanel("AllyCommand", entState, playerState);
 		if (g_SelectionPanels["Garrison"].used)
 			supplementalDetailsPanel.hidden = false;
 		else
 			supplementalDetailsPanel.hidden = true;
 
 		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)
 		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)
 {
 	var trainableEnts = [];
 	var state;
 	// Get all buildable and trainable entities
 	for (let ent of selection)
 	{
 		if ((state = GetEntityState(ent)) && 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;
 	if (g_SelectionPanels["Construction"].used)
 		sum += g_unitPanelButtons["Construction"];
 	if (g_SelectionPanels["Training"].used)
 		sum += g_unitPanelButtons["Training"];
 	if (g_SelectionPanels["Pack"].used)
 		sum += g_unitPanelButtons["Pack"];
 	if (g_SelectionPanels["Gate"].used)
 		sum += g_unitPanelButtons["Gate"];
 	return sum;
 }
Index: ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js	(revision 17616)
+++ ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js	(revision 17617)
@@ -1,1887 +1,1887 @@
 function GuiInterface() {}
 
 GuiInterface.prototype.Schema =
 	"<a:component type='system'/><empty/>";
 
 GuiInterface.prototype.Serialize = function()
 {
 	// This component isn't network-synchronised for the biggest part
 	// So most of the attributes shouldn't be serialized
 	// Return an object with a small selection of deterministic data
 	return {
 		"timeNotifications": this.timeNotifications,
 		"timeNotificationID": this.timeNotificationID
 	};
 };
 
 GuiInterface.prototype.Deserialize = function(data)
 {
 	this.Init();
 	this.timeNotifications = data.timeNotifications;
 	this.timeNotificationID = data.timeNotificationID;
 };
 
 GuiInterface.prototype.Init = function()
 {
 	this.placementEntity = undefined; // = undefined or [templateName, entityID]
 	this.placementWallEntities = undefined;
 	this.placementWallLastAngle = 0;
 	this.notifications = [];
 	this.renamedEntities = [];
 	this.miragedEntities = [];
 	this.timeNotificationID = 1;
 	this.timeNotifications = [];
 	this.entsRallyPointsDisplayed = [];
 	this.entsWithAuraAndStatusBars = new Set();
 };
 
 /*
  * All of the functions defined below are called via Engine.GuiInterfaceCall(name, arg)
  * from GUI scripts, and executed here with arguments (player, arg).
  *
  * CAUTION: The input to the functions in this module is not network-synchronised, so it
  * mustn't affect the simulation state (i.e. the data that is serialised and can affect
  * the behaviour of the rest of the simulation) else it'll cause out-of-sync errors.
  */
 
 /**
  * Returns global information about the current game state.
  * This is used by the GUI and also by AI scripts.
  */
 GuiInterface.prototype.GetSimulationState = function(player)
 {
 	let ret = {
 		"players": []
 	};
 
 	let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	let numPlayers = cmpPlayerManager.GetNumPlayers();
 	for (let i = 0; i < numPlayers; ++i)
 	{
 		let playerEnt = cmpPlayerManager.GetPlayerByID(i);
 		let cmpPlayerEntityLimits = Engine.QueryInterface(playerEnt, IID_EntityLimits);
 		let cmpPlayer = Engine.QueryInterface(playerEnt, IID_Player);
 
 		// Work out what phase we are in
 		let phase = "";
 		let cmpTechnologyManager = Engine.QueryInterface(playerEnt, IID_TechnologyManager);
 		if (cmpTechnologyManager)
 		{
 			if (cmpTechnologyManager.IsTechnologyResearched("phase_city"))
 				phase = "city";
 			else if (cmpTechnologyManager.IsTechnologyResearched("phase_town"))
 				phase = "town";
 			else if (cmpTechnologyManager.IsTechnologyResearched("phase_village"))
 				phase = "village";
 		}
 
 		// store player ally/neutral/enemy data as arrays
 		let allies = [];
 		let mutualAllies = [];
 		let neutrals = [];
 		let enemies = [];
 		for (let j = 0; j < numPlayers; ++j)
 		{
 			allies[j] = cmpPlayer.IsAlly(j);
 			mutualAllies[j] = cmpPlayer.IsMutualAlly(j);
 			neutrals[j] = cmpPlayer.IsNeutral(j);
 			enemies[j] = cmpPlayer.IsEnemy(j);
 		}
 		let playerData = {
 			"name": cmpPlayer.GetName(),
 			"civ": cmpPlayer.GetCiv(),
 			"color": cmpPlayer.GetColor(),
 			"popCount": cmpPlayer.GetPopulationCount(),
 			"popLimit": cmpPlayer.GetPopulationLimit(),
 			"popMax": cmpPlayer.GetMaxPopulation(),
 			"heroes": cmpPlayer.GetHeroes(),
 			"resourceCounts": cmpPlayer.GetResourceCounts(),
 			"trainingBlocked": cmpPlayer.IsTrainingBlocked(),
 			"state": cmpPlayer.GetState(),
 			"team": cmpPlayer.GetTeam(),
 			"teamsLocked": cmpPlayer.GetLockTeams(),
 			"cheatsEnabled": cmpPlayer.GetCheatsEnabled(),
 			"disabledTemplates": cmpPlayer.GetDisabledTemplates(),
 			"phase": phase,
 			"isAlly": allies,
 			"isMutualAlly": mutualAllies,
 			"isNeutral": neutrals,
 			"isEnemy": enemies,
 			"entityLimits": cmpPlayerEntityLimits ? cmpPlayerEntityLimits.GetLimits() : null,
 			"entityCounts": cmpPlayerEntityLimits ? cmpPlayerEntityLimits.GetCounts() : null,
 			"entityLimitChangers": cmpPlayerEntityLimits ? cmpPlayerEntityLimits.GetLimitChangers() : null,
 			"researchQueued": cmpTechnologyManager ? cmpTechnologyManager.GetQueuedResearch() : null,
 			"researchStarted": cmpTechnologyManager ? cmpTechnologyManager.GetStartedResearch() : null,
 			"researchedTechs": cmpTechnologyManager ? cmpTechnologyManager.GetResearchedTechs() : null,
 			"classCounts": cmpTechnologyManager ? cmpTechnologyManager.GetClassCounts() : null,
 			"typeCountsByClass": cmpTechnologyManager ? cmpTechnologyManager.GetTypeCountsByClass() : null
 		};
 		ret.players.push(playerData);
 	}
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (cmpRangeManager)
 		ret.circularMap = cmpRangeManager.GetLosCircular();
 
 	let cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 	if (cmpTerrain)
 		ret.mapSize = 4 * cmpTerrain.GetTilesPerSide();
 
 	// Add timeElapsed
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	ret.timeElapsed = cmpTimer.GetTime();
 
 	// Add ceasefire info
 	let cmpCeasefireManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_CeasefireManager);
 	if (cmpCeasefireManager)
 	{
 		ret.ceasefireActive = cmpCeasefireManager.IsCeasefireActive();
 		ret.ceasefireTimeRemaining = ret.ceasefireActive ? cmpCeasefireManager.GetCeasefireStartedTime() + cmpCeasefireManager.GetCeasefireTime() - ret.timeElapsed : 0;
 	}
 
 	// Add the game type
 	let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
 	ret.gameType = cmpEndGameManager.GetGameType();
 
 	// Add bartering prices
 	let cmpBarter = Engine.QueryInterface(SYSTEM_ENTITY, IID_Barter);
 	ret.barterPrices = cmpBarter.GetPrices();
 
 	// Add basic statistics to each player
 	for (let i = 0; i < numPlayers; ++i)
 	{
 		let playerEnt = cmpPlayerManager.GetPlayerByID(i);
 		let cmpPlayerStatisticsTracker = Engine.QueryInterface(playerEnt, IID_StatisticsTracker);
 		if (cmpPlayerStatisticsTracker)
 			ret.players[i].statistics = cmpPlayerStatisticsTracker.GetBasicStatistics();
 	}
 
 	return ret;
 };
 
 /**
  * Returns global information about the current game state, plus statistics.
  * This is used by the GUI at the end of a game, in the summary screen.
  * Note: Amongst statistics, the team exploration map percentage is computed from
  * scratch, so the extended simulation state should not be requested too often.
  */
 GuiInterface.prototype.GetExtendedSimulationState = function(player)
 {
 	// Get basic simulation info
 	let ret = this.GetSimulationState();
 
 	// Add statistics to each player
 	let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	let n = cmpPlayerManager.GetNumPlayers();
 	for (let i = 0; i < n; ++i)
 	{
 		let playerEnt = cmpPlayerManager.GetPlayerByID(i);
 		let cmpPlayerStatisticsTracker = Engine.QueryInterface(playerEnt, IID_StatisticsTracker);
 		if (cmpPlayerStatisticsTracker)
 			ret.players[i].statistics = cmpPlayerStatisticsTracker.GetStatistics();
 	}
 
 	return ret;
 };
 
 GuiInterface.prototype.GetRenamedEntities = function(player)
 {
 	if (this.miragedEntities[player])
 		return this.renamedEntities.concat(this.miragedEntities[player]);
 	else
 		return this.renamedEntities;
 };
 
 GuiInterface.prototype.ClearRenamedEntities = function(player)
 {
 	this.renamedEntities = [];
 	this.miragedEntities = [];
 };
 
 GuiInterface.prototype.AddMiragedEntity = function(player, entity, mirage)
 {
 	if (!this.miragedEntities[player])
 		this.miragedEntities[player] = [];
 
 	this.miragedEntities[player].push({ "entity": entity, "newentity": mirage });
 };
 
 /**
  * Get common entity info, often used in the gui
  */
 GuiInterface.prototype.GetEntityState = function(player, ent)
 {
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 
 	// All units must have a template; if not then it's a nonexistent entity id
 	let template = cmpTemplateManager.GetCurrentTemplateName(ent);
 	if (!template)
 		return null;
 
 	let ret = {
 		"id": ent,
 		"template": template,
 
 		"alertRaiser": null,
 		"builder": null,
 		"identity": null,
 		"fogging": null,
 		"foundation": null,
 		"garrisonHolder": null,
 		"gate": null,
 		"guard": null,
 		"mirage": null,
 		"pack": null,
 		"player": -1,
 		"position": null,
 		"production": null,
 		"rallyPoint": null,
 		"resourceCarrying": null,
 		"rotation": null,
 		"trader": null,
 		"unitAI": null,
 		"visibility": null,
 	};
 
 	let cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
 	if (cmpMirage)
 		ret.mirage = true;
 
 	let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 	if (cmpIdentity)
 		ret.identity = {
 			"rank": cmpIdentity.GetRank(),
 			"classes": cmpIdentity.GetClassesList(),
 			"visibleClasses": cmpIdentity.GetVisibleClassesList(),
 			"selectionGroupName": cmpIdentity.GetSelectionGroupName()
 		};
 
 	let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	if (cmpPosition && cmpPosition.IsInWorld())
 	{
 		ret.position = cmpPosition.GetPosition();
 		ret.rotation = cmpPosition.GetRotation();
 	}
 
 	let cmpHealth = QueryMiragedInterface(ent, IID_Health);
 	if (cmpHealth)
 	{
 		ret.hitpoints = Math.ceil(cmpHealth.GetHitpoints());
 		ret.maxHitpoints = cmpHealth.GetMaxHitpoints();
 		ret.needsRepair = cmpHealth.IsRepairable() && (cmpHealth.GetHitpoints() < cmpHealth.GetMaxHitpoints());
 		ret.needsHeal = !cmpHealth.IsUnhealable();
 		ret.canDelete = !cmpHealth.IsUndeletable();
 	}
 
 	let cmpCapturable = QueryMiragedInterface(ent, IID_Capturable);
 	if (cmpCapturable)
 	{
 		ret.capturePoints = cmpCapturable.GetCapturePoints();
 		ret.maxCapturePoints = cmpCapturable.GetMaxCapturePoints();
 	}
 
 	let cmpBuilder = Engine.QueryInterface(ent, IID_Builder);
 	if (cmpBuilder)
 		ret.builder = true;
 
 	let cmpPack = Engine.QueryInterface(ent, IID_Pack);
 	if (cmpPack)
 		ret.pack = {
 			"packed": cmpPack.IsPacked(),
 			"progress": cmpPack.GetProgress(),
 		};
 
 	let cmpProductionQueue = Engine.QueryInterface(ent, IID_ProductionQueue);
 	if (cmpProductionQueue)
 		ret.production = {
 			"entities": cmpProductionQueue.GetEntitiesList(),
 			"technologies": cmpProductionQueue.GetTechnologiesList(),
 			"queue": cmpProductionQueue.GetQueue(),
 		};
 
 	let cmpTrader = Engine.QueryInterface(ent, IID_Trader);
 	if (cmpTrader)
 		ret.trader = {
 			"goods": cmpTrader.GetGoods(),
 			"requiredGoods": cmpTrader.GetRequiredGoods()
 		};
 
 	let cmpFogging = Engine.QueryInterface(ent, IID_Fogging);
 	if (cmpFogging)
 	{
 		if (cmpFogging.IsMiraged(player))
 			ret.fogging = { "mirage": cmpFogging.GetMirage(player) };
 		else
 			ret.fogging = { "mirage": null };
 	}
 
 	let cmpFoundation = QueryMiragedInterface(ent, IID_Foundation);
 	if (cmpFoundation)
 		ret.foundation = {
 			"progress": cmpFoundation.GetBuildPercentage(),
 			"numBuilders": cmpFoundation.GetNumBuilders()
 		};
 
 	let cmpRepairable = QueryMiragedInterface(ent, IID_Repairable);
 	if (cmpRepairable)
 		ret.repairable = { "numBuilders": cmpRepairable.GetNumBuilders() };
 
 	let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 	if (cmpOwnership)
 		ret.player = cmpOwnership.GetOwner();
 
 	let cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 	if (cmpRallyPoint)
 		ret.rallyPoint = { "position": cmpRallyPoint.GetPositions()[0] }; // undefined or {x,z} object
 
 	let cmpGarrisonHolder = Engine.QueryInterface(ent, IID_GarrisonHolder);
 	if (cmpGarrisonHolder)
 		ret.garrisonHolder = {
 			"entities": cmpGarrisonHolder.GetEntities(),
 			"allowedClasses": cmpGarrisonHolder.GetAllowedClasses(),
 			"capacity": cmpGarrisonHolder.GetCapacity(),
 			"garrisonedEntitiesCount": cmpGarrisonHolder.GetGarrisonedEntitiesCount()
 		};
 
 	let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 	if (cmpUnitAI)
 	{
 		ret.unitAI = {
 			"state": cmpUnitAI.GetCurrentState(),
 			"orders": cmpUnitAI.GetOrders(),
 			"hasWorkOrders": cmpUnitAI.HasWorkOrders(),
 			"canGuard": cmpUnitAI.CanGuard(),
 			"isGuarding": cmpUnitAI.IsGuardOf(),
 			"possibleStances": cmpUnitAI.GetPossibleStances(),
 			"isIdle":cmpUnitAI.IsIdle(),
 		};
 		// Add some information needed for ungarrisoning
 		if (cmpUnitAI.IsGarrisoned() && ret.player !== undefined)
 			ret.template = "p" + ret.player + "&" + ret.template;
 	}
 
 	let cmpGuard = Engine.QueryInterface(ent, IID_Guard);
 	if (cmpGuard)
 		ret.guard = {
 			"entities": cmpGuard.GetEntities(),
 		};
 
 	let cmpResourceGatherer = Engine.QueryInterface(ent, IID_ResourceGatherer);
 	if (cmpResourceGatherer)
 		ret.resourceCarrying = cmpResourceGatherer.GetCarryingStatus();
 
 	let cmpGate = Engine.QueryInterface(ent, IID_Gate);
 	if (cmpGate)
 		ret.gate = {
 			"locked": cmpGate.IsLocked(),
 		};
 
 	let cmpAlertRaiser = Engine.QueryInterface(ent, IID_AlertRaiser);
 	if (cmpAlertRaiser)
 		ret.alertRaiser = {
 			"level": cmpAlertRaiser.GetLevel(),
 			"canIncreaseLevel": cmpAlertRaiser.CanIncreaseLevel(),
 			"hasRaisedAlert": cmpAlertRaiser.HasRaisedAlert(),
 		};
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	ret.visibility = cmpRangeManager.GetLosVisibility(ent, player);
 
 	return ret;
 };
 
 /**
  * Get additionnal entity info, rarely used in the gui
  */
 GuiInterface.prototype.GetExtendedEntityState = function(player, ent)
 {
 	let ret = {
 		"armour": null,
 		"attack": null,
 		"barterMarket": null,
 		"buildingAI": null,
 		"healer": null,
 		"obstruction": null,
 		"turretParent":null,
 		"promotion": null,
 		"repairRate": null,
 		"buildRate": null,
 		"resourceDropsite": null,
 		"resourceGatherRates": null,
 		"resourceSupply": null,
 	};
 
 	let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 
 	let cmpAttack = Engine.QueryInterface(ent, IID_Attack);
 	if (cmpAttack)
 	{
 		let types = cmpAttack.GetAttackTypes();
 		if (types.length)
 			ret.attack = {};
 		for (let type of types)
 		{
 			ret.attack[type] = cmpAttack.GetAttackStrengths(type);
 			let range = cmpAttack.GetRange(type);
 			ret.attack[type].minRange = range.min;
 			ret.attack[type].maxRange = range.max;
 			let timers = cmpAttack.GetTimers(type);
 			ret.attack[type].prepareTime = timers.prepare;
 			ret.attack[type].repeatTime = timers.repeat;
 			if (type != "Ranged")
 			{
 				// not a ranged attack, set some defaults
 				ret.attack[type].elevationBonus = 0;
 				ret.attack[type].elevationAdaptedRange = ret.attack.maxRange;
 				continue;
 			}
 
 			ret.attack[type].elevationBonus = range.elevationBonus;
 			let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 			let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 			if (cmpUnitAI && cmpPosition && cmpPosition.IsInWorld())
 			{
 				// For units, take the rage in front of it, no spread. So angle = 0
 				ret.attack[type].elevationAdaptedRange = cmpRangeManager.GetElevationAdaptedRange(cmpPosition.GetPosition(), cmpPosition.GetRotation(), range.max, range.elevationBonus, 0);
 			}
 			else if(cmpPosition && cmpPosition.IsInWorld())
 			{
 				// For buildings, take the average elevation around it. So angle = 2*pi
 				ret.attack[type].elevationAdaptedRange = cmpRangeManager.GetElevationAdaptedRange(cmpPosition.GetPosition(), cmpPosition.GetRotation(), range.max, range.elevationBonus, 2*Math.PI);
 			}
 			else
 			{
 				// not in world, set a default?
 				ret.attack[type].elevationAdaptedRange = ret.attack.maxRange;
 			}
 		}
 	}
 
 	let cmpArmour = Engine.QueryInterface(ent, IID_DamageReceiver);
 	if (cmpArmour)
 		ret.armour = cmpArmour.GetArmourStrengths();
 
 	let cmpAuras = Engine.QueryInterface(ent, IID_Auras);
 	if (cmpAuras)
 		ret.auras = cmpAuras.GetDescriptions();
 
 	let cmpBuildingAI = Engine.QueryInterface(ent, IID_BuildingAI);
 	if (cmpBuildingAI)
 		ret.buildingAI = {
 			"defaultArrowCount": cmpBuildingAI.GetDefaultArrowCount(),
 			"garrisonArrowMultiplier": cmpBuildingAI.GetGarrisonArrowMultiplier(),
 			"garrisonArrowClasses": cmpBuildingAI.GetGarrisonArrowClasses(),
 			"arrowCount": cmpBuildingAI.GetArrowCount()
 		};
 
 	let cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
 	if (cmpObstruction)
 		ret.obstruction = {
 			"controlGroup": cmpObstruction.GetControlGroup(),
 			"controlGroup2": cmpObstruction.GetControlGroup2(),
 		};
 
 	let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	if (cmpPosition && cmpPosition.GetTurretParent() != INVALID_ENTITY)
 		ret.turretParent = cmpPosition.GetTurretParent();
 
 	let cmpRepairable = Engine.QueryInterface(ent, IID_Repairable);
 	if (cmpRepairable)
 		ret.repairRate = cmpRepairable.GetRepairRate();
 
 	let cmpFoundation = Engine.QueryInterface(ent, IID_Foundation);
 	if (cmpFoundation)
 		ret.buildRate = cmpFoundation.GetBuildRate();
 
 	let cmpResourceSupply = QueryMiragedInterface(ent, IID_ResourceSupply);
 	if (cmpResourceSupply)
 		ret.resourceSupply = {
 			"isInfinite": cmpResourceSupply.IsInfinite(),
 			"max": cmpResourceSupply.GetMaxAmount(),
 			"amount": cmpResourceSupply.GetCurrentAmount(),
 			"type": cmpResourceSupply.GetType(),
 			"killBeforeGather": cmpResourceSupply.GetKillBeforeGather(),
 			"maxGatherers": cmpResourceSupply.GetMaxGatherers(),
 			"numGatherers": cmpResourceSupply.GetNumGatherers()
 		};
 
 	let cmpResourceGatherer = Engine.QueryInterface(ent, IID_ResourceGatherer);
 	if (cmpResourceGatherer)
 		ret.resourceGatherRates = cmpResourceGatherer.GetGatherRates();
 
 	let cmpResourceDropsite = Engine.QueryInterface(ent, IID_ResourceDropsite);
 	if (cmpResourceDropsite)
 		ret.resourceDropsite = {
 			"types": cmpResourceDropsite.GetTypes()
 		};
 
 	let cmpPromotion = Engine.QueryInterface(ent, IID_Promotion);
 	if (cmpPromotion)
 		ret.promotion = {
 			"curr": cmpPromotion.GetCurrentXp(),
 			"req": cmpPromotion.GetRequiredXp()
 		};
 
 	let cmpFoundation = Engine.QueryInterface(ent, IID_Foundation);
 	if (!cmpFoundation && cmpIdentity && cmpIdentity.HasClass("BarterMarket"))
 	{
 		let cmpBarter = Engine.QueryInterface(SYSTEM_ENTITY, IID_Barter);
 		ret.barterMarket = { "prices": cmpBarter.GetPrices() };
 	}
 
 	let cmpHeal = Engine.QueryInterface(ent, IID_Heal);
 	if (cmpHeal)
 		ret.healer = {
 			"unhealableClasses": cmpHeal.GetUnhealableClasses(),
 			"healableClasses": cmpHeal.GetHealableClasses(),
 		};
 
 	return ret;
 };
 
 GuiInterface.prototype.GetAverageRangeForBuildings = function(player, cmd)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 
 	let rot = { "x": 0, "y": 0, "z": 0 };
 	let pos = {
 		"x": cmd.x,
 		"y": cmpTerrain.GetGroundLevel(cmd.x, cmd.z),
 		"z": cmd.z
 	};
 
 	let elevationBonus = cmd.elevationBonus || 0;
 	let range = cmd.range;
 
 	return cmpRangeManager.GetElevationAdaptedRange(pos, rot, range, elevationBonus, 2*Math.PI);
 };
 
 GuiInterface.prototype.GetTemplateData = function(player, extendedName)
 {
 	let name = extendedName;
 	// Special case for garrisoned units which have a extended template
 	if (extendedName.indexOf("&") != -1)
 		name = extendedName.slice(extendedName.indexOf("&")+1);
 
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let template = cmpTemplateManager.GetTemplate(name);
 
 	if (!template)
 		return null;
 
 	return GetTemplateDataHelper(template, player);
 };
 
 GuiInterface.prototype.GetTechnologyData = function(player, name)
 {
 	let cmpTechnologyTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TechnologyTemplateManager);
 	let template = cmpTechnologyTemplateManager.GetTemplate(name);
 
 	if (!template)
 	{
 		warn("Tried to get data for invalid technology: " + name);
 		return null;
 	}
 
 	let cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
 	return GetTechnologyDataHelper(template, cmpPlayer.GetCiv());
 };
 
-GuiInterface.prototype.IsTechnologyResearched = function(player, tech)
+GuiInterface.prototype.IsTechnologyResearched = function(player, data)
 {
-	if (!tech)
+	if (!data.tech)
 		return true;
 
-	let cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
+	let cmpTechnologyManager = QueryPlayerIDInterface(data.player || player, IID_TechnologyManager);
 
 	if (!cmpTechnologyManager)
 		return false;
 
-	return cmpTechnologyManager.IsTechnologyResearched(tech);
+	return cmpTechnologyManager.IsTechnologyResearched(data.tech);
 };
 
 // Checks whether the requirements for this technology have been met
-GuiInterface.prototype.CheckTechnologyRequirements = function(player, tech)
+GuiInterface.prototype.CheckTechnologyRequirements = function(player, data)
 {
-	let cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
+	let cmpTechnologyManager = QueryPlayerIDInterface(data.player || player, IID_TechnologyManager);
 
 	if (!cmpTechnologyManager)
 		return false;
 
-	return cmpTechnologyManager.CanResearch(tech);
+	return cmpTechnologyManager.CanResearch(data.tech);
 };
 
 // Returns technologies that are being actively researched, along with
 // which entity is researching them and how far along the research is.
 GuiInterface.prototype.GetStartedResearch = function(player)
 {
 	let cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
 	if (!cmpTechnologyManager)
 		return false;
 
 	let ret = {};
 	for (let tech in cmpTechnologyManager.GetTechsStarted())
 	{
 		ret[tech] = { "researcher": cmpTechnologyManager.GetResearcher(tech) };
 		let cmpProductionQueue = Engine.QueryInterface(ret[tech].researcher, IID_ProductionQueue);
 		if (cmpProductionQueue)
 			ret[tech].progress = cmpProductionQueue.GetQueue()[0].progress;
 		else
 			ret[tech].progress = 0;
 	}
 	return ret;
 };
 
 // Returns the battle state of the player.
 GuiInterface.prototype.GetBattleState = function(player)
 {
 	let cmpBattleDetection = QueryPlayerIDInterface(player, IID_BattleDetection);
 
 	if (!cmpBattleDetection)
 		return false;
 
 	return cmpBattleDetection.GetState();
 };
 
 // Returns a list of ongoing attacks against the player.
 GuiInterface.prototype.GetIncomingAttacks = function(player)
 {
 	return QueryPlayerIDInterface(player, IID_AttackDetection).GetIncomingAttacks();
 };
 
 // Used to show a red square over GUI elements you can't yet afford.
-GuiInterface.prototype.GetNeededResources = function(player, amounts)
+GuiInterface.prototype.GetNeededResources = function(player, data)
 {
-	return QueryPlayerIDInterface(player).GetNeededResources(amounts);
+	return QueryPlayerIDInterface(data.player || player).GetNeededResources(data.cost);
 };
 
 /**
  * Add a timed notification.
  * Warning: timed notifacations are serialised
  * (to also display them on saved games or after a rejoin)
  * so they should allways be added and deleted in a deterministic way.
  */
 GuiInterface.prototype.AddTimeNotification = function(notification, duration = 10000)
 {
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	notification.endTime = duration + cmpTimer.GetTime();
 	notification.id = ++this.timeNotificationID;
 
 	// Let all players and observers receive the notification by default
 	if (notification.players == undefined)
 	{
 		let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 		let numPlayers = cmpPlayerManager.GetNumPlayers();
 		notification.players = [-1];
 		for (let i = 1; i < numPlayers; ++i)
 			notification.players.push(i);
 	}
 	this.timeNotifications.push(notification);
 	this.timeNotifications.sort((n1, n2) => n2.endTime - n1.endTime);
 
 	cmpTimer.SetTimeout(this.entity, IID_GuiInterface, "DeleteTimeNotification", duration, this.timeNotificationID);
 
 	return this.timeNotificationID;
 };
 
 GuiInterface.prototype.DeleteTimeNotification = function(notificationID)
 {
 	this.timeNotifications = this.timeNotifications.filter(n => n.id != notificationID);
 };
 
 GuiInterface.prototype.GetTimeNotifications = function(playerID)
 {
 	let time = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
 	// filter on players and time, since the delete timer might be executed with a delay
 	return this.timeNotifications.filter(n => n.players.indexOf(playerID) != -1 && n.endTime > time);
 };
 
 GuiInterface.prototype.PushNotification = function(notification)
 {
 	if (!notification.type || notification.type == "text")
 		this.AddTimeNotification(notification);
 	else
 		this.notifications.push(notification);
 };
 
 GuiInterface.prototype.GetNotifications = function()
 {
 	let n = this.notifications;
 	this.notifications = [];
 	return n;
 };
 
 GuiInterface.prototype.GetAvailableFormations = function(player, wantedPlayer)
 {
 	return QueryPlayerIDInterface(wantedPlayer).GetFormations();
 };
 
 GuiInterface.prototype.GetFormationRequirements = function(player, data)
 {
 	return GetFormationRequirements(data.formationTemplate);
 };
 
 GuiInterface.prototype.CanMoveEntsIntoFormation = function(player, data)
 {
 	return CanMoveEntsIntoFormation(data.ents, data.formationTemplate);
 };
 
 GuiInterface.prototype.GetFormationInfoFromTemplate = function(player, data)
 {
 	let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	let template = cmpTemplateManager.GetTemplate(data.templateName);
 
 	if (!template || !template.Formation)
 		return {};
 
 	return {
 		"name": template.Formation.FormationName,
 		"tooltip": template.Formation.DisabledTooltip || "",
 		"icon": template.Formation.Icon
 	};
 };
 
 GuiInterface.prototype.IsFormationSelected = function(player, data)
 {
 	for each (let ent in data.ents)
 	{
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		// GetLastFormationName is named in a strange way as it (also) is
 		// the value of the current formation (see Formation.js LoadFormation)
 		if (cmpUnitAI && cmpUnitAI.GetLastFormationTemplate() == data.formationTemplate)
 			return true;
 	}
 	return false;
 };
 
 GuiInterface.prototype.IsStanceSelected = function(player, data)
 {
 	for each (let ent in data.ents)
 	{
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		if (cmpUnitAI && cmpUnitAI.GetStanceName() == data.stance)
 			return true;
 	}
 	return false;
 };
 
 GuiInterface.prototype.GetAllBuildableEntities = function(player, cmd)
 {
 	let buildableEnts = [];
 	for each (let ent in cmd.entities)
 	{
 		let cmpBuilder = Engine.QueryInterface(ent, IID_Builder);
 		if (!cmpBuilder)
 			continue;
 
 		for (let building of cmpBuilder.GetEntitiesList())
 			if (buildableEnts.indexOf(building) == -1)
 				buildableEnts.push(building);
 	}
 	return buildableEnts;
 };
 
 GuiInterface.prototype.SetSelectionHighlight = function(player, cmd)
 {
 	let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	let playerColors = {}; // cache of owner -> color map
 
 	for each (let ent in cmd.entities)
 	{
 		let cmpSelectable = Engine.QueryInterface(ent, IID_Selectable);
 		if (!cmpSelectable)
 			continue;
 
 		// Find the entity's owner's color:
 		let owner = -1;
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (cmpOwnership)
 			owner = cmpOwnership.GetOwner();
 
 		let color = playerColors[owner];
 		if (!color)
 		{
 			color = { "r":1, "g":1, "b":1 };
 			let cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(owner), IID_Player);
 			if (cmpPlayer)
 				color = cmpPlayer.GetColor();
 			playerColors[owner] = color;
 		}
 
 		cmpSelectable.SetSelectionHighlight({ "r": color.r, "g": color.g, "b": color.b, "a": cmd.alpha }, cmd.selected);
 	}
 };
 
 GuiInterface.prototype.GetEntitiesWithStatusBars = function()
 {
 	return [...this.entsWithAuraAndStatusBars];
 };
 
 GuiInterface.prototype.SetStatusBars = function(player, cmd)
 {
 	let affectedEnts = new Set();
 	for (let ent of cmd.entities)
 	{
 		let cmpStatusBars = Engine.QueryInterface(ent, IID_StatusBars);
 		if (!cmpStatusBars)
 			continue;
 		cmpStatusBars.SetEnabled(cmd.enabled);
 
 		let cmpAuras = Engine.QueryInterface(ent, IID_Auras);
 		if (!cmpAuras)
 			continue;
 
 		for (let name of cmpAuras.GetAuraNames())
 		{
 			if (!cmpAuras.GetOverlayIcon(name))
 				continue;
 			for (let e of cmpAuras.GetAffectedEntities(name))
 				affectedEnts.add(e);
 			if (cmd.enabled)
 				this.entsWithAuraAndStatusBars.add(ent);
 			else
 				this.entsWithAuraAndStatusBars.delete(ent);
 		}
 	}
 
 	for (let ent of affectedEnts)
 	{
 		let cmpStatusBars = Engine.QueryInterface(ent, IID_StatusBars);
 		if (cmpStatusBars)
 			cmpStatusBars.RegenerateSprites();
 	}
 };
 
 GuiInterface.prototype.GetPlayerEntities = function(player)
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetEntitiesByPlayer(player);
 };
 
 /**
  * Displays the rally points of a given list of entities (carried in cmd.entities).
  *
  * The 'cmd' object may carry its own x/z coordinate pair indicating the location where the rally point should
  * be rendered, in order to support instantaneously rendering a rally point marker at a specified location
  * instead of incurring a delay while PostNetworkCommand processes the set-rallypoint command (see input.js).
  * If cmd doesn't carry a custom location, then the position to render the marker at will be read from the
  * RallyPoint component.
  */
 GuiInterface.prototype.DisplayRallyPoint = function(player, cmd)
 {
 	let cmpPlayer = QueryPlayerIDInterface(player);
 
 	// If there are some rally points already displayed, first hide them
 	for each (let ent in this.entsRallyPointsDisplayed)
 	{
 		let cmpRallyPointRenderer = Engine.QueryInterface(ent, IID_RallyPointRenderer);
 		if (cmpRallyPointRenderer)
 			cmpRallyPointRenderer.SetDisplayed(false);
 	}
 
 	this.entsRallyPointsDisplayed = [];
 
 	// Show the rally points for the passed entities
 	for each (let ent in cmd.entities)
 	{
 		let cmpRallyPointRenderer = Engine.QueryInterface(ent, IID_RallyPointRenderer);
 		if (!cmpRallyPointRenderer)
 			continue;
 
 		// entity must have a rally point component to display a rally point marker
 		// (regardless of whether cmd specifies a custom location)
 		let cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 		if (!cmpRallyPoint)
 			continue;
 
 		// Verify the owner
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (!(cmpPlayer && cmpPlayer.CanControlAllUnits()))
 			if (!cmpOwnership || cmpOwnership.GetOwner() != player)
 				continue;
 
 		// If the command was passed an explicit position, use that and
 		// override the real rally point position; otherwise use the real position
 		let pos;
 		if (cmd.x && cmd.z)
 			pos = cmd;
 		else
 			pos = cmpRallyPoint.GetPositions()[0]; // may return undefined if no rally point is set
 
 		if (pos)
 		{
 			// Only update the position if we changed it (cmd.queued is set)
 			if ("queued" in cmd)
 				if (cmd.queued == true)
 					cmpRallyPointRenderer.AddPosition({ 'x': pos.x, 'y': pos.z }); // AddPosition takes a CFixedVector2D which has X/Y components, not X/Z
 				else
 					cmpRallyPointRenderer.SetPosition({ 'x': pos.x, 'y': pos.z }); // SetPosition takes a CFixedVector2D which has X/Y components, not X/Z
 
 			// rebuild the renderer when not set (when reading saved game or in case of building update)
 			else if (!cmpRallyPointRenderer.IsSet())
 				for each (let posi in cmpRallyPoint.GetPositions())
 					cmpRallyPointRenderer.AddPosition({ 'x': posi.x, 'y': posi.z });
 
 			cmpRallyPointRenderer.SetDisplayed(true);
 
 			// remember which entities have their rally points displayed so we can hide them again
 			this.entsRallyPointsDisplayed.push(ent);
 		}
 	}
 };
 
 /**
  * Display the building placement preview.
  * cmd.template is the name of the entity template, or "" to disable the preview.
  * cmd.x, cmd.z, cmd.angle give the location.
  *
  * Returns result object from CheckPlacement:
  * 	{
  *		"success":             true iff the placement is valid, else false
  *		"message":             message to display in UI for invalid placement, else ""
  *		"parameters":          parameters to use in the message
  *		"translateMessage":    localisation info
  *		"translateParameters": localisation info
  *		"pluralMessage":       we might return a plural translation instead (optional)
  *		"pluralCount":         localisation info (optional)
  *  }
  */
 GuiInterface.prototype.SetBuildingPlacementPreview = function(player, cmd)
 {
 	let result = {
 		"success": false,
 		"message": "",
 		"parameters": {},
 		"translateMessage": false,
 		"translateParameters": [],
 	};
 
 	// See if we're changing template
 	if (!this.placementEntity || this.placementEntity[0] != cmd.template)
 	{
 		// Destroy the old preview if there was one
 		if (this.placementEntity)
 			Engine.DestroyEntity(this.placementEntity[1]);
 
 		// Load the new template
 		if (cmd.template == "")
 			this.placementEntity = undefined;
 		else
 			this.placementEntity = [cmd.template, Engine.AddLocalEntity("preview|" + cmd.template)];
 	}
 
 	if (this.placementEntity)
 	{
 		let ent = this.placementEntity[1];
 
 		// Move the preview into the right location
 		let pos = Engine.QueryInterface(ent, IID_Position);
 		if (pos)
 		{
 			pos.JumpTo(cmd.x, cmd.z);
 			pos.SetYRotation(cmd.angle);
 		}
 
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		cmpOwnership.SetOwner(player);
 
 		// Check whether building placement is valid
 		let cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 		if (!cmpBuildRestrictions)
 			error("cmpBuildRestrictions not defined");
 		else
 			result = cmpBuildRestrictions.CheckPlacement();
 
 		// Set it to a red shade if this is an invalid location
 		let cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 		if (cmpVisual)
 		{
 			if (cmd.actorSeed !== undefined)
 				cmpVisual.SetActorSeed(cmd.actorSeed);
 
 			if (!result.success)
 				cmpVisual.SetShadingColor(1.4, 0.4, 0.4, 1);
 			else
 				cmpVisual.SetShadingColor(1, 1, 1, 1);
 		}
 	}
 
 	return result;
 };
 
 /**
  * Previews the placement of a wall between cmd.start and cmd.end, or just the starting piece of a wall if cmd.end is not
  * specified. Returns an object with information about the list of entities that need to be newly constructed to complete
  * at least a part of the wall, or false if there are entities required to build at least part of the wall but none of
  * them can be validly constructed.
  *
  * It's important to distinguish between three lists of entities that are at play here, because they may be subsets of one
  * another depending on things like snapping and whether some of the entities inside them can be validly positioned.
  * We have:
  *    - The list of entities that previews the wall. This list is usually equal to the entities required to construct the
  *      entire wall. However, if there is snapping to an incomplete tower (i.e. a foundation), it includes extra entities
  *      to preview the completed tower on top of its foundation.
  *
  *    - The list of entities that need to be newly constructed to build the entire wall. This list is regardless of whether
  *      any of them can be validly positioned. The emphasishere here is on 'newly'; this list does not include any existing
  *      towers at either side of the wall that we snapped to. Or, more generally; it does not include any _entities_ that we
  *      snapped to; we might still snap to e.g. terrain, in which case the towers on either end will still need to be newly
  *      constructed.
  *
  *    - The list of entities that need to be newly constructed to build at least a part of the wall. This list is the same
  *      as the one above, except that it is truncated at the first entity that cannot be validly positioned. This happens
  *      e.g. if the player tries to build a wall straight through an obstruction. Note that any entities that can be validly
  *      constructed but come after said first invalid entity are also truncated away.
  *
  * With this in mind, this method will return false if the second list is not empty, but the third one is. That is, if there
  * were entities that are needed to build the wall, but none of them can be validly constructed. False is also returned in
  * case of unexpected errors (typically missing components), and when clearing the preview by passing an empty wallset
  * argument (see below). Otherwise, it will return an object with the following information:
  *
  * result: {
  *   'startSnappedEnt':   ID of the entity that we snapped to at the starting side of the wall. Currently only supports towers.
  *   'endSnappedEnt':     ID of the entity that we snapped to at the (possibly truncated) ending side of the wall. Note that this
  *                        can only be set if no truncation of the second list occurs; if we snapped to an entity at the ending side
  *                        but the wall construction was truncated before we could reach it, it won't be set here. Currently only
  *                        supports towers.
  *   'pieces':            Array with the following data for each of the entities in the third list:
  *    [{
  *       'template':      Template name of the entity.
  *       'x':             X coordinate of the entity's position.
  *       'z':             Z coordinate of the entity's position.
  *       'angle':         Rotation around the Y axis of the entity (in radians).
  *     },
  *     ...]
  *   'cost': {            The total cost required for constructing all the pieces as listed above.
  *     'food': ...,
  *     'wood': ...,
  *     'stone': ...,
  *     'metal': ...,
  *     'population': ...,
  *     'populationBonus': ...,
  *   }
  * }
  *
  * @param cmd.wallSet Object holding the set of wall piece template names. Set to an empty value to clear the preview.
  * @param cmd.start Starting point of the wall segment being created.
  * @param cmd.end (Optional) Ending point of the wall segment being created. If not defined, it is understood that only
  *                 the starting point of the wall is available at this time (e.g. while the player is still in the process
  *                 of picking a starting point), and that therefore only the first entity in the wall (a tower) should be
  *                 previewed.
  * @param cmd.snapEntities List of candidate entities to snap the start and ending positions to.
  */
 GuiInterface.prototype.SetWallPlacementPreview = function(player, cmd)
 {
 	let wallSet = cmd.wallSet;
 
 	let start = {
 		"pos": cmd.start,
 		"angle": 0,
 		"snapped": false,                       // did the start position snap to anything?
 		"snappedEnt": INVALID_ENTITY,           // if we snapped, was it to an entity? if yes, holds that entity's ID
 	};
 
 	let end = {
 		"pos": cmd.end,
 		"angle": 0,
 		"snapped": false,                       // did the start position snap to anything?
 		"snappedEnt": INVALID_ENTITY,           // if we snapped, was it to an entity? if yes, holds that entity's ID
 	};
 
 	// --------------------------------------------------------------------------------
 	// do some entity cache management and check for snapping
 
 	if (!this.placementWallEntities)
 		this.placementWallEntities = {};
 
 	if (!wallSet)
 	{
 		// we're clearing the preview, clear the entity cache and bail
 		for (let tpl in this.placementWallEntities)
 		{
 			for each (let ent in this.placementWallEntities[tpl].entities)
 				Engine.DestroyEntity(ent);
 
 			this.placementWallEntities[tpl].numUsed = 0;
 			this.placementWallEntities[tpl].entities = [];
 			// keep template data around
 		}
 
 		return false;
 	}
 	else
 	{
 		// Move all existing cached entities outside of the world and reset their use count
 		for (let tpl in this.placementWallEntities)
 		{
 			for each (let ent in this.placementWallEntities[tpl].entities)
 			{
 				let pos = Engine.QueryInterface(ent, IID_Position);
 				if (pos)
 					pos.MoveOutOfWorld();
 			}
 
 			this.placementWallEntities[tpl].numUsed = 0;
 		}
 
 		// Create cache entries for templates we haven't seen before
 		for each (let tpl in wallSet.templates)
 		{
 			if (!(tpl in this.placementWallEntities))
 			{
 				this.placementWallEntities[tpl] = {
 					"numUsed": 0,
 					"entities": [],
 					"templateData": this.GetTemplateData(player, tpl),
 				};
 
 				// ensure that the loaded template data contains a wallPiece component
 				if (!this.placementWallEntities[tpl].templateData.wallPiece)
 				{
 					error("[SetWallPlacementPreview] No WallPiece component found for wall set template '" + tpl + "'");
 					return false;
 				}
 			}
 		}
 	}
 
 	// prevent division by zero errors further on if the start and end positions are the same
 	if (end.pos && (start.pos.x === end.pos.x && start.pos.z === end.pos.z))
 		end.pos = undefined;
 
 	// See if we need to snap the start and/or end coordinates to any of our list of snap entities. Note that, despite the list
 	// of snapping candidate entities, it might still snap to e.g. terrain features. Use the "ent" key in the returned snapping
 	// data to determine whether it snapped to an entity (if any), and to which one (see GetFoundationSnapData).
 	if (cmd.snapEntities)
 	{
 		let snapRadius = this.placementWallEntities[wallSet.templates.tower].templateData.wallPiece.length * 0.5; // determined through trial and error
 		let startSnapData = this.GetFoundationSnapData(player, {
 			"x": start.pos.x,
 			"z": start.pos.z,
 			"template": wallSet.templates.tower,
 			"snapEntities": cmd.snapEntities,
 			"snapRadius": snapRadius,
 		});
 
 		if (startSnapData)
 		{
 			start.pos.x = startSnapData.x;
 			start.pos.z = startSnapData.z;
 			start.angle = startSnapData.angle;
 			start.snapped = true;
 
 			if (startSnapData.ent)
 				start.snappedEnt = startSnapData.ent;
 		}
 
 		if (end.pos)
 		{
 			let endSnapData = this.GetFoundationSnapData(player, {
 				"x": end.pos.x,
 				"z": end.pos.z,
 				"template": wallSet.templates.tower,
 				"snapEntities": cmd.snapEntities,
 				"snapRadius": snapRadius,
 			});
 
 			if (endSnapData)
 			{
 				end.pos.x = endSnapData.x;
 				end.pos.z = endSnapData.z;
 				end.angle = endSnapData.angle;
 				end.snapped = true;
 
 				if (endSnapData.ent)
 					end.snappedEnt = endSnapData.ent;
 			}
 		}
 	}
 
 	// clear the single-building preview entity (we'll be rolling our own)
 	this.SetBuildingPlacementPreview(player, { "template": "" });
 
 	// --------------------------------------------------------------------------------
 	// calculate wall placement and position preview entities
 
 	let result = {
 		"pieces": [],
 		"cost": { "food": 0, "wood": 0, "stone": 0, "metal": 0, "population": 0, "populationBonus": 0, "time": 0 },
 	};
 
 	let previewEntities = [];
 	if (end.pos)
 		previewEntities = GetWallPlacement(this.placementWallEntities, wallSet, start, end); // see helpers/Walls.js
 
 	// For wall placement, we may (and usually do) need to have wall pieces overlap each other more than would
 	// otherwise be allowed by their obstruction shapes. However, during this preview phase, this is not so much of
 	// an issue, because all preview entities have their obstruction components deactivated, meaning that their
 	// obstruction shapes do not register in the simulation and hence cannot affect it. This implies that the preview
 	// entities cannot be found to obstruct each other, which largely solves the issue of overlap between wall pieces.
 
 	// Note that they will still be obstructed by existing shapes in the simulation (that have the BLOCK_FOUNDATION
 	// flag set), which is what we want. The only exception to this is when snapping to existing towers (or
 	// foundations thereof); the wall segments that connect up to these will be found to be obstructed by the
 	// existing tower/foundation, and be shaded red to indicate that they cannot be placed there. To prevent this,
 	// we manually set the control group of the outermost wall pieces equal to those of the snapped-to towers, so
 	// that they are free from mutual obstruction (per definition of obstruction control groups). This is done by
 	// assigning them an extra "controlGroup" field, which we'll then set during the placement loop below.
 
 	// Additionally, in the situation that we're snapping to merely a foundation of a tower instead of a fully
 	// constructed one, we'll need an extra preview entity for the starting tower, which also must not be obstructed
 	// by the foundation it snaps to.
 
 	if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
 	{
 		let startEntObstruction = Engine.QueryInterface(start.snappedEnt, IID_Obstruction);
 		if (previewEntities.length > 0 && startEntObstruction)
 			previewEntities[0].controlGroups = [startEntObstruction.GetControlGroup()];
 
 		// if we're snapping to merely a foundation, add an extra preview tower and also set it to the same control group
 		let startEntState = this.GetEntityState(player, start.snappedEnt);
 		if (startEntState.foundation)
 		{
 			let cmpPosition = Engine.QueryInterface(start.snappedEnt, IID_Position);
 			if (cmpPosition)
 				previewEntities.unshift({
 					"template": wallSet.templates.tower,
 					"pos": start.pos,
 					"angle": cmpPosition.GetRotation().y,
 					"controlGroups": [(startEntObstruction ? startEntObstruction.GetControlGroup() : undefined)],
 					"excludeFromResult": true, // preview only, must not appear in the result
 				});
 		}
 	}
 	else
 	{
 		// Didn't snap to an existing entity, add the starting tower manually. To prevent odd-looking rotation jumps
 		// when shift-clicking to build a wall, reuse the placement angle that was last seen on a validly positioned
 		// wall piece.
 
 		// To illustrate the last point, consider what happens if we used some constant instead, say, 0. Issuing the
 		// build command for a wall is asynchronous, so when the preview updates after shift-clicking, the wall piece
 		// foundations are not registered yet in the simulation. This means they cannot possibly be picked in the list
 		// of candidate entities for snapping. In the next preview update, we therefore hit this case, and would rotate
 		// the preview to 0 radians. Then, after one or two simulation updates or so, the foundations register and
 		// onSimulationUpdate in session.js updates the preview again. It first grabs a new list of snapping candidates,
 		// which this time does include the new foundations; so we snap to the entity, and rotate the preview back to
 		// the foundation's angle.
 
 		// The result is a noticeable rotation to 0 and back, which is undesirable. So, for a split second there until
 		// the simulation updates, we fake it by reusing the last angle and hope the player doesn't notice.
 		previewEntities.unshift({
 			"template": wallSet.templates.tower,
 			"pos": start.pos,
 			"angle": (previewEntities.length > 0 ? previewEntities[0].angle : this.placementWallLastAngle)
 		});
 	}
 
 	if (end.pos)
 	{
 		// Analogous to the starting side case above
 		if (end.snappedEnt && end.snappedEnt != INVALID_ENTITY)
 		{
 			let endEntObstruction = Engine.QueryInterface(end.snappedEnt, IID_Obstruction);
 
 			// Note that it's possible for the last entity in previewEntities to be the same as the first, i.e. the
 			// same wall piece snapping to both a starting and an ending tower. And it might be more common than you would
 			// expect; the allowed overlap between wall segments and towers facilitates this to some degree. To deal with
 			// the possibility of dual initial control groups, we use a '.controlGroups' array rather than a single
 			// '.controlGroup' property. Note that this array can only ever have 0, 1 or 2 elements (checked at a later time).
 			if (previewEntities.length > 0 && endEntObstruction)
 			{
 				previewEntities[previewEntities.length-1].controlGroups = (previewEntities[previewEntities.length-1].controlGroups || []);
 				previewEntities[previewEntities.length-1].controlGroups.push(endEntObstruction.GetControlGroup());
 			}
 
 			// if we're snapping to a foundation, add an extra preview tower and also set it to the same control group
 			let endEntState = this.GetEntityState(player, end.snappedEnt);
 			if (endEntState.foundation)
 			{
 				let cmpPosition = Engine.QueryInterface(end.snappedEnt, IID_Position);
 				if (cmpPosition)
 					previewEntities.push({
 						"template": wallSet.templates.tower,
 						"pos": end.pos,
 						"angle": cmpPosition.GetRotation().y,
 						"controlGroups": [(endEntObstruction ? endEntObstruction.GetControlGroup() : undefined)],
 						"excludeFromResult": true
 					});
 			}
 		}
 		else
 			previewEntities.push({
 				"template": wallSet.templates.tower,
 				"pos": end.pos,
 				"angle": (previewEntities.length > 0 ? previewEntities[previewEntities.length-1].angle : this.placementWallLastAngle)
 			});
 	}
 
 	let cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 	if (!cmpTerrain)
 	{
 		error("[SetWallPlacementPreview] System Terrain component not found");
 		return false;
 	}
 
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (!cmpRangeManager)
 	{
 		error("[SetWallPlacementPreview] System RangeManager component not found");
 		return false;
 	}
 
 	// Loop through the preview entities, and construct the subset of them that need to be, and can be, validly constructed
 	// to build at least a part of the wall (meaning that the subset is truncated after the first entity that needs to be,
 	// but cannot validly be, constructed). See method-level documentation for more details.
 
 	let allPiecesValid = true;
 	let numRequiredPieces = 0; // number of entities that are required to build the entire wall, regardless of validity
 
 	for (let i = 0; i < previewEntities.length; ++i)
 	{
 		let entInfo = previewEntities[i];
 
 		let ent = null;
 		let tpl = entInfo.template;
 		let tplData = this.placementWallEntities[tpl].templateData;
 		let entPool = this.placementWallEntities[tpl];
 
 		if (entPool.numUsed >= entPool.entities.length)
 		{
 			// allocate new entity
 			ent = Engine.AddLocalEntity("preview|" + tpl);
 			entPool.entities.push(ent);
 		}
 		else
 			 // reuse an existing one
 			ent = entPool.entities[entPool.numUsed];
 
 		if (!ent)
 		{
 			error("[SetWallPlacementPreview] Failed to allocate or reuse preview entity of template '" + tpl + "'");
 			continue;
 		}
 
 		// move piece to right location
 		// TODO: consider reusing SetBuildingPlacementReview for this, enhanced to be able to deal with multiple entities
 		let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 		if (cmpPosition)
 		{
 			cmpPosition.JumpTo(entInfo.pos.x, entInfo.pos.z);
 			cmpPosition.SetYRotation(entInfo.angle);
 
 			// if this piece is a tower, then it should have a Y position that is at least as high as its surrounding pieces
 			if (tpl === wallSet.templates.tower)
 			{
 				let terrainGroundPrev = null;
 				let terrainGroundNext = null;
 
 				if (i > 0)
 					terrainGroundPrev = cmpTerrain.GetGroundLevel(previewEntities[i-1].pos.x, previewEntities[i-1].pos.z);
 
 				if (i < previewEntities.length - 1)
 					terrainGroundNext = cmpTerrain.GetGroundLevel(previewEntities[i+1].pos.x, previewEntities[i+1].pos.z);
 
 				if (terrainGroundPrev != null || terrainGroundNext != null)
 				{
 					let targetY = Math.max(terrainGroundPrev, terrainGroundNext);
 					cmpPosition.SetHeightFixed(targetY);
 				}
 			}
 		}
 
 		let cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
 		if (!cmpObstruction)
 		{
 			error("[SetWallPlacementPreview] Preview entity of template '" + tpl + "' does not have an Obstruction component");
 			continue;
 		}
 
 		// Assign any predefined control groups. Note that there can only be 0, 1 or 2 predefined control groups; if there are
 		// more, we've made a programming error. The control groups are assigned from the entInfo.controlGroups array on a
 		// first-come first-served basis; the first value in the array is always assigned as the primary control group, and
 		// any second value as the secondary control group.
 
 		// By default, we reset the control groups to their standard values. Remember that we're reusing entities; if we don't
 		// reset them, then an ending wall segment that was e.g. at one point snapped to an existing tower, and is subsequently
 		// reused as a non-snapped ending wall segment, would no longer be capable of being obstructed by the same tower it was
 		// once snapped to.
 
 		let primaryControlGroup = ent;
 		let secondaryControlGroup = INVALID_ENTITY;
 
 		if (entInfo.controlGroups && entInfo.controlGroups.length > 0)
 		{
 			if (entInfo.controlGroups.length > 2)
 			{
 				error("[SetWallPlacementPreview] Encountered preview entity of template '" + tpl + "' with more than 2 initial control groups");
 				break;
 			}
 
 			primaryControlGroup = entInfo.controlGroups[0];
 			if (entInfo.controlGroups.length > 1)
 				secondaryControlGroup = entInfo.controlGroups[1];
 		}
 
 		cmpObstruction.SetControlGroup(primaryControlGroup);
 		cmpObstruction.SetControlGroup2(secondaryControlGroup);
 
 		// check whether this wall piece can be validly positioned here
 		let validPlacement = false;
 
 		let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		cmpOwnership.SetOwner(player);
 
 		// Check whether it's in a visible or fogged region
 		// TODO: should definitely reuse SetBuildingPlacementPreview, this is just straight up copy/pasta
 		let visible = (cmpRangeManager.GetLosVisibility(ent, player) != "hidden");
 		if (visible)
 		{
 			let cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 			if (!cmpBuildRestrictions)
 			{
 				error("[SetWallPlacementPreview] cmpBuildRestrictions not defined for preview entity of template '" + tpl + "'");
 				continue;
 			}
 
 			// TODO: Handle results of CheckPlacement
 			validPlacement = (cmpBuildRestrictions && cmpBuildRestrictions.CheckPlacement().success);
 
 			// If a wall piece has two control groups, it's likely a segment that spans
 			// between two existing towers. To avoid placing a duplicate wall segment,
 			// check for collisions with entities that share both control groups.
 			if (validPlacement && entInfo.controlGroups && entInfo.controlGroups.length > 1)
 				validPlacement = cmpObstruction.CheckDuplicateFoundation();
 		}
 
 		allPiecesValid = allPiecesValid && validPlacement;
 
 		// The requirement below that all pieces so far have to have valid positions, rather than only this single one,
 		// ensures that no more foundations will be placed after a first invalidly-positioned piece. (It is possible
 		// for pieces past some invalidly-positioned ones to still have valid positions, e.g. if you drag a wall
 		// through and past an existing building).
 
 		// Additionally, the excludeFromResult flag is set for preview entities that were manually added to be placed
 		// on top of foundations of incompleted towers that we snapped to; they must not be part of the result.
 
 		if (!entInfo.excludeFromResult)
 			++numRequiredPieces;
 
 		if (allPiecesValid && !entInfo.excludeFromResult)
 		{
 			result.pieces.push({
 				"template": tpl,
 				"x": entInfo.pos.x,
 				"z": entInfo.pos.z,
 				"angle": entInfo.angle,
 			});
 			this.placementWallLastAngle = entInfo.angle;
 
 			// grab the cost of this wall piece and add it up (note; preview entities don't have their Cost components
 			// copied over, so we need to fetch it from the template instead).
 			// TODO: we should really use a Cost object or at least some utility functions for this, this is mindless
 			// boilerplate that's probably duplicated in tons of places.
 			result.cost.food += tplData.cost.food;
 			result.cost.wood += tplData.cost.wood;
 			result.cost.stone += tplData.cost.stone;
 			result.cost.metal += tplData.cost.metal;
 			result.cost.population += tplData.cost.population;
 			result.cost.populationBonus += tplData.cost.populationBonus;
 			result.cost.time += tplData.cost.time;
 		}
 
 		let canAfford = true;
 		let cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
 		if (cmpPlayer && cmpPlayer.GetNeededResources(result.cost))
 			canAfford = false;
 
 		let cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 		if (cmpVisual)
 		{
 			if (!allPiecesValid || !canAfford)
 				cmpVisual.SetShadingColor(1.4, 0.4, 0.4, 1);
 			else
 				cmpVisual.SetShadingColor(1, 1, 1, 1);
 		}
 
 		++entPool.numUsed;
 	}
 
 	// If any were entities required to build the wall, but none of them could be validly positioned, return failure
 	// (see method-level documentation).
 	if (numRequiredPieces > 0 && result.pieces.length == 0)
 		return false;
 
 	if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
 		result.startSnappedEnt = start.snappedEnt;
 
 	// We should only return that we snapped to an entity if all pieces up until that entity can be validly constructed,
 	// i.e. are included in result.pieces (see docs for the result object).
 	if (end.pos && end.snappedEnt && end.snappedEnt != INVALID_ENTITY && allPiecesValid)
 		result.endSnappedEnt = end.snappedEnt;
 
 	return result;
 };
 
 /**
  * Given the current position {data.x, data.z} of an foundation of template data.template, returns the position and angle to snap
  * it to (if necessary/useful).
  *
  * @param data.x            The X position of the foundation to snap.
  * @param data.z            The Z position of the foundation to snap.
  * @param data.template     The template to get the foundation snapping data for.
  * @param data.snapEntities Optional; list of entity IDs to snap to if {data.x, data.z} is within a circle of radius data.snapRadius
  *                            around the entity. Only takes effect when used in conjunction with data.snapRadius.
  *                          When this option is used and the foundation is found to snap to one of the entities passed in this list
  *                            (as opposed to e.g. snapping to terrain features), then the result will contain an additional key "ent",
  *                            holding the ID of the entity that was snapped to.
  * @param data.snapRadius   Optional; when used in conjunction with data.snapEntities, indicates the circle radius around an entity that
  *                            {data.x, data.z} must be located within to have it snap to that entity.
  */
 GuiInterface.prototype.GetFoundationSnapData = function(player, data)
 {
 	let template = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).GetTemplate(data.template);
 	if (!template)
 	{
 		warn("[GetFoundationSnapData] Failed to load template '" + data.template + "'");
 		return false;
 	}
 
 	if (data.snapEntities && data.snapRadius && data.snapRadius > 0)
 	{
 		// see if {data.x, data.z} is inside the snap radius of any of the snap entities; and if so, to which it is closest
 		// (TODO: break unlikely ties by choosing the lowest entity ID)
 
 		let minDist2 = -1;
 		let minDistEntitySnapData = null;
 		let radius2 = data.snapRadius * data.snapRadius;
 
 		for each (let ent in data.snapEntities)
 		{
 			let cmpPosition = Engine.QueryInterface(ent, IID_Position);
 			if (!cmpPosition || !cmpPosition.IsInWorld())
 				continue;
 
 			let pos = cmpPosition.GetPosition();
 			let dist2 = (data.x - pos.x) * (data.x - pos.x) + (data.z - pos.z) * (data.z - pos.z);
 			if (dist2 > radius2)
 				continue;
 
 			if (minDist2 < 0 || dist2 < minDist2)
 			{
 				minDist2 = dist2;
 				minDistEntitySnapData = {
 						"x": pos.x,
 						"z": pos.z,
 						"angle": cmpPosition.GetRotation().y,
 						"ent": ent
 				};
 			}
 		}
 
 		if (minDistEntitySnapData != null)
 			return minDistEntitySnapData;
 	}
 
 	if (template.BuildRestrictions.Category == "Dock")
 	{
 		let angle = GetDockAngle(template, data.x, data.z);
 		if (angle !== undefined)
 			return {
 				"x": data.x,
 				"z": data.z,
 				"angle": angle
 			};
 	}
 
 	return false;
 };
 
 GuiInterface.prototype.PlaySound = function(player, data)
 {
 	if (!data.entity)
 		return;
 
 	PlaySound(data.name, data.entity);
 };
 
 GuiInterface.prototype.FindIdleUnits = function(player, data)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let playerEntities = cmpRangeManager.GetEntitiesByPlayer(player).filter(function(e) {
 
 		let cmpUnitAI = Engine.QueryInterface(e, IID_UnitAI);
 		if (!cmpUnitAI || !cmpUnitAI.IsIdle() || cmpUnitAI.IsGarrisoned())
 			return false;
 
 		let cmpIdentity = Engine.QueryInterface(e, IID_Identity);
 		if (!cmpIdentity || !cmpIdentity.HasClass(data.idleClass))
 			return false;
 
 		return true;
 	});
 
 	let idleUnits = [];
 
 	for (let ent of playerEntities)
 	{
 		if (ent <= data.prevUnit|0 || data.excludeUnits.indexOf(ent) > -1)
 			continue;
 		idleUnits.push(ent);
 		if (data.limit && idleUnits.length >= data.limit)
 			break;
 	}
 
 	return idleUnits;
 };
 
 GuiInterface.prototype.GetTradingRouteGain = function(player, data)
 {
 	if (!data.firstMarket || !data.secondMarket)
 		return null;
 
 	return CalculateTraderGain(data.firstMarket, data.secondMarket, data.template);
 };
 
 GuiInterface.prototype.GetTradingDetails = function(player, data)
 {
 	let cmpEntityTrader = Engine.QueryInterface(data.trader, IID_Trader);
 	if (!cmpEntityTrader || !cmpEntityTrader.CanTrade(data.target))
 		return null;
 
 	let firstMarket = cmpEntityTrader.GetFirstMarket();
 	let secondMarket = cmpEntityTrader.GetSecondMarket();
 	let result = null;
 	if (data.target === firstMarket)
 	{
 		result = {
 			"type": "is first",
 			"hasBothMarkets": cmpEntityTrader.HasBothMarkets()
 		};
 		if (cmpEntityTrader.HasBothMarkets())
 			result.gain = cmpEntityTrader.GetGain();
 	}
 	else if (data.target === secondMarket)
 	{
 		result = {
 			"type": "is second",
 			"gain": cmpEntityTrader.GetGain(),
 		};
 	}
 	else if (!firstMarket)
 	{
 		result = { "type": "set first" };
 	}
 	else if (!secondMarket)
 	{
 		result = {
 			"type": "set second",
 			"gain": cmpEntityTrader.CalculateGain(firstMarket, data.target),
 		};
 	}
 	else
 	{
 		// Else both markets are not null and target is different from them
 		result = { "type": "set first" };
 	}
 	return result;
 };
 
 GuiInterface.prototype.CanCapture = function(player, data)
 {
 	let cmpAttack = Engine.QueryInterface(data.entity, IID_Attack);
 	if (!cmpAttack)
 		return false;
 
 	let owner = QueryOwnerInterface(data.entity).GetPlayerID();
 
 	let cmpCapturable = QueryMiragedInterface(data.target, IID_Capturable);
 	if (cmpCapturable && cmpCapturable.CanCapture(owner) && cmpAttack.GetAttackTypes().indexOf("Capture") != -1)
 		return cmpAttack.CanAttack(data.target);
 
 	return false;
 };
 
 GuiInterface.prototype.CanAttack = function(player, data)
 {
 	let cmpAttack = Engine.QueryInterface(data.entity, IID_Attack);
 	if (!cmpAttack)
 		return false;
 
 	let cmpEntityPlayer = QueryOwnerInterface(data.entity, IID_Player);
 	let cmpTargetPlayer = QueryOwnerInterface(data.target, IID_Player);
 	if (!cmpEntityPlayer || !cmpTargetPlayer)
 		return false;
 
 	// if the owner is an enemy, it's up to the attack component to decide
 	if (cmpEntityPlayer.IsEnemy(cmpTargetPlayer.GetPlayerID()))
 		return cmpAttack.CanAttack(data.target);
 
 	return false;
 };
 
 /*
  * Returns batch build time.
  */
 GuiInterface.prototype.GetBatchTime = function(player, data)
 {
 	let cmpProductionQueue = Engine.QueryInterface(data.entity, IID_ProductionQueue);
 	if (!cmpProductionQueue)
 		return 0;
 
 	return cmpProductionQueue.GetBatchTime(data.batchSize);
 };
 
 GuiInterface.prototype.IsMapRevealed = function(player)
 {
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).GetLosRevealAll(player);
 };
 
 GuiInterface.prototype.SetPathfinderDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder).SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetPathfinderHierDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder).SetHierDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetObstructionDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager).SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetMotionDebugOverlay = function(player, data)
 {
 	for each (let ent in data.entities)
 	{
 		let cmpUnitMotion = Engine.QueryInterface(ent, IID_UnitMotion);
 		if (cmpUnitMotion)
 			cmpUnitMotion.SetDebugOverlay(data.enabled);
 	}
 };
 
 GuiInterface.prototype.SetRangeDebugOverlay = function(player, enabled)
 {
 	Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.GetTraderNumber = function(player)
 {
 	let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	let traders = cmpRangeManager.GetEntitiesByPlayer(player).filter(e => Engine.QueryInterface(e, IID_Trader));
 
 	let landTrader = { "total": 0, "trading": 0, "garrisoned": 0 };
 	let shipTrader = { "total": 0, "trading": 0 };
 
 	for each (let ent in traders)
 	{
 		let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 		let cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		if (!cmpIdentity || !cmpUnitAI)
 			continue;
 
 		if (cmpIdentity.HasClass("Ship"))
 		{
 			++shipTrader.total;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Trade")
 				++shipTrader.trading;
 		}
 		else
 		{
 			++landTrader.total;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Trade")
 				++landTrader.trading;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Garrison")
 			{
 				let holder = cmpUnitAI.order.data.target;
 				let cmpHolderUnitAI = Engine.QueryInterface(holder, IID_UnitAI);
 				if (cmpHolderUnitAI && cmpHolderUnitAI.order && cmpHolderUnitAI.order.type == "Trade")
 					++landTrader.garrisoned;
 			}
 		}
 	}
 
 	return { "landTrader": landTrader, "shipTrader": shipTrader };
 };
 
 GuiInterface.prototype.GetTradingGoods = function(player)
 {
 	return QueryPlayerIDInterface(player).GetTradingGoods();
 };
 
 GuiInterface.prototype.OnGlobalEntityRenamed = function(msg)
 {
 	this.renamedEntities.push(msg);
 };
 
 // List the GuiInterface functions that can be safely called by GUI scripts.
 // (GUI scripts are non-deterministic and untrusted, so these functions must be
 // appropriately careful. They are called with a first argument "player", which is
 // trusted and indicates the player associated with the current client; no data should
 // be returned unless this player is meant to be able to see it.)
 let exposedFunctions = {
 
 	"GetSimulationState": 1,
 	"GetExtendedSimulationState": 1,
 	"GetRenamedEntities": 1,
 	"ClearRenamedEntities": 1,
 	"GetEntityState": 1,
 	"GetExtendedEntityState": 1,
 	"GetAverageRangeForBuildings": 1,
 	"GetTemplateData": 1,
 	"GetTechnologyData": 1,
 	"IsTechnologyResearched": 1,
 	"CheckTechnologyRequirements": 1,
 	"GetStartedResearch": 1,
 	"GetBattleState": 1,
 	"GetIncomingAttacks": 1,
 	"GetNeededResources": 1,
 	"GetNotifications": 1,
 	"GetTimeNotifications": 1,
 
 	"GetAvailableFormations": 1,
 	"GetFormationRequirements": 1,
 	"CanMoveEntsIntoFormation": 1,
 	"IsFormationSelected": 1,
 	"GetFormationInfoFromTemplate": 1,
 	"IsStanceSelected": 1,
 
 	"SetSelectionHighlight": 1,
 	"GetAllBuildableEntities": 1,
 	"SetStatusBars": 1,
 	"GetPlayerEntities": 1,
 	"DisplayRallyPoint": 1,
 	"SetBuildingPlacementPreview": 1,
 	"SetWallPlacementPreview": 1,
 	"GetFoundationSnapData": 1,
 	"PlaySound": 1,
 	"FindIdleUnits": 1,
 	"GetTradingRouteGain": 1,
 	"GetTradingDetails": 1,
 	"CanCapture": 1,
 	"CanAttack": 1,
 	"GetBatchTime": 1,
 
 	"IsMapRevealed": 1,
 	"SetPathfinderDebugOverlay": 1,
 	"SetPathfinderHierDebugOverlay": 1,
 	"SetObstructionDebugOverlay": 1,
 	"SetMotionDebugOverlay": 1,
 	"SetRangeDebugOverlay": 1,
 
 	"GetTraderNumber": 1,
 	"GetTradingGoods": 1,
 };
 
 GuiInterface.prototype.ScriptCall = function(player, name, args)
 {
 	if (exposedFunctions[name])
 		return this[name](player, args);
 	else
 		throw new Error("Invalid GuiInterface Call name \""+name+"\"");
 };
 
 Engine.RegisterSystemComponentType(IID_GuiInterface, "GuiInterface", GuiInterface);