Index: ps/trunk/binaries/data/mods/public/gui/common/functions_global_object.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/common/functions_global_object.js	(revision 18612)
+++ ps/trunk/binaries/data/mods/public/gui/common/functions_global_object.js	(revision 18613)
@@ -1,167 +1,180 @@
 // We want to pass callback functions for the different buttons in a convenient way.
 // Because passing functions accross compartment boundaries is a pain, we just store them here together with some optional arguments.
 // The messageBox page will return the code of the pressed button and the according function will be called.
 var g_MessageBoxBtnFunctions = [];
 var g_MessageBoxCallbackArgs = [];
 
 var g_MessageBoxCallbackFunction = function(btnCode)
 {
 	if (btnCode !== undefined && g_MessageBoxBtnFunctions[btnCode])
 	{
 		// Cache the variables to make it possible to call a messageBox from a callback function.
 		let callbackFunction = g_MessageBoxBtnFunctions[btnCode];
 		let callbackArgs = g_MessageBoxCallbackArgs[btnCode];
 
 		g_MessageBoxBtnFunctions = [];
 		g_MessageBoxCallbackArgs = [];
 
 		if (callbackArgs !== undefined)
 			callbackFunction(callbackArgs);
 		else
 			callbackFunction();
 		return;
 	}
 
 	g_MessageBoxBtnFunctions = [];
 	g_MessageBoxCallbackArgs = [];
 };
 
 function messageBox(mbWidth, mbHeight, mbMessage, mbTitle, mbButtonCaptions, mbBtnCode, mbCallbackArgs)
 {
 	if (g_MessageBoxBtnFunctions && g_MessageBoxBtnFunctions.length)
 	{
 		warn("A messagebox was called when a previous callback function is still set, aborting!");
 		return;
 	}
 
 	g_MessageBoxBtnFunctions = mbBtnCode;
 	g_MessageBoxCallbackArgs = mbCallbackArgs || g_MessageBoxCallbackArgs;
 
 	Engine.PushGuiPage("page_msgbox.xml", {
 		"width": mbWidth,
 		"height": mbHeight,
 		"message": mbMessage,
 		"title": mbTitle,
 		"buttonCaptions": mbButtonCaptions,
 		"callback": mbBtnCode && "g_MessageBoxCallbackFunction"
 	});
 }
 
 function openURL(url)
 {
 	Engine.OpenURL(url);
 
 	messageBox(
 		600, 200,
 		sprintf(
 			translate("Opening %(url)s\n in default web browser. Please wait...."),
 			{ "url": url }
 		),
 		translate("Opening page")
 	);
 }
 
 function updateCounters()
 {
 	var caption = "";
 	var linesCount = 0;
 	var researchCount = 0;
 
 	if (Engine.ConfigDB_GetValue("user", "overlay.fps") === "true")
 	{
 		caption += sprintf(translate("FPS: %(fps)4s"), { "fps": Engine.GetFPS() }) + "\n";
 		++linesCount;
 	}
 	if (Engine.ConfigDB_GetValue("user", "overlay.realtime") === "true")
 	{
 		caption += (new Date()).toLocaleTimeString() + "\n";
 		++linesCount;
 	}
 
 	// If game has been started
 	if (typeof g_SimState != "undefined")
 	{
 		if (Engine.ConfigDB_GetValue("user", "gui.session.timeelapsedcounter") === "true")
 		{
 			var currentSpeed = Engine.GetSimRate();
 			if (currentSpeed != 1.0)
 				// Translation: The "x" means "times", with the mathematical meaning of multiplication.
 				caption += sprintf(translate("%(time)s (%(speed)sx)"), {
 					"time": timeToString(g_SimState.timeElapsed),
 					"speed": Engine.FormatDecimalNumberIntoString(currentSpeed)
 				});
 			else
 				caption += timeToString(g_SimState.timeElapsed);
 			caption += "\n";
 			++linesCount;
 		}
 
 		var diplomacyCeasefireCounter = Engine.GetGUIObjectByName("diplomacyCeasefireCounter");
 		if (g_SimState.ceasefireActive)
 		{
 			// Update ceasefire counter in the diplomacy window
 			var remainingTimeString = timeToString(g_SimState.ceasefireTimeRemaining);
 
 			diplomacyCeasefireCounter.caption = sprintf(
 				translateWithContext("ceasefire", "Time remaining until ceasefire is over: %(time)s."),
 				{ "time": remainingTimeString }
 			);
 
 			// Update ceasefire overlay counter
 			if (Engine.ConfigDB_GetValue("user", "gui.session.ceasefirecounter") === "true")
 			{
 				caption += remainingTimeString + "\n";
 				++linesCount;
 			}
 		}
 		else if (!diplomacyCeasefireCounter.hidden)
 		{
 			diplomacyCeasefireCounter.hidden = true;
 			updateDiplomacy();
 		}
 
 		g_ResearchListTop = 4;
 		if (linesCount)
 			g_ResearchListTop += 14 * linesCount;
 	}
 
 	var dataCounter = Engine.GetGUIObjectByName("dataCounter");
 	dataCounter.caption = caption;
 	dataCounter.size = sprintf("100%%-100 40 100%%-5 %(bottom)s", { "bottom": 40 + 14 * linesCount });
 	dataCounter.hidden = linesCount == 0;
 }
 
 /**
  * Update the overlay with the most recent network warning of each client.
  */
 function displayGamestateNotifications()
 {
 	let messages = [];
 	let maxTextWidth = 0;
 
 	// Add network warnings
 	if (Engine.ConfigDB_GetValue("user", "overlay.netwarnings") == "true")
 	{
 		let netwarnings = getNetworkWarnings();
 		messages = messages.concat(netwarnings.messages);
 		maxTextWidth = Math.max(maxTextWidth, netwarnings.maxTextWidth);
 	}
 
 	// Resize textbox
 	let width = maxTextWidth + 20;
 	let height = 14 * messages.length;
 
 	// Position left of the dataCounter
 	let top = "40";
 	let right = Engine.GetGUIObjectByName("dataCounter").hidden ? "100%-15" : "100%-110";
 
 	let bottom = top + "+" + height;
 	let left = right + "-" + width;
 
 	let gameStateNotifications = Engine.GetGUIObjectByName("gameStateNotifications");
 	gameStateNotifications.caption = messages.join("\n");
 	gameStateNotifications.hidden = !messages.length;
 	gameStateNotifications.size = left + " " + top + " " + right + " " + bottom;
 
 	setTimeout(displayGamestateNotifications, 1000);
 }
+
+/**
+ * Also called from the C++ side when ending the game.
+ */
+function getReplayMetadata()
+{
+	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
+	return {
+		"timeElapsed" : extendedSimState.timeElapsed,
+		"playerStates": extendedSimState.players,
+		"mapSettings": Engine.GetInitAttributes().settings
+	};
+}
Index: ps/trunk/binaries/data/mods/public/gui/session/session.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 18612)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 18613)
@@ -1,1326 +1,1315 @@
 const g_IsReplay = Engine.IsVisualReplay();
 const g_GameSpeeds = prepareForDropdown(g_Settings && g_Settings.GameSpeeds.filter(speed => !speed.ReplayOnly || g_IsReplay));
 
 /**
  * Colors to flash when pop limit reached.
  */
 const g_DefaultPopulationColor = "white";
 const g_PopulationAlertColor = "orange";
 
 /**
  * A random file will be played. TODO: more variety
  */
 const g_Ambient = [ "audio/ambient/dayscape/day_temperate_gen_03.ogg" ];
 
 /**
  * Map, player and match settings set in gamesetup.
  */
 const g_GameAttributes = Object.freeze(Engine.GetInitAttributes());
 
 /**
  * Is this user in control of game settings (i.e. is a network server, or offline player).
  */
 var g_IsController;
 
 /**
  * True if this is a multiplayer game.
  */
 var g_IsNetworked = false;
 
 /**
  * True if the connection to the server has been lost.
  */
 var g_Disconnected = false;
 
 /**
  * True if the current user has observer capabilities.
  */
 var g_IsObserver = false;
 
 /**
  * True if the current user has rejoined (or joined the game after it started).
  */
 var g_HasRejoined = false;
 
 /**
  * Shows a message box asking the user to leave if "won" or "defeated".
  */
 var g_ConfirmExit = false;
 
 /**
  * True if the current player has paused the game explicitly.
  */
 var g_Paused = false;
 
 /**
  * The list of GUIDs of players who have currently paused the game, if the game is networked.
  */
 var g_PausingClients = [];
 
 /**
  * The playerID selected in the change perspective tool.
  */
 var g_ViewedPlayer = Engine.GetPlayerID();
 
 /**
  * True if the camera should focus on attacks and player commands
  * and select the affected units.
  */
 var g_FollowPlayer = false;
 
 /**
  * Cache the basic player data (name, civ, color).
  */
 var g_Players = [];
 
 /**
  * Last time when onTick was called().
  * Used for animating the main menu.
  */
 var lastTickTime = new Date();
 
 /**
  * Not constant as we add "gaia".
  */
 var g_CivData = {};
 
 /**
  * For restoring selection, order and filters when returning to the replay menu
  */
 var g_ReplaySelectionData;
 
 var g_PlayerAssignments = {
 	"local": {
 		"name": singleplayerName(),
 		"player": 1
 	}
 };
 
 /**
  * Cache dev-mode settings that are frequently or widely used.
  */
 var g_DevSettings = {
 	"changePerspective": false,
 	"controlAll": false
 };
 
 /**
  * Whether status bars should be shown for all of the player's units.
  */
 var g_ShowAllStatusBars = false;
 
 /**
  * Blink the population counter if the player can't train more units.
  */
 var g_IsTrainingBlocked = false;
 
 /**
  * Cache simulation state (updated on every simulation update).
  */
 var g_SimState;
 var g_EntityStates = {};
 var g_TemplateData = {};
 var g_TemplateDataWithoutLocalization = {};
 var g_TechnologyData = {};
 
 /**
  * Top coordinate of the research list.
  * Changes depending on the number of displayed counters.
  */
 var g_ResearchListTop = 4;
 
 /**
  * List of additional entities to highlight.
  */
 var g_ShowGuarding = false;
 var g_ShowGuarded = false;
 var g_AdditionalHighlight = [];
 
 /**
  * Display data of the current players heroes.
  */
 var g_Heroes = [];
 
 /**
  * Unit classes to be checked for the idle-worker-hotkey.
  */
 var g_WorkerTypes = ["Female", "Trader", "FishingBoat", "CitizenSoldier"];
 
 /**
  * Cache the idle worker status.
  */
 var g_HasIdleWorker = false;
 
 function GetSimState()
 {
 	if (!g_SimState)
 		g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	return g_SimState;
 }
 
 function GetEntityState(entId)
 {
 	if (!g_EntityStates[entId])
 		g_EntityStates[entId] = Engine.GuiInterfaceCall("GetEntityState", entId);
 
 	return g_EntityStates[entId];
 }
 
 function GetExtendedEntityState(entId)
 {
 	let entState = GetEntityState(entId);
 	if (!entState || entState.extended)
 		return entState;
 
 	let extension = Engine.GuiInterfaceCall("GetExtendedEntityState", entId);
 	for (let prop in extension)
 		entState[prop] = extension[prop];
 	entState.extended = true;
 	g_EntityStates[entId] = entState;
 	return entState;
 }
 
 function GetTemplateData(templateName)
 {
 	if (!(templateName in g_TemplateData))
 	{
 		let template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		translateObjectKeys(template, ["specific", "generic", "tooltip"]);
 		g_TemplateData[templateName] = template;
 	}
 
 	return g_TemplateData[templateName];
 }
 
 function GetTemplateDataWithoutLocalization(templateName)
 {
 	if (!(templateName in g_TemplateDataWithoutLocalization))
 	{
 		let template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		g_TemplateDataWithoutLocalization[templateName] = template;
 	}
 
 	return g_TemplateDataWithoutLocalization[templateName];
 }
 
 function GetTechnologyData(technologyName)
 {
 	if (!(technologyName in g_TechnologyData))
 	{
 		let template = Engine.GuiInterfaceCall("GetTechnologyData", technologyName);
 		translateObjectKeys(template, ["specific", "generic", "description", "tooltip", "requirementsTooltip"]);
 		g_TechnologyData[technologyName] = template;
 	}
 
 	return g_TechnologyData[technologyName];
 }
 
 function init(initData, hotloadData)
 {
 	if (!g_Settings)
 	{
 		Engine.EndGame();
 		Engine.SwitchGuiPage("page_pregame.xml");
 		return;
 	}
 
 	if (initData)
 	{
 		g_IsNetworked = initData.isNetworked;
 		g_IsController = initData.isController;
 		g_PlayerAssignments = initData.playerAssignments;
 		g_ReplaySelectionData = initData.replaySelectionData;
 		g_HasRejoined = initData.isRejoining;
 
 		if (initData.savedGUIData)
 			restoreSavedGameData(initData.savedGUIData);
 
 		Engine.GetGUIObjectByName("gameSpeedButton").hidden = g_IsNetworked;
 	}
 	else // Needed for autostart loading option
 	{
 		if (g_IsReplay)
 			g_PlayerAssignments.local.player = -1;
 	}
 
 	g_Players = getPlayerData();
 
 	g_CivData = loadCivData();
 	g_CivData.gaia = { "Code": "gaia", "Name": translate("Gaia") };
 
 	initializeMusic(); // before changing the perspective
 
 	let gameSpeed = Engine.GetGUIObjectByName("gameSpeed");
 	gameSpeed.list = g_GameSpeeds.Title;
 	gameSpeed.list_data = g_GameSpeeds.Speed;
 	let gameSpeedIdx = g_GameSpeeds.Speed.indexOf(Engine.GetSimRate());
 	gameSpeed.selected = gameSpeedIdx != -1 ? gameSpeedIdx : g_GameSpeeds.Default;
 	gameSpeed.onSelectionChange = function() { changeGameSpeed(+this.list_data[this.selected]); };
 	initMenuPosition();
 
 	for (let slot in Engine.GetGUIObjectByName("unitHeroPanel").children)
 		initGUIHeroes(slot);
 
 	// Populate player selection dropdown
 	let playerNames = [translate("Observer")];
 	let playerIDs = [-1];
 	for (let player in g_Players)
 	{
 		playerIDs.push(player);
 		playerNames.push(colorizePlayernameHelper("■", player) + " " + g_Players[player].name);
 	}
 
 	// Select "observer" item when rejoining as a defeated player
 	let viewedPlayer = g_Players[Engine.GetPlayerID()];
 	let viewPlayerDropdown = Engine.GetGUIObjectByName("viewPlayer");
 	viewPlayerDropdown.list = playerNames;
 	viewPlayerDropdown.list_data = playerIDs;
 	viewPlayerDropdown.selected = viewedPlayer && viewedPlayer.state == "defeated" ? 0 : Engine.GetPlayerID() + 1;
 
 	// If in Atlas editor, disable the exit button
 	if (Engine.IsAtlasRunning())
 		Engine.GetGUIObjectByName("menuExitButton").enabled = false;
 
 	initHotkeyTooltips();
 
 	if (hotloadData)
 		g_Selection.selected = hotloadData.selection;
 
 	sendLobbyPlayerlistUpdate();
 	onSimulationUpdate();
 	setTimeout(displayGamestateNotifications, 1000);
 
 	// Report the performance after 5 seconds (when we're still near
 	// the initial camera view) and a minute (when the profiler will
 	// have settled down if framerates as very low), to give some
 	// extremely rough indications of performance
 	//
 	// DISABLED: this information isn't currently useful for anything much,
 	// and it generates a massive amount of data to transmit and store
 	//setTimeout(function() { reportPerformance(5); }, 5000);
 	//setTimeout(function() { reportPerformance(60); }, 60000);
 }
 
 function initHotkeyTooltips()
 {
 	Engine.GetGUIObjectByName("idleWorkerButton").tooltip =
 		colorizeHotkey("%(hotkey)s" + " ", "selection.idleworker") +
 		translate("Find idle worker");
 
 	Engine.GetGUIObjectByName("tradeHelp").tooltip =
 		translate("Select one goods as origin of the changes, then use the arrows of the target goods to make the changes.") +
 		colorizeHotkey(
 			"\n" + translate("Using %(hotkey)s will put the selected resource to 100%%."),
 			"session.fulltradeswap");
 }
 
 function initGUIHeroes(slot)
 {
 	let button = Engine.GetGUIObjectByName("unitHeroButton[" + slot + "]");
 
 	button.onPress = function() {
 		let hero = g_Heroes.find(hero => hero.slot !== undefined && hero.slot == slot);
 		if (!hero)
 			return;
 
 		if (!Engine.HotkeyIsPressed("selection.add"))
 			g_Selection.reset();
 
 		g_Selection.addList([hero.ent]);
 	};
 
 	button.onDoublePress = function() {
 		let hero = g_Heroes.find(hero => hero.slot !== undefined && hero.slot == slot);
 		if (hero)
 			selectAndMoveTo(getEntityOrHolder(hero.ent));
 	};
 }
 
 function initializeMusic()
 {
 	initMusic();
 	if (g_ViewedPlayer != -1)
 		global.music.storeTracks(g_CivData[g_Players[g_ViewedPlayer].civ].Music);
 	global.music.setState(global.music.states.PEACE);
 	playAmbient();
 }
 
 function toggleChangePerspective(enabled)
 {
 	g_DevSettings.changePerspective = enabled;
 	selectViewPlayer(g_ViewedPlayer);
 }
 
 /**
  * Change perspective tool.
  * Shown to observers or when enabling the developers option.
  */
 function selectViewPlayer(playerID)
 {
 	if (playerID < -1 || playerID > g_Players.length - 1)
 		return;
 
 	if (g_ShowAllStatusBars)
 		recalculateStatusBarDisplay(true);
 
 	g_IsObserver = isPlayerObserver(Engine.GetPlayerID());
 
 	if (g_IsObserver || g_DevSettings.changePerspective)
 		g_ViewedPlayer = playerID;
 
 	if (g_DevSettings.changePerspective)
 	{
 		Engine.SetPlayerID(g_ViewedPlayer);
 		g_IsObserver = isPlayerObserver(g_ViewedPlayer);
 	}
 
 	Engine.SetViewedPlayer(g_ViewedPlayer);
 
 	updateTopPanel();
 
 	updateChatAddressees();
 
 	// Update GUI and clear player-dependent cache
 	onSimulationUpdate();
 
 	if (g_IsDiplomacyOpen)
 		openDiplomacy();
 
 	if (g_IsTradeOpen)
 		openTrade();
 }
 
 /**
  * Returns true if the player with that ID is in observermode.
  */
 function isPlayerObserver(playerID)
 {
 	let playerStates = GetSimState().players;
 	return !playerStates[playerID] || playerStates[playerID].state != "active";
 }
 
 /**
  * Returns true if the current user can issue commands for that player.
  */
 function controlsPlayer(playerID)
 {
 	let playerStates = GetSimState().players;
 
 	return playerStates[Engine.GetPlayerID()] &&
 		playerStates[Engine.GetPlayerID()].controlsAll ||
 		Engine.GetPlayerID() == playerID &&
 		playerStates[playerID] &&
 		playerStates[playerID].state != "defeated";
 }
 
 /**
  * Called when a player has won or was defeated.
  */
 function playerFinished(player, won)
 {
 	if (player == Engine.GetPlayerID())
 		reportGame();
 
 	updateDiplomacy();
 	updateChatAddressees();
 
 	if (player != Engine.GetPlayerID() || Engine.IsAtlasRunning())
 		return;
 
 	global.music.setState(
 		won ?
 			global.music.states.VICTORY :
 			global.music.states.DEFEAT
 	);
 
 	// Select "observer" item on loss. On win enable observermode without changing perspective
 	Engine.GetGUIObjectByName("viewPlayer").selected = won ? g_ViewedPlayer + 1 : 0;
 
 	g_ConfirmExit = won ? "won" : "defeated";
 }
 
 /**
  * Sets civ icon for the currently viewed player.
  * Hides most gui objects for observers.
  */
 function updateTopPanel()
 {
 	let isPlayer = g_ViewedPlayer > 0;
 
 	let civIcon = Engine.GetGUIObjectByName("civIcon");
 	civIcon.hidden = !isPlayer;
 	if (isPlayer)
 	{
 		civIcon.sprite = "stretched:" + g_CivData[g_Players[g_ViewedPlayer].civ].Emblem;
 		Engine.GetGUIObjectByName("civIconOverlay").tooltip = sprintf(translate("%(civ)s - Structure Tree"), {
 			"civ": g_CivData[g_Players[g_ViewedPlayer].civ].Name
 		});
 	}
 
 	Engine.GetGUIObjectByName("optionFollowPlayer").hidden = !g_IsObserver || !isPlayer;
 
 	let viewPlayer = Engine.GetGUIObjectByName("viewPlayer");
 	viewPlayer.hidden = !g_IsObserver && !g_DevSettings.changePerspective;
 
 	Engine.GetGUIObjectByName("food").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("wood").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("stone").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("metal").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("population").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("diplomacyButton1").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("tradeButton1").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("observerText").hidden = isPlayer;
 
 	let alphaLabel = Engine.GetGUIObjectByName("alphaLabel");
 	alphaLabel.hidden = isPlayer && !viewPlayer.hidden;
 	alphaLabel.size = isPlayer ? "50%+20 0 100%-226 100%" : "200 0 100%-475 100%";
 
 	Engine.GetGUIObjectByName("pauseButton").enabled = !g_IsObserver || !g_IsNetworked;
 	Engine.GetGUIObjectByName("menuResignButton").enabled = !g_IsObserver;
 }
 
 function reportPerformance(time)
 {
 	let settings = g_GameAttributes.settings;
 	Engine.SubmitUserReport("profile", 3, JSON.stringify({
 		"time": time,
 		"map": settings.Name,
 		"seed": settings.Seed, // only defined for random maps
 		"size": settings.Size, // only defined for random maps
 		"profiler": Engine.GetProfilerState()
 	}));
 }
 
 /**
  * Resign a player.
  * @param leaveGameAfterResign If player is quitting after resignation.
  */
 function resignGame(leaveGameAfterResign)
 {
 	if (g_IsObserver || g_Disconnected)
 		return;
 
 	Engine.PostNetworkCommand({
 		"type": "defeat-player",
 		"playerId": Engine.GetPlayerID(),
 		"resign": true
 	});
 
 	if (!leaveGameAfterResign)
 		resumeGame(true);
 }
 
 /**
  * Leave the game
  * @param willRejoin If player is going to be rejoining a networked game.
  */
 function leaveGame(willRejoin)
 {
-	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
-	let simData = {
-		"timeElapsed" : extendedSimState.timeElapsed,
-		"playerStates": extendedSimState.players,
-		"mapSettings": g_GameAttributes.settings
-	};
-
-	if (!g_IsReplay)
-		Engine.SaveReplayMetadata(JSON.stringify(simData));
-
-	if (!willRejoin &&
-	    simData.playerStates[Engine.GetPlayerID()] &&
-	    simData.playerStates[Engine.GetPlayerID()].state == "active")
+	if (!willRejoin && !g_IsObserver)
 		resignGame(true);
 
 	// Before ending the game
 	let replayDirectory = Engine.GetCurrentReplayDirectory();
+	let simData = getReplayMetadata();
 
 	Engine.EndGame();
 
 	if (g_IsController && Engine.HasXmppClient())
 		Engine.SendUnregisterGame();
 
 	Engine.SwitchGuiPage("page_summary.xml", {
 		"sim": simData,
 		"gui": {
 			"assignedPlayer": Engine.GetPlayerID(),
 			"disconnected": g_Disconnected,
 			"isReplay": g_IsReplay,
 			"replayDirectory": !g_HasRejoined && replayDirectory,
 			"replaySelectionData": g_ReplaySelectionData
 		}
 	});
 }
 
 // Return some data that we'll use when hotloading this file after changes
 function getHotloadData()
 {
 	return { "selection": g_Selection.selected };
 }
 
 function getSavedGameData()
 {
 	return {
 		"groups": g_Groups.groups
 	};
 }
 
 function restoreSavedGameData(data)
 {
 	// Restore camera if any
 	if (data.camera)
 		Engine.SetCameraData(data.camera.PosX, data.camera.PosY, data.camera.PosZ,
 			data.camera.RotX, data.camera.RotY, data.camera.Zoom);
 
 	// Clear selection when loading a game
 	g_Selection.reset();
 
 	// Restore control groups
 	for (let groupNumber in data.groups)
 	{
 		g_Groups.groups[groupNumber].groups = data.groups[groupNumber].groups;
 		g_Groups.groups[groupNumber].ents = data.groups[groupNumber].ents;
 	}
 	updateGroups();
 }
 
 /**
  * Called every frame.
  */
 function onTick()
 {
 	if (!g_Settings)
 		return;
 
 	let now = new Date();
 	let tickLength = new Date() - lastTickTime;
 	lastTickTime = now;
 
 	handleNetMessages();
 
 	updateCursorAndTooltip();
 
 	if (g_Selection.dirty)
 	{
 		g_Selection.dirty = false;
 
 		updateGUIObjects();
 
 		// Display rally points for selected buildings
 		if (Engine.GetPlayerID() != -1)
 			Engine.GuiInterfaceCall("DisplayRallyPoint", { "entities": g_Selection.toList() });
 	}
 
 	updateTimers();
 
 	updateMenuPosition(tickLength);
 
 	// When training is blocked, flash population (alternates color every 500msec)
 	Engine.GetGUIObjectByName("resourcePop").textcolor = g_IsTrainingBlocked && Date.now() % 1000 < 500 ? g_PopulationAlertColor : g_DefaultPopulationColor;
 
 	Engine.GuiInterfaceCall("ClearRenamedEntities");
 }
 
 function changeGameSpeed(speed)
 {
 	if (!g_IsNetworked)
 		Engine.SetSimRate(speed);
 }
 
 function hasIdleWorker()
 {
 	return Engine.GuiInterfaceCall("HasIdleUnits", {
 			"viewedPlayer": g_ViewedPlayer,
 			"idleClasses": g_WorkerTypes,
 			"excludeUnits": []
 	});
 }
 
 function updateIdleWorkerButton()
 {
 	g_HasIdleWorker = hasIdleWorker();
 
 	let idleWorkerButton = Engine.GetGUIObjectByName("idleOverlay");
 	let prefix = "stretched:session/";
 
 	if (!g_HasIdleWorker)
 		idleWorkerButton.sprite = prefix + "minimap-idle-disabled.png";
 	else if (idleWorkerButton.sprite != prefix + "minimap-idle-highlight.png")
 		idleWorkerButton.sprite = prefix + "minimap-idle.png";
 }
 
 function onSimulationUpdate()
 {
 	g_EntityStates = {};
 	g_TemplateData = {};
 	g_TechnologyData = {};
 
 	g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	if (!g_SimState)
 		return;
 
 	handleNotifications();
 	updateGUIObjects();
 
 	if (g_ConfirmExit)
 		confirmExit();
 }
 
 /**
  * Don't show the message box before all playerstate changes are processed.
  */
 function confirmExit()
 {
 	closeOpenDialogs();
 
 	let subject = g_ConfirmExit == "won" ?
 		translate("You have won!") :
 		translate("You have been defeated!");
 
 	subject += "\n" + translate("Do you want to quit?");
 
 	if (g_IsNetworked && g_IsController)
 		subject += "\n" + translate("Leaving will disconnect all other players.");
 
 	messageBox(
 		400, 200,
 		subject,
 		g_ConfirmExit == "won" ?
 			translate("VICTORIOUS!") :
 			translate("DEFEATED!"),
 		[translate("No"), translate("Yes")],
 		[resumeGame, leaveGame]
 	);
 
 	g_ConfirmExit = false;
 }
 
 function updateGUIObjects()
 {
 	g_Selection.update();
 
 	if (g_ShowAllStatusBars)
 		recalculateStatusBarDisplay();
 
 	if (g_ShowGuarding || g_ShowGuarded)
 		updateAdditionalHighlight();
 
 	updateHeroes();
 	displayHeroes();
 
 	updateGroups();
 	updateDebug();
 	updatePlayerDisplay();
 	updateResearchDisplay();
 	updateSelectionDetails();
 	updateBuildingPlacementPreview();
 	updateTimeNotifications();
 	updateIdleWorkerButton();
 
 	if (g_ViewedPlayer > 0)
 	{
 		let playerState = GetSimState().players[g_ViewedPlayer];
 		g_DevSettings.controlAll = playerState && playerState.controlsAll;
 		Engine.GetGUIObjectByName("devControlAll").checked = g_DevSettings.controlAll;
 	}
 
 	if (!g_IsObserver)
 	{
 		// Update music state on basis of battle state.
 		let battleState = Engine.GuiInterfaceCall("GetBattleState", g_ViewedPlayer);
 		if (battleState)
 			global.music.setState(global.music.states[battleState]);
 	}
 }
 
 function onReplayFinished()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	messageBox(400, 200,
 		translateWithContext("replayFinished", "The replay has finished. Do you want to quit?"),
 		translateWithContext("replayFinished", "Confirmation"),
 		[translateWithContext("replayFinished", "No"), translateWithContext("replayFinished", "Yes")],
 		[resumeGame, leaveGame]);
 }
 
 /**
 * updates a status bar on the GUI
 * nameOfBar: name of the bar
 * points: points to show
 * maxPoints: max points
 * direction: gets less from (right to left) 0; (top to bottom) 1; (left to right) 2; (bottom to top) 3;
 */
 function updateGUIStatusBar(nameOfBar, points, maxPoints, direction)
 {
 	// check, if optional direction parameter is valid.
 	if (!direction || !(direction >= 0 && direction < 4))
 		direction = 0;
 
 	// get the bar and update it
 	let statusBar = Engine.GetGUIObjectByName(nameOfBar);
 	if (!statusBar)
 		return;
 
 	let healthSize = statusBar.size;
 	let value = 100*Math.max(0, Math.min(1, points / maxPoints));
 
 	// inverse bar
 	if (direction == 2 || direction == 3)
 		value = 100 - value;
 
 	if (direction == 0)
 		healthSize.rright = value;
 	else if (direction == 1)
 		healthSize.rbottom = value;
 	else if (direction == 2)
 		healthSize.rleft = value;
 	else if (direction == 3)
 		healthSize.rtop = value;
 
 	statusBar.size = healthSize;
 }
 
 function updateHeroes()
 {
 	let playerState = GetSimState().players[g_ViewedPlayer];
 	let heroes = playerState ? playerState.heroes : [];
 
 	g_Heroes = g_Heroes.filter(hero => heroes.find(ent => ent == hero.ent));
 
 	for (let ent of heroes)
 	{
 		let heroState = GetExtendedEntityState(ent);
 		let template = GetTemplateData(heroState.template);
 
 		let hero = g_Heroes.find(hero => ent == hero.ent);
 		if (!hero)
 		{
 			hero = {
 				"ent": ent,
 				"tooltip": undefined,
 				"sprite": "stretched:session/portraits/" + template.icon,
 				"maxHitpoints": undefined,
 				"currentHitpoints": heroState.hitpoints,
 				"previousHitpoints": undefined
 			};
 			g_Heroes.push(hero);
 		}
 
 		hero.tooltip = createHeroTooltip(heroState, template);
 
 		hero.previousHitpoints = hero.currentHitpoints;
 		hero.currentHitpoints = heroState.hitpoints;
 		hero.maxHitpoints = heroState.maxHitpoints;
 	}
 }
 
 function createHeroTooltip(heroState, template)
 {
 	return [
 		"[font=\"sans-bold-16\"]" + template.name.specific + "[/font]" + "\n" +
 			sprintf(translate("%(label)s %(current)s / %(max)s"), {
 				"label": "[font=\"sans-bold-13\"]" + translate("Health:") + "[/font]",
 				"current": Math.ceil(heroState.hitpoints),
 				"max": Math.ceil(heroState.maxHitpoints)
 			}),
 		getAttackTooltip(heroState),
 		getArmorTooltip(heroState),
 		getEntityTooltip(heroState)
 	].filter(tip => tip).join("\n");
 }
 
 function displayHeroes()
 {
 	let buttons = Engine.GetGUIObjectByName("unitHeroPanel").children;
 
 	buttons.forEach((button, slot) => {
 
 		if (button.hidden || g_Heroes.some(hero => hero.slot !== undefined && hero.slot == slot))
 			return;
 
 		button.hidden = true;
 		stopColorFade("heroHitOverlay[" + slot + "]");
 	});
 
 	// The slot identifies the button, displayIndex determines its position.
 	for (let displayIndex = 0; displayIndex < Math.min(g_Heroes.length, buttons.length); ++displayIndex)
 	{
 		let hero = g_Heroes[displayIndex];
 
 		// Find the first unused slot if new, otherwise reuse previous.
 		let slot = hero.slot === undefined ?
 			buttons.findIndex(button => button.hidden) :
 			hero.slot;
 
 		let heroButton = Engine.GetGUIObjectByName("unitHeroButton[" + slot + "]");
 		heroButton.tooltip = hero.tooltip;
 
 		updateGUIStatusBar("heroHealthBar[" + slot + "]", hero.currentHitpoints, hero.maxHitpoints);
 
 		if (hero.slot === undefined)
 		{
 			let heroImage = Engine.GetGUIObjectByName("unitHeroImage[" + slot + "]");
 			heroImage.sprite = hero.sprite;
 
 			heroButton.hidden = false;
 			hero.slot = slot;
 		}
 
 		// If the health of the hero changed since the last update, trigger the animation.
 		if (hero.previousHitpoints > hero.currentHitpoints)
 			startColorFade("heroHitOverlay[" + slot + "]", 100, 0,
 				colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
 
 		// TODO: Instead of instant position changes, animate button movement.
 		setPanelObjectPosition(heroButton, displayIndex, buttons.length);
 	}
 }
 
 function updateGroups()
 {
 	g_Groups.update();
 
 	for (let i in Engine.GetGUIObjectByName("unitGroupPanel").children)
 	{
 		Engine.GetGUIObjectByName("unitGroupLabel[" + i + "]").caption = i;
 
 		let button = Engine.GetGUIObjectByName("unitGroupButton["+i+"]");
 		button.hidden = g_Groups.groups[i].getTotalCount() == 0;
 		button.onpress = (function(i) { return function() { performGroup((Engine.HotkeyIsPressed("selection.add") ? "add" : "select"), i); }; })(i);
 		button.ondoublepress = (function(i) { return function() { performGroup("snap", i); }; })(i);
 		button.onpressright = (function(i) { return function() { performGroup("breakUp", i); }; })(i);
 		setPanelObjectPosition(button, i, 1);
 	}
 }
 
 function updateDebug()
 {
 	let debug = Engine.GetGUIObjectByName("debugEntityState");
 
 	if (!Engine.GetGUIObjectByName("devDisplayState").checked)
 	{
 		debug.hidden = true;
 		return;
 	}
 
 	debug.hidden = false;
 
 	let conciseSimState = deepcopy(GetSimState());
 	conciseSimState.players = "<<<omitted>>>";
 	let text = "simulation: " + uneval(conciseSimState);
 
 	let selection = g_Selection.toList();
 	if (selection.length)
 	{
 		let entState = GetExtendedEntityState(selection[0]);
 		if (entState)
 		{
 			let template = GetTemplateData(entState.template);
 			text += "\n\nentity: {\n";
 			for (let k in entState)
 				text += "  "+k+":"+uneval(entState[k])+"\n";
 			text += "}\n\ntemplate: " + uneval(template);
 		}
 	}
 
 	debug.caption = text.replace(/\[/g, "\\[");
 }
 
 function getAllyStatTooltip(resource)
 {
 	let playersState = GetSimState().players;
 	let ret = "";
 	for (let player in playersState)
 		if (player != 0 && player != g_ViewedPlayer &&
 		    (g_IsObserver || playersState[g_ViewedPlayer].hasSharedLos && g_Players[player].isMutualAlly[g_ViewedPlayer]))
 			ret += "\n" + sprintf(translate("%(playername)s: %(statValue)s"),{
 				"playername": colorizePlayernameHelper("■", player) + " " + g_Players[player].name,
 				"statValue": resource == "pop" ?
 					sprintf(translate("%(popCount)s/%(popLimit)s/%(popMax)s"), playersState[player]) :
 					Math.round(playersState[player].resourceCounts[resource])
 			});
 	return ret;
 }
 
 function updatePlayerDisplay()
 {
 	let playerState = GetSimState().players[g_ViewedPlayer];
 	if (!playerState)
 		return;
 
 	for (let res of RESOURCES)
 	{
 		Engine.GetGUIObjectByName("resource_" + res).caption = Math.floor(playerState.resourceCounts[res]);
 		Engine.GetGUIObjectByName(res).tooltip = getLocalizedResourceName(res, "firstWord") + getAllyStatTooltip(res);
 	}
 
 	Engine.GetGUIObjectByName("resourcePop").caption = sprintf(translate("%(popCount)s/%(popLimit)s"), playerState);
 	Engine.GetGUIObjectByName("population").tooltip = translate("Population (current / limit)") + "\n" +
 		sprintf(translate("Maximum population: %(popCap)s"), { "popCap": playerState.popMax }) +
 		getAllyStatTooltip("pop");
 
 	g_IsTrainingBlocked = playerState.trainingBlocked;
 }
 
 function selectAndMoveTo(ent)
 {
 	let entState = GetEntityState(ent);
 	if (!entState || !entState.position)
 		return;
 
 	g_Selection.reset();
 	g_Selection.addList([ent]);
 
 	let position = entState.position;
 	Engine.CameraMoveTo(position.x, position.z);
 }
 
 function updateResearchDisplay()
 {
 	let researchStarted = Engine.GuiInterfaceCall("GetStartedResearch", g_ViewedPlayer);
 
 	// Set up initial positioning.
 	let buttonSideLength = Engine.GetGUIObjectByName("researchStartedButton[0]").size.right;
 	for (let i = 0; i < 10; ++i)
 	{
 		let button = Engine.GetGUIObjectByName("researchStartedButton[" + i + "]");
 		let size = button.size;
 		size.top = g_ResearchListTop + (4 + buttonSideLength) * i;
 		size.bottom = size.top + buttonSideLength;
 		button.size = size;
 	}
 
 	let numButtons = 0;
 	for (let tech in researchStarted)
 	{
 		// Show at most 10 in-progress techs.
 		if (numButtons >= 10)
 			break;
 
 		let template = GetTechnologyData(tech);
 		let button = Engine.GetGUIObjectByName("researchStartedButton[" + numButtons + "]");
 		button.hidden = false;
 		button.tooltip = getEntityNames(template);
 		button.onpress = (function(e) { return function() { selectAndMoveTo(e); }; })(researchStarted[tech].researcher);
 
 		let icon = "stretched:session/portraits/" + template.icon;
 		Engine.GetGUIObjectByName("researchStartedIcon[" + numButtons + "]").sprite = icon;
 
 		// Scale the progress indicator.
 		let size = Engine.GetGUIObjectByName("researchStartedProgressSlider[" + numButtons + "]").size;
 
 		// Buttons are assumed to be square, so left/right offsets can be used for top/bottom.
 		size.top = size.left + Math.round(researchStarted[tech].progress * (size.right - size.left));
 		Engine.GetGUIObjectByName("researchStartedProgressSlider[" + numButtons + "]").size = size;
 
 		++numButtons;
 	}
 
 	// Hide unused buttons.
 	for (let i = numButtons; i < 10; ++i)
 		Engine.GetGUIObjectByName("researchStartedButton[" + i + "]").hidden = true;
 }
 
 /**
  * Toggles the display of status bars for all of the player's entities.
  *
  * @param {Boolean} remove - Whether to hide all previously shown status bars.
  */
 function recalculateStatusBarDisplay(remove = false)
 {
 	let entities;
 	if (g_ShowAllStatusBars && !remove)
 		entities = g_ViewedPlayer == -1 ?
 			Engine.PickNonGaiaEntitiesOnScreen() :
 			Engine.PickPlayerEntitiesOnScreen(g_ViewedPlayer);
 	else
 	{
 		let selected = g_Selection.toList();
 		for (let ent in g_Selection.highlighted)
 			selected.push(g_Selection.highlighted[ent]);
 
 		// Remove selected entities from the 'all entities' array,
 		// to avoid disabling their status bars.
 		entities = Engine.GuiInterfaceCall(
 			g_ViewedPlayer == -1 ? "GetNonGaiaEntities" : "GetPlayerEntities", {
 				"viewedPlayer": g_ViewedPlayer
 			}).filter(idx => selected.indexOf(idx) == -1);
 	}
 
 	Engine.GuiInterfaceCall("SetStatusBars", {
 		"entities": entities,
 		"enabled": g_ShowAllStatusBars && !remove
 	});
 }
 
 // Update the additional list of entities to be highlighted.
 function updateAdditionalHighlight()
 {
 	let entsAdd = []; // list of entities units to be highlighted
 	let entsRemove = [];
 	let highlighted = g_Selection.toList();
 	for (let ent in g_Selection.highlighted)
 		highlighted.push(g_Selection.highlighted[ent]);
 
 	if (g_ShowGuarding)
 	{
 		// flag the guarding entities to add in this additional highlight
 		for (let sel in g_Selection.selected)
 		{
 			let state = GetEntityState(g_Selection.selected[sel]);
 			if (!state.guard || !state.guard.entities.length)
 				continue;
 
 			for (let ent of state.guard.entities)
 				if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
 					entsAdd.push(ent);
 		}
 	}
 
 	if (g_ShowGuarded)
 	{
 		// flag the guarded entities to add in this additional highlight
 		for (let sel in g_Selection.selected)
 		{
 			let state = GetEntityState(g_Selection.selected[sel]);
 			if (!state.unitAI || !state.unitAI.isGuarding)
 				continue;
 			let ent = state.unitAI.isGuarding;
 			if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
 				entsAdd.push(ent);
 		}
 	}
 
 	// flag the entities to remove (from the previously added) from this additional highlight
 	for (let ent of g_AdditionalHighlight)
 		if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1 && entsRemove.indexOf(ent) == -1)
 			entsRemove.push(ent);
 
 	_setHighlight(entsAdd, g_HighlightedAlpha, true);
 	_setHighlight(entsRemove, 0, false);
 	g_AdditionalHighlight = entsAdd;
 }
 
 function playAmbient()
 {
 	Engine.PlayAmbientSound(g_Ambient[Math.floor(Math.random() * g_Ambient.length)], true);
 }
 
 function getBuildString()
 {
 	return sprintf(translate("Build: %(buildDate)s (%(revision)s)"), {
 		"buildDate": Engine.GetBuildTimestamp(0),
 		"revision": Engine.GetBuildTimestamp(2)
 	});
 }
 
 function showTimeWarpMessageBox()
 {
 	messageBox(
 		500, 250,
 		translate("Note: time warp mode is a developer option, and not intended for use over long periods of time. Using it incorrectly may cause the game to run out of memory or crash."),
 		translate("Time warp mode")
 	);
 }
 
 /**
  * Send a report on the gamestatus to the lobby.
  */
 function reportGame()
 {
 	// Only 1v1 games are rated (and Gaia is part of g_Players)
 	if (!Engine.HasXmppClient() || !Engine.IsRankedGame() ||
 	    g_Players.length != 3 || Engine.GetPlayerID() == -1)
 		return;
 
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 
 	let unitsClasses = [
 		"total",
 		"Infantry",
 		"Worker",
 		"Female",
 		"Cavalry",
 		"Champion",
 		"Hero",
 		"Ship",
 		"Trader"
 	];
 
 	let unitsCountersTypes = [
 		"unitsTrained",
 		"unitsLost",
 		"enemyUnitsKilled"
 	];
 
 	let buildingsClasses = [
 		"total",
 		"CivCentre",
 		"House",
 		"Economic",
 		"Outpost",
 		"Military",
 		"Fortress",
 		"Wonder"
 	];
 
 	let buildingsCountersTypes = [
 		"buildingsConstructed",
 		"buildingsLost",
 		"enemyBuildingsDestroyed"
 	];
 
 	let resourcesTypes = [
 		"wood",
 		"food",
 		"stone",
 		"metal"
 	];
 
 	let resourcesCounterTypes = [
 		"resourcesGathered",
 		"resourcesUsed",
 		"resourcesSold",
 		"resourcesBought"
 	];
 
 	let playerStatistics = {};
 
 	// Unit Stats
 	for (let unitCounterType of unitsCountersTypes)
 	{
 		if (!playerStatistics[unitCounterType])
 			playerStatistics[unitCounterType] = { };
 		for (let unitsClass of unitsClasses)
 			playerStatistics[unitCounterType][unitsClass] = "";
 	}
 
 	playerStatistics.unitsLostValue = "";
 	playerStatistics.unitsKilledValue = "";
 	// Building stats
 	for (let buildingCounterType of buildingsCountersTypes)
 	{
 		if (!playerStatistics[buildingCounterType])
 			playerStatistics[buildingCounterType] = { };
 		for (let buildingsClass of buildingsClasses)
 			playerStatistics[buildingCounterType][buildingsClass] = "";
 	}
 
 	playerStatistics.buildingsLostValue = "";
 	playerStatistics.enemyBuildingsDestroyedValue = "";
 	// Resources
 	for (let resourcesCounterType of resourcesCounterTypes)
 	{
 		if (!playerStatistics[resourcesCounterType])
 			playerStatistics[resourcesCounterType] = { };
 		for (let resourcesType of resourcesTypes)
 			playerStatistics[resourcesCounterType][resourcesType] = "";
 	}
 	playerStatistics.resourcesGathered.vegetarianFood = "";
 
 	playerStatistics.tradeIncome = "";
 	// Tribute
 	playerStatistics.tributesSent = "";
 	playerStatistics.tributesReceived = "";
 	// Total
 	playerStatistics.economyScore = "";
 	playerStatistics.militaryScore = "";
 	playerStatistics.totalScore = "";
 	// Various
 	playerStatistics.treasuresCollected = "";
 	playerStatistics.lootCollected = "";
 	playerStatistics.feminisation = "";
 	playerStatistics.percentMapExplored = "";
 
 	let mapName = g_GameAttributes.settings.Name;
 	let playerStates = "";
 	let playerCivs = "";
 	let teams = "";
 	let teamsLocked = true;
 
 	// Serialize the statistics for each player into a comma-separated list.
 	// Ignore gaia
 	for (let i = 1; i < extendedSimState.players.length; ++i)
 	{
 		let player = extendedSimState.players[i];
 
 		playerStates += player.state + ",";
 		playerCivs += player.civ + ",";
 		teams += player.team + ",";
 		teamsLocked = teamsLocked && player.teamsLocked;
 		for (let resourcesCounterType of resourcesCounterTypes)
 			for (let resourcesType of resourcesTypes)
 				playerStatistics[resourcesCounterType][resourcesType] += player.statistics[resourcesCounterType][resourcesType] + ",";
 		playerStatistics.resourcesGathered.vegetarianFood += player.statistics.resourcesGathered.vegetarianFood + ",";
 
 		for (let unitCounterType of unitsCountersTypes)
 			for (let unitsClass of unitsClasses)
 				playerStatistics[unitCounterType][unitsClass] += player.statistics[unitCounterType][unitsClass] + ",";
 
 		for (let buildingCounterType of buildingsCountersTypes)
 			for (let buildingsClass of buildingsClasses)
 				playerStatistics[buildingCounterType][buildingsClass] += player.statistics[buildingCounterType][buildingsClass] + ",";
 		let total = 0;
 		for (let type in player.statistics.resourcesGathered)
 			total += player.statistics.resourcesGathered[type];
 
 		playerStatistics.economyScore += total + ",";
 		playerStatistics.militaryScore += Math.round((player.statistics.enemyUnitsKilledValue +
 			player.statistics.enemyBuildingsDestroyedValue) / 10)  + ",";
 		playerStatistics.totalScore += (total + Math.round((player.statistics.enemyUnitsKilledValue +
 			player.statistics.enemyBuildingsDestroyedValue) / 10)) + ",";
 		playerStatistics.tradeIncome += player.statistics.tradeIncome + ",";
 		playerStatistics.tributesSent += player.statistics.tributesSent + ",";
 		playerStatistics.tributesReceived += player.statistics.tributesReceived + ",";
 		playerStatistics.percentMapExplored += player.statistics.percentMapExplored + ",";
 		playerStatistics.treasuresCollected += player.statistics.treasuresCollected + ",";
 		playerStatistics.lootCollected += player.statistics.lootCollected + ",";
 	}
 
 	// Send the report with serialized data
 	let reportObject = {};
 	reportObject.timeElapsed = extendedSimState.timeElapsed;
 	reportObject.playerStates = playerStates;
 	reportObject.playerID = Engine.GetPlayerID();
 	reportObject.matchID = g_GameAttributes.matchID;
 	reportObject.civs = playerCivs;
 	reportObject.teams = teams;
 	reportObject.teamsLocked = String(teamsLocked);
 	reportObject.ceasefireActive = String(extendedSimState.ceasefireActive);
 	reportObject.ceasefireTimeRemaining = String(extendedSimState.ceasefireTimeRemaining);
 	reportObject.mapName = mapName;
 	reportObject.economyScore = playerStatistics.economyScore;
 	reportObject.militaryScore = playerStatistics.militaryScore;
 	reportObject.totalScore = playerStatistics.totalScore;
 	for (let rct of resourcesCounterTypes)
 	{
 		for (let rt of resourcesTypes)
 			reportObject[rt+rct.substr(9)] = playerStatistics[rct][rt];
 			// eg. rt = food rct.substr = Gathered rct = resourcesGathered
 	}
 	reportObject.vegetarianFoodGathered = playerStatistics.resourcesGathered.vegetarianFood;
 	for (let type of unitsClasses)
 	{
 		// eg. type = Infantry (type.substr(0,1)).toLowerCase()+type.substr(1) = infantry
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"UnitsTrained"] = playerStatistics.unitsTrained[type];
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"UnitsLost"] = playerStatistics.unitsLost[type];
 		reportObject["enemy"+type+"UnitsKilled"] = playerStatistics.enemyUnitsKilled[type];
 	}
 	for (let type of buildingsClasses)
 	{
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"BuildingsConstructed"] = playerStatistics.buildingsConstructed[type];
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"BuildingsLost"] = playerStatistics.buildingsLost[type];
 		reportObject["enemy"+type+"BuildingsDestroyed"] = playerStatistics.enemyBuildingsDestroyed[type];
 	}
 	reportObject.tributesSent = playerStatistics.tributesSent;
 	reportObject.tributesReceived = playerStatistics.tributesReceived;
 	reportObject.percentMapExplored = playerStatistics.percentMapExplored;
 	reportObject.treasuresCollected = playerStatistics.treasuresCollected;
 	reportObject.lootCollected = playerStatistics.lootCollected;
 	reportObject.tradeIncome = playerStatistics.tradeIncome;
 
 	Engine.SendGameReport(reportObject);
 }
Index: ps/trunk/binaries/data/mods/public/gui/structree/structree.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/structree/structree.xml	(revision 18612)
+++ ps/trunk/binaries/data/mods/public/gui/structree/structree.xml	(revision 18613)
@@ -1,124 +1,125 @@
 <?xml version="1.0" encoding="utf-8"?>
 
 <objects>
 	<script file="gui/common/functions_civinfo.js"/>
+	<script file="gui/common/functions_global_object.js"/>
 	<script file="gui/common/functions_utility.js"/>
 	<script file="gui/common/tooltips.js"/>
 	<script file="gui/structree/structree.js"/>
 	<script file="gui/structree/draw.js"/>
 	<script file="gui/structree/helper.js"/>
 	<script file="gui/structree/load.js"/>
 
 	<!-- Add a translucent black background to fade out the menu page -->
 	<object type="image" z="0" sprite="bkTranslucent"/>
 
 	<object type="image" style="ModernDialog" size="16 24 100%-16 100%-24">
 		<object style="TitleText" type="text" size="50%-128 -18 50%+128 14">
 			<translatableAttribute id="caption">Structure Tree</translatableAttribute>
 		</object>
 
 		<!-- Civ selection -->
 		<object size="16 10 100%-16 30">
 			<object
 				name="civSelectionHeading"
 				type="text"
 				font="sans-bold-16"
 				textcolor="white"
 				text_align="left"
 				size="100%-264 10 100%-160 48">
 				<translatableAttribute id="caption">Civilization:</translatableAttribute>
 			</object>
 
 			<object name="civSelection" type="dropdown" style="ModernDropDown" size="100%-160 8 100% 34">
 				<action on="SelectionChange">selectCiv(this.list_data[this.selected]);</action>
 			</object>
 		</object>
 
 		<object
 			name="civEmblem"
 			type="image"
 			size="6 6 96+6 96+6"
 			sprite="stretched:pregame/shell/logo/wfg_logo_white.png"
 		/>
 
 		<object
 			name="civName"
 			type="text"
 			font="sans-bold-20"
 			textcolor="white"
 			text_align="left"
 			text_valign="top"
 			size="104 32 100%-8 96"
 		/>
 
 		<object
 			name="civHistory"
 			type="text"
 			font="sans-12"
 			textcolor="white"
 			text_align="left"
 			text_valign="top"
 			size="104 52 100%-8 100%"
 		/>
 
 		<!-- Structure Tree display -->
 		<object size="0 54+64 100%-124 100%-54" name="display_tree">
 			<repeat count="4" var="n">
 				<object name="phase[n]_phase" type="image"/>
 				<object name="phase[n]_bar">
 					<repeat count="4" var="k">
 						<object name="phase[n]_bar[k]" type="image" sprite="ProdBar">
 							<object name="phase[n]_bar[k]_icon" type="image" size="2 2 20 20"/>
 						</object>
 					</repeat>
 				</object>
 			</repeat>
 
 			<object type="image" style="TreeDisplay" size="48+16+8 0 100%-12 100%">
 				<include file="gui/structree/rows.xml"/>
 			</object>
 		</object>
 
 		<!-- Trainer Units display -->
 		<object size="100%-124 54+64 100%-16 100%-54" name="display_trainers">
 			<object
 				type="text"
 				font="sans-bold-14"
 				textcolor="white"
 				text_align="center"
 				text_valign="top"
 				size="0 0 100% 16"
 			>
 				<translatableAttribute id="caption">Trainer Units</translatableAttribute>
 			</object>
 			
 			<object type="image" style="TreeDisplay" size="0 24 100% 100%">
 				<repeat count="3" var="t">
 					<object type="image" style="StructBox" name="trainer[t]">
 						<object type="text" style="StructNameSpecific" name="trainer[t]_name"/>
 						<object type="image" style="StructIcon" name="trainer[t]_icon"
 							sprite="stretched:pregame/shell/logo/wfg_logo_white.png"
 						/>
 						<object name="trainer[t]_row">
 							<repeat count="4" var="p">
 								<object type="image" style="ProdBox" name="trainer[t]_prod[p]"/>
 							</repeat>
 						</object>
 					</object>
 				</repeat>
 			</object>
 		</object>
 
 		<!-- Close dialog -->
 		<object
 			type="button"
 			style="StoneButton"
 			size="100%-164 100%-44 100%-16 100%-16"
 			hotkey="cancel"
 		>
 			<translatableAttribute id="caption">Close</translatableAttribute>
 			<action on="Press">closeStrucTree();</action>
 		</object>
 
 	</object>
 </objects>
Index: ps/trunk/source/ps/GameSetup/GameSetup.cpp
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 18612)
+++ ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 18613)
@@ -1,1572 +1,1577 @@
 /* Copyright (C) 2016 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 "lib/sysdep/cpu.h"
 #include "lib/sysdep/gfx.h"
 #include "lib/sysdep/os_cpu.h"
 #include "lib/tex/tex.h"
 #if OS_WIN
 #include "lib/sysdep/os/win/wversion.h"
 #endif
 
 #include "graphics/CinemaManager.h"
 #include "graphics/CinemaPath.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/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 "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
 
 #if OS_WIN
 extern void wmi_Shutdown();
 #endif
 
 extern void restart_engine();
 
 #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);
 	g_GUI->GetActiveGUI()->GetScriptInterface()->SetGlobal("g_LoadDescription", pending_task, true);
 	g_GUI->GetActiveGUI()->SendEventToAll("progress");
 }
 
 
 
 void Render()
 {
 	PROFILE3("render");
 
 	if (g_SoundManager)
 		g_SoundManager->IdleTask();
 
 	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 (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, 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, 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();
 }
 
 
 static size_t OperatingSystemFootprint()
 {
 #if OS_WIN
 	switch(wversion_Number())
 	{
 	case WVERSION_2K:
 	case WVERSION_XP:
 		return 150;
 	case WVERSION_XP64:
 		return 200;
 	default:	// newer Windows version: assume the worst, and don't warn
 	case WVERSION_VISTA:
 		return 300;
 	case WVERSION_7:
 		return 250;
 	}
 #else
 	return 200;
 #endif
 }
 
 static size_t ChooseCacheSize()
 {
 	// (all sizes in MiB and signed to allow temporarily negative computations)
 
 	const ssize_t total = (ssize_t)os_cpu_MemorySize();
 	// (NB: os_cpu_MemoryAvailable is useless on Linux because free memory
 	// is marked as "in use" by OS caches.)
 	const ssize_t os = (ssize_t)OperatingSystemFootprint();
 	const ssize_t game = 300;	// estimated working set
 
 	ssize_t cache = 400;	// upper bound: total size of our data
 
 	// the cache reserves contiguous address space, which is a precious
 	// resource on 32-bit systems, so don't use too much:
 	if(ARCH_IA32 || sizeof(void*) == 4)
 		cache = std::min(cache, (ssize_t)200);
 
 	// try to leave over enough memory for the OS and game
 	cache = std::min(cache, total-os-game);
 
 	// always provide at least this much to ensure correct operation
 	cache = std::max(cache, (ssize_t)64);
 
 	debug_printf("Cache: %d (total: %d) MiB\n", (int)cache, (int)total);
 	return size_t(cache)*MiB;
 }
 
 
 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;
 }
 
 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);
 
 	const size_t cacheSize = ChooseCacheSize();
 	g_VFS = CreateVfs(cacheSize);
 	
 	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);
 }
 
 
 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);
 	
 	in_add_handler(cinema_manager_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, 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_WATERUGLY, g_WaterUgly);
 	g_ConfigDB.SetValueBool(CFG_SYSTEM, "waterugly", g_WaterUgly);
 	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_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);
 
 #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()
 {
+	if (g_Game && g_Game->IsGameStarted() && !g_Game->IsVisualReplay() &&
+	    g_AtlasGameLoop && !g_AtlasGameLoop->running)
+		VisualReplay::SaveReplayMetadata(g_GUI->GetActiveGUI()->GetScriptInterface().get());
+
 	SAFE_DELETE(g_NetClient);
 	SAFE_DELETE(g_NetServer);
 	SAFE_DELETE(g_Game);
 
 	ISoundManager::CloseGame();
 }
 
 
 void Shutdown(int flags)
 {
 	if ((flags & SHUTDOWN_FROM_CONFIG))
 		goto from_config;
 
 	EndGame();
 
 	SAFE_DELETE(g_XmppClient);
 
 	ShutdownPs();
 
 	TIMER_BEGIN(L"shutdown TexMan");
 	delete &g_TexMan;
 	TIMER_END(L"shutdown TexMan");
 
 	// destroy renderer
 	TIMER_BEGIN(L"shutdown Renderer");
 	delete &g_Renderer;
 	g_VBMan.Shutdown();
 	TIMER_END(L"shutdown Renderer");
 
 	g_Profiler2.ShutdownGPU();
 
 	#if OS_WIN
 		TIMER_BEGIN(L"shutdown wmi");
 		wmi_Shutdown();
 		TIMER_END(L"shutdown wmi");
 	#endif
 
 	// 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");
 
 	g_VideoMode.Shutdown();
 
 	TIMER_BEGIN(L"shutdown UserReporter");
 	g_UserReporter.Deinitialize();
 	TIMER_END(L"shutdown UserReporter");
 
 	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);
 
 	// 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
 	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
 			restart_engine();
 			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();
 
 	if (!g_Quickstart)
 		g_UserReporter.Initialize(); // after config
 
 	PROFILE2_EVENT("Init finished");
 	return true;
 }
 
 void InitGraphics(const CmdLineArgs& args, int flags)
 {
 	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);
 			}
 			InitPs(setup_gui, L"page_pregame.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 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-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-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).
  *
  * 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-seed=SEED            sets random map SEED value
  *                                 (default 0, use -1 for random)
  * -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 02" -autostart-host -autostart-host-players=2 -autostart-playername="Bob"
  * 
  * 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
 */
 bool Autostart(const CmdLineArgs& args)
 {
 	CStr autoStartName = args.Get("autostart");
 
 	if (autoStartName.empty())
 		return false;
 
 	g_Game = new CGame();
 
 	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")
 	{
 		// Default seed is 0
 		u32 seed = 0;
 		CStr seedArg = args.Get("autostart-seed");
 
 		if (!seedArg.empty())
 		{
 			// Random seed value
 			if (seedArg == "-1")
 				seed = rand();
 			else
 				seed = seedArg.ToULong();
 		}
 		
 		// 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, "Seed", seed);		// Random seed
 		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);
 
 	// 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);
 		}
 	}
 
 	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.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);
 
 	JS::RootedValue mpInitData(cx);
 	scriptInterface.Eval("({isNetworked:true, playerAssignments:{}})", &mpInitData);
 	scriptInterface.SetProperty(mpInitData, "attribs", attrs);
 
 	// Get optional playername
 	CStrW userName = L"anonymous";
 	if (args.Has("autostart-playername"))
 	{
 		userName = args.Get("autostart-playername").FromUTF8();
 	}
 
 	if (args.Has("autostart-host"))
 	{
 		InitPs(true, L"page_loading.xml", &scriptInterface, mpInitData);
 
 		size_t maxPlayers = 2;
 		if (args.Has("autostart-host-players"))
 			maxPlayers = args.Get("autostart-host-players").ToUInt();
 
 		g_NetServer = new CNetServer(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"))
 	{
 		InitPs(true, L"page_loading.xml", &scriptInterface, mpInitData);
 
 		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(1);
 		g_Game->StartGame(&attrs, "");
 
 		LDR_NonprogressiveLoad();
 
 		PSRETURN ret = g_Game->ReallyStartGame();
 		ENSURE(ret == PSRETURN_OK);
 
 		InitPs(true, L"page_session.xml", NULL, JS::UndefinedHandleValue);
 	}
 
 	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);
 
 	// TODO: Non progressive load can fail - need a decent way to handle this
 	LDR_NonprogressiveLoad();
 
 	ENSURE(g_Game->ReallyStartGame() == PSRETURN_OK);
 
 	ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 
 	InitPs(true, L"page_session.xml", &scriptInterface, JS::UndefinedHandleValue);
 	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());
 	// Cancel loader
 	LDR_Cancel();
 
 	// Call the cancelOnError GUI function, defined in ..gui/common/functions_utility_error.js
 	// So all GUI pages that load games should include this script
 	if (g_GUI && g_GUI->HasPages())
 	{
 		if (pScriptInterface->HasProperty(global, "cancelOnError" ))
 			pScriptInterface->CallFunctionVoid(global, "cancelOnError", 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/ps/VisualReplay.cpp
===================================================================
--- ps/trunk/source/ps/VisualReplay.cpp	(revision 18612)
+++ ps/trunk/source/ps/VisualReplay.cpp	(revision 18613)
@@ -1,342 +1,350 @@
 /* Copyright (C) 2016 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 "VisualReplay.h"
 #include "graphics/GameView.h"
 #include "gui/GUIManager.h"
 #include "lib/allocators/shared_ptr.h"
 #include "lib/external_libraries/libsdl.h"
 #include "lib/utf8.h"
 #include "network/NetClient.h"
 #include "network/NetServer.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/Paths.h"
 #include "ps/Mod.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Replay.h"
 #include "ps/Util.h"
 #include "scriptinterface/ScriptInterface.h"
 
 /**
  * Filter too short replays (value in seconds).
  */
 const u8 minimumReplayDuration = 3;
 
 OsPath VisualReplay::GetDirectoryName()
 {
 	const Paths paths(g_args);
 	return OsPath(paths.UserData() / "replays" / engine_version);
 }
 
 void VisualReplay::StartVisualReplay(const CStrW& directory)
 {
 	ENSURE(!g_NetServer);
 	ENSURE(!g_NetClient);
 	ENSURE(!g_Game);
 
 	const OsPath replayFile = VisualReplay::GetDirectoryName() / directory / L"commands.txt";
 
 	if (!FileExists(replayFile))
 		return;
 
 	g_Game = new CGame(false, false);
 	g_Game->StartVisualReplay(replayFile.string8());
 }
 
 /**
  * Load all replays found in the directory.
  *
  * Since files are spread across the harddisk,
  * loading hundreds of them can consume a lot of time.
  */
 JS::Value VisualReplay::GetReplays(ScriptInterface& scriptInterface)
 {
 	TIMER(L"GetReplays");
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	u32 i = 0;
 	DirectoryNames directories;
 	JS::RootedObject replays(cx, JS_NewArrayObject(cx, 0));
 
 	if (GetDirectoryEntries(GetDirectoryName(), NULL, &directories) == INFO::OK)
 		for (OsPath& directory : directories)
 		{
 			if (SDL_QuitRequested())
 				return JSVAL_NULL;
 
 			JS::RootedValue replayData(cx, LoadReplayData(scriptInterface, directory));
 			if (!replayData.isNull())
 				JS_SetElement(cx, replays, i++, replayData);
 		}
 	return JS::ObjectValue(*replays);
 }
 
 /**
  * Move the cursor backwards until a newline was read or the beginning of the file was found.
  * Either way the cursor points to the beginning of a newline.
  *
  * @return The current cursor position or -1 on error.
  */
 inline int goBackToLineBeginning(std::istream* replayStream, const CStr& fileName, const u64& fileSize)
 {
 	int currentPos;
 	char character;
 	for (int characters = 0; characters < 10000; ++characters)
 	{
 		currentPos = (int) replayStream->tellg();
 
 		// Stop when reached the beginning of the file
 		if (currentPos == 0)
 			return currentPos;
 
 		if (!replayStream->good())
 		{
 			LOGERROR("Unknown error when returning to the last line (%i of %lu) of %s", currentPos, fileSize, fileName.c_str());
 			return -1;
 		}
 
 		// Stop when reached newline
 		replayStream->get(character);
 		if (character == '\n')
 			return currentPos;
 
 		// Otherwise go back one character.
 		// Notice: -1 will set the cursor back to the most recently read character.
 		replayStream->seekg(-2, std::ios_base::cur);
 	}
 
 	LOGERROR("Infinite loop when going back to a line beginning in %s", fileName.c_str());
 	return -1;
 }
 
 /**
  * Compute game duration. Assume constant turn length.
  * Find the last line that starts with "turn" by reading the file backwards.
  *
  * @return seconds or -1 on error
  */
-inline int getReplayDuration(std::istream *replayStream, const CStr& fileName, const u64& fileSize)
+inline int getReplayDuration(std::istream* replayStream, const CStr& fileName, const u64& fileSize)
 {
 	CStr type;
 
 	// Move one character before the file-end
 	replayStream->seekg(-2, std::ios_base::end);
 
 	// Infinite loop protection, should never occur.
 	// There should be about 5 lines to read until a turn is found.
 	for (int linesRead = 1; linesRead < 1000; ++linesRead)
 	{
 		int currentPosition = goBackToLineBeginning(replayStream, fileName, fileSize);
 
 		// Read error or reached file beginning. No turns exist.
 		if (currentPosition < 1)
 			return -1;
 
 		if (!replayStream->good())
 		{
 			LOGERROR("Read error when determining replay duration at %i of %llu in %s", currentPosition - 2, fileSize, fileName.c_str());
 			return -1;
 		}
 
 		// Found last turn, compute duration.
 		if ((u64) currentPosition + 4 < fileSize && (*replayStream >> type).good() && type == "turn")
 		{
 			u32 turn = 0, turnLength = 0;
 			*replayStream >> turn >> turnLength;
 			return (turn+1) * turnLength / 1000; // add +1 as turn numbers starts with 0
 		}
 
 		// Otherwise move cursor back to the character before the last newline
 		replayStream->seekg(currentPosition - 2, std::ios_base::beg);
 	}
 
 	LOGERROR("Infinite loop when determining replay duration for %s", fileName.c_str());
 	return -1;
 }
 
 JS::Value VisualReplay::LoadReplayData(ScriptInterface& scriptInterface, OsPath& directory)
 {
 	// The directory argument must not be constant, otherwise concatenating will fail
 	const OsPath replayFile = GetDirectoryName() / directory / L"commands.txt";
 
 	if (!FileExists(replayFile))
 		return JSVAL_NULL;
 
 	// Get file size and modification date
 	CFileInfo fileInfo;
 	GetFileInfo(replayFile, &fileInfo);
 	const u64 fileTime = (u64)fileInfo.MTime() & ~1; // skip lowest bit, since zip and FAT don't preserve it (according to CCacheLoader::LooseCachePath)
 	const u64 fileSize = (u64)fileInfo.Size();
 
 	if (fileSize == 0)
 		return JSVAL_NULL;
 
 	// Open file
 	const CStr fileName = replayFile.string8();
 	std::ifstream* replayStream = new std::ifstream(fileName.c_str());
 
 	// File must begin with "start"
 	CStr type;
 	if (!(*replayStream >> type).good())
 	{
 		LOGERROR("Couldn't open %s. Non-latin characters are not supported yet.", fileName.c_str());
 		SAFE_DELETE(replayStream);
 		return JSVAL_NULL;
 	}
 	if (type != "start")
 	{
 		LOGWARNING("The replay %s is broken!", fileName.c_str());
 		SAFE_DELETE(replayStream);
 		return JSVAL_NULL;
 	}
 
 	// Parse header / first line
 	CStr header;
 	std::getline(*replayStream, header);
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue attribs(cx);
 	if (!scriptInterface.ParseJSON(header, &attribs))
 	{
 		LOGERROR("Couldn't parse replay header of %s", fileName.c_str());
 		SAFE_DELETE(replayStream);
 		return JSVAL_NULL;
 	}
 
 	// Ensure "turn" after header
 	if (!(*replayStream >> type).good() || type != "turn")
 	{
 		SAFE_DELETE(replayStream);
 		return JSVAL_NULL; // there are no turns at all
 	}
 
 	// Don't process files of rejoined clients
 	u32 turn = 1;
 	*replayStream >> turn;
 	if (turn != 0)
 	{
 		SAFE_DELETE(replayStream);
 		return JSVAL_NULL;
 	}
 
 	int duration = getReplayDuration(replayStream, fileName, fileSize);
 
 	SAFE_DELETE(replayStream);
 
 	// Ensure minimum duration
 	if (duration < minimumReplayDuration)
 		return JSVAL_NULL;
 
 	// Return the actual data
 	JS::RootedValue replayData(cx);
 	scriptInterface.Eval("({})", &replayData);
 	scriptInterface.SetProperty(replayData, "file", replayFile);
 	scriptInterface.SetProperty(replayData, "directory", directory);
 	scriptInterface.SetProperty(replayData, "filemod_timestamp", std::to_string(fileTime));
 	scriptInterface.SetProperty(replayData, "attribs", attribs);
 	scriptInterface.SetProperty(replayData, "duration", duration);
 	return replayData;
 }
 
 bool VisualReplay::DeleteReplay(const CStrW& replayDirectory)
 {
 	if (replayDirectory.empty())
 		return false;
 
 	const OsPath directory = GetDirectoryName() / replayDirectory;
 	return DirectoryExists(directory) && DeleteDirectory(directory) == INFO::OK;
 }
 
 
 JS::Value VisualReplay::GetReplayAttributes(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName)
 {
 	// Create empty JS object
 	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue attribs(cx);
 	pCxPrivate->pScriptInterface->Eval("({})", &attribs);
 
 	// Return empty object if file doesn't exist
 	const OsPath replayFile = GetDirectoryName() / directoryName / L"commands.txt";
 	if (!FileExists(replayFile))
 		return attribs;
 
 	// Open file
 	std::istream* replayStream = new std::ifstream(replayFile.string8().c_str());
 	CStr type, line;
 	ENSURE((*replayStream >> type).good() && type == "start");
 
 	// Read and return first line
 	std::getline(*replayStream, line);
 	pCxPrivate->pScriptInterface->ParseJSON(line, &attribs);
 	SAFE_DELETE(replayStream);;
 	return attribs;
 }
 
-// TODO: enhancement: how to save the data if the process is killed? (case SDL_QUIT in main.cpp)
-void VisualReplay::SaveReplayMetadata(const CStrW& data)
+void VisualReplay::SaveReplayMetadata(ScriptInterface* scriptInterface)
 {
-	// TODO: enhancement: use JS::HandleValue similar to SaveGame
-	if (!g_Game)
+	JSContext* cx = scriptInterface->GetContext();
+	JSAutoRequest rq(cx);
+
+	JS::RootedValue metadata(cx);
+	JS::RootedValue global(cx, scriptInterface->GetGlobalObject());
+
+	if (!scriptInterface->CallFunction(global, "getReplayMetadata", &metadata))
+	{
+		LOGERROR("Could not save replay metadata!");
 		return;
+	}
 
 	// Get the directory of the currently active replay
 	const OsPath fileName = g_Game->GetReplayLogger().GetDirectory() / L"metadata.json";
 	CreateDirectories(fileName.Parent(), 0700);
 
 	std::ofstream stream (fileName.string8().c_str(), std::ofstream::out | std::ofstream::trunc);
-	stream << utf8_from_wstring(data);
+	stream << scriptInterface->StringifyJSON(&metadata, false);
 	stream.close();
+	debug_printf("Saved replay metadata to %s\n", fileName.string8().c_str());
 }
 
 bool VisualReplay::HasReplayMetadata(const CStrW& directoryName)
 {
 	const OsPath filePath(GetDirectoryName() / directoryName / L"metadata.json");
 
 	if (!FileExists(filePath))
 		return false;
 
 	CFileInfo fileInfo;
 	GetFileInfo(filePath, &fileInfo);
 
 	return fileInfo.Size() > 0;
 }
 
 JS::Value VisualReplay::GetReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName)
 {
 	if (!HasReplayMetadata(directoryName))
 		return JSVAL_NULL;
 
 	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue metadata(cx);
 
 	std::ifstream* stream = new std::ifstream(OsPath(GetDirectoryName() / directoryName / L"metadata.json").string8());
 	ENSURE(stream->good());
 	CStr line;
 	std::getline(*stream, line);
 	stream->close();
 	SAFE_DELETE(stream);
 	pCxPrivate->pScriptInterface->ParseJSON(line, &metadata);
 
 	return metadata;
 }
Index: ps/trunk/source/ps/VisualReplay.h
===================================================================
--- ps/trunk/source/ps/VisualReplay.h	(revision 18612)
+++ ps/trunk/source/ps/VisualReplay.h	(revision 18613)
@@ -1,88 +1,88 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 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_REPlAY
 #define INCLUDED_REPlAY
 
 #include "scriptinterface/ScriptInterface.h"
 class CSimulation2;
 class CGUIManager;
 
 /**
  * Contains functions for visually replaying past games.
  */
 namespace VisualReplay
 {
 
 /**
  * Returns the path to the sim-log directory (that contains the directories with the replay files.
  *
  * @param scriptInterface the ScriptInterface in which to create the return data.
  * @return OsPath the absolute file path
  */
 OsPath GetDirectoryName();
 
 /**
  * Replays the commands.txt file in the given subdirectory visually.
  */
 void StartVisualReplay(const CStrW& directory);
 
 /**
  * Get a list of replays to display in the GUI.
  *
  * @param scriptInterface the ScriptInterface in which to create the return data.
  * @return array of objects containing replay data
  */
 JS::Value GetReplays(ScriptInterface& scriptInterface);
 
 /**
  * Parses a commands.txt file and extracts metadata.
  * Works similarly to CGame::LoadReplayData().
  */
 JS::Value LoadReplayData(ScriptInterface& scriptInterface, OsPath& directory);
 
 /**
  * Permanently deletes the visual replay (including the parent directory)
  *
  * @param replayFile path to commands.txt, whose parent directory will be deleted
  * @return true if deletion was successful, false on error
  */
 bool DeleteReplay(const CStrW& replayFile);
 
 /**
  * Returns the parsed header of the replay file (commands.txt).
  */
 JS::Value GetReplayAttributes(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
 
 /**
  * Returns whether or not the metadata / summary screen data has been saved properly when the game ended.
  */
 bool HasReplayMetadata(const CStrW& directoryName);
 
 /**
  * Returns the metadata of a replay.
  */
 JS::Value GetReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
 
 /**
  * Saves the metadata from the session to metadata.json
  */
-void SaveReplayMetadata(const CStrW& data);
+void SaveReplayMetadata(ScriptInterface* scriptInterface);
 
 }
 
 #endif
Index: ps/trunk/source/ps/scripting/JSInterface_VisualReplay.cpp
===================================================================
--- ps/trunk/source/ps/scripting/JSInterface_VisualReplay.cpp	(revision 18612)
+++ ps/trunk/source/ps/scripting/JSInterface_VisualReplay.cpp	(revision 18613)
@@ -1,70 +1,64 @@
 /* Copyright (C) 2016 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 "ps/scripting/JSInterface_VisualReplay.h"
 
 #include "ps/CStr.h"
 #include "ps/Profile.h"
 #include "ps/VisualReplay.h"
 
 void JSI_VisualReplay::StartVisualReplay(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& directory)
 {
 	VisualReplay::StartVisualReplay(directory);
 }
 
 bool JSI_VisualReplay::DeleteReplay(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& replayFile)
 {
 	return VisualReplay::DeleteReplay(replayFile);
 }
 
 JS::Value JSI_VisualReplay::GetReplays(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return VisualReplay::GetReplays(*(pCxPrivate->pScriptInterface));
 }
 
 JS::Value JSI_VisualReplay::GetReplayAttributes(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName)
 {
 	return VisualReplay::GetReplayAttributes(pCxPrivate, directoryName);
 }
 
 bool JSI_VisualReplay::HasReplayMetadata(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& directoryName)
 {
 	return VisualReplay::HasReplayMetadata(directoryName);
 }
 
 JS::Value JSI_VisualReplay::GetReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName)
 {
 	return VisualReplay::GetReplayMetadata(pCxPrivate, directoryName);
 }
 
-void JSI_VisualReplay::SaveReplayMetadata(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& data)
-{
-	VisualReplay::SaveReplayMetadata(data);
-}
-
 void JSI_VisualReplay::RegisterScriptFunctions(ScriptInterface& scriptInterface)
 {
 	scriptInterface.RegisterFunction<JS::Value, &GetReplays>("GetReplays");
 	scriptInterface.RegisterFunction<bool, CStrW, &DeleteReplay>("DeleteReplay");
 	scriptInterface.RegisterFunction<void, CStrW, &StartVisualReplay>("StartVisualReplay");
 	scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayAttributes>("GetReplayAttributes");
 	scriptInterface.RegisterFunction<JS::Value, CStrW, &GetReplayMetadata>("GetReplayMetadata");
 	scriptInterface.RegisterFunction<bool, CStrW, &HasReplayMetadata>("HasReplayMetadata");
-	scriptInterface.RegisterFunction<void, CStrW, &SaveReplayMetadata>("SaveReplayMetadata");
 }
Index: ps/trunk/source/ps/scripting/JSInterface_VisualReplay.h
===================================================================
--- ps/trunk/source/ps/scripting/JSInterface_VisualReplay.h	(revision 18612)
+++ ps/trunk/source/ps/scripting/JSInterface_VisualReplay.h	(revision 18613)
@@ -1,36 +1,35 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 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_JSI_VISUALREPLAY
 #define INCLUDED_JSI_VISUALREPLAY
 
 #include "ps/VisualReplay.h"
 #include "scriptinterface/ScriptInterface.h"
 
 namespace JSI_VisualReplay
 {
 	void StartVisualReplay(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directory);
 	bool DeleteReplay(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& replayFile);
 	JS::Value GetReplays(ScriptInterface::CxPrivate* pCxPrivate);
 	JS::Value GetReplayAttributes(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
 	bool HasReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
 	JS::Value GetReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& directoryName);
-	void SaveReplayMetadata(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& data);
 	void RegisterScriptFunctions(ScriptInterface& scriptInterface);
 }
 
 #endif