Index: ps/trunk/binaries/data/mods/public/gui/loading/loading.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/loading/loading.js	(revision 22514)
+++ ps/trunk/binaries/data/mods/public/gui/loading/loading.js	(revision 22515)
@@ -1,103 +1,106 @@
 /**
  * Path to a file containing quotes of historical figures.
  */
 var g_QuotesFile = "gui/text/quotes.txt";
 
 /**
  * Directory storing txt files containing the gameplay tips.
  */
 var g_TipsTextPath = "gui/text/tips/";
 
 /**
  * Directory storing the PNG images with filenames corresponding to the tip text files.
  */
 var g_TipsImagePath = "loading/tips/";
 
 var g_Data;
 var g_EndPieceWidth = 16;
 
 function init(data)
 {
 	g_Data = data;
 
 	Engine.SetCursor("cursor-wait");
 
 	let tipFile = pickRandom(listFiles(g_TipsTextPath, ".txt", false));
 
 	if (tipFile)
 	{
 			let tipText = Engine.TranslateLines(Engine.ReadFile(g_TipsTextPath + tipFile + ".txt")).split("\n");
 			Engine.GetGUIObjectByName("tipTitle").caption = tipText.shift();
 			Engine.GetGUIObjectByName("tipText").caption = tipText.map(
 				// Translation: A bullet point used before every item of list of tips displayed on loading screen
 				text => text && sprintf(translate("• %(tiptext)s"), { "tiptext": text })
 			).join("\n\n");
 			Engine.GetGUIObjectByName("tipImage").sprite = "stretched:" + g_TipsImagePath + tipFile + ".png";
 	}
 	else
 		error("Failed to find any matching tips for the loading screen.");
 
 	// janwas: main loop now sets progress / description, but that won't
 	// happen until the first timeslice completes, so set initial values.
 	let loadingMapName = Engine.GetGUIObjectByName("loadingMapName");
 
 	if (data)
 	{
 		let mapName = translate(data.attribs.settings.Name);
 		switch (data.attribs.mapType)
 		{
 		case "skirmish":
 		case "scenario":
 			loadingMapName.caption = sprintf(translate("Loading “%(map)s”"), { "map": mapName });
 			break;
 
 		case "random":
 			loadingMapName.caption = sprintf(translate("Generating “%(map)s”"), { "map": mapName });
 			break;
 		}
 	}
 
 	Engine.GetGUIObjectByName("progressText").caption = "";
-	Engine.GetGUIObjectByName("progressbar").caption = 0;
+
+	let progressbar = Engine.GetGUIObjectByName("progressbar");
+	progressbar.caption = 0;
+	progressbar.onGameLoadProgress = displayProgress;
 
 	Engine.GetGUIObjectByName("quoteText").caption = translate(pickRandom(Engine.ReadFileLines(g_QuotesFile).filter(line => line)));
 }
 
-function displayProgress()
+function displayProgress(progression, description)
 {
 	// Make the progessbar finish a little early so that the user can actually see it finish
-	if (g_Progress >= 100)
+	if (progression >= 100)
 		return;
 
 	// Show 100 when it is really 99
-	let progress = g_Progress + 1;
+	let progress = progression + 1;
 
 	Engine.GetGUIObjectByName("progressbar").caption = progress; // display current progress
 	Engine.GetGUIObjectByName("progressText").caption = progress + "%";
 
 	// Displays detailed loading info rather than a percent
-	// Engine.GetGUIObjectByName("progressText").caption = g_LoadDescription; // display current progess details
+	// Engine.GetGUIObjectByName("progressText").caption = description;
 
 	// Keep curved right edge of progress bar in sync with the rest of the progress bar
 	let middle = Engine.GetGUIObjectByName("progressbar");
 	let rightSide = Engine.GetGUIObjectByName("progressbar_right");
 
 	let middleLength = (middle.size.right - middle.size.left) - (g_EndPieceWidth / 2);
 	let increment = Math.round(progress * middleLength / 100);
 
 	let size = rightSide.size;
 	size.left = increment;
 	size.right = increment + g_EndPieceWidth;
 	rightSide.size = size;
 }
 
 /**
  * This is a reserved function name that is executed by the engine when it is ready
  * to start the game (i.e. loading progress has reached 100%).
  */
 function reallyStartGame()
 {
 	Engine.SwitchGuiPage("page_session.xml", g_Data);
 
 	Engine.ResetCursor();
 }
Index: ps/trunk/binaries/data/mods/public/gui/loading/loading.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/loading/loading.xml	(revision 22514)
+++ ps/trunk/binaries/data/mods/public/gui/loading/loading.xml	(revision 22515)
@@ -1,50 +1,49 @@
 <?xml version="1.0" encoding="utf-8"?>
 
 <!--
 ==========================================
 - LOADING SCREEN -
 ==========================================
 -->
 <objects>
 
 	<script directory="gui/common/"/>
 	<script directory="gui/loading/"/>
 
 	<object type="image" style="ModernWindow">
 
 		<!-- LOADING SCREEN progress bar -->
 		<object size="50%-256 4 50%+256 36" type="image" sprite="LoadingProgressBarBackground">
 			<object name="progressbar"
 				type="progressbar"
 				style="LoadingProgressbar"
 				size="56 5 456 100%-5"
 			>
 				<object name="progressbar_left" size="-8 0 8 100%" type="image" sprite="LoadingProgressBarLeft"/>
 				<object name="progressbar_right" size="8 0 24 100%" type="image" sprite="LoadingProgressBarRight"/>
-				<action on="Progress">displayProgress();</action>
 				<object name="progressText" size="0 0 100% 100%" type="text" style="LoadingBarText"/>
 			</object>
 		</object>
 
 		<!-- LOADING SCREEN TEXT -->
 		<object name="loadingMapName" size="50%-256 36 50%+256 50%-196" type="text" style="LargeTitleText"/>
 
 		<!-- LOADING SCREEN TIP IMAGE-->
 		<object size="50%-452 50%-196 50%+68 50%+196" type="image" sprite="LoadingTipImage">
 			<object name="tipImage" size="4 4 516 516" type="image">
 				<object name="tipImageCover" size="0 0 100% 100%" type="image" sprite="LoadingTipImageCover"/>
 			</object>
 		</object>
 
 		<!-- LOADING SCREEN TIP TEXT-->
 		<object size="50%+128 50%-193 50%+448 50%+193" type="image" sprite="LoadingTipText">
 			<object name="tipTitle" size="30 30 100% 50" type="text" style="LoadingTipTitleText"/>
 			<object name="tipText" size="30 50 100%-30 100%" type="text" style="LoadingTipText"/>
 		</object>
 
 		<!-- LOADING SCREEN QUOTE (needs increased z value to overcome the transparent area of the tip image above it -->
 		<object size="50%-448 50%+230 50%+448 100%-16" z="20">
 			<object name="quoteText" size="0 0 100% 100%" type="text" style="LoadingText"/>
 		</object>
 	</object>
 </objects>
Index: ps/trunk/binaries/data/mods/public/gui/session/messages.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/messages.js	(revision 22514)
+++ ps/trunk/binaries/data/mods/public/gui/session/messages.js	(revision 22515)
@@ -1,1293 +1,1295 @@
 /**
  * All known cheat commands.
  */
 const g_Cheats = getCheatsData();
 
 /**
  * Number of seconds after which chatmessages will disappear.
  */
 var g_ChatTimeout = 30;
 
 /**
  * Maximum number of lines to display simultaneously.
  */
 var g_ChatLines = 20;
 
 /**
  * The currently displayed strings, limited by the given timeframe and limit above.
  */
 var g_ChatMessages = [];
 
 /**
  * All unparsed chat messages received since connect, including timestamp.
  */
 var g_ChatHistory = [];
 
 /**
  * Holds the timer-IDs used for hiding the chat after g_ChatTimeout seconds.
  */
 var g_ChatTimers = [];
 
 /**
  * Command to send to the previously selected private chat partner.
  */
 var g_LastChatAddressee = "";
 
 /**
  * All tutorial messages received so far.
  */
 var g_TutorialMessages = [];
 
 /**
  * GUI tags applied to the most recent tutorial message.
  */
 var g_TutorialNewMessageTags = { "color": "yellow" };
 
 /**
  * Handle all netmessage types that can occur.
  */
 var g_NetMessageTypes = {
 	"netstatus": msg => {
 		handleNetStatusMessage(msg);
 	},
 	"netwarn": msg => {
 		addNetworkWarning(msg);
 	},
 	"out-of-sync": msg => {
 		onNetworkOutOfSync(msg);
 	},
 	"players": msg => {
 		handlePlayerAssignmentsMessage(msg);
 	},
 	"paused": msg => {
 		setClientPauseState(msg.guid, msg.pause);
 	},
 	"clients-loading": msg => {
 		handleClientsLoadingMessage(msg.guids);
 	},
 	"rejoined": msg => {
 		addChatMessage({
 			"type": "rejoined",
 			"guid": msg.guid
 		});
 	},
 	"kicked": msg => {
 		addChatMessage({
 			"type": "kicked",
 			"username": msg.username,
 			"banned": msg.banned
 		});
 	},
 	"chat": msg => {
 		addChatMessage({
 			"type": "message",
 			"guid": msg.guid,
 			"text": msg.text
 		});
 	},
 	"aichat": msg => {
 		addChatMessage({
 			"type": "message",
 			"guid": msg.guid,
 			"text": msg.text,
 			"translate": true
 		});
 	},
 	"gamesetup": msg => {}, // Needed for autostart
 	"start": msg => {}
 };
 
 var g_FormatChatMessage = {
 	"system": msg => msg.text,
 	"connect": msg =>
 		sprintf(
 			g_PlayerAssignments[msg.guid].player != -1 ?
 				// Translation: A player that left the game joins again
 				translate("%(player)s is starting to rejoin the game.") :
 				// Translation: A player joins the game for the first time
 				translate("%(player)s is starting to join the game."),
 			{ "player": colorizePlayernameByGUID(msg.guid) }
 		),
 	"disconnect": msg =>
 		sprintf(translate("%(player)s has left the game."), {
 			"player": colorizePlayernameByGUID(msg.guid)
 		}),
 	"rejoined": msg =>
 		sprintf(
 			g_PlayerAssignments[msg.guid].player != -1 ?
 				// Translation: A player that left the game joins again
 				translate("%(player)s has rejoined the game.") :
 				// Translation: A player joins the game for the first time
 				translate("%(player)s has joined the game."),
 			{ "player": colorizePlayernameByGUID(msg.guid) }
 		),
 	"kicked": msg =>
 		sprintf(
 			msg.banned ?
 				translate("%(username)s has been banned") :
 				translate("%(username)s has been kicked"),
 			{
 				"username": colorizePlayernameHelper(
 					msg.username,
 					g_Players.findIndex(p => p.name == msg.username)
 				)
 			}
 		),
 	"clientlist": msg => getUsernameList(),
 	"message": msg => formatChatCommand(msg),
 	"defeat-victory": msg => formatDefeatVictoryMessage(msg.message, msg.players),
 	"diplomacy": msg => formatDiplomacyMessage(msg),
 	"tribute": msg => formatTributeMessage(msg),
 	"barter": msg => formatBarterMessage(msg),
 	"attack": msg => formatAttackMessage(msg),
 	"phase": msg => formatPhaseMessage(msg)
 };
 
 /**
  * Show a label and grey overlay or hide both on connection change.
  */
 var g_StatusMessageTypes = {
 	"authenticated": msg => translate("Connection to the server has been authenticated."),
 	"connected": msg => translate("Connected to the server."),
 	"disconnected": msg => translate("Connection to the server has been lost.") + "\n" +
 		getDisconnectReason(msg.reason, true),
 	"waiting_for_players": msg => translate("Waiting for players to connect:"),
 	"join_syncing": msg => translate("Synchronizing gameplay with other players…"),
 	"active": msg => ""
 };
 
 /**
  * Chatmessage shown after commands like /me or /enemies.
  */
 var g_ChatCommands = {
 	"regular": {
 		"context": translate("(%(context)s) %(userTag)s %(message)s"),
 		"no-context": translate("%(userTag)s %(message)s")
 	},
 	"me": {
 		"context": translate("(%(context)s) * %(user)s %(message)s"),
 		"no-context": translate("* %(user)s %(message)s")
 	}
 };
 
 var g_ChatAddresseeContext = {
 	"/team": translate("Team"),
 	"/allies": translate("Ally"),
 	"/enemies": translate("Enemy"),
 	"/observers": translate("Observer"),
 	"/msg": translate("Private")
 };
 
 /**
  * Returns true if the current player is an addressee, given the chat message type and sender.
  */
 var g_IsChatAddressee = {
 	"/team": senderID =>
 		g_Players[senderID] &&
 		g_Players[Engine.GetPlayerID()] &&
 		g_Players[Engine.GetPlayerID()].team != -1 &&
 		g_Players[Engine.GetPlayerID()].team == g_Players[senderID].team,
 
 	"/allies": senderID =>
 		g_Players[senderID] &&
 		g_Players[Engine.GetPlayerID()] &&
 		g_Players[senderID].isMutualAlly[Engine.GetPlayerID()],
 
 	"/enemies": senderID =>
 		g_Players[senderID] &&
 		g_Players[Engine.GetPlayerID()] &&
 		g_Players[senderID].isEnemy[Engine.GetPlayerID()],
 
 	"/observers": senderID =>
 		g_IsObserver,
 
 	"/msg": (senderID, addresseeGUID) =>
 		addresseeGUID == Engine.GetPlayerGUID()
 };
 
 /**
  * Notice only messages will be filtered that are visible to the player in the first place.
  */
 var g_ChatHistoryFilters = [
 	{
 		"key": "all",
 		"text": translateWithContext("chat history filter", "Chat and notifications"),
 		"filter": (msg, senderID) => true
 	},
 	{
 		"key": "chat",
 		"text": translateWithContext("chat history filter", "Chat messages"),
 		"filter": (msg, senderID) => msg.type == "message"
 	},
 	{
 		"key": "player",
 		"text": translateWithContext("chat history filter", "Players chat"),
 		"filter": (msg, senderID) =>
 			msg.type == "message" &&
 			senderID > 0 && !isPlayerObserver(senderID)
 	},
 	{
 		"key": "ally",
 		"text": translateWithContext("chat history filter", "Ally chat"),
 		"filter": (msg, senderID) =>
 			msg.type == "message" &&
 			msg.cmd && msg.cmd == "/allies"
 	},
 	{
 		"key": "enemy",
 		"text": translateWithContext("chat history filter", "Enemy chat"),
 		"filter": (msg, senderID) =>
 			msg.type == "message" &&
 			msg.cmd && msg.cmd == "/enemies"
 	},
 	{
 		"key": "observer",
 		"text": translateWithContext("chat history filter", "Observer chat"),
 		"filter": (msg, senderID) =>
 			msg.type == "message" &&
 			msg.cmd && msg.cmd == "/observers"
 	},
 	{
 		"key": "private",
 		"text": translateWithContext("chat history filter", "Private chat"),
 		"filter": (msg, senderID) => !!msg.isVisiblePM
 	}
 ];
 
 var g_PlayerStateMessages = {
 	"won": translate("You have won!"),
 	"defeated": translate("You have been defeated!")
 };
 
 /**
  * Chatmessage shown on diplomacy change.
  */
 var g_DiplomacyMessages = {
 	"active": {
 		"ally": translate("You are now allied with %(player)s."),
 		"enemy": translate("You are now at war with %(player)s."),
 		"neutral": translate("You are now neutral with %(player)s.")
 	},
 	"passive": {
 		"ally": translate("%(player)s is now allied with you."),
 		"enemy": translate("%(player)s is now at war with you."),
 		"neutral": translate("%(player)s is now neutral with you.")
 	},
 	"observer": {
 		"ally": translate("%(player)s is now allied with %(player2)s."),
 		"enemy": translate("%(player)s is now at war with %(player2)s."),
 		"neutral": translate("%(player)s is now neutral with %(player2)s.")
 	}
 };
 
 /**
  * Defines how the GUI reacts to notifications that are sent by the simulation.
  * Don't open new pages (message boxes) here! Otherwise further notifications
  * handled in the same turn can't access the GUI objects anymore.
  */
 var g_NotificationsTypes =
 {
 	"chat": function(notification, player)
 	{
 		let message = {
 			"type": "message",
 			"guid": findGuidForPlayerID(player) || -1,
 			"text": notification.message
 		};
 		if (message.guid == -1)
 			message.player = player;
 
 		addChatMessage(message);
 	},
 	"aichat": function(notification, player)
 	{
 		let message = {
 			"type": "message",
 			"text": notification.message,
 			"guid": findGuidForPlayerID(player) || -1,
 			"player": player,
 			"translate": true
 		};
 
 		if (notification.translateParameters)
 		{
 			message.translateParameters = notification.translateParameters;
 			message.parameters = notification.parameters;
 			colorizePlayernameParameters(notification.parameters);
 		}
 
 		addChatMessage(message);
 	},
 	"defeat": function(notification, player)
 	{
 		playersFinished(notification.allies, notification.message, false);
 	},
 	"won": function(notification, player)
 	{
 		playersFinished(notification.allies, notification.message, true);
 	},
 	"diplomacy": function(notification, player)
 	{
 		updatePlayerData();
 		if (g_DiplomacyColorsToggle)
 			updateDisplayedPlayerColors();
 
 		addChatMessage({
 			"type": "diplomacy",
 			"sourcePlayer": player,
 			"targetPlayer": notification.targetPlayer,
 			"status": notification.status
 		});
 	},
 	"ceasefire-ended": function(notification, player)
 	{
 		updatePlayerData();
 		if (g_DiplomacyColorsToggle)
 			updateDisplayedPlayerColors();
 	},
 	"tutorial": function(notification, player)
 	{
 		updateTutorial(notification);
 	},
 	"tribute": function(notification, player)
 	{
 		addChatMessage({
 			"type": "tribute",
 			"sourcePlayer": notification.donator,
 			"targetPlayer": player,
 			"amounts": notification.amounts
 		});
 	},
 	"barter": function(notification, player)
 	{
 		addChatMessage({
 			"type": "barter",
 			"player": player,
 			"amountsSold": notification.amountsSold,
 			"amountsBought": notification.amountsBought,
 			"resourceSold": notification.resourceSold,
 			"resourceBought": notification.resourceBought
 		});
 	},
 	"spy-response": function(notification, player)
 	{
 		if (g_BribeButtonsWaiting[player])
 			g_BribeButtonsWaiting[player] = g_BribeButtonsWaiting[player].filter(p => p != notification.target);
 
 		if (notification.entity && g_ViewedPlayer == player)
 		{
 			closeDiplomacy();
 			setCameraFollow(notification.entity);
 		}
 	},
 	"attack": function(notification, player)
 	{
 		if (player != g_ViewedPlayer)
 			return;
 
 		// Focus camera on attacks
 		if (g_FollowPlayer)
 		{
 			setCameraFollow(notification.target);
 
 			g_Selection.reset();
 			if (notification.target)
 				g_Selection.addList([notification.target]);
 		}
 
 		if (Engine.ConfigDB_GetValue("user", "gui.session.notifications.attack") !== "true")
 			return;
 
 		addChatMessage({
 			"type": "attack",
 			"player": player,
 			"attacker": notification.attacker,
 			"targetIsDomesticAnimal": notification.targetIsDomesticAnimal
 		});
 	},
 	"phase": function(notification, player)
 	{
 		addChatMessage({
 			"type": "phase",
 			"player": player,
 			"phaseName": notification.phaseName,
 			"phaseState": notification.phaseState
 		});
 	},
 	"dialog": function(notification, player)
 	{
 		if (player == Engine.GetPlayerID())
 			openDialog(notification.dialogName, notification.data, player);
 	},
 	"resetselectionpannel": function(notification, player)
 	{
 		if (player != Engine.GetPlayerID())
 			return;
 		g_Selection.rebuildSelection({});
 	},
 	"playercommand": function(notification, player)
 	{
 		// For observers, focus the camera on units commanded by the selected player
 		if (!g_FollowPlayer || player != g_ViewedPlayer)
 			return;
 
 		let cmd = notification.cmd;
 
 		// Ignore rallypoint commands of trained animals
 		let entState = cmd.entities && cmd.entities[0] && GetEntityState(cmd.entities[0]);
 		if (g_ViewedPlayer != 0 &&
 		    entState && entState.identity && entState.identity.classes &&
 		    entState.identity.classes.indexOf("Animal") != -1)
 			return;
 
 		// Focus the building to construct
 		if (cmd.type == "repair")
 		{
 			let targetState = GetEntityState(cmd.target);
 			if (targetState)
 				Engine.CameraMoveTo(targetState.position.x, targetState.position.z);
 		}
 		else if (cmd.type == "delete-entities" && notification.position)
 			Engine.CameraMoveTo(notification.position.x, notification.position.y);
 		// Focus commanded entities, but don't lose previous focus when training units
 		else if (cmd.type != "train" && cmd.type != "research" && entState)
 			setCameraFollow(cmd.entities[0]);
 
 		if (["walk", "attack-walk", "patrol"].indexOf(cmd.type) != -1)
 			DrawTargetMarker(cmd);
 
 		// Select units affected by that command
 		let selection = [];
 		if (cmd.entities)
 			selection = cmd.entities;
 		if (cmd.target)
 			selection.push(cmd.target);
 
 		// Allow gaia in selection when gathering
 		g_Selection.reset();
 		g_Selection.addList(selection, false, cmd.type == "gather");
 	},
 	"play-tracks": function (notification, player)
 	{
 		if (notification.lock)
 		{
 			global.music.storeTracks(notification.tracks.map(track => ({ "Type": "custom", "File": track })));
 			global.music.setState(global.music.states.CUSTOM);
 		}
 
 		global.music.setLocked(notification.lock);
 	}
 };
 
 /**
  * Loads all known cheat commands.
  */
 function getCheatsData()
 {
 	let cheats = {};
 	for (let fileName of Engine.ListDirectoryFiles("simulation/data/cheats/", "*.json", false))
 	{
 		let currentCheat = Engine.ReadJSONFile(fileName);
 		if (cheats[currentCheat.Name])
 			warn("Cheat name '" + currentCheat.Name + "' is already present");
 		else
 			cheats[currentCheat.Name] = currentCheat.Data;
 	}
 	return deepfreeze(cheats);
 }
 
 /**
  * Reads userinput from the chat and sends a simulation command in case it is a known cheat.
  *
  * @returns {boolean} - True if a cheat was executed.
  */
 function executeCheat(text)
 {
 	if (!controlsPlayer(Engine.GetPlayerID()) ||
 	    !g_Players[Engine.GetPlayerID()].cheatsEnabled)
 		return false;
 
 	// Find the cheat code that is a prefix of the user input
 	let cheatCode = Object.keys(g_Cheats).find(code => text.indexOf(code) == 0);
 	if (!cheatCode)
 		return false;
 
 	let cheat = g_Cheats[cheatCode];
 
 	let parameter = text.substr(cheatCode.length + 1);
 	if (cheat.isNumeric)
 		parameter = +parameter;
 
 	if (cheat.DefaultParameter && !parameter)
 		parameter = cheat.DefaultParameter;
 
 	Engine.PostNetworkCommand({
 		"type": "cheat",
 		"action": cheat.Action,
 		"text": cheat.Type,
 		"player": Engine.GetPlayerID(),
 		"parameter": parameter,
 		"templates": cheat.Templates,
 		"selected": g_Selection.toList()
 	});
 
 	return true;
 }
 
 function findGuidForPlayerID(playerID)
 {
 	return Object.keys(g_PlayerAssignments).find(guid => g_PlayerAssignments[guid].player == playerID);
 }
 
 /**
  * Processes all pending notifications sent from the GUIInterface simulation component.
  */
 function handleNotifications()
 {
 	for (let notification of Engine.GuiInterfaceCall("GetNotifications"))
 	{
 		if (!notification.players || !notification.type || !g_NotificationsTypes[notification.type])
 		{
 			error("Invalid GUI notification: " + uneval(notification));
 			continue;
 		}
 
 		for (let player of notification.players)
 			g_NotificationsTypes[notification.type](notification, player);
 	}
 }
 
 /**
  * Updates the tutorial panel when a new goal.
  */
 function updateTutorial(notification)
 {
 	// Show the tutorial panel if not yet done
 	Engine.GetGUIObjectByName("tutorialPanel").hidden = false;
 
 	if (notification.warning)
 	{
 		Engine.GetGUIObjectByName("tutorialWarning").caption = coloredText(translate(notification.warning), "orange");
 		return;
 	}
 
 	let notificationText =
 		notification.instructions.reduce((instructions, item) =>
 			instructions + (typeof item == "string" ? translate(item) : colorizeHotkey(translate(item.text), item.hotkey)),
 			"");
 
 	Engine.GetGUIObjectByName("tutorialText").caption = g_TutorialMessages.concat(setStringTags(notificationText, g_TutorialNewMessageTags)).join("\n");
 	g_TutorialMessages.push(notificationText);
 
 	if (notification.readyButton)
 	{
 		Engine.GetGUIObjectByName("tutorialReady").hidden = false;
 		if (notification.leave)
 		{
 			Engine.GetGUIObjectByName("tutorialWarning").caption = translate("Click to quit this tutorial.");
 			Engine.GetGUIObjectByName("tutorialReady").caption = translate("Quit");
 			Engine.GetGUIObjectByName("tutorialReady").onPress = leaveGame;
 		}
 		else
 			Engine.GetGUIObjectByName("tutorialWarning").caption = translate("Click when ready.");
 	}
 	else
 	{
 		Engine.GetGUIObjectByName("tutorialWarning").caption = translate("Follow the instructions.");
 		Engine.GetGUIObjectByName("tutorialReady").hidden = true;
 	}
 }
 
 /**
  * Displays all active counters (messages showing the remaining time) for wonder-victory, ceasefire etc.
  */
 function updateTimeNotifications()
 {
 	let notifications = Engine.GuiInterfaceCall("GetTimeNotifications", g_ViewedPlayer);
 	let notificationText = "";
 	for (let n of notifications)
 	{
 		let message = n.message;
 		if (n.translateMessage)
 			message = translate(message);
 
 		let parameters = n.parameters || {};
 		if (n.translateParameters)
 			translateObjectKeys(parameters, n.translateParameters);
 
 		parameters.time = timeToString(n.endTime - GetSimState().timeElapsed);
 
 		colorizePlayernameParameters(parameters);
 
 		notificationText += sprintf(message, parameters) + "\n";
 	}
 	Engine.GetGUIObjectByName("notificationText").caption = notificationText;
 }
 
 /**
  * Process every CNetMessage (see NetMessage.h, NetMessages.h) sent by the CNetServer.
  * Saves the received object to mainlog.html.
  */
 function handleNetMessages()
 {
 	while (true)
 	{
 		let msg = Engine.PollNetworkClient();
 		if (!msg)
 			return;
 
 		log("Net message: " + uneval(msg));
 
 		if (g_NetMessageTypes[msg.type])
 			g_NetMessageTypes[msg.type](msg);
 		else
 			error("Unrecognised net message type '" + msg.type + "'");
 	}
 }
 
 /**
  * @param {Object} message
  */
 function handleNetStatusMessage(message)
 {
 	if (g_Disconnected)
 		return;
 
 	if (!g_StatusMessageTypes[message.status])
 	{
 		error("Unrecognised netstatus type '" + message.status + "'");
 		return;
 	}
 
 	g_IsNetworkedActive = message.status == "active";
 
 	let netStatus = Engine.GetGUIObjectByName("netStatus");
 	let statusMessage = g_StatusMessageTypes[message.status](message);
 	netStatus.caption = statusMessage;
 	netStatus.hidden = !statusMessage;
 
 	let loadingClientsText = Engine.GetGUIObjectByName("loadingClientsText");
 	loadingClientsText.hidden = message.status != "waiting_for_players";
 
 	if (message.status == "disconnected")
 	{
 		// Hide the pause overlay, and pause animations.
 		Engine.GetGUIObjectByName("pauseOverlay").hidden = true;
 		Engine.SetPaused(true, false);
 
 		g_Disconnected = true;
 		updateCinemaPath();
 		closeOpenDialogs();
 	}
 }
 
 function handleClientsLoadingMessage(guids)
 {
 	let loadingClientsText = Engine.GetGUIObjectByName("loadingClientsText");
 	loadingClientsText.caption = guids.map(guid => colorizePlayernameByGUID(guid)).join(translateWithContext("Separator for a list of client loading messages", ", "));
 }
 
 function onNetworkOutOfSync(msg)
 {
 	let txt = [
 		sprintf(translate("Out-Of-Sync error on turn %(turn)s."), {
 			"turn": msg.turn
 		}),
 
 		sprintf(translateWithContext("Out-Of-Sync", "Players: %(players)s"), {
 			"players": msg.players.join(translateWithContext("Separator for a list of players", ", "))
 		}),
 
 		msg.hash == msg.expectedHash ?
 			translateWithContext("Out-Of-Sync", "Your game state is identical to the hosts game state.") :
 			translateWithContext("Out-Of-Sync", "Your game state differs from the hosts game state."),
 
 		""
 	];
 
 	if (msg.turn > 1 && g_GameAttributes.settings.PlayerData.some(pData => pData && pData.AI))
 		txt.push(translateWithContext("Out-Of-Sync", "Rejoining Multiplayer games with AIs is not supported yet!"));
 	else
 		txt.push(
 			translateWithContext("Out-Of-Sync", "Ensure all players use the same mods."),
 			translateWithContext("Out-Of-Sync", 'Click on "Report a Bug" in the main menu to help fix this.'),
 			sprintf(translateWithContext("Out-Of-Sync", "Replay saved to %(filepath)s"), {
 				"filepath": escapeText(msg.path_replay)
 			}),
 			sprintf(translateWithContext("Out-Of-Sync", "Dumping current state to %(filepath)s"), {
 				"filepath": escapeText(msg.path_oos_dump)
 			})
 		);
 
 	messageBox(
 		600, 280,
 		txt.join("\n"),
 		translate("Out of Sync")
 	);
 }
 
-function onReplayOutOfSync()
+function onReplayOutOfSync(turn, hash, expectedHash)
 {
 	messageBox(
 		500, 140,
-		translate("Out-Of-Sync error!") + "\n" +
+		sprintf(translate("Out-Of-Sync error on turn %(turn)s."), {
+			"turn": turn
+		}) + "\n" +
 			// Translation: This is shown if replay is out of sync
 			translateWithContext("Out-Of-Sync", "The current game state is different from the original game state."),
 		translate("Out of Sync")
 	);
 }
 
 function handlePlayerAssignmentsMessage(message)
 {
 	for (let guid in g_PlayerAssignments)
 		if (!message.newAssignments[guid])
 			onClientLeave(guid);
 
 	let joins = Object.keys(message.newAssignments).filter(guid => !g_PlayerAssignments[guid]);
 
 	g_PlayerAssignments = message.newAssignments;
 
 	joins.forEach(guid => {
 		onClientJoin(guid);
 	});
 
 	updateGUIObjects();
 	updateChatAddressees();
 	sendLobbyPlayerlistUpdate();
 }
 
 function onClientJoin(guid)
 {
 	let playerID = g_PlayerAssignments[guid].player;
 
 	if (g_Players[playerID])
 	{
 		g_Players[playerID].guid = guid;
 		g_Players[playerID].name = g_PlayerAssignments[guid].name;
 		g_Players[playerID].offline = false;
 	}
 
 	addChatMessage({
 		"type": "connect",
 		"guid": guid
 	});
 }
 
 function onClientLeave(guid)
 {
 	setClientPauseState(guid, false);
 
 	for (let id in g_Players)
 		if (g_Players[id].guid == guid)
 			g_Players[id].offline = true;
 
 	addChatMessage({
 		"type": "disconnect",
 		"guid": guid
 	});
 }
 
 function updateChatAddressees()
 {
 	// Remember previously selected item
 	let chatAddressee = Engine.GetGUIObjectByName("chatAddressee");
 	let selectedName = chatAddressee.list_data[chatAddressee.selected] || "";
 	selectedName = selectedName.substr(0, 4) == "/msg" && selectedName.substr(5);
 
 	let addressees = [
 		{
 			"label": translateWithContext("chat addressee", "Everyone"),
 			"cmd": ""
 		}
 	];
 
 	if (!g_IsObserver)
 	{
 		addressees.push({
 			"label": translateWithContext("chat addressee", "Allies"),
 			"cmd": "/allies"
 		});
 		addressees.push({
 			"label": translateWithContext("chat addressee", "Enemies"),
 			"cmd": "/enemies"
 		});
 	}
 
 	addressees.push({
 		"label": translateWithContext("chat addressee", "Observers"),
 		"cmd": "/observers"
 	});
 
 	// Add playernames for private messages
 	let guids = sortGUIDsByPlayerID();
 	for (let guid of guids)
 	{
 		if (guid == Engine.GetPlayerGUID())
 			continue;
 
 		let playerID = g_PlayerAssignments[guid].player;
 
 		// Don't provide option for PM from observer to player
 		if (g_IsObserver && !isPlayerObserver(playerID))
 			continue;
 
 		let colorBox = isPlayerObserver(playerID) ? "" : colorizePlayernameHelper("■", playerID) + " ";
 
 		addressees.push({
 			"cmd": "/msg " + g_PlayerAssignments[guid].name,
 			"label": colorBox + g_PlayerAssignments[guid].name
 		});
 	}
 
 	// Select mock item if the selected addressee went offline
 	if (selectedName && guids.every(guid => g_PlayerAssignments[guid].name != selectedName))
 		addressees.push({
 			"cmd": "/msg " + selectedName,
 			"label": sprintf(translate("\\[OFFLINE] %(player)s"), { "player": selectedName })
 		});
 
 	let oldChatAddressee = chatAddressee.list_data[chatAddressee.selected];
 	chatAddressee.list = addressees.map(adressee => adressee.label);
 	chatAddressee.list_data = addressees.map(adressee => adressee.cmd);
 	chatAddressee.selected = Math.max(0, chatAddressee.list_data.indexOf(oldChatAddressee));
 }
 
 /**
  * Send text as chat. Don't look for commands.
  *
  * @param {string} text
  */
 function submitChatDirectly(text)
 {
 	if (!text.length)
 		return;
 
 	if (g_IsNetworked)
 		Engine.SendNetworkChat(text);
 	else
 		addChatMessage({ "type": "message", "guid": "local", "text": text });
 }
 
 /**
  * Loads the text from the GUI window, checks if it is a local command
  * or cheat and executes it. Otherwise sends it as chat.
  */
 function submitChatInput()
 {
 	let text = Engine.GetGUIObjectByName("chatInput").caption;
 
 	closeChat();
 
 	if (!text.length)
 		return;
 
 	if (executeNetworkCommand(text))
 		return;
 
 	if (executeCheat(text))
 		return;
 
 	let chatAddressee = Engine.GetGUIObjectByName("chatAddressee");
 	if (chatAddressee.selected > 0 && (text.indexOf("/") != 0 || text.indexOf("/me ") == 0))
 		text = chatAddressee.list_data[chatAddressee.selected] + " " + text;
 
 	let selectedChat = chatAddressee.list_data[chatAddressee.selected];
 	if (selectedChat.startsWith("/msg"))
 		g_LastChatAddressee = selectedChat;
 
 	submitChatDirectly(text);
 }
 
 /**
  * Displays the prepared chatmessage.
  *
  * @param msg {Object}
  */
 function addChatMessage(msg)
 {
 	if (!g_FormatChatMessage[msg.type])
 		return;
 
 	let formatted = g_FormatChatMessage[msg.type](msg);
 	if (!formatted)
 		return;
 
 	// Update chat overlay
 	g_ChatMessages.push(formatted);
 	g_ChatTimers.push(setTimeout(removeOldChatMessage, g_ChatTimeout * 1000));
 
 	if (g_ChatMessages.length > g_ChatLines)
 		removeOldChatMessage();
 	else
 		Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 
 	// Save to chat history
 	let historical = {
 		"txt": formatted,
 		"timePrefix": sprintf(translate("\\[%(time)s]"), {
 			"time": Engine.FormatMillisecondsIntoDateStringLocal(Date.now(), translate("HH:mm"))
 		}),
 		"filter": {}
 	};
 
 	// Apply the filters now before diplomacies or playerstates change
 	let senderID = msg.guid && g_PlayerAssignments[msg.guid] ? g_PlayerAssignments[msg.guid].player : 0;
 	for (let filter of g_ChatHistoryFilters)
 		historical.filter[filter.key] = filter.filter(msg, senderID);
 
 	g_ChatHistory.push(historical);
 	updateChatHistory();
 }
 
 /**
  * Called when the timer has run out for the oldest chatmessage or when the message limit is reached.
  */
 function removeOldChatMessage()
 {
 	clearTimeout(g_ChatTimers[0]);
 	g_ChatTimers.shift();
 	g_ChatMessages.shift();
 	Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 }
 
 /**
  * This function is used for AIs, whose names don't exist in g_PlayerAssignments.
  */
 function colorizePlayernameByID(playerID)
 {
 	let username = g_Players[playerID] && escapeText(g_Players[playerID].name);
 	return colorizePlayernameHelper(username, playerID);
 }
 
 function colorizePlayernameByGUID(guid)
 {
 	let username = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].name : "";
 	let playerID = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].player : -1;
 	return colorizePlayernameHelper(username, playerID);
 }
 
 function colorizePlayernameHelper(username, playerID)
 {
 	let playerColor = playerID > -1 ? rgbToGuiColor(g_DisplayedPlayerColors[playerID]) : "white";
 	return coloredText(username || translate("Unknown Player"), playerColor);
 }
 
 /**
  * Insert the colorized playername to chat messages sent by the AI and time notifications.
  */
 function colorizePlayernameParameters(parameters)
 {
 	for (let param in parameters)
 		if (param.startsWith("_player_"))
 			parameters[param] = colorizePlayernameByID(parameters[param]);
 }
 
 function formatDefeatVictoryMessage(message, players)
 {
 	if (!message.pluralMessage)
 		return sprintf(translate(message), {
 			"player": colorizePlayernameByID(players[0])
 		});
 
 	let mPlayers = players.map(playerID => colorizePlayernameByID(playerID));
 	let lastPlayer = mPlayers.pop();
 
 	return sprintf(translatePlural(message.message, message.pluralMessage, message.pluralCount), {
 		// Translation: This comma is used for separating first to penultimate elements in an enumeration.
 		"players": mPlayers.join(translate(", ")),
 		"lastPlayer": lastPlayer
 	});
 }
 
 function formatDiplomacyMessage(msg)
 {
 	let messageType;
 
 	if (g_IsObserver)
 		messageType = "observer";
 	else if (Engine.GetPlayerID() == msg.sourcePlayer)
 		messageType = "active";
 	else if (Engine.GetPlayerID() == msg.targetPlayer)
 		messageType = "passive";
 	else
 		return "";
 
 	return sprintf(g_DiplomacyMessages[messageType][msg.status], {
 		"player": colorizePlayernameByID(messageType == "active" ? msg.targetPlayer : msg.sourcePlayer),
 		"player2": colorizePlayernameByID(messageType == "active" ? msg.sourcePlayer : msg.targetPlayer)
 	});
 }
 
 /**
  * Optionally show all tributes sent in observer mode and tributes sent between allied players.
  * Otherwise, only show tributes sent directly to us, and tributes that we send.
  */
 function formatTributeMessage(msg)
 {
 	let message = "";
 	if (msg.targetPlayer == Engine.GetPlayerID())
 		message = translate("%(player)s has sent you %(amounts)s.");
 	else if (msg.sourcePlayer == Engine.GetPlayerID())
 		message = translate("You have sent %(player2)s %(amounts)s.");
 	else if (Engine.ConfigDB_GetValue("user", "gui.session.notifications.tribute") == "true" &&
 	        (g_IsObserver || g_GameAttributes.settings.LockTeams &&
 	           g_Players[msg.sourcePlayer].isMutualAlly[Engine.GetPlayerID()] &&
 	           g_Players[msg.targetPlayer].isMutualAlly[Engine.GetPlayerID()]))
 		message = translate("%(player)s has sent %(player2)s %(amounts)s.");
 
 	return sprintf(message, {
 		"player": colorizePlayernameByID(msg.sourcePlayer),
 		"player2": colorizePlayernameByID(msg.targetPlayer),
 		"amounts": getLocalizedResourceAmounts(msg.amounts)
 	});
 }
 
 function formatBarterMessage(msg)
 {
 	if (!g_IsObserver || Engine.ConfigDB_GetValue("user", "gui.session.notifications.barter") != "true")
 		return "";
 
 	let amountsSold = {};
 	amountsSold[msg.resourceSold] = msg.amountsSold;
 
 	let amountsBought = {};
 	amountsBought[msg.resourceBought] = msg.amountsBought;
 
 	return sprintf(translate("%(player)s bartered %(amountsBought)s for %(amountsSold)s."), {
 		"player": colorizePlayernameByID(msg.player),
 		"amountsBought": getLocalizedResourceAmounts(amountsBought),
 		"amountsSold": getLocalizedResourceAmounts(amountsSold)
 	});
 }
 
 function formatAttackMessage(msg)
 {
 	if (msg.player != g_ViewedPlayer)
 		return "";
 
 	let message = msg.targetIsDomesticAnimal ?
 		translate("Your livestock has been attacked by %(attacker)s!") :
 		translate("You have been attacked by %(attacker)s!");
 
 	return sprintf(message, {
 		"attacker": colorizePlayernameByID(msg.attacker)
 	});
 }
 
 function formatPhaseMessage(msg)
 {
 	let notifyPhase = Engine.ConfigDB_GetValue("user", "gui.session.notifications.phase");
 	if (notifyPhase == "none" || msg.player != g_ViewedPlayer && !g_IsObserver && !g_Players[msg.player].isMutualAlly[g_ViewedPlayer])
 		return "";
 
 	let message = "";
 	if (notifyPhase == "all")
 	{
 		if (msg.phaseState == "started")
 			message = translate("%(player)s is advancing to the %(phaseName)s.");
 		else if (msg.phaseState == "aborted")
 			message = translate("The %(phaseName)s of %(player)s has been aborted.");
 	}
 	if (msg.phaseState == "completed")
 		message = translate("%(player)s has reached the %(phaseName)s.");
 
 	return sprintf(message, {
 		"player": colorizePlayernameByID(msg.player),
 		"phaseName": getEntityNames(GetTechnologyData(msg.phaseName, g_Players[msg.player].civ))
 	});
 }
 
 function formatChatCommand(msg)
 {
 	if (!msg.text)
 		return "";
 
 	let isMe = msg.text.indexOf("/me ") == 0;
 	if (!isMe && !parseChatAddressee(msg))
 		return "";
 
 	isMe = msg.text.indexOf("/me ") == 0;
 	if (isMe)
 		msg.text = msg.text.substr("/me ".length);
 
 	// Translate or escape text
 	if (!msg.text)
 		return "";
 
 	if (msg.translate)
 	{
 		msg.text = translate(msg.text);
 		if (msg.translateParameters)
 		{
 			let parameters = msg.parameters || {};
 			translateObjectKeys(parameters, msg.translateParameters);
 			msg.text = sprintf(msg.text, parameters);
 		}
 	}
 	else
 	{
 		msg.text = escapeText(msg.text);
 
 		let userName = g_PlayerAssignments[Engine.GetPlayerGUID()].name;
 		if (userName != g_PlayerAssignments[msg.guid].name &&
 		    msg.text.toLowerCase().indexOf(splitRatingFromNick(userName).nick.toLowerCase()) != -1)
 			soundNotification("nick");
 	}
 
 	// GUID for players, playerID for AIs
 	let coloredUsername = msg.guid != -1 ? colorizePlayernameByGUID(msg.guid) : colorizePlayernameByID(msg.player);
 
 	return sprintf(g_ChatCommands[isMe ? "me" : "regular"][msg.context ? "context" : "no-context"], {
 		"message": msg.text,
 		"context": msg.context || undefined,
 		"user": coloredUsername,
 		"userTag": sprintf(translate("<%(user)s>"), { "user": coloredUsername })
 	});
 }
 
 /**
  * Checks if the current user is an addressee of the chatmessage sent by another player.
  * Sets the context and potentially addresseeGUID of that message.
  * Returns true if the message should be displayed.
  *
  * @param {Object} msg
  */
 function parseChatAddressee(msg)
 {
 	if (msg.text[0] != '/')
 		return true;
 
 	// Split addressee command and message-text
 	msg.cmd = msg.text.split(/\s/)[0];
 	msg.text = msg.text.substr(msg.cmd.length + 1);
 
 	// GUID is "local" in singleplayer, some string in multiplayer.
 	// Chat messages sent by the simulation (AI) come with the playerID.
 	let senderID = msg.player ? msg.player : (g_PlayerAssignments[msg.guid] || msg).player;
 
 	let isSender = msg.guid ?
 		msg.guid == Engine.GetPlayerGUID() :
 		senderID == Engine.GetPlayerID();
 
 	// Parse private message
 	let isPM = msg.cmd == "/msg";
 	let addresseeGUID;
 	let addresseeIndex;
 	if (isPM)
 	{
 		addresseeGUID = matchUsername(msg.text);
 		let addressee = g_PlayerAssignments[addresseeGUID];
 		if (!addressee)
 		{
 			if (isSender)
 				warn("Couldn't match username: " + msg.text);
 			return false;
 		}
 
 		// Prohibit PM if addressee and sender are identical
 		if (isSender && addresseeGUID == Engine.GetPlayerGUID())
 			return false;
 
 		msg.text = msg.text.substr(addressee.name.length + 1);
 		addresseeIndex = addressee.player;
 	}
 
 	// Set context string
 	if (!g_ChatAddresseeContext[msg.cmd])
 	{
 		if (isSender)
 			warn("Unknown chat command: " + msg.cmd);
 		return false;
 	}
 	msg.context = g_ChatAddresseeContext[msg.cmd];
 
 	// For observers only permit public- and observer-chat and PM to observers
 	if (isPlayerObserver(senderID) &&
 	    (isPM && !isPlayerObserver(addresseeIndex) || !isPM && msg.cmd != "/observers"))
 		return false;
 	let visible = isSender || g_IsChatAddressee[msg.cmd](senderID, addresseeGUID);
 	msg.isVisiblePM = isPM && visible;
 
 	return visible;
 }
 
 /**
  * Returns the guid of the user with the longest name that is a prefix of the given string.
  */
 function matchUsername(text)
 {
 	if (!text)
 		return "";
 
 	let match = "";
 	let playerGUID = "";
 	for (let guid in g_PlayerAssignments)
 	{
 		let pName = g_PlayerAssignments[guid].name;
 		if (text.indexOf(pName + " ") == 0 && pName.length > match.length)
 		{
 			match = pName;
 			playerGUID = guid;
 		}
 	}
 	return playerGUID;
 }
 
 /**
  * Custom dialog response handling, usable by trigger maps.
  */
 function sendDialogAnswer(guiObject, dialogName)
 {
 	Engine.GetGUIObjectByName(dialogName + "-dialog").hidden = true;
 
 	Engine.PostNetworkCommand({
 		"type": "dialog-answer",
 		"dialog": dialogName,
 		"answer": guiObject.name.split("-").pop(),
 	});
 
 	resumeGame();
 }
 
 /**
  * Custom dialog opening, usable by trigger maps.
  */
 function openDialog(dialogName, data, player)
 {
 	let dialog = Engine.GetGUIObjectByName(dialogName + "-dialog");
 	if (!dialog)
 	{
 		warn("messages.js: Unknow dialog with name " + dialogName);
 		return;
 	}
 	dialog.hidden = false;
 
 	for (let objName in data)
 	{
 		let obj = Engine.GetGUIObjectByName(dialogName + "-dialog-" + objName);
 		if (!obj)
 		{
 			warn("messages.js: Key '" + objName + "' not found in '" + dialogName + "' dialog.");
 			continue;
 		}
 
 		for (let key in data[objName])
 		{
 			let n = data[objName][key];
 			if (typeof n == "object" && n.message)
 			{
 				let message = n.message;
 				if (n.translateMessage)
 					message = translate(message);
 				let parameters = n.parameters || {};
 				if (n.translateParameters)
 					translateObjectKeys(parameters, n.translateParameters);
 				obj[key] = sprintf(message, parameters);
 			}
 			else
 				obj[key] = n;
 		}
 	}
 
 	pauseGame();
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/session.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.xml	(revision 22514)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.xml	(revision 22515)
@@ -1,158 +1,158 @@
 <?xml version="1.0" encoding="utf-8"?>
 
 <objects>
 
 <script directory="gui/common/"/>
 <script directory="gui/session/"/>
 
 <object name="session">
 
 	<action on="Tick">
 		onTick();
 	</action>
 
 	<action on="WindowResized">
 		onWindowResized();
 	</action>
 
 	<action on="SimulationUpdate">
 		onSimulationUpdate();
 	</action>
 
 	<action on="ReplayFinished">
 		onReplayFinished();
 	</action>
 
 	<action on="ReplayOutOfSync">
-		onReplayOutOfSync();
+		onReplayOutOfSync(arguments[0], arguments[1], arguments[2]);
 	</action>
 
 	<!-- Hotkeys won't work properly unless outside menu -->
 	<include directory="gui/session/hotkeys/"/>
 
 	<!-- Time elapsed counter -->
 	<object size="100%-250 45 100%-140 65" type="text" name="timeElapsedCounter" style="SettingsText" hotkey="timeelapsedcounter.toggle" hidden="true">
 		<action on="Press">
 			Engine.ConfigDB_CreateValue("user", "gui.session.timeelapsedcounter", String(Engine.ConfigDB_GetValue("user", "gui.session.timeelapsedcounter") != "true"));
 		</action>
 	</object>
 
 	<!-- Ceasefire counter -->
 	<object size="100%-250 80 100%-140 100" type="text" name="ceasefireCounter" style="SettingsText" hotkey="ceasefirecounter.toggle" hidden="true">
 		<action on="Press">
 			Engine.ConfigDB_CreateValue("user", "gui.session.ceasefirecounter", String(Engine.ConfigDB_GetValue("user", "gui.session.ceasefirecounter") != "true"));
 		</action>
 	</object>
 
 	<!-- Network status -->
 	<object name="netStatus" type="text" style="netStatus" z="0" hidden="true">
 		<object type="button"
 			name="disconnectedExitButton"
 			style="StoneButton"
 			size="50%-84 50%+128 50%+84 50%+160"
 			tooltip_style="sessionToolTip"
 			z="0"
 		>
 			<translatableAttribute id="caption">Exit</translatableAttribute>
 			<action on="Press">leaveGame();</action>
 		</object>
 		<object name="loadingClientsText" size="50%-300 50%+60 50%+300 50%+110" type="text" style="netStatusPlayersText" hidden="true" z="0"/>
 	</object>
 
 	<!-- Pause Overlay -->
 	<object type="button" name="pauseOverlay" size="0 0 100% 100%" tooltip_style="sessionToolTip" hidden="true" z="0">
 		<object size="0 0 100% 100%" type="image" sprite="sessionOverlayBackground" ghost="true" z="0"/>
 		<object size="50%-128 40%-20 50%+128 40%+20" type="text" style="PauseText" ghost="true" z="0">
 			<translatableAttribute id="caption">Game Paused</translatableAttribute>
 		</object>
 		<object name="resumeMessage" size="50%-128 40%+20 50%+128 40%+40" type="text" style="ResumeMessageText" ghost="true" z="0">
 			<translatableAttribute id="caption">Click to Resume Game</translatableAttribute>
 		</object>
 		<object name="pausedByText" size="30% 40%+50 70% 100%" type="text" style="netStatusPlayersText" ghost="true" hidden="true" z="0"/>
 		<action on="Press">togglePause();</action>
 	</object>
 
 	<!-- Notification Area -->
 	<object name="notificationPanel" type="image" size="50%-300 60 50%+300 120" ghost="true">
 		<object name="notificationText" size="0 0 100% 100%" type="text" style="notificationPanel" ghost="true"/>
 	</object>
 
 	<!-- Chat messages -->
 	<object name="chatPanel" size="0 130 100% 100%-240" type="image" ghost="true" z="0" absolute="true">
 		<object name="chatText" size="3 1 100%-1 100%-1" type="text" style="chatPanelOverlay" ghost="true"/>
 	</object>
 
 	<!-- Entity selection state text -->
 	<object name="debugEntityState"
 		type="text"
 		size="0 70 80% 100%"
 		ghost="true"
 		textcolor="yellow"
 		font="mono-stroke-10"
 	/>
 
 	<include directory="gui/session/dialogs/"/>
 	<include file="gui/session/chat_window.xml"/>
 	<include file="gui/session/developer_overlay.xml"/>
 	<include file="gui/session/diplomacy_window.xml"/>
 	<include file="gui/session/objectives_window.xml"/>
 	<include file="gui/session/top_panel.xml"/>
 	<include file="gui/session/trade_window.xml"/>
 	<include file="gui/session/tutorial_panel.xml"/>
 	<include file="gui/session/menu.xml"/>
 
 	<!-- Contains miscellanious objects s.a.: the technology research -->
 	<!-- progress, group selection icons, and the hero selection icon -->
 	<include directory="gui/session/session_objects/"/>
 
 	<!-- Information tooltip -->
 	<!-- Follows the mouse around if 'independent' is set to 'true'. -->
 	<object name="informationTooltip" type="tooltip" independent="true" style="informationTooltip"/>
 
 	<!-- Building placement info tooltip -->
 	<object name="placementTooltip" type="tooltip" independent="true" style="informationTooltip"/>
 
 	<!-- START of BOTTOM PANEL -->
 	<!-- limit to the minimal supported width of 1024px -->
 	<object size="50%-512 0 50%+512 100%">
 
 		<include file="gui/session/minimap_panel.xml"/>
 
 		<!-- Supplemental Details Panel (Left of Selection Details) -->
 		<object
 			size="50%-304 100%-170 50%-110 100%"
 			name="supplementalSelectionDetails"
 			type="image"
 			sprite="supplementalDetailsPanel"
 			z="20"
 		>
 			<include directory="gui/session/selection_panels_left/"/>
 		</object>
 
 		<!-- Selection Details Panel (Middle) -->
 		<object name="selectionDetails"
 			type="image"
 			sprite="selectionDetailsPanel"
 			size="50%-114 100%-205 50%+114 100%"
 			hidden="false"
 		>
 			<include directory="gui/session/selection_panels_middle/"/>
 		</object>
 
 		<!-- Commands Panel (Right of Selection Details) -->
 		<object name="unitCommands"
 			type="image"
 			sprite="unitCommandsPanel"
 			size="50%+110 100%-170 50%+512 100%"
 			hidden="false"
 			z="20"
 		>
 			<include directory="gui/session/selection_panels_right/"/>
 		</object>
 	</object><!-- END OF BOTTOM PANEL -->
 </object> <!-- END OF SESSION OBJECT -->
 
 <!-- Selection bandbox -->
 <object name="bandbox" type="image" sprite="bandbox" ghost="true" hidden="true" z="200"/>
 
 </objects>
Index: ps/trunk/source/gui/CGUI.cpp
===================================================================
--- ps/trunk/source/gui/CGUI.cpp	(revision 22514)
+++ ps/trunk/source/gui/CGUI.cpp	(revision 22515)
@@ -1,1757 +1,1761 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include <stdarg.h>
 #include <string>
 
 #include "GUI.h"
 
 // Types - when including them into the engine.
 #include "CButton.h"
 #include "CChart.h"
 #include "CCheckBox.h"
 #include "CDropDown.h"
 #include "CImage.h"
 #include "CInput.h"
 #include "CList.h"
 #include "COList.h"
 #include "CProgressBar.h"
 #include "CRadioButton.h"
 #include "CSlider.h"
 #include "CText.h"
 #include "CTooltip.h"
 #include "MiniMap.h"
 
 #include "graphics/FontMetrics.h"
 #include "graphics/ShaderManager.h"
 #include "graphics/TextRenderer.h"
 #include "i18n/L10n.h"
 #include "lib/bits.h"
 #include "lib/input.h"
 #include "lib/sysdep/sysdep.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Profile.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "scripting/ScriptFunctions.h"
 #include "scriptinterface/ScriptInterface.h"
 
 extern int g_yres;
 
 const double SELECT_DBLCLICK_RATE = 0.5;
 const u32 MAX_OBJECT_DEPTH = 100; // Max number of nesting for GUI includes. Used to detect recursive inclusion
 
 InReaction CGUI::HandleEvent(const SDL_Event_* ev)
 {
 	InReaction ret = IN_PASS;
 
 	if (ev->ev.type == SDL_HOTKEYDOWN || ev->ev.type == SDL_HOTKEYUP)
 	{
 		const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
 
 		std::map<CStr, std::vector<IGUIObject*> >::iterator it = m_HotkeyObjects.find(hotkey);
 		if (it != m_HotkeyObjects.end())
 			for (IGUIObject* const& obj : it->second)
 			{
 				// Update hotkey status before sending the event,
 				// else the status will be outdated when processing the GUI event.
 				HotkeyInputHandler(ev);
 				ret = IN_HANDLED;
 
 				if (ev->ev.type == SDL_HOTKEYDOWN)
 					obj->SendEvent(GUIM_PRESSED, "press");
 				else
 					obj->SendEvent(GUIM_RELEASED, "release");
 			}
 	}
 
 	else if (ev->ev.type == SDL_MOUSEMOTION)
 	{
 		// Yes the mouse position is stored as float to avoid
 		//  constant conversions when operating in a
 		//  float-based environment.
 		m_MousePos = CPos((float)ev->ev.motion.x / g_GuiScale, (float)ev->ev.motion.y / g_GuiScale);
 
 		SGUIMessage msg(GUIM_MOUSE_MOTION);
 		GUI<SGUIMessage>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
 										&IGUIObject::HandleMessage,
 										msg);
 	}
 
 	// Update m_MouseButtons. (BUTTONUP is handled later.)
 	else if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons |= Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Update m_MousePos (for delayed mouse button events)
 	CPos oldMousePos = m_MousePos;
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		m_MousePos = CPos((float)ev->ev.button.x / g_GuiScale, (float)ev->ev.button.y / g_GuiScale);
 	}
 
 	// Only one object can be hovered
 	IGUIObject* pNearest = NULL;
 
 	// TODO Gee: (2004-09-08) Big TODO, don't do the below if the SDL_Event is something like a keypress!
 	try
 	{
 		PROFILE("mouse events");
 		// TODO Gee: Optimizations needed!
 		//  these two recursive function are quite overhead heavy.
 
 		// pNearest will after this point at the hovered object, possibly NULL
 		pNearest = FindObjectUnderMouse();
 
 		// Now we'll call UpdateMouseOver on *all* objects,
 		//  we'll input the one hovered, and they will each
 		//  update their own data and send messages accordingly
 		GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST,
 			m_BaseObject, &IGUIObject::UpdateMouseOver, pNearest);
 
 		if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				// Focus the clicked object (or focus none if nothing clicked on)
 				SetFocusedObject(pNearest);
 
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_LEFT, "mouseleftpress");
 				break;
 
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 					ret = pNearest->SendEvent(GUIM_MOUSE_PRESS_RIGHT, "mouserightpress");
 				break;
 
 			default:
 				break;
 			}
 		}
 		else if (ev->ev.type == SDL_MOUSEWHEEL && pNearest)
 		{
 			if (ev->ev.wheel.y < 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_DOWN, "mousewheeldown");
 			else if (ev->ev.wheel.y > 0)
 				ret = pNearest->SendEvent(GUIM_MOUSE_WHEEL_UP, "mousewheelup");
 		}
 		else if (ev->ev.type == SDL_MOUSEBUTTONUP)
 		{
 			switch (ev->ev.button.button)
 			{
 			case SDL_BUTTON_LEFT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
 					pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_LEFT, "mouseleftdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_LEFT, "mouseleftrelease");
 				}
 				break;
 			case SDL_BUTTON_RIGHT:
 				if (pNearest)
 				{
 					double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
 					pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = timer_Time();
 
 					if (timeElapsed < SELECT_DBLCLICK_RATE)
 						ret = pNearest->SendEvent(GUIM_MOUSE_DBLCLICK_RIGHT, "mouserightdoubleclick");
 					else
 						ret = pNearest->SendEvent(GUIM_MOUSE_RELEASE_RIGHT, "mouserightrelease");
 				}
 				break;
 			}
 
 			// Reset all states on all visible objects
 			GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject,
 									&IGUIObject::ResetStates);
 
 			// Since the hover state will have been reset, we reload it.
 			GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST,
 				m_BaseObject, &IGUIObject::UpdateMouseOver, pNearest);
 		}
 	}
 	catch (PSERROR_GUI& e)
 	{
 		UNUSED2(e);
 		debug_warn(L"CGUI::HandleEvent error");
 		// TODO Gee: Handle
 	}
 
 	// BUTTONUP's effect on m_MouseButtons is handled after
 	// everything else, so that e.g. 'press' handlers (activated
 	// on button up) see which mouse button had been pressed.
 	if (ev->ev.type == SDL_MOUSEBUTTONUP)
 	{
 		switch (ev->ev.button.button)
 		{
 		case SDL_BUTTON_LEFT:
 		case SDL_BUTTON_RIGHT:
 		case SDL_BUTTON_MIDDLE:
 			m_MouseButtons &= ~Bit<unsigned int>(ev->ev.button.button);
 			break;
 		default:
 			break;
 		}
 	}
 
 	// Restore m_MousePos (for delayed mouse button events)
 	if (ev->ev.type == SDL_MOUSEBUTTONDOWN || ev->ev.type == SDL_MOUSEBUTTONUP)
 		m_MousePos = oldMousePos;
 
 	// Handle keys for input boxes
 	if (GetFocusedObject())
 	{
 		if ((ev->ev.type == SDL_KEYDOWN &&
 		     ev->ev.key.keysym.sym != SDLK_ESCAPE &&
 		     !g_keys[SDLK_LCTRL] && !g_keys[SDLK_RCTRL] &&
 		     !g_keys[SDLK_LALT] && !g_keys[SDLK_RALT]) ||
 		    ev->ev.type == SDL_HOTKEYDOWN ||
 		    ev->ev.type == SDL_TEXTINPUT ||
 		    ev->ev.type == SDL_TEXTEDITING)
 		{
 			ret = GetFocusedObject()->ManuallyHandleEvent(ev);
 		}
 		// else will return IN_PASS because we never used the button.
 	}
 
 	return ret;
 }
 
 void CGUI::TickObjects()
 {
 	CStr action = "tick";
 	GUI<CStr>::RecurseObject(0, m_BaseObject,
 							&IGUIObject::ScriptEvent, action);
 
 	m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, this);
 }
 
 void CGUI::SendEventToAll(const CStr& EventName)
 {
 	// janwas 2006-03-03: spoke with Ykkrosh about EventName case.
 	// when registering, case is converted to lower - this avoids surprise
 	// if someone were to get the case wrong and then not notice their
 	// handler is never called. however, until now, the other end
 	// (sending events here) wasn't converting to lower case,
 	// leading to a similar problem.
 	// now fixed; case is irrelevant since all are converted to lower.
-	GUI<CStr>::RecurseObject(0, m_BaseObject,
-		&IGUIObject::ScriptEvent, EventName.LowerCase());
+	GUI<CStr>::RecurseObject(0, m_BaseObject, &IGUIObject::ScriptEvent, EventName.LowerCase());
+}
+
+void CGUI::SendEventToAll(const CStr& EventName, JS::HandleValueArray paramData)
+{
+	GUI<CStr>::RecurseObject(0, m_BaseObject, &IGUIObject::ScriptEvent, EventName.LowerCase(), paramData);
 }
 
 CGUI::CGUI(const shared_ptr<ScriptRuntime>& runtime)
 	: m_MouseButtons(0), m_FocusedObject(NULL), m_InternalNameNumber(0)
 {
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIPage", runtime));
 	m_ScriptInterface->SetCallbackData(this);
 
 	GuiScriptingInit(*m_ScriptInterface);
 	m_ScriptInterface->LoadGlobalScripts();
 	m_BaseObject = new CGUIDummyObject;
 	m_BaseObject->SetGUI(this);
 }
 
 CGUI::~CGUI()
 {
 	Destroy();
 
 	if (m_BaseObject)
 		delete m_BaseObject;
 }
 
 IGUIObject* CGUI::ConstructObject(const CStr& str)
 {
 	if (m_ObjectTypes.count(str) > 0)
 		return (*m_ObjectTypes[str])();
 	else
 	{
 		// Error reporting will be handled with the NULL return.
 		return NULL;
 	}
 }
 
 void CGUI::Initialize()
 {
 	// Add base types!
 	//  You can also add types outside the GUI to extend the flexibility of the GUI.
 	//  Pyrogenesis though will have all the object types inserted from here.
 	AddObjectType("empty",			&CGUIDummyObject::ConstructObject);
 	AddObjectType("button",			&CButton::ConstructObject);
 	AddObjectType("image",			&CImage::ConstructObject);
 	AddObjectType("text",			&CText::ConstructObject);
 	AddObjectType("checkbox",		&CCheckBox::ConstructObject);
 	AddObjectType("radiobutton",	&CRadioButton::ConstructObject);
 	AddObjectType("progressbar",	&CProgressBar::ConstructObject);
 	AddObjectType("minimap",        &CMiniMap::ConstructObject);
 	AddObjectType("input",			&CInput::ConstructObject);
 	AddObjectType("list",			&CList::ConstructObject);
 	AddObjectType("olist",			&COList::ConstructObject);
 	AddObjectType("dropdown",		&CDropDown::ConstructObject);
 	AddObjectType("tooltip",		&CTooltip::ConstructObject);
 	AddObjectType("chart",			&CChart::ConstructObject);
 	AddObjectType("slider",			&CSlider::ConstructObject);
 }
 
 void CGUI::Draw()
 {
 	// Clear the depth buffer, so the GUI is
 	// drawn on top of everything else
 	glClear(GL_DEPTH_BUFFER_BIT);
 
 	try
 	{
 		// Recurse IGUIObject::Draw() with restriction: hidden
 		//  meaning all hidden objects won't call Draw (nor will it recurse its children)
 		GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, &IGUIObject::Draw);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("GUI draw error: %s", e.what());
 	}
 }
 
 void CGUI::DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float& Z, const CRect& Rect, const CRect& UNUSED(Clipping))
 {
 	// If the sprite doesn't exist (name == ""), don't bother drawing anything
 	if (Sprite.IsEmpty())
 		return;
 
 	// TODO: Clipping?
 
 	Sprite.Draw(Rect, CellID, m_Sprites, Z);
 }
 
 void CGUI::Destroy()
 {
 	// We can use the map to delete all
 	//  now we don't want to cancel all if one Destroy fails
 	for (const std::pair<CStr, IGUIObject*>& p : m_pAllObjects)
 	{
 		try
 		{
 			p.second->Destroy();
 		}
 		catch (PSERROR_GUI& e)
 		{
 			UNUSED2(e);
 			debug_warn(L"CGUI::Destroy error");
 			// TODO Gee: Handle
 		}
 
 		delete p.second;
 	}
 	m_pAllObjects.clear();
 
 	for (const std::pair<CStr, CGUISprite*>& p : m_Sprites)
 		delete p.second;
 	m_Sprites.clear();
 	m_Icons.clear();
 }
 
 void CGUI::UpdateResolution()
 {
 	// Update ALL cached
 	GUI<>::RecurseObject(0, m_BaseObject, &IGUIObject::UpdateCachedSize);
 }
 
 void CGUI::AddObject(IGUIObject* pObject)
 {
 	try
 	{
 		// Add CGUI pointer
 		GUI<CGUI*>::RecurseObject(0, pObject, &IGUIObject::SetGUI, this);
 
 		m_BaseObject->AddChild(pObject);
 
 		// Cache tree
 		GUI<>::RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize);
 
 		SGUIMessage msg(GUIM_LOAD);
 		GUI<SGUIMessage>::RecurseObject(0, pObject, &IGUIObject::HandleMessage, msg);
 	}
 	catch (PSERROR_GUI&)
 	{
 		throw;
 	}
 }
 
 void CGUI::UpdateObjects()
 {
 	// We'll fill a temporary map until we know everything succeeded
 	map_pObjects AllObjects;
 
 	try
 	{
 		// Fill freshly
 		GUI<map_pObjects>::RecurseObject(0, m_BaseObject, &IGUIObject::AddToPointersMap, AllObjects);
 	}
 	catch (PSERROR_GUI&)
 	{
 		throw;
 	}
 
 	// Else actually update the real one
 	m_pAllObjects.swap(AllObjects);
 }
 
 bool CGUI::ObjectExists(const CStr& Name) const
 {
 	return m_pAllObjects.count(Name) != 0;
 }
 
 IGUIObject* CGUI::FindObjectByName(const CStr& Name) const
 {
 	map_pObjects::const_iterator it = m_pAllObjects.find(Name);
 	if (it == m_pAllObjects.end())
 		return NULL;
 	else
 		return it->second;
 }
 
 IGUIObject* CGUI::FindObjectUnderMouse() const
 {
 	IGUIObject* pNearest = NULL;
 
 	GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
 		&IGUIObject::ChooseMouseOverAndClosest, pNearest);
 
 	return pNearest;
 }
 
 void CGUI::SetFocusedObject(IGUIObject* pObject)
 {
 	if (pObject == m_FocusedObject)
 		return;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_LOST_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 
 	m_FocusedObject = pObject;
 
 	if (m_FocusedObject)
 	{
 		SGUIMessage msg(GUIM_GOT_FOCUS);
 		m_FocusedObject->HandleMessage(msg);
 	}
 }
 
 const SGUIScrollBarStyle* CGUI::GetScrollBarStyle(const CStr& style) const
 {
 	std::map<CStr, SGUIScrollBarStyle>::const_iterator it = m_ScrollBarStyles.find(style);
 	if (it == m_ScrollBarStyles.end())
 		return nullptr;
 
  	return &it->second;
 }
 
 // private struct used only in GenerateText(...)
 struct SGenerateTextImage
 {
 	float m_YFrom,			// The image's starting location in Y
 		  m_YTo,			// The image's end location in Y
 		  m_Indentation;	// The image width in other words
 
 	// Some help functions
 	// TODO Gee: CRect => CPoint ?
 	void SetupSpriteCall(const bool Left, SGUIText::SSpriteCall& SpriteCall,
 						 const float width, const float y,
 						 const CSize& Size, const CStr& TextureName,
 						 const float BufferZone, const int CellID)
 	{
 		// TODO Gee: Temp hardcoded values
 		SpriteCall.m_Area.top = y+BufferZone;
 		SpriteCall.m_Area.bottom = y+BufferZone + Size.cy;
 
 		if (Left)
 		{
 			SpriteCall.m_Area.left = BufferZone;
 			SpriteCall.m_Area.right = Size.cx+BufferZone;
 		}
 		else
 		{
 			SpriteCall.m_Area.left = width-BufferZone - Size.cx;
 			SpriteCall.m_Area.right = width-BufferZone;
 		}
 
 		SpriteCall.m_CellID = CellID;
 		SpriteCall.m_Sprite = TextureName;
 
 		m_YFrom = SpriteCall.m_Area.top-BufferZone;
 		m_YTo = SpriteCall.m_Area.bottom+BufferZone;
 		m_Indentation = Size.cx+BufferZone*2;
 	}
 };
 
 SGUIText CGUI::GenerateText(const CGUIString& string, const CStrW& FontW, const float& Width, const float& BufferZone, const IGUIObject* pObject)
 {
 	SGUIText Text;
 
 	CStrIntern Font(FontW.ToUTF8());
 
 	if (string.m_Words.empty())
 		return Text;
 
 	float x = BufferZone, y = BufferZone; // drawing pointer
 	int from = 0;
 	bool done = false;
 
 	bool FirstLine = true;	// Necessary because text in the first line is shorter
 							// (it doesn't count the line spacing)
 
 	// Images on the left or the right side.
 	std::vector<SGenerateTextImage> Images[2];
 	int pos_last_img = -1;	// Position in the string where last img (either left or right) were encountered.
 							//  in order to avoid duplicate processing.
 
 	// Easier to read.
 	bool WordWrapping = (Width != 0);
 
 	// get the alignment type for the control we are computing the text for since
 	// we are computing the horizontal alignment in this method in order to not have
 	// to run through the TextCalls a second time in the CalculateTextPosition method again
 	EAlign align = EAlign_Left;
 	if (pObject->SettingExists("text_align"))
 		GUI<EAlign>::GetSetting(pObject, "text_align", align);
 
 	// Go through string word by word
 	for (int i = 0; i < (int)string.m_Words.size()-1 && !done; ++i)
 	{
 		// Pre-process each line one time, so we know which floating images
 		//  will be added for that line.
 
 		// Generated stuff is stored in Feedback.
 		CGUIString::SFeedback Feedback;
 
 		// Preliminary line_height, used for word-wrapping with floating images.
 		float prelim_line_height = 0.f;
 
 		// Width and height of all text calls generated.
 		string.GenerateTextCall(this, Feedback, Font,
 								string.m_Words[i], string.m_Words[i+1],
 								FirstLine);
 
 		// Loop through our images queues, to see if images has been added.
 
 		// Check if this has already been processed.
 		//  Also, floating images are only applicable if Word-Wrapping is on
 		if (WordWrapping && i > pos_last_img)
 		{
 			// Loop left/right
 			for (int j = 0; j < 2; ++j)
 			{
 				for (const CStr& imgname : Feedback.m_Images[j])
 				{
 					SGUIText::SSpriteCall SpriteCall;
 					SGenerateTextImage Image;
 
 					// Y is if no other floating images is above, y. Else it is placed
 					//  after the last image, like a stack downwards.
 					float _y;
 					if (!Images[j].empty())
 						_y = std::max(y, Images[j].back().m_YTo);
 					else
 						_y = y;
 
 					// Get Size from Icon database
 					SGUIIcon icon = GetIcon(imgname);
 
 					CSize size = icon.m_Size;
 					Image.SetupSpriteCall((j == CGUIString::SFeedback::Left), SpriteCall, Width, _y, size, icon.m_SpriteName, BufferZone, icon.m_CellID);
 
 					// Check if image is the lowest thing.
 					Text.m_Size.cy = std::max(Text.m_Size.cy, Image.m_YTo);
 
 					Images[j].push_back(Image);
 					Text.m_SpriteCalls.push_back(SpriteCall);
 				}
 			}
 		}
 
 		pos_last_img = std::max(pos_last_img, i);
 
 		x += Feedback.m_Size.cx;
 		prelim_line_height = std::max(prelim_line_height, Feedback.m_Size.cy);
 
 		// If Width is 0, then there's no word-wrapping, disable NewLine.
 		if ((WordWrapping && (x > Width-BufferZone || Feedback.m_NewLine)) || i == (int)string.m_Words.size()-2)
 		{
 			// Change 'from' to 'i', but first keep a copy of its value.
 			int temp_from = from;
 			from = i;
 
 			static const int From = 0, To = 1;
 			//int width_from=0, width_to=width;
 			float width_range[2];
 			width_range[From] = BufferZone;
 			width_range[To] = Width - BufferZone;
 
 			// Floating images are only applicable if word-wrapping is enabled.
 			if (WordWrapping)
 			{
 				// Decide width of the line. We need to iterate our floating images.
 				//  this won't be exact because we're assuming the line_height
 				//  will be as our preliminary calculation said. But that may change,
 				//  although we'd have to add a couple of more loops to try straightening
 				//  this problem out, and it is very unlikely to happen noticeably if one
 				//  structures his text in a stylistically pure fashion. Even if not, it
 				//  is still quite unlikely it will happen.
 				// Loop through left and right side, from and to.
 				for (int j = 0; j < 2; ++j)
 				{
 					for (const SGenerateTextImage& img : Images[j])
 					{
 						// We're working with two intervals here, the image's and the line height's.
 						//  let's find the union of these two.
 						float union_from, union_to;
 
 						union_from = std::max(y, img.m_YFrom);
 						union_to = std::min(y+prelim_line_height, img.m_YTo);
 
 						// The union is not empty
 						if (union_to > union_from)
 						{
 							if (j == From)
 								width_range[From] = std::max(width_range[From], img.m_Indentation);
 							else
 								width_range[To] = std::min(width_range[To], Width - img.m_Indentation);
 						}
 					}
 				}
 			}
 
 			// Reset X for the next loop
 			x = width_range[From];
 
 			// Now we'll do another loop to figure out the height and width of
 			//  the line (the height of the largest character and the width is
 			//  the sum of all of the individual widths). This
 			//  couldn't be determined in the first loop (main loop)
 			//  because it didn't regard images, so we don't know
 			//  if all characters processed, will actually be involved
 			//  in that line.
 			float line_height = 0.f;
 			float line_width = 0.f;
 			for (int j = temp_from; j <= i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another.
 				CGUIString::SFeedback Feedback2;
 
 				// Don't attach object, it'll suppress the errors
 				//  we want them to be reported in the final GenerateTextCall()
 				//  so that we don't get duplicates.
 				string.GenerateTextCall(this, Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1],
 										FirstLine);
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				if (WordWrapping && x > width_range[To] && j!=temp_from && !Feedback2.m_NewLine)
 				{
 					// The calculated width of each word includes the space between the current
 					// word and the next. When we're wrapping, we need subtract the width of the
 					// space after the last word on the line before the wrap.
 					CFontMetrics currentFont(Font);
 					line_width -= currentFont.GetCharacterWidth(*L" ");
 					break;
 				}
 
 				// Let line_height be the maximum m_Height we encounter.
 				line_height = std::max(line_height, Feedback2.m_Size.cy);
 
 				// If the current word is an explicit new line ("\n"),
 				// break now before adding the width of this character.
 				// ("\n" doesn't have a glyph, thus is given the same width as
 				// the "missing glyph" character by CFont::GetCharacterWidth().)
 				if (WordWrapping && Feedback2.m_NewLine)
 					break;
 
 				line_width += Feedback2.m_Size.cx;
 			}
 
 			float dx = 0.f;
 			// compute offset based on what kind of alignment
 			switch (align)
 			{
 			case EAlign_Left:
 				// don't add an offset
 				dx = 0.f;
 				break;
 
 			case EAlign_Center:
 				dx = ((width_range[To] - width_range[From]) - line_width) / 2;
 				break;
 
 			case EAlign_Right:
 				dx = width_range[To] - line_width;
 				break;
 
 			default:
 				debug_warn(L"Broken EAlign in CGUI::GenerateText()");
 				break;
 			}
 			// Reset x once more
 			x = width_range[From];
 			// Move down, because font drawing starts from the baseline
 			y += line_height;
 
 			// Do the real processing now
 			for (int j = temp_from; j <= i; ++j)
 			{
 				// We don't want to use Feedback now, so we'll have to use
 				//  another one.
 				CGUIString::SFeedback Feedback2;
 
 				// Defaults
 				string.GenerateTextCall(this, Feedback2, Font,
 										string.m_Words[j], string.m_Words[j+1],
 										FirstLine, pObject);
 
 				// Iterate all and set X/Y values
 				// Since X values are not set, we need to make an internal
 				//  iteration with an increment that will append the internal
 				//  x, that is what x_pointer is for.
 				float x_pointer = 0.f;
 
 				for (SGUIText::STextCall& tc : Feedback2.m_TextCalls)
 				{
 					tc.m_Pos = CPos(dx + x + x_pointer, y);
 
 					x_pointer += tc.m_Size.cx;
 
 					if (tc.m_pSpriteCall)
 						tc.m_pSpriteCall->m_Area += tc.m_Pos - CSize(0, tc.m_pSpriteCall->m_Area.GetHeight());
 				}
 
 				// Append X value.
 				x += Feedback2.m_Size.cx;
 
 				// The first word overrides the width limit, what we
 				//  do, in those cases, are just drawing that word even
 				//  though it'll extend the object.
 				if (WordWrapping) // only if word-wrapping is applicable
 				{
 					if (Feedback2.m_NewLine)
 					{
 						from = j+1;
 
 						// Sprite call can exist within only a newline segment,
 						//  therefore we need this.
 						Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 						break;
 					}
 					else if (x > width_range[To] && j == temp_from)
 					{
 						from = j+1;
 						// do not break, since we want it to be added to m_TextCalls
 					}
 					else if (x > width_range[To])
 					{
 						from = j;
 						break;
 					}
 				}
 
 				// Add the whole Feedback2.m_TextCalls to our m_TextCalls.
 				Text.m_TextCalls.insert(Text.m_TextCalls.end(), Feedback2.m_TextCalls.begin(), Feedback2.m_TextCalls.end());
 				Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
 
 				if (j == (int)string.m_Words.size()-2)
 					done = true;
 			}
 
 			// Reset X
 			x = BufferZone;
 
 			// Update dimensions
 			Text.m_Size.cx = std::max(Text.m_Size.cx, line_width + BufferZone * 2);
 			Text.m_Size.cy = std::max(Text.m_Size.cy, y + BufferZone);
 
 			FirstLine = false;
 
 			// Now if we entered as from = i, then we want
 			//  i being one minus that, so that it will become
 			//  the same i in the next loop. The difference is that
 			//  we're on a new line now.
 			i = from-1;
 		}
 	}
 
 	return Text;
 }
 
 void CGUI::DrawText(SGUIText& Text, const CColor& DefaultColor, const CPos& pos, const float& z, const CRect& clipping)
 {
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_gui_text);
 
 	tech->BeginPass();
 
 	bool isClipped = (clipping != CRect());
 	if (isClipped)
 	{
 		glEnable(GL_SCISSOR_TEST);
 		glScissor(
 			clipping.left * g_GuiScale,
 			g_yres - clipping.bottom * g_GuiScale,
 			clipping.GetWidth() * g_GuiScale,
 			clipping.GetHeight() * g_GuiScale);
 	}
 
 	CTextRenderer textRenderer(tech->GetShader());
 	textRenderer.SetClippingRect(clipping);
 	textRenderer.Translate(0.0f, 0.0f, z);
 
 	for (const SGUIText::STextCall& tc : Text.m_TextCalls)
 	{
 		// If this is just a placeholder for a sprite call, continue
 		if (tc.m_pSpriteCall)
 			continue;
 
 		CColor color = tc.m_UseCustomColor ? tc.m_Color : DefaultColor;
 
 		textRenderer.Color(color);
 		textRenderer.Font(tc.m_Font);
 		textRenderer.Put((float)(int)(pos.x + tc.m_Pos.x), (float)(int)(pos.y + tc.m_Pos.y), &tc.m_String);
 	}
 
 	textRenderer.Render();
 
 	for (const SGUIText::SSpriteCall& sc : Text.m_SpriteCalls)
 		DrawSprite(sc.m_Sprite, sc.m_CellID, z, sc.m_Area + pos);
 
 	if (isClipped)
 		glDisable(GL_SCISSOR_TEST);
 
 	tech->EndPass();
 }
 
 bool CGUI::GetPreDefinedColor(const CStr& name, CColor& Output) const
 {
 	std::map<CStr, CColor>::const_iterator cit = m_PreDefinedColors.find(name);
 	if (cit == m_PreDefinedColors.end())
 		return false;
 
 	Output = cit->second;
 	return true;
 }
 
 /**
  * @callgraph
  */
 void CGUI::LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths)
 {
 	Paths.insert(Filename);
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
 		return;
 
 	XMBElement node = XeroFile.GetRoot();
 
 	CStr root_name(XeroFile.GetElementString(node.GetNodeName()));
 	try
 	{
 		if (root_name == "objects")
 		{
 			Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
 
 			// Re-cache all values so these gets cached too.
 			//UpdateResolution();
 		}
 		else if (root_name == "sprites")
 			Xeromyces_ReadRootSprites(node, &XeroFile);
 		else if (root_name == "styles")
 			Xeromyces_ReadRootStyles(node, &XeroFile);
 		else if (root_name == "setup")
 			Xeromyces_ReadRootSetup(node, &XeroFile);
 		else
 			debug_warn(L"CGUI::LoadXmlFile error");
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("Errors loading GUI file %s (%u)", Filename.string8(), e.getCode());
 		return;
 	}
 }
 
 //===================================================================
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
 void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	int el_script = pFile->GetElementID("script");
 
 	std::vector<std::pair<CStr, CStr> > subst;
 
 	// Iterate main children
 	//  they should all be <object> or <script> elements
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		if (child.GetNodeName() == el_script)
 			// Execute the inline script
 			Xeromyces_ReadScript(child, pFile, Paths);
 		else
 			// Read in this whole object into the GUI
 			Xeromyces_ReadObject(child, pFile, m_BaseObject, subst, Paths, 0);
 	}
 }
 
 void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadSprite(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 		Xeromyces_ReadStyle(child, pFile);
 }
 
 void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
 {
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr name(pFile->GetElementString(child.GetNodeName()));
 
 		if (name == "scrollbar")
 			Xeromyces_ReadScrollBarStyle(child, pFile);
 		else if (name == "icon")
 			Xeromyces_ReadIcon(child, pFile);
 		else if (name == "tooltip")
 			Xeromyces_ReadTooltip(child, pFile);
 		else if (name == "color")
 			Xeromyces_ReadColor(child, pFile);
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	ENSURE(pParent);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CStr type(attributes.GetNamedItem(pFile->GetAttributeID("type")));
 	if (type.empty())
 		type = "empty";
 
 	// Construct object from specified type
 	//  henceforth, we need to do a rollback before aborting.
 	//  i.e. releasing this object
 	IGUIObject* object = ConstructObject(type);
 
 	if (!object)
 	{
 		LOGERROR("GUI: Unrecognized object type \"%s\"", type.c_str());
 		return;
 	}
 
 	// Cache some IDs for element attribute names, to avoid string comparisons
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ELMT(action);
 	ELMT(repeat);
 	ELMT(translatableAttribute);
 	ELMT(translate);
 	ELMT(attribute);
 	ELMT(keep);
 	ELMT(include);
 	ATTR(style);
 	ATTR(type);
 	ATTR(name);
 	ATTR(hotkey);
 	ATTR(z);
 	ATTR(on);
 	ATTR(file);
 	ATTR(directory);
 	ATTR(id);
 	ATTR(context);
 
 	//
 	//	Read Style and set defaults
 	//
 	//	If the setting "style" is set, try loading that setting.
 	//
 	//	Always load default (if it's available) first!
 	//
 	CStr argStyle(attributes.GetNamedItem(attr_style));
 
 	if (m_Styles.count("default") == 1)
 		object->LoadStyle(*this, "default");
 
 	if (!argStyle.empty())
 	{
 		if (m_Styles.count(argStyle) == 0)
 			LOGERROR("GUI: Trying to use style '%s' that doesn't exist.", argStyle.c_str());
 		else
 			object->LoadStyle(*this, argStyle);
 	}
 
 	bool NameSet = false;
 	bool ManuallySetZ = false;
 
 	CStrW inclusionPath;
 	CStr hotkeyTag;
 
 	for (XMBAttribute attr : attributes)
 	{
 		// If value is "null", then it is equivalent as never being entered
 		if (CStr(attr.Value) == "null")
 			continue;
 
 		// Ignore "type" and "style", we've already checked it
 		if (attr.Name == attr_type || attr.Name == attr_style)
 			continue;
 
 		if (attr.Name == attr_name)
 		{
 			CStr name(attr.Value);
 
 			for (const std::pair<CStr, CStr>& sub : NameSubst)
 				name.Replace(sub.first, sub.second);
 
 			object->SetName(name);
 			NameSet = true;
 			continue;
 		}
 
 		if (attr.Name == attr_hotkey)
 			hotkeyTag = attr.Value;
 
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
 		if (object->SetSetting(pFile->GetAttributeString(attr.Name), attr.Value.FromUTF8(), true) != PSRETURN_OK)
 			LOGERROR("GUI: (object: %s) Can't set \"%s\" to \"%s\"", object->GetPresentableName(), pFile->GetAttributeString(attr.Name), attr.Value);
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
 	if (!NameSet)
 	{
 		object->SetName("__internal(" + CStr::FromInt(m_InternalNameNumber) + ")");
 		++m_InternalNameNumber;
 	}
 
 	if (!hotkeyTag.empty())
 		m_HotkeyObjects[hotkeyTag].push_back(object);
 
 	CStrW caption(Element.GetText().FromUTF8());
 	if (!caption.empty())
 		object->SetSetting("caption", caption, true);
 
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		// Check what name the elements got
 		int element_name = child.GetNodeName();
 
 		if (element_name == elmt_object)
 		{
 			// Call this function on the child
 			Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_action)
 		{
 			// Scripted <action> element
 
 			// Check for a 'file' parameter
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 
 			CStr code;
 
 			// If there is a file, open it and use it as the code
 			if (!filename.empty())
 			{
 				Paths.insert(filename);
 				CVFSFile scriptfile;
 				if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
 				{
 					LOGERROR("Error opening GUI script action file '%s'", utf8_from_wstring(filename));
 					throw PSERROR_GUI_JSOpenFailed();
 				}
 
 				code = scriptfile.DecodeUTF8(); // assume it's UTF-8
 			}
 
 			XMBElementList grandchildren = child.GetChildNodes();
 			if (!grandchildren.empty()) // The <action> element contains <keep> and <translate> tags.
 				for (XMBElement grandchild : grandchildren)
 				{
 					if (grandchild.GetNodeName() == elmt_translate)
 						code += g_L10n.Translate(grandchild.GetText());
 					else if (grandchild.GetNodeName() == elmt_keep)
 						code += grandchild.GetText();
 				}
 			else // It’s pure JavaScript code.
 				// Read the inline code (concatenating to the file code, if both are specified)
 				code += CStr(child.GetText());
 
 			CStr action = CStr(child.GetAttributes().GetNamedItem(attr_on));
 
 			// We need to set the GUI this object belongs to because RegisterScriptHandler requires an associated GUI.
 			object->SetGUI(this);
 			object->RegisterScriptHandler(action.LowerCase(), code, this);
 		}
 		else if (element_name == elmt_repeat)
 		{
 			Xeromyces_ReadRepeat(child, pFile, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_translatableAttribute)
 		{
 			// This is an element in the form “<translatableAttribute id="attributeName">attributeValue</translatableAttribute>”.
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: ‘translatableAttribute’ XML element with empty ‘id’ XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr value(child.GetText());
 			if (value.empty())
 				continue;
 
 			CStr context(child.GetAttributes().GetNamedItem(attr_context)); // Read the context if any.
 			if (!context.empty())
 			{
 				CStr translatedValue(g_L10n.TranslateWithContext(context, value));
 				object->SetSetting(attributeName, translatedValue.FromUTF8(), true);
 			}
 			else
 			{
 				CStr translatedValue(g_L10n.Translate(value));
 				object->SetSetting(attributeName, translatedValue.FromUTF8(), true);
 			}
 		}
 		else if (element_name == elmt_attribute)
 		{
 			// This is an element in the form “<attribute id="attributeName"><keep>Don’t translate this part
 			// </keep><translate>but translate this one.</translate></attribute>”.
 			CStr attributeName(child.GetAttributes().GetNamedItem(attr_id)); // Read the attribute name.
 			if (attributeName.empty())
 			{
 				LOGERROR("GUI: ‘attribute’ XML element with empty ‘id’ XML attribute found. (object: %s)", object->GetPresentableName().c_str());
 				continue;
 			}
 
 			CStr translatedValue;
 
 			for (XMBElement grandchild : child.GetChildNodes())
 			{
 				if (grandchild.GetNodeName() == elmt_translate)
 					translatedValue += g_L10n.Translate(grandchild.GetText());
 				else if (grandchild.GetNodeName() == elmt_keep)
 					translatedValue += grandchild.GetText();
 			}
 			object->SetSetting(attributeName, translatedValue.FromUTF8(), true);
 		}
 		else if (element_name == elmt_include)
 		{
 			CStrW filename(child.GetAttributes().GetNamedItem(attr_file).FromUTF8());
 			CStrW directory(child.GetAttributes().GetNamedItem(attr_directory).FromUTF8());
 			if (!filename.empty())
 			{
 				if (!directory.empty())
 					LOGWARNING("GUI: Include element found with file name (%s) and directory name (%s). Only the file will be processed.", utf8_from_wstring(filename), utf8_from_wstring(directory));
 
 				Paths.insert(filename);
 
 				CXeromyces XeroIncluded;
 				if (XeroIncluded.Load(g_VFS, filename, "gui") != PSRETURN_OK)
 				{
 					LOGERROR("GUI: Error reading included XML: '%s'", utf8_from_wstring(filename));
 					continue;
 				}
 
 				XMBElement node = XeroIncluded.GetRoot();
 				if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
 				{
 					LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", utf8_from_wstring(filename));
 					continue;
 				}
 
 				if (nesting_depth+1 >= MAX_OBJECT_DEPTH)
 				{
 					LOGERROR("GUI: Too many nested GUI includes. Probably caused by a recursive include attribute. Abort rendering '%s'.", utf8_from_wstring(filename));
 					continue;
 				}
 
 				Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
 			}
 			else if (!directory.empty())
 			{
 				if (nesting_depth+1 >= MAX_OBJECT_DEPTH)
 				{
 					LOGERROR("GUI: Too many nested GUI includes. Probably caused by a recursive include attribute. Abort rendering '%s'.", utf8_from_wstring(directory));
 					continue;
 				}
 
 				VfsPaths pathnames;
 				vfs::GetPathnames(g_VFS, directory, L"*.xml", pathnames);
 				for (const VfsPath& path : pathnames)
 				{
 					// as opposed to loading scripts, don't care if it's loaded before
 					// one might use the same parts of the GUI in different situations
 					Paths.insert(path);
 					CXeromyces XeroIncluded;
 					if (XeroIncluded.Load(g_VFS, path, "gui") != PSRETURN_OK)
 					{
 						LOGERROR("GUI: Error reading included XML: '%s'", path.string8());
 						continue;
 					}
 
 					XMBElement node = XeroIncluded.GetRoot();
 					if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
 					{
 						LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", path.string8());
 						continue;
 					}
 					Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
 				}
 
 			}
 			else
 				LOGERROR("GUI: 'include' XML element must have valid 'file' or 'directory' attribute found. (object %s)", object->GetPresentableName().c_str());
 		}
 		else
 		{
 			// Try making the object read the tag.
 			if (!object->HandleAdditionalChildren(child, pFile))
 				LOGERROR("GUI: (object: %s) Reading unknown children for its type", object->GetPresentableName().c_str());
 		}
 	}
 
 	if (!ManuallySetZ)
 	{
 		// Set it automatically to 10 plus its parents
 		bool absolute;
 		GUI<bool>::GetSetting(object, "absolute", absolute);
 
 		if (absolute)
 			// If the object is absolute, we'll have to get the parent's Z buffered,
 			// and add to that!
 			GUI<float>::SetSetting(object, "z", pParent->GetBufferedZ() + 10.f, true);
 		else
 			// If the object is relative, then we'll just store Z as "10"
 			GUI<float>::SetSetting(object, "z", 10.f, true);
 	}
 
 	try
 	{
 		if (pParent == m_BaseObject)
 			AddObject(object);
 		else
 			pParent->AddChild(object);
 	}
 	catch (PSERROR_GUI& e)
 	{
 		LOGERROR("GUI error: %s", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
 	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
 	ELMT(object);
 	ATTR(count);
 	ATTR(var);
 
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
 	CStr var("["+attributes.GetNamedItem(attr_var)+"]");
 	if (var.size() < 3)
 		var = "[n]";
 
 	for (int n = 0; n < count; ++n)
 	{
 		NameSubst.emplace_back(var, "[" + CStr::FromInt(n) + "]");
 
 		XERO_ITER_EL(Element, child)
 		{
 			if (child.GetNodeName() == elmt_object)
 				Xeromyces_ReadObject(child, pFile, pParent, NameSubst, Paths, nesting_depth);
 		}
 		NameSubst.pop_back();
 	}
 }
 
 void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
 	CStrW file(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("file")).FromUTF8());
 
 	// If there is a file specified, open and execute it
 	if (!file.empty())
 	{
 		Paths.insert(file);
 		try
 		{
 			m_ScriptInterface->LoadGlobalScriptFile(file);
 		}
 		catch (PSERROR_Scripting& e)
 		{
 			LOGERROR("GUI: Error executing script %s: %s", utf8_from_wstring(file), e.what());
 		}
 	}
 
 	// If it has a directory attribute, read all JS files in that directory
 	CStrW directory(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("directory")).FromUTF8());
 	if (!directory.empty())
 	{
 		VfsPaths pathnames;
 		vfs::GetPathnames(g_VFS, directory, L"*.js", pathnames);
 		for (const VfsPath& path : pathnames)
 		{
 			// Only load new files (so when the insert succeeds)
 			if (Paths.insert(path).second)
 				try
 				{
 					m_ScriptInterface->LoadGlobalScriptFile(path);
 				}
 				catch (PSERROR_Scripting& e)
 				{
 					LOGERROR("GUI: Error executing script %s: %s", path.string8(), e.what());
 				}
 		}
 	}
 
 	// Execute inline scripts
 	try
 	{
 		CStr code(Element.GetText());
 		if (!code.empty())
 			m_ScriptInterface->LoadGlobalScript(L"Some XML file", code.FromUTF8());
 	}
 	catch (PSERROR_Scripting& e)
 	{
 		LOGERROR("GUI: Error executing inline script: %s", e.what());
 	}
 }
 
 void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
 {
 	CGUISprite* Sprite = new CGUISprite;
 
 	// Get name, we know it exists because of DTD requirements
 	CStr name = Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("name"));
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOGWARNING("GUI sprite name '%s' used more than once; first definition will be discarded", name.c_str());
 
 	SGUIImageEffects* effects = NULL;
 
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 
 		if (ElementName == "image")
 			Xeromyces_ReadImage(child, pFile, *Sprite);
 		else if (ElementName == "effect")
 		{
 			if (effects)
 				LOGERROR("GUI <sprite> must not have more than one <effect>");
 			else
 			{
 				effects = new SGUIImageEffects;
 				Xeromyces_ReadEffects(child, pFile, *effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Apply the effects to every image (unless the image overrides it with
 	// different effects)
 	if (effects)
 		for (SGUIImage* const& img : Sprite->m_Images)
 			if (!img->m_Effects)
 				img->m_Effects = new SGUIImageEffects(*effects); // do a copy just so it can be deleted correctly later
 
 	delete effects;
 
 	m_Sprites[name] = Sprite;
 }
 
 void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent)
 {
 	SGUIImage* Image = new SGUIImage;
 
 	Image->m_TextureSize = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 	Image->m_Size = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
 
 	// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStrW attr_value(attr.Value.FromUTF8());
 
 		if (attr_name == "texture")
 		{
 			Image->m_TextureName = VfsPath("art/textures/ui") / attr_value;
 		}
 		else if (attr_name == "size")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Size = ca;
 		}
 		else if (attr_name == "texture_size")
 		{
 			CClientArea ca;
 			if (!GUI<CClientArea>::ParseString(attr_value, ca))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_TextureSize = ca;
 		}
 		else if (attr_name == "real_texture_placement")
 		{
 			CRect rect;
 			if (!GUI<CRect>::ParseString(attr_value, rect))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_TexturePlacementInFile = rect;
 		}
 		else if (attr_name == "cell_size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(attr_value, size))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_CellSize = size;
 		}
 		else if (attr_name == "fixed_h_aspect_ratio")
 		{
 			float val;
 			if (!GUI<float>::ParseString(attr_value, val))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_FixedHAspectRatio = val;
 		}
 		else if (attr_name == "round_coordinates")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_RoundCoordinates = b;
 		}
 		else if (attr_name == "wrap_mode")
 		{
 			if (attr_value == L"repeat")
 				Image->m_WrapMode = GL_REPEAT;
 			else if (attr_value == L"mirrored_repeat")
 				Image->m_WrapMode = GL_MIRRORED_REPEAT;
 			else if (attr_value == L"clamp_to_edge")
 				Image->m_WrapMode = GL_CLAMP_TO_EDGE;
 			else
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 		}
 		else if (attr_name == "z_level")
 		{
 			float z_level;
 			if (!GUI<float>::ParseString(attr_value, z_level))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_DeltaZ = z_level/100.f;
 		}
 		else if (attr_name == "backcolor")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_BackColor = color;
 		}
 		else if (attr_name == "bordercolor")
 		{
 			CColor color;
 			if (!GUI<CColor>::ParseString(attr_value, color))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_BorderColor = color;
 		}
 		else if (attr_name == "border")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(attr_value, b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else
 				Image->m_Border = b;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	// Look for effects
 	for (XMBElement child : Element.GetChildNodes())
 	{
 		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			if (Image->m_Effects)
 				LOGERROR("GUI <image> must not have more than one <effect>");
 			else
 			{
 				Image->m_Effects = new SGUIImageEffects;
 				Xeromyces_ReadEffects(child, pFile, *Image->m_Effects);
 			}
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	parent.AddImage(Image);
 }
 
 void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects)
 {
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStrW attr_value(attr.Value.FromUTF8());
 
 		if (attr_name == "add_color")
 		{
 			CColor color;
 			if (!GUI<int>::ParseColor(attr_value, color, 0))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, utf8_from_wstring(attr_value));
 			else effects.m_AddColor = color;
 		}
 		else if (attr_name == "grayscale")
 			effects.m_Greyscale = true;
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
 void CGUI::Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIStyle style;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 
 		// The "name" setting is actually the name of the style
 		//  and not a new default
 		if (attr_name == "name")
 			name = attr.Value;
 		else
 			style.m_SettingsDefaults[attr_name] = attr.Value.FromUTF8();
 	}
 
 	m_Styles[name] = style;
 }
 
 void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
 
 	// Setup some defaults.
 	scrollbar.m_MinimumBarSize = 0.f;
 	// Using 1.0e10 as a substitute for infinity
 	scrollbar.m_MaximumBarSize = 1.0e10;
 	scrollbar.m_UseEdgeButtons = false;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name = pFile->GetAttributeString(attr.Name);
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "show_edge_buttons")
 		{
 			bool b;
 			if (!GUI<bool>::ParseString(attr_value.FromUTF8(), b))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_UseEdgeButtons = b;
 		}
 		else if (attr_name == "width")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_Width = f;
 		}
 		else if (attr_name == "minimum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MinimumBarSize = f;
 		}
 		else if (attr_name == "maximum_bar_size")
 		{
 			float f;
 			if (!GUI<float>::ParseString(attr_value.FromUTF8(), f))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\")", attr_name, attr_value);
 			else
 				scrollbar.m_MaximumBarSize = f;
 		}
 		else if (attr_name == "sprite_button_top")
 			scrollbar.m_SpriteButtonTop = attr_value;
 		else if (attr_name == "sprite_button_top_pressed")
 			scrollbar.m_SpriteButtonTopPressed = attr_value;
 		else if (attr_name == "sprite_button_top_disabled")
 			scrollbar.m_SpriteButtonTopDisabled = attr_value;
 		else if (attr_name == "sprite_button_top_over")
 			scrollbar.m_SpriteButtonTopOver = attr_value;
 		else if (attr_name == "sprite_button_bottom")
 			scrollbar.m_SpriteButtonBottom = attr_value;
 		else if (attr_name == "sprite_button_bottom_pressed")
 			scrollbar.m_SpriteButtonBottomPressed = attr_value;
 		else if (attr_name == "sprite_button_bottom_disabled")
 			scrollbar.m_SpriteButtonBottomDisabled = attr_value;
 		else if (attr_name == "sprite_button_bottom_over")
 			scrollbar.m_SpriteButtonBottomOver = attr_value;
 		else if (attr_name == "sprite_back_vertical")
 			scrollbar.m_SpriteBackVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical")
 			scrollbar.m_SpriteBarVertical = attr_value;
 		else if (attr_name == "sprite_bar_vertical_over")
 			scrollbar.m_SpriteBarVerticalOver = attr_value;
 		else if (attr_name == "sprite_bar_vertical_pressed")
 			scrollbar.m_SpriteBarVerticalPressed = attr_value;
 	}
 
 	m_ScrollBarStyles[name] = scrollbar;
 }
 
 void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
 {
 	SGUIIcon icon;
 	CStr name;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
 			continue;
 
 		if (attr_name == "name")
 			name = attr_value;
 		else if (attr_name == "sprite")
 			icon.m_SpriteName = attr_value;
 		else if (attr_name == "size")
 		{
 			CSize size;
 			if (!GUI<CSize>::ParseString(attr_value.FromUTF8(), size))
 				LOGERROR("Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_Size = size;
 		}
 		else if (attr_name == "cell_id")
 		{
 			int cell_id;
 			if (!GUI<int>::ParseString(attr_value.FromUTF8(), cell_id))
 				LOGERROR("GUI: Error parsing '%s' (\"%s\") inside <icon>.", attr_name, attr_value);
 			else
 				icon.m_CellID = cell_id;
 		}
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 
 	m_Icons[name] = icon;
 }
 
 void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
 {
 	IGUIObject* object = new CTooltip;
 
 	for (XMBAttribute attr : Element.GetAttributes())
 	{
 		CStr attr_name(pFile->GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_name == "name")
 			object->SetName("__tooltip_" + attr_value);
 		else
 			object->SetSetting(attr_name, attr_value.FromUTF8());
 	}
 
 	AddObject(object);
 }
 
 void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
 {
 	XMBAttributeList attributes = Element.GetAttributes();
 
 	CColor color;
 	CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
 
 	// Try parsing value
 	CStr value(Element.GetText());
 	if (value.empty())
 		return;
 
 	// Try setting color to value
 	if (!color.ParseString(value))
 	{
 		LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str());
 		return;
 	}
 
 	m_PreDefinedColors[name] = color;
 }
Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 22514)
+++ ps/trunk/source/gui/CGUI.h	(revision 22515)
@@ -1,639 +1,647 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * This is the top class of the whole GUI, all objects
  * and settings are stored within this class.
  */
 
 #ifndef INCLUDED_CGUI
 #define INCLUDED_CGUI
 
 #include "GUITooltip.h"
 #include "GUIbase.h"
 
 #include "lib/input.h"
 #include "ps/Shapes.h"
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <boost/unordered_set.hpp>
 
 ERROR_TYPE(GUI, JSOpenFailed);
 
 extern const double SELECT_DBLCLICK_RATE;
 
 /**
  * Contains a list of values for new defaults to objects.
  */
 struct SGUIStyle
 {
 	std::map<CStr, CStrW> m_SettingsDefaults;
 };
 
 class JSObject; // The GUI stores a JSObject*, so needs to know that JSObject exists
 class IGUIObject;
 class CGUISpriteInstance;
 struct SGUIText;
 struct CColor;
 struct SGUIText;
 struct SGUIIcon;
 class CGUIString;
 class CGUISprite;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
 class GUITooltip;
 
 /**
  * The main object that represents a whole GUI page.
  *
  * No interfacial functions throws.
  */
 class CGUI
 {
 	NONCOPYABLE(CGUI);
 
 	friend class IGUIObject;
 	friend class CInternalCGUIAccessorBase;
 
 private:
 	// Private typedefs
 	typedef IGUIObject *(*ConstructObjectFunction)();
 
 public:
 	CGUI(const shared_ptr<ScriptRuntime>& runtime);
 	~CGUI();
 
 	/**
 	 * Initializes the GUI, needs to be called before the GUI is used
 	 */
 	void Initialize();
 
 	/**
 	 * Performs processing that should happen every frame
 	 * (including sending the "Tick" event to scripts)
 	 */
 	void TickObjects();
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param EventName String representation of event name
 	 */
 	void SendEventToAll(const CStr& EventName);
 
 	/**
+	 * Sends a specified script event to every object
+	 *
+	 * @param EventName String representation of event name
+	 * @param paramData JS::HandleValueArray storing the arguments passed to the event handler.
+	 */
+	void SendEventToAll(const CStr& EventName, JS::HandleValueArray paramData);
+
+	/**
 	 * Displays the whole GUI
 	 */
 	void Draw();
 
 	/**
 	 * Draw GUI Sprite
 	 *
 	 * @param Sprite Object referring to the sprite (which also caches
 	 *        calculations for faster rendering)
 	 * @param CellID Number of the icon cell to use. (Ignored if this sprite doesn't
 	 *        have any images with "cell-size")
 	 * @param Z Drawing order, depth value
 	 * @param Rect Position and Size
 	 * @param Clipping The sprite shouldn't be drawn outside this rectangle
 	 */
 	void DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float& Z, const CRect& Rect, const CRect& Clipping = CRect());
 
 	/**
 	 * Draw a SGUIText object
 	 *
 	 * @param Text Text object.
 	 * @param DefaultColor Color used if no tag applied.
 	 * @param pos position
 	 * @param z z value.
 	 * @param clipping
 	 */
 	void DrawText(SGUIText& Text, const CColor& DefaultColor, const CPos& pos, const float& z, const CRect& clipping);
 
 	/**
 	 * Clean up, call this to clean up all memory allocated
 	 * within the GUI.
 	 */
 	void Destroy();
 
 	/**
 	 * The replacement of Process(), handles an SDL_Event_
 	 *
 	 * @param ev SDL Event, like mouse/keyboard input
 	 */
 	InReaction HandleEvent(const SDL_Event_* ev);
 
 	/**
 	 * Load a GUI XML file into the GUI.
 	 *
 	 * <b>VERY IMPORTANT!</b> All \<styles\>-files must be read before
 	 * everything else!
 	 *
 	 * @param Filename Name of file
 	 * @param Paths Set of paths; all XML and JS files loaded will be added to this
 	 */
 	void LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Checks if object exists and return true or false accordingly
 	 *
 	 * @param Name String name of object
 	 * @return true if object exists
 	 */
 	bool ObjectExists(const CStr& Name) const;
 
 
 	/**
 	 * Returns the GUI object with the desired name, or NULL
 	 * if no match is found,
 	 *
 	 * @param Name String name of object
 	 * @return Matching object, or NULL
 	 */
 	IGUIObject* FindObjectByName(const CStr& Name) const;
 
 	/**
 	 * Returns the GUI object under the mouse, or NULL if none.
 	 */
 	IGUIObject* FindObjectUnderMouse() const;
 
 	const SGUIScrollBarStyle* GetScrollBarStyle(const CStr& style) const;
 
 	/**
 	 * The GUI needs to have all object types inputted and
 	 * their constructors. Also it needs to associate a type
 	 * by a string name of the type.
 	 *
 	 * To add a type:
 	 * @code
 	 * AddObjectType("button", &CButton::ConstructObject);
 	 * @endcode
 	 *
 	 * @param str Reference name of object type
 	 * @param pFunc Pointer of function ConstuctObject() in the object
 	 *
 	 * @see CGUI#ConstructObject()
 	 */
 	void AddObjectType(const CStr& str, ConstructObjectFunction pFunc) { m_ObjectTypes[str] = pFunc; }
 
 	/**
 	 * Update Resolution, should be called every time the resolution
 	 * of the OpenGL screen has been changed, this is because it needs
 	 * to re-cache all its actual sizes
 	 *
 	 * Needs no input since screen resolution is global.
 	 *
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	void UpdateResolution();
 
 	/**
 	 * Generate a SGUIText object from the inputted string.
 	 * The function will break down the string and its
 	 * tags to calculate exactly which rendering queries
 	 * will be sent to the Renderer. Also, horizontal alignment
 	 * is taken into acount in this method but NOT vertical alignment.
 	 *
 	 * Done through the CGUI since it can communicate with
 	 *
 	 * @param Text Text to generate SGUIText object from
 	 * @param Font Default font, notice both Default color and default font
 	 *		  can be changed by tags.
 	 * @param Width Width, 0 if no word-wrapping.
 	 * @param BufferZone space between text and edge, and space between text and images.
 	 * @param pObject Optional parameter for error output. Used *only* if error parsing fails,
 	 *		  and we need to be able to output which object the error occurred in to aid the user.
 	 */
 	SGUIText GenerateText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone, const IGUIObject* pObject = NULL);
 
 
 	/**
 	 * Check if an icon exists
 	 */
 	bool IconExists(const CStr& str) const { return (m_Icons.count(str) != 0); }
 
 	/**
 	 * Get Icon (a copy, can never be changed)
 	 */
 	SGUIIcon GetIcon(const CStr& str) const { return m_Icons.find(str)->second; }
 
 	/**
 	 * Get pre-defined color (if it exists)
 	 * Returns false if it fails.
 	 */
 	bool GetPreDefinedColor(const CStr& name, CColor& Output) const;
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 	JS::Value GetGlobalObject() { return m_ScriptInterface->GetGlobalObject(); };
 
 private:
 
 	/**
 	 * Updates the object pointers, needs to be called each
 	 * time an object has been added or removed.
 	 *
 	 * This function is atomic, meaning if it throws anything, it will
 	 * have seen it through that nothing was ultimately changed.
 	 *
 	 * @throws PSERROR_GUI that is thrown from IGUIObject::AddToPointersMap().
 	 */
 	void UpdateObjects();
 
 	/**
 	 * Adds an object to the GUI's object database
 	 * Private, since you can only add objects through
 	 * XML files. Why? Because it enables the GUI to
 	 * be much more encapsulated and safe.
 	 *
 	 * @throws	Rethrows PSERROR_GUI from IGUIObject::AddChild().
 	 */
 	void AddObject(IGUIObject* pObject);
 
 	/**
 	 * You input the name of the object type, and let's
 	 * say you input "button", then it will construct a
 	 * CGUIObjet* as a CButton.
 	 *
 	 * @param str Name of object type
 	 * @return Newly constructed IGUIObject (but constructed as a subclass)
 	 */
 	IGUIObject* ConstructObject(const CStr& str);
 
 	/**
 	 * Get Focused Object.
 	 */
 	IGUIObject* GetFocusedObject() { return m_FocusedObject; }
 
 public:
 	/**
 	 * Change focus to new object.
 	 * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 	 * pObject can be NULL to remove all focus.
 	 */
 	void SetFocusedObject(IGUIObject* pObject);
 
 private:
 	//--------------------------------------------------------
 	/** @name XML Reading Xeromyces specific subroutines
 	 *
 	 * These does not throw!
 	 * Because when reading in XML files, it won't be fatal
 	 * if an error occurs, perhaps one particular object
 	 * fails, but it'll still continue reading in the next.
 	 * All Error are reported with ReportParseError
 	 */
 	//--------------------------------------------------------
 
 	/*
 		Xeromyces_* functions tree
 		<objects> (ReadRootObjects)
 		 |
 		 +-<script> (ReadScript)
 		 |
 		 +-<object> (ReadObject)
 			|
 			+-<action>
 			|
 			+-Optional Type Extensions (IGUIObject::ReadExtendedElement) TODO
 			|
 			+-<<object>> *recursive*
 
 
 		<styles> (ReadRootStyles)
 		 |
 		 +-<style> (ReadStyle)
 
 
 		<sprites> (ReadRootSprites)
 		 |
 		 +-<sprite> (ReadSprite)
 			|
 			+-<image> (ReadImage)
 
 
 		<setup> (ReadRootSetup)
 		 |
 		 +-<tooltip> (ReadToolTip)
 		 |
 		 +-<scrollbar> (ReadScrollBar)
 		 |
 		 +-<icon> (ReadIcon)
 		 |
 		 +-<color> (ReadColor)
 	*/
 	//@{
 
 	// Read Roots
 
 	/**
 	 * Reads in the root element \<objects\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the objects-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Collects the set of all XML/JS files that are loaded
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the root element \<sprites\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprites-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<styles\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the styles-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<setup\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the setup-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile);
 
 	// Read Subs
 
 	/**
 	 * Notice! Recursive function!
 	 *
 	 * Read in an \<object\> (the XMBElement) and stores it
 	 * as a child in the pParent.
 	 *
 	 * It will also check the object's children and call this function
 	 * on them too. Also it will call all other functions that reads
 	 * in other stuff that can be found within an object. Check the
 	 * tree in the beginning of this class' Xeromyces_* section.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the object-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param pParent	Parent to add this object as child in.
 	 * @param NameSubst	A set of substitution strings that will be
 	 * 					applied to all object names within this object.
 	 * @param Paths		Output set of file paths that this GUI object
 	 * 					relies on.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
 	 * 'count' times, replacing the string "[n]" (or the value of the attribute
 	 * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 	 * "[1]", etc.
 	 */
 	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<script\> (the XMBElement) and executes
 	 * the script's code.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the script-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Output set of file paths that this script is loaded from.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<sprite\> (the XMBElement) and stores the
 	 * result in a new CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprite-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<image\> (the XMBElement) and stores the
 	 * result within the CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param parent	Parent sprite.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent);
 
 	/**
 	 * Reads in the element \<effect\> (the XMBElement) and stores the
 	 * result within the SGUIImageEffects.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param effects	Effects object to add this effect to.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects);
 
 	/**
 	 * Reads in the element \<style\> (the XMBElement) and stores the
 	 * result in m_Styles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the style-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<scrollbar\> (the XMBElement) and stores the
 	 * result in m_ScrollBarStyles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<icon\> (the XMBElement) and stores the
 	 * result in m_Icons.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<tooltip\> (the XMBElement) and stores the
 	 * result as an object with the name __tooltip_#.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<color\> (the XMBElement) and stores the
 	 * result in m_PreDefinedColors
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile);
 
 	//@}
 
 private:
 
 	// Variables
 
 	//--------------------------------------------------------
 	/** @name Miscellaneous */
 	//--------------------------------------------------------
 	//@{
 
 	shared_ptr<ScriptInterface> m_ScriptInterface;
 
 	/**
 	 * don't want to pass this around with the
 	 * ChooseMouseOverAndClosest broadcast -
 	 * we'd need to pack this and pNearest in a struct
 	 */
 	CPos m_MousePos;
 
 	/**
 	 * Indicates which buttons are pressed (bit 0 = LMB,
 	 * bit 1 = RMB, bit 2 = MMB)
 	 */
 	unsigned int m_MouseButtons;
 
 	// Tooltip
 	GUITooltip m_Tooltip;
 
 	/**
 	 * This is a bank of custom colors, it is simply a look up table that
 	 * will return a color object when someone inputs the name of that
 	 * color. Of course the colors have to be declared in XML, there are
 	 * no hard-coded values.
 	 */
 	std::map<CStr, CColor>	m_PreDefinedColors;
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Objects */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Base Object, all its children are considered parentless
 	 * because this is not a real object per se.
 	 */
 	IGUIObject* m_BaseObject;
 
 	/**
 	 * Focused object!
 	 * Say an input box that is selected. That one is focused.
 	 * There can only be one focused object.
 	 */
 	IGUIObject* m_FocusedObject;
 
 	/**
 	 * Just pointers for fast name access, each object
 	 * is really constructed within its parent for easy
 	 * recursive management.
 	 * Notice m_BaseObject won't belong here since it's
 	 * not considered a real object.
 	 */
 	map_pObjects m_pAllObjects;
 
 	/**
 	 * Number of object that has been given name automatically.
 	 * the name given will be '__internal(#)', the number (#)
 	 * being this variable. When an object's name has been set
 	 * as followed, the value will increment.
 	 */
 	int m_InternalNameNumber;
 
 	/**
 	 * Function pointers to functions that constructs
 	 * IGUIObjects by name... For instance m_ObjectTypes["button"]
 	 * is filled with a function that will "return new CButton();"
 	 */
 	std::map<CStr, ConstructObjectFunction>	m_ObjectTypes;
 
 	/**
 	 * Map from hotkey names to objects that listen to the hotkey.
 	 * (This is an optimisation to avoid recursing over the whole GUI
 	 * tree every time a hotkey is pressed).
 	 * Currently this is only set at load time - dynamic changes to an
 	 * object's hotkey property will be ignored.
 	 */
 	std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 
 	//--------------------------------------------------------
 	//	Databases
 	//--------------------------------------------------------
 
 	// Sprites
 	std::map<CStr, CGUISprite*> m_Sprites;
 
 	// Styles
 	std::map<CStr, SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, SGUIIcon> m_Icons;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/gui/GUIManager.cpp
===================================================================
--- ps/trunk/source/gui/GUIManager.cpp	(revision 22514)
+++ ps/trunk/source/gui/GUIManager.cpp	(revision 22515)
@@ -1,416 +1,421 @@
-/* Copyright (C) 2018 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "GUIManager.h"
 
 #include "CGUI.h"
 
 #include "lib/timer.h"
 #include "ps/Filesystem.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "ps/XML/Xeromyces.h"
 #include "ps/GameSetup/Config.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptRuntime.h"
 
 CGUIManager* g_GUI = NULL;
 
 
 // General TODOs:
 //
 // A lot of the CGUI data could (and should) be shared between
 // multiple pages, instead of treating them as completely independent, to save
 // memory and loading time.
 
 
 // called from main loop when (input) events are received.
 // event is passed to other handlers if false is returned.
 // trampoline: we don't want to make the HandleEvent implementation static
 InReaction gui_handler(const SDL_Event_* ev)
 {
 	PROFILE("GUI event handler");
 	return g_GUI->HandleEvent(ev);
 }
 
 static Status ReloadChangedFileCB(void* param, const VfsPath& path)
 {
 	return static_cast<CGUIManager*>(param)->ReloadChangedFile(path);
 }
 
 CGUIManager::CGUIManager()
 {
 	m_ScriptRuntime = g_ScriptRuntime;
 	m_ScriptInterface.reset(new ScriptInterface("Engine", "GUIManager", m_ScriptRuntime));
 	m_ScriptInterface->SetCallbackData(this);
 	m_ScriptInterface->LoadGlobalScripts();
 
 	if (!CXeromyces::AddValidator(g_VFS, "gui_page", "gui/gui_page.rng"))
 		LOGERROR("CGUIManager: failed to load GUI page grammar file 'gui/gui_page.rng'");
 	if (!CXeromyces::AddValidator(g_VFS, "gui", "gui/gui.rng"))
 		LOGERROR("CGUIManager: failed to load GUI XML grammar file 'gui/gui.rng'");
 
 	RegisterFileReloadFunc(ReloadChangedFileCB, this);
 }
 
 CGUIManager::~CGUIManager()
 {
 	UnregisterFileReloadFunc(ReloadChangedFileCB, this);
 }
 
 bool CGUIManager::HasPages()
 {
 	return !m_PageStack.empty();
 }
 
 void CGUIManager::SwitchPage(const CStrW& pageName, ScriptInterface* srcScriptInterface, JS::HandleValue initData)
 {
 	// The page stack is cleared (including the script context where initData came from),
 	// therefore we have to clone initData.
 	shared_ptr<ScriptInterface::StructuredClone> initDataClone;
 	if (!initData.isUndefined())
 	{
 		initDataClone = srcScriptInterface->WriteStructuredClone(initData);
 	}
 	m_PageStack.clear();
 	PushPage(pageName, initDataClone);
 }
 
 void CGUIManager::PushPage(const CStrW& pageName, shared_ptr<ScriptInterface::StructuredClone> initData)
 {
 	m_PageStack.push_back(SGUIPage());
 	m_PageStack.back().name = pageName;
 	m_PageStack.back().initData = initData;
 	LoadPage(m_PageStack.back());
 
 	ResetCursor();
 }
 
 void CGUIManager::PopPage()
 {
 	if (m_PageStack.size() < 2)
 	{
 		debug_warn(L"Tried to pop GUI page when there's < 2 in the stack");
 		return;
 	}
 
 	m_PageStack.pop_back();
 }
 
 void CGUIManager::PopPageCB(shared_ptr<ScriptInterface::StructuredClone> args)
 {
 	shared_ptr<ScriptInterface::StructuredClone> initDataClone = m_PageStack.back().initData;
 	PopPage();
 
 	shared_ptr<ScriptInterface> scriptInterface = m_PageStack.back().gui->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue initDataVal(cx);
 	if (!initDataClone)
 	{
 		LOGERROR("Called PopPageCB when initData (which should contain the callback function name) isn't set!");
 		return;
 	}
 
 	scriptInterface->ReadStructuredClone(initDataClone, &initDataVal);
 
 	if (!scriptInterface->HasProperty(initDataVal, "callback"))
 	{
 		LOGERROR("Called PopPageCB when the callback function name isn't set!");
 		return;
 	}
 
 	std::string callback;
 	if (!scriptInterface->GetProperty(initDataVal, "callback", callback))
 	{
 		LOGERROR("Failed to get the callback property as a string from initData in PopPageCB!");
 		return;
 	}
 
 	JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
 	if (!scriptInterface->HasProperty(global, callback.c_str()))
 	{
 		LOGERROR("The specified callback function %s does not exist in the page %s", callback, utf8_from_wstring(m_PageStack.back().name));
 		return;
 	}
 
 	JS::RootedValue argVal(cx);
 	if (args)
 		scriptInterface->ReadStructuredClone(args, &argVal);
 	if (!scriptInterface->CallFunctionVoid(global, callback.c_str(), argVal))
 	{
 		LOGERROR("Failed to call the callback function %s in the page %s", callback, utf8_from_wstring(m_PageStack.back().name));
 		return;
 	}
 }
 
 void CGUIManager::LoadPage(SGUIPage& page)
 {
 	// If we're hotloading then try to grab some data from the previous page
 	shared_ptr<ScriptInterface::StructuredClone> hotloadData;
 	if (page.gui)
 	{
 		shared_ptr<ScriptInterface> scriptInterface = page.gui->GetScriptInterface();
 		JSContext* cx = scriptInterface->GetContext();
 		JSAutoRequest rq(cx);
 
 		JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
 		JS::RootedValue hotloadDataVal(cx);
 		scriptInterface->CallFunction(global, "getHotloadData", &hotloadDataVal);
 		hotloadData = scriptInterface->WriteStructuredClone(hotloadDataVal);
 	}
 
 	page.inputs.clear();
 	page.gui.reset(new CGUI(m_ScriptRuntime));
 
 	page.gui->Initialize();
 
 	VfsPath path = VfsPath("gui") / page.name;
 	page.inputs.insert(path);
 
 	CXeromyces xero;
 	if (xero.Load(g_VFS, path, "gui_page") != PSRETURN_OK)
 		// Fail silently (Xeromyces reported the error)
 		return;
 
 	int elmt_page = xero.GetElementID("page");
 	int elmt_include = xero.GetElementID("include");
 
 	XMBElement root = xero.GetRoot();
 
 	if (root.GetNodeName() != elmt_page)
 	{
 		LOGERROR("GUI page '%s' must have root element <page>", utf8_from_wstring(page.name));
 		return;
 	}
 
 	XERO_ITER_EL(root, node)
 	{
 		if (node.GetNodeName() != elmt_include)
 		{
 			LOGERROR("GUI page '%s' must only have <include> elements inside <page>", utf8_from_wstring(page.name));
 			continue;
 		}
 
 		std::string name = node.GetText();
 		CStrW nameW (node.GetText().FromUTF8());
 
 		PROFILE2("load gui xml");
 		PROFILE2_ATTR("name: %s", name.c_str());
 
 		TIMER(nameW.c_str());
 		if (name.back() == '/')
 		{
 			VfsPath directory = VfsPath("gui") / nameW;
 			VfsPaths pathnames;
 			vfs::GetPathnames(g_VFS, directory, L"*.xml", pathnames);
 			for (const VfsPath& path : pathnames)
 				page.gui->LoadXmlFile(path, page.inputs);
 		}
 		else
 		{
 			VfsPath path = VfsPath("gui") / nameW;
 			page.gui->LoadXmlFile(path, page.inputs);
 		}
 	}
 
 	page.gui->SendEventToAll("load");
 
 	shared_ptr<ScriptInterface> scriptInterface = page.gui->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue initDataVal(cx);
 	JS::RootedValue hotloadDataVal(cx);
 	JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
 
 	if (page.initData)
 		scriptInterface->ReadStructuredClone(page.initData, &initDataVal);
 
 	if (hotloadData)
 		scriptInterface->ReadStructuredClone(hotloadData, &hotloadDataVal);
 
 	if (scriptInterface->HasProperty(global, "init") &&
 	    !scriptInterface->CallFunctionVoid(global, "init", initDataVal, hotloadDataVal))
 		LOGERROR("GUI page '%s': Failed to call init() function", utf8_from_wstring(page.name));
 }
 
 Status CGUIManager::ReloadChangedFile(const VfsPath& path)
 {
 	for (SGUIPage& p : m_PageStack)
 		if (p.inputs.count(path))
 		{
 			LOGMESSAGE("GUI file '%s' changed - reloading page '%s'", path.string8(), utf8_from_wstring(p.name));
 			LoadPage(p);
 			// TODO: this can crash if LoadPage runs an init script which modifies the page stack and breaks our iterators
 		}
 
 	return INFO::OK;
 }
 
 Status CGUIManager::ReloadAllPages()
 {
 	// TODO: this can crash if LoadPage runs an init script which modifies the page stack and breaks our iterators
 	for (SGUIPage& p : m_PageStack)
 		LoadPage(p);
 
 	return INFO::OK;
 }
 
 void CGUIManager::ResetCursor()
 {
 	g_CursorName = g_DefaultCursor;
 }
 
 std::string CGUIManager::GetSavedGameData()
 {
 	shared_ptr<ScriptInterface> scriptInterface = top()->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue data(cx);
 	JS::RootedValue global(cx, top()->GetGlobalObject());
 	scriptInterface->CallFunction(global, "getSavedGameData", &data);
 	return scriptInterface->StringifyJSON(&data, false);
 }
 
 void CGUIManager::RestoreSavedGameData(const std::string& jsonData)
 {
 	shared_ptr<ScriptInterface> scriptInterface = top()->GetScriptInterface();
 	JSContext* cx = scriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue global(cx, top()->GetGlobalObject());
 	JS::RootedValue dataVal(cx);
 	scriptInterface->ParseJSON(jsonData, &dataVal);
 	scriptInterface->CallFunctionVoid(global, "restoreSavedGameData", dataVal);
 }
 
 InReaction CGUIManager::HandleEvent(const SDL_Event_* ev)
 {
 	// We want scripts to have access to the raw input events, so they can do complex
 	// processing when necessary (e.g. for unit selection and camera movement).
 	// Sometimes they'll want to be layered behind the GUI widgets (e.g. to detect mousedowns on the
 	// visible game area), sometimes they'll want to intercepts events before the GUI (e.g.
 	// to capture all mouse events until a mouseup after dragging).
 	// So we call two separate handler functions:
 
 	bool handled;
 
 	{
 		PROFILE("handleInputBeforeGui");
 		JSContext* cx = top()->GetScriptInterface()->GetContext();
 		JSAutoRequest rq(cx);
 		JS::RootedValue global(cx, top()->GetGlobalObject());
 		if (top()->GetScriptInterface()->CallFunction(global, "handleInputBeforeGui", handled, *ev, top()->FindObjectUnderMouse()))
 			if (handled)
 				return IN_HANDLED;
 	}
 
 	{
 		PROFILE("handle event in native GUI");
 		InReaction r = top()->HandleEvent(ev);
 		if (r != IN_PASS)
 			return r;
 	}
 
 	{
 		// We can't take the following lines out of this scope because top() may be another gui page than it was when calling handleInputBeforeGui!
 		JSContext* cx = top()->GetScriptInterface()->GetContext();
 		JSAutoRequest rq(cx);
 		JS::RootedValue global(cx, top()->GetGlobalObject());
 
 		PROFILE("handleInputAfterGui");
 		if (top()->GetScriptInterface()->CallFunction(global, "handleInputAfterGui", handled, *ev))
 			if (handled)
 				return IN_HANDLED;
 	}
 
 	return IN_PASS;
 }
 
 
 bool CGUIManager::GetPreDefinedColor(const CStr& name, CColor& output) const
 {
 	return top()->GetPreDefinedColor(name, output);
 }
 
 void CGUIManager::SendEventToAll(const CStr& eventName) const
 {
 	top()->SendEventToAll(eventName);
 }
 
+void CGUIManager::SendEventToAll(const CStr& eventName, JS::HandleValueArray paramData) const
+{
+	top()->SendEventToAll(eventName, paramData);
+}
+
 void CGUIManager::TickObjects()
 {
 	PROFILE3("gui tick");
 
 	// We share the script runtime with everything else that runs in the same thread.
 	// This call makes sure we trigger GC regularly even if the simulation is not running.
 	m_ScriptInterface->GetRuntime()->MaybeIncrementalGC(1.0f);
 
 	// Save an immutable copy so iterators aren't invalidated by tick handlers
 	PageStackType pageStack = m_PageStack;
 
 	for (const SGUIPage& p : pageStack)
 		p.gui->TickObjects();
 }
 
 void CGUIManager::Draw()
 {
 	PROFILE3_GPU("gui");
 
 	for (const SGUIPage& p : m_PageStack)
 		p.gui->Draw();
 }
 
 void CGUIManager::UpdateResolution()
 {
 	// Save an immutable copy so iterators aren't invalidated by event handlers
 	PageStackType pageStack = m_PageStack;
 
 	for (const SGUIPage& p : pageStack)
 	{
 		p.gui->UpdateResolution();
 		p.gui->SendEventToAll("WindowResized");
 	}
 }
 
 bool CGUIManager::TemplateExists(const std::string& templateName) const
 {
 	return m_TemplateLoader.TemplateExists(templateName);
 }
 
 const CParamNode& CGUIManager::GetTemplate(const std::string& templateName)
 {
 	const CParamNode& templateRoot = m_TemplateLoader.GetTemplateFileData(templateName).GetChild("Entity");
 	if (!templateRoot.IsOk())
 		LOGERROR("Invalid template found for '%s'", templateName.c_str());
 
 	return templateRoot;
 }
 
 // This returns a shared_ptr to make sure the CGUI doesn't get deallocated
 // while we're in the middle of calling a function on it (e.g. if a GUI script
 // calls SwitchPage)
 shared_ptr<CGUI> CGUIManager::top() const
 {
 	ENSURE(m_PageStack.size());
 	return m_PageStack.back().gui;
 }
Index: ps/trunk/source/gui/GUIManager.h
===================================================================
--- ps/trunk/source/gui/GUIManager.h	(revision 22514)
+++ ps/trunk/source/gui/GUIManager.h	(revision 22515)
@@ -1,177 +1,178 @@
-/* Copyright (C) 2018 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_GUIMANAGER
 #define INCLUDED_GUIMANAGER
 
 #include <boost/unordered_set.hpp>
 #include <set>
 
 #include "lib/input.h"
 #include "lib/file/vfs/vfs_path.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/TemplateLoader.h"
 #include "scriptinterface/ScriptVal.h"
 #include "scriptinterface/ScriptInterface.h"
 
 class CGUI;
 class JSObject;
 class IGUIObject;
 struct CColor;
 struct SGUIIcon;
 
 /**
  * External interface to the GUI system.
  *
  * The GUI consists of a set of pages. Each page is constructed from a
  * series of XML files, and is independent from any other page.
  * Only one page is active at a time. All events and render requests etc
  * will go to the active page. This lets the GUI switch between pre-game menu
  * and in-game UI.
  */
 class CGUIManager
 {
 	NONCOPYABLE(CGUIManager);
 public:
 	CGUIManager();
 	~CGUIManager();
 
 	shared_ptr<ScriptInterface> GetScriptInterface()
 	{
 		return m_ScriptInterface;
 	}
 	shared_ptr<ScriptRuntime> GetRuntime() { return m_ScriptRuntime; }
 	shared_ptr<CGUI> GetActiveGUI() { return top(); }
 
 	/**
 	 * Returns whether there are any current pages.
 	 */
 	bool HasPages();
 
 	/**
 	 * Load a new GUI page and make it active. All current pages will be destroyed.
 	 */
 	void SwitchPage(const CStrW& name, ScriptInterface* srcScriptInterface, JS::HandleValue initData);
 
 	/**
 	 * Load a new GUI page and make it active. All current pages will be retained,
 	 * and will still be drawn and receive tick events, but will not receive
 	 * user inputs.
 	 */
 	void PushPage(const CStrW& pageName, shared_ptr<ScriptInterface::StructuredClone> initData);
 
 	/**
 	 * Unload the currently active GUI page, and make the previous page active.
 	 * (There must be at least two pages when you call this.)
 	 */
 	void PopPage();
 	void PopPageCB(shared_ptr<ScriptInterface::StructuredClone> args);
 
 	/**
 	 * Called when a file has been modified, to hotload changes.
 	 */
 	Status ReloadChangedFile(const VfsPath& path);
 
 	/**
 	 * Sets the default mouse pointer.
 	 */
 	void ResetCursor();
 
 	/**
 	 * Called when we should reload all pages (e.g. translation hotloading update).
 	 */
 	Status ReloadAllPages();
 
 	/**
 	 * Pass input events to the currently active GUI page.
 	 */
 	InReaction HandleEvent(const SDL_Event_* ev);
 
 	/**
 	 * See CGUI::GetPreDefinedColor; applies to the currently active page.
 	 */
 	bool GetPreDefinedColor(const CStr& name, CColor& output) const;
 
 	/**
 	 * See CGUI::SendEventToAll; applies to the currently active page.
 	 */
 	void SendEventToAll(const CStr& eventName) const;
+	void SendEventToAll(const CStr& eventName, JS::HandleValueArray paramData) const;
 
 	/**
 	 * See CGUI::TickObjects; applies to @em all loaded pages.
 	 */
 	void TickObjects();
 
 	/**
 	 * See CGUI::Draw; applies to @em all loaded pages.
 	 */
 	void Draw();
 
 	/**
 	 * See CGUI::UpdateResolution; applies to @em all loaded pages.
 	 */
 	void UpdateResolution();
 
  	/**
  	 * Calls the current page's script function getSavedGameData() and returns the result.
  	 */
 	std::string GetSavedGameData();
 
 	void RestoreSavedGameData(const std::string& jsonData);
 
 	/**
 	 * Check if a template with this name exists
 	 */
 	bool TemplateExists(const std::string& templateName) const;
 
 	/**
 	 * Retrieve the requested template, used for displaying faction specificities.
 	 */
 	const CParamNode& GetTemplate(const std::string& templateName);
 
 private:
 	struct SGUIPage
 	{
 		CStrW name;
 		boost::unordered_set<VfsPath> inputs; // for hotloading
 
 		JSContext* cx;
 		shared_ptr<ScriptInterface::StructuredClone> initData; // data to be passed to the init() function
 		CStrW callbackPageName;
 
 		shared_ptr<CGUI> gui; // the actual GUI page
 	};
 
 	void LoadPage(SGUIPage& page);
 
 	shared_ptr<CGUI> top() const;
 
 	shared_ptr<ScriptRuntime> m_ScriptRuntime;
 	shared_ptr<ScriptInterface> m_ScriptInterface;
 
 	typedef std::vector<SGUIPage> PageStackType;
 	PageStackType m_PageStack;
 
 	CTemplateLoader m_TemplateLoader;
 };
 
 extern CGUIManager* g_GUI;
 
 extern InReaction gui_handler(const SDL_Event_* ev);
 
 #endif // INCLUDED_GUIMANAGER
Index: ps/trunk/source/gui/GUIutil.h
===================================================================
--- ps/trunk/source/gui/GUIutil.h	(revision 22514)
+++ ps/trunk/source/gui/GUIutil.h	(revision 22515)
@@ -1,348 +1,361 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
 GUI util
 
 --Overview--
 
 	Contains help class GUI<>, which gives us templated
 	 parameter to all functions within GUI.
 
 --More info--
 
 	Check GUI.h
 
 */
 
 #ifndef INCLUDED_GUIUTIL
 #define INCLUDED_GUIUTIL
 
 #include "CGUI.h"
 #include "CGUISprite.h"
 #include "GUIbase.h"
 #include "IGUIObject.h"
 
 class CClientArea;
 class CGUIString;
 class CMatrix3D;
 
 template <typename T>
 bool __ParseString(const CStrW& Value, T& tOutput);
 
 // Model-view-projection matrix with (0,0) in top-left of screen
 CMatrix3D GetDefaultGuiMatrix();
 
 struct SGUIMessage;
 
 /**
  * Base class to only the class GUI. This superclass is
  * kind of a templateless extention of the class GUI.
  * Used for other functions to friend with, because it
  * can't friend with GUI since it's templated (at least
  * not on all compilers we're using).
  */
 class CInternalCGUIAccessorBase
 {
 protected:
 	/// Get object pointer
 	static IGUIObject* GetObjectPointer(CGUI& GUIinstance, const CStr& Object);
 
 	/// const version
 	static const IGUIObject* GetObjectPointer(const CGUI& GUIinstance, const CStr& Object);
 
 	/// Wrapper for ResetStates
 	static void QueryResetting(IGUIObject* pObject);
 
 	static void HandleMessage(IGUIObject* pObject, SGUIMessage& message);
 };
 
 
 #ifndef NDEBUG
 // Used to ensure type-safety, sort of
 template<typename T> void CheckType(const IGUIObject* obj, const CStr& setting);
 #endif
 
 
 /**
  * Includes static functions that needs one template
  * argument.
  *
  * int is only to please functions that doesn't even use T
  * and are only within this class because it's convenient
  */
 template <typename T=int>
 class GUI : public CInternalCGUIAccessorBase
 {
 	// Private functions further ahead
 	friend class CGUI;
 	friend class IGUIObject;
 	friend class CInternalCGUIAccessorBase;
 
 public:
 
 	// Like GetSetting (below), but doesn't make a copy of the value
 	// (so it can be modified later)
 	static PSRETURN GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, T*& Value);
 
 	/**
 	 * Retrieves a setting by name from object pointer
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Stores value here, note type T!
 	 */
 	static PSRETURN GetSetting(const IGUIObject* pObject, const CStr& Setting, T& Value);
 
 	/**
 	 * Sets a value by name using a real datatype as input.
 	 *
 	 * This is the official way of setting a setting, no other
 	 *  way should only cautiously be used!
 	 *
 	 * @param pObject Object pointer
 	 * @param Setting Setting by name
 	 * @param Value Sets value to this, note type T!
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 */
 	static PSRETURN SetSetting(IGUIObject* pObject, const CStr& Setting, const T& Value, const bool& SkipMessage = false);
 
 	/**
 	 * Retrieves a setting by settings name and object name
 	 *
 	 * @param GUIinstance GUI Object const ref
 	 * @param Object Object name
 	 * @param Setting Setting by name
 	 * @param Value Stores value here, note type T!
 	 */
 	static PSRETURN GetSetting(const CGUI& GUIinstance, const CStr& Object, const CStr& Setting, T& Value)
 	{
 		if (!GUIinstance.ObjectExists(Object))
 			return PSRETURN_GUI_NullObjectProvided;
 
 		// Retrieve pointer and call sibling function
 		const IGUIObject* pObject = GetObjectPointer(GUIinstance, Object);
 
 		return GetSetting(pObject, Setting, Value);
 	}
 
 	/**
 	 * Sets a value by setting and object name using a real
 	 * datatype as input
 	 *
 	 * This is just a wrapper so that we can type the object name
 	 *  and not input the actual pointer.
 	 *
 	 * @param GUIinstance GUI Object, reference since we'll be changing values
 	 * @param Object Object name
 	 * @param Setting Setting by name
 	 * @param Value Sets value to this, note type T!
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 */
 	static PSRETURN SetSetting(CGUI& GUIinstance, const CStr& Object, const CStr& Setting, const T& Value, const bool& SkipMessage = false)
 	{
 		if (!GUIinstance.ObjectExists(Object))
 			return PSRETURN_GUI_NullObjectProvided;
 
 		// Retrieve pointer and call sibling function
 
 		// Important, we don't want to use this T, we want
 		//  to use the standard T, since that will be the
 		//  one with the friend relationship
 		IGUIObject* pObject = GetObjectPointer(GUIinstance, Object);
 
 		return SetSetting(pObject, Setting, Value, SkipMessage);
 	}
 
 	/**
 	 * This will return the value of the first sprite if it's not null,
 	 * if it is null, it will return the value of the second sprite, if
 	 * that one is null, then null it is.
 	 *
 	 * @param prim Primary sprite that should be used
 	 * @param sec Secondary sprite if Primary should fail
 	 * @return Resulting string
 	 */
 	static const CGUISpriteInstance& FallBackSprite(const CGUISpriteInstance& prim, const CGUISpriteInstance& sec)
 	{
 		return (prim.IsEmpty() ? sec : prim);
 	}
 
 	/**
 	 * Same principle as FallBackSprite
 	 *
 	 * @param prim Primary color that should be used
 	 * @param sec Secondary color if Primary should fail
 	 * @return Resulting color
 	 * @see FallBackSprite
 	 */
 	static CColor FallBackColor(const CColor& prim, const CColor& sec)
 	{
 		// CColor() == null.
 		return ((prim!=CColor())?(prim):(sec));
 	}
 
 	/**
 	 * Sets a value by setting and object name using a real
 	 * datatype as input.
 	 *
 	 * This is just a wrapper for __ParseString() which really
 	 * works the magic.
 	 *
 	 * @param Value The value in string form, like "0 0 100% 100%"
 	 * @param tOutput Parsed value of type T
 	 * @return True at success.
 	 *
 	 * @see __ParseString()
 	 */
 	static bool ParseString(const CStrW& Value, T& tOutput)
 	{
 		return __ParseString<T>(Value, tOutput);
 	}
 
 	static bool ParseColor(const CStrW& Value, CColor& tOutput, int DefaultAlpha);
 
 private:
 
 	// templated typedef of function pointer
 	typedef void (IGUIObject::*void_Object_pFunction_argT)(const T& arg);
 	typedef void (IGUIObject::*void_Object_pFunction_argRefT)(T& arg);
 	typedef void (IGUIObject::*void_Object_pFunction)();
+	typedef void (IGUIObject::*void_Object_pFunction_argTJS)(const T& arg, JS::HandleValueArray paramData);
 
 	/**
 	 * If you want to call a IGUIObject-function
 	 * on not just an object, but also on ALL of their children
 	 * you want to use this recursion system.
 	 * It recurses an object calling a function on itself
 	 * and all children (and so forth).
 	 *
 	 * <b>Restrictions:</b>\n
 	 * You can also set restrictions, so that if the recursion
 	 * reaches an objects with certain setup, it just doesn't
 	 * call the function on the object, nor it's children for
 	 * that matter. i.e. it cuts that object off from the
 	 * recursion tree. What setups that can cause restrictions
 	 * are hardcoded and specific. Check out the defines
 	 * GUIRR_* for all different setups.
 	 *
 	 * Error reports are either logged or thrown out of RecurseObject.
 	 * Always use it with try/catch!
 	 *
 	 * @param RR Recurse Restrictions, set to 0 if no restrictions
 	 * @param pObject Top object, this is where the iteration starts
 	 * @param pFunc Function to recurse
 	 * @param Argument Argument for pFunc of type T
 	 * @throws PSERROR Depends on what pFunc might throw. PSERROR is standard.
 	 *			Itself doesn't throw anything.
 	*/
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argT pFunc, const T& Argument)
 	{
 		// TODO Gee: Don't run this for the base object.
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument);
 	}
 
 	/**
 	 * Argument is reference.
 	 *
 	 * @see RecurseObject()
 	 */
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argRefT pFunc, T& Argument)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)(Argument);
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc, Argument);
 	}
 
+	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction_argTJS pFunc, const T& Argument, JS::HandleValueArray paramData)
+	{
+		if (CheckIfRestricted(RR, pObject))
+			return;
+
+		(pObject->*pFunc)(Argument, paramData);
+
+		// Iterate children
+		for (IGUIObject* const& obj : *pObject)
+			RecurseObject(RR, obj, pFunc, Argument, paramData);
+	}
+
 	/**
 	 * With no argument.
 	 *
 	 * @see RecurseObject()
 	 */
 	static void RecurseObject(int RR, IGUIObject* pObject, void_Object_pFunction pFunc)
 	{
 		if (CheckIfRestricted(RR, pObject))
 			return;
 
 		(pObject->*pFunc)();
 
 		// Iterate children
 		for (IGUIObject* const& obj : *pObject)
 			RecurseObject(RR, obj, pFunc);
 	}
 
 private:
 	/**
 	 * Checks restrictions for the iteration, for instance if
 	 * you tell the recursor to avoid all hidden objects, it
 	 * will, and this function checks a certain object's
 	 * restriction values.
 	 *
 	 * @param RR What kind of restriction, for instance hidden or disabled
 	 * @param pObject Object
 	 * @return true if restricted
 	 */
 	static bool CheckIfRestricted(int RR, IGUIObject* pObject)
 	{
 		// Statically initialise some strings, so we don't have to do
 		// lots of allocation every time this function is called
 		static const CStr strHidden("hidden");
 		static const CStr strEnabled("enabled");
 		static const CStr strGhost("ghost");
 
 		if (RR & GUIRR_HIDDEN)
 		{
 			bool hidden = true;
 			GUI<bool>::GetSetting(pObject, strHidden, hidden);
 
 			if (hidden)
 				return true;
 		}
 		if (RR & GUIRR_DISABLED)
 		{
 			bool enabled = false;
 			GUI<bool>::GetSetting(pObject, strEnabled, enabled);
 
 			if (!enabled)
 				return true;
 		}
 		if (RR & GUIRR_GHOST)
 		{
 			bool ghost = true;
 			GUI<bool>::GetSetting(pObject, strGhost, ghost);
 
 			if (ghost)
 				return true;
 		}
 
 		// false means not restricted
 		return false;
 	}
 };
 
 #endif // INCLUDED_GUIUTIL
Index: ps/trunk/source/gui/IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/IGUIObject.cpp	(revision 22514)
+++ ps/trunk/source/gui/IGUIObject.cpp	(revision 22515)
@@ -1,553 +1,549 @@
-/* Copyright (C) 2016 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "GUI.h"
 
 #include "gui/scripting/JSInterface_GUITypes.h"
 #include "gui/scripting/JSInterface_IGUIObject.h"
 
 #include "ps/GameSetup/Config.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptInterface.h"
 
 
 IGUIObject::IGUIObject()
 	: m_pGUI(NULL), m_pParent(NULL), m_MouseHovering(false), m_LastClickTime()
 {
 	AddSetting(GUIST_bool,			"enabled");
 	AddSetting(GUIST_bool,			"hidden");
 	AddSetting(GUIST_CClientArea,	"size");
 	AddSetting(GUIST_CStr,			"style");
 	AddSetting(GUIST_CStr,			"hotkey");
 	AddSetting(GUIST_float,			"z");
 	AddSetting(GUIST_bool,			"absolute");
 	AddSetting(GUIST_bool,			"ghost");
 	AddSetting(GUIST_float,			"aspectratio");
 	AddSetting(GUIST_CStrW,			"tooltip");
 	AddSetting(GUIST_CStr,			"tooltip_style");
 
 	// Setup important defaults
 	GUI<bool>::SetSetting(this, "hidden", false);
 	GUI<bool>::SetSetting(this, "ghost", false);
 	GUI<bool>::SetSetting(this, "enabled", true);
 	GUI<bool>::SetSetting(this, "absolute", true);
 }
 
 IGUIObject::~IGUIObject()
 {
 	for (const std::pair<CStr, SGUISetting>& p : m_Settings)
 		switch (p.second.m_Type)
 		{
 			// delete() needs to know the type of the variable - never delete a void*
 #define TYPE(t) case GUIST_##t: delete (t*)p.second.m_pSetting; break;
 #include "GUItypes.h"
 #undef TYPE
 		default:
 			debug_warn(L"Invalid setting type");
 		}
 
 	if (m_pGUI)
 		JS_RemoveExtraGCRootsTracer(m_pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 }
 
 //-------------------------------------------------------------------
 //  Functions
 //-------------------------------------------------------------------
 void IGUIObject::SetGUI(CGUI* const& pGUI)
 {
 	if (!m_pGUI)
 		JS_AddExtraGCRootsTracer(pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 	m_pGUI = pGUI;
 }
 
 void IGUIObject::AddChild(IGUIObject* pChild)
 {
 //	ENSURE(pChild);
 
 	pChild->SetParent(this);
 
 	m_Children.push_back(pChild);
 
 	// If this (not the child) object is already attached
 	//  to a CGUI, it pGUI pointer will be non-null.
 	//  This will mean we'll have to check if we're using
 	//  names already used.
 	if (pChild->GetGUI())
 	{
 		try
 		{
 			// Atomic function, if it fails it won't
 			//  have changed anything
 			//UpdateObjects();
 			pChild->GetGUI()->UpdateObjects();
 		}
 		catch (PSERROR_GUI&)
 		{
 			// If anything went wrong, reverse what we did and throw
 			//  an exception telling it never added a child
 			m_Children.erase(m_Children.end()-1);
 
 			throw;
 		}
 	}
 	// else do nothing
 }
 
 void IGUIObject::AddToPointersMap(map_pObjects& ObjectMap)
 {
 	// Just don't do anything about the top node
 	if (m_pParent == NULL)
 		return;
 
 	// Now actually add this one
 	//  notice we won't add it if it's doesn't have any parent
 	//  (i.e. being the base object)
 	if (m_Name.empty())
 	{
 		throw PSERROR_GUI_ObjectNeedsName();
 	}
 	if (ObjectMap.count(m_Name) > 0)
 	{
 		throw PSERROR_GUI_NameAmbiguity(m_Name.c_str());
 	}
 	else
 	{
 		ObjectMap[m_Name] = this;
 	}
 }
 
 void IGUIObject::Destroy()
 {
 	// Is there anything besides the children to destroy?
 }
 
 void IGUIObject::AddSetting(const EGUISettingType& Type, const CStr& Name)
 {
 	// Is name already taken?
 	if (m_Settings.count(Name) >= 1)
 		return;
 
 	// Construct, and set type
 	m_Settings[Name].m_Type = Type;
 
 	switch (Type)
 	{
 #define TYPE(type) \
 	case GUIST_##type: \
 		m_Settings[Name].m_pSetting = new type(); \
 		break;
 
 		// Construct the setting.
 		#include "GUItypes.h"
 
 #undef TYPE
 
 	default:
 		debug_warn(L"IGUIObject::AddSetting failed, type not recognized!");
 		break;
 	}
 }
 
 
 bool IGUIObject::MouseOver()
 {
 	if (!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	return m_CachedActualSize.PointInside(GetMousePos());
 }
 
 bool IGUIObject::MouseOverIcon()
 {
 	return false;
 }
 
 CPos IGUIObject::GetMousePos() const
 {
 	if (GetGUI())
 		return GetGUI()->m_MousePos;
 
 	return CPos();
 }
 
 void IGUIObject::UpdateMouseOver(IGUIObject* const& pMouseOver)
 {
 	if (pMouseOver == this)
 	{
 		if (!m_MouseHovering)
 			SendEvent(GUIM_MOUSE_ENTER, "mouseenter");
 
 		m_MouseHovering = true;
 
 		SendEvent(GUIM_MOUSE_OVER, "mousemove");
 	}
 	else
 	{
 		if (m_MouseHovering)
 		{
 			m_MouseHovering = false;
 			SendEvent(GUIM_MOUSE_LEAVE, "mouseleave");
 		}
 	}
 }
 
 bool IGUIObject::SettingExists(const CStr& Setting) const
 {
 	// Because GetOffsets will direct dynamically defined
 	//  classes with polymorphism to respective ms_SettingsInfo
 	//  we need to make no further updates on this function
 	//  in derived classes.
 	//return (GetSettingsInfo().count(Setting) >= 1);
 	return (m_Settings.count(Setting) >= 1);
 }
 
 PSRETURN IGUIObject::SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage)
 {
 	if (!SettingExists(Setting))
 		return PSRETURN_GUI_InvalidSetting;
 
 	SGUISetting set = m_Settings[Setting];
 
 #define TYPE(type) \
 	else if (set.m_Type == GUIST_##type) \
 	{ \
 		type _Value; \
 		if (!GUI<type>::ParseString(Value, _Value)) \
 			return PSRETURN_GUI_UnableToParse; \
 		GUI<type>::SetSetting(this, Setting, _Value, SkipMessage); \
 	}
 
 	if (0)
 		;
 #include "GUItypes.h"
 #undef TYPE
 	else
 	{
 		// Why does it always fail?
 		//return PS_FAIL;
 		return LogInvalidSettings(Setting);
 	}
 	return PSRETURN_OK;
 }
 
 
 
 PSRETURN IGUIObject::GetSettingType(const CStr& Setting, EGUISettingType& Type) const
 {
 	if (!SettingExists(Setting))
 		return LogInvalidSettings(Setting);
 
 	if (m_Settings.find(Setting) == m_Settings.end())
 		return LogInvalidSettings(Setting);
 
 	Type = m_Settings.find(Setting)->second.m_Type;
 
 	return PSRETURN_OK;
 }
 
 
 void IGUIObject::ChooseMouseOverAndClosest(IGUIObject*& pObject)
 {
 	if (!MouseOver())
 		return;
 
 	// Check if we've got competition at all
 	if (pObject == NULL)
 	{
 		pObject = this;
 		return;
 	}
 
 	// Or if it's closer
 	if (GetBufferedZ() >= pObject->GetBufferedZ())
 	{
 		pObject = this;
 		return;
 	}
 }
 
 IGUIObject* IGUIObject::GetParent() const
 {
 	// Important, we're not using GetParent() for these
 	//  checks, that could screw it up
 	if (m_pParent)
 	{
 		if (m_pParent->m_pParent == NULL)
 			return NULL;
 	}
 
 	return m_pParent;
 }
 
 void IGUIObject::UpdateCachedSize()
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float aspectratio = 0.f;
 	GUI<float>::GetSetting(this, "aspectratio", aspectratio);
 
 	CClientArea ca;
 	GUI<CClientArea>::GetSetting(this, "size", ca);
 
 	// If absolute="false" and the object has got a parent,
 	//  use its cached size instead of the screen. Notice
 	//  it must have just been cached for it to work.
 	if (absolute == false && m_pParent && !IsRootObject())
 		m_CachedActualSize = ca.GetClientArea(m_pParent->m_CachedActualSize);
 	else
 		m_CachedActualSize = ca.GetClientArea(CRect(0.f, 0.f, g_xres / g_GuiScale, g_yres / g_GuiScale));
 
 	// In a few cases, GUI objects have to resize to fill the screen
 	// but maintain a constant aspect ratio.
 	// Adjust the size to be the max possible, centered in the original size:
 	if (aspectratio)
 	{
 		if (m_CachedActualSize.GetWidth() > m_CachedActualSize.GetHeight()*aspectratio)
 		{
 			float delta = m_CachedActualSize.GetWidth() - m_CachedActualSize.GetHeight()*aspectratio;
 			m_CachedActualSize.left += delta/2.f;
 			m_CachedActualSize.right -= delta/2.f;
 		}
 		else
 		{
 			float delta = m_CachedActualSize.GetHeight() - m_CachedActualSize.GetWidth()/aspectratio;
 			m_CachedActualSize.bottom -= delta/2.f;
 			m_CachedActualSize.top += delta/2.f;
 		}
 	}
 }
 
 void IGUIObject::LoadStyle(CGUI& GUIinstance, const CStr& StyleName)
 {
 	// Fetch style
 	if (GUIinstance.m_Styles.count(StyleName) == 1)
 	{
 		LoadStyle(GUIinstance.m_Styles[StyleName]);
 	}
 	else
 	{
 		debug_warn(L"IGUIObject::LoadStyle failed");
 	}
 }
 
 void IGUIObject::LoadStyle(const SGUIStyle& Style)
 {
 	// Iterate settings, it won't be able to set them all probably, but that doesn't matter
 	for (const std::pair<CStr, CStrW>& p : Style.m_SettingsDefaults)
 	{
 		// Try set setting in object
 		SetSetting(p.first, p.second);
 
 		// It doesn't matter if it fail, it's not suppose to be able to set every setting.
 		//  since it's generic.
 
 		// The beauty with styles is that it can contain more settings
 		//  than exists for the objects using it. So if the SetSetting
 		//  fails, don't care.
 	}
 }
 
 float IGUIObject::GetBufferedZ() const
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float Z;
 	GUI<float>::GetSetting(this, "z", Z);
 
 	if (absolute)
 		return Z;
 	else
 	{
 		if (GetParent())
 			return GetParent()->GetBufferedZ() + Z;
 		else
 		{
 			// In philosophy, a parentless object shouldn't be able to have a relative sizing,
 			//  but we'll accept it so that absolute can be used as default without a complaint.
 			//  Also, you could consider those objects children to the screen resolution.
 			return Z;
 		}
 	}
 }
 
 void IGUIObject::RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI)
 {
 	if(!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	JSContext* cx = pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue globalVal(cx, pGUI->GetGlobalObject());
 	JS::RootedObject globalObj(cx, &globalVal.toObject());
 
 	const int paramCount = 1;
 	const char* paramNames[paramCount] = { "mouse" };
 
 	// Location to report errors from
 	CStr CodeName = GetName()+" "+Action;
 
 	// Generate a unique name
 	static int x = 0;
 	char buf[64];
 	sprintf_s(buf, ARRAY_SIZE(buf), "__eventhandler%d (%s)", x++, Action.c_str());
 
 	JS::CompileOptions options(cx);
 	options.setFileAndLine(CodeName.c_str(), 0);
 	options.setCompileAndGo(true);
 
 	JS::RootedFunction func(cx);
 	JS::AutoObjectVector emptyScopeChain(cx);
 	if (!JS::CompileFunction(cx, emptyScopeChain, options, buf, paramCount, paramNames, Code.c_str(), Code.length(), &func))
 	{
 		LOGERROR("RegisterScriptHandler: Failed to compile the script for %s", Action.c_str());
 		return;
 	}
 
 	JS::RootedObject funcObj(cx, JS_GetFunctionObject(func));
 	SetScriptHandler(Action, funcObj);
 }
 
 void IGUIObject::SetScriptHandler(const CStr& Action, JS::HandleObject Function)
 {
 	// m_ScriptHandlers is only rooted after SetGUI() has been called (which sets up the GC trace callbacks),
 	// so we can't safely store objects in it if the GUI hasn't been set yet.
 	ENSURE(m_pGUI && "A GUI must be associated with the GUIObject before adding ScriptHandlers!");
 	m_ScriptHandlers[Action] = JS::Heap<JSObject*>(Function);
 }
 
 InReaction IGUIObject::SendEvent(EGUIMessageType type, const CStr& EventName)
 {
 	PROFILE2_EVENT("gui event");
 	PROFILE2_ATTR("type: %s", EventName.c_str());
 	PROFILE2_ATTR("object: %s", m_Name.c_str());
 
 	SGUIMessage msg(type);
 	HandleMessage(msg);
 
 	ScriptEvent(EventName);
 
 	return (msg.skipped ? IN_PASS : IN_HANDLED);
 }
 
 void IGUIObject::ScriptEvent(const CStr& Action)
 {
-	std::map<CStr, JS::Heap<JSObject*>>::iterator it = m_ScriptHandlers.find(Action);
+	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 
 	// Set up the 'mouse' parameter
 	JS::RootedValue mouse(cx);
 	m_pGUI->GetScriptInterface()->Eval("({})", &mouse);
 	m_pGUI->GetScriptInterface()->SetProperty(mouse, "x", m_pGUI->m_MousePos.x, false);
 	m_pGUI->GetScriptInterface()->SetProperty(mouse, "y", m_pGUI->m_MousePos.y, false);
 	m_pGUI->GetScriptInterface()->SetProperty(mouse, "buttons", m_pGUI->m_MouseButtons, false);
 
 	JS::AutoValueVector paramData(cx);
 	paramData.append(mouse);
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
 	bool ok = JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result);
 	if (!ok)
 	{
 		// We have no way to propagate the script exception, so just ignore it
 		// and hope the caller checks JS_IsExceptionPending
 	}
 }
 
-void IGUIObject::ScriptEvent(const CStr& Action, JS::HandleValue Argument)
+void IGUIObject::ScriptEvent(const CStr& Action, JS::HandleValueArray paramData)
 {
-	std::map<CStr, JS::Heap<JSObject*>>::iterator it = m_ScriptHandlers.find(Action);
+	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
-	JS::AutoValueVector paramData(cx);
-	paramData.append(Argument.get());
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
-	bool ok = JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result);
-	if (!ok)
-	{
+
+	if (!JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result))
 		JS_ReportError(cx, "Errors executing script action \"%s\"", Action.c_str());
-	}
 }
 
 JSObject* IGUIObject::GetJSObject()
 {
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	// Cache the object when somebody first asks for it, because otherwise
 	// we end up doing far too much object allocation. TODO: Would be nice to
 	// not have these objects hang around forever using up memory, though.
 	if (!m_JSObject.initialized())
 	{
 		m_JSObject.init(cx, m_pGUI->GetScriptInterface()->CreateCustomObject("GUIObject"));
 		JS_SetPrivate(m_JSObject.get(), this);
 	}
 	return m_JSObject.get();
 }
 
 CStr IGUIObject::GetPresentableName() const
 {
 	// __internal(), must be at least 13 letters to be able to be
 	//  an internal name
 	if (m_Name.length() <= 12)
 		return m_Name;
 
 	if (m_Name.substr(0, 10) == "__internal")
 		return CStr("[unnamed object]");
 	else
 		return m_Name;
 }
 
 void IGUIObject::SetFocus()
 {
 	GetGUI()->m_FocusedObject = this;
 }
 
 bool IGUIObject::IsFocused() const
 {
 	return GetGUI()->m_FocusedObject == this;
 }
 
 bool IGUIObject::IsRootObject() const
 {
 	return GetGUI() != 0 && m_pParent == GetGUI()->m_BaseObject;
 }
 
 void IGUIObject::TraceMember(JSTracer* trc)
 {
 	for (std::pair<const CStr, JS::Heap<JSObject*>>& handler : m_ScriptHandlers)
 		JS_CallObjectTracer(trc, &handler.second, "IGUIObject::m_ScriptHandlers");
 }
 
 PSRETURN IGUIObject::LogInvalidSettings(const CStr8& Setting) const
 {
 	LOGWARNING("IGUIObject: setting %s was not found on an object", Setting.c_str());
 	return PSRETURN_GUI_InvalidSetting;
 }
Index: ps/trunk/source/gui/IGUIObject.h
===================================================================
--- ps/trunk/source/gui/IGUIObject.h	(revision 22514)
+++ ps/trunk/source/gui/IGUIObject.h	(revision 22515)
@@ -1,530 +1,530 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * The base class of an object.
  * All objects are derived from this class.
  * It's an abstract data type, so it can't be used per se.
  * Also contains a Dummy object which is used for completely blank objects.
  */
 
 #ifndef INCLUDED_IGUIOBJECT
 #define INCLUDED_IGUIOBJECT
 
 #include "GUIbase.h"
 #include "GUItext.h"
 
 #include "gui/scripting/JSInterface_IGUIObject.h"
 #include "lib/input.h" // just for IN_PASS
 #include "ps/XML/Xeromyces.h"
 
 #include <string>
 #include <vector>
 
 struct SGUISetting;
 struct SGUIStyle;
 class CGUI;
 
 class JSObject;
 
 ERROR_TYPE(GUI, UnableToParse);
 
 /**
  * Setting Type
  * @see SGUISetting
  *
  * For use of later macros, all names should be GUIST_ followed
  * by the code name (case sensitive!).
  */
 #define TYPE(T) GUIST_##T,
 enum EGUISettingType
 {
 	#include "GUItypes.h"
 };
 #undef TYPE
 
 /**
  * A GUI Setting is anything that can be inputted from XML as
  * \<object\>-attributes (with exceptions). For instance:
  * \<object style="null"\>
  *
  * "style" will be a SGUISetting.
  */
 struct SGUISetting
 {
 	SGUISetting() : m_pSetting(NULL) {}
 
 	void				*m_pSetting;
 	EGUISettingType		m_Type;
 };
 
 /**
  * GUI object such as a button or an input-box.
  * Abstract data type !
  */
 class IGUIObject
 {
 	friend class CGUI;
 	friend class CInternalCGUIAccessorBase;
 	friend class IGUIScrollBar;
 	friend class GUITooltip;
 
 	// Allow getProperty to access things like GetParent()
 	friend bool JSI_IGUIObject::getProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::setProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool UNUSED(strict), JS::MutableHandleValue vp);
 	friend bool JSI_IGUIObject::getComputedSize(JSContext* cx, uint argc, JS::Value* vp);
 	friend bool JSI_IGUIObject::getTextSize(JSContext* cx, uint argc, JS::Value* vp);
 
 public:
 	IGUIObject();
 	virtual ~IGUIObject();
 
 	/**
 	 * Checks if mouse is hovering this object.
      * The mouse position is cached in CGUI.
 	 *
 	 * This function checks if the mouse is hovering the
 	 * rectangle that the base setting "size" makes.
 	 * Although it is virtual, so one could derive
 	 * an object from CButton, which changes only this
 	 * to checking the circle that "size" makes.
 	 *
 	 * @return true if mouse is hovering
 	 */
 	virtual bool MouseOver();
 
 	/**
 	 * Test if mouse position is over an icon
 	 */
 	virtual bool MouseOverIcon();
 
 	//--------------------------------------------------------
 	/** @name Leaf Functions */
 	//--------------------------------------------------------
 	//@{
 
 	/// Get object name, name is unique
 	const CStr& GetName() const { return m_Name; }
 
 	/// Get object name
 	void SetName(const CStr& Name) { m_Name = Name; }
 
 	// Get Presentable name.
 	//  Will change all internally set names to something like "<unnamed object>"
 	CStr GetPresentableName() const;
 
 	/**
 	 * Adds object and its children to the map, it's name being the
 	 * first part, and the second being itself.
 	 *
 	 * @param ObjectMap Adds this to the map_pObjects.
 	 *
 	 * @throws PSERROR_GUI_ObjectNeedsName Name is missing
 	 * @throws PSERROR_GUI_NameAmbiguity Name is already taken
 	 */
 	void AddToPointersMap(map_pObjects& ObjectMap);
 
 	/**
 	 * Notice nothing will be returned or thrown if the child hasn't
 	 * been inputted into the GUI yet. This is because that's were
 	 * all is checked. Now we're just linking two objects, but
 	 * it's when we're inputting them into the GUI we'll check
 	 * validity! Notice also when adding it to the GUI this function
 	 * will inevitably have been called by CGUI::AddObject which
 	 * will catch the throw and return the error code.
 	 * i.e. The user will never put in the situation wherein a throw
 	 * must be caught, the GUI's internal error handling will be
 	 * completely transparent to the interfacially sequential model.
 	 *
 	 * @param pChild Child to add
 	 *
 	 * @throws PSERROR_GUI from CGUI::UpdateObjects().
 	 */
 	void AddChild(IGUIObject* pChild);
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Iterate
 	 * Used to iterate over all children of this object.
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	vector_pObjects::iterator begin() { return m_Children.begin(); }
 	vector_pObjects::iterator end() { return m_Children.end(); }
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Settings Management */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Checks if settings exists, only available for derived
 	 * classes that has this set up, that's why the base
 	 * class just returns false
 	 *
 	 * @param Setting setting name
 	 * @return True if settings exist.
 	 */
 	bool SettingExists(const CStr& Setting) const;
 
 	/**
 	 * All sizes are relative to resolution, and the calculation
 	 * is not wanted in real time, therefore it is cached, update
 	 * the cached size with this function.
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Set a setting by string, regardless of what type it is.
 	 *
 	 * example a CRect(10,10,20,20) would be "10 10 20 20"
 	 *
 	 * @param Setting Setting by name
 	 * @param Value Value to set to
 	 * @param SkipMessage Does not send a GUIM_SETTINGS_UPDATED if true
 	 *
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage = false);
 
 	/**
 	 * Retrieves the type of a named setting.
 	 *
 	 * @param Setting Setting by name
 	 * @param Type Stores an EGUISettingType
 	 * @return PSRETURN (PSRETURN_OK if successful)
 	 */
 	PSRETURN GetSettingType(const CStr& Setting, EGUISettingType& Type) const;
 
 	/**
 	 * Set the script handler for a particular object-specific action
 	 *
 	 * @param Action Name of action
 	 * @param Code Javascript code to execute when the action occurs
 	 * @param pGUI GUI instance to associate the script with
 	 */
 	void RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI);
 
 	/**
 	 * Retrieves the JSObject representing this GUI object.
 	 */
 	JSObject* GetJSObject();
 
 	//@}
 protected:
 	//--------------------------------------------------------
 	/** @name Called by CGUI and friends
 	 *
 	 * Methods that the CGUI will call using
 	 * its friendship, these should not
 	 * be called by user.
 	 * These functions' security are a lot
 	 * what constitutes the GUI's
 	 */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Add a setting to m_Settings
 	 *
 	 * @param Type Setting type
 	 * @param Name Setting reference name
 	 */
 	void AddSetting(const EGUISettingType& Type, const CStr& Name);
 
 	/**
 	 * Calls Destroy on all children, and deallocates all memory.
 	 * MEGA TODO Should it destroy it's children?
 	 */
 	virtual void Destroy();
 
 public:
 	/**
      * This function is called with different messages
 	 * for instance when the mouse enters the object.
 	 *
 	 * @param Message GUI Message
 	 */
 	virtual void HandleMessage(SGUIMessage& UNUSED(Message)) {}
 
 protected:
 	/**
 	 * Draws the object.
 	 *
 	 * @throws	PSERROR if any. But this will mostlikely be
 	 *			very rare since if an object is drawn unsuccessfully
 	 *			it'll probably only output in the Error log, and not
 	 *			disrupt the whole GUI drawing.
 	 */
 	virtual void Draw() = 0;
 
 	/**
 	 * Some objects need to handle the SDL_Event_ manually.
 	 * For instance the input box.
 	 *
 	 * Only the object with focus will have this function called.
 	 *
 	 * Returns either IN_PASS or IN_HANDLED. If IN_HANDLED, then
 	 * the key won't be passed on and processed by other handlers.
 	 * This is used for keys that the GUI uses.
 	 */
 	virtual InReaction ManuallyHandleEvent(const SDL_Event_* UNUSED(ev)) { return IN_PASS; }
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param GUIinstance Reference to the GUI
 	 * @param StyleName Style by name
 	 */
 	void LoadStyle(CGUI& GUIinstance, const CStr& StyleName);
 
 	/**
 	 * Loads a style.
 	 *
 	 * @param Style The style object.
 	 */
 	void LoadStyle(const SGUIStyle& Style);
 
 	/**
 	 * Returns not the Z value, but the actual buffered Z value, i.e. if it's
 	 * defined relative, then it will check its parent's Z value and add
 	 * the relativity.
 	 *
 	 * @return Actual Z value on the screen.
 	 */
 	virtual float GetBufferedZ() const;
 
 	void SetGUI(CGUI* const& pGUI);
 
 	/**
 	 * Set parent of this object
 	 */
 	void SetParent(IGUIObject* pParent) { m_pParent = pParent; }
 
 	/**
 	 * Reset internal state of this object
 	 */
 	virtual void ResetStates()
 	{
 		// Notify the gui that we aren't hovered anymore
 		UpdateMouseOver(NULL);
 	}
 
 public:
 	CGUI* GetGUI() { return m_pGUI; }
 	const CGUI* GetGUI() const { return m_pGUI; }
 
 	/**
 	 * Take focus!
 	 */
 	void SetFocus();
 
 protected:
 	/**
 	 * Check if object is focused.
 	 */
 	bool IsFocused() const;
 
 	/**
 	 * <b>NOTE!</b> This will not just return m_pParent, when that is
 	 * need use it! There is one exception to it, when the parent is
 	 * the top-node (the object that isn't a real object), this
 	 * will return NULL, so that the top-node's children are
 	 * seemingly parentless.
 	 *
 	 * @return Pointer to parent
 	 */
 	IGUIObject* GetParent() const;
 
 	/**
 	 * Get Mouse from CGUI.
 	 */
 	CPos GetMousePos() const;
 
 	/**
 	 * Handle additional children to the \<object\>-tag. In IGUIObject, this function does
 	 * nothing. In CList and CDropDown, it handles the \<item\>, used to build the data.
 	 *
 	 * Returning false means the object doesn't recognize the child. Should be reported.
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
 	virtual bool HandleAdditionalChildren(const XMBElement& UNUSED(child), CXeromyces* UNUSED(pFile))
 	{
 		return false;
 	}
 
 	/**
 	 * Cached size, real size m_Size is actually dependent on resolution
 	 * and can have different *real* outcomes, this is the real outcome
 	 * cached to avoid slow calculations in real time.
 	 */
 	CRect m_CachedActualSize;
 
 	/**
 	 * Send event to this GUI object (HandleMessage and ScriptEvent)
 	 *
 	 * @param type Type of GUI message to be handled
 	 * @param EventName String representation of event name
 	 * @return IN_HANDLED if event was handled, or IN_PASS if skipped
 	 */
 	InReaction SendEvent(EGUIMessageType type, const CStr& EventName);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 * The mouse coordinates will be passed as the first argument.
 	 *
 	 * @param Action Name of action
 	 */
 	void ScriptEvent(const CStr& Action);
 
 	/**
 	 * Execute the script for a particular action.
 	 * Does nothing if no script has been registered for that action.
 	 *
 	 * @param Action Name of action
-	 * @param Argument Argument to pass to action
+	 * @param paramData JS::HandleValueArray arguments to pass to the event.
 	 */
-	void ScriptEvent(const CStr& Action, JS::HandleValue Argument);
+	void ScriptEvent(const CStr& Action, JS::HandleValueArray paramData);
 
 	void SetScriptHandler(const CStr& Action, JS::HandleObject Function);
 
 	/**
 	 * Inputes the object that is currently hovered, this function
 	 * updates this object accordingly (i.e. if it's the object
 	 * being inputted one thing happens, and not, another).
 	 *
 	 * @param pMouseOver	Object that is currently hovered,
 	 *						can OF COURSE be NULL too!
 	 */
 	void UpdateMouseOver(IGUIObject* const& pMouseOver);
 
 	//@}
 private:
 	//--------------------------------------------------------
 	/** @name Internal functions */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Inputs a reference pointer, checks if the new inputted object
 	 * if hovered, if so, then check if this's Z value is greater
 	 * than the inputted object... If so then the object is closer
 	 * and we'll replace the pointer with this.
 	 * Also Notice input can be NULL, which means the Z value demand
 	 *  is out. NOTICE you can't input NULL as const so you'll have
 	 * to set an object to NULL.
 	 *
 	 * @param pObject	Object pointer, can be either the old one, or
 	 *					the new one.
 	 */
 	void ChooseMouseOverAndClosest(IGUIObject*& pObject);
 
 	// Is the object a Root object, in philosophy, this means it
 	//  has got no parent, and technically, it's got the m_BaseObject
 	//  as parent.
 	bool IsRootObject() const;
 
 	/**
 	 * Logs an invalid setting search and returns the correct return result
 	 *
 	 * @return the error result
 	 */
 	PSRETURN LogInvalidSettings(const CStr8& Setting) const;
 
 	static void Trace(JSTracer* trc, void* data)
 	{
 		reinterpret_cast<IGUIObject*>(data)->TraceMember(trc);
 	}
 
 	void TraceMember(JSTracer* trc);
 
 	// Variables
 
 protected:
 	// Name of object
 	CStr									m_Name;
 
 	// Constructed on the heap, will be destroyed along with the the object
 	// TODO Gee: really the above?
 	vector_pObjects							m_Children;
 
 	// Pointer to parent
 	IGUIObject								*m_pParent;
 
 	//This represents the last click time for each mouse button
 	double m_LastClickTime[6];
 
 	/**
 	 * This is an array of true or false, each element is associated with
 	 * a string representing a setting. Number of elements is equal to
 	 * number of settings.
 	 *
 	 * A true means the setting has been manually set in the file when
 	 * read. This is important to know because I don't want to force
 	 * the user to include its \<styles\>-XML-files first, so somehow
 	 * the GUI needs to know which settings were set, and which is meant
 	 * to.
 	 */
 
 	// More variables
 
 	// Is mouse hovering the object? used with the function MouseOver()
 	bool									m_MouseHovering;
 
 	/**
 	 * Settings pool, all an object's settings are located here
 	 * If a derived object has got more settings that the base
 	 * settings, it's because they have a new version of the
 	 * function SetupSettings().
 	 *
 	 * @see SetupSettings()
 	 */
 	public:
 	std::map<CStr, SGUISetting>				m_Settings;
 
 private:
 	// An object can't function stand alone
 	CGUI									*m_pGUI;
 
 	// Internal storage for registered script handlers.
 	std::map<CStr, JS::Heap<JSObject*> >	m_ScriptHandlers;
 
 	// Cached JSObject representing this GUI object
 	JS::PersistentRootedObject				m_JSObject;
 };
 
 
 /**
  * Dummy object used primarily for the root object
  * or objects of type 'empty'
  */
 class CGUIDummyObject : public IGUIObject
 {
 	GUI_OBJECT(CGUIDummyObject)
 
 public:
 
 	virtual void Draw() {}
 	// Empty can never be hovered. It is only a category.
 	virtual bool MouseOver() { return false; }
 };
 
 #endif // INCLUDED_IGUIOBJECT
Index: ps/trunk/source/gui/MiniMap.cpp
===================================================================
--- ps/trunk/source/gui/MiniMap.cpp	(revision 22514)
+++ ps/trunk/source/gui/MiniMap.cpp	(revision 22515)
@@ -1,707 +1,711 @@
 /* Copyright (C) 2017 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include <math.h>
 
 #include "MiniMap.h"
 
 #include "graphics/GameView.h"
 #include "graphics/LOSTexture.h"
 #include "graphics/MiniPatch.h"
 #include "graphics/Terrain.h"
 #include "graphics/TerrainTextureEntry.h"
 #include "graphics/TerrainTextureManager.h"
 #include "graphics/TerritoryTexture.h"
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
 #include "lib/bits.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Profile.h"
 #include "ps/World.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpMinimap.h"
 #include "simulation2/system/ParamNode.h"
 
 extern bool g_GameRestarted;
 
 // Set max drawn entities to UINT16_MAX for now, which is more than enough
 // TODO: we should be cleverer about drawing them to reduce clutter
 const u16 MAX_ENTITIES_DRAWN = 65535;
 
 static unsigned int ScaleColor(unsigned int color, float x)
 {
 	unsigned int r = unsigned(float(color & 0xff) * x);
 	unsigned int g = unsigned(float((color>>8) & 0xff) * x);
 	unsigned int b = unsigned(float((color>>16) & 0xff) * x);
 	return (0xff000000 | b | g<<8 | r<<16);
 }
 
 CMiniMap::CMiniMap() :
 	m_TerrainTexture(0), m_TerrainData(0), m_MapSize(0), m_Terrain(0), m_TerrainDirty(true), m_MapScale(1.f),
 	m_EntitiesDrawn(0), m_IndexArray(GL_STATIC_DRAW), m_VertexArray(GL_DYNAMIC_DRAW),
 	m_NextBlinkTime(0.0), m_PingDuration(25.0), m_BlinkState(false), m_WaterHeight(0.0)
 {
 	AddSetting(GUIST_CColor,	"fov_wedge_color");
 	AddSetting(GUIST_CStrW,		"tooltip");
 	AddSetting(GUIST_CStr,		"tooltip_style");
 	m_Clicking = false;
 	m_MouseHovering = false;
 
 	// Register Relax NG validator
 	CXeromyces::AddValidator(g_VFS, "pathfinder", "simulation/data/pathfinder.rng");
 
 	// Get the maximum height for unit passage in water.
 	CParamNode externalParamNode;
 	CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml", "pathfinder");
 	const CParamNode pathingSettings = externalParamNode.GetChild("Pathfinder").GetChild("PassabilityClasses");
 	if (pathingSettings.GetChild("default").IsOk() && pathingSettings.GetChild("default").GetChild("MaxWaterDepth").IsOk())
 		m_ShallowPassageHeight = pathingSettings.GetChild("default").GetChild("MaxWaterDepth").ToFloat();
 	else
 		m_ShallowPassageHeight = 0.0f;
 
 	m_AttributePos.type = GL_FLOAT;
 	m_AttributePos.elems = 2;
 	m_VertexArray.AddAttribute(&m_AttributePos);
 
 	m_AttributeColor.type = GL_UNSIGNED_BYTE;
 	m_AttributeColor.elems = 4;
 	m_VertexArray.AddAttribute(&m_AttributeColor);
 
 	m_VertexArray.SetNumVertices(MAX_ENTITIES_DRAWN);
 	m_VertexArray.Layout();
 
 	m_IndexArray.SetNumVertices(MAX_ENTITIES_DRAWN);
 	m_IndexArray.Layout();
 	VertexArrayIterator<u16> index = m_IndexArray.GetIterator();
 	for (u16 i = 0; i < MAX_ENTITIES_DRAWN; ++i)
 		*index++ = i;
 	m_IndexArray.Upload();
 	m_IndexArray.FreeBackingStore();
 
 
 	VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();
 	VertexArrayIterator<u8[4]> attrColor = m_AttributeColor.GetIterator<u8[4]>();
 	for (u16 i = 0; i < MAX_ENTITIES_DRAWN; ++i)
 	{
 		(*attrColor)[0] = 0;
 		(*attrColor)[1] = 0;
 		(*attrColor)[2] = 0;
 		(*attrColor)[3] = 0;
 		++attrColor;
 
 		(*attrPos)[0] = -10000.0f;
 		(*attrPos)[1] = -10000.0f;
 
 		++attrPos;
 
 	}
 	m_VertexArray.Upload();
 
 	double blinkDuration = 1.0;
 
 	// Tests won't have config initialised
 	if (CConfigDB::IsInitialised())
 	{
 		CFG_GET_VAL("gui.session.minimap.pingduration", m_PingDuration);
 		CFG_GET_VAL("gui.session.minimap.blinkduration", blinkDuration);
 	}
 	m_HalfBlinkDuration = blinkDuration/2;
 }
 
 CMiniMap::~CMiniMap()
 {
 	Destroy();
 }
 
 void CMiniMap::HandleMessage(SGUIMessage& Message)
 {
 	switch (Message.type)
 	{
 	case GUIM_MOUSE_PRESS_LEFT:
 		if (m_MouseHovering)
 		{
 			SetCameraPos();
 			m_Clicking = true;
 		}
 		break;
 	case GUIM_MOUSE_RELEASE_LEFT:
 		if (m_MouseHovering && m_Clicking)
 			SetCameraPos();
 		m_Clicking = false;
 		break;
 	case GUIM_MOUSE_DBLCLICK_LEFT:
 		if (m_MouseHovering && m_Clicking)
 			SetCameraPos();
 		m_Clicking = false;
 		break;
 	case GUIM_MOUSE_ENTER:
 		m_MouseHovering = true;
 		break;
 	case GUIM_MOUSE_LEAVE:
 		m_Clicking = false;
 		m_MouseHovering = false;
 		break;
 	case GUIM_MOUSE_RELEASE_RIGHT:
 		CMiniMap::FireWorldClickEvent(SDL_BUTTON_RIGHT, 1);
 		break;
 	case GUIM_MOUSE_DBLCLICK_RIGHT:
 		CMiniMap::FireWorldClickEvent(SDL_BUTTON_RIGHT, 2);
 		break;
 	case GUIM_MOUSE_MOTION:
 		if (m_MouseHovering && m_Clicking)
 			SetCameraPos();
 		break;
 	case GUIM_MOUSE_WHEEL_DOWN:
 	case GUIM_MOUSE_WHEEL_UP:
 		Message.Skip();
 		break;
 
 	default:
 		break;
 	}
 }
 
 bool CMiniMap::MouseOver()
 {
 	// Get the mouse position.
 	CPos mousePos = GetMousePos();
 	// Get the position of the center of the minimap.
 	CPos minimapCenter = CPos(m_CachedActualSize.left + m_CachedActualSize.GetWidth() / 2.0, m_CachedActualSize.bottom - m_CachedActualSize.GetHeight() / 2.0);
 	// Take the magnitude of the difference of the mouse position and minimap center.
 	double distFromCenter = sqrt(pow((mousePos.x - minimapCenter.x), 2) + pow((mousePos.y - minimapCenter.y), 2));
 	// If the distance is less then the radius of the minimap (half the width) the mouse is over the minimap.
 	if (distFromCenter < m_CachedActualSize.GetWidth() / 2.0)
 		return true;
 	else
 		return false;
 }
 
 void CMiniMap::GetMouseWorldCoordinates(float& x, float& z)
 {
 	// Determine X and Z according to proportion of mouse position and minimap
 
 	CPos mousePos = GetMousePos();
 
 	float px = (mousePos.x - m_CachedActualSize.left) / m_CachedActualSize.GetWidth();
 	float py = (m_CachedActualSize.bottom - mousePos.y) / m_CachedActualSize.GetHeight();
 
 	float angle = GetAngle();
 
 	// Scale world coordinates for shrunken square map
 	x = TERRAIN_TILE_SIZE * m_MapSize * (m_MapScale * (cos(angle)*(px-0.5) - sin(angle)*(py-0.5)) + 0.5);
 	z = TERRAIN_TILE_SIZE * m_MapSize * (m_MapScale * (cos(angle)*(py-0.5) + sin(angle)*(px-0.5)) + 0.5);
 }
 
 void CMiniMap::SetCameraPos()
 {
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	CVector3D target;
 	GetMouseWorldCoordinates(target.X, target.Z);
 	target.Y = terrain->GetExactGroundLevel(target.X, target.Z);
 	g_Game->GetView()->MoveCameraTarget(target);
 }
 
 float CMiniMap::GetAngle()
 {
 	CVector3D cameraIn = m_Camera->m_Orientation.GetIn();
 	return -atan2(cameraIn.X, cameraIn.Z);
 }
 
 void CMiniMap::FireWorldClickEvent(int UNUSED(button), int UNUSED(clicks))
 {
 	JSContext* cx = g_GUI->GetActiveGUI()->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 
 	float x, z;
 	GetMouseWorldCoordinates(x, z);
 
 	JS::RootedValue coords(cx);
 	g_GUI->GetActiveGUI()->GetScriptInterface()->Eval("({})", &coords);
 	g_GUI->GetActiveGUI()->GetScriptInterface()->SetProperty(coords, "x", x, false);
 	g_GUI->GetActiveGUI()->GetScriptInterface()->SetProperty(coords, "z", z, false);
-	ScriptEvent("worldclick", coords);
+
+	JS::AutoValueVector paramData(cx);
+	paramData.append(coords);
+
+	ScriptEvent("worldclick", paramData);
 }
 
 // This sets up and draws the rectangle on the minimap
 //  which represents the view of the camera in the world.
 void CMiniMap::DrawViewRect(CMatrix3D transform)
 {
 	// Compute the camera frustum intersected with a fixed-height plane.
 	// Use the water height as a fixed base height, which should be the lowest we can go
 	float h = g_Renderer.GetWaterManager()->m_WaterHeight;
 	const float width = m_CachedActualSize.GetWidth();
 	const float height = m_CachedActualSize.GetHeight();
 	const float invTileMapSize = 1.0f / float(TERRAIN_TILE_SIZE * m_MapSize);
 
 	CVector3D hitPt[4];
 	hitPt[0] = m_Camera->GetWorldCoordinates(0, g_Renderer.GetHeight(), h);
 	hitPt[1] = m_Camera->GetWorldCoordinates(g_Renderer.GetWidth(), g_Renderer.GetHeight(), h);
 	hitPt[2] = m_Camera->GetWorldCoordinates(g_Renderer.GetWidth(), 0, h);
 	hitPt[3] = m_Camera->GetWorldCoordinates(0, 0, h);
 
 	float ViewRect[4][2];
 	for (int i = 0; i < 4; ++i)
 	{
 		// convert to minimap space
 		ViewRect[i][0] = (width * hitPt[i].X * invTileMapSize);
 		ViewRect[i][1] = (height * hitPt[i].Z * invTileMapSize);
 	}
 
 	float viewVerts[] = {
 		ViewRect[0][0], -ViewRect[0][1],
 		ViewRect[1][0], -ViewRect[1][1],
 		ViewRect[2][0], -ViewRect[2][1],
 		ViewRect[3][0], -ViewRect[3][1]
 	};
 
 	// Enable Scissoring to restrict the rectangle to only the minimap.
 	glScissor(
 		m_CachedActualSize.left * g_GuiScale,
 		g_Renderer.GetHeight() - m_CachedActualSize.bottom * g_GuiScale,
 		width * g_GuiScale,
 		height * g_GuiScale);
 	glEnable(GL_SCISSOR_TEST);
 	glLineWidth(2.0f);
 
 	CShaderDefines lineDefines;
 	lineDefines.Add(str_MINIMAP_LINE, str_1);
 	CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), lineDefines);
 	tech->BeginPass();
 	CShaderProgramPtr shader = tech->GetShader();
 	shader->Uniform(str_transform, transform);
 	shader->Uniform(str_color, 1.0f, 0.3f, 0.3f, 1.0f);
 
 	shader->VertexPointer(2, GL_FLOAT, 0, viewVerts);
 	shader->AssertPointersBound();
 
 	if (!g_Renderer.m_SkipSubmit)
 		glDrawArrays(GL_LINE_LOOP, 0, 4);
 
 	tech->EndPass();
 
 	glLineWidth(1.0f);
 	glDisable(GL_SCISSOR_TEST);
 }
 
 struct MinimapUnitVertex
 {
 	u8 r, g, b, a;
 	float x, y;
 };
 
 // Adds a vertex to the passed VertexArray
 static void inline addVertex(const MinimapUnitVertex& v,
 					  VertexArrayIterator<u8[4]>& attrColor,
 					  VertexArrayIterator<float[2]>& attrPos)
 {
 	(*attrColor)[0] = v.r;
 	(*attrColor)[1] = v.g;
 	(*attrColor)[2] = v.b;
 	(*attrColor)[3] = v.a;
 	++attrColor;
 
 	(*attrPos)[0] = v.x;
 	(*attrPos)[1] = v.y;
 
 	++attrPos;
 }
 
 
 void CMiniMap::DrawTexture(CShaderProgramPtr shader, float coordMax, float angle, float x, float y, float x2, float y2, float z)
 {
 	// Rotate the texture coordinates (0,0)-(coordMax,coordMax) around their center point (m,m)
 	// Scale square maps to fit in circular minimap area
 	const float s = sin(angle) * m_MapScale;
 	const float c = cos(angle) * m_MapScale;
 	const float m = coordMax / 2.f;
 
 	float quadTex[] = {
 		m*(-c + s + 1.f), m*(-c + -s + 1.f),
 		m*(c + s + 1.f), m*(-c + s + 1.f),
 		m*(c + -s + 1.f), m*(c + s + 1.f),
 
 		m*(c + -s + 1.f), m*(c + s + 1.f),
 		m*(-c + -s + 1.f), m*(c + -s + 1.f),
 		m*(-c + s + 1.f), m*(-c + -s + 1.f)
 	};
 	float quadVerts[] = {
 		x, y, z,
 		x2, y, z,
 		x2, y2, z,
 
 		x2, y2, z,
 		x, y2, z,
 		x, y, z
 	};
 
 	shader->TexCoordPointer(GL_TEXTURE0, 2, GL_FLOAT, 0, quadTex);
 	shader->VertexPointer(3, GL_FLOAT, 0, quadVerts);
 	shader->AssertPointersBound();
 
 	if (!g_Renderer.m_SkipSubmit)
 		glDrawArrays(GL_TRIANGLES, 0, 6);
 }
 
 // TODO: render the minimap in a framebuffer and just draw the frambuffer texture
 //	most of the time, updating the framebuffer twice a frame.
 // Here it updates as ping-pong either texture or vertex array each sec to lower gpu stalling
 // (those operations cause a gpu sync, which slows down the way gpu works)
 void CMiniMap::Draw()
 {
 	PROFILE3("render minimap");
 
 	// The terrain isn't actually initialized until the map is loaded, which
 	// happens when the game is started, so abort until then.
 	if (!(GetGUI() && g_Game && g_Game->IsGameStarted()))
 		return;
 
 	CSimulation2* sim = g_Game->GetSimulation2();
 	CmpPtr<ICmpRangeManager> cmpRangeManager(*sim, SYSTEM_ENTITY);
 	ENSURE(cmpRangeManager);
 
 	// Set our globals in case they hadn't been set before
 	m_Camera = g_Game->GetView()->GetCamera();
 	m_Terrain = g_Game->GetWorld()->GetTerrain();
 	m_Width  = (u32)(m_CachedActualSize.right - m_CachedActualSize.left);
 	m_Height = (u32)(m_CachedActualSize.bottom - m_CachedActualSize.top);
 	m_MapSize = m_Terrain->GetVerticesPerSide();
 	m_TextureSize = (GLsizei)round_up_to_pow2((size_t)m_MapSize);
 	m_MapScale = (cmpRangeManager->GetLosCircular() ? 1.f : 1.414f);
 
 	if (!m_TerrainTexture || g_GameRestarted)
 		CreateTextures();
 
 
 	// only update 2x / second
 	// (note: since units only move a few pixels per second on the minimap,
 	// we can get away with infrequent updates; this is slow)
 	// TODO: Update all but camera at same speed as simulation
 	static double last_time;
 	const double cur_time = timer_Time();
 	const bool doUpdate = cur_time - last_time > 0.5;
 	if (doUpdate)
 	{
 		last_time = cur_time;
 		if (m_TerrainDirty || m_WaterHeight != g_Renderer.GetWaterManager()->m_WaterHeight)
 			RebuildTerrainTexture();
 	}
 
 	const float x = m_CachedActualSize.left, y = m_CachedActualSize.bottom;
 	const float x2 = m_CachedActualSize.right, y2 = m_CachedActualSize.top;
 	const float z = GetBufferedZ();
 	const float texCoordMax = (float)(m_MapSize - 1) / (float)m_TextureSize;
 	const float angle = GetAngle();
 	const float unitScale = (cmpRangeManager->GetLosCircular() ? 1.f : m_MapScale/2.f);
 
 	// Disable depth updates to prevent apparent z-fighting-related issues
 	//  with some drivers causing units to get drawn behind the texture.
 	glDepthMask(0);
 
 	CShaderProgramPtr shader;
 	CShaderTechniquePtr tech;
 
 	CShaderDefines baseDefines;
 	baseDefines.Add(str_MINIMAP_BASE, str_1);
 	tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), baseDefines);
 	tech->BeginPass();
 	shader = tech->GetShader();
 
 	// Draw the main textured quad
 	shader->BindTexture(str_baseTex, m_TerrainTexture);
 	const CMatrix3D baseTransform = GetDefaultGuiMatrix();
 	CMatrix3D baseTextureTransform;
 	baseTextureTransform.SetIdentity();
 	shader->Uniform(str_transform, baseTransform);
 	shader->Uniform(str_textureTransform, baseTextureTransform);
 
 	DrawTexture(shader, texCoordMax, angle, x, y, x2, y2, z);
 
 	// Draw territory boundaries
 	glEnable(GL_BLEND);
 
 	CTerritoryTexture& territoryTexture = g_Game->GetView()->GetTerritoryTexture();
 
 	shader->BindTexture(str_baseTex, territoryTexture.GetTexture());
 	const CMatrix3D* territoryTransform = territoryTexture.GetMinimapTextureMatrix();
 	shader->Uniform(str_transform, baseTransform);
 	shader->Uniform(str_textureTransform, *territoryTransform);
 
 	DrawTexture(shader, 1.0f, angle, x, y, x2, y2, z);
 	tech->EndPass();
 
 	// Draw the LOS quad in black, using alpha values from the LOS texture
 	CLOSTexture& losTexture = g_Game->GetView()->GetLOSTexture();
 
 	CShaderDefines losDefines;
 	losDefines.Add(str_MINIMAP_LOS, str_1);
 	tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), losDefines);
 	tech->BeginPass();
 	shader = tech->GetShader();
 	shader->BindTexture(str_baseTex, losTexture.GetTexture());
 
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 	const CMatrix3D* losTransform = losTexture.GetMinimapTextureMatrix();
 	shader->Uniform(str_transform, baseTransform);
 	shader->Uniform(str_textureTransform, *losTransform);
 
 	DrawTexture(shader, 1.0f, angle, x, y, x2, y2, z);
 	tech->EndPass();
 
 	glDisable(GL_BLEND);
 
 	PROFILE_START("minimap units");
 
 	CShaderDefines pointDefines;
 	pointDefines.Add(str_MINIMAP_POINT, str_1);
 	tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, g_Renderer.GetSystemShaderDefines(), pointDefines);
 	tech->BeginPass();
 	shader = tech->GetShader();
 	shader->Uniform(str_transform, baseTransform);
 	shader->Uniform(str_pointSize, 3.f);
 
 	CMatrix3D unitMatrix;
 	unitMatrix.SetIdentity();
 	// Center the minimap on the origin of the axis of rotation.
 	unitMatrix.Translate(-(x2 - x) / 2.f, -(y2 - y) / 2.f, 0.f);
 	// Rotate the map.
 	unitMatrix.RotateZ(angle);
 	// Scale square maps to fit.
 	unitMatrix.Scale(unitScale, unitScale, 1.f);
 	// Move the minimap back to it's starting position.
 	unitMatrix.Translate((x2 - x) / 2.f, (y2 - y) / 2.f, 0.f);
 	// Move the minimap to it's final location.
 	unitMatrix.Translate(x, y, z);
 	// Apply the gui matrix.
 	unitMatrix *= GetDefaultGuiMatrix();
 	// Load the transform into the shader.
 	shader->Uniform(str_transform, unitMatrix);
 
 	const float sx = (float)m_Width / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
 	const float sy = (float)m_Height / ((m_MapSize - 1) * TERRAIN_TILE_SIZE);
 
 	CSimulation2::InterfaceList ents = sim->GetEntitiesWithInterface(IID_Minimap);
 
 	if (doUpdate)
 	{
 		VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();
 		VertexArrayIterator<u8[4]> attrColor = m_AttributeColor.GetIterator<u8[4]>();
 
 		m_EntitiesDrawn = 0;
 		MinimapUnitVertex v;
 		std::vector<MinimapUnitVertex> pingingVertices;
 		pingingVertices.reserve(MAX_ENTITIES_DRAWN / 2);
 
 		if (cur_time > m_NextBlinkTime)
 		{
 			m_BlinkState = !m_BlinkState;
 			m_NextBlinkTime = cur_time + m_HalfBlinkDuration;
 		}
 
 		entity_pos_t posX, posZ;
 		for (CSimulation2::InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
 		{
 			ICmpMinimap* cmpMinimap = static_cast<ICmpMinimap*>(it->second);
 			if (cmpMinimap->GetRenderData(v.r, v.g, v.b, posX, posZ))
 			{
 				ICmpRangeManager::ELosVisibility vis = cmpRangeManager->GetLosVisibility(it->first, g_Game->GetSimulation2()->GetSimContext().GetCurrentDisplayedPlayer());
 				if (vis != ICmpRangeManager::VIS_HIDDEN)
 				{
 					v.a = 255;
 					v.x = posX.ToFloat() * sx;
 					v.y = -posZ.ToFloat() * sy;
 
 					// Check minimap pinging to indicate something
 					if (m_BlinkState && cmpMinimap->CheckPing(cur_time, m_PingDuration))
 					{
 						v.r = 255; // ping color is white
 						v.g = 255;
 						v.b = 255;
 						pingingVertices.push_back(v);
 					}
 					else
 					{
 						addVertex(v, attrColor, attrPos);
 						++m_EntitiesDrawn;
 					}
 				}
 			}
 		}
 
 		// Add the pinged vertices at the end, so they are drawn on top
 		for (size_t v = 0; v < pingingVertices.size(); ++v)
 		{
 			addVertex(pingingVertices[v], attrColor, attrPos);
 			++m_EntitiesDrawn;
 		}
 
 		ENSURE(m_EntitiesDrawn < MAX_ENTITIES_DRAWN);
 		m_VertexArray.Upload();
 	}
 
 	m_VertexArray.PrepareForRendering();
 
 	if (m_EntitiesDrawn > 0)
 	{
 #if !CONFIG2_GLES
 		if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
 			glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
 #endif
 
 		u8* indexBase = m_IndexArray.Bind();
 		u8* base = m_VertexArray.Bind();
 		const GLsizei stride = (GLsizei)m_VertexArray.GetStride();
 
 		shader->VertexPointer(2, GL_FLOAT, stride, base + m_AttributePos.offset);
 		shader->ColorPointer(4, GL_UNSIGNED_BYTE, stride, base + m_AttributeColor.offset);
 		shader->AssertPointersBound();
 
 		if (!g_Renderer.m_SkipSubmit)
 			glDrawElements(GL_POINTS, (GLsizei)(m_EntitiesDrawn), GL_UNSIGNED_SHORT, indexBase);
 
 		g_Renderer.GetStats().m_DrawCalls++;
 		CVertexBuffer::Unbind();
 
 #if !CONFIG2_GLES
 		if (g_Renderer.GetRenderPath() == CRenderer::RP_SHADER)
 			glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
 #endif
 	}
 
 	tech->EndPass();
 
 	DrawViewRect(unitMatrix);
 
 	PROFILE_END("minimap units");
 
 	// Reset depth mask
 	glDepthMask(1);
 }
 
 void CMiniMap::CreateTextures()
 {
 	Destroy();
 
 	// Create terrain texture
 	glGenTextures(1, &m_TerrainTexture);
 	g_Renderer.BindTexture(0, m_TerrainTexture);
 
 	// Initialise texture with solid black, for the areas we don't
 	// overwrite with glTexSubImage2D later
 	u32* texData = new u32[m_TextureSize * m_TextureSize];
 	for (ssize_t i = 0; i < m_TextureSize * m_TextureSize; ++i)
 		texData[i] = 0xFF000000;
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_TextureSize, m_TextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, texData);
 	delete[] texData;
 
 	m_TerrainData = new u32[(m_MapSize - 1) * (m_MapSize - 1)];
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
 	// Rebuild and upload both of them
 	RebuildTerrainTexture();
 }
 
 
 void CMiniMap::RebuildTerrainTexture()
 {
 	u32 x = 0;
 	u32 y = 0;
 	u32 w = m_MapSize - 1;
 	u32 h = m_MapSize - 1;
 	m_WaterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
 
 	m_TerrainDirty = false;
 
 	for (u32 j = 0; j < h; ++j)
 	{
 		u32* dataPtr = m_TerrainData + ((y + j) * (m_MapSize - 1)) + x;
 		for (u32 i = 0; i < w; ++i)
 		{
 			float avgHeight = ( m_Terrain->GetVertexGroundLevel((int)i, (int)j)
 					+ m_Terrain->GetVertexGroundLevel((int)i+1, (int)j)
 					+ m_Terrain->GetVertexGroundLevel((int)i, (int)j+1)
 					+ m_Terrain->GetVertexGroundLevel((int)i+1, (int)j+1)
 				) / 4.0f;
 
 			if (avgHeight < m_WaterHeight && avgHeight > m_WaterHeight - m_ShallowPassageHeight)
 			{
 				// shallow water
 				*dataPtr++ = 0xffc09870;
 			}
 			else if (avgHeight < m_WaterHeight)
 			{
 				// Set water as constant color for consistency on different maps
 				*dataPtr++ = 0xffa07850;
 			}
 			else
 			{
 				int hmap = ((int)m_Terrain->GetHeightMap()[(y + j) * m_MapSize + x + i]) >> 8;
 				int val = (hmap / 3) + 170;
 
 				u32 color = 0xFFFFFFFF;
 
 				CMiniPatch* mp = m_Terrain->GetTile(x + i, y + j);
 				if (mp)
 				{
 					CTerrainTextureEntry* tex = mp->GetTextureEntry();
 					if (tex)
 					{
 						// If the texture can't be loaded yet, set the dirty flags
 						// so we'll try regenerating the terrain texture again soon
 						if(!tex->GetTexture()->TryLoad())
 							m_TerrainDirty = true;
 
 						color = tex->GetBaseColor();
 					}
 				}
 
 				*dataPtr++ = ScaleColor(color, float(val) / 255.0f);
 			}
 		}
 	}
 
 	// Upload the texture
 	g_Renderer.BindTexture(0, m_TerrainTexture);
 	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_MapSize - 1, m_MapSize - 1, GL_RGBA, GL_UNSIGNED_BYTE, m_TerrainData);
 }
 
 void CMiniMap::Destroy()
 {
 	if (m_TerrainTexture)
 	{
 		glDeleteTextures(1, &m_TerrainTexture);
 		m_TerrainTexture = 0;
 	}
 
 	SAFE_ARRAY_DELETE(m_TerrainData);
 }
Index: ps/trunk/source/ps/GameSetup/GameSetup.cpp
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 22514)
+++ ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 22515)
@@ -1,1675 +1,1685 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "lib/app_hooks.h"
 #include "lib/config2.h"
 #include "lib/input.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/file/common/file_stats.h"
 #include "lib/res/h_mgr.h"
 #include "lib/res/graphics/cursor.h"
 #include "lib/sysdep/cursor.h"
 
 #include "graphics/CinemaManager.h"
 #include "graphics/FontMetrics.h"
 #include "graphics/GameView.h"
 #include "graphics/LightEnv.h"
 #include "graphics/MapReader.h"
 #include "graphics/MaterialManager.h"
 #include "graphics/TerrainTextureManager.h"
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
 #include "gui/scripting/ScriptFunctions.h"
 #include "i18n/L10n.h"
 #include "maths/MathUtil.h"
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 #include "network/NetMessage.h"
 #include "network/NetMessages.h"
 
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/Atlas.h"
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/GameSetup/Paths.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/GameSetup/CmdLineArgs.h"
 #include "ps/GameSetup/HWDetect.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Joystick.h"
 #include "ps/Loader.h"
 #include "ps/Mod.h"
 #include "ps/ModIo.h"
 #include "ps/Profile.h"
 #include "ps/ProfileViewer.h"
 #include "ps/Profiler2.h"
 #include "ps/Pyrogenesis.h"	// psSetLogDir
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/TouchInput.h"
 #include "ps/UserReport.h"
 #include "ps/Util.h"
 #include "ps/VideoMode.h"
 #include "ps/VisualReplay.h"
 #include "ps/World.h"
 
 #include "renderer/Renderer.h"
 #include "renderer/VertexBufferManager.h"
 #include "renderer/ModelRenderer.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptStats.h"
 #include "scriptinterface/ScriptConversions.h"
 #include "scriptinterface/ScriptRuntime.h"
 #include "simulation2/Simulation2.h"
 #include "lobby/IXmppClient.h"
 #include "soundmanager/scripting/JSInterface_Sound.h"
 #include "soundmanager/ISoundManager.h"
 #include "tools/atlas/GameInterface/GameLoop.h"
 #include "tools/atlas/GameInterface/View.h"
 
 #if !(OS_WIN || OS_MACOSX || OS_ANDROID) // assume all other platforms use X11 for wxWidgets
 #define MUST_INIT_X11 1
 #include <X11/Xlib.h>
 #else
 #define MUST_INIT_X11 0
 #endif
 
 extern void RestartEngine();
 
 #include <iostream>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
 
 ERROR_GROUP(System);
 ERROR_TYPE(System, SDLInitFailed);
 ERROR_TYPE(System, VmodeFailed);
 ERROR_TYPE(System, RequiredExtensionsMissing);
 
 bool g_DoRenderGui = true;
 bool g_DoRenderLogger = true;
 bool g_DoRenderCursor = true;
 
 shared_ptr<ScriptRuntime> g_ScriptRuntime;
 
 static const int SANE_TEX_QUALITY_DEFAULT = 5;	// keep in sync with code
 
 bool g_InDevelopmentCopy;
 bool g_CheckedIfInDevelopmentCopy = false;
 
 static void SetTextureQuality(int quality)
 {
 	int q_flags;
 	GLint filter;
 
 retry:
 	// keep this in sync with SANE_TEX_QUALITY_DEFAULT
 	switch(quality)
 	{
 		// worst quality
 	case 0:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST;
 		break;
 		// [perf] add bilinear filtering
 	case 1:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] no longer reduce resolution
 	case 2:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] add mipmaps
 	case 3:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST_MIPMAP_LINEAR;
 		break;
 		// [perf] better filtering
 	case 4:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [vmem] no longer reduce bpp
 	case SANE_TEX_QUALITY_DEFAULT:
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [perf] add anisotropy
 	case 6:
 		// TODO: add anisotropic filtering
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// invalid
 	default:
 		debug_warn(L"SetTextureQuality: invalid quality");
 		quality = SANE_TEX_QUALITY_DEFAULT;
 		// careful: recursion doesn't work and we don't want to duplicate
 		// the "sane" default values.
 		goto retry;
 	}
 
 	ogl_tex_set_defaults(q_flags, filter);
 }
 
 
 //----------------------------------------------------------------------------
 // GUI integration
 //----------------------------------------------------------------------------
 
 // display progress / description in loading screen
 void GUI_DisplayLoadProgress(int percent, const wchar_t* pending_task)
 {
-	g_GUI->GetActiveGUI()->GetScriptInterface()->SetGlobal("g_Progress", percent, true, false, true);
-	g_GUI->GetActiveGUI()->GetScriptInterface()->SetGlobal("g_LoadDescription", pending_task, true, false, true);
-	g_GUI->GetActiveGUI()->SendEventToAll("progress");
+	const ScriptInterface& scriptInterface = *(g_GUI->GetActiveGUI()->GetScriptInterface());
+	JSContext* cx = scriptInterface.GetContext();
+	JSAutoRequest rq(cx);
+
+	JS::AutoValueVector paramData(cx);
+
+	paramData.append(JS::NumberValue(percent));
+
+	JS::RootedValue valPendingTask(cx);
+	scriptInterface.ToJSVal(cx, &valPendingTask, pending_task);
+	paramData.append(valPendingTask);
+
+	g_GUI->GetActiveGUI()->SendEventToAll("GameLoadProgress", paramData);
 }
 
 void SwapBuffers()
 {
 	PROFILE3("swap buffers");
 	SDL_GL_SwapWindow(g_VideoMode.GetWindow());
 	ogl_WarnIfError();
 }
 
 void Render()
 {
 	// Do not render if not focused while in fullscreen or minimised,
 	// as that triggers a difficult-to-reproduce crash on some graphic cards.
 	if (g_app_minimized || (!g_app_has_focus && g_VideoMode.IsInFullscreen()))
 		return;
 
 	PROFILE3("render");
 
 	ogl_WarnIfError();
 
 	g_Profiler2.RecordGPUFrameStart();
 
 	ogl_WarnIfError();
 
 	// prepare before starting the renderer frame
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->BeginFrame();
 
 	if (g_Game)
 		g_Renderer.SetSimulation(g_Game->GetSimulation2());
 
 	// start new frame
 	g_Renderer.BeginFrame();
 
 	ogl_WarnIfError();
 
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->Render();
 
 	ogl_WarnIfError();
 
 	g_Renderer.RenderTextOverlays();
 
 	// If we're in Atlas game view, render special tools
 	if (g_AtlasGameLoop && g_AtlasGameLoop->view)
 	{
 		g_AtlasGameLoop->view->DrawCinemaPathTool();
 		ogl_WarnIfError();
 	}
 
 	if (g_Game && g_Game->IsGameStarted())
 		g_Game->GetView()->GetCinema()->Render();
 
 	ogl_WarnIfError();
 
 	if (g_DoRenderGui)
 		g_GUI->Draw();
 
 	ogl_WarnIfError();
 
 	// If we're in Atlas game view, render special overlays (e.g. editor bandbox)
 	if (g_AtlasGameLoop && g_AtlasGameLoop->view)
 	{
 		g_AtlasGameLoop->view->DrawOverlays();
 		ogl_WarnIfError();
 	}
 
 	// Text:
 
  	glDisable(GL_DEPTH_TEST);
 
 	g_Console->Render();
 
 	ogl_WarnIfError();
 
 	if (g_DoRenderLogger)
 		g_Logger->Render();
 
 	ogl_WarnIfError();
 
 	// Profile information
 
 	g_ProfileViewer.RenderProfile();
 
 	ogl_WarnIfError();
 
 	// Draw the cursor (or set the Windows cursor, on Windows)
 	if (g_DoRenderCursor)
 	{
 		PROFILE3_GPU("cursor");
 		CStrW cursorName = g_CursorName;
 		if (cursorName.empty())
 		{
 			cursor_draw(g_VFS, NULL, g_mouse_x, g_yres-g_mouse_y, g_GuiScale, false);
 		}
 		else
 		{
 			bool forceGL = false;
 			CFG_GET_VAL("nohwcursor", forceGL);
 
 #if CONFIG2_GLES
 #warning TODO: implement cursors for GLES
 #else
 			// set up transform for GL cursor
 			glMatrixMode(GL_PROJECTION);
 			glPushMatrix();
 			glLoadIdentity();
 			glMatrixMode(GL_MODELVIEW);
 			glPushMatrix();
 			glLoadIdentity();
 			CMatrix3D transform;
 			transform.SetOrtho(0.f, (float)g_xres, 0.f, (float)g_yres, -1.f, 1000.f);
 			glLoadMatrixf(&transform._11);
 #endif
 
 #if OS_ANDROID
 #warning TODO: cursors for Android
 #else
 			if (cursor_draw(g_VFS, cursorName.c_str(), g_mouse_x, g_yres-g_mouse_y, g_GuiScale, forceGL) < 0)
 				LOGWARNING("Failed to draw cursor '%s'", utf8_from_wstring(cursorName));
 #endif
 
 #if CONFIG2_GLES
 #warning TODO: implement cursors for GLES
 #else
 			// restore transform
 			glMatrixMode(GL_PROJECTION);
 			glPopMatrix();
 			glMatrixMode(GL_MODELVIEW);
 			glPopMatrix();
 #endif
 		}
 	}
 
 	glEnable(GL_DEPTH_TEST);
 
 	g_Renderer.EndFrame();
 
 	PROFILE2_ATTR("draw calls: %d", (int)g_Renderer.GetStats().m_DrawCalls);
 	PROFILE2_ATTR("terrain tris: %d", (int)g_Renderer.GetStats().m_TerrainTris);
 	PROFILE2_ATTR("water tris: %d", (int)g_Renderer.GetStats().m_WaterTris);
 	PROFILE2_ATTR("model tris: %d", (int)g_Renderer.GetStats().m_ModelTris);
 	PROFILE2_ATTR("overlay tris: %d", (int)g_Renderer.GetStats().m_OverlayTris);
 	PROFILE2_ATTR("blend splats: %d", (int)g_Renderer.GetStats().m_BlendSplats);
 	PROFILE2_ATTR("particles: %d", (int)g_Renderer.GetStats().m_Particles);
 
 	ogl_WarnIfError();
 
 	g_Profiler2.RecordGPUFrameEnd();
 
 	ogl_WarnIfError();
 
 	SwapBuffers();
 }
 
 ErrorReactionInternal psDisplayError(const wchar_t* UNUSED(text), size_t UNUSED(flags))
 {
 	// If we're fullscreen, then sometimes (at least on some particular drivers on Linux)
 	// displaying the error dialog hangs the desktop since the dialog box is behind the
 	// fullscreen window. So we just force the game to windowed mode before displaying the dialog.
 	// (But only if we're in the main thread, and not if we're being reentrant.)
 	if (ThreadUtil::IsMainThread())
 	{
 		static bool reentering = false;
 		if (!reentering)
 		{
 			reentering = true;
 			g_VideoMode.SetFullscreen(false);
 			reentering = false;
 		}
 	}
 
 	// We don't actually implement the error display here, so return appropriately
 	return ERI_NOT_IMPLEMENTED;
 }
 
 const std::vector<CStr>& GetMods(const CmdLineArgs& args, int flags)
 {
 	const bool init_mods = (flags & INIT_MODS) == INIT_MODS;
 	const bool add_user = !InDevelopmentCopy() && !args.Has("noUserMod");
 	const bool add_public = (flags & INIT_MODS_PUBLIC) == INIT_MODS_PUBLIC;
 
 	if (!init_mods)
 	{
 		// Add the user mod if it should be present
 		if (add_user && (g_modsLoaded.empty() || g_modsLoaded.back() != "user"))
 			g_modsLoaded.push_back("user");
 
 		return g_modsLoaded;
 	}
 
 	g_modsLoaded = args.GetMultiple("mod");
 
 	if (add_public)
 		g_modsLoaded.insert(g_modsLoaded.begin(), "public");
 
 	g_modsLoaded.insert(g_modsLoaded.begin(), "mod");
 
 	// Add the user mod if not explicitly disabled or we have a dev copy so
 	// that saved files end up in version control and not in the user mod.
 	if (add_user)
 		g_modsLoaded.push_back("user");
 
 	return g_modsLoaded;
 }
 
 void MountMods(const Paths& paths, const std::vector<CStr>& mods)
 {
 	OsPath modPath = paths.RData()/"mods";
 	OsPath modUserPath = paths.UserData()/"mods";
 	for (size_t i = 0; i < mods.size(); ++i)
 	{
 		size_t priority = (i+1)*2;	// mods are higher priority than regular mountings, which default to priority 0
 		size_t userFlags = VFS_MOUNT_WATCH|VFS_MOUNT_ARCHIVABLE|VFS_MOUNT_REPLACEABLE;
 		size_t baseFlags = userFlags|VFS_MOUNT_MUST_EXIST;
 
 		OsPath modName(mods[i]);
 		if (InDevelopmentCopy())
 		{
 			// We are running a dev copy, so only mount mods in the user mod path
 			// if the mod does not exist in the data path.
 			if (DirectoryExists(modPath / modName/""))
 				g_VFS->Mount(L"", modPath / modName/"", baseFlags, priority);
 			else
 				g_VFS->Mount(L"", modUserPath / modName/"", userFlags, priority);
 		}
 		else
 		{
 			g_VFS->Mount(L"", modPath / modName/"", baseFlags, priority);
 			// Ensure that user modified files are loaded, if they are present
 			g_VFS->Mount(L"", modUserPath / modName/"", userFlags, priority+1);
 		}
 	}
 }
 
 static void InitVfs(const CmdLineArgs& args, int flags)
 {
 	TIMER(L"InitVfs");
 
 	const bool setup_error = (flags & INIT_HAVE_DISPLAY_ERROR) == 0;
 
 	const Paths paths(args);
 
 	OsPath logs(paths.Logs());
 	CreateDirectories(logs, 0700);
 
 	psSetLogDir(logs);
 	// desired location for crashlog is now known. update AppHooks ASAP
 	// (particularly before the following error-prone operations):
 	AppHooks hooks = {0};
 	hooks.bundle_logs = psBundleLogs;
 	hooks.get_log_dir = psLogDir;
 	if (setup_error)
 		hooks.display_error = psDisplayError;
 	app_hooks_update(&hooks);
 
 	g_VFS = CreateVfs();
 
 	const OsPath readonlyConfig = paths.RData()/"config"/"";
 	g_VFS->Mount(L"config/", readonlyConfig);
 
 	// Engine localization files.
 	g_VFS->Mount(L"l10n/", paths.RData()/"l10n"/"");
 
 	MountMods(paths, GetMods(args, flags));
 
 	// We mount these dirs last as otherwise writing could result in files being placed in a mod's dir.
 	g_VFS->Mount(L"screenshots/", paths.UserData()/"screenshots"/"");
 	g_VFS->Mount(L"saves/", paths.UserData()/"saves"/"", VFS_MOUNT_WATCH);
 	// Mounting with highest priority, so that a mod supplied user.cfg is harmless
 	g_VFS->Mount(L"config/", readonlyConfig, 0, (size_t)-1);
 	if(readonlyConfig != paths.Config())
 		g_VFS->Mount(L"config/", paths.Config(), 0, (size_t)-1);
 
 	g_VFS->Mount(L"cache/", paths.Cache(), VFS_MOUNT_ARCHIVABLE);	// (adding XMBs to archive speeds up subsequent reads)
 
 	// note: don't bother with g_VFS->TextRepresentation - directories
 	// haven't yet been populated and are empty.
 }
 
 
 static void InitPs(bool setup_gui, const CStrW& gui_page, ScriptInterface* srcScriptInterface, JS::HandleValue initData)
 {
 	{
 		// console
 		TIMER(L"ps_console");
 
 		g_Console->UpdateScreenSize(g_xres, g_yres);
 
 		// Calculate and store the line spacing
 		CFontMetrics font(CStrIntern(CONSOLE_FONT));
 		g_Console->m_iFontHeight = font.GetLineSpacing();
 		g_Console->m_iFontWidth = font.GetCharacterWidth(L'C');
 		g_Console->m_charsPerPage = (size_t)(g_xres / g_Console->m_iFontWidth);
 		// Offset by an arbitrary amount, to make it fit more nicely
 		g_Console->m_iFontOffset = 7;
 
 		double blinkRate = 0.5;
 		CFG_GET_VAL("gui.cursorblinkrate", blinkRate);
 		g_Console->SetCursorBlinkRate(blinkRate);
 	}
 
 	// hotkeys
 	{
 		TIMER(L"ps_lang_hotkeys");
 		LoadHotkeys();
 	}
 
 	if (!setup_gui)
 	{
 		// We do actually need *some* kind of GUI loaded, so use the
 		// (currently empty) Atlas one
 		g_GUI->SwitchPage(L"page_atlas.xml", srcScriptInterface, initData);
 		return;
 	}
 
 	// GUI uses VFS, so this must come after VFS init.
 	g_GUI->SwitchPage(gui_page, srcScriptInterface, initData);
 }
 
 void InitPsAutostart(bool networked, JS::HandleValue attrs)
 {
 	// The GUI has not been initialized yet, so use the simulation scriptinterface for this variable
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue playerAssignments(cx);
 	scriptInterface.Eval("({})", &playerAssignments);
 
 	if (!networked)
 	{
 		JS::RootedValue localPlayer(cx);
 		scriptInterface.Eval("({})", &localPlayer);
 		scriptInterface.SetProperty(localPlayer, "player", g_Game->GetPlayerID());
 		scriptInterface.SetProperty(playerAssignments, "local", localPlayer);
 	}
 
 	JS::RootedValue sessionInitData(cx);
 	scriptInterface.Eval("({})", &sessionInitData);
 	scriptInterface.SetProperty(sessionInitData, "attribs", attrs);
 	scriptInterface.SetProperty(sessionInitData, "playerAssignments", playerAssignments);
 
 	InitPs(true, L"page_loading.xml", &scriptInterface, sessionInitData);
 }
 
 
 static void InitInput()
 {
 	g_Joystick.Initialise();
 
 	// register input handlers
 	// This stack is constructed so the first added, will be the last
 	//  one called. This is important, because each of the handlers
 	//  has the potential to block events to go further down
 	//  in the chain. I.e. the last one in the list added, is the
 	//  only handler that can block all messages before they are
 	//  processed.
 	in_add_handler(game_view_handler);
 
 	in_add_handler(CProfileViewer::InputThunk);
 
 	in_add_handler(conInputHandler);
 
 	in_add_handler(HotkeyInputHandler);
 
 	// gui_handler needs to be registered after (i.e. called before!) the
 	// hotkey handler so that input boxes can be typed in without
 	// setting off hotkeys.
 	in_add_handler(gui_handler);
 
 	in_add_handler(touch_input_handler);
 
 	// must be registered after (called before) the GUI which relies on these globals
 	in_add_handler(GlobalsInputHandler);
 }
 
 
 static void ShutdownPs()
 {
 	SAFE_DELETE(g_GUI);
 
 	UnloadHotkeys();
 
 	// disable the special Windows cursor, or free textures for OGL cursors
 	cursor_draw(g_VFS, 0, g_mouse_x, g_yres-g_mouse_y, 1.0, false);
 }
 
 
 static void InitRenderer()
 {
 	TIMER(L"InitRenderer");
 
 	if(g_NoGLS3TC)
 		ogl_tex_override(OGL_TEX_S3TC, OGL_TEX_DISABLE);
 	if(g_NoGLAutoMipmap)
 		ogl_tex_override(OGL_TEX_AUTO_MIPMAP_GEN, OGL_TEX_DISABLE);
 
 	// create renderer
 	new CRenderer;
 
 	// set renderer options from command line options - NOVBO must be set before opening the renderer
 	// and init them in the ConfigDB when needed
 	g_Renderer.SetOptionBool(CRenderer::OPT_NOVBO, g_NoGLVBO);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWS, g_Shadows);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "shadows", g_Shadows);
 
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATEREFFECTS, g_WaterEffects);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "watereffects", g_WaterEffects);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERFANCYEFFECTS, g_WaterFancyEffects);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterfancyeffects", g_WaterFancyEffects);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERREALDEPTH, g_WaterRealDepth);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterrealdepth", g_WaterRealDepth);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERREFLECTION, g_WaterReflection);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterreflection", g_WaterReflection);
 	g_Renderer.SetOptionBool(CRenderer::OPT_WATERREFRACTION, g_WaterRefraction);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterrefraction", g_WaterRefraction);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWSONWATER, g_WaterShadows);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "watershadows", g_WaterShadows);
 
 	g_Renderer.SetRenderPath(CRenderer::GetRenderPathByName(g_RenderPath));
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWPCF, g_ShadowPCF);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "shadowpcf", g_ShadowPCF);
 	g_Renderer.SetOptionBool(CRenderer::OPT_PARTICLES, g_Particles);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "particles", g_Particles);
 	g_Renderer.SetOptionBool(CRenderer::OPT_FOG, g_Fog);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "fog", g_Fog);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SILHOUETTES, g_Silhouettes);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "silhouettes", g_Silhouettes);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHOWSKY, g_ShowSky);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "showsky", g_ShowSky);
 	g_Renderer.SetOptionBool(CRenderer::OPT_PREFERGLSL, g_PreferGLSL);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "preferglsl", g_PreferGLSL);
 	g_Renderer.SetOptionBool(CRenderer::OPT_POSTPROC, g_PostProc);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "postproc", g_PostProc);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SMOOTHLOS, g_SmoothLOS);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "smoothlos", g_SmoothLOS);
 
 	// create terrain related stuff
 	new CTerrainTextureManager;
 
 	g_Renderer.Open(g_xres, g_yres);
 
 	// Setup lighting environment. Since the Renderer accesses the
 	// lighting environment through a pointer, this has to be done before
 	// the first Frame.
 	g_Renderer.SetLightEnv(&g_LightEnv);
 
 	// I haven't seen the camera affecting GUI rendering and such, but the
 	// viewport has to be updated according to the video mode
 	SViewPort vp;
 	vp.m_X = 0;
 	vp.m_Y = 0;
 	vp.m_Width = g_xres;
 	vp.m_Height = g_yres;
 	g_Renderer.SetViewport(vp);
 
 	ColorActivateFastImpl();
 	ModelRenderer::Init();
 }
 
 static void InitSDL()
 {
 #if OS_LINUX
 	// In fullscreen mode when SDL is compiled with DGA support, the mouse
 	// sensitivity often appears to be unusably wrong (typically too low).
 	// (This seems to be reported almost exclusively on Ubuntu, but can be
 	// reproduced on Gentoo after explicitly enabling DGA.)
 	// Disabling the DGA mouse appears to fix that problem, and doesn't
 	// have any obvious negative effects.
 	setenv("SDL_VIDEO_X11_DGAMOUSE", "0", 0);
 #endif
 
 	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) < 0)
 	{
 		LOGERROR("SDL library initialization failed: %s", SDL_GetError());
 		throw PSERROR_System_SDLInitFailed();
 	}
 	atexit(SDL_Quit);
 
 	// Text input is active by default, disable it until it is actually needed.
 	SDL_StopTextInput();
 
 #if OS_MACOSX
 	// Some Mac mice only have one button, so they can't right-click
 	// but SDL2 can emulate that with Ctrl+Click
 	bool macMouse = false;
 	CFG_GET_VAL("macmouse", macMouse);
 	SDL_SetHint(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, macMouse ? "1" : "0");
 #endif
 }
 
 static void ShutdownSDL()
 {
 	SDL_Quit();
 	sys_cursor_reset();
 }
 
 
 void EndGame()
 {
 	const bool nonVisual = g_Game && g_Game->IsGraphicsDisabled();
 
 	if (g_Game && g_Game->IsGameStarted() && !g_Game->IsVisualReplay() &&
 	    g_AtlasGameLoop && !g_AtlasGameLoop->running && !nonVisual)
 		VisualReplay::SaveReplayMetadata(g_GUI->GetActiveGUI()->GetScriptInterface().get());
 
 	SAFE_DELETE(g_NetClient);
 	SAFE_DELETE(g_NetServer);
 	SAFE_DELETE(g_Game);
 
 	if (!nonVisual)
 	{
 		ISoundManager::CloseGame();
 		g_Renderer.ResetState();
 	}
 }
 
 void Shutdown(int flags)
 {
 	const bool nonVisual = g_Game && g_Game->IsGraphicsDisabled();
 
 	if ((flags & SHUTDOWN_FROM_CONFIG))
 		goto from_config;
 
 	EndGame();
 
 	SAFE_DELETE(g_XmppClient);
 
 	SAFE_DELETE(g_ModIo);
 
 	ShutdownPs();
 
 	TIMER_BEGIN(L"shutdown TexMan");
 	delete &g_TexMan;
 	TIMER_END(L"shutdown TexMan");
 
 	// destroy renderer if it was initialised
 	if (!nonVisual)
 	{
 		TIMER_BEGIN(L"shutdown Renderer");
 		delete &g_Renderer;
 		g_VBMan.Shutdown();
 		TIMER_END(L"shutdown Renderer");
 	}
 
 	g_Profiler2.ShutdownGPU();
 
 	// Free cursors before shutting down SDL, as they may depend on SDL.
 	cursor_shutdown();
 
 	TIMER_BEGIN(L"shutdown SDL");
 	ShutdownSDL();
 	TIMER_END(L"shutdown SDL");
 
 	if (!nonVisual)
 		g_VideoMode.Shutdown();
 
 	TIMER_BEGIN(L"shutdown UserReporter");
 	g_UserReporter.Deinitialize();
 	TIMER_END(L"shutdown UserReporter");
 
 	// Cleanup curl now that g_ModIo and g_UserReporter have been shutdown.
 	curl_global_cleanup();
 
 	delete &g_L10n;
 
 from_config:
 	TIMER_BEGIN(L"shutdown ConfigDB");
 	delete &g_ConfigDB;
 	TIMER_END(L"shutdown ConfigDB");
 
 	SAFE_DELETE(g_Console);
 
 	// This is needed to ensure that no callbacks from the JSAPI try to use
 	// the profiler when it's already destructed
 	g_ScriptRuntime.reset();
 
 	// resource
 	// first shut down all resource owners, and then the handle manager.
 	TIMER_BEGIN(L"resource modules");
 
 		ISoundManager::SetEnabled(false);
 
 		g_VFS.reset();
 
 		// this forcibly frees all open handles (thus preventing real leaks),
 		// and makes further access to h_mgr impossible.
 		h_mgr_shutdown();
 
 		file_stats_dump();
 
 	TIMER_END(L"resource modules");
 
 	TIMER_BEGIN(L"shutdown misc");
 		timer_DisplayClientTotals();
 
 		CNetHost::Deinitialize();
 
 		// should be last, since the above use them
 		SAFE_DELETE(g_Logger);
 		delete &g_Profiler;
 		delete &g_ProfileViewer;
 
 		SAFE_DELETE(g_ScriptStatsTable);
 	TIMER_END(L"shutdown misc");
 }
 
 #if OS_UNIX
 static void FixLocales()
 {
 #if OS_MACOSX || OS_BSD
 	// OS X requires a UTF-8 locale in LC_CTYPE so that *wprintf can handle
 	// wide characters. Peculiarly the string "UTF-8" seems to be acceptable
 	// despite not being a real locale, and it's conveniently language-agnostic,
 	// so use that.
 	setlocale(LC_CTYPE, "UTF-8");
 #endif
 
 
 	// On misconfigured systems with incorrect locale settings, we'll die
 	// with a C++ exception when some code (e.g. Boost) tries to use locales.
 	// To avoid death, we'll detect the problem here and warn the user and
 	// reset to the default C locale.
 
 
 	// For informing the user of the problem, use the list of env vars that
 	// glibc setlocale looks at. (LC_ALL is checked first, and LANG last.)
 	const char* const LocaleEnvVars[] = {
 		"LC_ALL",
 		"LC_COLLATE",
 		"LC_CTYPE",
 		"LC_MONETARY",
 		"LC_NUMERIC",
 		"LC_TIME",
 		"LC_MESSAGES",
 		"LANG"
 	};
 
 	try
 	{
 		// this constructor is similar to setlocale(LC_ALL, ""),
 		// but instead of returning NULL, it throws runtime_error
 		// when the first locale env variable found contains an invalid value
 		std::locale("");
 	}
 	catch (std::runtime_error&)
 	{
 		LOGWARNING("Invalid locale settings");
 
 		for (size_t i = 0; i < ARRAY_SIZE(LocaleEnvVars); i++)
 		{
 			if (char* envval = getenv(LocaleEnvVars[i]))
 				LOGWARNING("  %s=\"%s\"", LocaleEnvVars[i], envval);
 			else
 				LOGWARNING("  %s=\"(unset)\"", LocaleEnvVars[i]);
 		}
 
 		// We should set LC_ALL since it overrides LANG
 		if (setenv("LC_ALL", std::locale::classic().name().c_str(), 1))
 			debug_warn(L"Invalid locale settings, and unable to set LC_ALL env variable.");
 		else
 			LOGWARNING("Setting LC_ALL env variable to: %s", getenv("LC_ALL"));
 	}
 }
 #else
 static void FixLocales()
 {
 	// Do nothing on Windows
 }
 #endif
 
 void EarlyInit()
 {
 	// If you ever want to catch a particular allocation:
 	//_CrtSetBreakAlloc(232647);
 
 	ThreadUtil::SetMainThread();
 
 	debug_SetThreadName("main");
 	// add all debug_printf "tags" that we are interested in:
 	debug_filter_add("TIMER");
 
 	timer_LatchStartTime();
 
 	// initialise profiler early so it can profile startup,
 	// but only after LatchStartTime
 	g_Profiler2.Initialise();
 
 	FixLocales();
 
 	// Because we do GL calls from a secondary thread, Xlib needs to
 	// be told to support multiple threads safely.
 	// This is needed for Atlas, but we have to call it before any other
 	// Xlib functions (e.g. the ones used when drawing the main menu
 	// before launching Atlas)
 #if MUST_INIT_X11
 	int status = XInitThreads();
 	if (status == 0)
 		debug_printf("Error enabling thread-safety via XInitThreads\n");
 #endif
 
 	// Initialise the low-quality rand function
 	srand(time(NULL));	// NOTE: this rand should *not* be used for simulation!
 }
 
 bool Autostart(const CmdLineArgs& args);
 
 /**
  * Returns true if the user has intended to start a visual replay from command line.
  */
 bool AutostartVisualReplay(const std::string& replayFile);
 
 bool Init(const CmdLineArgs& args, int flags)
 {
 	h_mgr_init();
 
 	// Do this as soon as possible, because it chdirs
 	// and will mess up the error reporting if anything
 	// crashes before the working directory is set.
 	InitVfs(args, flags);
 
 	// This must come after VFS init, which sets the current directory
 	// (required for finding our output log files).
 	g_Logger = new CLogger;
 
 	new CProfileViewer;
 	new CProfileManager;	// before any script code
 
 	g_ScriptStatsTable = new CScriptStatsTable;
 	g_ProfileViewer.AddRootTable(g_ScriptStatsTable);
 
 	// Set up the console early, so that debugging
 	// messages can be logged to it. (The console's size
 	// and fonts are set later in InitPs())
 	g_Console = new CConsole();
 
 	// g_ConfigDB, command line args, globals
 	CONFIG_Init(args);
 
 	// Using a global object for the runtime is a workaround until Simulation and AI use
 	// their own threads and also their own runtimes.
 	const int runtimeSize = 384 * 1024 * 1024;
 	const int heapGrowthBytesGCTrigger = 20 * 1024 * 1024;
 	g_ScriptRuntime = ScriptInterface::CreateRuntime(shared_ptr<ScriptRuntime>(), runtimeSize, heapGrowthBytesGCTrigger);
 
 	Mod::CacheEnabledModVersions(g_ScriptRuntime);
 
 	// Special command-line mode to dump the entity schemas instead of running the game.
 	// (This must be done after loading VFS etc, but should be done before wasting time
 	// on anything else.)
 	if (args.Has("dumpSchema"))
 	{
 		CSimulation2 sim(NULL, g_ScriptRuntime, NULL);
 		sim.LoadDefaultScripts();
 		std::ofstream f("entity.rng", std::ios_base::out | std::ios_base::trunc);
 		f << sim.GenerateSchema();
 		std::cout << "Generated entity.rng\n";
 		exit(0);
 	}
 
 	CNetHost::Initialize();
 
 #if CONFIG2_AUDIO
 	if (!args.Has("autostart-nonvisual"))
 		ISoundManager::CreateSoundManager();
 #endif
 
 	// Check if there are mods specified on the command line,
 	// or if we already set the mods (~INIT_MODS),
 	// else check if there are mods that should be loaded specified
 	// in the config and load those (by aborting init and restarting
 	// the engine).
 	if (!args.Has("mod") && (flags & INIT_MODS) == INIT_MODS)
 	{
 		CStr modstring;
 		CFG_GET_VAL("mod.enabledmods", modstring);
 		if (!modstring.empty())
 		{
 			std::vector<CStr> mods;
 			boost::split(mods, modstring, boost::is_any_of(" "), boost::token_compress_on);
 			std::swap(g_modsLoaded, mods);
 
 			// Abort init and restart
 			RestartEngine();
 			return false;
 		}
 	}
 
 	new L10n;
 
 	// Optionally start profiler HTTP output automatically
 	// (By default it's only enabled by a hotkey, for security/performance)
 	bool profilerHTTPEnable = false;
 	CFG_GET_VAL("profiler2.autoenable", profilerHTTPEnable);
 	if (profilerHTTPEnable)
 		g_Profiler2.EnableHTTP();
 
 	// Initialise everything except Win32 sockets (because our networking
 	// system already inits those)
 	curl_global_init(CURL_GLOBAL_ALL & ~CURL_GLOBAL_WIN32);
 
 	if (!g_Quickstart)
 		g_UserReporter.Initialize(); // after config
 
 	PROFILE2_EVENT("Init finished");
 	return true;
 }
 
 void InitGraphics(const CmdLineArgs& args, int flags, const std::vector<CStr>& installedMods)
 {
 	const bool setup_vmode = (flags & INIT_HAVE_VMODE) == 0;
 
 	if(setup_vmode)
 	{
 		InitSDL();
 
 		if (!g_VideoMode.InitSDL())
 			throw PSERROR_System_VmodeFailed(); // abort startup
 	}
 
 	RunHardwareDetection();
 
 	const int quality = SANE_TEX_QUALITY_DEFAULT;	// TODO: set value from config file
 	SetTextureQuality(quality);
 
 	ogl_WarnIfError();
 
 	// Optionally start profiler GPU timings automatically
 	// (By default it's only enabled by a hotkey, for performance/compatibility)
 	bool profilerGPUEnable = false;
 	CFG_GET_VAL("profiler2.autoenable", profilerGPUEnable);
 	if (profilerGPUEnable)
 		g_Profiler2.EnableGPU();
 
 	if(!g_Quickstart)
 	{
 		WriteSystemInfo();
 		// note: no longer vfs_display here. it's dog-slow due to unbuffered
 		// file output and very rarely needed.
 	}
 
 	if(g_DisableAudio)
 		ISoundManager::SetEnabled(false);
 
 	g_GUI = new CGUIManager();
 
 	// (must come after SetVideoMode, since it calls ogl_Init)
 	if (ogl_HaveExtensions(0, "GL_ARB_vertex_program", "GL_ARB_fragment_program", NULL) != 0 // ARB
 		&& ogl_HaveExtensions(0, "GL_ARB_vertex_shader", "GL_ARB_fragment_shader", NULL) != 0) // GLSL
 	{
 		DEBUG_DISPLAY_ERROR(
 			L"Your graphics card doesn't appear to be fully compatible with OpenGL shaders."
 			L" In the future, the game will not support pre-shader graphics cards."
 			L" You are advised to try installing newer drivers and/or upgrade your graphics card."
 			L" For more information, please see http://www.wildfiregames.com/forum/index.php?showtopic=16734"
 		);
 		// TODO: actually quit once fixed function support is dropped
 	}
 
 	const char* missing = ogl_HaveExtensions(0,
 		"GL_ARB_multitexture",
 		"GL_EXT_draw_range_elements",
 		"GL_ARB_texture_env_combine",
 		"GL_ARB_texture_env_dot3",
 		NULL);
 	if(missing)
 	{
 		wchar_t buf[500];
 		swprintf_s(buf, ARRAY_SIZE(buf),
 			L"The %hs extension doesn't appear to be available on your computer."
 			L" The game may still work, though - you are welcome to try at your own risk."
 			L" If not or it doesn't look right, upgrade your graphics card.",
 			missing
 		);
 		DEBUG_DISPLAY_ERROR(buf);
 		// TODO: i18n
 	}
 
 	if (!ogl_HaveExtension("GL_ARB_texture_env_crossbar"))
 	{
 		DEBUG_DISPLAY_ERROR(
 			L"The GL_ARB_texture_env_crossbar extension doesn't appear to be available on your computer."
 			L" Shadows are not available and overall graphics quality might suffer."
 			L" You are advised to try installing newer drivers and/or upgrade your graphics card.");
 		g_Shadows = false;
 	}
 
 	ogl_WarnIfError();
 	InitRenderer();
 
 	InitInput();
 
 	ogl_WarnIfError();
 
 	// TODO: Is this the best place for this?
 	if (VfsDirectoryExists(L"maps/"))
 		CXeromyces::AddValidator(g_VFS, "map", "maps/scenario.rng");
 
 	try
 	{
 		if (!AutostartVisualReplay(args.Get("replay-visual")) && !Autostart(args))
 		{
 			const bool setup_gui = ((flags & INIT_NO_GUI) == 0);
 			// We only want to display the splash screen at startup
 			shared_ptr<ScriptInterface> scriptInterface = g_GUI->GetScriptInterface();
 			JSContext* cx = scriptInterface->GetContext();
 			JSAutoRequest rq(cx);
 			JS::RootedValue data(cx);
 			if (g_GUI)
 			{
 				scriptInterface->Eval("({})", &data);
 				scriptInterface->SetProperty(data, "isStartup", true);
 				if (!installedMods.empty())
 					scriptInterface->SetProperty(data, "installedMods", installedMods);
 			}
 			InitPs(setup_gui, installedMods.empty() ? L"page_pregame.xml" : L"page_modmod.xml", g_GUI->GetScriptInterface().get(), data);
 		}
 	}
 	catch (PSERROR_Game_World_MapLoadFailed& e)
 	{
 		// Map Loading failed
 
 		// Start the engine so we have a GUI
 		InitPs(true, L"page_pregame.xml", NULL, JS::UndefinedHandleValue);
 
 		// Call script function to do the actual work
 		//	(delete game data, switch GUI page, show error, etc.)
 		CancelLoad(CStr(e.what()).FromUTF8());
 	}
 }
 
 void InitNonVisual(const CmdLineArgs& args)
 {
 	// Need some stuff for terrain movement costs:
 	// (TODO: this ought to be independent of any graphics code)
 	new CTerrainTextureManager;
 	g_TexMan.LoadTerrainTextures();
 	Autostart(args);
 }
 
 void RenderGui(bool RenderingState)
 {
 	g_DoRenderGui = RenderingState;
 }
 
 void RenderLogger(bool RenderingState)
 {
 	g_DoRenderLogger = RenderingState;
 }
 
 void RenderCursor(bool RenderingState)
 {
 	g_DoRenderCursor = RenderingState;
 }
 
 /**
  * Temporarily loads a scenario map and retrieves the "ScriptSettings" JSON
  * data from it.
  * The scenario map format is used for scenario and skirmish map types (random
  * games do not use a "map" (format) but a small JavaScript program which
  * creates a map on the fly). It contains a section to initialize the game
  * setup screen.
  * @param mapPath Absolute path (from VFS root) to the map file to peek in.
  * @return ScriptSettings in JSON format extracted from the map.
  */
 CStr8 LoadSettingsOfScenarioMap(const VfsPath &mapPath)
 {
 	CXeromyces mapFile;
 	const char *pathToSettings[] =
 	{
 		"Scenario", "ScriptSettings", ""	// Path to JSON data in map
 	};
 
 	Status loadResult = mapFile.Load(g_VFS, mapPath);
 
 	if (INFO::OK != loadResult)
 	{
 		LOGERROR("LoadSettingsOfScenarioMap: Unable to load map file '%s'", mapPath.string8());
 		throw PSERROR_Game_World_MapLoadFailed("Unable to load map file, check the path for typos.");
 	}
 	XMBElement mapElement = mapFile.GetRoot();
 
 	// Select the ScriptSettings node in the map file...
 	for (int i = 0; pathToSettings[i][0]; ++i)
 	{
 		int childId = mapFile.GetElementID(pathToSettings[i]);
 
 		XMBElementList nodes = mapElement.GetChildNodes();
 		auto it = std::find_if(nodes.begin(), nodes.end(), [&childId](const XMBElement& child) {
 			return child.GetNodeName() == childId;
 		});
 
 		if (it != nodes.end())
 			mapElement = *it;
 	}
 	// ... they contain a JSON document to initialize the game setup
 	// screen
 	return mapElement.GetText();
 }
 
 /*
  * Command line options for autostart
  * (keep synchronized with binaries/system/readme.txt):
  *
  * -autostart="TYPEDIR/MAPNAME"    enables autostart and sets MAPNAME;
  *                                 TYPEDIR is skirmishes, scenarios, or random
  * -autostart-seed=SEED            sets randomization seed value (default 0, use -1 for random)
  * -autostart-ai=PLAYER:AI         sets the AI for PLAYER (e.g. 2:petra)
  * -autostart-aidiff=PLAYER:DIFF   sets the DIFFiculty of PLAYER's AI
  *                                 (0: sandbox, 5: very hard)
  * -autostart-aiseed=AISEED        sets the seed used for the AI random
  *                                 generator (default 0, use -1 for random)
  * -autostart-player=NUMBER        sets the playerID in non-networked games (default 1, use -1 for observer)
  * -autostart-civ=PLAYER:CIV       sets PLAYER's civilisation to CIV
  *                                 (skirmish and random maps only)
  * -autostart-team=PLAYER:TEAM     sets the team for PLAYER (e.g. 2:2).
  * -autostart-ceasefire=NUM        sets a ceasefire duration NUM
  *                                 (default 0 minutes)
  * -autostart-nonvisual            disable any graphics and sounds
  * -autostart-victory=SCRIPTNAME   sets the victory conditions with SCRIPTNAME
  *                                 located in simulation/data/settings/victory_conditions/
  *                                 (default conquest). When the first given SCRIPTNAME is 
  *                                 "endless", no victory conditions will apply.
  * -autostart-wonderduration=NUM   sets the victory duration NUM for wonder victory condition
  *                                 (default 10 minutes)
  * -autostart-relicduration=NUM    sets the victory duration NUM for relic victory condition
  *                                 (default 10 minutes)
  * -autostart-reliccount=NUM       sets the number of relics for relic victory condition
  *                                 (default 2 relics)
  * -autostart-disable-replay       disable saving of replays
  *
  * Multiplayer:
  * -autostart-playername=NAME      sets local player NAME (default 'anonymous')
  * -autostart-host                 sets multiplayer host mode
  * -autostart-host-players=NUMBER  sets NUMBER of human players for multiplayer
  *                                 game (default 2)
  * -autostart-client=IP            sets multiplayer client to join host at
  *                                 given IP address
  * Random maps only:
  * -autostart-size=TILES           sets random map size in TILES (default 192)
  * -autostart-players=NUMBER       sets NUMBER of players on random map
  *                                 (default 2)
  *
  * Examples:
  * 1) "Bob" will host a 2 player game on the Arcadia map:
  * -autostart="scenarios/Arcadia" -autostart-host -autostart-host-players=2 -autostart-playername="Bob"
  *  "Alice" joins the match as player 2:
  * -autostart="scenarios/Arcadia" -autostart-client=127.0.0.1 -autostart-playername="Alice"
  * The players use the developer overlay to control players.
  *
  * 2) Load Alpine Lakes random map with random seed, 2 players (Athens and Britons), and player 2 is PetraBot:
  * -autostart="random/alpine_lakes" -autostart-seed=-1 -autostart-players=2 -autostart-civ=1:athen -autostart-civ=2:brit -autostart-ai=2:petra
  *
  * 3) Observe the PetraBot on a triggerscript map:
  * -autostart="random/jebel_barkal" -autostart-seed=-1 -autostart-players=2 -autostart-civ=1:athen -autostart-civ=2:brit -autostart-ai=1:petra -autostart-ai=2:petra -autostart-player=-1
  */
 bool Autostart(const CmdLineArgs& args)
 {
 	CStr autoStartName = args.Get("autostart");
 
 	if (autoStartName.empty())
 		return false;
 
 	const bool nonVisual = args.Has("autostart-nonvisual");
 	g_Game = new CGame(nonVisual, !args.Has("autostart-disable-replay"));
 
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue attrs(cx);
 	scriptInterface.Eval("({})", &attrs);
 	JS::RootedValue settings(cx);
 	scriptInterface.Eval("({})", &settings);
 	JS::RootedValue playerData(cx);
 	scriptInterface.Eval("([])", &playerData);
 
 	// The directory in front of the actual map name indicates which type
 	// of map is being loaded. Drawback of this approach is the association
 	// of map types and folders is hard-coded, but benefits are:
 	// - No need to pass the map type via command line separately
 	// - Prevents mixing up of scenarios and skirmish maps to some degree
 	Path mapPath = Path(autoStartName);
 	std::wstring mapDirectory = mapPath.Parent().Filename().string();
 	std::string mapType;
 
 	if (mapDirectory == L"random")
 	{
 		// Random map definition will be loaded from JSON file, so we need to parse it
 		std::wstring scriptPath = L"maps/" + autoStartName.FromUTF8() + L".json";
 		JS::RootedValue scriptData(cx);
 		scriptInterface.ReadJSONFile(scriptPath, &scriptData);
 		if (!scriptData.isUndefined() && scriptInterface.GetProperty(scriptData, "settings", &settings))
 		{
 			// JSON loaded ok - copy script name over to game attributes
 			std::wstring scriptFile;
 			scriptInterface.GetProperty(settings, "Script", scriptFile);
 			scriptInterface.SetProperty(attrs, "script", scriptFile);				// RMS filename
 		}
 		else
 		{
 			// Problem with JSON file
 			LOGERROR("Autostart: Error reading random map script '%s'", utf8_from_wstring(scriptPath));
 			throw PSERROR_Game_World_MapLoadFailed("Error reading random map script.\nCheck application log for details.");
 		}
 
 		// Get optional map size argument (default 192)
 		uint mapSize = 192;
 		if (args.Has("autostart-size"))
 		{
 			CStr size = args.Get("autostart-size");
 			mapSize = size.ToUInt();
 		}
 
 		scriptInterface.SetProperty(settings, "Size", mapSize);		// Random map size (in patches)
 
 		// Get optional number of players (default 2)
 		size_t numPlayers = 2;
 		if (args.Has("autostart-players"))
 		{
 			CStr num = args.Get("autostart-players");
 			numPlayers = num.ToUInt();
 		}
 
 		// Set up player data
 		for (size_t i = 0; i < numPlayers; ++i)
 		{
 			JS::RootedValue player(cx);
 			scriptInterface.Eval("({})", &player);
 
 			// We could load player_defaults.json here, but that would complicate the logic
 			// even more and autostart is only intended for developers anyway
 			scriptInterface.SetProperty(player, "Civ", std::string("athen"));
 			scriptInterface.SetPropertyInt(playerData, i, player);
 		}
 		mapType = "random";
 	}
 	else if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
 	{
 		// Initialize general settings from the map data so some values
 		// (e.g. name of map) are always present, even when autostart is
 		// partially configured
 		CStr8 mapSettingsJSON = LoadSettingsOfScenarioMap("maps/" + autoStartName + ".xml");
 		scriptInterface.ParseJSON(mapSettingsJSON, &settings);
 
 		// Initialize the playerData array being modified by autostart
 		// with the real map data, so sensible values are present:
 		scriptInterface.GetProperty(settings, "PlayerData", &playerData);
 
 		if (mapDirectory == L"scenarios")
 			mapType = "scenario";
 		else
 			mapType = "skirmish";
 	}
 	else
 	{
 		LOGERROR("Autostart: Unrecognized map type '%s'", utf8_from_wstring(mapDirectory));
 		throw PSERROR_Game_World_MapLoadFailed("Unrecognized map type.\nConsult readme.txt for the currently supported types.");
 	}
 
 	scriptInterface.SetProperty(attrs, "mapType", mapType);
 	scriptInterface.SetProperty(attrs, "map", std::string("maps/" + autoStartName));
 	scriptInterface.SetProperty(settings, "mapType", mapType);
 	scriptInterface.SetProperty(settings, "CheatsEnabled", true);
 
 	// The seed is used for both random map generation and simulation
 	u32 seed = 0;
 	if (args.Has("autostart-seed"))
 	{
 		CStr seedArg = args.Get("autostart-seed");
 		if (seedArg == "-1")
 			seed = rand();
 		else
 			seed = seedArg.ToULong();
 	}
 	scriptInterface.SetProperty(settings, "Seed", seed);
 
 	// Set seed for AIs
 	u32 aiseed = 0;
 	if (args.Has("autostart-aiseed"))
 	{
 		CStr seedArg = args.Get("autostart-aiseed");
 		if (seedArg == "-1")
 			aiseed = rand();
 		else
 			aiseed = seedArg.ToULong();
 	}
 	scriptInterface.SetProperty(settings, "AISeed", aiseed);
 
 	// Set player data for AIs
 	//		attrs.settings = { PlayerData: [ { AI: ... }, ... ] }
 	//		            or = { PlayerData: [ null, { AI: ... }, ... ] } when gaia set
 	int offset = 1;
 	JS::RootedValue player(cx);
 	if (scriptInterface.GetPropertyInt(playerData, 0, &player) && player.isNull())
 		offset = 0;
 
 	// Set teams
 	if (args.Has("autostart-team"))
 	{
 		std::vector<CStr> civArgs = args.GetMultiple("autostart-team");
 		for (size_t i = 0; i < civArgs.size(); ++i)
 		{
 			int playerID = civArgs[i].BeforeFirst(":").ToInt();
 
 			// Instead of overwriting existing player data, modify the array
 			JS::RootedValue player(cx);
 			if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 			{
 				if (mapDirectory == L"skirmishes")
 				{
 					// playerID is certainly bigger than this map player number
 					LOGWARNING("Autostart: Invalid player %d in autostart-team option", playerID);
 					continue;
 				}
 				scriptInterface.Eval("({})", &player);
 			}
 
 			int teamID = civArgs[i].AfterFirst(":").ToInt() - 1;
 			scriptInterface.SetProperty(player, "Team", teamID);
 			scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 		}
 	}
 
 	int ceasefire = 0;
 	if (args.Has("autostart-ceasefire"))
 		ceasefire = args.Get("autostart-ceasefire").ToInt();
 	scriptInterface.SetProperty(settings, "Ceasefire", ceasefire);
 
 	if (args.Has("autostart-ai"))
 	{
 		std::vector<CStr> aiArgs = args.GetMultiple("autostart-ai");
 		for (size_t i = 0; i < aiArgs.size(); ++i)
 		{
 			int playerID = aiArgs[i].BeforeFirst(":").ToInt();
 
 			// Instead of overwriting existing player data, modify the array
 			JS::RootedValue player(cx);
 			if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 			{
 				if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
 				{
 					// playerID is certainly bigger than this map player number
 					LOGWARNING("Autostart: Invalid player %d in autostart-ai option", playerID);
 					continue;
 				}
 				scriptInterface.Eval("({})", &player);
 			}
 
 			CStr name = aiArgs[i].AfterFirst(":");
 			scriptInterface.SetProperty(player, "AI", std::string(name));
 			scriptInterface.SetProperty(player, "AIDiff", 3);
 			scriptInterface.SetProperty(player, "AIBehavior", std::string("balanced"));
 			scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 		}
 	}
 	// Set AI difficulty
 	if (args.Has("autostart-aidiff"))
 	{
 		std::vector<CStr> civArgs = args.GetMultiple("autostart-aidiff");
 		for (size_t i = 0; i < civArgs.size(); ++i)
 		{
 			int playerID = civArgs[i].BeforeFirst(":").ToInt();
 
 			// Instead of overwriting existing player data, modify the array
 			JS::RootedValue player(cx);
 			if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 			{
 				if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
 				{
 					// playerID is certainly bigger than this map player number
 					LOGWARNING("Autostart: Invalid player %d in autostart-aidiff option", playerID);
 					continue;
 				}
 				scriptInterface.Eval("({})", &player);
 			}
 
 			int difficulty = civArgs[i].AfterFirst(":").ToInt();
 			scriptInterface.SetProperty(player, "AIDiff", difficulty);
 			scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 		}
 	}
 	// Set player data for Civs
 	if (args.Has("autostart-civ"))
 	{
 		if (mapDirectory != L"scenarios")
 		{
 			std::vector<CStr> civArgs = args.GetMultiple("autostart-civ");
 			for (size_t i = 0; i < civArgs.size(); ++i)
 			{
 				int playerID = civArgs[i].BeforeFirst(":").ToInt();
 
 				// Instead of overwriting existing player data, modify the array
 				JS::RootedValue player(cx);
 				if (!scriptInterface.GetPropertyInt(playerData, playerID-offset, &player) || player.isUndefined())
 				{
 					if (mapDirectory == L"skirmishes")
 					{
 						// playerID is certainly bigger than this map player number
 						LOGWARNING("Autostart: Invalid player %d in autostart-civ option", playerID);
 						continue;
 					}
 					scriptInterface.Eval("({})", &player);
 				}
 
 				CStr name = civArgs[i].AfterFirst(":");
 				scriptInterface.SetProperty(player, "Civ", std::string(name));
 				scriptInterface.SetPropertyInt(playerData, playerID-offset, player);
 			}
 		}
 		else
 			LOGWARNING("Autostart: Option 'autostart-civ' is invalid for scenarios");
 	}
 
 	// Add player data to map settings
 	scriptInterface.SetProperty(settings, "PlayerData", playerData);
 
 	// Add map settings to game attributes
 	scriptInterface.SetProperty(attrs, "settings", settings);
 
 	// Get optional playername
 	CStrW userName = L"anonymous";
 	if (args.Has("autostart-playername"))
 		userName = args.Get("autostart-playername").FromUTF8();
 
 	// Add additional scripts to the TriggerScripts property
 	std::vector<CStrW> triggerScriptsVector;
 	JS::RootedValue triggerScripts(cx);
 
 	if (scriptInterface.HasProperty(settings, "TriggerScripts"))
 	{
 		scriptInterface.GetProperty(settings, "TriggerScripts", &triggerScripts);
 		FromJSVal_vector(cx, triggerScripts, triggerScriptsVector);
 	}
 
 	if (nonVisual)
 	{
 		CStr nonVisualScript = "scripts/NonVisualTrigger.js";
 		triggerScriptsVector.push_back(nonVisualScript.FromUTF8());
 	}
 
 	std::vector<CStr> victoryConditions(1, "conquest");
 	if (args.Has("autostart-victory"))
 		victoryConditions = args.GetMultiple("autostart-victory");
 
 	if (victoryConditions.size() == 1 && victoryConditions[0] == "endless")
 		victoryConditions.clear();
 
 	scriptInterface.SetProperty(settings, "VictoryConditions", victoryConditions);
 
 	for (const CStr& victory : victoryConditions)
 	{
 		JS::RootedValue scriptData(cx);
 		JS::RootedValue data(cx);
 		JS::RootedValue victoryScripts(cx);
 
 		CStrW scriptPath = L"simulation/data/settings/victory_conditions/" + victory.FromUTF8() + L".json";
 		scriptInterface.ReadJSONFile(scriptPath, &scriptData);
 		if (!scriptData.isUndefined() && scriptInterface.GetProperty(scriptData, "Data", &data) && !data.isUndefined()
 			&& scriptInterface.GetProperty(data, "Scripts", &victoryScripts) && !victoryScripts.isUndefined())
 		{
 			std::vector<CStrW> victoryScriptsVector;
 			FromJSVal_vector(cx, victoryScripts, victoryScriptsVector);
 			triggerScriptsVector.insert(triggerScriptsVector.end(), victoryScriptsVector.begin(), victoryScriptsVector.end());
 		}
 		else
 		{
 			LOGERROR("Autostart: Error reading victory script '%s'", utf8_from_wstring(scriptPath));
 			throw PSERROR_Game_World_MapLoadFailed("Error reading victory script.\nCheck application log for details.");
 		}
 	}
 
 	ToJSVal_vector(cx, &triggerScripts, triggerScriptsVector);
 	scriptInterface.SetProperty(settings, "TriggerScripts", triggerScripts);
 
 	int wonderDuration = 10;
 	if (args.Has("autostart-wonderduration"))
 		wonderDuration = args.Get("autostart-wonderduration").ToInt();
 	scriptInterface.SetProperty(settings, "WonderDuration", wonderDuration);
 
 	int relicDuration = 10;
 	if (args.Has("autostart-relicduration"))
 		relicDuration = args.Get("autostart-relicduration").ToInt();
 	scriptInterface.SetProperty(settings, "RelicDuration", relicDuration);
 
 	int relicCount = 2;
 	if (args.Has("autostart-reliccount"))
 		relicCount = args.Get("autostart-reliccount").ToInt();
 	scriptInterface.SetProperty(settings, "RelicCount", relicCount);
 
 	if (args.Has("autostart-host"))
 	{
 		InitPsAutostart(true, attrs);
 
 		size_t maxPlayers = 2;
 		if (args.Has("autostart-host-players"))
 			maxPlayers = args.Get("autostart-host-players").ToUInt();
 
 		g_NetServer = new CNetServer(false, maxPlayers);
 
 		g_NetServer->UpdateGameAttributes(&attrs, scriptInterface);
 
 		bool ok = g_NetServer->SetupConnection(PS_DEFAULT_PORT);
 		ENSURE(ok);
 
 		g_NetClient = new CNetClient(g_Game, true);
 		g_NetClient->SetUserName(userName);
 		g_NetClient->SetupConnection("127.0.0.1", PS_DEFAULT_PORT);
 	}
 	else if (args.Has("autostart-client"))
 	{
 		InitPsAutostart(true, attrs);
 
 		g_NetClient = new CNetClient(g_Game, false);
 		g_NetClient->SetUserName(userName);
 
 		CStr ip = args.Get("autostart-client");
 		if (ip.empty())
 			ip = "127.0.0.1";
 
 		bool ok = g_NetClient->SetupConnection(ip, PS_DEFAULT_PORT);
 		ENSURE(ok);
 	}
 	else
 	{
 		g_Game->SetPlayerID(args.Has("autostart-player") ? args.Get("autostart-player").ToInt() : 1);
 
 		g_Game->StartGame(&attrs, "");
 
 		if (nonVisual)
 		{
 			// TODO: Non progressive load can fail - need a decent way to handle this
 			LDR_NonprogressiveLoad();
 			ENSURE(g_Game->ReallyStartGame() == PSRETURN_OK);
 		}
 		else
 			InitPsAutostart(false, attrs);
 	}
 
 	return true;
 }
 
 bool AutostartVisualReplay(const std::string& replayFile)
 {
 	if (!FileExists(OsPath(replayFile)))
 		return false;
 
 	g_Game = new CGame(false, false);
 	g_Game->SetPlayerID(-1);
 	g_Game->StartVisualReplay(replayFile);
 
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue attrs(cx, g_Game->GetSimulation2()->GetInitAttributes());
 
 	InitPsAutostart(false, attrs);
 
 	return true;
 }
 
 void CancelLoad(const CStrW& message)
 {
 	shared_ptr<ScriptInterface> pScriptInterface = g_GUI->GetActiveGUI()->GetScriptInterface();
 	JSContext* cx = pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue global(cx, pScriptInterface->GetGlobalObject());
 
 	LDR_Cancel();
 
 	if (g_GUI &&
 	    g_GUI->HasPages() &&
 	    pScriptInterface->HasProperty(global, "cancelOnLoadGameError"))
 		pScriptInterface->CallFunctionVoid(global, "cancelOnLoadGameError", message);
 }
 
 bool InDevelopmentCopy()
 {
 	if (!g_CheckedIfInDevelopmentCopy)
 	{
 		g_InDevelopmentCopy = (g_VFS->GetFileInfo(L"config/dev.cfg", NULL) == INFO::OK);
 		g_CheckedIfInDevelopmentCopy = true;
 	}
 	return g_InDevelopmentCopy;
 }
Index: ps/trunk/source/simulation2/system/ReplayTurnManager.cpp
===================================================================
--- ps/trunk/source/simulation2/system/ReplayTurnManager.cpp	(revision 22514)
+++ ps/trunk/source/simulation2/system/ReplayTurnManager.cpp	(revision 22515)
@@ -1,106 +1,123 @@
-/* Copyright (C) 2017 Wildfire Games.
+/* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "ReplayTurnManager.h"
 
 #include "gui/GUIManager.h"
 #include "ps/Util.h"
 #include "simulation2/Simulation2.h"
 
 CReplayTurnManager::CReplayTurnManager(CSimulation2& simulation, IReplayLogger& replay)
 	: CLocalTurnManager(simulation, replay)
 {
 }
 
 void CReplayTurnManager::StoreReplayCommand(u32 turn, int player, const std::string& command)
 {
 	// Using the pair we make sure that commands per turn will be processed in the correct order
 	m_ReplayCommands[turn].emplace_back(player, command);
 }
 
 void CReplayTurnManager::StoreReplayHash(u32 turn, const std::string& hash, bool quick)
 {
 	m_ReplayHash[turn] = std::make_pair(hash, quick);
 }
 
 void CReplayTurnManager::StoreReplayTurnLength(u32 turn, u32 turnLength)
 {
 	m_ReplayTurnLengths[turn] = turnLength;
 
 	// Initialize turn length
 	if (turn == 0)
 		m_TurnLength = m_ReplayTurnLengths[0];
 }
 
 void CReplayTurnManager::StoreFinalReplayTurn(u32 turn)
 {
 	m_FinalTurn = turn;
 }
 
 void CReplayTurnManager::NotifyFinishedUpdate(u32 turn)
 {
 	if (turn == 1 && m_FinalTurn == 0)
 		g_GUI->SendEventToAll("ReplayFinished");
 
 	if (turn > m_FinalTurn)
 		return;
 
 	DoTurn(turn);
 
 	// Compare hash if it exists in the replay and if we didn't have an OOS already
 	std::map<u32, std::pair<std::string, bool>>::iterator turnHashIt = m_ReplayHash.find(turn);
 	if (m_HasSyncError || turnHashIt == m_ReplayHash.end())
 		return;
 
 	std::string expectedHash = turnHashIt->second.first;
 	bool quickHash = turnHashIt->second.second;
 
 	// Compute hash
 	std::string hash;
 	ENSURE(m_Simulation2.ComputeStateHash(hash, quickHash));
 	hash = Hexify(hash);
 
-	if (hash != expectedHash)
-	{
-		m_HasSyncError = true;
-		LOGERROR("Replay out of sync on turn %d", turn);
-		g_GUI->SendEventToAll("ReplayOutOfSync");
-	}
+	if (hash == expectedHash)
+		return;
+
+	m_HasSyncError = true;
+	LOGERROR("Replay out of sync on turn %d", turn);
+
+	const ScriptInterface& scriptInterface = m_Simulation2.GetScriptInterface();
+	JSContext* cx = scriptInterface.GetContext();
+	JSAutoRequest rq(cx);
+
+	JS::AutoValueVector paramData(cx);
+
+	paramData.append(JS::NumberValue(turn));
+
+	JS::RootedValue hashVal(cx);
+	scriptInterface.ToJSVal(cx, &hashVal, hash);
+	paramData.append(hashVal);
+
+	JS::RootedValue expectedHashVal(cx);
+	scriptInterface.ToJSVal(cx, &expectedHashVal, expectedHash);
+	paramData.append(expectedHashVal);
+
+	g_GUI->SendEventToAll("ReplayOutOfSync", paramData);
 }
 
 void CReplayTurnManager::DoTurn(u32 turn)
 {
 	debug_printf("Executing turn %u of %u\n", turn, m_FinalTurn);
 
 	m_TurnLength = m_ReplayTurnLengths[turn];
 
 	JSContext* cx = m_Simulation2.GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	// Simulate commands for that turn
 	for (const std::pair<player_id_t, std::string>& p : m_ReplayCommands[turn])
 	{
 		JS::RootedValue command(cx);
 		m_Simulation2.GetScriptInterface().ParseJSON(p.second, &command);
 		AddCommand(m_ClientId, p.first, command, m_CurrentTurn + 1);
 	}
 
 	if (turn == m_FinalTurn)
 		g_GUI->SendEventToAll("ReplayFinished");
 }