Index: ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js	(revision 14418)
@@ -1,1562 +1,1562 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////
 // Constants
 const DEFAULT_NETWORKED_MAP = "Acropolis 01";
 const DEFAULT_OFFLINE_MAP = "Acropolis 01";
 
 // TODO: Move these somewhere like simulation\data\game_types.json, Atlas needs them too
-const VICTORY_TEXT = ["Conquest", "None"];
-const VICTORY_DATA = ["conquest", "endless"];
+const VICTORY_TEXT = ["Conquest", "Wonder", "None"];
+const VICTORY_DATA = ["conquest", "wonder", "endless"];
 const VICTORY_DEFAULTIDX = 0;
 const POPULATION_CAP = ["50", "100", "150", "200", "250", "300", "Unlimited"];
 const POPULATION_CAP_DATA = [50, 100, 150, 200, 250, 300, 10000];
 const POPULATION_CAP_DEFAULTIDX = 5;
 const STARTING_RESOURCES = ["Very Low", "Low", "Medium", "High", "Very High", "Deathmatch"];
 const STARTING_RESOURCES_DATA = [100, 300, 500, 1000, 3000, 50000];
 const STARTING_RESOURCES_DEFAULTIDX = 1;
 // Max number of players for any map
 const MAX_PLAYERS = 8;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Is this is a networked game, or offline
 var g_IsNetworked;
 
 // Is this user in control of game settings (i.e. is a network server, or offline player)
 var g_IsController;
 
 //Server name, if user is a server, connected to the multiplayer lobby
 var g_ServerName;
 
 // Are we currently updating the GUI in response to network messages instead of user input
 // (and therefore shouldn't send further messages to the network)
 var g_IsInGuiUpdate;
 
 var g_PlayerAssignments = {};
 
 // Default game setup attributes
 var g_DefaultPlayerData = [];
 var g_GameAttributes = {
 	settings: {}
 };
 
 var g_GameSpeeds = {};
 var g_MapSizes = {};
 
 var g_AIs = [];
 
 var g_ChatMessages = [];
 
 // Data caches
 var g_MapData = {};
 var g_CivData = {};
 
 var g_MapFilters = [];
 
 // Warn about the AI's nonexistent naval map support.
 var g_NavalWarning = "\n\n[font=\"serif-bold-12\"][color=\"orange\"]Warning:[/color][/font] \
 The AI does not support naval maps and may cause severe performance issues. \
 Naval maps are recommended to be played with human opponents only.";
 
 // To prevent the display locking up while we load the map metadata,
 // we'll start with a 'loading' message and switch to the main screen in the
 // tick handler
 var g_LoadingState = 0; // 0 = not started, 1 = loading, 2 = loaded
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
 function init(attribs)
 {
 	switch (attribs.type)
 	{
 	case "offline":
 		g_IsNetworked = false;
 		g_IsController = true;
 		break;
 	case "server":
 		g_IsNetworked = true;
 		g_IsController = true;
 		break;
 	case "client":
 		g_IsNetworked = true;
 		g_IsController = false;
 		break;
 	default:
 		error("Unexpected 'type' in gamesetup init: "+attribs.type);
 	}
 
 	if (attribs.serverName)
 		g_ServerName = attribs.serverName;
 
 	// Init the Cancel Button caption and tooltip
 	var cancelButton = getGUIObjectByName("cancelGame");
 	if(!Engine.HasXmppClient())
 	{
 		cancelButton.tooltip = "Return to the main menu."
 	}
 	else
 	{
 		cancelButton.tooltip = "Return to the lobby."
 	}
 
 }
 
 // Called after the map data is loaded and cached
 function initMain()
 {
 	// Load AI list and hide deprecated AIs
 	g_AIs = Engine.GetAIs();
 
 	// Sort AIs by displayed name
 	g_AIs.sort(function (a, b) {
 		return a.data.name < b.data.name ? -1 : b.data.name < a.data.name ? +1 : 0;
 	});
 
 	// Get default player data - remove gaia
 	g_DefaultPlayerData = initPlayerDefaults();
 	g_DefaultPlayerData.shift();
 	for (var i = 0; i < g_DefaultPlayerData.length; i++)
 		g_DefaultPlayerData[i].Civ = "random";
 
 	g_GameSpeeds = initGameSpeeds();
 	g_MapSizes = initMapSizes();
 
 	// Init civs
 	initCivNameList();
 
 	// Init map types
 	var mapTypes = getGUIObjectByName("mapTypeSelection");
 	mapTypes.list = ["Skirmish","Random","Scenario"];
 	mapTypes.list_data = ["skirmish","random","scenario"];
 
 	// Setup map filters - will appear in order they are added
 	addFilter("Default", function(settings) { return settings && !keywordTestOR(settings.Keywords, ["naval", "demo", "hidden"]); });
 	addFilter("Naval Maps", function(settings) { return settings && keywordTestAND(settings.Keywords, ["naval"]); });
 	addFilter("Demo Maps", function(settings) { return settings && keywordTestAND(settings.Keywords, ["demo"]); });
 	addFilter("All Maps", function(settings) { return true; });
 
 	// Populate map filters dropdown
 	var mapFilters = getGUIObjectByName("mapFilterSelection");
 	mapFilters.list = getFilters();
 	g_GameAttributes.mapFilter = "Default";
 
 	// Setup controls for host only
 	if (g_IsController)
 	{
 		mapTypes.selected = 0;
 		mapFilters.selected = 0;
 
 		// Create a unique ID for this match, to be used for identifying the same game reports
 		// for the lobby.
 		g_GameAttributes.matchID = Engine.GetMatchID();
 
 		initMapNameList();
 
 		var numPlayersSelection = getGUIObjectByName("numPlayersSelection");
 		var players = [];
 		for (var i = 1; i <= MAX_PLAYERS; ++i)
 			players.push(i);
 		numPlayersSelection.list = players;
 		numPlayersSelection.list_data = players;
 		numPlayersSelection.selected = MAX_PLAYERS - 1;
 
 		var gameSpeed = getGUIObjectByName("gameSpeed");
 		gameSpeed.hidden = false;
 		getGUIObjectByName("gameSpeedText").hidden = true;
 		gameSpeed.list = g_GameSpeeds.names;
 		gameSpeed.list_data = g_GameSpeeds.speeds;
 		gameSpeed.onSelectionChange = function()
 		{
 			// Update attributes so other players can see change
 			if (this.selected != -1)
 				g_GameAttributes.gameSpeed = g_GameSpeeds.speeds[this.selected];
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		}
 		gameSpeed.selected = g_GameSpeeds["default"];
 
 		var populationCaps = getGUIObjectByName("populationCap");
 		populationCaps.list = POPULATION_CAP;
 		populationCaps.list_data = POPULATION_CAP_DATA;
 		populationCaps.selected = POPULATION_CAP_DEFAULTIDX;
 		populationCaps.onSelectionChange = function()
 		{
 			if (this.selected != -1)
 				g_GameAttributes.settings.PopulationCap = POPULATION_CAP_DATA[this.selected];
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		}
 
 		var startingResourcesL = getGUIObjectByName("startingResources");
 		startingResourcesL.list = STARTING_RESOURCES;
 		startingResourcesL.list_data = STARTING_RESOURCES_DATA;
 		startingResourcesL.selected = STARTING_RESOURCES_DEFAULTIDX;
 		startingResourcesL.onSelectionChange = function()
 		{
 			if (this.selected != -1)
 				g_GameAttributes.settings.StartingResources = STARTING_RESOURCES_DATA[this.selected];
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		}
 
 		var victoryConditions = getGUIObjectByName("victoryCondition");
 		victoryConditions.list = VICTORY_TEXT;
 		victoryConditions.list_data = VICTORY_DATA;
 		victoryConditions.onSelectionChange = function()
 		{	// Update attributes so other players can see change
 			if (this.selected != -1)
 				g_GameAttributes.settings.GameType = VICTORY_DATA[this.selected];
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		};
 		victoryConditions.selected = VICTORY_DEFAULTIDX;
 
 		var mapSize = getGUIObjectByName("mapSize");
 		mapSize.list = g_MapSizes.names;
 		mapSize.list_data = g_MapSizes.tiles;
 		mapSize.onSelectionChange = function()
 		{	// Update attributes so other players can see change
 			if (this.selected != -1)
 				g_GameAttributes.settings.Size = g_MapSizes.tiles[this.selected];
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		};
 		mapSize.selected = 0;
 
 		getGUIObjectByName("revealMap").onPress = function()
 		{	// Update attributes so other players can see change
 			g_GameAttributes.settings.RevealMap = this.checked;
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		};
 
 		getGUIObjectByName("lockTeams").onPress = function()
 		{	// Update attributes so other players can see change
 			g_GameAttributes.settings.LockTeams = this.checked;
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		};
 
 		getGUIObjectByName("enableCheats").onPress = function()
 		{	// Update attributes so other players can see change
 			g_GameAttributes.settings.CheatsEnabled = this.checked;
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		};
 	}
 	else
 	{
 		// If we're a network client, disable all the map controls
 		// TODO: make them look visually disabled so it's obvious why they don't work
 		getGUIObjectByName("mapTypeSelection").hidden = true;
 		getGUIObjectByName("mapTypeText").hidden = false;
 		getGUIObjectByName("mapFilterSelection").hidden = true;
 		getGUIObjectByName("mapFilterText").hidden = false;
 		getGUIObjectByName("mapSelectionText").hidden = false;
 		getGUIObjectByName("mapSelection").hidden = true;
 		getGUIObjectByName("victoryConditionText").hidden = false;
 		getGUIObjectByName("victoryCondition").hidden = true;
 		getGUIObjectByName("gameSpeedText").hidden = false;
 		getGUIObjectByName("gameSpeed").hidden = true;
 
 		// Disable player and game options controls
 		// TODO: Shouldn't players be able to choose their own assignment?
 		for (var i = 0; i < MAX_PLAYERS; ++i)
 		{
 			getGUIObjectByName("playerAssignment["+i+"]").enabled = false;
 			getGUIObjectByName("playerCiv["+i+"]").hidden = true;
 			getGUIObjectByName("playerTeam["+i+"]").hidden = true;
 		}
 
 		getGUIObjectByName("numPlayersSelection").hidden = true;
 	}
 
 	// Set up multiplayer/singleplayer bits:
 	if (!g_IsNetworked)
 	{
 		getGUIObjectByName("chatPanel").hidden = true;
 		getGUIObjectByName("enableCheats").checked = true;
 		g_GameAttributes.settings.CheatsEnabled = true;
 	}
 	else
 	{
 		getGUIObjectByName("enableCheatsDesc").hidden = false;
 		getGUIObjectByName("enableCheats").checked = false;
 		g_GameAttributes.settings.CheatsEnabled = false;
 		if (g_IsController)
 			getGUIObjectByName("enableCheats").hidden = false;
 		else
 			getGUIObjectByName("enableCheatsText").hidden = false;
 	}
 
 	// Settings for all possible player slots
 	var boxSpacing = 32;
 	for (var i = 0; i < MAX_PLAYERS; ++i)
 	{
 		// Space player boxes
 		var box = getGUIObjectByName("playerBox["+i+"]");
 		var boxSize = box.size;
 		var h = boxSize.bottom - boxSize.top;
 		boxSize.top = i * boxSpacing;
 		boxSize.bottom = i * boxSpacing + h;
 		box.size = boxSize;
 
 		// Populate team dropdowns
 		var team = getGUIObjectByName("playerTeam["+i+"]");
 		team.list = ["None", "1", "2", "3", "4"];
 		team.list_data = [-1, 0, 1, 2, 3];
 		team.selected = 0;
 
 		let playerSlot = i;	// declare for inner function use
 		team.onSelectionChange = function()
 		{	// Update team
 			if (this.selected != -1)
 				g_GameAttributes.settings.PlayerData[playerSlot].Team = this.selected - 1;
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		};
 
 		// Set events
 		var civ = getGUIObjectByName("playerCiv["+i+"]");
 		civ.onSelectionChange = function()
 		{	// Update civ
 			if ((this.selected != -1)&&(g_GameAttributes.mapType !== "scenario"))
 				g_GameAttributes.settings.PlayerData[playerSlot].Civ = this.list_data[this.selected];
 
 			if (!g_IsInGuiUpdate)
 				updateGameAttributes();
 		};
 	}
 
 	if (g_IsNetworked)
 	{
 		// For multiplayer, focus the chat input box by default
 		getGUIObjectByName("chatInput").focus();
 	}
 	else
 	{
 		// For single-player, focus the map list by default,
 		// to allow easy keyboard selection of maps
 		getGUIObjectByName("mapSelection").focus();
 	}
 }
 
 function handleNetMessage(message)
 {
 	log("Net message: "+uneval(message));
 
 	switch (message.type)
 	{
 	case "netstatus":
 		switch (message.status)
 		{
 		case "disconnected":
 			cancelSetup();
 			if (Engine.HasXmppClient())
 				Engine.SwitchGuiPage("page_lobby.xml");
 			else
 				Engine.SwitchGuiPage("page_pregame.xml");
 			reportDisconnect(message.reason);
 			break;
 
 		default:
 			error("Unrecognised netstatus type "+message.status);
 			break;
 		}
 		break;
 
 	case "gamesetup":
 		if (message.data) // (the host gets undefined data on first connect, so skip that)
 			g_GameAttributes = message.data;
 
 		onGameAttributesChange();
 		break;
 
 	case "players":
 		// Find and report all joinings/leavings
 		for (var host in message.hosts)
 			if (! g_PlayerAssignments[host])
 				addChatMessage({ "type": "connect", "username": message.hosts[host].name });
 
 		for (var host in g_PlayerAssignments)
 			if (! message.hosts[host])
 				addChatMessage({ "type": "disconnect", "guid": host });
 
 		// Update the player list
 		g_PlayerAssignments = message.hosts;
 		updatePlayerList();
 
 		if (g_IsController)
 			sendRegisterGameStanza();
 		break;
 
 	case "start":
 		if (g_IsController && Engine.HasXmppClient())
 		{
 			var players = [ assignment.name for each (assignment in g_PlayerAssignments) ]
 			Engine.SendChangeStateGame(Object.keys(g_PlayerAssignments).length, players.join(", "));
 		}
 		Engine.SwitchGuiPage("page_loading.xml", {
 			"attribs": g_GameAttributes,
 			"isNetworked" : g_IsNetworked,
 			"playerAssignments": g_PlayerAssignments,
 			"isController": g_IsController
 		});
 		break;
 
 	case "chat":
 		addChatMessage({ "type": "message", "guid": message.guid, "text": message.text });
 		break;
 
 	default:
 		error("Unrecognised net message type "+message.type);
 	}
 }
 
 // Get display name from map data
 function getMapDisplayName(map)
 {
 	var mapData = loadMapData(map);
 
 	if (!mapData || !mapData.settings || !mapData.settings.Name)
 	{	// Give some msg that map format is unsupported
 		log("Map data missing in scenario '"+map+"' - likely unsupported format");
 		return map;
 	}
 
 	return mapData.settings.Name;
 }
 
 // Get display name from map data
 function getMapPreview(map)
 {
 	var mapData = loadMapData(map);
 
 	if (!mapData || !mapData.settings || !mapData.settings.Preview)
 	{	// Give some msg that map format is unsupported
 		return "nopreview.png";
 	}
 
 	return mapData.settings.Preview;
 }
 
 // Get a setting if it exists or return default
 function getSetting(settings, defaults, property)
 {
 	if (settings && (property in settings))
 		return settings[property];
 
 	// Use defaults
 	if (defaults && (property in defaults))
 		return defaults[property];
 
 	return undefined;
 }
 
 // Initialize the dropdowns containing all the available civs
 function initCivNameList()
 {
 	// Cache civ data
 	g_CivData = loadCivData();
 
 	// Extract name/code, and skip civs that are explicitly disabled
 	// (intended for unusable incomplete civs)
 	var civList = [
 		{ "name": civ.Name, "code": civ.Code }
 		for each (civ in g_CivData)
 			if (civ.SelectableInGameSetup !== false)
 	];
 
 	// Alphabetically sort the list, ignoring case
 	civList.sort(sortNameIgnoreCase);
 
 	var civListNames = [ civ.name for each (civ in civList) ];
 	var civListCodes = [ civ.code for each (civ in civList) ];
 
 	//  Add random civ to beginning of list
 	civListNames.unshift("[color=\"orange\"]Random");
 	civListCodes.unshift("random");
 
 	// Update the dropdowns
 	for (var i = 0; i < MAX_PLAYERS; ++i)
 	{
 		var civ = getGUIObjectByName("playerCiv["+i+"]");
 		civ.list = civListNames;
 		civ.list_data = civListCodes;
 		civ.selected = 0;
 	}
 }
 
 // Initialise the list control containing all the available maps
 function initMapNameList()
 {
 	// Get a list of map filenames
 	// TODO: Should verify these are valid maps before adding to list
 	var mapSelectionBox = getGUIObjectByName("mapSelection")
 	var mapFiles;
 
 	switch (g_GameAttributes.mapType)
 	{
 	case "scenario":
 	case "skirmish":
 		mapFiles = getXMLFileList(g_GameAttributes.mapPath);
 		break;
 
 	case "random":
 		mapFiles = getJSONFileList(g_GameAttributes.mapPath);
 		break;
 
 	default:
 		error("initMapNameList: Unexpected map type '"+g_GameAttributes.mapType+"'");
 		return;
 	}
 
 	// Apply map filter, if any defined
 	var mapList = [];
 	for (var i = 0; i < mapFiles.length; ++i)
 	{
 		var file = g_GameAttributes.mapPath + mapFiles[i];
 		var mapData = loadMapData(file);
 
 		if (g_GameAttributes.mapFilter && mapData && testFilter(g_GameAttributes.mapFilter, mapData.settings))
 			mapList.push({ "name": getMapDisplayName(file), "file": file });
 	}
 
 	// Alphabetically sort the list, ignoring case
 	mapList.sort(sortNameIgnoreCase);
 	if (g_GameAttributes.mapType == "random")
 		mapList.unshift({ "name": "[color=\"orange\"]Random[/color]", "file": "random" });
 
 	var mapListNames = [ map.name for each (map in mapList) ];
 	var mapListFiles = [ map.file for each (map in mapList) ];
 
 	// Select the default map
 	var selected = mapListFiles.indexOf(g_GameAttributes.map);
 	// Default to the first element if list is not empty and we can't find the one we searched for
 	if (selected == -1 && mapList.length)
 	{
 		selected = 0;
 	}
 
 	// Update the list control
 	mapSelectionBox.list = mapListNames;
 	mapSelectionBox.list_data = mapListFiles;
 	mapSelectionBox.selected = selected;
 }
 
 function loadMapData(name)
 {
 	if (!name)
 		return undefined;
 
 	if (!g_MapData[name])
 	{
 		switch (g_GameAttributes.mapType)
 		{
 		case "scenario":
 		case "skirmish":
 			g_MapData[name] = Engine.LoadMapSettings(name);
 			break;
 
 		case "random":
 			if (name == "random")
 				g_MapData[name] = {settings : {"Name" : "Random", "Description" : "Randomly selects a map from the list"}};
 			else
 				g_MapData[name] = parseJSONData(name+".json");
 			break;
 
 		default:
 			error("loadMapData: Unexpected map type '"+g_GameAttributes.mapType+"'");
 			return undefined;
 		}
 	}
 
 	return g_MapData[name];
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 // GUI event handlers
 
 function cancelSetup()
 {
 	Engine.DisconnectNetworkGame();
 
 	if (Engine.HasXmppClient())
 	{
 		// Set player presence
 		Engine.LobbySetPlayerPresence("available");
 
 		// Unregister the game
 		if (g_IsController)
 			Engine.SendUnregisterGame();
 	}
 }
 
 function onTick()
 {
 	// First tick happens before first render, so don't load yet
 	if (g_LoadingState == 0)
 	{
 		g_LoadingState++;
 	}
 	else if (g_LoadingState == 1)
 	{
 		getGUIObjectByName("loadingWindow").hidden = true;
 		getGUIObjectByName("setupWindow").hidden = false;
 		initMain();
 		g_LoadingState++;
 	}
 	else if (g_LoadingState == 2)
 	{
 		while (true)
 		{
 			var message = Engine.PollNetworkClient();
 			if (!message)
 				break;
 
 			handleNetMessage(message);
 		}
 	}
 }
 
 // Called when user selects number of players
 function selectNumPlayers(num)
 {
 	// Avoid recursion
 	if (g_IsInGuiUpdate)
 		return;
 
 	// Network clients can't change number of players
 	if (g_IsNetworked && !g_IsController)
 		return;
 
 	// Only meaningful for random maps
 	if (g_GameAttributes.mapType != "random")
 		return;
 
 	// Update player data
 	var pData = g_GameAttributes.settings.PlayerData;
 	if (pData && num < pData.length)
 	{
 		// Remove extra player data
 		g_GameAttributes.settings.PlayerData = pData.slice(0, num);
 	}
 	else
 	{
 		// Add player data from defaults
 		for (var i = pData.length; i < num; ++i)
 			g_GameAttributes.settings.PlayerData.push(g_DefaultPlayerData[i]);
 	}
 
 	// Some players may have lost their assigned slot
 	for (var guid in g_PlayerAssignments)
 	{
 		var player = g_PlayerAssignments[guid].player;
 		if (player > num)
 		{
 			if (g_IsNetworked)
 				Engine.AssignNetworkPlayer(player, "");
 			else
 				g_PlayerAssignments = { "local": { "name": "You", "player": 1, "civ": "", "team": -1} };
 		}
 	}
 
 	updateGameAttributes();
 }
 
 // Called when the user selects a map type from the list
 function selectMapType(type)
 {
 	// Avoid recursion
 	if (g_IsInGuiUpdate)
 		return;
 
 	// Network clients can't change map type
 	if (g_IsNetworked && !g_IsController)
 		return;
 
 	// Reset game attributes
 	g_GameAttributes.map = "";
 	g_GameAttributes.mapType = type;
 
 	// Clear old map data
 	g_MapData = {};
 
 	// Select correct path
 	switch (g_GameAttributes.mapType)
 	{
 	case "scenario":
 		// Set a default map
 		// TODO: This should be remembered from the last session
 		g_GameAttributes.mapPath = "maps/scenarios/";
 		g_GameAttributes.map = g_GameAttributes.mapPath + (g_IsNetworked ? DEFAULT_NETWORKED_MAP : DEFAULT_OFFLINE_MAP);
 		break;
 
 	case "skirmish":
 		g_GameAttributes.mapPath = "maps/skirmishes/";
 		g_GameAttributes.settings = {
 			PlayerData: g_DefaultPlayerData.slice(0, 4),
 			Seed: Math.floor(Math.random() * 65536),
 			CheatsEnabled: g_GameAttributes.settings.CheatsEnabled
 		};
 		break;
 
 	case "random":
 		g_GameAttributes.mapPath = "maps/random/";
 		g_GameAttributes.settings = {
 			PlayerData: g_DefaultPlayerData.slice(0, 4),
 			Seed: Math.floor(Math.random() * 65536),
 			CheatsEnabled: g_GameAttributes.settings.CheatsEnabled
 		};
 		break;
 
 	default:
 		error("selectMapType: Unexpected map type '"+g_GameAttributes.mapType+"'");
 		return;
 	}
 
 	initMapNameList();
 
 	updateGameAttributes();
 }
 
 function selectMapFilter(filterName)
 {
 	// Avoid recursion
 	if (g_IsInGuiUpdate)
 		return;
 
 	// Network clients can't change map filter
 	if (g_IsNetworked && !g_IsController)
 		return;
 
 	g_GameAttributes.mapFilter = filterName;
 
 	initMapNameList();
 
 	updateGameAttributes();
 }
 
 // Called when the user selects a map from the list
 function selectMap(name)
 {
 	// Avoid recursion
 	if (g_IsInGuiUpdate)
 		return;
 
 	// Network clients can't change map
 	if (g_IsNetworked && !g_IsController)
 		return;
 
 	// Return if we have no map
 	if (!name)
 		return;
 
 	var mapData = loadMapData(name);
 	var mapSettings = (mapData && mapData.settings ? deepcopy(mapData.settings) : {});
 
 	// Copy any new settings
 	g_GameAttributes.map = name;
 	g_GameAttributes.script = mapSettings.Script;
 	if (mapData !== "Random")
 		for (var prop in mapSettings)
 			g_GameAttributes.settings[prop] = mapSettings[prop];
 
 	// Use default AI if the map doesn't specify any explicitly
 	for (var i = 0; i < g_GameAttributes.settings.PlayerData.length; ++i)
 	{
 		if (!('AI' in g_GameAttributes.settings.PlayerData[i]))
 			g_GameAttributes.settings.PlayerData[i].AI = g_DefaultPlayerData[i].AI;
 		if (!('AIDiff' in g_GameAttributes.settings.PlayerData[i]))
 			g_GameAttributes.settings.PlayerData[i].AIDiff = g_DefaultPlayerData[i].AIDiff;
 	}
 
 	// Reset player assignments on map change
 	if (!g_IsNetworked)
 	{	// Slot 1
 		g_PlayerAssignments = { "local": { "name": "You", "player": 1, "civ": "", "team": -1} };
 	}
 	else
 	{
 		var numPlayers = (mapSettings.PlayerData ? mapSettings.PlayerData.length : g_GameAttributes.settings.PlayerData.length);
 
 		for (var guid in g_PlayerAssignments)
 		{	// Unassign extra players
 			var player = g_PlayerAssignments[guid].player;
 
 			if (player <= MAX_PLAYERS && player > numPlayers)
 				Engine.AssignNetworkPlayer(player, "");
 		}
 	}
 
 	updateGameAttributes();
 }
 
 function launchGame()
 {
 	if (g_IsNetworked && !g_IsController)
 	{
 		error("Only host can start game");
 		return;
 	}
 
 	// Check that we have a map
 	if (!g_GameAttributes.map)
 		return;
 
 	if (g_GameAttributes.map == "random")
 		selectMap(getGUIObjectByName("mapSelection").list_data[Math.floor(Math.random() *
 			(getGUIObjectByName("mapSelection").list.length - 1)) + 1]);
 
 	g_GameAttributes.settings.mapType = g_GameAttributes.mapType;
 	var numPlayers = g_GameAttributes.settings.PlayerData.length;
 	// Assign random civilizations to players with that choice
 	//  (this is synchronized because we're the host)
 	var cultures = [];
 	for each (var civ in g_CivData)
 		if (civ.Culture !== undefined && cultures.indexOf(civ.Culture) < 0 && (civ.SelectableInGameSetup === undefined || civ.SelectableInGameSetup))
 			cultures.push(civ.Culture);
 	var allcivs = new Array(cultures.length);
 	for (var i = 0; i < allcivs.length; ++i)
 		allcivs[i] = [];
 	for each (var civ in g_CivData)
 		if (civ.Culture !== undefined && (civ.SelectableInGameSetup === undefined || civ.SelectableInGameSetup))
 			allcivs[cultures.indexOf(civ.Culture)].push(civ.Code);
 
 	const romanNumbers = [undefined, "I", "II", "III", "IV", "V", "VI", "VII", "VIII"];
 	for (var i = 0; i < numPlayers; ++i)
 	{
 		var civs = allcivs[Math.floor(Math.random()*allcivs.length)];
 
 		if (!g_GameAttributes.settings.PlayerData[i].Civ || g_GameAttributes.settings.PlayerData[i].Civ == "random")
 			g_GameAttributes.settings.PlayerData[i].Civ = civs[Math.floor(Math.random()*civs.length)];
 		// Setting names for AI players. Check if the player is AI and the match is not a scenario
 		if (g_GameAttributes.mapType !== "scenario" && g_GameAttributes.settings.PlayerData[i].AI)
 		{
 			// Get the civ specific names
 			if (g_CivData[g_GameAttributes.settings.PlayerData[i].Civ].AINames !== undefined)
 				var civAINames = shuffleArray(g_CivData[g_GameAttributes.settings.PlayerData[i].Civ].AINames);
 			else
 				var civAINames = [g_CivData[g_GameAttributes.settings.PlayerData[i].Civ].Name];
 			// Choose the name
 			var usedName = 0;
 			if (i < civAINames.length)
 				var chosenName = civAINames[i];
 			else
 				var chosenName = civAINames[Math.floor(Math.random() * civAINames.length)];
 			for (var j = 0; j < numPlayers; ++j)
 				if (g_GameAttributes.settings.PlayerData[j].Name && g_GameAttributes.settings.PlayerData[j].Name.indexOf(chosenName) !== -1)
 					usedName++;
 
 			// Assign civ specific names to AI players
 			if (usedName)
 				g_GameAttributes.settings.PlayerData[i].Name = chosenName + " " + romanNumbers[usedName+1];
 			else
 				g_GameAttributes.settings.PlayerData[i].Name = chosenName;
 		}
 	}
 
 	if (g_IsNetworked)
 	{
 		Engine.SetNetworkGameAttributes(g_GameAttributes);
 		Engine.StartNetworkGame();
 	}
 	else
 	{
 		// Find the player ID which the user has been assigned to
 		var numPlayers = g_GameAttributes.settings.PlayerData.length;
 		var playerID = -1;
 		for (var i = 0; i < numPlayers; ++i)
 		{
 			var assignBox = getGUIObjectByName("playerAssignment["+i+"]");
 			if (assignBox.list_data[assignBox.selected] == "local")
 				playerID = i+1;
 		}
 		// Remove extra player data
 		g_GameAttributes.settings.PlayerData = g_GameAttributes.settings.PlayerData.slice(0, numPlayers);
 
 		Engine.StartGame(g_GameAttributes, playerID);
 		Engine.SwitchGuiPage("page_loading.xml", {
 			"attribs": g_GameAttributes,
 			"isNetworked" : g_IsNetworked,
 			"playerAssignments": g_PlayerAssignments
 		});
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
 function onGameAttributesChange()
 {
 	g_IsInGuiUpdate = true;
 
 	// Don't set any attributes here, just show the changes in GUI
 
 	var mapName = g_GameAttributes.map || "";
 	var mapSettings = g_GameAttributes.settings;
 	var numPlayers = (mapSettings.PlayerData ? mapSettings.PlayerData.length : MAX_PLAYERS);
 
 	// Update some controls for clients
 	if (!g_IsController)
 	{
 		getGUIObjectByName("mapFilterText").caption = g_GameAttributes.mapFilter;
 		var mapTypeSelection = getGUIObjectByName("mapTypeSelection");
 		var idx = mapTypeSelection.list_data.indexOf(g_GameAttributes.mapType);
 		getGUIObjectByName("mapTypeText").caption = mapTypeSelection.list[idx];
 		var mapSelectionBox = getGUIObjectByName("mapSelection");
 		mapSelectionBox.selected = mapSelectionBox.list_data.indexOf(mapName);
 		getGUIObjectByName("mapSelectionText").caption = getMapDisplayName(mapName);
 		var populationCapBox = getGUIObjectByName("populationCap");
 		populationCapBox.selected = populationCapBox.list_data.indexOf(mapSettings.PopulationCap);
 		var startingResourcesBox = getGUIObjectByName("startingResources");
 		startingResourcesBox.selected = startingResourcesBox.list_data.indexOf(mapSettings.StartingResources);
 		initMapNameList();
 	}
 
 	// Controls common to all map types
 	var numPlayersSelection = getGUIObjectByName("numPlayersSelection");
 	var revealMap = getGUIObjectByName("revealMap");
 	var victoryCondition = getGUIObjectByName("victoryCondition");
 	var lockTeams = getGUIObjectByName("lockTeams");
 	var mapSize = getGUIObjectByName("mapSize");
 	var enableCheats = getGUIObjectByName("enableCheats");
 	var populationCap = getGUIObjectByName("populationCap");
 	var startingResources = getGUIObjectByName("startingResources");
 
 	var numPlayersText= getGUIObjectByName("numPlayersText");
 	var mapSizeText = getGUIObjectByName("mapSizeText");
 	var revealMapText = getGUIObjectByName("revealMapText");
 	var victoryConditionText = getGUIObjectByName("victoryConditionText");
 	var lockTeamsText = getGUIObjectByName("lockTeamsText");
 	var enableCheatsText = getGUIObjectByName("enableCheatsText");
 	var populationCapText = getGUIObjectByName("populationCapText");
 	var startingResourcesText = getGUIObjectByName("startingResourcesText");
 	var gameSpeedText = getGUIObjectByName("gameSpeedText");
 
 	var sizeIdx = (g_MapSizes.tiles.indexOf(mapSettings.Size) != -1 ? g_MapSizes.tiles.indexOf(mapSettings.Size) : g_MapSizes["default"]);
 	var speedIdx = (g_GameAttributes.gameSpeed !== undefined && g_GameSpeeds.speeds.indexOf(g_GameAttributes.gameSpeed) != -1) ? g_GameSpeeds.speeds.indexOf(g_GameAttributes.gameSpeed) : g_GameSpeeds["default"];
 	var victoryIdx = (VICTORY_DATA.indexOf(mapSettings.GameType) != -1 ? VICTORY_DATA.indexOf(mapSettings.GameType) : VICTORY_DEFAULTIDX);
 	enableCheats.checked = (g_GameAttributes.settings.CheatsEnabled === undefined || !g_GameAttributes.settings.CheatsEnabled ? false : true)
 	enableCheatsText.caption = (enableCheats.checked ? "Yes" : "No");
 	gameSpeedText.caption = g_GameSpeeds.names[speedIdx];
 	populationCap.selected = (POPULATION_CAP_DATA.indexOf(mapSettings.PopulationCap) != -1 ? POPULATION_CAP_DATA.indexOf(mapSettings.PopulationCap) : POPULATION_CAP_DEFAULTIDX);
 	populationCapText.caption = POPULATION_CAP[populationCap.selected];
 	startingResources.selected = (STARTING_RESOURCES_DATA.indexOf(mapSettings.StartingResources) != -1 ? STARTING_RESOURCES_DATA.indexOf(mapSettings.StartingResources) : STARTING_RESOURCES_DEFAULTIDX);
 	startingResourcesText.caption = STARTING_RESOURCES[startingResources.selected];
 
 	// Update map preview
 	getGUIObjectByName("mapPreview").sprite = "cropped:(0.78125,0.5859375)session/icons/mappreview/" + getMapPreview(mapName);
 
 	// Handle map type specific logic
 	switch (g_GameAttributes.mapType)
 	{
 	case "random":
 		if (g_IsController)
 		{
 			//Host
 			numPlayersSelection.selected = numPlayers - 1;
 			numPlayersSelection.hidden = false;
 			mapSize.hidden = false;
 			revealMap.hidden = false;
 			victoryCondition.hidden = false;
 			lockTeams.hidden = false;
 			populationCap.hidden = false;
 			startingResources.hidden = false;
 
 			numPlayersText.hidden = true;
 			mapSizeText.hidden = true;
 			revealMapText.hidden = true;
 			victoryConditionText.hidden = true;
 			lockTeamsText.hidden = true;
 			populationCapText.hidden = true;
 			startingResourcesText.hidden = true;
 
 			mapSizeText.caption = "Map size:";
 			mapSize.selected = sizeIdx;
 			revealMapText.caption = "Reveal map:";
 			revealMap.checked = (mapSettings.RevealMap ? true : false);
 
 			victoryConditionText.caption = "Victory condition:";
 			victoryCondition.selected = victoryIdx;
 			lockTeamsText.caption = "Teams locked:";
 			lockTeams.checked = (mapSettings.LockTeams ? true : false);
 		}
 		else
 		{
 			// Client
 			numPlayersText.hidden = false;
 			mapSizeText.hidden = false;
 			revealMapText.hidden = false;
 			victoryConditionText.hidden = false;
 			lockTeamsText.hidden = false;
 			populationCap.hidden = true;
 			populationCapText.hidden = false;
 			startingResources.hidden = true;
 			startingResourcesText.hidden = false;
 
 			numPlayersText.caption = numPlayers;
 			mapSizeText.caption = g_MapSizes.names[sizeIdx];
 			revealMapText.caption = (mapSettings.RevealMap ? "Yes" : "No");
 			victoryConditionText.caption = VICTORY_TEXT[victoryIdx];
 			lockTeamsText.caption = (mapSettings.LockTeams ? "Yes" : "No");
 		}
 
 		break;
 
 	case "skirmish":
 		mapSizeText.caption = "Default";
 		numPlayersText.caption = numPlayers;
 		numPlayersSelection.hidden = true;
 		mapSize.hidden = true;
 		if (g_IsController)
 		{
 			//Host
 			revealMap.hidden = false;
 			victoryCondition.hidden = false;
 			lockTeams.hidden = false;
 			populationCap.hidden = false;
 			startingResources.hidden = false;
 			
 			numPlayersText.hidden = false;
 			mapSizeText.hidden = false;
 			revealMapText.hidden = true;
 			victoryConditionText.hidden = true;
 			lockTeamsText.hidden = true;
 			populationCapText.hidden = true;
 			startingResourcesText.hidden = true;
 
 			revealMapText.caption = "Reveal map:";
 			revealMap.checked = (mapSettings.RevealMap ? true : false);
 
 			victoryConditionText.caption = "Victory condition:";
 			victoryCondition.selected = victoryIdx;
 			lockTeamsText.caption = "Teams locked:";
 			lockTeams.checked = (mapSettings.LockTeams ? true : false);
 		}
 		else
 		{
 			// Client
 			numPlayersText.hidden = false;
 			mapSizeText.hidden = false;
 			revealMapText.hidden = false;
 			victoryConditionText.hidden = false;
 			lockTeamsText.hidden = false;
 			populationCap.hidden = true;
 			populationCapText.hidden = false;
 			startingResources.hidden = true;
 			startingResourcesText.hidden = false;
 
 			revealMapText.caption = (mapSettings.RevealMap ? "Yes" : "No");
 			victoryConditionText.caption = VICTORY_TEXT[victoryIdx];
 			lockTeamsText.caption = (mapSettings.LockTeams ? "Yes" : "No");
 		}
 
 		break;
 
 
 	case "scenario":
 		// For scenario just reflect settings for the current map
 		numPlayersSelection.hidden = true;
 		mapSize.hidden = true;
 		revealMap.hidden = true;
 		victoryCondition.hidden = true;
 		lockTeams.hidden = true;
 		numPlayersText.hidden = false;
 		mapSizeText.hidden = false;
 		revealMapText.hidden = false;
 		victoryConditionText.hidden = false;
 		lockTeamsText.hidden = false;
 		populationCap.hidden = true;
 		populationCapText.hidden = false;
 		startingResources.hidden = true;
 		startingResourcesText.hidden = false;
 
 		numPlayersText.caption = numPlayers;
 		mapSizeText.caption = "Default";
 		revealMapText.caption = (mapSettings.RevealMap ? "Yes" : "No");
 		victoryConditionText.caption = VICTORY_TEXT[victoryIdx];
 		lockTeamsText.caption = (mapSettings.LockTeams ? "Yes" : "No");
 		getGUIObjectByName("populationCap").selected = POPULATION_CAP_DEFAULTIDX;
 
 		break;
 
 	default:
 		error("onGameAttributesChange: Unexpected map type '"+g_GameAttributes.mapType+"'");
 		return;
 	}
 
 	// Display map name
 	getGUIObjectByName("mapInfoName").caption = getMapDisplayName(mapName);
 
 	// Load the description from the map file, if there is one
 	var description = mapSettings.Description || "Sorry, no description available.";
 
 	if (g_GameAttributes.mapFilter == "Naval Maps")
 		description += g_NavalWarning;
 
 	// Describe the number of players
 	var playerString = numPlayers + " " + (numPlayers == 1 ? "player" : "players") + ". ";
 
 	for (var i = 0; i < MAX_PLAYERS; ++i)
 	{
 		// Show only needed player slots
 		getGUIObjectByName("playerBox["+i+"]").hidden = (i >= numPlayers);
 
 		// Show player data or defaults as necessary
 		if (i >= numPlayers)
 			continue;
 
 		var pName = getGUIObjectByName("playerName["+i+"]");
 		var pCiv = getGUIObjectByName("playerCiv["+i+"]");
 		var pCivText = getGUIObjectByName("playerCivText["+i+"]");
 		var pTeam = getGUIObjectByName("playerTeam["+i+"]");
 		var pTeamText = getGUIObjectByName("playerTeamText["+i+"]");
 		var pColor = getGUIObjectByName("playerColour["+i+"]");
 
 		// Player data / defaults
 		var pData = mapSettings.PlayerData ? mapSettings.PlayerData[i] : {};
 		var pDefs = g_DefaultPlayerData ? g_DefaultPlayerData[i] : {};
 
 		// Common to all game types
 		var color = iColorToString(getSetting(pData, pDefs, "Colour"));
 		pColor.sprite = "colour:"+color+" 100";
 		pName.caption = getSetting(pData, pDefs, "Name");
 
 		var team = getSetting(pData, pDefs, "Team");
 		var civ = getSetting(pData, pDefs, "Civ");
 
 		// For clients or scenarios, hide some player dropdowns
 		if (!g_IsController || g_GameAttributes.mapType == "scenario")
 		{
 			pCivText.hidden = false;
 			pCiv.hidden = true;
 			pTeamText.hidden = false;
 			pTeam.hidden = true;
 			// Set text values
 			if (civ == "random")
 				pCivText.caption = "[color=\"orange\"]Random";
 			else
 				pCivText.caption = g_CivData[civ].Name;
 			pTeamText.caption = (team !== undefined && team >= 0) ? team+1 : "-";
 		}
 		else if (g_GameAttributes.mapType != "scenario")
 		{
 			pCivText.hidden = true;
 			pCiv.hidden = false;
 			pTeamText.hidden = true;
 			pTeam.hidden = false;
 			// Set dropdown values
 			pCiv.selected = (civ ? pCiv.list_data.indexOf(civ) : 0);
 			pTeam.selected = (team !== undefined && team >= 0) ? team+1 : 0;
 		}
 	}
 
 	getGUIObjectByName("mapInfoDescription").caption = playerString + description;
 
 	g_IsInGuiUpdate = false;
 
 	// Game attributes include AI settings, so update the player list
 	updatePlayerList();
 }
 
 function updateGameAttributes()
 {
 	if (g_IsNetworked)
     {
 		Engine.SetNetworkGameAttributes(g_GameAttributes);
 		if (g_IsController && g_LoadingState >= 2)
 			sendRegisterGameStanza();
 	}
 	else
     {
 		onGameAttributesChange();
     }
 }
 
 function updatePlayerList()
 {
 	g_IsInGuiUpdate = true;
 
 	var hostNameList = [];
 	var hostGuidList = [];
 	var assignments = [];
 	var aiAssignments = {};
 	var noAssignment;
 	var assignedCount = 0;
 
 	for (var guid in g_PlayerAssignments)
 	{
 		var name = g_PlayerAssignments[guid].name;
 		var hostID = hostNameList.length;
 		var player = g_PlayerAssignments[guid].player;
 
 		hostNameList.push(name);
 		hostGuidList.push(guid);
 		assignments[player] = hostID;
 
 		if (player != 255)
 			assignedCount++;
 	}
 
 	// Only enable start button if we have enough assigned players
 	if (g_IsController)
 		getGUIObjectByName("startGame").enabled = (assignedCount > 0);
 
 	for each (var ai in g_AIs)
 	{
 		if (ai.data.hidden)
 		{
 			// If the map uses a hidden AI then don't hide it
 			var usedByMap = false;
 			for (var i = 0; i < MAX_PLAYERS; ++i)
 				if (i < g_GameAttributes.settings.PlayerData.length &&
 				    g_GameAttributes.settings.PlayerData[i].AI == ai.id)
 				{
 					usedByMap = true;
 					break;
 				}
 
 			if (!usedByMap)
 				continue;
 		}
 		// Give AI a different color so it stands out
 		aiAssignments[ai.id] = hostNameList.length;
 		hostNameList.push("[color=\"70 150 70 255\"]AI: " + ai.data.name);
 		hostGuidList.push("ai:" + ai.id);
 	}
 
 	noAssignment = hostNameList.length;
 	hostNameList.push("[color=\"140 140 140 255\"]Unassigned");
 	hostGuidList.push("");
 
 	for (var i = 0; i < MAX_PLAYERS; ++i)
 	{
 		let playerSlot = i;
 		let playerID = i+1; // we don't show Gaia, so first slot is ID 1
 
 		var selection = assignments[playerID];
 
 		var configButton = getGUIObjectByName("playerConfig["+i+"]");
 		configButton.hidden = true;
 
 		// Look for valid player slots
 		if (playerSlot >= g_GameAttributes.settings.PlayerData.length)
 			continue;
 
 		// If no human is assigned, look for an AI instead
 		if (selection === undefined)
 		{
 			var aiId = g_GameAttributes.settings.PlayerData[playerSlot].AI;
 			if (aiId)
 			{
 				// Check for a valid AI
 				if (aiId in aiAssignments)
 					selection = aiAssignments[aiId];
 				else
 					warn("AI \""+aiId+"\" not present. Defaulting to unassigned.");
 			}
 
 			if (!selection)
 				selection = noAssignment;
 
 			// Since no human is assigned, show the AI config button
 			if (g_IsController)
 			{
 				configButton.hidden = false;
 				configButton.onpress = function()
 				{
 					Engine.PushGuiPage("page_aiconfig.xml", {
 						ais: g_AIs,
 						id: g_GameAttributes.settings.PlayerData[playerSlot].AI,
 						difficulty: g_GameAttributes.settings.PlayerData[playerSlot].AIDiff,
 						callback: function(ai) {
 							g_GameAttributes.settings.PlayerData[playerSlot].AI = ai.id;
 							g_GameAttributes.settings.PlayerData[playerSlot].AIDiff = ai.difficulty;
 
 							if (g_IsNetworked)
 								Engine.SetNetworkGameAttributes(g_GameAttributes);
 							else
 								updatePlayerList();
 						}
 					});
 				};
 			}
 		}
 		// There was a human, so make sure we don't have any AI left
 		// over in their slot, if we're in charge of the attributes
 		else if (g_IsController && g_GameAttributes.settings.PlayerData[playerSlot].AI && g_GameAttributes.settings.PlayerData[playerSlot].AI != "")
 		{
 			g_GameAttributes.settings.PlayerData[playerSlot].AI = "";
 			if (g_IsNetworked)
 				Engine.SetNetworkGameAttributes(g_GameAttributes);
 		}
 
 		var assignBox = getGUIObjectByName("playerAssignment["+i+"]");
 		assignBox.list = hostNameList;
 		assignBox.list_data = hostGuidList;
 		if (assignBox.selected != selection)
 			assignBox.selected = selection;
 
 		if (g_IsNetworked && g_IsController)
 		{
 			assignBox.onselectionchange = function ()
 			{
 				if (!g_IsInGuiUpdate)
 				{
 					var guid = hostGuidList[this.selected];
 					if (guid == "")
 					{
 						// Unassign any host from this player slot
 						Engine.AssignNetworkPlayer(playerID, "");
 						// Remove AI from this player slot
 						g_GameAttributes.settings.PlayerData[playerSlot].AI = "";
 					}
 					else if (guid.substr(0, 3) == "ai:")
 					{
 						// Unassign any host from this player slot
 						Engine.AssignNetworkPlayer(playerID, "");
 						// Set the AI for this player slot
 						g_GameAttributes.settings.PlayerData[playerSlot].AI = guid.substr(3);
 					}
 					else
 						swapPlayers(guid, playerSlot);
 
 					Engine.SetNetworkGameAttributes(g_GameAttributes);
 				}
 			};
 		}
 		else if (!g_IsNetworked)
 		{
 			assignBox.onselectionchange = function ()
 			{
 				if (!g_IsInGuiUpdate)
 				{
 					var guid = hostGuidList[this.selected];
 					if (guid == "")
 					{
 						// Remove AI from this player slot
 						g_GameAttributes.settings.PlayerData[playerSlot].AI = "";
 					}
 					else if (guid.substr(0, 3) == "ai:")
 					{
 						// Set the AI for this player slot
 						g_GameAttributes.settings.PlayerData[playerSlot].AI = guid.substr(3);
 					}
 					else
 						swapPlayers(guid, playerSlot);
 
 					updatePlayerList();
 				}
 			};
 		}
 	}
 
 	g_IsInGuiUpdate = false;
 }
 
 function swapPlayers(guid, newSlot)
 {
 	// Player slots are indexed from 0 as Gaia is omitted.
 	var newPlayerID = newSlot + 1;
 	var playerID = g_PlayerAssignments[guid].player;
 
 	// Attempt to swap the player or AI occupying the target slot,
 	// if any, into the slot this player is currently in.
 	if (playerID != 255)
 	{
 		for (var i in g_PlayerAssignments)
 		{
 			// Move the player in the destination slot into the current slot.
 			if (g_PlayerAssignments[i].player == newPlayerID)
 			{
 				if (g_IsNetworked)
 					Engine.AssignNetworkPlayer(playerID, i);
 				else
 					g_PlayerAssignments[i].player = playerID;
 				break;
 			}
 		}
 
 		// Transfer the AI from the target slot to the current slot.
 		g_GameAttributes.settings.PlayerData[playerID - 1].AI = g_GameAttributes.settings.PlayerData[newSlot].AI;
 	}
 
 	if (g_IsNetworked)
 		Engine.AssignNetworkPlayer(newPlayerID, guid);
 	else
 		g_PlayerAssignments[guid].player = newPlayerID;
 
 	// Remove AI from this player slot
 	g_GameAttributes.settings.PlayerData[newSlot].AI = "";
 }
 
 function submitChatInput()
 {
 	var input = getGUIObjectByName("chatInput");
 	var text = input.caption;
 	if (text.length)
 	{
 		Engine.SendNetworkChat(text);
 		input.caption = "";
 	}
 }
 
 function addChatMessage(msg)
 {
 	var username = escapeText(msg.username || g_PlayerAssignments[msg.guid].name);
 	var message = escapeText(msg.text);
 
 	// TODO: Maybe host should have distinct font/color?
 	var color = "white";
 
 	if (g_PlayerAssignments[msg.guid] && g_PlayerAssignments[msg.guid].player != 255)
 	{	// Valid player who has been assigned - get player colour
 		var player = g_PlayerAssignments[msg.guid].player - 1;
 		var mapName = g_GameAttributes.map;
 		var mapData = loadMapData(mapName);
 		var mapSettings = (mapData && mapData.settings ? mapData.settings : {});
 		var pData = mapSettings.PlayerData ? mapSettings.PlayerData[player] : {};
 		var pDefs = g_DefaultPlayerData ? g_DefaultPlayerData[player] : {};
 
 		color = iColorToString(getSetting(pData, pDefs, "Colour"));
 	}
 
 	var formatted;
 	switch (msg.type)
 	{
 	case "connect":
 		formatted = '[font="serif-bold-13"][color="'+ color +'"]' + username + '[/color][/font] [color="gold"]has joined[/color]';
 		break;
 
 	case "disconnect":
 		formatted = '[font="serif-bold-13"][color="'+ color +'"]' + username + '[/color][/font] [color="gold"]has left[/color]';
 		break;
 
 	case "message":
 		formatted = '[font="serif-bold-13"]<[color="'+ color +'"]' + username + '[/color]>[/font] ' + message;
 		break;
 
 	default:
 		error("Invalid chat message '" + uneval(msg) + "'");
 		return;
 	}
 
 	g_ChatMessages.push(formatted);
 
 	getGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 }
 
 function toggleMoreOptions()
 {
 	getGUIObjectByName("moreOptions").hidden = !getGUIObjectByName("moreOptions").hidden;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 // Basic map filters API
 
 // Add a new map list filter
 function addFilter(name, filterFunc)
 {
 	if (filterFunc instanceof Object)
 	{	// Basic validity test
 		var newFilter = {};
 		newFilter.name = name;
 		newFilter.filter = filterFunc;
 
 		g_MapFilters.push(newFilter);
 	}
 	else
 	{
 		error("Invalid map filter: "+name);
 	}
 }
 
 // Get array of map filter names
 function getFilters()
 {
 	var filters = [];
 	for (var i = 0; i < g_MapFilters.length; ++i)
 		filters.push(g_MapFilters[i].name);
 
 	return filters;
 }
 
 // Test map filter on given map settings object
 function testFilter(name, mapSettings)
 {
 	for (var i = 0; i < g_MapFilters.length; ++i)
 		if (g_MapFilters[i].name == name)
 			return g_MapFilters[i].filter(mapSettings);
 
 	error("Invalid map filter: "+name);
 	return false;
 }
 
 // Test an array of keywords against a match array using AND logic
 function keywordTestAND(keywords, matches)
 {
 	if (!keywords || !matches)
 		return false;
 
 	for (var m = 0; m < matches.length; ++m)
 		if (keywords.indexOf(matches[m]) == -1)
 			return false;
 
 	return true;
 }
 
 // Test an array of keywords against a match array using OR logic
 function keywordTestOR(keywords, matches)
 {
 	if (!keywords || !matches)
 		return false;
 
 	for (var m = 0; m < matches.length; ++m)
 		if (keywords.indexOf(matches[m]) != -1)
 			return true;
 
 	return false;
 }
 
 function sendRegisterGameStanza()
 {
 	if (!Engine.HasXmppClient())
 		return;
 
 	var selectedMapSize = getGUIObjectByName("mapSize").selected;
 	var selectedVictoryCondition = getGUIObjectByName("victoryCondition").selected;
 
 	// Map sizes only apply to random maps.
 	if (g_GameAttributes.mapType == "random")
 		var mapSize = getGUIObjectByName("mapSize").list[selectedMapSize];
 	else
 		var mapSize = "Default";
 
 	var victoryCondition = getGUIObjectByName("victoryCondition").list[selectedVictoryCondition];
 	var numberOfPlayers = Object.keys(g_PlayerAssignments).length;
 	var players = [ assignment.name for each (assignment in g_PlayerAssignments) ].join(", ");
 
 	var nbp = numberOfPlayers ? numberOfPlayers : 1;
 	var tnbp = g_GameAttributes.settings.PlayerData.length;
 
 	var gameData = {
 		"name":g_ServerName,
 		"mapName":g_GameAttributes.map,
 		"niceMapName":getMapDisplayName(g_GameAttributes.map),
 		"mapSize":mapSize,
 		"mapType":g_GameAttributes.mapType,
 		"victoryCondition":victoryCondition,
 		"nbp":nbp,
 		"tnbp":tnbp,
 		"players":players
 	};
 	Engine.SendRegisterGame(gameData);
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/messages.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/messages.js	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/gui/session/messages.js	(revision 14418)
@@ -1,538 +1,543 @@
 // Chat data
 const CHAT_TIMEOUT = 30000;
 const MAX_NUM_CHAT_LINES = 20;
 var chatMessages = [];
 var chatTimers = [];
 
 // Notification Data
 const NOTIFICATION_TIMEOUT = 10000;
 const MAX_NUM_NOTIFICATION_LINES = 3;
 var notifications = [];
 var notificationsTimers = [];
 var cheats = getCheatsData();
 
 function getCheatsData()
 {
 	var cheats = {};
 	var cheatFileList = getJSONFileList("simulation/data/cheats/");
 	for each (var fileName in cheatFileList)
 	{
 		var currentCheat = parseJSONData("simulation/data/cheats/"+fileName+".json");
 		if (Object.keys(cheats).indexOf(currentCheat.Name) !== -1)
 			warn("Cheat name '"+currentCheat.Name+"' is already present");
 		else
 			cheats[currentCheat.Name] = currentCheat.Data;
 	}
 	return cheats;
 }
 
 // Notifications
 function handleNotifications()
 {
 	var notification = Engine.GuiInterfaceCall("GetNextNotification");
 
 	if (!notification)
 		return;
 
 	// Handle chat notifications specially
 	if (notification.type == "chat")
 	{
 		var guid = findGuidForPlayerID(g_PlayerAssignments, notification.player);
 		if (guid == undefined)
 		{
 			addChatMessage({
 				"type": "message",
 				"guid": -1,
 				"player": notification.player,
 				"text": notification.message
 			});
 		} else {
 			addChatMessage({
 				"type": "message",
 				"guid": findGuidForPlayerID(g_PlayerAssignments, notification.player),
 				"text": notification.message
 			});
 		}
 	}
 	else if (notification.type == "defeat")
 	{
 		addChatMessage({
 			"type": "defeat",
 			"guid": findGuidForPlayerID(g_PlayerAssignments, notification.player),
 			"player": notification.player
 		});
 
 		// If the diplomacy panel is open refresh it.
 		if (isDiplomacyOpen)
 			openDiplomacy();
 	}
 	else if (notification.type == "diplomacy")
 	{
 		addChatMessage({
 			"type": "diplomacy",
 			"player": notification.player,
 			"player1": notification.player1,
 			"status": notification.status
 		});
 
 		// If the diplomacy panel is open refresh it.
 		if (isDiplomacyOpen)
 			openDiplomacy();
 	}
 	else if (notification.type == "quit")
 	{
 		// Used for AI testing
 		exit();
 	}
 	else if (notification.type == "tribute")
 	{
 		addChatMessage({
 			"type": "tribute",
 			"player": notification.player,
 			"player1": notification.player1,
 			"amounts": notification.amounts
 		});
 	}
 	else if (notification.type == "attack")
 	{
 		if (notification.player == Engine.GetPlayerID())
 		{
 			if (Engine.ConfigDB_GetValue("user", "gui.session.attacknotificationmessage") === "true")
 			{
 				addChatMessage({
 					"type": "attack",
 					"player": notification.player,
 					"attacker": notification.attacker
 				});
 			}
 		}
 	}
 	else
 	{
 		// Only display notifications directed to this player
 		if (notification.player == Engine.GetPlayerID())
 		{
 			notifications.push(notification);
 			notificationsTimers.push(setTimeout(removeOldNotifications, NOTIFICATION_TIMEOUT));
 
 			if (notifications.length > MAX_NUM_NOTIFICATION_LINES)
 				removeOldNotifications();
 			else
 				displayNotifications();
 		}
 	}
 }
 
 function removeOldNotifications()
 {
 	clearTimeout(notificationsTimers[0]); // The timer only needs to be cleared when new notifications bump old notifications off
 	notificationsTimers.shift();
 	notifications.shift();
 	displayNotifications();
 }
 
 function displayNotifications()
 {
 	var messages = [];
 	for each (var n in notifications)
 		messages.push(n.message);
-	getGUIObjectByName("notificationText").caption = messages.join("\n");
-}
-
-// Returns [username, playercolor] for the given player
-function getUsernameAndColor(player)
-{
+	getGUIObjectByName("notificationText").caption = messages.join("\n");
+}
+
+function updateTimeNotifications()
+{
+	getGUIObjectByName("timeNotificationText").caption = Engine.GuiInterfaceCall("GetTimeNotificationText");
+}
+
+// Returns [username, playercolor] for the given player
+function getUsernameAndColor(player)
+{
 	// This case is hit for AIs, whose names don't exist in playerAssignments.
 	var color = g_Players[player].color;
 	return [
 		escapeText(g_Players[player].name),
 		color.r + " " + color.g + " " + color.b,
 	];
 }
 
 // Messages
 function handleNetMessage(message)
 {
 	log("Net message: " + uneval(message));
 
 	switch (message.type)
 	{
 	case "netstatus":
 		// If we lost connection, further netstatus messages are useless
 		if (g_Disconnected)
 			return;
 
 		var obj = getGUIObjectByName("netStatus");
 		switch (message.status)
 		{
 		case "waiting_for_players":
 			obj.caption = "Waiting for other players to connect...";
 			obj.hidden = false;
 			break;
 		case "join_syncing":
 			obj.caption = "Synchronising gameplay with other players...";
 			obj.hidden = false;
 			break;
 		case "active":
 			obj.caption = "";
 			obj.hidden = true;
 			break;
 		case "connected":
 			obj.caption = "Connected to the server.";
 			obj.hidden = false;
 			break;
 		case "authenticated":
 			obj.caption = "Connection to the server has been authenticated.";
 			obj.hidden = false;
 			break;
 		case "disconnected":
 			g_Disconnected = true;
 			obj.caption = "Connection to the server has been lost.\n\nThe game has ended.";
 			obj.hidden = false;
 			break;
 		default:
 			error("Unrecognised netstatus type "+message.status);
 			break;
 		}
 		break;
 
 	case "players":
 		// Find and report all leavings
 		for (var host in g_PlayerAssignments)
 		{
 			if (! message.hosts[host])
 			{
 				// Tell the user about the disconnection
 				addChatMessage({ "type": "disconnect", "guid": host });
 
 				// Update the cached player data, so we can display the disconnection status
 				updatePlayerDataRemove(g_Players, host);
 			}
 		}
 
 		// Find and report all joinings
 		for (var host in message.hosts)
 		{
 			if (! g_PlayerAssignments[host])
 			{
 				// Update the cached player data, so we can display the correct name
 				updatePlayerDataAdd(g_Players, host, message.hosts[host]);
 
 				// Tell the user about the connection
 				addChatMessage({ "type": "connect", "guid": host }, message.hosts);
 			}
 		}
 
 		g_PlayerAssignments = message.hosts;
 
 		if (g_IsController)
 		{
 			var players = [ assignment.name for each (assignment in g_PlayerAssignments) ]
 			Engine.SendChangeStateGame(Object.keys(g_PlayerAssignments).length, players.join(", "));
 		}
 
 		break;
 
 	case "chat":
 		addChatMessage({ "type": "message", "guid": message.guid, "text": message.text });
 		break;
 
 	// To prevent errors, ignore these message types that occur during autostart
 	case "gamesetup":
 	case "start":
 		break;
 
 	default:
 		error("Unrecognised net message type "+message.type);
 	}
 }
 
 function submitChatDirectly(text)
 {
 	if (text.length)
 	{
 		if (g_IsNetworked)
 			Engine.SendNetworkChat(text);
 		else
 			addChatMessage({ "type": "message", "guid": "local", "text": text });
 	}
 }
 
 function submitChatInput()
 {
 	var input = getGUIObjectByName("chatInput");
 	var text = input.caption;
 	var isCheat = false;
 	if (text.length)
 	{
 		if (g_Players[Engine.GetPlayerID()].cheatsEnabled)
 		{
 			for each (var cheat in Object.keys(cheats))
 			{
 				// Line must start with the cheat.
 				if (text.indexOf(cheat) !== 0)
 					continue;
 
 				var number;
 				if (cheats[cheat].DefaultNumber !== undefined)
 				{
 					// Match the first word in the substring.
 					var match = text.substr(cheat.length).match(/\S+/);
 					if (match && match[0])
 						number = Math.floor(match[0]);
 
 					if (number <= 0 || isNaN(number))
 						number = cheats[cheat].DefaultNumber;
 				}
 
 				Engine.PostNetworkCommand({
 					"type": "cheat",
 					"action": cheats[cheat].Action,
 					"number": number,
 					"text": cheats[cheat].Type,
 					"selected": g_Selection.toList(),
 					"templates": cheats[cheat].Templates,
 					"player": Engine.GetPlayerID()});
 				isCheat = true;
 				break;
 			}
 		}
 
 		if (!isCheat)
 		{
 			if (getGUIObjectByName("toggleTeamChat").checked)
 				text = "/team " + text;
 
 			if (g_IsNetworked)
 				Engine.SendNetworkChat(text);
 			else
 				addChatMessage({ "type": "message", "guid": "local", "text": text });
 		}
 		input.caption = ""; // Clear chat input
 	}
 
 	input.blur(); // Remove focus
 
 	toggleChatWindow();
 }
 
 function addChatMessage(msg, playerAssignments)
 {
 	// Default to global assignments, but allow overriding for when reporting
 	// new players joining
 	if (!playerAssignments)
 		playerAssignments = g_PlayerAssignments;
 
 	var playerColor, username;
 
 	// No prefix by default. May be set by parseChatCommands().
 	msg.prefix = "";
 
 	if (playerAssignments[msg.guid])
 	{
 		var n = playerAssignments[msg.guid].player;
 		playerColor = g_Players[n].color.r + " " + g_Players[n].color.g + " " + g_Players[n].color.b;
 		username = escapeText(playerAssignments[msg.guid].name);
 
 		// Parse in-line commands in regular messages.
 		if (msg.type == "message")
 			parseChatCommands(msg, playerAssignments);
 	}
 	else if (msg.type == "defeat" && msg.player)
 	{
 		[username, playerColor] = getUsernameAndColor(msg.player);
 	}
 	else if (msg.type == "message")
 	{
 		[username, playerColor] = getUsernameAndColor(msg.player);
 		parseChatCommands(msg, playerAssignments);
 	}
 	else
 	{
 		playerColor = "255 255 255";
 		username = "Unknown player";
 	}
 
 	var message = escapeText(msg.text);
 	
 	var formatted;
 	
 	switch (msg.type)
 	{
 	case "connect":
 		formatted = "[color=\"" + playerColor + "\"]" + username + "[/color] has joined the game.";
 		break;
 	case "disconnect":
 		formatted = "[color=\"" + playerColor + "\"]" + username + "[/color] has left the game.";
 		break;
 	case "defeat":
 		// In singleplayer, the local player is "You". "You has" is incorrect.
 		var verb = (!g_IsNetworked && msg.player == Engine.GetPlayerID()) ? "have" : "has";
 		formatted = "[color=\"" + playerColor + "\"]" + username + "[/color] " + verb + " been defeated.";
 		break;
 	case "diplomacy":
 		var status = (msg.status == "ally" ? "allied" : (msg.status == "enemy" ? "at war" : "neutral"));
 		if (msg.player == Engine.GetPlayerID())
 		{
 			[username, playerColor] = getUsernameAndColor(msg.player1);
 			formatted = "You are now "+status+" with [color=\"" + playerColor + "\"]"+username + "[/color].";
 		}
 		else if (msg.player1 == Engine.GetPlayerID())
 		{
 			[username, playerColor] = getUsernameAndColor(msg.player);
 			formatted = "[color=\"" + playerColor + "\"]" + username + "[/color] is now " + status + " with you."
 		}
 		else // No need for other players to know of this.
 			return;
 		break;
 	case "tribute":
 		if (msg.player != Engine.GetPlayerID()) 
 			return;
 
 		[username, playerColor] = getUsernameAndColor(msg.player1);
 
 		// Format the amounts to proper English: 200 food, 100 wood, and 300 metal; 100 food; 400 wood and 200 stone
 		var amounts = Object.keys(msg.amounts)
 			.filter(function (type) { return msg.amounts[type] > 0; })
 			.map(function (type) { return msg.amounts[type] + " " + type; });
 
 		if (amounts.length > 1)
 		{
 			var lastAmount = amounts.pop();
 			amounts = amounts.join(", ") + " and " + lastAmount;
 		}
 
 		formatted = "[color=\"" + playerColor + "\"]" + username + "[/color] has sent you " + amounts + ".";
 		break;
 	case "attack":
 		if (msg.player != Engine.GetPlayerID()) 
 			return;
 
 		[username, playerColor] = getUsernameAndColor(msg.attacker);
 		formatted = "You have been attacked by [color=\"" + playerColor + "\"]" + username + "[/color]!";
 		break;
 	case "message":
 		// May have been hidden by the 'team' command.
 		if (msg.hide)
 			return;
 
 		if (msg.action)
 		{
 			Engine.Console_Write(msg.prefix + "* " + username + " " + message);
 			formatted = msg.prefix + "* [color=\"" + playerColor + "\"]" + username + "[/color] " + message;
 		}
 		else
 		{
 			Engine.Console_Write(msg.prefix + "<" + username + "> " + message);
 			formatted = msg.prefix + "<[color=\"" + playerColor + "\"]" + username + "[/color]> " + message;
 		}
 		break;
 	default:
 		error("Invalid chat message '" + uneval(msg) + "'");
 		return;
 	}
 
 	chatMessages.push(formatted);
 	chatTimers.push(setTimeout(removeOldChatMessages, CHAT_TIMEOUT));
 
 	if (chatMessages.length > MAX_NUM_CHAT_LINES)
 		removeOldChatMessages();
 	else
 		getGUIObjectByName("chatText").caption = chatMessages.join("\n");
 }
 
 function removeOldChatMessages()
 {
 	clearTimeout(chatTimers[0]); // The timer only needs to be cleared when new messages bump old messages off
 	chatTimers.shift();
 	chatMessages.shift();
 	getGUIObjectByName("chatText").caption = chatMessages.join("\n");
 }
 
 // Parses chat messages for commands.
 function parseChatCommands(msg, playerAssignments)
 {
 	// Only interested in messages that start with '/'.
 	if (!msg.text || msg.text[0] != '/')
 		return;
 
 	var sender;
 	if (playerAssignments[msg.guid])
 		sender = playerAssignments[msg.guid].player;
 	else
 		sender = msg.player;
 	
 	var recurse = false;
 	var split = msg.text.split(/\s/);
 
 	// Parse commands embedded in the message.
 	switch (split[0])
 	{
 	case "/all":
 		// Resets values that 'team' or 'enemy' may have set.
 		msg.prefix = "";
 		msg.hide = false;
 		recurse = true;
 		break;
 	case "/team":
 		// Check if we are in a team.
 		if (g_Players[Engine.GetPlayerID()] && g_Players[Engine.GetPlayerID()].team != -1)
 		{
 			if (g_Players[Engine.GetPlayerID()].team != g_Players[sender].team)
 				msg.hide = true;
 			else
 				msg.prefix = "(Team) ";
 		}
 		else
 			msg.hide = true;
 		recurse = true;
 		break;
 	case "/enemy":
 		// Check if we are in a team.
 		if (g_Players[Engine.GetPlayerID()] && g_Players[Engine.GetPlayerID()].team != -1)
 		{
 			if (g_Players[Engine.GetPlayerID()].team == g_Players[sender].team && sender != Engine.GetPlayerID())
 				msg.hide = true;
 			else
 				msg.prefix = "(Enemy) ";
 		}
 		recurse = true;
 		break;
 	case "/me":
 		msg.action = true;
 		break;
 	case "/msg":
 		var trimmed = msg.text.substr(split[0].length + 1);
 		var matched = "";
 
 		// Reject names which don't match or are a superset of the intended name.
 		for each (var player in playerAssignments)
 			if (trimmed.indexOf(player.name + " ") == 0 && player.name.length > matched.length)
 				matched = player.name;
 
 		// If the local player's name was the longest one matched, show the message.
 		var playerName = g_Players[Engine.GetPlayerID()].name;
 		if (matched.length && (matched == playerName || sender == Engine.GetPlayerID()))
 		{
 			msg.prefix = "(Private) ";
 			msg.text = trimmed.substr(matched.length + 1);
 			msg.hide = false; // Might override team message hiding.
 			return;
 		}
 		else
 			msg.hide = true;
 		break;
 	default:
 		return;
 	}
 
 	msg.text = msg.text.substr(split[0].length + 1);
 
 	// Hide the message if parsing commands left it empty.
 	if (!msg.text.length)
 		msg.hide = true;
 
 	// Attempt to parse more commands if the current command allows it.
 	if (recurse)
 		parseChatCommands(msg, playerAssignments);
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/session.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 14418)
@@ -1,893 +1,894 @@
 // Network Mode
 var g_IsNetworked = false;
 
 // Is this user in control of game settings (i.e. is a network server, or offline player)
 var g_IsController;
 // Match ID for tracking
 var g_MatchID;
 
 // Cache the basic player data (name, civ, color)
 var g_Players = [];
 // Cache the useful civ data
 var g_CivData = {};
 
 var g_GameSpeeds = {};
 var g_CurrentSpeed;
 
 var g_PlayerAssignments = { "local": { "name": "You", "player": 1 } };
 
 // Cache dev-mode settings that are frequently or widely used
 var g_DevSettings = {
 	controlAll: false
 };
 
 // Whether status bars should be shown for all of the player's units.
 var g_ShowAllStatusBars = false;
 
 // Indicate when one of the current player's training queues is blocked
 // (this is used to support population counter blinking)
 var g_IsTrainingBlocked = false;
 
 // Cache simulation state (updated on every simulation update)
 var g_SimState;
 
 // Cache EntityStates
 var g_EntityStates = {}; // {id:entState}
 
 // Whether the player has lost/won and reached the end of their game
 var g_GameEnded = false;
 
 var g_Disconnected = false; // Lost connection to server
 
 // Holds player states from the last tick
 var g_CachedLastStates = "";
 
 // Colors to flash when pop limit reached
 const DEFAULT_POPULATION_COLOR = "white";
 const POPULATION_ALERT_COLOR = "orange";
 
 // List of additional entities to highlight
 var g_ShowGuarding = false;
 var g_ShowGuarded = false;
 var g_AdditionalHighlight = [];
 
 function GetSimState()
 {
 	if (!g_SimState)
 		g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	return g_SimState;
 }
 
 function GetEntityState(entId)
 {
 	if (!(entId in g_EntityStates))
 	{
 		var entState = Engine.GuiInterfaceCall("GetEntityState", entId);
 		if (entState)
 			entState.extended = false;
 		g_EntityStates[entId] = entState;
 	}
 
 	return g_EntityStates[entId];
 }
 
 function GetExtendedEntityState(entId)
 {
 	if (entId in g_EntityStates)
 		var entState = g_EntityStates[entId];
 	else
 		var entState = Engine.GuiInterfaceCall("GetEntityState", entId);
 
 	if (!entState || entState.extended)
 		return entState;
 
 	var extension = Engine.GuiInterfaceCall("GetExtendedEntityState", entId);
 	for (var prop in extension)
 		entState[prop] = extension[prop];
 	entState.extended = true;
 	g_EntityStates[entId] = entState;
 
 	return entState;
 }
 
 // Cache TemplateData
 var g_TemplateData = {}; // {id:template}
 
 
 function GetTemplateData(templateName)
 {
 	if (!(templateName in g_TemplateData))
 	{
 		var template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		g_TemplateData[templateName] = template;
 	}
 
 	return g_TemplateData[templateName];
 }
 
 // Cache TechnologyData
 var g_TechnologyData = {}; // {id:template}
 
 function GetTechnologyData(technologyName)
 {
 	if (!(technologyName in g_TechnologyData))
 	{
 		var template = Engine.GuiInterfaceCall("GetTechnologyData", technologyName);
 		g_TechnologyData[technologyName] = template;
 	}
 
 	return g_TechnologyData[technologyName];
 }
 
 // Init
 function init(initData, hotloadData)
 {
 	if (initData)
 	{
 		g_IsNetworked = initData.isNetworked; // Set network mode
 		g_IsController = initData.isController; // Set controller mode
 		g_PlayerAssignments = initData.playerAssignments;
 		g_MatchID = initData.attribs.matchID;
 
 		// Cache the player data
 		// (This may be updated at runtime by handleNetMessage)
 		g_Players = getPlayerData(g_PlayerAssignments);
 
 		if (initData.savedGUIData)
 			restoreSavedGameData(initData.savedGUIData);
 
 		getGUIObjectByName("gameSpeedButton").hidden = g_IsNetworked;
 	}
 	else // Needed for autostart loading option
 	{
 		g_Players = getPlayerData(null);
 	}
 
 	// Cache civ data
 	g_CivData = loadCivData();
 	g_CivData["gaia"] = { "Code": "gaia", "Name": "Gaia" };
 
 	g_GameSpeeds = initGameSpeeds();
 	g_CurrentSpeed = Engine.GetSimRate();
 	var gameSpeed = getGUIObjectByName("gameSpeed");
 	gameSpeed.list = g_GameSpeeds.names;
 	gameSpeed.list_data = g_GameSpeeds.speeds;
 	var idx = g_GameSpeeds.speeds.indexOf(g_CurrentSpeed);
 	gameSpeed.selected = idx != -1 ? idx : g_GameSpeeds["default"];
 	gameSpeed.onSelectionChange = function() { changeGameSpeed(+this.list_data[this.selected]); }
 
 	getGUIObjectByName("civIcon").sprite = "stretched:" + g_CivData[g_Players[Engine.GetPlayerID()].civ].Emblem;
 	getGUIObjectByName("civIcon").tooltip = g_CivData[g_Players[Engine.GetPlayerID()].civ].Name;
 	initMenuPosition(); // set initial position
 
 	// Populate player selection dropdown
 	var playerNames = [];
 	var playerIDs = [];
 	for (var player in g_Players)
 	{
 		playerNames.push(g_Players[player].name);
 		playerIDs.push(player);
 	}
 
 	var viewPlayerDropdown = getGUIObjectByName("viewPlayer");
 	viewPlayerDropdown.list = playerNames;
 	viewPlayerDropdown.list_data = playerIDs;
 	viewPlayerDropdown.selected = Engine.GetPlayerID();
 
 	// If in Atlas editor, disable the exit button
 	if (Engine.IsAtlasRunning())
 		getGUIObjectByName("menuExitButton").enabled = false;
 
 	if (hotloadData)
 	{
 		g_Selection.selected = hotloadData.selection;
 	}
 	else
 	{
 		// Starting for the first time:
 		var civMusic = g_CivData[g_Players[Engine.GetPlayerID()].civ].Music;
 		initMusic();
 		global.music.storeTracks(civMusic);
 		global.music.setState(global.music.states.PEACE);
 		playRandomAmbient("temperate");
 	}
 
 	if (Engine.ConfigDB_GetValue("user", "gui.session.timeelapsedcounter") === "true")
 		getGUIObjectByName("timeElapsedCounter").hidden = false;
 
 	onSimulationUpdate();
 
 	// Report the performance after 5 seconds (when we're still near
 	// the initial camera view) and a minute (when the profiler will
 	// have settled down if framerates as very low), to give some
 	// extremely rough indications of performance
 	setTimeout(function() { reportPerformance(5); }, 5000);
 	setTimeout(function() { reportPerformance(60); }, 60000);
 }
 
 function selectViewPlayer(playerID)
 {
 	Engine.SetPlayerID(playerID);
 	if (playerID != 0) {
 		getGUIObjectByName("civIcon").sprite = "stretched:" + g_CivData[g_Players[playerID].civ].Emblem;
 		getGUIObjectByName("civIcon").tooltip = g_CivData[g_Players[playerID].civ].Name;
 	}
 }
 
 function reportPerformance(time)
 {
 	var settings = Engine.GetMapSettings();
 	var data = {
 		time: time,
 		map: settings.Name,
 		seed: settings.Seed, // only defined for random maps
 		size: settings.Size, // only defined for random maps
 		profiler: Engine.GetProfilerState()
 	};
 
 	Engine.SubmitUserReport("profile", 3, JSON.stringify(data));
 }
 
 function resignGame()
 {
 	var simState = GetSimState();
 
 	// Players can't resign if they've already won or lost.
 	if (simState.players[Engine.GetPlayerID()].state != "active" || g_Disconnected)
 		return;
 
 	// Tell other players that we have given up and been defeated
 	Engine.PostNetworkCommand({
 		"type": "defeat-player",
 		"playerId": Engine.GetPlayerID()
 	});
 
 	global.music.setState(global.music.states.DEFEAT);
 	resumeGame();
 }
 
 function leaveGame()
 {
 	var extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 	var playerState = extendedSimState.players[Engine.GetPlayerID()];
 	var mapSettings = Engine.GetMapSettings();
 	var gameResult;
 
 	if (g_Disconnected)
 	{
 		gameResult = "You have been disconnected."
 	}
 	else if (playerState.state == "won")
 	{
 		gameResult = "You have won the battle!";
 	}
 	else if (playerState.state == "defeated")
 	{
 		gameResult = "You have been defeated...";
 	}
 	else // "active"
 	{
 		gameResult = "You have abandoned the game.";
 
 		// Tell other players that we have given up and been defeated
 		Engine.PostNetworkCommand({
 			"type": "defeat-player",
 			"playerId": Engine.GetPlayerID()
 		});
 
 		global.music.setState(global.music.states.DEFEAT);
 	}
 
 	stopAmbient();
 	endGame();
 
 	if (g_IsController && Engine.HasXmppClient())
 		Engine.SendUnregisterGame();
 
 	Engine.SwitchGuiPage("page_summary.xml", {
 							"gameResult"  : gameResult,
 							"timeElapsed" : extendedSimState.timeElapsed,
 							"playerStates": extendedSimState.players,
 							"players": g_Players,
 							"mapSettings": mapSettings
 						 });
 }
 
 // Return some data that we'll use when hotloading this file after changes
 function getHotloadData()
 {
 	return { selection: g_Selection.selected };
 }
 
 // Return some data that will be stored in saved game files
 function getSavedGameData()
 {
 	var data = {};
 	data.playerAssignments = g_PlayerAssignments;
 	data.groups = g_Groups.groups;
 	// TODO: any other gui state?
 	return data;
 }
 
 function restoreSavedGameData(data)
 {
 	// Clear selection when loading a game
 	g_Selection.reset();
 
 	// Restore control groups
 	for (var groupNumber in data.groups)
 	{
 		g_Groups.groups[groupNumber].groups = data.groups[groupNumber].groups;
 		g_Groups.groups[groupNumber].ents = data.groups[groupNumber].ents;
 	}
 	updateGroups();
 }
 
 var lastTickTime = new Date;
 
 /**
  * Called every frame.
  */
 function onTick()
 {
 	var now = new Date;
 	var tickLength = new Date - lastTickTime;
 	lastTickTime = now;
 
 	checkPlayerState();
 
 	while (true)
 	{
 		var message = Engine.PollNetworkClient();
 		if (!message)
 			break;
 		handleNetMessage(message);
 	}
 
 	updateCursorAndTooltip();
 
 	// If the selection changed, we need to regenerate the sim display (the display depends on both the
 	// simulation state and the current selection).
 	if (g_Selection.dirty)
 	{
 		g_Selection.dirty = false;
 
 		onSimulationUpdate();
 
 		// Display rally points for selected buildings
 		Engine.GuiInterfaceCall("DisplayRallyPoint", { "entities": g_Selection.toList() });
 	}
 
 	// Run timers
 	updateTimers();
 
 	// Animate menu
 	updateMenuPosition(tickLength);
 
 	// When training is blocked, flash population (alternates colour every 500msec)
 	if (g_IsTrainingBlocked && (Date.now() % 1000) < 500)
 		getGUIObjectByName("resourcePop").textcolor = POPULATION_ALERT_COLOR;
 	else
 		getGUIObjectByName("resourcePop").textcolor = DEFAULT_POPULATION_COLOR;
 
 	// Clear renamed entities list
 	Engine.GuiInterfaceCall("ClearRenamedEntities");
 }
 
 function checkPlayerState()
 {
 	// Once the game ends, we're done here.
 	if (g_GameEnded)
 		return;
 
 	// Send a game report for each player in this game.
 	var m_simState = GetSimState();
 	var playerState = m_simState.players[Engine.GetPlayerID()];
 	var tempStates = "";
 	for each (var player in m_simState.players) {tempStates += player.state + ",";}
 
 	if (g_CachedLastStates != tempStates)
 	{
 		g_CachedLastStates = tempStates;
 		reportGame(Engine.GuiInterfaceCall("GetExtendedSimulationState"));
 	}
 
 	// If the local player hasn't finished playing, we return here to avoid the victory/defeat messages.
 	if (playerState.state == "active")
 		return;
 
 	// We can't resign once the game is over.
 	getGUIObjectByName("menuResignButton").enabled = false;
 
 	// Make sure nothing is open to avoid stacking.
 	closeMenu();
 	closeOpenDialogs();
 
 	// Make sure this doesn't run again.
 	g_GameEnded = true;
 
 	if (Engine.IsAtlasRunning())
 	{
 		// If we're in Atlas, we can't leave the game
 		var btCaptions = ["OK"];
 		var btCode = [null];
 		var message = "Press OK to continue";
 	}
 	else
 	{
 		var btCaptions = ["Yes", "No"];
 		var btCode = [leaveGame, null];
 		var message = "Do you want to quit?";
 	}
 
 	if (playerState.state == "defeated")
 	{
 		global.music.setState(global.music.states.DEFEAT);
 		messageBox(400, 200, message, "DEFEATED!", 0, btCaptions, btCode);
 	}
 	else if (playerState.state == "won")
 	{
 		global.music.setState(global.music.states.VICTORY);
 		// TODO: Reveal map directly instead of this silly proxy.
 		if (!getGUIObjectByName("devCommandsRevealMap").checked)
 			getGUIObjectByName("devCommandsRevealMap").checked = true;
 		messageBox(400, 200, message, "VICTORIOUS!", 0, btCaptions, btCode);
 	}
 
 }
 
 function changeGameSpeed(speed)
 {
 	// For non-networked games only
 	if (!g_IsNetworked)
 	{
 		Engine.SetSimRate(speed);
 		g_CurrentSpeed = speed;
 	}
 }
 
 /**
  * Recomputes GUI state that depends on simulation state or selection state. Called directly every simulation
  * update (see session.xml), or from onTick when the selection has changed.
  */
 function onSimulationUpdate()
 {
 	g_EntityStates = {};
 	g_TemplateData = {};
 	g_TechnologyData = {};
 
 	g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	// If we're called during init when the game is first loading, there will be no simulation yet, so do nothing
 	if (!g_SimState)
 		return;
 
 	handleNotifications();
 
 	if (g_ShowAllStatusBars)
 		recalculateStatusBarDisplay();
 
 	if (g_ShowGuarding || g_ShowGuarded)
 		updateAdditionalHighlight();
 
 	updateHero();
 	updateGroups();
 	updateDebug();
 	updatePlayerDisplay();
 	updateSelectionDetails();
 	updateResearchDisplay();
 	updateBuildingPlacementPreview();
 	updateTimeElapsedCounter();
+	updateTimeNotifications();	
 
 	// Update music state on basis of battle state.
 	var battleState = Engine.GuiInterfaceCall("GetBattleState", Engine.GetPlayerID());
 	if (battleState)
 		global.music.setState(global.music.states[battleState]);
 }
 
 function updateHero()
 {
 	var simState = GetSimState();
 	var playerState = simState.players[Engine.GetPlayerID()];
 	var heroButton = getGUIObjectByName("unitHeroButton");
 
 	if (!playerState || playerState.heroes.length <= 0)
 	{
 		heroButton.hidden = true;
 		return;
 	}
 
 	var heroImage = getGUIObjectByName("unitHeroImage");
 	var heroState = GetExtendedEntityState(playerState.heroes[0]);
 	var template = GetTemplateData(heroState.template);
 	heroImage.sprite = "stretched:session/portraits/" + template.icon;
 	var hero = playerState.heroes[0];
 
 	heroButton.onpress = function()
 	{
 		if (!Engine.HotkeyIsPressed("selection.add"))
 			g_Selection.reset();
 		g_Selection.addList([hero]);
 	};
 	heroButton.ondoublepress = function() { selectAndMoveTo(getEntityOrHolder(hero)); };
 	heroButton.hidden = false;
 
 	// Setup tooltip
 	var tooltip = "[font=\"serif-bold-16\"]" + template.name.specific + "[/font]";
 	tooltip += "\n[font=\"serif-bold-13\"]Health:[/font] " + heroState.hitpoints + "/" + heroState.maxHitpoints;
 	tooltip += "\n[font=\"serif-bold-13\"]" + (heroState.attack ? heroState.attack.type + " " : "")
 	           + "Attack:[/font] " + damageTypeDetails(heroState.attack);
 	// Show max attack range if ranged attack, also convert to tiles (4m per tile)
 	if (heroState.attack && heroState.attack.type == "Ranged")
 		tooltip += ", [font=\"serif-bold-13\"]Range:[/font] " + Math.round(heroState.attack.maxRange/4);
 
 	tooltip += "\n[font=\"serif-bold-13\"]Armor:[/font] " + damageTypeDetails(heroState.armour);
 	tooltip += "\n" + template.tooltip;
 
 	heroButton.tooltip = tooltip;
 };
 
 function updateGroups()
 {
 	var guiName = "Group";
 	g_Groups.update();
 	for (var i = 0; i < 10; i++)
 	{
 		var button = getGUIObjectByName("unit"+guiName+"Button["+i+"]");
 		var label = getGUIObjectByName("unit"+guiName+"Label["+i+"]").caption = i;
 		if (g_Groups.groups[i].getTotalCount() == 0)
 			button.hidden = true;
 		else
 			button.hidden = false;
 		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);
 	}
 	var numButtons = i;
 	var rowLength = 1;
 	var numRows = Math.ceil(numButtons / rowLength);
 	var buttonSideLength = getGUIObjectByName("unit"+guiName+"Button[0]").size.bottom;
 	var buttonSpacer = buttonSideLength+1;
 	for (var i = 0; i < numRows; i++)
 		layoutButtonRow(i, guiName, buttonSideLength, buttonSpacer, rowLength*i, rowLength*(i+1) );
 }
 
 function updateDebug()
 {
 	var simState = GetSimState();
 	var debug = getGUIObjectByName("debug");
 
 	if (getGUIObjectByName("devDisplayState").checked)
 	{
 		debug.hidden = false;
 	}
 	else
 	{
 		debug.hidden = true;
 		return;
 	}
 
 	var conciseSimState = deepcopy(simState);
 	conciseSimState.players = "<<<omitted>>>";
 	var text = "simulation: " + uneval(conciseSimState);
 
 	var selection = g_Selection.toList();
 	if (selection.length)
 	{
 		var entState = GetExtendedEntityState(selection[0]);
 		if (entState)
 		{
 			var template = GetTemplateData(entState.template);
 			text += "\n\nentity: {\n";
 			for (var k in entState)
 				text += "  "+k+":"+uneval(entState[k])+"\n";
 			text += "}\n\ntemplate: " + uneval(template);
 		}
 	}
 
 	debug.caption = text;
 }
 
 function updatePlayerDisplay()
 {
 	var simState = GetSimState();
 	var playerState = simState.players[Engine.GetPlayerID()];
 	if (!playerState)
 		return;
 
 	getGUIObjectByName("resourceFood").caption = playerState.resourceCounts.food;
 	getGUIObjectByName("resourceWood").caption = playerState.resourceCounts.wood;
 	getGUIObjectByName("resourceStone").caption = playerState.resourceCounts.stone;
 	getGUIObjectByName("resourceMetal").caption = playerState.resourceCounts.metal;
 	getGUIObjectByName("resourcePop").caption = playerState.popCount + "/" + playerState.popLimit;
 
 	g_IsTrainingBlocked = playerState.trainingBlocked;
 }
 
 function selectAndMoveTo(ent)
 {
 	var entState = GetEntityState(ent);
 	if (!entState || !entState.position)
 		return;
 
 	g_Selection.reset();
 	g_Selection.addList([ent]);
 
 	var position = entState.position;
 	Engine.CameraMoveTo(position.x, position.z);
 }
 
 function updateResearchDisplay()
 {
 	var researchStarted = Engine.GuiInterfaceCall("GetStartedResearch", Engine.GetPlayerID());
 	if (!researchStarted)
 		return;
 
 	// Set up initial positioning.
 	var buttonSideLength = getGUIObjectByName("researchStartedButton[0]").size.right;
 	for (var i = 0; i < 10; ++i)
 	{
 		var button = getGUIObjectByName("researchStartedButton[" + i + "]");
 		var size = button.size;
 		size.top = (4 + buttonSideLength) * i;
 		size.bottom = size.top + buttonSideLength;
 		button.size = size;
 	}
 
 	var numButtons = 0;
 	for (var tech in researchStarted)
 	{
 		// Show at most 10 in-progress techs.
 		if (numButtons >= 10)
 			break;
 
 		var template = GetTechnologyData(tech);
 		var button = getGUIObjectByName("researchStartedButton[" + numButtons + "]");
 		button.hidden = false;
 		button.tooltip = getEntityNames(template);
 		button.onpress = (function(e) { return function() { selectAndMoveTo(e) } })(researchStarted[tech].researcher);
 
 		var icon = "stretched:session/portraits/" + template.icon;
 		getGUIObjectByName("researchStartedIcon[" + numButtons + "]").sprite = icon;
 
 		// Scale the progress indicator.
 		var size = 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));
 		getGUIObjectByName("researchStartedProgressSlider[" + numButtons + "]").size = size;
 
 		++numButtons;
 	}
 
 	// Hide unused buttons.
 	for (var i = numButtons; i < 10; ++i)
 		getGUIObjectByName("researchStartedButton[" + i + "]").hidden = true;
 }
 
 function updateTimeElapsedCounter()
 {
 	var simState = GetSimState();
 	var speed = g_CurrentSpeed != 1.0 ? " (" + g_CurrentSpeed + "x)" : "";
 	var timeElapsedCounter = getGUIObjectByName("timeElapsedCounter");
 	timeElapsedCounter.caption = timeToString(simState.timeElapsed) + speed;
 }
 
 // Toggles the display of status bars for all of the player's entities.
 function recalculateStatusBarDisplay()
 {
 	if (g_ShowAllStatusBars)
 		var entities = Engine.PickFriendlyEntitiesOnScreen(Engine.GetPlayerID());
 	else
 	{
 		var selected = g_Selection.toList();
 		for each (var ent in g_Selection.highlighted)
 			selected.push(ent);
 
 		// Remove selected entities from the 'all entities' array, to avoid disabling their status bars.
 		var entities = Engine.GuiInterfaceCall("GetPlayerEntities").filter(
 				function(idx) { return (selected.indexOf(idx) == -1); }
 		);
 	}
 
 	Engine.GuiInterfaceCall("SetStatusBars", { "entities": entities, "enabled": g_ShowAllStatusBars });
 }
 
 // Update the additional list of entities to be highlighted.
 function updateAdditionalHighlight()
 {
 	var entsAdd = [];    // list of entities units to be highlighted
 	var entsRemove = [];
 	var highlighted = g_Selection.toList();
 	for each (var ent in g_Selection.highlighted)
 		highlighted.push(ent);
 
 	if (g_ShowGuarding)
 	{
 		// flag the guarding entities to add in this additional highlight
 		for each (var sel in g_Selection.selected)
 		{
 			var state = GetEntityState(sel);
 			if (!state.guard || !state.guard.entities.length)
 				continue;
 			for each (var ent in 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 each (var sel in g_Selection.selected)
 		{
 			var state = GetEntityState(sel);
 			if (!state.unitAI || !state.unitAI.isGuarding)
 				continue;
 			var 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 each (var ent in g_AdditionalHighlight)
 	    if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1 && entsRemove.indexOf(ent) == -1)
 			entsRemove.push(ent);
 
 	_setHighlight(entsAdd   , HIGHLIGHTED_ALPHA, true );
 	_setHighlight(entsRemove, 0                , false);
 	g_AdditionalHighlight = entsAdd;
 }
 
 // Temporarily adding this here
 const AMBIENT_TEMPERATE = "temperate";
 var currentAmbient;
 function playRandomAmbient(type)
 {
 	switch (type)
 	{
 		case AMBIENT_TEMPERATE:
 			// Seem to need the underscore at the end of "temperate" to avoid crash
 			// (Might be caused by trying to randomly load day_temperate.xml)
 //			currentAmbient = newRandomSound("ambient", "temperate_", "dayscape");
 
 			const AMBIENT = "audio/ambient/dayscape/day_temperate_gen_03.ogg";
 			Engine.PlayAmbientSound( AMBIENT, true );
 			break;
 
 		default:
 			Engine.Console_Write("Unrecognized ambient type: " + type);
 			break;
 	}
 }
 
 // Temporarily adding this here
 function stopAmbient()
 {
 	if (currentAmbient)
 	{
 		currentAmbient.free();
 		currentAmbient = null;
 	}
 }
 // Send a report on the game status to the lobby
 function reportGame(extendedSimState)
 {
 	if (!Engine.HasXmppClient())
 		return;
 
 	// Resources gathered and used
 	var playerFoodGatheredString = "";
 	var playerWoodGatheredString  = "";
 	var playerStoneGatheredString = "";
 	var playerMetalGatheredString = "";
 	var playerFoodUsedString = "";
 	var playerWoodUsedString  = "";
 	var playerStoneUsedString = "";
 	var playerMetalUsedString = "";
 	// Resources exchanged
 	var playerFoodBoughtString = "";
 	var playerWoodBoughtString = "";
 	var playerStoneBoughtString = "";
 	var playerMetalBoughtString = "";
 	var playerFoodSoldString = "";
 	var playerWoodSoldString = "";
 	var playerStoneSoldString = "";
 	var playerMetalSoldString = "";
 	var playerTradeIncomeString = "";
 	// Unit Stats
 	var playerUnitsLostString = "";
 	var playerUnitsTrainedString = "";
 	var playerEnemyUnitsKilledString = "";
 	// Building stats
 	var playerBuildingsConstructedString = "";
 	var playerBuildingsLostString = "";
 	var playerEnemyBuildingsDestroyedString = "";
 	var playerCivCentersBuiltString = "";
 	var playerEnemyCivCentersDestroyedString = "";
 	// Tribute
 	var playerTributeSentString = "";
 	var playerTributeReceivedString = "";
 	// Various
 	var mapName = Engine.GetMapSettings().Name;
 	var playerStatesString = "";
 	var playerCivsString = "";
 	var playerPercentMapExploredString = "";
 	var playerTreasuresCollectedString = "";
 
 	// Serialize the statistics for each player into a comma-separated list.
 	for each (var player in extendedSimState.players)
 	{
 		playerStatesString += player.state + ",";
 		playerCivsString += player.civ + ",";
 		playerFoodGatheredString += player.statistics.resourcesGathered.food + ",";
 		playerWoodGatheredString += player.statistics.resourcesGathered.wood + ",";
 		playerStoneGatheredString += player.statistics.resourcesGathered.stone + ",";
 		playerMetalGatheredString += player.statistics.resourcesGathered.metal + ",";
 		playerFoodUsedString += player.statistics.resourcesUsed.food + ",";
 		playerWoodUsedString += player.statistics.resourcesUsed.wood + ",";
 		playerStoneUsedString += player.statistics.resourcesUsed.stone + ",";
 		playerMetalUsedString += player.statistics.resourcesUsed.metal + ",";
 		playerUnitsLostString += player.statistics.unitsLost + ",";
 		playerUnitsTrainedString += player.statistics.unitsTrained + ",";
 		playerEnemyUnitsKilledString += player.statistics.enemyUnitsKilled + ",";
 		playerBuildingsConstructedString += player.statistics.buildingsConstructed + ",";
 		playerBuildingsLostString += player.statistics.buildingsLost + ",";
 		playerEnemyBuildingsDestroyedString += player.statistics.enemyBuildingsDestroyed + ",";
 		playerFoodBoughtString += player.statistics.resourcesBought.food + ",";
 		playerWoodBoughtString += player.statistics.resourcesBought.wood + ",";
 		playerStoneBoughtString += player.statistics.resourcesBought.stone + ",";
 		playerMetalBoughtString += player.statistics.resourcesBought.metal + ",";
 		playerFoodSoldString += player.statistics.resourcesSold.food + ",";
 		playerWoodSoldString += player.statistics.resourcesSold.wood + ",";
 		playerStoneSoldString += player.statistics.resourcesSold.stone + ",";
 		playerMetalSoldString += player.statistics.resourcesSold.metal + ",";
 		playerTributeSentString += player.statistics.tributesSent + ",";
 		playerTributeReceivedString += player.statistics.tributesReceived + ",";
 		playerPercentMapExploredString += player.statistics.precentMapExplored = ",";
 		playerCivCentersBuiltString += player.statistics.civCentresBuilt + ",";
 		playerEnemyCivCentersDestroyedString += player.statistics.enemyCivCentresDestroyed + ",";
 		playerTreasuresCollectedString += player.statistics.treasuresCollected + ",";
 		playerTradeIncomeString += player.statistics.tradeIncome + ",";
 	}
 
 	// Send the report with serialized data
 	Engine.SendGameReport({
 			"timeElapsed" : extendedSimState.timeElapsed,
 			"playerStates" : playerStatesString,
 			"playerID": Engine.GetPlayerID(),
 			"matchID": g_MatchID,
 			"civs" : playerCivsString,
 			"mapName" : mapName,
 			"foodGathered": playerFoodGatheredString,
 			"woodGathered": playerWoodGatheredString,
 			"stoneGathered": playerStoneGatheredString,
 			"metalGathered": playerMetalGatheredString,
 			"foodUsed": playerFoodUsedString,
 			"woodUsed": playerWoodUsedString,
 			"stoneUsed": playerStoneUsedString,
 			"metalUsed": playerMetalUsedString,
 			"unitsLost": playerUnitsLostString,
 			"unitsTrained": playerUnitsTrainedString,
 			"enemyUnitsKilled": playerEnemyUnitsKilledString,
 			"buildingsLost": playerBuildingsLostString,
 			"buildingsConstructed": playerBuildingsConstructedString,
 			"enemyBuildingsDestroyed": playerEnemyBuildingsDestroyedString,
 			"foodBought": playerFoodBoughtString,
 			"woodBought": playerWoodBoughtString,
 			"stoneBought": playerStoneBoughtString,
 			"metalBought": playerMetalBoughtString,
 			"foodSold": playerFoodSoldString,
 			"woodSold": playerWoodSoldString,
 			"stoneSold": playerStoneSoldString,
 			"metalSold": playerMetalSoldString,
 			"tributeSent": playerTributeSentString,
 			"tributeReceived": playerTributeReceivedString,
 			"precentMapExplored": playerPercentMapExploredString,
 			"civCentersBuilt": playerCivCentersBuiltString,
 			"enemyCivCentersDestroyed": playerEnemyCivCentersDestroyedString,
 			"treasuresCollected": playerTreasuresCollectedString,
 			"tradeIncome": playerTradeIncomeString
 		});
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/session.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.xml	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.xml	(revision 14418)
@@ -1,1329 +1,1333 @@
 <?xml version="1.0" encoding="utf-8"?>
 
 <objects>
 
     <script file="gui/common/functions_civinfo.js"/>
     <script file="gui/common/functions_utility.js" />
     <script file="gui/common/functions_global_object.js" />
     <script file="gui/common/music.js"/>
     <script file="gui/common/timer.js"/>
     <script file="gui/session/session.js"/>
     <script file="gui/session/selection.js"/>
     <script file="gui/session/placement.js"/>
     <script file="gui/session/input.js"/>
     <script file="gui/session/menu.js"/>
     <script file="gui/session/selection_details.js"/>
     <script file="gui/session/unit_commands.js"/>
     <script file="gui/session/messages.js"/>
     <script file="gui/session/utility_functions.js"/>
 
     <object name="sn" hotkey="session.gui.toggle">
 	<action on="Tick">
 	    onTick();
 	</action>
 
 	<action on="SimulationUpdate">
 	    onSimulationUpdate();
 	</action>
 
 	<action on="Press">
 	    this.hidden = !this.hidden;
 	</action>
 
 	<!-- ================================  ================================ -->
 	<!-- HOTKEYS (For some reason, they won't work properly unless outside menu) -->
 	<!-- ================================  ================================ -->
 
 	<!-- Exit button Hotkey  -->
 	<!--
 		<action on="Press"><![CDATA[
 			messageBox(400, 200, "Do you really want to quit?", "Confirmation", 0,
 				["Yes", "No!"], [leaveGame, null]);
 		]]></action>
 	-->
 
 	<object hotkey="leave">
 	    <action on="Press">closeOpenDialogs();</action>
 	</object>
 
 	<!-- Chat: Depending on the current state, it either opens message window or closes message window / posts message -->
 	<object hotkey="chat">
 	    <action on="Press">toggleChatWindow();</action>
 	</object>
 
 	<!-- Team Chat: Does the same as the above, but sets the window up to only send messages to teammates. -->
 	<object hotkey="teamchat">
 	    <action on="Press">toggleChatWindow(true);</action>
 	</object>
 
 	<!-- Menu -->
 	<object hotkey="menu.toggle">
 	    <action on="Press">openMenu();</action>
 	</object>
 
 	<!-- Unit silhouettes -->
 	<object hotkey="silhouettes">
 	    <action on="Press">
 		var newSetting = !Engine.Renderer_GetSilhouettesEnabled();
 		Engine.Renderer_SetSilhouettesEnabled(newSetting);
 		getGUIObjectByName("silhouettesCheckbox").checked = newSetting;
 	    </action>
 	</object>
 
 	<!-- Sky -->
 	<object hotkey="showsky">
 	    <action on="Press">
 		var newSetting =  !Engine.Renderer_GetShowSkyEnabled();
 		Engine.Renderer_SetShowSkyEnabled(newSetting);
 	    </action>
 	</object>
 
 	<!-- Pause -->
 	<object hotkey="pause">
 	    <action on="Press">togglePause();</action>
 	</object>
 
 	<!-- Quicksave/load -->
 	<object hotkey="quicksave">
 	    <action on="Press">Engine.QuickSave();</action>
 	</object>
 	<object hotkey="quickload">
 	    <action on="Press">Engine.QuickLoad();</action>
 	</object>
 
 	<!-- Delete button Hotkey (For some reason it won't work when the console is visible -->
 	<object hotkey="session.kill">
 	    <action on="Press">performCommand(g_Selection.toList()[0], "delete");</action>
 	</object>
 
 	<!-- camera.follow mode - follow the first unit in the selection -->
 	<object hotkey="camera.follow">
 	    <action on="Press">setCameraFollow(g_Selection.toList()[0]);</action>
 	</object>
 
 	<!-- Camera jumping - press a hotkey to mark a position and another hotkey to jump back there -->
 	<object hotkey="camera.jump.1">
 		<action on="Press">jumpCamera(1);</action>
 	</object>
 
 	<object hotkey="camera.jump.2">
 		<action on="Press">jumpCamera(2);</action>
 	</object>
 
 	<object hotkey="camera.jump.3">
 		<action on="Press">jumpCamera(3);</action>
 	</object>
 
 	<object hotkey="camera.jump.4">
 		<action on="Press">jumpCamera(4);</action>
 	</object>
 
 	<object hotkey="camera.jump.5">
 		<action on="Press">jumpCamera(5);</action>
 	</object>
 
 	<object hotkey="camera.jump.6">
 		<action on="Press">jumpCamera(6);</action>
 	</object>
 
 	<object hotkey="camera.jump.7">
 		<action on="Press">jumpCamera(7);</action>
 	</object>
 
 	<object hotkey="camera.jump.8">
 		<action on="Press">jumpCamera(8);</action>
 	</object>
 
 	<object hotkey="camera.jump.9">
 		<action on="Press">jumpCamera(9);</action>
 	</object>
 
 	<object hotkey="camera.jump.10">
 		<action on="Press">jumpCamera(10);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.1">
 		<action on="Press">setJumpCamera(1);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.2">
 		<action on="Press">setJumpCamera(2);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.3">
 		<action on="Press">setJumpCamera(3);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.4">
 		<action on="Press">setJumpCamera(4);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.5">
 		<action on="Press">setJumpCamera(5);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.6">
 		<action on="Press">setJumpCamera(6);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.7">
 		<action on="Press">setJumpCamera(7);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.8">
 		<action on="Press">setJumpCamera(8);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.9">
 		<action on="Press">setJumpCamera(9);</action>
 	</object>
 
 	<object hotkey="camera.jump.set.10">
 		<action on="Press">setJumpCamera(10);</action>
 	</object>
 	
 	<!-- Stop the selected units -->
 	<object hotkey="session.stop">
 	    <action on="Press">stopUnits(g_Selection.toList());</action>
 	</object>
 	
 	<!-- queue first unit in the training queue  -->
 	<object hotkey="session.queueunit.1">
 	    <action on="Press">addTrainingByPosition(0);</action>
 	</object>
 
 	<!-- queue 2nd unit in the training queue  -->
 	<object hotkey="session.queueunit.2">
 	    <action on="Press">addTrainingByPosition(1);</action>
 	</object>
 
 	<!-- queue 3rd unit in the training queue  -->
 	<object hotkey="session.queueunit.3">
 	    <action on="Press">addTrainingByPosition(2);</action>
 	</object>
 
 	<!-- queue 4th unit in the training queue  -->
 	<object hotkey="session.queueunit.4">
 	    <action on="Press">addTrainingByPosition(3);</action>
 	</object>
 	
 	<!-- queue 5th unit in the training queue  -->
 	<object hotkey="session.queueunit.5">
 	    <action on="Press">addTrainingByPosition(4);</action>
 	</object>
 
 	<!-- queue 6th unit in the training queue  -->
 	<object hotkey="session.queueunit.6">
 	    <action on="Press">addTrainingByPosition(5);</action>
 	</object>
 
 	<!-- queue 7th unit in the training queue  -->
 	<object hotkey="session.queueunit.7">
 	    <action on="Press">addTrainingByPosition(6);</action>
 	</object>
 
 		<!-- Find idle warrior - TODO: Potentially move this to own UI button? -->
 	<object hotkey="selection.idlewarrior">
 	    <action on="Press">findIdleUnit(["Hero", "Champion", "CitizenSoldier", "Siege", "Warship"]);</action>
 	</object>
 
 	<!-- Unselect any selected entities -->
 	<object hotkey="selection.cancel">
 	    <action on="Press">clearSelection()</action>
 	</object>
 	<!-- ================================  ================================ -->
 	<!-- Developer / Debug items -->
 	<!-- ================================  ================================ -->
 
 	<!-- Debug text -->
 	<object name="debug"
 		type="text"
 		size="0 70 80% 100%"
 		ghost="true"
 		textcolor="yellow"
 		font="mono-stroke-10"
 		/>
 
 	<!-- Dev/cheat commands -->
 	<object name="devCommands" size="100%-156 50%-88 100%-8 50%+104" type="image" sprite="devCommandsBackground" z="40"
 		hidden="true" hotkey="session.devcommands.toggle">
 		<action on="Press">toggleDeveloperOverlay();</action>
 
 	    <object size="0 0 100%-18 16" type="text" style="devCommandsText">Control all units</object>
 	    <object size="100%-16 0 100% 16" type="checkbox" name="devControlAll" style="StoneCrossBox">
 		<action on="Press">
 		    g_DevSettings.controlAll = this.checked;
 		    Engine.PostNetworkCommand( {"type": "control-all", "flag": this.checked} );
 		</action>
 	    </object>
 
 	    <object size="0 16 100%-18 32" type="text" style="devCommandsText">Change perspective</object>
 	    <object size="100%-16 16 100% 32" type="checkbox" style="StoneCrossBox">
 		<action on="Press">getGUIObjectByName("viewPlayer").hidden = !this.checked;</action>
 	    </object>
 
 	    <object size="0 32 100%-18 48" type="text" style="devCommandsText">Display selection state</object>
 	    <object size="100%-16 32 100% 48" type="checkbox" name="devDisplayState" style="StoneCrossBox"/>
 
 	    <object size="0 48 100%-18 64" type="text" style="devCommandsText">Pathfinder overlay</object>
 	    <object size="100%-16 48 100% 64" type="checkbox" style="StoneCrossBox">
 		<action on="Press">Engine.GuiInterfaceCall("SetPathfinderDebugOverlay", this.checked);</action>
 	    </object>
 
 	    <object size="0 64 100%-18 80" type="text" style="devCommandsText">Obstruction overlay</object>
 	    <object size="100%-16 64 100% 80" type="checkbox" style="StoneCrossBox">
 		<action on="Press">Engine.GuiInterfaceCall("SetObstructionDebugOverlay", this.checked);</action>
 	    </object>
 
 	    <object size="0 80 100%-18 96" type="text" style="devCommandsText">Unit motion overlay</object>
 	    <object size="100%-16 80 100% 96" type="checkbox" style="StoneCrossBox">
 		<action on="Press">g_Selection.SetMotionDebugOverlay(this.checked);</action>
 	    </object>
 
 	    <object size="0 96 100%-18 112" type="text" style="devCommandsText">Range overlay</object>
 	    <object size="100%-16 96 100% 112" type="checkbox" style="StoneCrossBox">
 		<action on="Press">Engine.GuiInterfaceCall("SetRangeDebugOverlay", this.checked);</action>
 	    </object>
 
 	    <object size="0 112 100%-18 128" type="text" style="devCommandsText">Bounding box overlay</object>
 	    <object size="100%-16 112 100% 128" type="checkbox" style="StoneCrossBox">
 		<action on="Press">Engine.SetBoundingBoxDebugOverlay(this.checked);</action>
 	    </object>
 
 	    <object size="0 128 100%-18 144" type="text" style="devCommandsText">Restrict camera</object>
 	    <object size="100%-16 128 100% 144" type="checkbox" style="StoneCrossBox" checked="true">
 		<action on="Press">Engine.GameView_SetConstrainCameraEnabled(this.checked);</action>
 	    </object>
 
 	    <object size="0 144 100%-18 160" type="text" style="devCommandsText">Reveal map</object>
 	    <object size="100%-16 144 100% 160" type="checkbox" name="devCommandsRevealMap" style="StoneCrossBox">
 		<action on="Load">this.checked = Engine.GuiInterfaceCall("IsMapRevealed");</action>
 		<action on="Press">Engine.PostNetworkCommand({"type": "reveal-map", "enable": this.checked});</action>
 	    </object>
 
 	    <object size="0 160 100%-18 176" type="text" style="devCommandsText">Enable time warp</object>
 	    <object size="100%-16 160 100% 176" type="checkbox" name="devTimeWarp" style="StoneCrossBox">
 		<action on="Press">
         if (this.checked)
           messageBox(500, 250, "Note: time warp mode is a developer option, and not intended\nfor use over long periods of time. Using it incorrectly may\ncause the game to run out of memory or crash.", "Time warp mode", 2);
         Engine.EnableTimeWarpRecording(this.checked ? 10 : 0);</action>
 	    </object>
 
 	    <object size="0 176 100%-18 192" type="text" style="devCommandsText">Promote selected units</object>
 	    <object size="100%-16 176 100% 192" type="button" style="StoneCrossBox">
 		<action on="Press">Engine.PostNetworkCommand({"type": "promote", "entities": g_Selection.toList()});</action>
 	    </object>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Time elapsed counter -->
 	<!-- ================================  ================================ -->
 	
 	<object size="100%-120 45 100%-10 65" type="text" name="timeElapsedCounter" style="SettingsText" hotkey="timeelapsedcounter.toggle" hidden="true">
 	    <action on="Press">this.hidden = !this.hidden;</action>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Pause Overlay -->
 	<!-- ================================  ================================ -->
 	<object type="button"
 		name="pauseOverlay"
 		size="0 0 100% 100%"
 		tooltip_style="sessionToolTip"
 		hidden="true"
 		z="0"
 	>
 	    <object size="0 0 100% 100%" type="image" sprite="devCommandsBackground" ghost="true" z="0"/>
 	    <object size="50%-128 50%-20 50%+128 50%+20" type="text" style="PauseText" ghost="true" z="0">Game Paused</object>
 	    <object size="50%-128 50%+20 50%+128 50%+30" type="text" style="PauseMessageText" ghost="true" z="0">Click to Resume Game</object>
 	    <action on="Press">togglePause();</action>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Notification Area -->
 	<!-- ================================  ================================ -->
 	<object name="notificationPanel" type="image" size="50%-300 60 50%+300 120" ghost="true">
 	    <object name="notificationText" size="0 0 100% 100%" type="text" style="notificationPanel" ghost="true"/>
 	</object>
+	<object name="timeNotificationPanel" type="image" size="100%-600 60 100%-20 120" ghost="true">
+	    <object name="timeNotificationText" size="0 0 100% 100%" type="text" style="notificationPanel" ghost="true"/>
+	</object>
+
 
 	<!-- ================================  ================================ -->
 	<!-- Chat -->
 	<!-- ================================  ================================ -->
 
 	<!-- Chat panel -->
 	<object name="chatPanel" size="0 130 100% 100%-240" type="image" ghost="true">
 	    <object name="chatText" size="3 1 100%-1 100%-1" type="text" style="chatPanel" ghost="true"/>
 	</object>
 
 	<!-- Chat window -->
 	<object name="chatDialogPanel" size="50%-180 50%-48 50%+180 50%+36" type="image" hidden="true" sprite="genericPanel">
 	    <object name="chatInput" size="16 12 100%-16 36" type="input" style="StoneInput" max_length="80">
 		<action on="Press">submitChatInput();</action>
 	    </object>
 
 	    <object size="16 100%-40 30%+16 100%-12" type="button" style="StoneButton">
 		Send
 		<action on="Press">submitChatInput();</action>
 	    </object>
 
 	    <object size="30%+24 100%-40 60%+24 100%-12" type="button" style="StoneButton">
 		Cancel
 		<action on="Press">closeChat();</action>
 	    </object>
 	    <object name="toggleTeamChat" size="60%+32 100%-34 60%+48 100%-6" type="checkbox" style="StoneCrossBox"/>
 	    <object size="60%+48 100%-40 100% 100%-12" type="text"  style="LeftLabelText">
 		Team Only
 	    </object>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Diplomacy Window -->
 	<!-- ================================  ================================ -->
 	<object name="diplomacyDialogPanel"
 		size="50%-300 50%-200 50%+300 50%+150"
 		type="image"
 		hidden="true"
 		sprite="StoneDialog"
 	>
 		<object type="text" style="TitleText" size="50%-96 -16 50%+96 16">Diplomacy</object>
 
 		<object name="diplomacyHeader" size="32 32 100%-32 64">
 			<object name="diplomacyHeaderName" size="0 0 150 100%" type="text" style="chatPanel" ghost="true" caption="Name"/>
 			<object name="diplomacyHeaderCiv" size="150 0 250 100%" type="text" style="chatPanel" ghost="true" caption="Civilization"/>
 			<object name="diplomacyHeaderTeam" size="250 0 300 100%" type="text" style="chatPanel" ghost="true" caption="Team"/>
 			<object name="diplomacyHeaderTheirs" size="300 0 360 100%" type="text" style="chatPanel" ghost="true" caption="Theirs"/>
 			<object name="diplomacyHeaderAlly" size="100%-180 0 100%-160 100%" type="text" style="chatPanel" caption="A" tooltip="Ally" tooltip_style="sessionToolTipBold"/>
 			<object name="diplomacyHeaderNeutral" size="100%-160 0 100%-140 100%" type="text" style="chatPanel" caption="N" tooltip="Neutral" tooltip_style="sessionToolTipBold"/>
 			<object name="diplomacyHeaderEnemy" size="100%-140 0 100%-120 100%" type="text" style="chatPanel" caption="E" tooltip="Enemy" tooltip_style="sessionToolTipBold"/>
 			<object name="diplomacyHeaderTribute" size="100%-110 0 100% 100%" type="text" style="chatPanel" caption="Tribute"/>
 		</object>
 
 		<object size="32 64 100%-32 384">
 			<repeat count="16">
 				<object name="diplomacyPlayer[n]" size="0 0 100% 20" type="image" hidden="false">
 					<object name="diplomacyPlayerName[n]" size="0 0 150 100%" type="text" style="chatPanel" ghost="true"/>
 					<object name="diplomacyPlayerCiv[n]" size="150 0 250 100%" type="text" style="chatPanel" ghost="true"/>
 					<object name="diplomacyPlayerTeam[n]" size="250 0 300 100%" type="text" style="chatPanel" ghost="true"/>
 					<object name="diplomacyPlayerTheirs[n]" size="300 0 360 100%" type="text" style="chatPanel" ghost="true"/>
 
 					<!-- Diplomatic stance - selection -->
 					<object name="diplomacyPlayerAlly[n]" size="100%-180 0 100%-160 100%" type="button" style="StoneButton" hidden="true"/>
 					<object name="diplomacyPlayerNeutral[n]" size="100%-160 0 100%-140 100%" type="button" style="StoneButton" hidden="true"/>
 					<object name="diplomacyPlayerEnemy[n]" size="100%-140 0 100%-120 100%" type="button" style="StoneButton" hidden="true"/>
 
 					<!-- Tribute -->
 					<object name="diplomacyPlayerTributeFood[n]" size="100%-110 0 100%-90 100%" type="button" style="iconButton" tooltip_style="sessionToolTipBold" hidden="true">
 						<object name="diplomacyPlayerTributeFoodImage[n]" type="image" size="0 0 100% 100%" sprite="stretched:session/icons/resources/food.png" ghost="true"/>
 					</object>
 					<object name="diplomacyPlayerTributeWood[n]" size="100%-90 0 100%-70 100%" type="button" style="iconButton" tooltip_style="sessionToolTipBold" hidden="true">
 						<object name="diplomacyPlayerTributeWoodImage[n]" type="image" size="0 0 100% 100%" sprite="stretched:session/icons/resources/wood.png" ghost="true"/>
 					</object>
 					<object name="diplomacyPlayerTributeStone[n]" size="100%-70 0 100%-50 100%" type="button" style="iconButton" tooltip_style="sessionToolTipBold" hidden="true">
 						<object name="diplomacyPlayerTributeStoneImage[n]" type="image" size="0 0 100% 100%" sprite="stretched:session/icons/resources/stone.png" ghost="true"/>
 					</object>
 					<object name="diplomacyPlayerTributeMetal[n]" size="100%-50 0 100%-30 100%" type="button" style="iconButton" tooltip_style="sessionToolTipBold" hidden="true">
 						<object name="diplomacyPlayerTributeMetalImage[n]" type="image" size="0 0 100% 100%" sprite="stretched:session/icons/resources/metal.png" ghost="true"/>
 					</object>
 				</object>
 			</repeat>
 		</object>
 
 		<object size="50%-64 100%-50 50%+64 100%-22" type="button" style="StoneButton">
 		    Close
 		    <action on="Press">closeDiplomacy();</action>
 		</object>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Trade Window -->
 	<!-- ================================  ================================ -->
 	<object name="tradeDialogPanel"
 		size="50%-250 50%-130 50%+250 50%+100"
 		type="image"
 		hidden="true"
 		sprite="ModernDialog"
 	>
 		<object type="text" style="TitleText" size="50%-96 -16 50%+96 16">Trade</object>
 
 		<!-- Trading goods -->
 		<object name="tradeGoods" size="20 50 100%-20 82">
 			<object name="tradeHeader" size="0 0 180 100%" type="text" style="ModernLeftLabelText" ghost="true" caption="Trading goods selection:"/>
 
 			<object size="180 0 100% 100%">
 				<repeat count="4">
 					<object name="tradeResource[n]" size="0 0 58 32">
 						<object name="tradeResourceButton[n]" size="4 0 36 100%" type="button" style="StoneButton">
 							<object name="tradeResourceIcon[n]" type="image" ghost="true"/>
 							<object name="tradeResourceSelection[n]" type="image" sprite="stretched:session/icons/corners.png" ghost="true"/>
 							<object name="tradeResourceText[n]" type="text" style="ModernCenteredLabelText" ghost="true"/>
 						</object>
 						<object name="tradeArrowUp[n]" size="36 0 52 50%" type="button" style="iconButton">
 							<object type="image" ghost="true" sprite="wheatArrowUp"/>
 						</object>
 						<object name="tradeArrowDn[n]" size="36 50% 52 100%" type="button" style="iconButton">
 							<object type="image" ghost="true" sprite="wheatArrowDn"/>
 						</object>
 					</object>
 				</repeat>
 				<object name="tradeHelp" size="100%-24 4 100% 28" enabled="false" type="button" style="StoneButton" tooltip_style="sessionToolTipBold" tooltip="Select one goods as origin of the changes, \nthen use the arrows of the target goods to make the changes.">
 					<object size="20% 15% 80% 75%" type="image" ghost="true" sprite="iconInfoWhite"/>
 				</object>
 			</object>
 		</object>
 
 		<object name="tradeStatistics" size="20 120 100%-20 168">
 			<object                    size="0   0   130   50%" type="text" style="ModernLeftLabelText" ghost="true" caption="Traders:"/>
 			<object name="landTraders" size="130 0   100%  50%" type="text" style="ModernLeftLabelText" ghost="true" />
 			<object                    size="0   50% 130  100%" type="text" style="ModernLeftLabelText" ghost="true" caption = "Merchant ships:"/>
 			<object name="shipTraders" size="130 50% 100% 100%" type="text" style="ModernLeftLabelText" ghost="true" />
 		</object>
 
 		<object size="50%-64 100%-50 50%+64 100%-22" type="button" style="StoneButton">
 		    Close
 		    <action on="Press">closeTrade();</action>
 		</object>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Settings Window -->
 	<!-- ================================  ================================ -->
 		<object name="settingsDialogPanel"
 			style="StoneDialog"
 			type="image"
 			size="50%-180 50%-225 50%+180 50%+225"
 			hidden="true"
 			z="200"
 			>
 			<object type="text" style="TitleText" size="50%-96 -16 50%+96 16">Settings</object>
 			
 			<object style="TranslucentPanelThinBorder"
 				type="image"
 				size="32 32 100%-32 100%-70"
 				>
 				<!-- Settings / shadows -->
 				<object size="0 10 100%-80 35" type="text" style="RightLabelText" ghost="true">Enable Shadows</object>
 				<object name="shadowsCheckbox" size="100%-56 15 100%-30 40" type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetShadowsEnabled();</action>
 					<action on="Press">Engine.Renderer_SetShadowsEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Shadow PCF -->
 				<object size="0 35 100%-80 60" type="text" style="RightLabelText" ghost="true">Enable Shadow Filtering</object>
 				<object name="shadowPCFCheckbox" size="100%-56 40 100%-30 65" type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetShadowPCFEnabled();</action>
 					<action on="Press">Engine.Renderer_SetShadowPCFEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Water Normals -->
 				<object size="0 60 100%-80 85" type="text" style="RightLabelText" ghost="true">Water - HQ Waviness</object>
 				<object name="waterNormalCheckox" size="100%-56 65 100%-30 90"  type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetWaterNormalEnabled();</action>
 					<action on="Press">Engine.Renderer_SetWaterNormalEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Real Depth -->
 				<object size="0 85 100%-80 110" type="text" style="RightLabelText" ghost="true">Water - Use Actual Depth</object>
 				<object name="waterRealDepthCheckbox" size="100%-56 90 100%-30 115"  type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetWaterRealDepthEnabled();</action>
 					<action on="Press">Engine.Renderer_SetWaterRealDepthEnabled(this.checked);</action>
 				</object>
 
 				<!-- Settings / Reflection -->
 				<object size="0 110 100%-80 135" type="text" style="RightLabelText" ghost="true">Water - Enable Reflections</object>
 				<object name="waterReflectionCheckbox" size="100%-56 115 100%-30 140"  type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetWaterReflectionEnabled();</action>
 					<action on="Press">Engine.Renderer_SetWaterReflectionEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Refraction -->
 				<object size="0 135 100%-80 160" type="text" style="RightLabelText" ghost="true">Water - Enable Refraction</object>
 				<object name="waterRefractionCheckbox" size="100%-56 140 100%-30 165"  type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetWaterRefractionEnabled();</action>
 					<action on="Press">Engine.Renderer_SetWaterRefractionEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Foam -->
 				<object size="0 160 100%-80 185" type="text" style="RightLabelText" ghost="true">Water - Enable Shore Foam</object>
 				<object name="waterFoamCheckbox" size="100%-56 165 100%-30 190"  type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetWaterFoamEnabled();</action>
 					<action on="Press">Engine.Renderer_SetWaterFoamEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Waves -->
 				<object size="0 185 100%-80 210" type="text" style="RightLabelText" ghost="true">Water - Enable Shore Waves</object>
 				<object name="waterCoastalWavesCheckbox" size="100%-56 190 100%-30 215"  type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetWaterCoastalWavesEnabled();</action>
 					<action on="Press">Engine.Renderer_SetWaterCoastalWavesEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Shadows -->
 				<object size="0 210 100%-80 235" type="text" style="RightLabelText" ghost="true">Water - Use Surface Shadows</object>
 				<object name="waterShadowsCheckbox" size="100%-56 215 100%-30 240"  type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">if (Engine.Renderer_GetWaterShadowEnabled()) this.checked = true; else this.checked = false;</action>
 					<action on="Press">Engine.Renderer_SetWaterShadowEnabled(this.checked);</action>
 				</object>
 
 				<!-- Settings / Particles -->
 				<object size="0 235 100%-80 260" type="text" style="RightLabelText" ghost="true">Enable Particles</object>
 				<object name="particlesCheckbox" size="100%-56 240 100%-30 265" type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetParticlesEnabled();</action>
 					<action on="Press">Engine.Renderer_SetParticlesEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Unit Silhouettes -->
 				<object size="0 260 100%-80 285" type="text" style="RightLabelText" ghost="true">Enable Unit Silhouettes</object>
 				<object name="silhouettesCheckbox" size="100%-56 265 100%-30 290" type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Load">this.checked = Engine.Renderer_GetSilhouettesEnabled();</action>
 					<action on="Press">Engine.Renderer_SetSilhouettesEnabled(this.checked);</action>
 				</object>
 				
 				<!-- Settings / Music-->
 				<object size="0 285 100%-80 310" type="text" style="RightLabelText" ghost="true">Enable Music</object>
 				<object name="musicCheckbox" size="100%-56 290 100%-30 315" type="checkbox" style="StoneCrossBox" checked="true">
 					<action on="Press">if (this.checked) global.music.start(); else global.music.stop();</action>
 				</object>
 				
 				<!-- Settings / Dev Overlay -->
 				<object size="0 310 100%-80 335" type="text" style="RightLabelText" ghost="true">Developer Overlay</object>
 				<object name="developerOverlayCheckbox" size="100%-56 315 100%-30 340" type="checkbox" style="StoneCrossBox" checked="false">
 					<action on="Load"><![CDATA[
 						if (Engine.HasXmppClient() && Engine.IsRankedGame())
 							this.enabled = false;
 					]]></action>
 					<action on="Press">toggleDeveloperOverlay();</action>
 				</object>
 			</object>
 			
 			<!-- Close button -->
 			<object type="button"
 				style="StoneButton"
 				size="50%-64 100%-52 50%+64 100%-24"
 				tooltip_style="sessionToolTip"
 				>
 				Close
 				<action on="Press">closeSettings(true);</action>
 			</object>
 		</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Top Panel  -->
 	<!-- ================================  ================================ -->
 	<object name="topPanel"
 		type="image"
 		sprite="topPanel"
 		size="-3 0 100%+3 36"
 	>
 	    <!-- ================================  ================================ -->
 	    <!-- Player resource bar -->
 	    <!-- ================================  ================================ -->
 	    <object
 		size="10 0 45% 100%"
 	    >
 		<!-- Food -->
 		<object size="0 0 90 100%" type="image" style="resourceCounter" tooltip="Food" tooltip_style="sessionToolTipBold">
 		    <object size="0 -4 40 36" type="image" sprite="stretched:session/icons/resources/food.png" ghost="true"/>
 		    <object size="32 0 100% 100%-2" type="text" style="resourceText" name="resourceFood"/>
 		</object>
 
 		<!-- Wood -->
 		<object size="90 0 180 100%" type="image" style="resourceCounter" tooltip="Wood" tooltip_style="sessionToolTipBold">
 		    <object size="0 -4 40 36" type="image" sprite="stretched:session/icons/resources/wood.png" ghost="true"/>
 		    <object size="32 0 100% 100%-2" type="text" style="resourceText" name="resourceWood"/>
 		</object>
 
 		<!-- Stone -->
 		<object size="180 0 270 100%" type="image" style="resourceCounter" tooltip="Stone" tooltip_style="sessionToolTipBold">
 		    <object size="0 -4 40 36" type="image" sprite="stretched:session/icons/resources/stone.png" ghost="true"/>
 		    <object size="32 0 100% 100%-2" type="text" style="resourceText" name="resourceStone"/>
 		</object>
 
 		<!-- Metal -->
 		<object size="270 0 360 100%"  type="image" style="resourceCounter" tooltip="Metal" tooltip_style="sessionToolTipBold">
 		    <object size="0 -4 40 36" type="image" sprite="stretched:session/icons/resources/metal.png" ghost="true"/>
 		    <object size="32 0 100% 100%-2" type="text" style="resourceText" name="resourceMetal"/>
 		</object>
 
 		<!-- Population -->
 		<object size="360 0 450 100%" type="image" style="resourceCounter" tooltip="Population (current / limit)" tooltip_style="sessionToolTipBold">
 		    <object size="0 -4 40 34" type="image" sprite="stretched:session/icons/resources/population.png" ghost="true"/>
 		    <object size="32 0 100% 100%-2" type="text" style="resourceText" name="resourcePop"/>
 		</object>
 	    </object>
 
 	    <!-- ================================  ================================ -->
 	    <!-- Civ Icon -->
 	    <!-- ================================  ================================ -->
 	    <object size="50%-48 -26 50%+48 70" name="civIcon" type="image" tooltip_style="sessionToolTipBold"/>
 
 	    <!-- Switch the view perspective to another player's (largely for AI development) -->
 	    <object size="50%+50 5 50%+150 100%-5" name="viewPlayer" type="dropdown" hidden="true" style="StoneDropDown" tooltip_style="sessionToolTipBold" tooltip="Choose player to view">
 		<action on="SelectionChange">selectViewPlayer(this.selected);</action>
 	    </object>
 
 	    <!-- ================================  ================================ -->
 	    <!-- Phase -->
 	    <!-- ================================  ================================ -->
 	    <!--<object size="50%+50 4 50%+300 100%-2" name="PhaseTitleBar" type="text" font="serif-bold-stroke-14" textcolor="white"> Death Match :: Village Phase</object>-->
 
 
 	    <!-- ================================  ================================ -->
 	    <!-- ALPHA LABELS (alpha, build time, revision) -->
 	    <!-- ================================  ================================ -->
 
 	    <!-- Displays Alpha name and number -->
 	    <object size="50%+48 0 100%-226 100%" name="alphaLabel" type="text" style="CenteredLabelText" text_valign="top" ghost="true">
 		ALPHA XV : Osiris<!-- IMPORTANT: remember to update pregame/mainmenu.xml in sync with this -->
 
 		<!-- Displays build date and revision number-->
 		<object size="50%-128 0 50%+128 100%-2" name="buildTimeLabel" type="text" style="BuildNameText" ghost="true">
 		    <action on="Load">this.caption = buildTime(0) + " (" + buildTime(2) + ")"</action>
 		</object>
 	    </object>
 
 		<!-- ================================  ================================ -->
 	    <!-- Game Speed Button -->
 	    <!-- ================================  ================================ -->
 	    <object type="button"
 		name="gameSpeedButton"
 		size="100%-258 4 100%-230 32"
 		style="iconButton"
 		tooltip_style="sessionToolTip"
 		tooltip="Game speed"
 	    >
 			<object size="5 5 100%-5 100%-5" type="image" sprite="stretched:session/icons/resources/time_small.png" ghost="true"/>
 			<action on="Press">
 				toggleGameSpeed();
 			</action>
 	    </object>
 
 		<object size="100%-380 40 100%-230 65" name="gameSpeed" type="dropdown" buffer_zone="5" style="StoneDropDown" hidden="true" tooltip="Choose game speed" tooltip_style="sessionToolTip"/>
 		
 	    <!-- ================================  ================================ -->
 	    <!-- Diplomacy Button -->
 	    <!-- ================================  ================================ -->
 	    <object type="button"
 		name="diplomacyButton1"
 		size="100%-226 4 100%-198 32"
 		style="iconButton"
 		tooltip_style="sessionToolTip"
 		tooltip="Diplomacy"
 	    >
 		<!-- TODO make the button less ugly -->
 		<object size="0 0 100% 100%" name="diplomacyButtonImage" type="image" sprite="stretched:session/icons/diplomacy.png" ghost="true"/>
 		<action on="Press">
 		    toggleDiplomacy();
 		</action>
 	    </object>
 
 	    <!-- ================================  ================================ -->
 	    <!-- Trade Button -->
 	    <!-- ================================  ================================ -->
 	    <object type="button"
 		name="tradeButton1"
 		size="100%-194 4 100%-166 32"
 		style="iconButton"
 		tooltip_style="sessionToolTip"
 		tooltip="Trade"
 	    >
 		<!-- TODO make the button less ugly -->
 		<object size="0 0 100% 100%" name="tradeButtonImage" type="image" sprite="stretched:session/icons/economics.png" ghost="true"/>
 		<action on="Press">
 		    toggleTrade();
 		</action>
 	    </object>
 
 	    <!-- ================================  ================================ -->
 	    <!-- Menu Button -->
 	    <!-- ================================  ================================ -->
 	    <object type="button"
 		    name="menuButton"
 		    size="100%-164 4 100%-8 32"
 		    style="StoneButtonFancy"
 		    tooltip_style="sessionToolTip"
 		    z="70"
 	    >
 		<!-- This object covers up the text on the menu
 		buttons as they slide by so that you don't see
 		them on top of the main menu button -->
 		<object size="0 -4 100% 0" type="image" sprite="horizontalThinBorder" ghost="true"/>
 
 		<object size="50%-32 50%-16 50%+32 50%+16" type="image" sprite="menuButton" ghost="true">MENU</object>
 		<action on="Press">
 		    toggleMenu();
 		</action>
 	    </object> <!-- END OF MENU BUTTON -->
 	</object> <!-- END OF TOP PANEL -->
 
 	<!-- ================================  ================================ -->
 	<!-- Menu -->
 	<!-- ================================  ================================ -->
 	<object name="menu"
 		style="StonePanelThinBorder"
 		type="image"
 		hidden="false"
 		z="40"
 	>
 	    <object size="4 36 100%-4 50%+20">
 
 		<!-- Settings button -->
 		<object type="button"
 			name="settingsButton"
 			style="StoneButtonFancy"
 			size="0 0 100% 28"
 			tooltip_style="sessionToolTip"
 		>
 		    Settings
 		    <action on="Press">settingsMenuButton();</action>
 		</object>
 
 
 		<!-- Save game button -->
 		<object type="button"
 			name="saveGameButton"
 			style="StoneButtonFancy"
 			size="0 32 100% 60"
 			tooltip_style="sessionToolTip"
 		>
 		    Save
 		    <action on="Press">
 			openSave();
 		    </action>
 		</object>
 
 		<!-- Chat button -->
 		<object type="button"
 			name="chatButton"
 			style="StoneButtonFancy"
 			size="0 64 100% 92"
 			tooltip_style="sessionToolTip"
 		>
 		    Chat
 		    <action on="Press">chatMenuButton();</action>
 		</object>
 
 		<!-- Resign button -->
 		<object type="button"
 			name="menuResignButton"
 			style="StoneButtonFancy"
 			size="0 96 100% 124"
 			tooltip_style="sessionToolTip"
 		>
 		    Resign
 		    <action on="Press">resignMenuButton();</action>
 		</object>
 
 		<!-- Exit button -->
 		<object type="button"
 			name="menuExitButton"
 			style="StoneButtonFancy"
 			size="0 128 100% 156"
 			tooltip_style="sessionToolTip"
 		>
 		    Exit
 		    <action on="Press">exitMenuButton();</action>
 		</object>
 
 		<!-- Pause / Resume Button -->
 		<object type="button"
 			name="pauseButton"
 			style="StoneButtonFancy"
 			size="0 160 100% 188"
 			tooltip_style="sessionToolTip"
 		>
 		    <object name="pauseButtonText" type="text" style="CenteredButtonText" ghost="true">Pause</object>
 		    <action on="Press">togglePause();</action>
 		</object>
 
 		<!-- Manual button -->
 		<object type="button"
 			name="manualButton"
 			style="StoneButtonFancy"
 			size="0 192 100% 220"
 			tooltip_style="sessionToolTip"
 		>
 			Manual
 			<action on="Press">openManual();</action>
 		</object>
 		</object>
 	</object>
 
 	<!-- In-progress research -->
 	<object size="100%-50 85 100%-10 100%-200">
 		<repeat count="10">
 			<object name="researchStartedButton[n]" hidden="true" style="iconButton" type="button" size="0 0 40 40" tooltip_style="sessionToolTipBottom">
 				<object name="researchStartedIcon[n]" ghost="true" type="image" size="3 3 37 37"/>
 				<object name="researchStartedProgressSlider[n]" type="image" sprite="queueProgressSlider" ghost="true" size="3 3 37 37"/>
 			</object>
 		</repeat>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Hero Selection -->
 	<!-- ================================  ================================ -->
 	<object
 	    name="unitHeroPanel"
 	    size="0 36 50 86"
 	>
 		<object name="unitHeroButton" size="0 0 50 50" type="button" hidden="false" style="iconButton" 
 			tooltip_style="sessionToolTip" tooltip="Attack and Armor">
 			<object name="unitHeroImage" size="5 5 100%-5 100%-5" type="image" ghost="true"/>
 		</object>
 	</object>
 	
 	<!-- ================================  ================================ -->
 	<!-- Unit Selection Groups -->
 	<!-- ================================  ================================ -->
 	<object
 	    name="unitGroupPanel"
 	    size="0% 50%-216 0%+36 50%+144"
 	>
 	    <repeat count="10">
 		<object name="unitGroupButton[n]" size="0 0 36 36" type="button" hidden="false" style="iconButton" tooltip_style="sessionToolTipBottomBold"
 			tooltip="Click to select grouped units.">
 		    <object name="unitGroupIcon[n]" size="3 3 33 33" type="image" sprite="groupsIcon" ghost="true"/>
 		    <object name="unitGroupLabel[n]" type="text" style="largeCenteredOutlinedText" ghost="true"/>
 		</object>
 	    </repeat>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Information tooltip
 		Follows the mouse around if 'independent' is set to 'true'. -->
 	<!-- ================================  ================================ -->
 	<object name="informationTooltip" type="tooltip" independent="true" style="informationTooltip"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Building placement info tooltip									-->
 	<!-- ================================  ================================ -->
 	<object name="placementTooltip" type="tooltip" independent="true" style="informationTooltip"/>
 
 	<!-- ================================  ================================ -->
 	<!-- START of BOTTOM PANEL -->
 	<!-- ================================  ================================ -->
 
 	<object size="50%-512 100%-180 50%+512 100%">
 
 	    <!-- ================================  ================================ -->
 	    <!-- Minimap -->
 	    <!-- ================================  ================================ -->
 	    <object
 		name="minimapPanel"
 		size="0 100%-212 212 100%"
 		type="image"
 		sprite="mapPanel"
 		z="20"
 	    >
 		<object name="minimap"
 			type="minimap"
 			size="14 14 100%-14 100%-14"
 		>
 		    <action on="WorldClick">handleMinimapEvent(arguments[0]);</action>
 		</object>
 
 		<object name="minimapOverlay" size="10 10 100%-10 100%-10" type="image" sprite="stretched:session/minimap_circle.png" ghost="true"/>
 
 		<!-- Idle Worker Button -->
 		<object type="image"
 			size="100%-36 4 100%-4 36"
 		>
 		    <object type="button"
 			    style="iconButton"
 			    tooltip_style="sessionToolTip"
 			    tooltip="Find idle worker"
 			    hotkey="selection.idleworker"
 		    >
 			<!-- TODO: should highlight the button if there's non-zero idle workers -->
 			<object size="0 0 100% 100%" type="image" sprite="idleWorker" ghost="true" />
 			<action on="Press">findIdleUnit(["Female", "Trade", "FishingBoat", "CitizenSoldier", "Healer"]);</action>
 		    </object>
 		</object>
 	    </object>
 
 	    <!-- ================================  ================================ -->
 	    <!-- Supplemental Details Panel (Left of Selection Details) -->
 	    <!-- ================================  ================================ -->
 	    <object size="50%-304 100%-170 50%-110 100%" name="supplementalSelectionDetails" type="image" sprite="supplementalDetailsPanel" z="20">
 
 		<object name="unitFormationPanel"
 			size="24 12 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="16">
 			    <object name="unitFormationButton[n]" hidden="true" style="iconButton" type="button" size="0 0 36 36" tooltip_style="sessionToolTipBottomBold" z="100">
 				<object name="unitFormationIcon[n]" type="image" ghost="true" size="3 3 33 33"/>
 				<object name="unitFormationSelection[n]" hidden="true" type="image" ghost="true" size="3 3 33 33" sprite="stretched:session/icons/corners.png"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<object name="unitGarrisonPanel"
 			size="24 12 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="12">
 			    <object name="unitGarrisonButton[n]" hidden="true" style="iconButton" type="button" size="0 0 36 36" tooltip_style="sessionToolTipBottomBold" z="100">
 				<object name="unitGarrisonIcon[n]" type="image" ghost="true" size="3 3 33 33"/>
 				<object name="unitGarrisonCount[n]" ghost="true" style="groupIconsText" type="text" size="0 0 100% 100%"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<object name="unitBarterPanel" 
 			size="6 36 100% 100%"
 			hidden="true"
 		>
 		    <object ghost="true" style="resourceText" type="text" size="0 0 100% 20">Exchange resources:</object>
 		    <object size="0 32 100% 78">
 			<repeat count="4">
 			    <object name="unitBarterSellButton[n]" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottomBold">
 				<object name="unitBarterSellIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 				<object name="unitBarterSellUnaffordable[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="colour: 255 0 0 60"/>
 				<object name="unitBarterSellAmount[n]" ghost="true" style="resourceText" type="text" size="0 0 100% 50%"/>
 				<object name="unitBarterSellSelection[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/corners.png"/>
 			    </object>
 			</repeat>
 		    </object>
 		    <object size="0 78 100% 124">
 			<repeat count="4">
 			    <object name="unitBarterBuyButton[n]" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottomBold">
 				<object name="unitBarterBuyIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 				<object name="unitBarterBuyUnaffordable[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="colour: 255 0 0 60"/>
 				<object name="unitBarterBuyAmount[n]" ghost="true" style="resourceText" type="text" size="0 0 100% 50%"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<!-- Stance Selection -->
 		<object name="unitStancePanel"
 			style="TranslucentPanel"
 			size="4 100%-43 100%-4 100%-4"
 			type="text"
 		>
 		    <object size="1 2 100% 100%">
 			<repeat count="5">
 			    <object name="unitStanceButton[n]" hidden="true" style="iconButton" type="button" size="0 0 36 36" tooltip_style="sessionToolTipBottomBold" z="100">
 				<object name="unitStanceIcon[n]" type="image" ghost="true" size="3 3 33 33"/>
 				<object name="unitStanceSelection[n]" hidden="true" type="image" ghost="true" size="3 3 33 33" sprite="stretched:session/icons/corners.png"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 	    </object>
 
 	    <!-- ================================  ================================ -->
 	    <!-- Selection Details Panel (Middle) -->
 	    <!-- ================================  ================================ -->
 	    <object name="selectionDetails"
 		    type="image"
 		    sprite="selectionDetailsPanel"
 		    size="50%-114 100%-205 50%+114 100%"
 		    hidden="false"
 	    >
 		<!-- Unit details for Single Unit -->
 		<object size="50%-112 0 50%+112 100%" name="detailsAreaSingle">
 		    
 		    <!-- Stats Bars -->
 		    <object size= "2 0 100%-2 98" type="image" tooltip_style="sessionToolTip">
 			
 			<object size="0 8 100% 60" type="image" sprite="edgedPanelShader">
 			    <!-- Health bar -->
 			    <object size="88 0 100% 24" name="healthSection">
 				<object size="0 0 100% 16" name="healthLabel" type="text" style="StatsTextLeft" ghost="true">Health:</object>
 				<object size="0 0 100% 16" name="healthStats" type="text" style="StatsTextRight" ghost="true"/>
 				<object size="1 16 100% 23" name="health" type="image">
 				    <object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
 				    <object type="image" sprite="healthBackground" ghost="true"/>
 				    <object type="image" sprite="healthForeground" ghost="true" name="healthBar"/>
 				    <object type="image" sprite="statsBarShaderHorizontal" ghost="true"/>
 				</object>
 			    </object>
 
 			    <!-- Stamina bar -->
 			    <object size="88 28 100% 52" name="staminaSection">
 				<object size="0 0 100% 16" name="staminaLabel" type="text" style="StatsTextLeft" ghost="true">Stamina:</object>
 				<object size="0 0 100% 16" name="staminaStats" type="text" style="StatsTextRight" ghost="true"/>
 				<object size="1 16 100% 23" name="stamina" type="image">
 				    <object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
 				    <object type="image" sprite="staminaBackground" ghost="true"/>
 				    <object type="image" sprite="staminaForeground" ghost="true" name="staminaBar"/>
 				    <object type="image" sprite="statsBarShaderHorizontal" ghost="true"/>
 				</object>
 			    </object>
 
 			    <!-- Resource bar -->
 			    <object size="88 28 100% 52" name="resourceSection">
 				<object size="0 0 100% 16" name="resourceLabel" type="text" style="StatsTextLeft" ghost="true"/>
 				<object size="0 0 100% 16" name="resourceStats" type="text" style="StatsTextRight" ghost="true"/>
 				<object size="1 16 100% 23" name="resources" type="image">
 				    <object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
 				    <object type="image" sprite="resourceBackground" ghost="true"/>
 				    <object type="image" sprite="resourceForeground" ghost="true" name="resourceBar"/>
 				    <object type="image" sprite="statsBarShaderHorizontal" ghost="true"/>
 				</object>
 			    </object>
 			</object>
 			
 			<object size="0 60 100% 96" type="image" sprite="edgedPanelShader">
 			    <!-- Attack and Armor -->
 			    <object size="90 -2 126 34" name="attackAndArmorStats" type="image" sprite="stretched:session/icons/stances/defensive.png" tooltip="Attack and Armor" tooltip_style="sessionToolTip"/>
 
 			    <!-- Resource carrying icon/counter -->
 			    <!-- Used also for number of gatherers/builders -->
 			    <object size="100%-98 -2 100%-28 34" type="text" name="resourceCarryingText" style="CarryingTextRight"/>
 			    <object size="100%-36 -2 100% 34" type="image" name="resourceCarryingIcon" tooltip_style="sessionToolTip"/>
 			</object>
 			
 			<!-- Big unit icon -->
 			<object size="-8 -8 88 88" type="image" name="iconBorder" sprite="iconBorder" tooltip_style="sessionToolTip">
 			    <object size="1 1 100%-1 100%-1" type="image" name="icon" ghost="true"/>
 			
 			    <!-- Experience bar -->
 			    <object size="2 2 6 100%-2" type="image" name="experience" tooltip="Experience" tooltip_style="sessionToolTip">
 				<object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
 				<object type="image" sprite="experienceBackground" ghost="true"/>
 				<object type="image" sprite="experienceForeground" ghost="true" name="experienceBar"/>
 				<object type="image" sprite="statsBarShaderVertical" ghost="true"/>
 			    </object>
 			
 			    <object z="20" size="4 4 20 20" name="rankIcon" type="image" tooltip="Rank" tooltip_style="sessionToolTip"/>
 			</object>
 		    </object>
 		    
 		    <!-- Names (this must come before the attack and armor icon to avoid clipping issues) -->
 		    <object size="2 96 100%-2 100%-36" name="statsArea" type="image" sprite="edgedPanelShader">
 			
 			<!-- These images are used to clip off the top and bottom of the civ icon -->
 			<object z="30" size="0 -5 100% 40" ghost="true" type="image" sprite="remove"/>
 			<object z="30" size="0 100%-5 100% 100%+40" ghost="true" type="image" sprite="remove"/>
 			
 			<object z="30" size="0 2 100% 45" ghost="true">
 			    <!-- Specific Name -->
 			    <object size="0 0 100% 20" name="specific" ghost="true" type="text" style="SpecificNameCentered"/>
 
 			    <!-- Generic Name -->
 			    <object size="0 15 100% 36" name="generic" ghost="true" type="text" style="GenericNameCentered"/>
 			</object>
 			
 			<!-- Player Name and Civ -->
 			<object size="0 40 100% 100%">
 			    <object size="50%-64 50%-64 50%+64 50%+64" name="playerCivIcon" type="image" ghost="true"/>
 			    <object size="0 0 100% 100%" name="playerColorBackground" type="image" sprite="playerColorBackground" ghost="true"/>
 			    <object size="0 0 100% 100%" type="image" sprite="bottomEdgedPanelShader" ghost="true"/>
 			    
 			    <!-- Why is this being automatically ghosted? In the mean time, set ghost to false -->
 			    <object ghost="false" size="0 0 100% 100%-5" name="player" type="text" style="largeCenteredOutlinedText" tooltip_style="sessionToolTip"/>
 			</object>
 		    </object>
 
 		</object>
 
 		<!-- Unit details for Multiple Units -->
 		<object size="50%-112 0 50%+112 100%" name="detailsAreaMultiple">
 
 		    <object name="unitSelectionPanel"
 			    size="20 12 100%-20 100%"
 		    >
 			<object size="0 0 100% 100%">
 			    <repeat count="16">
 				<object name="unitSelectionButton[n]" hidden="true" style="iconButton" type="button" size="0 0 36 36" tooltip_style="sessionToolTipBold" z="100">
 				    <object name="unitSelectionIcon[n]" type="image" ghost="true" size="3 3 33 33"/>
 				    <object name="unitSelectionCount[n]" ghost="true" style="groupIconsText" type="text" size="0 0 100% 100%"/>
 				    <object size="0 100%-3 100% 100%" name="unitSelectionHealth[n]" ghost="true">
 				    </object>
 				</object>
 			    </repeat>
 			</object>
 		    </object>
 
 		    <!-- Total -->
 		    <object size="100%-42 12 100%-8 46" type="image" sprite="groupsIcon">
 			<object size="0 0 100% 100%" type="text" style="largeCenteredOutlinedText" name="numberOfUnits"/>
 		    </object>
 
 		    <!-- Stats Bars -->
 		    <object size= "100%-38 50 100%-18 100%-44" type="image" tooltip_style="sessionToolTip">
 			<!-- Health bar -->
 			<object size="4 0 11 100%" type="image" name="healthMultiple" tooltip="Hitpoints" tooltip_style="sessionToolTip">
 			    <object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
 			    <object type="image" sprite="healthBackground" ghost="true"/>
 			    <object type="image" sprite="healthForeground" ghost="true" name="healthBarMultiple"/>
 			    <object type="image" sprite="statsBarShaderVertical" ghost="true"/>
 			</object>
 
 			<!-- Stamina bar -->
 			<object size="15 0 22 100%" type="image" name="staminaMultiple" tooltip="Stamina" tooltip_style="sessionToolTipBold">
 			    <object type="image" sprite="barBorder" ghost="true" size="-1 -1 100%+1 100%+1"/>
 			    <object type="image" sprite="staminaBackground" ghost="true"/>
 			    <object type="image" sprite="staminaForeground" ghost="true" name="staminaBarMultiple"/>
 			    <object type="image" sprite="statsBarShaderVertical" ghost="true"/>
 			</object>
 		    </object>
 		</object>
 
 		<!-- Unit Commands -->
 		<object name="unitCommandPanel"
 			size="0 100%-36 100% 100%-4"
 			type="image"
 			z="30"
 		>
 		    <object size="0 1 100% 100%">
 			<repeat count="6">
 			    <object name="unitCommandButton[n]" hidden="true" style="iconButton" type="button" size="0 0 32 32" tooltip_style="sessionToolTipBottomBold">
 				<object name="unitCommandIcon[n]" ghost="true" type="image" size="0 0 100% 100%" style="commandIcon"/>
 				<object name="unitCommandCount[n]" ghost="true" style="groupIconsText" type="text" size="0 0 100% 100%"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<!-- shading for unit commands area -->
 		<object z="50" size="4 100%-36 100%-4 100%-4" ghost="true" type="image" sprite="bottomEdgedPanelShader"/>
 
 	    </object> <!-- END OF SELECTION DETAILS -->
 
 	    <!-- ================================  ================================ -->
 	    <!-- Commands Panel (Right of Selection Details) -->
 	    <!-- ================================  ================================ -->
 	    <object name="unitCommands"
 		    type="image"
 		    sprite="unitCommandsPanel"
 		    size="50%+110 100%-170 50%+512 100%"
 		    hidden="false"
 		    z="20"
 	    >
 		<object name="unitConstructionPanel"
 			size="10 12 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="24">
 			    <object name="unitConstructionButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
 				<object name="unitConstructionIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 				<object name="unitConstructionUnaffordable[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="colour: 255 0 0 127"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<object name="unitResearchPanel"
 			size="10 100%-102 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="16">
 			    <object name="unitResearchButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
 				<object name="unitResearchIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 				<object name="unitResearchUnchosenIcon[n]" type="image" hidden="true" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/tech_pair_would_be_unavailable.png"/>
 				<object name="unitResearchUnaffordable[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="colour: 255 0 0 60"/>
 			    </object>
 			</repeat>
 			<repeat count="8">
 			    <object name="unitResearchPair[n]" hidden="true" size="0 0 46 92">
 				<object name="unitResearchPairIcon[n]" type="image" ghost="true" size="8 38 38 54" sprite="stretched:session/icons/vertical_pair.png"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<object name="unitTrainingPanel"
 			size="10 12 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="24">
 			    <object name="unitTrainingButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
 				<object name="unitTrainingIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 				<object name="unitTrainingUnaffordable[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="colour: 255 0 0 127"/>
 				<object name="unitTrainingCount[n]" ghost="true" style="groupIconsText" type="text" z="20"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<object name="unitTradingPanel"
 			size="10 12 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="4">
 			    <object name="unitTradingButton[n]" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
 				<object name="unitTradingIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 				<object name="unitTradingSelection[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/corners.png"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<object name="unitQueuePanel"
 			size="4 -56 100% 0"
 			type="image"
 			sprite="queuePanelShader"
 		>
 		    <object size="-4 -2 52 54" type="image" sprite="stretched:session/icons/production.png" tooltip_style="sessionToolTipBottom" tooltip="Production queue">
 			<object name="queueProgress" ghost="true" style="iconButtonProgress" type="text"/>
 		    </object>
 
 		    <object size="48 6 100% 100%">
 			<repeat count="16">
 			    <object name="unitQueueButton[n]" hidden="true" style="iconButton" type="button" size="0 0 40 40" tooltip_style="sessionToolTipBottom">
 				<object name="unitQueueIcon[n]" ghost="true" type="image" size="3 3 37 37"/>
 				<object name="unitQueueProgressSlider[n]" type="image" sprite="queueProgressSlider" ghost="true" size="3 3 37 37" z="20"/>
 				<object name="unitQueueCount[n]" ghost="true" style="groupIconsText" type="text" z="20"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 		<object name="unitGatePanel"
 			size="10 12 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="8">
 			    <object name="unitGateButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
 				<object name="unitGateIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 				<object name="unitGateSelection[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="stretched:session/icons/corners.png"/>
 				<object name="unitGateUnaffordable[n]" hidden="true" type="image" ghost="true" size="3 3 43 43" sprite="colour: 255 0 0 127"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
     
     <object name="unitPackPanel"
 			size="10 12 100% 100%"
 		>
 		    <object size="0 0 100% 100%">
 			<repeat count="8">
 			    <object name="unitPackButton[n]" hidden="true" style="iconButton" type="button" size="0 0 46 46" tooltip_style="sessionToolTipBottom">
 				<object name="unitPackIcon[n]" type="image" ghost="true" size="3 3 43 43"/>
 			    </object>
 			</repeat>
 		    </object>
 		</object>
 
 	    </object> <!-- END OF UNIT COMMANDS -->
 
 	</object><!-- END OF BOTTOM PANEL -->
 
     </object> <!-- END OF SN OBJECT -->
 
     <!-- ================================  ================================ -->
     <!-- Selection bandbox -->
     <!-- ================================  ================================ -->
     <object name="bandbox" type="image" sprite="bandbox" ghost="true" hidden="true" z="200"/>
 
     <!-- ================================  ================================ -->
     <!-- Network status -->
     <!-- ================================  ================================ -->
     <object name="netStatus" type="text" style="netStatus" z="100" hidden="true">
 	<object type="button"
 		name="disconnectedExitButton"
 		style="StoneButton"
 		size="50%-84 50%+128 50%+84 50%+160"
 		tooltip_style="sessionToolTip"
 	>
 	    <object size="0 0 100% 100%" type="text" style="CenteredButtonText" name="disconnectedExitButtonText" ghost="true">Exit</object>
 	    <action on="Press">leaveGame()</action>
 	</object>
 
     </object>
 
 </objects>
Index: ps/trunk/binaries/data/mods/public/simulation/components/EndGameManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/EndGameManager.js	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/simulation/components/EndGameManager.js	(revision 14418)
@@ -1,99 +1,132 @@
 // Repetition interval (msecs) for checking end game conditions
 var g_ProgressInterval = 1000;
 
 /**
  * System component which regularly checks victory/defeat conditions
  * and if they are satisfied then it marks the player as victorious/defeated.
  */
 function EndGameManager() {}
 
 EndGameManager.prototype.Schema =
 	"<a:component type='system'/><empty/>";
 	
 EndGameManager.prototype.Init = function()
 {
 	// Game type, initialised from the map settings.
 	// One of: "conquest" (default) and "endless"
 	this.gameType = "conquest";
 	
 	// Allied victory means allied players can win if victory conditions are met for each of them
 	// Would be false for a "last man standing" game (when diplomacy is fully implemented)
 	this.alliedVictory = true;
 };
 
 EndGameManager.prototype.SetGameType = function(newGameType)
 {
 	this.gameType = newGameType;
+	Engine.BroadcastMessage(MT_GameTypeChanged, {});
+};
+
+EndGameManager.prototype.CheckGameType = function(type)
+{
+	return this.gameType == type;
+};
+
+EndGameManager.prototype.RegisterWonder = function(entity)
+{
+	if (!this.CheckGameType("wonder"))
+		return;
+
+	var cmpWon = QueryOwnerInterface(entity, IID_Player);
+	cmpWon.SetState("won");
+	
+	var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+	var numPlayers = cmpPlayerManager.GetNumPlayers();
+	for (var i = 1; i < numPlayers; i++)
+	{
+		var playerEntityId = cmpPlayerManager.GetPlayerByID(i);
+		var cmpPlayer = Engine.QueryInterface(playerEntityId, IID_Player);
+		if (cmpPlayer.GetState() != "active")
+			continue;
+		if (this.alliedVictory && cmpPlayer.IsMutualAlly(cmpWon.GetPlayerID()))
+			cmpPlayer.SetState("won")
+		else
+			Engine.PostMessage(playerEntityId, MT_PlayerDefeated, { "playerId": i } );
+	}
+
+	// Reveal the map to all players
+	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+	cmpRangeManager.SetLosRevealAll(-1, true);
 };
 
 EndGameManager.prototype.SetAlliedVictory = function(flag)
 {
 	this.alliedVictory = flag;
 };
 
 /*
  * Check players the next turn. Avoids problems in Atlas, with promoting entities etc
  */
 EndGameManager.prototype.CheckPlayers = function()
 {
 	if (this.timeout)
 		return;
 	// wait a turn for actually checking the players
 	var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	this.timeout = cmpTimer.SetTimeout(this.entity, IID_EndGameManager, "CheckPlayersNow", 100, null);	
 };
 
 /*
  * Check players immediately. Might cause problems with converting/promoting entities.
  */
 EndGameManager.prototype.CheckPlayersNow = function()
 {
 	if (this.timeout)
 		this.timeout = null;
 	if (this.gameType == "endless")
 		return; 
 
 	// for all other game types, defeat that player
 	var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	
 	// Ignore gaia
 	var numPlayers = cmpPlayerManager.GetNumPlayers();
 	var cmpPlayers = [];
 	
 	var allies = [];
 	var onlyAlliesLeft = true;
 	// If the player is currently active but needs to be defeated,
 	// mark that player as defeated
 	// cache the cmpPlayer instances of the other players and search the allies
 	for (var i = 1; i < numPlayers; i++)
 	{
 		// cmpPlayer should always exist for the player ids from 1 to numplayers
 		// so no tests on the existance of cmpPlayer are needed
 		var playerEntityId = cmpPlayerManager.GetPlayerByID(i);
 		cmpPlayers[i] = Engine.QueryInterface(playerEntityId, IID_Player);
 		if (cmpPlayers[i].GetState() != "active") 
 			continue;
 		if (cmpPlayers[i].GetConquestCriticalEntitiesCount() == 0)
 			Engine.PostMessage(playerEntityId, MT_PlayerDefeated, { "playerId": i } );
 		else
 		{
 			if (!allies.length || cmpPlayers[allies[0]].IsMutualAlly(i))
 				allies.push(i);
 			else
 				onlyAlliesLeft = false;
 		}
 	}
 
 	// check if there are winners, or the game needs to continue
 	if (!allies.length || !onlyAlliesLeft || !(this.alliedVictory || allies.length == 1))
 		return; 
 
 	for each (var p in allies)
 		cmpPlayers[p].SetState("won");
 
 	// Reveal the map to all players
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	cmpRangeManager.SetLosRevealAll(-1, true);
 };
 
 Engine.RegisterComponentType(IID_EndGameManager, "EndGameManager", EndGameManager);
Index: ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/simulation/components/GuiInterface.js	(revision 14418)
@@ -1,1921 +1,1973 @@
 function GuiInterface() {}
 
 GuiInterface.prototype.Schema =
 	"<a:component type='system'/><empty/>";
 
 GuiInterface.prototype.Serialize = function()
 {
 	// This component isn't network-synchronised so we mustn't serialise
 	// its non-deterministic data. Instead just return an empty object.
 	return {};
 };
 
 GuiInterface.prototype.Deserialize = function(obj)
 {
 	this.Init();
 };
 
 GuiInterface.prototype.Init = function()
 {
 	this.placementEntity = undefined; // = undefined or [templateName, entityID]
 	this.placementWallEntities = undefined;
 	this.placementWallLastAngle = 0;
 	this.notifications = [];
 	this.renamedEntities = [];
+	this.timeNotificationID = 1;
+	this.timeNotifications = [];
 };
 
 /*
  * All of the functions defined below are called via Engine.GuiInterfaceCall(name, arg)
  * from GUI scripts, and executed here with arguments (player, arg).
  * 
  * CAUTION: The input to the functions in this module is not network-synchronised, so it 
  * mustn't affect the simulation state (i.e. the data that is serialised and can affect 
  * the behaviour of the rest of the simulation) else it'll cause out-of-sync errors.
  */
 
 /**
  * Returns global information about the current game state.
  * This is used by the GUI and also by AI scripts.
  */
 GuiInterface.prototype.GetSimulationState = function(player)
 {
 	var ret = {
 		"players": []
 	};
 	
 	var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	var n = cmpPlayerMan.GetNumPlayers();
 	for (var i = 0; i < n; ++i)
 	{
 		var playerEnt = cmpPlayerMan.GetPlayerByID(i);
 		var cmpPlayerEntityLimits = Engine.QueryInterface(playerEnt, IID_EntityLimits);
 		var cmpPlayer = Engine.QueryInterface(playerEnt, IID_Player);
 		
 		// Work out what phase we are in
 		var cmpTechnologyManager = Engine.QueryInterface(playerEnt, IID_TechnologyManager);
 		var phase = "";
 		if (cmpTechnologyManager.IsTechnologyResearched("phase_city"))
 			phase = "city";
 		else if (cmpTechnologyManager.IsTechnologyResearched("phase_town"))
 			phase = "town";
 		else if (cmpTechnologyManager.IsTechnologyResearched("phase_village"))
 			phase = "village";
 		
 		// store player ally/neutral/enemy data as arrays
 		var allies = [];
 		var mutualAllies = [];
 		var neutrals = [];
 		var enemies = [];
 		for (var j = 0; j < n; ++j)
 		{
 			allies[j] = cmpPlayer.IsAlly(j);
 			mutualAllies[j] = cmpPlayer.IsMutualAlly(j);
 			neutrals[j] = cmpPlayer.IsNeutral(j);
 			enemies[j] = cmpPlayer.IsEnemy(j);
 		}
 		var playerData = {
 			"name": cmpPlayer.GetName(),
 			"civ": cmpPlayer.GetCiv(),
 			"colour": cmpPlayer.GetColour(),
 			"popCount": cmpPlayer.GetPopulationCount(),
 			"popLimit": cmpPlayer.GetPopulationLimit(),
 			"popMax": cmpPlayer.GetMaxPopulation(),
 			"heroes": cmpPlayer.GetHeroes(),
 			"resourceCounts": cmpPlayer.GetResourceCounts(),
 			"trainingBlocked": cmpPlayer.IsTrainingBlocked(),
 			"state": cmpPlayer.GetState(),
 			"team": cmpPlayer.GetTeam(),
 			"teamsLocked": cmpPlayer.GetLockTeams(),
 			"cheatsEnabled": cmpPlayer.GetCheatsEnabled(),
 			"phase": phase,
 			"isAlly": allies,
 			"isMutualAlly": mutualAllies,
 			"isNeutral": neutrals,
 			"isEnemy": enemies,
 			"entityLimits": cmpPlayerEntityLimits.GetLimits(),
 			"entityCounts": cmpPlayerEntityLimits.GetCounts(),
 			"entityLimitChangers": cmpPlayerEntityLimits.GetLimitChangers(),
 			"techModifications": cmpTechnologyManager.GetTechModifications(),
 			"researchQueued": cmpTechnologyManager.GetQueuedResearch(),
 			"researchStarted": cmpTechnologyManager.GetStartedResearch(),
 			"researchedTechs": cmpTechnologyManager.GetResearchedTechs(),
 			"classCounts": cmpTechnologyManager.GetClassCounts(),
 			"typeCountsByClass": cmpTechnologyManager.GetTypeCountsByClass()
 		};
 		ret.players.push(playerData);
 	}
 
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (cmpRangeManager)
 	{
 		ret.circularMap = cmpRangeManager.GetLosCircular();
 	}
 	
 	// Add timeElapsed
 	var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	ret.timeElapsed = cmpTimer.GetTime();
 
 	return ret;
 };
 
 GuiInterface.prototype.GetExtendedSimulationState = function(player)
 {
 	// Get basic simulation info
 	var ret = this.GetSimulationState();
 
 	// Add statistics to each player
 	var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	var n = cmpPlayerMan.GetNumPlayers();
 	for (var i = 0; i < n; ++i)
 	{
 		var playerEnt = cmpPlayerMan.GetPlayerByID(i);
 		var cmpPlayerStatisticsTracker = Engine.QueryInterface(playerEnt, IID_StatisticsTracker);
 		ret.players[i].statistics = cmpPlayerStatisticsTracker.GetStatistics();
 	}
 
 	return ret;
 };
 
 GuiInterface.prototype.GetRenamedEntities = function(player)
 {
 	return this.renamedEntities;
 };
 
 GuiInterface.prototype.ClearRenamedEntities = function(player)
 {
 	this.renamedEntities = [];
 };
 
 /**
  * Get common entity info, often used in the gui
  */
 GuiInterface.prototype.GetEntityState = function(player, ent)
 {
 	var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 
 	// All units must have a template; if not then it's a nonexistent entity id
 	var template = cmpTemplateManager.GetCurrentTemplateName(ent);
 	if (!template)
 		return null;
 
 	var ret = {
 		"id": ent,
 		"template": template
 	};
 
 	var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 	if (cmpIdentity)
 	{
 		ret.identity = {
 			"rank": cmpIdentity.GetRank(),
 			"classes": cmpIdentity.GetClassesList(),
 			"selectionGroupName": cmpIdentity.GetSelectionGroupName()
 		};
 	}
 	
 	var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 	if (cmpPosition && cmpPosition.IsInWorld())
 	{
 		ret.position = cmpPosition.GetPosition();
 		ret.rotation = cmpPosition.GetRotation();
 	}
 
 	var cmpHealth = Engine.QueryInterface(ent, IID_Health);
 	if (cmpHealth)
 	{
 		ret.hitpoints = Math.ceil(cmpHealth.GetHitpoints());
 		ret.maxHitpoints = cmpHealth.GetMaxHitpoints();
 		ret.needsRepair = cmpHealth.IsRepairable() && (cmpHealth.GetHitpoints() < cmpHealth.GetMaxHitpoints());
 		ret.needsHeal = !cmpHealth.IsUnhealable();
 	}
 
 	var cmpBuilder = Engine.QueryInterface(ent, IID_Builder);
 	if (cmpBuilder)
 	{
 		ret.buildEntities = cmpBuilder.GetEntitiesList();
 	}
 
 	var cmpPack = Engine.QueryInterface(ent, IID_Pack);
 	if (cmpPack)
 	{
 		ret.pack = {
 			"packed": cmpPack.IsPacked(),
 			"progress": cmpPack.GetProgress(),
 		};
 	}
 
 	var cmpProductionQueue = Engine.QueryInterface(ent, IID_ProductionQueue);
 	if (cmpProductionQueue)
 	{
 		ret.production = {
 			"entities": cmpProductionQueue.GetEntitiesList(),
 			"technologies": cmpProductionQueue.GetTechnologiesList(),
 			"queue": cmpProductionQueue.GetQueue(),
 		};
 	}
 
 	var cmpTrader = Engine.QueryInterface(ent, IID_Trader);
 	if (cmpTrader)
 	{
 		ret.trader = {
 			"goods": cmpTrader.GetGoods(),
 			"requiredGoods": cmpTrader.GetRequiredGoods()
 		};
 	}
 
 	var cmpFoundation = Engine.QueryInterface(ent, IID_Foundation);
 	if (cmpFoundation)
 	{
 		ret.foundation = {
 			"progress": cmpFoundation.GetBuildPercentage(),
 			"numBuilders": cmpFoundation.GetNumBuilders()
 		};
 	}
 
 	var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 	if (cmpOwnership)
 	{
 		ret.player = cmpOwnership.GetOwner();
 	}
 
 	var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 	if (cmpRallyPoint)
 	{
 		ret.rallyPoint = {'position': cmpRallyPoint.GetPositions()[0]}; // undefined or {x,z} object
 	}
 
 	var cmpGarrisonHolder = Engine.QueryInterface(ent, IID_GarrisonHolder);
 	if (cmpGarrisonHolder)
 	{
 		ret.garrisonHolder = {
 			"entities": cmpGarrisonHolder.GetEntities(),
 			"allowedClasses": cmpGarrisonHolder.GetAllowedClassesList(),
 			"capacity": cmpGarrisonHolder.GetCapacity(),
 			"garrisonedEntitiesCount": cmpGarrisonHolder.GetGarrisonedEntitiesCount()
 		};
 	}
 	
 	var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 	if (cmpUnitAI)
 	{
 		ret.unitAI = {
 			"state": cmpUnitAI.GetCurrentState(),
 			"orders": cmpUnitAI.GetOrders(),
 			"hasWorkOrders": cmpUnitAI.HasWorkOrders(),
 			"canGuard": cmpUnitAI.CanGuard(),
 			"isGuarding": cmpUnitAI.IsGuardOf(),
 		};
 		// Add some information needed for ungarrisoning
 		if (cmpUnitAI.isGarrisoned && ret.player !== undefined)
 			ret.template = "p" + ret.player + "&" + ret.template;
 	}
 
 	var cmpGuard = Engine.QueryInterface(ent, IID_Guard);
 	if (cmpGuard)
 	{
 		ret.guard = {
 			"entities": cmpGuard.GetEntities(),
 		};
 	}
 
 	var cmpGate = Engine.QueryInterface(ent, IID_Gate);
 	if (cmpGate)
 	{
 		ret.gate = {
 			"locked": cmpGate.IsLocked(),
 		};
 	}
 
 	var cmpAlertRaiser = Engine.QueryInterface(ent, IID_AlertRaiser);
 	if(cmpAlertRaiser)
 	{
 		ret.alertRaiser = {
 			"level": cmpAlertRaiser.GetLevel(),
 			"canIncreaseLevel": cmpAlertRaiser.CanIncreaseLevel(),
 			"hasRaisedAlert": cmpAlertRaiser.HasRaisedAlert(),
 		};
 	}
 
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	ret.visibility = cmpRangeManager.GetLosVisibility(ent, player, false);
 
 	return ret;
 };
 
 /**
  * Get additionnal entity info, rarely used in the gui
  */
 GuiInterface.prototype.GetExtendedEntityState = function(player, ent)
 {
 	var ret = {};
 
 	var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 
 	var cmpAttack = Engine.QueryInterface(ent, IID_Attack);
 	if (cmpAttack)
 	{
 		var type = cmpAttack.GetBestAttack(); // TODO: how should we decide which attack to show? show all?
 		ret.attack = cmpAttack.GetAttackStrengths(type);
 		var range = cmpAttack.GetRange(type);
 		ret.attack.type = type;
 		ret.attack.minRange = range.min;
 		ret.attack.maxRange = range.max;
 		if (type == "Ranged")
 		{
 			ret.attack.elevationBonus = range.elevationBonus;
 			var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 			var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 			var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 			if (cmpUnitAI && cmpPosition && cmpPosition.IsInWorld())
 			{
 				// For units, take the rage in front of it, no spread. So angle = 0
 				ret.attack.elevationAdaptedRange = cmpRangeManager.GetElevationAdaptedRange(cmpPosition.GetPosition(), cmpPosition.GetRotation(), range.max, range.elevationBonus, 0);
 			}
 			else if(cmpPosition && cmpPosition.IsInWorld())
 			{
 				// For buildings, take the average elevation around it. So angle = 2*pi
 				ret.attack.elevationAdaptedRange = cmpRangeManager.GetElevationAdaptedRange(cmpPosition.GetPosition(), cmpPosition.GetRotation(), range.max, range.elevationBonus, 2*Math.PI);
 			}
 			else
 			{
 				// not in world, set a default?
 				ret.attack.elevationAdaptedRange = ret.attack.maxRange;
 			}
 			
 		}
 		else
 		{
 			// not a ranged attack, set some defaults
 			ret.attack.elevationBonus = 0;
 			ret.attack.elevationAdaptedRange = ret.attack.maxRange;
 		}
 	}
 
 	var cmpArmour = Engine.QueryInterface(ent, IID_DamageReceiver);
 	if (cmpArmour)
 	{
 		ret.armour = cmpArmour.GetArmourStrengths();
 	}
 
 	var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
 	if (cmpObstruction)
 	{
 		ret.obstruction = {
 			"controlGroup": cmpObstruction.GetControlGroup(),
 			"controlGroup2": cmpObstruction.GetControlGroup2(),
 		};
 	}
 
 	var cmpResourceSupply = Engine.QueryInterface(ent, IID_ResourceSupply);
 	if (cmpResourceSupply)
 	{
 		ret.resourceSupply = {
 			"isInfinite": cmpResourceSupply.IsInfinite(),
 			"max": cmpResourceSupply.GetMaxAmount(),
 			"amount": cmpResourceSupply.GetCurrentAmount(),
 			"type": cmpResourceSupply.GetType(),
 			"killBeforeGather": cmpResourceSupply.GetKillBeforeGather(),
 			"maxGatherers": cmpResourceSupply.GetMaxGatherers(),
 			"gatherers": cmpResourceSupply.GetGatherers()
 		};
 	}
 
 	var cmpResourceGatherer = Engine.QueryInterface(ent, IID_ResourceGatherer);
 	if (cmpResourceGatherer)
 	{
 		ret.resourceGatherRates = cmpResourceGatherer.GetGatherRates();
 		ret.resourceCarrying = cmpResourceGatherer.GetCarryingStatus();
 	}
 	
 	var cmpResourceDropsite = Engine.QueryInterface(ent, IID_ResourceDropsite);
 	if (cmpResourceDropsite)
 	{
 		ret.resourceDropsite = {
 			"types": cmpResourceDropsite.GetTypes()
 		};
 	}
 	
 	var cmpPromotion = Engine.QueryInterface(ent, IID_Promotion);
 	if (cmpPromotion)
 	{
 		ret.promotion = {
 			"curr": cmpPromotion.GetCurrentXp(),
 			"req": cmpPromotion.GetRequiredXp()
 		};
 	}	
 
 	var cmpFoundation = Engine.QueryInterface(ent, IID_Foundation);
 	if (!cmpFoundation && cmpIdentity && cmpIdentity.HasClass("BarterMarket"))
 	{
 		var cmpBarter = Engine.QueryInterface(SYSTEM_ENTITY, IID_Barter);
 		ret.barterMarket = { "prices": cmpBarter.GetPrices() };
 	}
 
 	var cmpHeal = Engine.QueryInterface(ent, IID_Heal);
 	if (cmpHeal)
 	{
 		ret.healer = { 
 			"unhealableClasses": cmpHeal.GetUnhealableClasses(),
 			"healableClasses": cmpHeal.GetHealableClasses(),
 		};
 	}
 
 	return ret;
 };
 
 GuiInterface.prototype.GetAverageRangeForBuildings = function(player, cmd)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 	var rot = {x:0, y:0, z:0};
 	var pos = {x:cmd.x,z:cmd.z};
 	pos.y = cmpTerrain.GetGroundLevel(cmd.x, cmd.z);
 	var elevationBonus = cmd.elevationBonus || 0;
 	var range = cmd.range;
 
 	return cmpRangeManager.GetElevationAdaptedRange(pos, rot, range, elevationBonus, 2*Math.PI);
 };
 
 GuiInterface.prototype.GetTemplateData = function(player, extendedName)
 {
 	var name = extendedName;
 	// Special case for garrisoned units which have a extended template
 	if (extendedName.indexOf("&") != -1)
 		name = extendedName.slice(extendedName.indexOf("&")+1);
 
 	var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	var template = cmpTemplateManager.GetTemplate(name);
 
 	if (!template)
 		return null;
 
 	var ret = {};
 
 	if (template.Armour)
 	{
 		ret.armour = {
 			"hack": ApplyValueModificationsToTemplate("Armour/Hack", +template.Armour.Hack, player, template),
 			"pierce": ApplyValueModificationsToTemplate("Armour/Pierce", +template.Armour.Hack, player, template),
 			"crush": ApplyValueModificationsToTemplate("Armour/Crush", +template.Armour.Hack, player, template),
 		};
 	}
 	
 	if (template.Attack)
 	{
 		ret.attack = {};
 		for (var type in template.Attack)
 		{
 			ret.attack[type] = {
 				"hack": ApplyValueModificationsToTemplate("Attack/"+type+"/Hack", +(template.Attack[type].Hack || 0), player, template),
 				"pierce": ApplyValueModificationsToTemplate("Attack/"+type+"/Pierce", +(template.Attack[type].Pierce || 0), player, template),
 				"crush": ApplyValueModificationsToTemplate("Attack/"+type+"/Crush", +(template.Attack[type].Crush || 0), player, template),
 				"minRange": ApplyValueModificationsToTemplate("Attack/"+type+"/MinRange", +(template.Attack[type].MinRange || 0), player, template),
 				"maxRange": ApplyValueModificationsToTemplate("Attack/"+type+"/MaxRange", +template.Attack[type].MaxRange, player, template),
 				"elevationBonus": ApplyValueModificationsToTemplate("Attack/"+type+"/ElevationBonus", +(template.Attack[type].ElevationBonus || 0), player, template),
 			};
 		}
 	}
 	
 	if (template.BuildRestrictions)
 	{
 		// required properties
 		ret.buildRestrictions = {
 			"placementType": template.BuildRestrictions.PlacementType,
 			"territory": template.BuildRestrictions.Territory,
 			"category": template.BuildRestrictions.Category,
 		};
 		
 		// optional properties
 		if (template.BuildRestrictions.Distance)
 		{
 			ret.buildRestrictions.distance = {
 				"fromCategory": template.BuildRestrictions.Distance.FromCategory,
 			};
 			if (template.BuildRestrictions.Distance.MinDistance) ret.buildRestrictions.distance.min = +template.BuildRestrictions.Distance.MinDistance;
 			if (template.BuildRestrictions.Distance.MaxDistance) ret.buildRestrictions.distance.max = +template.BuildRestrictions.Distance.MaxDistance;
 		}
 	}
 
 	if (template.TrainingRestrictions)
 	{
 		ret.trainingRestrictions = {
 			"category": template.TrainingRestrictions.Category,
 		};
 	}
 
 	if (template.Cost)
 	{
 		ret.cost = {};
 		if (template.Cost.Resources.food) ret.cost.food = ApplyValueModificationsToTemplate("Cost/Resources/food", +template.Cost.Resources.food, player, template);
 		if (template.Cost.Resources.wood) ret.cost.wood = ApplyValueModificationsToTemplate("Cost/Resources/wood", +template.Cost.Resources.wood, player, template);
 		if (template.Cost.Resources.stone) ret.cost.stone = ApplyValueModificationsToTemplate("Cost/Resources/stone", +template.Cost.Resources.stone, player, template);
 		if (template.Cost.Resources.metal) ret.cost.metal = ApplyValueModificationsToTemplate("Cost/Resources/metal", +template.Cost.Resources.metal, player, template);
 		if (template.Cost.Population) ret.cost.population = ApplyValueModificationsToTemplate("Cost/Population", +template.Cost.Population, player, template);
 		if (template.Cost.PopulationBonus) ret.cost.populationBonus = ApplyValueModificationsToTemplate("Cost/PopulationBonus", +template.Cost.PopulationBonus, player, template);
 		if (template.Cost.BuildTime) ret.cost.time = ApplyValueModificationsToTemplate("Cost/BuildTime", +template.Cost.BuildTime, player, template);
 	}
 	
 	if (template.Footprint)
 	{
 		ret.footprint = {"height": template.Footprint.Height};
 		
 		if (template.Footprint.Square)
 			ret.footprint.square = {"width": +template.Footprint.Square["@width"], "depth": +template.Footprint.Square["@depth"]};
 		else if (template.Footprint.Circle)
 			ret.footprint.circle = {"radius": +template.Footprint.Circle["@radius"]};
 		else
 			warn("[GetTemplateData] Unrecognized Footprint type");
 	}
 	
 	if (template.Obstruction)
 	{
 		ret.obstruction = {
 			"active": ("" + template.Obstruction.Active == "true"),
 			"blockMovement": ("" + template.Obstruction.BlockMovement == "true"),
 			"blockPathfinding": ("" + template.Obstruction.BlockPathfinding == "true"),
 			"blockFoundation": ("" + template.Obstruction.BlockFoundation == "true"),
 			"blockConstruction": ("" + template.Obstruction.BlockConstruction == "true"),
 			"disableBlockMovement": ("" + template.Obstruction.DisableBlockMovement == "true"),
 			"disableBlockPathfinding": ("" + template.Obstruction.DisableBlockPathfinding == "true"),
 			"shape": {}
 		};
 		
 		if (template.Obstruction.Static)
 		{
 			ret.obstruction.shape.type = "static";
 			ret.obstruction.shape.width = +template.Obstruction.Static["@width"];
 			ret.obstruction.shape.depth = +template.Obstruction.Static["@depth"];
 		}
 		else if (template.Obstruction.Unit)
 		{
 			ret.obstruction.shape.type = "unit";
 			ret.obstruction.shape.radius = +template.Obstruction.Unit["@radius"];
 		}
 		else
 		{
 			ret.obstruction.shape.type = "cluster";
 		}
 	}
 
 	if (template.Pack)
 	{
 		ret.pack = {
 			"state": template.Pack.State,
 			"time": ApplyValueModificationsToTemplate("Pack/Time", +template.Pack.Time, player, template),
 		};
 	}
 
 	if (template.Health)
 	{
 		ret.health = Math.round(ApplyValueModificationsToTemplate("Health/Max", +template.Health.Max, player, template));
 	}
 
 	if (template.Identity)
 	{
 		ret.selectionGroupName = template.Identity.SelectionGroupName;
 		ret.name = {
 			"specific": (template.Identity.SpecificName || template.Identity.GenericName),
 			"generic": template.Identity.GenericName
 		};
 		ret.icon = template.Identity.Icon;
 		ret.tooltip =  template.Identity.Tooltip;
 		ret.requiredTechnology = template.Identity.RequiredTechnology;
 		ret.identityClassesString = GetTemplateIdentityClassesString(template);
 	}
 
 	if (template.UnitMotion)
 	{
 		ret.speed = {
 			"walk": ApplyValueModificationsToTemplate("UnitMotion/WalkSpeed", +template.UnitMotion.WalkSpeed, player, template),
 		};
 		if (template.UnitMotion.Run) ret.speed.run = ApplyValueModificationsToTemplate("UnitMotion/Run/Speed", +template.UnitMotion.Run.Speed, player, template);
 	}
 
 	if (template.Trader)
 		ret.trader = template.Trader;
 
 	if (template.WallSet)
 	{
 		ret.wallSet = {
 			"templates": {
 				"tower": template.WallSet.Templates.Tower,
 				"gate": template.WallSet.Templates.Gate,
 				"long": template.WallSet.Templates.WallLong,
 				"medium": template.WallSet.Templates.WallMedium,
 				"short": template.WallSet.Templates.WallShort,
 			},
 			"maxTowerOverlap": +template.WallSet.MaxTowerOverlap,
 			"minTowerOverlap": +template.WallSet.MinTowerOverlap,
 		};
 	}
 	
 	if (template.WallPiece)
 	{
 		ret.wallPiece = {"length": +template.WallPiece.Length};
 	}
 
 	return ret;
 };
 
 GuiInterface.prototype.GetTechnologyData = function(player, name)
 {
 	var cmpTechTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TechnologyTemplateManager);
 	var template = cmpTechTempMan.GetTemplate(name);
 	
 	if (!template)
 	{
 		warn("Tried to get data for invalid technology: " + name);
 		return null;
 	}
 	
 	var ret = {};
 	
 	// Get specific name for this civ or else the generic specific name 
 	var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
 	var specific = undefined;
 	if (template.specificName)
 	{
 		if (template.specificName[cmpPlayer.GetCiv()])
 			specific = template.specificName[cmpPlayer.GetCiv()];
 		else
 			specific = template.specificName['generic'];
 	}
 	
 	ret.name = {
 		"specific": specific,
 		"generic": template.genericName,
 	};
 	ret.icon = "technologies/" + template.icon;
 	ret.cost = {
 		"food": template.cost ? (+template.cost.food) : 0,
 		"wood": template.cost ? (+template.cost.wood) : 0,
 		"metal": template.cost ? (+template.cost.metal) : 0,
 		"stone": template.cost ? (+template.cost.stone) : 0,
 		"time": template.researchTime ? (+template.researchTime) : 0,
 	}
 	ret.tooltip = template.tooltip;
 	
 	if (template.requirementsTooltip)
 		ret.requirementsTooltip = template.requirementsTooltip;
 	else
 		ret.requirementsTooltip = "";
 	
 	ret.description = template.description;
 	
 	return ret;
 };
 
 GuiInterface.prototype.IsTechnologyResearched = function(player, tech)
 {
 	var cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
 	
 	if (!cmpTechnologyManager)
 		return false;
 	
 	return cmpTechnologyManager.IsTechnologyResearched(tech);
 };
 
 // Checks whether the requirements for this technology have been met
 GuiInterface.prototype.CheckTechnologyRequirements = function(player, tech)
 {
 	var cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
 	
 	if (!cmpTechnologyManager)
 		return false;
 	
 	return cmpTechnologyManager.CanResearch(tech);
 };
 
 // Returns technologies that are being actively researched, along with
 // which entity is researching them and how far along the research is.
 GuiInterface.prototype.GetStartedResearch = function(player)
 {
 	var cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
 	if (!cmpTechnologyManager)
 		return false;
 
 	var ret = {};
 	for (var tech in cmpTechnologyManager.GetTechsStarted())
 	{
 		ret[tech] = { "researcher": cmpTechnologyManager.GetResearcher(tech) };
 		var cmpProductionQueue = Engine.QueryInterface(ret[tech].researcher, IID_ProductionQueue);
 		if (cmpProductionQueue)
 			ret[tech].progress = cmpProductionQueue.GetQueue()[0].progress;
 		else
 			ret[tech].progress = 0;
 	}
 	return ret;
 }
 
 // Returns the battle state of the player.
 GuiInterface.prototype.GetBattleState = function(player)
 {
 	var cmpBattleDetection = QueryPlayerIDInterface(player, IID_BattleDetection);
 	return cmpBattleDetection.GetState();
 };
 
 // Returns a list of ongoing attacks against the player.
 GuiInterface.prototype.GetIncomingAttacks = function(player)
 {
 	var cmpAttackDetection = QueryPlayerIDInterface(player, IID_AttackDetection);
 	return cmpAttackDetection.GetIncomingAttacks();
 };
 
 // Used to show a red square over GUI elements you can't yet afford.
 GuiInterface.prototype.GetNeededResources = function(player, amounts)
 {
 	var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
 	return cmpPlayer.GetNeededResources(amounts);
 };
 
+GuiInterface.prototype.AddTimeNotification = function(notification)
+{
+	var time = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
+	notification.endTime = notification.time + time;
+	notification.id = ++this.timeNotificationID;
+	this.timeNotifications.push(notification);
+	this.timeNotifications.sort(function (n1, n2){return n2.endTime - n1.endTime});
+	return this.timeNotificationID;
+};
+
+GuiInterface.prototype.DeleteTimeNotification = function(notificationID)
+{
+	for (var i in this.timeNotifications)
+	{
+		if (this.timeNotifications[i].id == notificationID)
+		{
+			this.timeNotifications.splice(i);
+			return;
+		}
+	}
+};
+
+GuiInterface.prototype.GetTimeNotificationText = function(playerID)
+{	
+	var formatTime = function(time)
+		{
+			// add 1000 ms to get ceiled instead of floored millisecons
+			// displaying 00:00 for a full second isn't nice
+			time += 1000;
+			var hours   = Math.floor(time / 1000 / 60 / 60);
+			var minutes = Math.floor(time / 1000 / 60) % 60;
+			var seconds = Math.floor(time / 1000) % 60;
+			return (hours ? hours + ':' : "") + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds);
+		};
+	var time = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
+	var text = "";
+	for each (var n in this.timeNotifications)
+	{
+		if (time >= n.endTime)
+		{
+			// delete the notification and start over 
+			this.DeleteTimeNotification(n.id);
+			return this.GetTimeNotificationText(playerID);
+		}
+		if (n.players.indexOf(playerID) >= 0)
+			text += n.message.replace("%T",formatTime(n.endTime - time))+"\n";
+	}
+	return text;
+};
 
 GuiInterface.prototype.PushNotification = function(notification)
 {
 	this.notifications.push(notification);
 };
 
 GuiInterface.prototype.GetNextNotification = function()
 {
 	if (this.notifications.length)
 		return this.notifications.pop();
 	else
 		return "";
 };
 
 GuiInterface.prototype.GetAvailableFormations = function(player, data)
 {
 	var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	var cmpPlayer = Engine.QueryInterface(cmpPlayerMan.GetPlayerByID(player), IID_Player);
 	return cmpPlayer.GetFormations();
 };
 
 GuiInterface.prototype.GetFormationRequirements = function(player, data)
 {
 	return GetFormationRequirements(data.formationName);
 };
 
 GuiInterface.prototype.CanMoveEntsIntoFormation = function(player, data)
 {
 	return CanMoveEntsIntoFormation(data.ents, data.formationName);
 };
 
 GuiInterface.prototype.IsFormationSelected = function(player, data)
 {
 	for each (var ent in data.ents)
 	{
 		var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		if (cmpUnitAI)
 		{
 			// GetLastFormationName is named in a strange way as it (also) is
 			// the value of the current formation (see Formation.js LoadFormation)
 			if (cmpUnitAI.GetLastFormationName() == data.formationName)
 				return true;
 		}
 	}
 	return false;
 };
 
 GuiInterface.prototype.IsStanceSelected = function(player, data)
 {
 	for each (var ent in data.ents)
 	{
 		var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 		if (cmpUnitAI)
 		{
 			if (cmpUnitAI.GetStanceName() == data.stance)
 				return true;
 		}
 	}
 	return false;
 };
 
 GuiInterface.prototype.SetSelectionHighlight = function(player, cmd)
 {
 	var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	var playerColours = {}; // cache of owner -> colour map
 	
 	for each (var ent in cmd.entities)
 	{
 		var cmpSelectable = Engine.QueryInterface(ent, IID_Selectable);
 		if (!cmpSelectable)
 			continue;
 
 		// Find the entity's owner's colour:
 		var owner = -1;
 		var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (cmpOwnership)
 			owner = cmpOwnership.GetOwner();
 
 		var colour = playerColours[owner];
 		if (!colour)
 		{
 			colour = {"r":1, "g":1, "b":1};
 			var cmpPlayer = Engine.QueryInterface(cmpPlayerMan.GetPlayerByID(owner), IID_Player);
 			if (cmpPlayer)
 				colour = cmpPlayer.GetColour();
 			playerColours[owner] = colour;
 		}
 
 		cmpSelectable.SetSelectionHighlight({"r":colour.r, "g":colour.g, "b":colour.b, "a":cmd.alpha}, cmd.selected);
 	}
 };
 
 GuiInterface.prototype.SetStatusBars = function(player, cmd)
 {
 	for each (var ent in cmd.entities)
 	{
 		var cmpStatusBars = Engine.QueryInterface(ent, IID_StatusBars);
 		if (cmpStatusBars)
 			cmpStatusBars.SetEnabled(cmd.enabled);
 	}
 };
 
 GuiInterface.prototype.GetPlayerEntities = function(player)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return cmpRangeManager.GetEntitiesByPlayer(player);
 };
 
 /**
  * Displays the rally points of a given list of entities (carried in cmd.entities).
  * 
  * The 'cmd' object may carry its own x/z coordinate pair indicating the location where the rally point should 
  * be rendered, in order to support instantaneously rendering a rally point marker at a specified location 
  * instead of incurring a delay while PostNetworkCommand processes the set-rallypoint command (see input.js).
  * If cmd doesn't carry a custom location, then the position to render the marker at will be read from the 
  * RallyPoint component.
  */
 GuiInterface.prototype.DisplayRallyPoint = function(player, cmd)
 {
 	var cmpPlayerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
 	var cmpPlayer = Engine.QueryInterface(cmpPlayerMan.GetPlayerByID(player), IID_Player);
 
 	// If there are some rally points already displayed, first hide them
 	for each (var ent in this.entsRallyPointsDisplayed)
 	{
 		var cmpRallyPointRenderer = Engine.QueryInterface(ent, IID_RallyPointRenderer);
 		if (cmpRallyPointRenderer)
 			cmpRallyPointRenderer.SetDisplayed(false);
 	}
 	
 	this.entsRallyPointsDisplayed = [];
 	
 	// Show the rally points for the passed entities
 	for each (var ent in cmd.entities)
 	{
 		var cmpRallyPointRenderer = Engine.QueryInterface(ent, IID_RallyPointRenderer);
 		if (!cmpRallyPointRenderer)
 			continue;
 		
 		// entity must have a rally point component to display a rally point marker
 		// (regardless of whether cmd specifies a custom location)
 		var cmpRallyPoint = Engine.QueryInterface(ent, IID_RallyPoint);
 		if (!cmpRallyPoint)
 			continue;
 
 		// Verify the owner
 		var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		if (!(cmpPlayer && cmpPlayer.CanControlAllUnits()))
 			if (!cmpOwnership || cmpOwnership.GetOwner() != player)
 				continue;
 
 		// If the command was passed an explicit position, use that and
 		// override the real rally point position; otherwise use the real position
 		var pos;
 		if (cmd.x && cmd.z)
 			pos = cmd; 
 		else
 			pos = cmpRallyPoint.GetPositions()[0]; // may return undefined if no rally point is set
 
 		if (pos)
 		{
 			// Only update the position if we changed it (cmd.queued is set)
 			if (cmd.queued == true)
 				cmpRallyPointRenderer.AddPosition({'x': pos.x, 'y': pos.z}); // AddPosition takes a CFixedVector2D which has X/Y components, not X/Z
 			else if (cmd.queued == false)
 				cmpRallyPointRenderer.SetPosition({'x': pos.x, 'y': pos.z}); // SetPosition takes a CFixedVector2D which has X/Y components, not X/Z
 			// rebuild the renderer when not set (when reading saved game or in case of building update)
 			else if (!cmpRallyPointRenderer.IsSet())
 				for each (var posi in cmpRallyPoint.GetPositions())
 					cmpRallyPointRenderer.AddPosition({'x': posi.x, 'y': posi.z});
 
 			cmpRallyPointRenderer.SetDisplayed(true);
 			
 			// remember which entities have their rally points displayed so we can hide them again
 			this.entsRallyPointsDisplayed.push(ent);
 		}
 	}
 };
 
 /**
  * Display the building placement preview.
  * cmd.template is the name of the entity template, or "" to disable the preview.
  * cmd.x, cmd.z, cmd.angle give the location.
  * 
  * Returns result object from CheckPlacement:
  * 	{
  *		"success":	true iff the placement is valid, else false
  *		"message":	message to display in UI for invalid placement, else empty string
  *  }
  */
 GuiInterface.prototype.SetBuildingPlacementPreview = function(player, cmd)
 {
 	var result = {
 		"success": false,
 		"message": "",
 	}
 
 	// See if we're changing template
 	if (!this.placementEntity || this.placementEntity[0] != cmd.template)
 	{
 		// Destroy the old preview if there was one
 		if (this.placementEntity)
 			Engine.DestroyEntity(this.placementEntity[1]);
 
 		// Load the new template
 		if (cmd.template == "")
 		{
 			this.placementEntity = undefined;
 		}
 		else
 		{
 			this.placementEntity = [cmd.template, Engine.AddLocalEntity("preview|" + cmd.template)];
 		}
 	}
 
 	if (this.placementEntity)
 	{
 		var ent = this.placementEntity[1];
 
 		// Move the preview into the right location
 		var pos = Engine.QueryInterface(ent, IID_Position);
 		if (pos)
 		{
 			pos.JumpTo(cmd.x, cmd.z);
 			pos.SetYRotation(cmd.angle);
 		}
 
 		var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		cmpOwnership.SetOwner(player);
 
 		// Check whether building placement is valid
 		var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 		if (!cmpBuildRestrictions)
 			error("cmpBuildRestrictions not defined");
 		else
 			result = cmpBuildRestrictions.CheckPlacement();
 
 		// Set it to a red shade if this is an invalid location
 		var cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 		if (cmpVisual)
 		{
 			if (cmd.actorSeed !== undefined)
 				cmpVisual.SetActorSeed(cmd.actorSeed);
 
 			if (!result.success)
 				cmpVisual.SetShadingColour(1.4, 0.4, 0.4, 1);
 			else
 				cmpVisual.SetShadingColour(1, 1, 1, 1);
 		}
 	}
 
 	return result;
 };
 
 /**
  * Previews the placement of a wall between cmd.start and cmd.end, or just the starting piece of a wall if cmd.end is not 
  * specified. Returns an object with information about the list of entities that need to be newly constructed to complete
  * at least a part of the wall, or false if there are entities required to build at least part of the wall but none of
  * them can be validly constructed.
  * 
  * It's important to distinguish between three lists of entities that are at play here, because they may be subsets of one
  * another depending on things like snapping and whether some of the entities inside them can be validly positioned.
  * We have:
  *    - The list of entities that previews the wall. This list is usually equal to the entities required to construct the
  *      entire wall. However, if there is snapping to an incomplete tower (i.e. a foundation), it includes extra entities
  *      to preview the completed tower on top of its foundation.
  *      
  *    - The list of entities that need to be newly constructed to build the entire wall. This list is regardless of whether
  *      any of them can be validly positioned. The emphasishere here is on 'newly'; this list does not include any existing
  *      towers at either side of the wall that we snapped to. Or, more generally; it does not include any _entities_ that we
  *      snapped to; we might still snap to e.g. terrain, in which case the towers on either end will still need to be newly
  *      constructed.
  *      
  *    - The list of entities that need to be newly constructed to build at least a part of the wall. This list is the same
  *      as the one above, except that it is truncated at the first entity that cannot be validly positioned. This happens
  *      e.g. if the player tries to build a wall straight through an obstruction. Note that any entities that can be validly
  *      constructed but come after said first invalid entity are also truncated away.
  * 
  * With this in mind, this method will return false if the second list is not empty, but the third one is. That is, if there
  * were entities that are needed to build the wall, but none of them can be validly constructed. False is also returned in
  * case of unexpected errors (typically missing components), and when clearing the preview by passing an empty wallset
  * argument (see below). Otherwise, it will return an object with the following information:
  * 
  * result: {
  *   'startSnappedEnt':   ID of the entity that we snapped to at the starting side of the wall. Currently only supports towers.
  *   'endSnappedEnt':     ID of the entity that we snapped to at the (possibly truncated) ending side of the wall. Note that this
  *                        can only be set if no truncation of the second list occurs; if we snapped to an entity at the ending side
  *                        but the wall construction was truncated before we could reach it, it won't be set here. Currently only
  *                        supports towers.
  *   'pieces':            Array with the following data for each of the entities in the third list:
  *    [{
  *       'template':      Template name of the entity. 
  *       'x':             X coordinate of the entity's position.
  *       'z':             Z coordinate of the entity's position.
  *       'angle':         Rotation around the Y axis of the entity (in radians).
  *     },
  *     ...]
  *   'cost': {            The total cost required for constructing all the pieces as listed above.
  *     'food': ...,
  *     'wood': ...,
  *     'stone': ...,
  *     'metal': ...,
  *     'population': ...,
  *     'populationBonus': ...,
  *   }
  * }
  * 
  * @param cmd.wallSet Object holding the set of wall piece template names. Set to an empty value to clear the preview.
  * @param cmd.start Starting point of the wall segment being created.
  * @param cmd.end (Optional) Ending point of the wall segment being created. If not defined, it is understood that only
  *                 the starting point of the wall is available at this time (e.g. while the player is still in the process
  *                 of picking a starting point), and that therefore only the first entity in the wall (a tower) should be
  *                 previewed.
  * @param cmd.snapEntities List of candidate entities to snap the start and ending positions to.
  */
 GuiInterface.prototype.SetWallPlacementPreview = function(player, cmd)
 {
 	var wallSet = cmd.wallSet;
 	
 	var start = {
 		"pos": cmd.start,
 		"angle": 0,
 		"snapped": false,                       // did the start position snap to anything?
 		"snappedEnt": INVALID_ENTITY,           // if we snapped, was it to an entity? if yes, holds that entity's ID
 	};
 	
 	var end = {
 		"pos": cmd.end,
 		"angle": 0,
 		"snapped": false,                       // did the start position snap to anything?
 		"snappedEnt": INVALID_ENTITY,           // if we snapped, was it to an entity? if yes, holds that entity's ID
 	};
 	
 	// --------------------------------------------------------------------------------
 	// do some entity cache management and check for snapping
 	
 	if (!this.placementWallEntities)
 		this.placementWallEntities = {};
 	
 	if (!wallSet)
 	{
 		// we're clearing the preview, clear the entity cache and bail
 		var numCleared = 0;
 		for (var tpl in this.placementWallEntities)
 		{
 			for each (var ent in this.placementWallEntities[tpl].entities)
 				Engine.DestroyEntity(ent);
 			
 			this.placementWallEntities[tpl].numUsed = 0;
 			this.placementWallEntities[tpl].entities = [];
 			// keep template data around
 		}
 		
 		return false;
 	}
 	else
 	{
 		// Move all existing cached entities outside of the world and reset their use count
 		for (var tpl in this.placementWallEntities)
 		{
 			for each (var ent in this.placementWallEntities[tpl].entities)
 			{
 				var pos = Engine.QueryInterface(ent, IID_Position);
 				if (pos)
 					pos.MoveOutOfWorld();
 			}
 			
 			this.placementWallEntities[tpl].numUsed = 0;
 		}
 		
 		// Create cache entries for templates we haven't seen before
 		for each (var tpl in wallSet.templates)
 		{
 			if (!(tpl in this.placementWallEntities))
 			{
 				this.placementWallEntities[tpl] = {
 					"numUsed": 0,
 					"entities": [],
 					"templateData": this.GetTemplateData(player, tpl),
 				};
 				
 				// ensure that the loaded template data contains a wallPiece component
 				if (!this.placementWallEntities[tpl].templateData.wallPiece)
 				{
 					error("[SetWallPlacementPreview] No WallPiece component found for wall set template '" + tpl + "'");
 					return false;
 				}
 			}
 		}
 	}
 	
 	// prevent division by zero errors further on if the start and end positions are the same
 	if (end.pos && (start.pos.x === end.pos.x && start.pos.z === end.pos.z))
 		end.pos = undefined;
 	
 	// See if we need to snap the start and/or end coordinates to any of our list of snap entities. Note that, despite the list
 	// of snapping candidate entities, it might still snap to e.g. terrain features. Use the "ent" key in the returned snapping
 	// data to determine whether it snapped to an entity (if any), and to which one (see GetFoundationSnapData).
 	if (cmd.snapEntities)
 	{
 		var snapRadius = this.placementWallEntities[wallSet.templates.tower].templateData.wallPiece.length * 0.5; // determined through trial and error
 		var startSnapData = this.GetFoundationSnapData(player, {
 			"x": start.pos.x,
 			"z": start.pos.z,
 			"template": wallSet.templates.tower,
 			"snapEntities": cmd.snapEntities,
 			"snapRadius": snapRadius,
 		});
 		
 		if (startSnapData)
 		{
 			start.pos.x = startSnapData.x;
 			start.pos.z = startSnapData.z;
 			start.angle = startSnapData.angle;
 			start.snapped = true;
 			
 			if (startSnapData.ent)
 				start.snappedEnt = startSnapData.ent; 
 		}
 		
 		if (end.pos)
 		{
 			var endSnapData = this.GetFoundationSnapData(player, {
 				"x": end.pos.x,
 				"z": end.pos.z,
 				"template": wallSet.templates.tower,
 				"snapEntities": cmd.snapEntities,
 				"snapRadius": snapRadius,
 			});
 			
 			if (endSnapData)
 			{
 				end.pos.x = endSnapData.x;
 				end.pos.z = endSnapData.z;
 				end.angle = endSnapData.angle;
 				end.snapped = true;
 				
 				if (endSnapData.ent)
 					end.snappedEnt = endSnapData.ent;
 			}
 		}
 	}
 	
 	// clear the single-building preview entity (we'll be rolling our own)
 	this.SetBuildingPlacementPreview(player, {"template": ""});
 	
 	// --------------------------------------------------------------------------------
 	// calculate wall placement and position preview entities
 	
 	var result = {
 		"pieces": [],
 		"cost": {"food": 0, "wood": 0, "stone": 0, "metal": 0, "population": 0, "populationBonus": 0, "time": 0},
 	};
 	
 	var previewEntities = [];
 	if (end.pos)
 		previewEntities = GetWallPlacement(this.placementWallEntities, wallSet, start, end); // see helpers/Walls.js
 	
 	// For wall placement, we may (and usually do) need to have wall pieces overlap each other more than would 
 	// otherwise be allowed by their obstruction shapes. However, during this preview phase, this is not so much of
 	// an issue, because all preview entities have their obstruction components deactivated, meaning that their 
 	// obstruction shapes do not register in the simulation and hence cannot affect it. This implies that the preview
 	// entities cannot be found to obstruct each other, which largely solves the issue of overlap between wall pieces.
 	
 	// Note that they will still be obstructed by existing shapes in the simulation (that have the BLOCK_FOUNDATION
 	// flag set), which is what we want. The only exception to this is when snapping to existing towers (or
 	// foundations thereof); the wall segments that connect up to these will be found to be obstructed by the
 	// existing tower/foundation, and be shaded red to indicate that they cannot be placed there. To prevent this,
 	// we manually set the control group of the outermost wall pieces equal to those of the snapped-to towers, so
 	// that they are free from mutual obstruction (per definition of obstruction control groups). This is done by
 	// assigning them an extra "controlGroup" field, which we'll then set during the placement loop below.
 	
 	// Additionally, in the situation that we're snapping to merely a foundation of a tower instead of a fully
 	// constructed one, we'll need an extra preview entity for the starting tower, which also must not be obstructed
 	// by the foundation it snaps to.
 	
 	if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
 	{
 		var startEntObstruction = Engine.QueryInterface(start.snappedEnt, IID_Obstruction);
 		if (previewEntities.length > 0 && startEntObstruction)
 			previewEntities[0].controlGroups = [startEntObstruction.GetControlGroup()];
 		
 		// if we're snapping to merely a foundation, add an extra preview tower and also set it to the same control group
 		var startEntState = this.GetEntityState(player, start.snappedEnt);
 		if (startEntState.foundation)
 		{
 			var cmpPosition = Engine.QueryInterface(start.snappedEnt, IID_Position);
 			if (cmpPosition)
 			{
 				previewEntities.unshift({
 					"template": wallSet.templates.tower,
 					"pos": start.pos,
 					"angle": cmpPosition.GetRotation().y,
 					"controlGroups": [(startEntObstruction ? startEntObstruction.GetControlGroup() : undefined)],
 					"excludeFromResult": true, // preview only, must not appear in the result
 				});
 			}
 		}
 	}
 	else
 	{
 		// Didn't snap to an existing entity, add the starting tower manually. To prevent odd-looking rotation jumps 
 		// when shift-clicking to build a wall, reuse the placement angle that was last seen on a validly positioned 
 		// wall piece.
 		
 		// To illustrate the last point, consider what happens if we used some constant instead, say, 0. Issuing the
 		// build command for a wall is asynchronous, so when the preview updates after shift-clicking, the wall piece
 		// foundations are not registered yet in the simulation. This means they cannot possibly be picked in the list
 		// of candidate entities for snapping. In the next preview update, we therefore hit this case, and would rotate
 		// the preview to 0 radians. Then, after one or two simulation updates or so, the foundations register and 
 		// onSimulationUpdate in session.js updates the preview again. It first grabs a new list of snapping candidates,
 		// which this time does include the new foundations; so we snap to the entity, and rotate the preview back to
 		// the foundation's angle.
 		
 		// The result is a noticeable rotation to 0 and back, which is undesirable. So, for a split second there until
 		// the simulation updates, we fake it by reusing the last angle and hope the player doesn't notice.
 		previewEntities.unshift({
 			"template": wallSet.templates.tower,
 			"pos": start.pos,
 			"angle": (previewEntities.length > 0 ? previewEntities[0].angle : this.placementWallLastAngle)
 		});
 	}
 	
 	if (end.pos)
 	{
 		// Analogous to the starting side case above
 		if (end.snappedEnt && end.snappedEnt != INVALID_ENTITY)
 		{
 			var endEntObstruction = Engine.QueryInterface(end.snappedEnt, IID_Obstruction);
 			
 			// Note that it's possible for the last entity in previewEntities to be the same as the first, i.e. the
 			// same wall piece snapping to both a starting and an ending tower. And it might be more common than you would
 			// expect; the allowed overlap between wall segments and towers facilitates this to some degree. To deal with
 			// the possibility of dual initial control groups, we use a '.controlGroups' array rather than a single
 			// '.controlGroup' property. Note that this array can only ever have 0, 1 or 2 elements (checked at a later time).
 			if (previewEntities.length > 0 && endEntObstruction)
 			{
 				previewEntities[previewEntities.length-1].controlGroups = (previewEntities[previewEntities.length-1].controlGroups || []);
 				previewEntities[previewEntities.length-1].controlGroups.push(endEntObstruction.GetControlGroup());
 			}
 			
 			// if we're snapping to a foundation, add an extra preview tower and also set it to the same control group
 			var endEntState = this.GetEntityState(player, end.snappedEnt);
 			if (endEntState.foundation)
 			{
 				var cmpPosition = Engine.QueryInterface(end.snappedEnt, IID_Position);
 				if (cmpPosition)
 				{
 					previewEntities.push({
 						"template": wallSet.templates.tower,
 						"pos": end.pos,
 						"angle": cmpPosition.GetRotation().y,
 						"controlGroups": [(endEntObstruction ? endEntObstruction.GetControlGroup() : undefined)],
 						"excludeFromResult": true
 					});
 				}
 			}
 		}
 		else
 		{
 			previewEntities.push({
 				"template": wallSet.templates.tower,
 				"pos": end.pos,
 				"angle": (previewEntities.length > 0 ? previewEntities[previewEntities.length-1].angle : this.placementWallLastAngle)
 			});
 		}
 	}
 	
 	var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 	if (!cmpTerrain)
 	{
 		error("[SetWallPlacementPreview] System Terrain component not found");
 		return false;
 	}
 	
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	if (!cmpRangeManager)
 	{
 		error("[SetWallPlacementPreview] System RangeManager component not found");
 		return false;
 	}
 	
 	// Loop through the preview entities, and construct the subset of them that need to be, and can be, validly constructed
 	// to build at least a part of the wall (meaning that the subset is truncated after the first entity that needs to be,
 	// but cannot validly be, constructed). See method-level documentation for more details.
 	
 	var allPiecesValid = true;
 	var numRequiredPieces = 0; // number of entities that are required to build the entire wall, regardless of validity
 	
 	for (var i = 0; i < previewEntities.length; ++i)
 	{
 		var entInfo = previewEntities[i];
 		
 		var ent = null;
 		var tpl = entInfo.template;
 		var tplData = this.placementWallEntities[tpl].templateData;
 		var entPool = this.placementWallEntities[tpl];
 		
 		if (entPool.numUsed >= entPool.entities.length)
 		{
 			// allocate new entity
 			ent = Engine.AddLocalEntity("preview|" + tpl);
 			entPool.entities.push(ent);
 		}
 		else
 		{
 			 // reuse an existing one
 			ent = entPool.entities[entPool.numUsed];
 		}
 		
 		if (!ent)
 		{
 			error("[SetWallPlacementPreview] Failed to allocate or reuse preview entity of template '" + tpl + "'");
 			continue;
 		}
 		
 		// move piece to right location
 		// TODO: consider reusing SetBuildingPlacementReview for this, enhanced to be able to deal with multiple entities
 		var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 		if (cmpPosition)
 		{
 			cmpPosition.JumpTo(entInfo.pos.x, entInfo.pos.z);
 			cmpPosition.SetYRotation(entInfo.angle);
 			
 			// if this piece is a tower, then it should have a Y position that is at least as high as its surrounding pieces
 			if (tpl === wallSet.templates.tower)
 			{
 				var terrainGroundPrev = null;
 				var terrainGroundNext = null;
 				
 				if (i > 0)
 					terrainGroundPrev = cmpTerrain.GetGroundLevel(previewEntities[i-1].pos.x, previewEntities[i-1].pos.z);
 				if (i < previewEntities.length - 1)
 					terrainGroundNext = cmpTerrain.GetGroundLevel(previewEntities[i+1].pos.x, previewEntities[i+1].pos.z);
 				
 				if (terrainGroundPrev != null || terrainGroundNext != null)
 				{
 					var targetY = Math.max(terrainGroundPrev, terrainGroundNext);
 					cmpPosition.SetHeightFixed(targetY);
 				}
 			}
 		}
 		
 		var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
 		if (!cmpObstruction)
 		{
 			error("[SetWallPlacementPreview] Preview entity of template '" + tpl + "' does not have an Obstruction component");
 			continue;
 		}
 		
 		// Assign any predefined control groups. Note that there can only be 0, 1 or 2 predefined control groups; if there are
 		// more, we've made a programming error. The control groups are assigned from the entInfo.controlGroups array on a
 		// first-come first-served basis; the first value in the array is always assigned as the primary control group, and
 		// any second value as the secondary control group.
 		
 		// By default, we reset the control groups to their standard values. Remember that we're reusing entities; if we don't
 		// reset them, then an ending wall segment that was e.g. at one point snapped to an existing tower, and is subsequently
 		// reused as a non-snapped ending wall segment, would no longer be capable of being obstructed by the same tower it was
 		// once snapped to.
 		
 		var primaryControlGroup = ent;
 		var secondaryControlGroup = INVALID_ENTITY;
 		
 		if (entInfo.controlGroups && entInfo.controlGroups.length > 0)
 		{
 			if (entInfo.controlGroups.length > 2)
 			{
 				error("[SetWallPlacementPreview] Encountered preview entity of template '" + tpl + "' with more than 2 initial control groups");
 				break;
 			}
 			
 			primaryControlGroup = entInfo.controlGroups[0];
 			if (entInfo.controlGroups.length > 1)
 				secondaryControlGroup = entInfo.controlGroups[1];
 		}
 		
 		cmpObstruction.SetControlGroup(primaryControlGroup);
 		cmpObstruction.SetControlGroup2(secondaryControlGroup);
 		
 		// check whether this wall piece can be validly positioned here
 		var validPlacement = false;
 		
 		var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
 		cmpOwnership.SetOwner(player);
 		
 		// Check whether it's in a visible or fogged region
 		//  tell GetLosVisibility to force RetainInFog because preview entities set this to false,
 		//	which would show them as hidden instead of fogged
 		// TODO: should definitely reuse SetBuildingPlacementPreview, this is just straight up copy/pasta
 		var visible = (cmpRangeManager.GetLosVisibility(ent, player, true) != "hidden");
 		if (visible)
 		{
 			var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
 			if (!cmpBuildRestrictions)
 			{
 				error("[SetWallPlacementPreview] cmpBuildRestrictions not defined for preview entity of template '" + tpl + "'");
 				continue;
 			}
 			
 			// TODO: Handle results of CheckPlacement
 			validPlacement = (cmpBuildRestrictions && cmpBuildRestrictions.CheckPlacement().success);
 
 			// If a wall piece has two control groups, it's likely a segment that spans
 			// between two existing towers. To avoid placing a duplicate wall segment,
 			// check for collisions with entities that share both control groups.
 			if (validPlacement && entInfo.controlGroups && entInfo.controlGroups.length > 1)
 				validPlacement = cmpObstruction.CheckDuplicateFoundation();
 		}
 
 		allPiecesValid = allPiecesValid && validPlacement;
 		
 		// The requirement below that all pieces so far have to have valid positions, rather than only this single one,
 		// ensures that no more foundations will be placed after a first invalidly-positioned piece. (It is possible
 		// for pieces past some invalidly-positioned ones to still have valid positions, e.g. if you drag a wall 
 		// through and past an existing building).
 		
 		// Additionally, the excludeFromResult flag is set for preview entities that were manually added to be placed
 		// on top of foundations of incompleted towers that we snapped to; they must not be part of the result.
 		
 		if (!entInfo.excludeFromResult)
 			numRequiredPieces++;
 		
 		if (allPiecesValid && !entInfo.excludeFromResult)
 		{
 			result.pieces.push({
 				"template": tpl,
 				"x": entInfo.pos.x,
 				"z": entInfo.pos.z,
 				"angle": entInfo.angle,
 			});
 			this.placementWallLastAngle = entInfo.angle;
 			
 			// grab the cost of this wall piece and add it up (note; preview entities don't have their Cost components
 			// copied over, so we need to fetch it from the template instead).
 			// TODO: we should really use a Cost object or at least some utility functions for this, this is mindless
 			// boilerplate that's probably duplicated in tons of places.
 			result.cost.food += tplData.cost.food;
 			result.cost.wood += tplData.cost.wood;
 			result.cost.stone += tplData.cost.stone;
 			result.cost.metal += tplData.cost.metal;
 			result.cost.population += tplData.cost.population;
 			result.cost.populationBonus += tplData.cost.populationBonus;
 			result.cost.time += tplData.cost.time;
 		}
 
 		var canAfford = true;
 		var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
 		if (cmpPlayer && cmpPlayer.GetNeededResources(result.cost))
 			var canAfford = false;
 
 		var cmpVisual = Engine.QueryInterface(ent, IID_Visual);
 		if (cmpVisual)
 		{
 			if (!allPiecesValid || !canAfford)
 				cmpVisual.SetShadingColour(1.4, 0.4, 0.4, 1);
 			else
 				cmpVisual.SetShadingColour(1, 1, 1, 1);
 		}
 
 		entPool.numUsed++;
 	}
 	
 	// If any were entities required to build the wall, but none of them could be validly positioned, return failure
 	// (see method-level documentation).
 	if (numRequiredPieces > 0 && result.pieces.length == 0)
 		return false;
 	
 	if (start.snappedEnt && start.snappedEnt != INVALID_ENTITY)
 		result.startSnappedEnt = start.snappedEnt;
 	
 	// We should only return that we snapped to an entity if all pieces up until that entity can be validly constructed,
 	// i.e. are included in result.pieces (see docs for the result object).
 	if (end.pos && end.snappedEnt && end.snappedEnt != INVALID_ENTITY && allPiecesValid)
 		result.endSnappedEnt = end.snappedEnt;
 	
 	return result;
 };
 
 /**
  * Given the current position {data.x, data.z} of an foundation of template data.template, returns the position and angle to snap
  * it to (if necessary/useful).
  * 
  * @param data.x            The X position of the foundation to snap.
  * @param data.z            The Z position of the foundation to snap.
  * @param data.template     The template to get the foundation snapping data for.
  * @param data.snapEntities Optional; list of entity IDs to snap to if {data.x, data.z} is within a circle of radius data.snapRadius
  *                            around the entity. Only takes effect when used in conjunction with data.snapRadius.
  *                          When this option is used and the foundation is found to snap to one of the entities passed in this list
  *                            (as opposed to e.g. snapping to terrain features), then the result will contain an additional key "ent",
  *                            holding the ID of the entity that was snapped to.
  * @param data.snapRadius   Optional; when used in conjunction with data.snapEntities, indicates the circle radius around an entity that
  *                            {data.x, data.z} must be located within to have it snap to that entity.
  */
 GuiInterface.prototype.GetFoundationSnapData = function(player, data)
 {
 	var cmpTemplateMgr = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
 	var template = cmpTemplateMgr.GetTemplate(data.template);
 
 	if (!template)
 	{
 		warn("[GetFoundationSnapData] Failed to load template '" + data.template + "'");
 		return false;
 	}
 	
 	if (data.snapEntities && data.snapRadius && data.snapRadius > 0)
 	{
 		// see if {data.x, data.z} is inside the snap radius of any of the snap entities; and if so, to which it is closest
 		// (TODO: break unlikely ties by choosing the lowest entity ID)
 		
 		var minDist2 = -1;
 		var minDistEntitySnapData = null;
 		var radius2 = data.snapRadius * data.snapRadius;
 		
 		for each (var ent in data.snapEntities)
 		{
 			var cmpPosition = Engine.QueryInterface(ent, IID_Position);
 			if (!cmpPosition || !cmpPosition.IsInWorld())
 				continue;
 			
 			var pos = cmpPosition.GetPosition();
 			var dist2 = (data.x - pos.x) * (data.x - pos.x) + (data.z - pos.z) * (data.z - pos.z);
 			if (dist2 > radius2)
 				continue;
 			
 			if (minDist2 < 0 || dist2 < minDist2)
 			{
 				minDist2 = dist2;
 				minDistEntitySnapData = {"x": pos.x, "z": pos.z, "angle": cmpPosition.GetRotation().y, "ent": ent};
 			}
 		}
 		
 		if (minDistEntitySnapData != null)
 			return minDistEntitySnapData;
 	}
 	
 	if (template.BuildRestrictions.Category == "Dock")
 	{
 		// warning: copied almost identically in helpers/command.js , "GetDockAngle".
 		var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
 		var cmpWaterManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_WaterManager);
 		if (!cmpTerrain || !cmpWaterManager)
 		{
 			return false;
 		}
 		
 		// Get footprint size
 		var halfSize = 0;
 		if (template.Footprint.Square)
 		{
 			halfSize = Math.max(template.Footprint.Square["@depth"], template.Footprint.Square["@width"])/2;
 		}
 		else if (template.Footprint.Circle)
 		{
 			halfSize = template.Footprint.Circle["@radius"];
 		}
 		
 		/* Find direction of most open water, algorithm:
 		 *	1. Pick points in a circle around dock
 		 *	2. If point is in water, add to array
 		 *	3. Scan array looking for consecutive points
 		 *	4. Find longest sequence of consecutive points
 		 *	5. If sequence equals all points, no direction can be determined,
 		 *		expand search outward and try (1) again
 		 *	6. Calculate angle using average of sequence
 		 */
 		const numPoints = 16;
 		for (var dist = 0; dist < 4; ++dist)
 		{
 			var waterPoints = [];
 			for (var i = 0; i < numPoints; ++i)
 			{
 				var angle = (i/numPoints)*2*Math.PI;
 				var d = halfSize*(dist+1);
 				var nx = data.x - d*Math.sin(angle);
 				var nz = data.z + d*Math.cos(angle);
 				
 				if (cmpTerrain.GetGroundLevel(nx, nz) < cmpWaterManager.GetWaterLevel(nx, nz))
 				{
 					waterPoints.push(i);
 				}
 			}
 			var consec = [];
 			var length = waterPoints.length;
 			for (var i = 0; i < length; ++i)
 			{
 				var count = 0;
 				for (var j = 0; j < (length-1); ++j)
 				{
 					if (((waterPoints[(i + j) % length]+1) % numPoints) == waterPoints[(i + j + 1) % length])
 					{
 						++count;
 					}
 					else
 					{
 						break;
 					}
 				}
 				consec[i] = count;
 			}
 			var start = 0;
 			var count = 0;
 			for (var c in consec)
 			{
 				if (consec[c] > count)
 				{
 					start = c;
 					count = consec[c];
 				}
 			}
 			
 			// If we've found a shoreline, stop searching
 			if (count != numPoints-1)
 			{
 				return {"x": data.x, "z": data.z, "angle": -(((waterPoints[start] + consec[start]/2) % numPoints)/numPoints*2*Math.PI)};
 			}
 		}
 	}
 
 	return false;
 };
 
 GuiInterface.prototype.PlaySound = function(player, data)
 {
 	// Ignore if no entity was passed
 	if (!data.entity)
 		return;
 
 	PlaySound(data.name, data.entity);
 };
 
 function isIdleUnit(ent, idleClass)
 {
 	var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
 	var cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
 	
 	// TODO: Do something with garrisoned idle units
 	return (cmpUnitAI && cmpIdentity && cmpUnitAI.IsIdle() && !cmpUnitAI.IsGarrisoned() && idleClass && cmpIdentity.HasClass(idleClass));
 }
 
 GuiInterface.prototype.FindIdleUnits = function(player, data)
 {
 	var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	var playerEntities = rangeMan.GetEntitiesByPlayer(player).filter( function(e) {
 		var cmpUnitAI = Engine.QueryInterface(e, IID_UnitAI);
 		if (cmpUnitAI)
 			return true;
 		return false;
 	});
 
 	var idleUnits = [];
 	var noFilter = (data.prevUnit == undefined && data.excludeUnits == undefined);
 
 	for (var j = 0; j < playerEntities.length; ++j)
 	{
 		var ent = playerEntities[j];
 		if (!isIdleUnit(ent, data.idleClass))
 			continue;
 
 		if (noFilter || ((data.prevUnit == undefined || ent > data.prevUnit) &&
 				(data.excludeUnits == undefined || data.excludeUnits.indexOf(ent) == -1)))
 		{
 			idleUnits.push(ent);
 			playerEntities.splice(j--, 1);
 		}
 
 		if (data.limit && idleUnits.length >= data.limit)
 			break;
 	}
 
 	return idleUnits;
 }
 
 GuiInterface.prototype.GetTradingRouteGain = function(player, data)
 {
 	if (!data.firstMarket || !data.secondMarket)
 		return null;
 
 	return CalculateTraderGain(data.firstMarket, data.secondMarket, data.template);
 }
 
 GuiInterface.prototype.GetTradingDetails = function(player, data)
 {
 	var cmpEntityTrader = Engine.QueryInterface(data.trader, IID_Trader);
 	if (!cmpEntityTrader || !cmpEntityTrader.CanTrade(data.target))
 		return null;
 	var firstMarket = cmpEntityTrader.GetFirstMarket();
 	var secondMarket = cmpEntityTrader.GetSecondMarket();
 	var result = null;
 	if (data.target === firstMarket)
 	{
 		result = {
 			"type": "is first",
 			"hasBothMarkets": cmpEntityTrader.HasBothMarkets()
 		};
 		if (cmpEntityTrader.HasBothMarkets())
 			result.gain = cmpEntityTrader.GetGain();
 	}
 	else if (data.target === secondMarket)
 	{
 		result = {
 			"type": "is second",
 			"gain": cmpEntityTrader.GetGain(),
 		};
 	}
 	else if (!firstMarket)
 	{
 		result = {"type": "set first"};
 	}
 	else if (!secondMarket)
 	{
 		result = {
 			"type": "set second",
 			"gain": cmpEntityTrader.CalculateGain(firstMarket, data.target),
 		};
 	}
 	else
 	{
 		// Else both markets are not null and target is different from them
 		result = {"type": "set first"};
 	}
 	return result;
 };
 
 GuiInterface.prototype.CanAttack = function(player, data)
 {
 	var cmpAttack = Engine.QueryInterface(data.entity, IID_Attack);
 	if (!cmpAttack)
 		return false;
 
 	return cmpAttack.CanAttack(data.target);
 };
 
 /*
  * Returns batch build time.
  */
 GuiInterface.prototype.GetBatchTime = function(player, data)
 {
 	var cmpProductionQueue = Engine.QueryInterface(data.entity, IID_ProductionQueue);
 	if (!cmpProductionQueue)
 		return 0;
 
 	return cmpProductionQueue.GetBatchTime(data.batchSize);
 };
 
 GuiInterface.prototype.IsMapRevealed = function(player)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	return cmpRangeManager.GetLosRevealAll(-1);
 };
 
 GuiInterface.prototype.SetPathfinderDebugOverlay = function(player, enabled)
 {
 	var cmpPathfinder = Engine.QueryInterface(SYSTEM_ENTITY, IID_Pathfinder);
 	cmpPathfinder.SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetObstructionDebugOverlay = function(player, enabled)
 {
 	var cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
 	cmpObstructionManager.SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.SetMotionDebugOverlay = function(player, data)
 {
 	for each (var ent in data.entities)
 	{
 		var cmpUnitMotion = Engine.QueryInterface(ent, IID_UnitMotion);
 		if (cmpUnitMotion)
 			cmpUnitMotion.SetDebugOverlay(data.enabled);
 	}
 };
 
 GuiInterface.prototype.SetRangeDebugOverlay = function(player, enabled)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	cmpRangeManager.SetDebugOverlay(enabled);
 };
 
 GuiInterface.prototype.GetTraderNumber = function(player)
 {
 	var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
 	var traders = cmpRangeManager.GetEntitiesByPlayer(player).filter( function(e) {
 		return Engine.QueryInterface(e, IID_Trader);
 	});
 
 	var landTrader = { "total": 0, "trading": 0, "garrisoned": 0 };
 	var shipTrader = { "total": 0, "trading": 0 };
 	for each (var ent in traders)
 	{
 		var cmpIdentity =  Engine.QueryInterface(ent, IID_Identity);
 		var cmpUnitAI =  Engine.QueryInterface(ent, IID_UnitAI);
 		if (!cmpIdentity || !cmpUnitAI)
 			continue;
 		if (cmpIdentity.HasClass("Ship"))
 		{
 			++shipTrader.total;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Trade")
 				++shipTrader.trading;
 		}
 		else
 		{
 			++landTrader.total;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Trade")
 				++landTrader.trading;
 			if (cmpUnitAI.order && cmpUnitAI.order.type == "Garrison")
 			{
 				var holder = cmpUnitAI.order.data.target;
 				var cmpHolderUnitAI = Engine.QueryInterface(holder, IID_UnitAI);
 				if (cmpHolderUnitAI && cmpHolderUnitAI.order && cmpHolderUnitAI.order.type == "Trade")
 					++landTrader.garrisoned;
 			}
 		}
 	}
 
 	return { "landTrader": landTrader, "shipTrader": shipTrader };
 };
 
 GuiInterface.prototype.GetTradingGoods = function(player, tradingGoods)
 {
 	var cmpPlayer = QueryPlayerIDInterface(player, IID_Player);
 	return cmpPlayer.GetTradingGoods();
 };
 
 GuiInterface.prototype.OnGlobalEntityRenamed = function(msg)
 {
 	this.renamedEntities.push(msg);
 }
 
 // List the GuiInterface functions that can be safely called by GUI scripts.
 // (GUI scripts are non-deterministic and untrusted, so these functions must be
 // appropriately careful. They are called with a first argument "player", which is
 // trusted and indicates the player associated with the current client; no data should
 // be returned unless this player is meant to be able to see it.)
 var exposedFunctions = {
 	
 	"GetSimulationState": 1,
 	"GetExtendedSimulationState": 1,
 	"GetRenamedEntities": 1,
 	"ClearRenamedEntities": 1,
 	"GetEntityState": 1,
 	"GetExtendedEntityState": 1,
 	"GetAverageRangeForBuildings": 1,
 	"GetTemplateData": 1,
 	"GetTechnologyData": 1,
 	"IsTechnologyResearched": 1,
 	"CheckTechnologyRequirements": 1,
 	"GetStartedResearch": 1,
 	"GetBattleState": 1,
 	"GetIncomingAttacks": 1,
 	"GetNeededResources": 1,
 	"GetNextNotification": 1,
+	"GetTimeNotificationText": 1,
 
 	"GetAvailableFormations": 1,
 	"GetFormationRequirements": 1,
 	"CanMoveEntsIntoFormation": 1,
 	"IsFormationSelected": 1,
 	"IsStanceSelected": 1,
 
 	"SetSelectionHighlight": 1,
 	"SetStatusBars": 1,
 	"GetPlayerEntities": 1,
 	"DisplayRallyPoint": 1,
 	"SetBuildingPlacementPreview": 1,
 	"SetWallPlacementPreview": 1,
 	"GetFoundationSnapData": 1,
 	"PlaySound": 1,
 	"FindIdleUnits": 1,
 	"GetTradingRouteGain": 1,
 	"GetTradingDetails": 1,
 	"CanAttack": 1,
 	"GetBatchTime": 1,
 
 	"IsMapRevealed": 1,
 	"SetPathfinderDebugOverlay": 1,
 	"SetObstructionDebugOverlay": 1,
 	"SetMotionDebugOverlay": 1,
 	"SetRangeDebugOverlay": 1,
 
 	"GetTraderNumber": 1,
 	"GetTradingGoods": 1,
 };
 
 GuiInterface.prototype.ScriptCall = function(player, name, args)
 {
 	if (exposedFunctions[name])
 		return this[name](player, args);
 	else
 		throw new Error("Invalid GuiInterface Call name \""+name+"\"");
 };
 
 Engine.RegisterComponentType(IID_GuiInterface, "GuiInterface", GuiInterface);
Index: ps/trunk/binaries/data/mods/public/simulation/components/Wonder.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Wonder.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Wonder.js	(revision 14418)
@@ -0,0 +1,67 @@
+function Wonder() {}
+
+Wonder.prototype.Schema = 
+	"<element name='TimeTillVictory'>" +
+		"<data type='nonNegativeInteger'/>" +
+	"</element>";
+
+Wonder.prototype.Init = function()
+{
+};
+
+Wonder.prototype.OnOwnershipChanged = function(msg)
+{
+	this.ResetTimer(msg.to);
+};
+
+Wonder.prototype.OnGameTypeChanged = function()
+{
+	var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+	if (!cmpPlayer)
+		return;
+	this.ResetTimer(cmpPlayer.GetPlayerID());
+};
+
+Wonder.prototype.ResetTimer = function(ownerID)
+{
+	var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+	// remove existing messages if any
+	if (this.timer)
+	{
+		cmpTimer.CancelTimer(this.timer);
+		cmpGuiInterface.DeleteTimeNotification(this.ownMessage);
+		cmpGuiInterface.DeleteTimeNotification(this.otherMessage);
+	}
+	if (ownerID <= 0)
+		return;
+
+	var cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
+	if (!cmpEndGameManager.CheckGameType("wonder"))
+		return;
+
+	// create new messages, and start timer to register defeat.
+	var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+	var numPlayers = cmpPlayerManager.GetNumPlayers();
+	var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+	var players = [];
+	for (var i = 1; i < numPlayers; i++)
+		if (i != ownerID)
+			players.push(i);
+
+	this.otherMessage = cmpGuiInterface.AddTimeNotification(
+		{
+			"message": cmpPlayer.GetName() + " will have won in %T",
+			"players": players,
+			"time": +this.template.TimeTillVictory*1000
+		});
+	this.ownMessage = cmpGuiInterface.AddTimeNotification(
+		{
+			"message": "You will have won in %T",
+			"players": [ownerID],
+			"time": +this.template.TimeTillVictory*1000
+		});
+	this.timer = cmpTimer.SetTimeout(SYSTEM_ENTITY, IID_EndGameManager, "RegisterWonder", +this.template.TimeTillVictory*1000, this.entity);
+};
+
+Engine.RegisterComponentType(IID_Wonder, "Wonder", Wonder);
Index: ps/trunk/binaries/data/mods/public/simulation/components/interfaces/EndGameManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/interfaces/EndGameManager.js	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/simulation/components/interfaces/EndGameManager.js	(revision 14418)
@@ -1,2 +1,3 @@
 Engine.RegisterInterface("EndGameManager");
 Engine.RegisterMessageType("PlayerDefeated");
+Engine.RegisterMessageType("GameTypeChanged");
Index: ps/trunk/binaries/data/mods/public/simulation/components/interfaces/Wonder.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/interfaces/Wonder.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/public/simulation/components/interfaces/Wonder.js	(revision 14418)
@@ -0,0 +1 @@
+Engine.RegisterInterface("Wonder");
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_structure_wonder.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_structure_wonder.xml	(revision 14417)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_structure_wonder.xml	(revision 14418)
@@ -1,79 +1,82 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_structure">
   <Armour>
     <Hack>5</Hack>
     <Pierce>25</Pierce>
     <Crush>5</Crush>
     <Foundation>
       <Hack>2</Hack>
       <Pierce>10</Pierce>
       <Crush>2</Crush>
     </Foundation>
   </Armour>
   <BuildRestrictions>
     <Category>Wonder</Category>
   </BuildRestrictions>
   <Cost>
     <BuildTime>500</BuildTime>
     <Resources>
       <food>0</food>
       <wood>1000</wood>
       <stone>1000</stone>
       <metal>1000</metal>
     </Resources>
   </Cost>
   <Footprint>
     <Square width="34.0" depth="34.0"/>
     <Height>10.0</Height>
   </Footprint>
   <GarrisonHolder disable=""/>
   <Health>
     <Max>5000</Max>
     <SpawnEntityOnDeath>rubble/rubble_stone_6x6</SpawnEntityOnDeath>
   </Health>
   <Identity>
     <GenericName>Wonder</GenericName>
     <Tooltip>Bring glory to your civilization and add large tracts of land to your empire.</Tooltip>
     <Classes datatype="tokens">
 	  City
 	  Wonder
 	</Classes>
     <Icon>structures/wonder.png</Icon>
     <RequiredTechnology>phase_city</RequiredTechnology>
   </Identity>
   <Loot>
     <xp>200</xp>
     <food>0</food>
     <wood>100</wood>
     <stone>100</stone>
     <metal>100</metal>
   </Loot>
   <Obstruction>
     <Static width="30.0" depth="30.0"/>
   </Obstruction>
   <RallyPoint disable=""/>
   <Sound>
     <SoundGroups>
       <select>interface/select/building/sel_wonder.xml</select>
       <constructed>interface/complete/building/complete_wonder.xml</constructed>
       <death>attack/destruction/building_collapse_large.xml</death>
     </SoundGroups>
   </Sound>
   <StatusBars>
     <BarWidth>6.0</BarWidth>
     <BarHeight>0.6</BarHeight>
     <HeightOffset>12.0</HeightOffset>
   </StatusBars>
   <TerritoryInfluence>
     <Root>true</Root>
     <Radius>100</Radius>
     <Weight>65536</Weight>
   </TerritoryInfluence>
   <Vision>
     <Range>72</Range>
     <RetainInFog>true</RetainInFog>
   </Vision>
   <VisualActor>
     <FoundationActor>structures/fndn_6x6.xml</FoundationActor>
   </VisualActor>
+  <Wonder>
+    <TimeTillVictory>300</TimeTillVictory>
+  </Wonder>
 </Entity>
Index: ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Map/Map.cpp
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Map/Map.cpp	(revision 14417)
+++ ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Map/Map.cpp	(revision 14418)
@@ -1,568 +1,569 @@
 /* Copyright (C) 2013 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 "Map.h"
 
 #include "AtlasObject/AtlasObject.h"
 #include "AtlasScript/ScriptInterface.h"
 #include "GameInterface/Messages.h"
 #include "ScenarioEditor/ScenarioEditor.h"
 #include "ScenarioEditor/Tools/Common/Tools.h"
 
 #include "wx/busyinfo.h"
 #include "wx/filename.h"
 
 enum
 {
 	ID_MapName,
 	ID_MapDescription,
 	ID_MapReveal,
 	ID_MapType,
 	ID_MapPreview,
 	ID_MapTeams,
 	ID_MapKW_Demo,
 	ID_MapKW_Naval,
 	ID_RandomScript,
 	ID_RandomSize,
 	ID_RandomSeed,
 	ID_RandomReseed,
 	ID_RandomGenerate,
 	ID_SimPlay,
 	ID_SimFast,
 	ID_SimSlow,
 	ID_SimPause,
 	ID_SimReset,
 	ID_OpenPlayerPanel
 };
 
 enum
 {
 	SimInactive,
 	SimPlaying,
 	SimPlayingFast,
 	SimPlayingSlow,
 	SimPaused
 };
 
 bool IsPlaying(int s) { return (s == SimPlaying || s == SimPlayingFast || s == SimPlayingSlow); }
 
 // TODO: Some of these helper things should be moved out of this file
 // and into shared locations
 
 // Helper function for adding tooltips
 static wxWindow* Tooltipped(wxWindow* window, const wxString& tip)
 {
 	window->SetToolTip(tip);
 	return window;
 }
 
 // Helper class for storing AtObjs
 class AtObjClientData : public wxClientData
 {
 public:
 	AtObjClientData(const AtObj& obj) : obj(obj) {}
 	virtual ~AtObjClientData() {}
 	AtObj GetValue() { return obj; }
 private:
 	AtObj obj;
 };
 
 class MapSettingsControl : public wxPanel
 {
 public:
 	MapSettingsControl(wxWindow* parent, ScenarioEditor& scenarioEditor);
 	void CreateWidgets();
 	void ReadFromEngine();
 	void SetMapSettings(const AtObj& obj);
 	AtObj UpdateSettingsObject();
 private:
 	void SendToEngine();
 
 	void OnEdit(wxCommandEvent& WXUNUSED(evt))
 	{
 		SendToEngine();
 	}
 
 	std::set<std::wstring> m_MapSettingsKeywords;
 	std::vector<wxChoice*> m_PlayerCivChoices;
 	ScenarioEditor& m_ScenarioEditor;
 	Observable<AtObj>& m_MapSettings;
 
 	DECLARE_EVENT_TABLE();
 };
 
 BEGIN_EVENT_TABLE(MapSettingsControl, wxPanel)
 	EVT_TEXT(ID_MapName, MapSettingsControl::OnEdit)
 	EVT_TEXT(ID_MapDescription, MapSettingsControl::OnEdit)
 	EVT_TEXT(ID_MapPreview, MapSettingsControl::OnEdit)
 	EVT_CHECKBOX(wxID_ANY, MapSettingsControl::OnEdit)
 	EVT_CHOICE(wxID_ANY, MapSettingsControl::OnEdit)
 END_EVENT_TABLE();
 
 MapSettingsControl::MapSettingsControl(wxWindow* parent, ScenarioEditor& scenarioEditor)
 	: wxPanel(parent, wxID_ANY), m_ScenarioEditor(scenarioEditor), m_MapSettings(scenarioEditor.GetMapSettings())
 {
 	wxStaticBoxSizer* sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Map settings"));
 	SetSizer(sizer);
 }
 
 void MapSettingsControl::CreateWidgets()
 {
 	wxSizer* sizer = GetSizer();
 
 	/////////////////////////////////////////////////////////////////////////
 	// Map settings
 	wxBoxSizer* nameSizer = new wxBoxSizer(wxHORIZONTAL);
 	nameSizer->Add(new wxStaticText(this, wxID_ANY, _("Name")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL));
 	nameSizer->Add(8, 0);
 	nameSizer->Add(Tooltipped(new wxTextCtrl(this, ID_MapName),
 			_("Displayed name of the map")), wxSizerFlags().Proportion(1));
 	sizer->Add(nameSizer, wxSizerFlags().Expand());
 
 	sizer->Add(0, 2);
 
 	sizer->Add(new wxStaticText(this, wxID_ANY, _("Description")));
 	sizer->Add(Tooltipped(new wxTextCtrl(this, ID_MapDescription, wxEmptyString, wxDefaultPosition, wxSize(-1, 100), wxTE_MULTILINE),
 			_("Short description used on the map selection screen")), wxSizerFlags().Expand());
 
 	sizer->AddSpacer(5);
 
 	wxArrayString gameTypes;
 	gameTypes.Add(_T("conquest"));
+	gameTypes.Add(_T("wonder"));
 	gameTypes.Add(_T("endless"));
 
 	wxFlexGridSizer* gridSizer = new wxFlexGridSizer(2, 5, 5);
 	gridSizer->AddGrowableCol(1);
 	// TODO: have preview selector tool?
 	gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Preview")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 	gridSizer->Add(Tooltipped(new wxTextCtrl(this, ID_MapPreview, wxEmptyString),
 		_("Texture used for map preview")), wxSizerFlags().Expand());
 	gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Reveal map")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 	gridSizer->Add(Tooltipped(new wxCheckBox(this, ID_MapReveal, wxEmptyString),
 		_("If checked, players won't need to explore")));
 	gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Game type")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 	gridSizer->Add(Tooltipped(new wxChoice(this, ID_MapType, wxDefaultPosition, wxDefaultSize, gameTypes),
 		_("Select the game type (or victory condition)")), wxSizerFlags().Expand());
 	gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Lock teams")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 	gridSizer->Add(Tooltipped(new wxCheckBox(this, ID_MapTeams, wxEmptyString),
 		_("If checked, teams will be locked")));
 	sizer->Add(gridSizer, wxSizerFlags().Expand());
 
 	sizer->AddSpacer(5);
 
 	wxStaticBoxSizer* keywordsSizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Keywords"));
 	wxFlexGridSizer* kwGridSizer = new wxFlexGridSizer(4, 5, 5);
 	kwGridSizer->Add(new wxStaticText(this, wxID_ANY, _("Demo")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 	kwGridSizer->Add(Tooltipped(new wxCheckBox(this, ID_MapKW_Demo, wxEmptyString),
 		_("If checked, map will only be visible using filters in game setup")));
 	kwGridSizer->Add(new wxStaticText(this, wxID_ANY, _("Naval")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 	kwGridSizer->Add(Tooltipped(new wxCheckBox(this, ID_MapKW_Naval, wxEmptyString),
 		_("If checked, map will only be visible using filters in game setup")));
 	keywordsSizer->Add(kwGridSizer);
 	sizer->Add(keywordsSizer, wxSizerFlags().Expand());
 }
 
 void MapSettingsControl::ReadFromEngine()
 {
 	AtlasMessage::qGetMapSettings qry;
 	qry.Post();
 	if (!(*qry.settings).empty())
 	{
 		// Prevent error if there's no map settings to parse
 		m_MapSettings = AtlasObject::LoadFromJSON(m_ScenarioEditor.GetScriptInterface().GetContext(), *qry.settings);
 	}
 
 	// map name
 	wxDynamicCast(FindWindow(ID_MapName), wxTextCtrl)->ChangeValue(wxString(m_MapSettings["Name"]));
 
 	// map description
 	wxDynamicCast(FindWindow(ID_MapDescription), wxTextCtrl)->ChangeValue(wxString(m_MapSettings["Description"]));
 
 	// map preview
 	wxDynamicCast(FindWindow(ID_MapPreview), wxTextCtrl)->ChangeValue(wxString(m_MapSettings["Preview"]));
 
 	// reveal map
 	wxDynamicCast(FindWindow(ID_MapReveal), wxCheckBox)->SetValue(wxString(m_MapSettings["RevealMap"]) == L"true");
 
 	// game type / victory conditions
 	if (m_MapSettings["GameType"].defined())
 		wxDynamicCast(FindWindow(ID_MapType), wxChoice)->SetStringSelection(wxString(m_MapSettings["GameType"]));
 	else
 		wxDynamicCast(FindWindow(ID_MapType), wxChoice)->SetSelection(0);
 
 	// lock teams
 	wxDynamicCast(FindWindow(ID_MapTeams), wxCheckBox)->SetValue(wxString(m_MapSettings["LockTeams"]) == L"true");
 
 	// keywords
 	{
 		m_MapSettingsKeywords.clear();
 		for (AtIter keyword = m_MapSettings["Keywords"]["item"]; keyword.defined(); ++keyword)
 			m_MapSettingsKeywords.insert(std::wstring(keyword));
 
 		wxDynamicCast(FindWindow(ID_MapKW_Demo), wxCheckBox)->SetValue(m_MapSettingsKeywords.count(L"demo") != 0);
 		wxDynamicCast(FindWindow(ID_MapKW_Naval), wxCheckBox)->SetValue(m_MapSettingsKeywords.count(L"naval") != 0);
 	}
 }
 
 void MapSettingsControl::SetMapSettings(const AtObj& obj)
 {
 	m_MapSettings = obj;
 	m_MapSettings.NotifyObservers();
 
 	SendToEngine();
 }
 
 AtObj MapSettingsControl::UpdateSettingsObject()
 {
 	// map name
 	m_MapSettings.set("Name", wxDynamicCast(FindWindow(ID_MapName), wxTextCtrl)->GetValue());
 
 	// map description
 	m_MapSettings.set("Description", wxDynamicCast(FindWindow(ID_MapDescription), wxTextCtrl)->GetValue());
 
 	// map preview
 	m_MapSettings.set("Preview", wxDynamicCast(FindWindow(ID_MapPreview), wxTextCtrl)->GetValue());
 
 	// reveal map
 	m_MapSettings.setBool("RevealMap", wxDynamicCast(FindWindow(ID_MapReveal), wxCheckBox)->GetValue());
 
 	// game type / victory conditions
 	m_MapSettings.set("GameType", wxDynamicCast(FindWindow(ID_MapType), wxChoice)->GetStringSelection());
 
 	// keywords
 	{
 		if (wxDynamicCast(FindWindow(ID_MapKW_Demo), wxCheckBox)->GetValue())
 			m_MapSettingsKeywords.insert(L"demo");
 		else
 			m_MapSettingsKeywords.erase(L"demo");
 
 		if (wxDynamicCast(FindWindow(ID_MapKW_Naval), wxCheckBox)->GetValue())
 			m_MapSettingsKeywords.insert(L"naval");
 		else
 			m_MapSettingsKeywords.erase(L"naval");
 
 		AtObj keywords;
 		keywords.set("@array", L"");
 		for (std::set<std::wstring>::iterator it = m_MapSettingsKeywords.begin(); it != m_MapSettingsKeywords.end(); ++it)
 			keywords.add("item", it->c_str());
 		m_MapSettings.set("Keywords", keywords);
 	}
 
 	// teams locked
 	m_MapSettings.setBool("LockTeams", wxDynamicCast(FindWindow(ID_MapTeams), wxCheckBox)->GetValue());
 
 	return m_MapSettings;
 }
 
 void MapSettingsControl::SendToEngine()
 {
 	UpdateSettingsObject();
 
 	std::string json = AtlasObject::SaveToJSON(m_ScenarioEditor.GetScriptInterface().GetContext(), m_MapSettings);
 
 	// TODO: would be nice if we supported undo for settings changes
 
 	POST_COMMAND(SetMapSettings, (json));
 }
 
 
 MapSidebar::MapSidebar(ScenarioEditor& scenarioEditor, wxWindow* sidebarContainer, wxWindow* bottomBarContainer)
 	: Sidebar(scenarioEditor, sidebarContainer, bottomBarContainer), m_SimState(SimInactive)
 {
 	m_MapSettingsCtrl = new MapSettingsControl(this, m_ScenarioEditor);
 	m_MainSizer->Add(m_MapSettingsCtrl, wxSizerFlags().Expand());
 
 	{
 		/////////////////////////////////////////////////////////////////////////
 		// Random map settings
 		wxStaticBoxSizer* sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Random map"));
 
 		sizer->Add(new wxChoice(this, ID_RandomScript), wxSizerFlags().Expand());
 
 		sizer->AddSpacer(5);
 
 		sizer->Add(new wxButton(this, ID_OpenPlayerPanel, _T("Change players")), wxSizerFlags().Expand());
 
 		sizer->AddSpacer(5);
 
 		wxFlexGridSizer* gridSizer = new wxFlexGridSizer(2, 5, 5);
 		gridSizer->AddGrowableCol(1);
 
 		wxChoice* sizeChoice = new wxChoice(this, ID_RandomSize);
 		gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Map size")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 		gridSizer->Add(sizeChoice, wxSizerFlags().Expand());
 
 		gridSizer->Add(new wxStaticText(this, wxID_ANY, _("Random seed")), wxSizerFlags().Align(wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT));
 		wxBoxSizer* seedSizer = new wxBoxSizer(wxHORIZONTAL);
 		seedSizer->Add(Tooltipped(new wxTextCtrl(this, ID_RandomSeed, _T("0"), wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC)),
 			_("Seed value for random map")), wxSizerFlags(1).Expand());
 		seedSizer->Add(Tooltipped(new wxButton(this, ID_RandomReseed, _("R"), wxDefaultPosition, wxSize(24, -1)),
 			_("New random seed")));
 		gridSizer->Add(seedSizer, wxSizerFlags().Expand());
 
 		sizer->Add(gridSizer, wxSizerFlags().Expand());
 
 		sizer->AddSpacer(5);
 
 		sizer->Add(Tooltipped(new wxButton(this, ID_RandomGenerate, _("Generate map")),
 			_("Run selected random map script")), wxSizerFlags().Expand());
 
 		m_MainSizer->Add(sizer, wxSizerFlags().Expand().Border(wxTOP, 10));
 	}
 
 	{
 		/////////////////////////////////////////////////////////////////////////
 		// Simulation buttons
 		wxStaticBoxSizer* sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Simulation test"));
 		wxGridSizer* gridSizer = new wxGridSizer(5);
 		gridSizer->Add(Tooltipped(new wxButton(this, ID_SimPlay, _("Play")),
 			_("Run the simulation at normal speed")), wxSizerFlags().Expand());
 		gridSizer->Add(Tooltipped(new wxButton(this, ID_SimFast, _("Fast")),
 			_("Run the simulation at 8x speed")), wxSizerFlags().Expand());
 		gridSizer->Add(Tooltipped(new wxButton(this, ID_SimSlow, _("Slow")),
 			_("Run the simulation at 1/8x speed")), wxSizerFlags().Expand());
 		gridSizer->Add(Tooltipped(new wxButton(this, ID_SimPause, _("Pause")),
 			_("Pause the simulation")), wxSizerFlags().Expand());
 		gridSizer->Add(Tooltipped(new wxButton(this, ID_SimReset, _("Reset")),
 			_("Reset the editor to initial state")), wxSizerFlags().Expand());
 		sizer->Add(gridSizer, wxSizerFlags().Expand());
 		UpdateSimButtons();
 		m_MainSizer->Add(sizer, wxSizerFlags().Expand().Border(wxTOP, 10));
 	}
 }
 
 void MapSidebar::OnCollapse(wxCollapsiblePaneEvent& WXUNUSED(evt))
 {
 	Freeze();
 
 	// Toggling the collapsing doesn't seem to update the sidebar layout
 	// automatically, so do it explicitly here
 	Layout();
 
 	Refresh(); // fixes repaint glitch on Windows
 
 	Thaw();
 }
 
 void MapSidebar::OnFirstDisplay()
 {
 	// We do this here becase messages are used which requires simulation to be init'd
 	m_MapSettingsCtrl->CreateWidgets();
 	m_MapSettingsCtrl->ReadFromEngine();
 
 	// Load the map sizes list
 	AtlasMessage::qGetMapSizes qrySizes;
 	qrySizes.Post();
 	AtObj sizes = AtlasObject::LoadFromJSON(m_ScenarioEditor.GetScriptInterface().GetContext(), *qrySizes.sizes);
 	wxChoice* sizeChoice = wxDynamicCast(FindWindow(ID_RandomSize), wxChoice);
 	for (AtIter s = sizes["Sizes"]["item"]; s.defined(); ++s)
 	{
 		long tiles = 0;
 		wxString(s["Tiles"]).ToLong(&tiles);
 		sizeChoice->Append(wxString(s["Name"]), (void*)(intptr_t)tiles);
 	}
 	sizeChoice->SetSelection(0);
 
 	// Load the RMS script list
 	AtlasMessage::qGetRMSData qry;
 	qry.Post();
 	std::vector<std::string> scripts = *qry.data;
 	wxChoice* scriptChoice = wxDynamicCast(FindWindow(ID_RandomScript), wxChoice);
 	scriptChoice->Clear();
 	for (size_t i = 0; i < scripts.size(); ++i)
 	{
 		AtObj data = AtlasObject::LoadFromJSON(m_ScenarioEditor.GetScriptInterface().GetContext(), scripts[i]);
 		wxString name(data["settings"]["Name"]);
 		scriptChoice->Append(name, new AtObjClientData(*data["settings"]));
 	}
 	scriptChoice->SetSelection(0);
 
 	Layout();
 }
 
 void MapSidebar::OnMapReload()
 {
 	m_MapSettingsCtrl->ReadFromEngine();
 
 	// Reset sim test buttons
 	POST_MESSAGE(SimPlay, (0.f, false));
 	POST_MESSAGE(GuiSwitchPage, (L"page_atlas.xml"));
 	m_SimState = SimInactive;
 	UpdateSimButtons();
 }
 
 void MapSidebar::UpdateSimButtons()
 {
 	wxButton* button;
 
 	button = wxDynamicCast(FindWindow(ID_SimPlay), wxButton);
 	wxCHECK(button, );
 	button->Enable(m_SimState != SimPlaying);
 
 	button = wxDynamicCast(FindWindow(ID_SimFast), wxButton);
 	wxCHECK(button, );
 	button->Enable(m_SimState != SimPlayingFast);
 
 	button = wxDynamicCast(FindWindow(ID_SimSlow), wxButton);
 	wxCHECK(button, );
 	button->Enable(m_SimState != SimPlayingSlow);
 
 	button = wxDynamicCast(FindWindow(ID_SimPause), wxButton);
 	wxCHECK(button, );
 	button->Enable(IsPlaying(m_SimState));
 
 	button = wxDynamicCast(FindWindow(ID_SimReset), wxButton);
 	wxCHECK(button, );
 	button->Enable(m_SimState != SimInactive);
 }
 
 void MapSidebar::OnSimPlay(wxCommandEvent& event)
 {
 	float speed = 1.f;
 	int newState = SimPlaying;
 	if (event.GetId() == ID_SimFast)
 	{
 		speed = 8.f;
 		newState = SimPlayingFast;
 	}
 	else if (event.GetId() == ID_SimSlow)
 	{
 		speed = 0.125f;
 		newState = SimPlayingSlow;
 	}
 
 	if (m_SimState == SimInactive)
 	{
 		// Force update of player settings
 		POST_MESSAGE(LoadPlayerSettings, (false));
 
 		POST_MESSAGE(SimStateSave, (L"default"));
 		POST_MESSAGE(GuiSwitchPage, (L"page_session.xml"));
 		POST_MESSAGE(SimPlay, (speed, true));
 		m_SimState = newState;
 	}
 	else // paused or already playing at a different speed
 	{
 		POST_MESSAGE(SimPlay, (speed, true));
 		m_SimState = newState;
 	}
 	UpdateSimButtons();
 }
 
 void MapSidebar::OnSimPause(wxCommandEvent& WXUNUSED(event))
 {
 	if (IsPlaying(m_SimState))
 	{
 		POST_MESSAGE(SimPlay, (0.f, true));
 		m_SimState = SimPaused;
 	}
 	UpdateSimButtons();
 }
 
 void MapSidebar::OnSimReset(wxCommandEvent& WXUNUSED(event))
 {
 	if (IsPlaying(m_SimState))
 	{
 		POST_MESSAGE(SimPlay, (0.f, true));
 		POST_MESSAGE(SimStateRestore, (L"default"));
 		POST_MESSAGE(SimPlay, (0.f, false));
 		POST_MESSAGE(GuiSwitchPage, (L"page_atlas.xml"));
 		m_SimState = SimInactive;
 	}
 	else if (m_SimState == SimPaused)
 	{
 		POST_MESSAGE(SimPlay, (0.f, true));
 		POST_MESSAGE(SimStateRestore, (L"default"));
 		POST_MESSAGE(SimPlay, (0.f, false));
 		POST_MESSAGE(GuiSwitchPage, (L"page_atlas.xml"));
 		m_SimState = SimInactive;
 	}
 	UpdateSimButtons();
 }
 
 void MapSidebar::OnRandomReseed(wxCommandEvent& WXUNUSED(evt))
 {
 	// Pick a shortish randomish value
 	wxString seed;
 	seed << (int)floor((rand() / (float)RAND_MAX) * 10000.f);
 	wxDynamicCast(FindWindow(ID_RandomSeed), wxTextCtrl)->SetValue(seed);
 }
 
 void MapSidebar::OnRandomGenerate(wxCommandEvent& WXUNUSED(evt))
 {
 	wxChoice* scriptChoice = wxDynamicCast(FindWindow(ID_RandomScript), wxChoice);
 
 	if (scriptChoice->GetSelection() < 0)
 		return;
 
 	// TODO: this settings thing seems a bit of a mess,
 	// since it's mixing data from three different sources
 
 	AtObj settings = m_MapSettingsCtrl->UpdateSettingsObject();
 
 	AtObj scriptSettings = dynamic_cast<AtObjClientData*>(scriptChoice->GetClientObject(scriptChoice->GetSelection()))->GetValue();
 
 	settings.addOverlay(scriptSettings);
 
 	wxChoice* sizeChoice = wxDynamicCast(FindWindow(ID_RandomSize), wxChoice);
 	wxString size;
 	size << (intptr_t)sizeChoice->GetClientData(sizeChoice->GetSelection());
 	settings.setInt("Size", wxAtoi(size));
 
 	settings.setInt("Seed", wxAtoi(wxDynamicCast(FindWindow(ID_RandomSeed), wxTextCtrl)->GetValue()));
 
 	std::string json = AtlasObject::SaveToJSON(m_ScenarioEditor.GetScriptInterface().GetContext(), settings);
 
 	wxBusyInfo busy(_("Generating map"));
 	wxBusyCursor busyc;
 
 	wxString scriptName(settings["Script"]);
 
 	// Copy the old map settings, so we don't lose them if the map generation fails
 	AtObj oldSettings = settings;
 
 	AtlasMessage::qGenerateMap qry((std::wstring)scriptName.wc_str(), json);
 	qry.Post();
 
 	if (qry.status < 0)
 	{
 		// Display error message and revert to old map settings
 		wxLogError(_("Random map script '%ls' failed"), scriptName.wc_str());
 		m_MapSettingsCtrl->SetMapSettings(oldSettings);
 	}
 
 	m_ScenarioEditor.NotifyOnMapReload();
 }
 
 void MapSidebar::OnOpenPlayerPanel(wxCommandEvent& WXUNUSED(evt))
 {
 	m_ScenarioEditor.SelectPage(_T("PlayerSidebar"));
 }
 
 BEGIN_EVENT_TABLE(MapSidebar, Sidebar)
 	EVT_COLLAPSIBLEPANE_CHANGED(wxID_ANY, MapSidebar::OnCollapse)
 	EVT_BUTTON(ID_SimPlay, MapSidebar::OnSimPlay)
 	EVT_BUTTON(ID_SimFast, MapSidebar::OnSimPlay)
 	EVT_BUTTON(ID_SimSlow, MapSidebar::OnSimPlay)
 	EVT_BUTTON(ID_SimPause, MapSidebar::OnSimPause)
 	EVT_BUTTON(ID_SimReset, MapSidebar::OnSimReset)
 	EVT_BUTTON(ID_RandomReseed, MapSidebar::OnRandomReseed)
 	EVT_BUTTON(ID_RandomGenerate, MapSidebar::OnRandomGenerate)
 	EVT_BUTTON(ID_OpenPlayerPanel, MapSidebar::OnOpenPlayerPanel)
 END_EVENT_TABLE();