Index: ps/trunk/binaries/data/mods/public/gui/common/gamedescription.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/common/gamedescription.js	(revision 22825)
+++ ps/trunk/binaries/data/mods/public/gui/common/gamedescription.js	(revision 22826)
@@ -1,483 +1,481 @@
 /**
  * Highlights the victory condition in the game-description.
  */
 var g_DescriptionHighlight = "orange";
 
 /**
  * The rating assigned to lobby players who didn't complete a ranked 1v1 yet.
  */
 var g_DefaultLobbyRating = 1200;
 
 /**
  * XEP-0172 doesn't restrict nicknames, but our lobby policy does.
  * So use this human readable delimiter to separate buddy names in the config file.
  */
 var g_BuddyListDelimiter = ",";
 
 
 /**
  * Returns the nickname without the lobby rating.
  */
 function splitRatingFromNick(playerName)
 {
 	let result = /^(\S+)\ \((\d+)\)$/g.exec(playerName);
 	return { "nick": result ? result[1] : playerName, "rating": result ? +result[2] : "" };
 }
 
 /**
  * Array of playernames that the current user has marked as buddies.
  */
 var g_Buddies = Engine.ConfigDB_GetValue("user", "lobby.buddies").split(g_BuddyListDelimiter);
 
 /**
  * Denotes which players are a lobby buddy of the current user.
  */
 var g_BuddySymbol = '•';
 
 var g_MapPreviewPath = "session/icons/mappreview/";
 
 /**
  * Returns the biome specific mappreview image if it exists, or empty string otherwise.
  */
 function getBiomePreview(mapName, biomeName)
 {
 	let biomePreview = basename(mapName) + "_" + basename(biomeName) + ".png";
 
 	if (Engine.TextureExists("art/textures/ui/" + g_MapPreviewPath + biomePreview))
 		return biomePreview;
 
 	return "";
 }
 
 /**
  * Returns map description and preview image or placeholder.
  */
 function getMapDescriptionAndPreview(mapType, mapName, gameAttributes = undefined)
 {
 	let mapData;
 	if (mapType == "random" && mapName == "random")
 		mapData = { "settings": { "Description": translate("A randomly selected map.") } };
 	else if (mapType == "random" && Engine.FileExists(mapName + ".json"))
 		mapData = Engine.ReadJSONFile(mapName + ".json");
 	else if (Engine.FileExists(mapName + ".xml"))
 		mapData = Engine.LoadMapSettings(mapName + ".xml");
 
 	let biomePreview = getBiomePreview(mapName, gameAttributes && gameAttributes.settings.Biome || "");
 
 	return deepfreeze({
 		"description": mapData && mapData.settings && mapData.settings.Description ? translate(mapData.settings.Description) : translate("Sorry, no description available."),
 		"preview": biomePreview ? biomePreview :
 			mapData && mapData.settings && mapData.settings.Preview ? mapData.settings.Preview : "nopreview.png"
 	});
 }
 
 /**
  * Sets the mappreview image correctly.
  * It needs to be cropped as the engine only allows loading square textures.
  *
- * @param {string} guiObject
  * @param {string} filename
  */
-function setMapPreviewImage(guiObject, filename)
+function getMapPreviewImage(filename)
 {
-	Engine.GetGUIObjectByName(guiObject).sprite =
-		"cropped:" + 400 / 512 + "," + 300 / 512 + ":" +
+	return "cropped:" + 400 / 512 + "," + 300 / 512 + ":" +
 		g_MapPreviewPath + filename;
 }
 
 /**
  * Returns a formatted string describing the player assignments.
  * Needs g_CivData to translate!
  *
  * @param {object} playerDataArray - As known from gamesetup and simstate.
  * @param {(string[]|false)} playerStates - One of "won", "defeated", "active" for each player.
  * @returns {string}
  */
 function formatPlayerInfo(playerDataArray, playerStates)
 {
 	let playerDescriptions = {};
 	let playerIdx = 0;
 
 	for (let playerData of playerDataArray)
 	{
 		if (playerData == null || playerData.Civ && playerData.Civ == "gaia")
 			continue;
 
 		++playerIdx;
 		let teamIdx = playerData.Team;
 		let isAI = playerData.AI && playerData.AI != "";
 		let playerState = playerStates && playerStates[playerIdx] || playerData.State;
 		let isActive = !playerState || playerState == "active";
 
 		let playerDescription;
 		if (isAI)
 		{
 			if (playerData.Civ)
 			{
 				if (isActive)
 					// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 					playerDescription = translate("%(playerName)s (%(civ)s, %(AIdescription)s)");
 				else
 					// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 					playerDescription = translate("%(playerName)s (%(civ)s, %(AIdescription)s, %(state)s)");
 			}
 			else
 			{
 				if (isActive)
 					// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 					playerDescription = translate("%(playerName)s (%(AIdescription)s)");
 				else
 					// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 					playerDescription = translate("%(playerName)s (%(AIdescription)s, %(state)s)");
 			}
 		}
 		else
 		{
 			if (playerData.Offline)
 			{
 				// Can only occur in the lobby for now, so no strings with civ needed
 				if (isActive)
 					// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 					playerDescription = translate("%(playerName)s (OFFLINE)");
 				else
 					// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 					playerDescription = translate("%(playerName)s (OFFLINE, %(state)s)");
 			}
 			else
 			{
 				if (playerData.Civ)
 					if (isActive)
 						// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 						playerDescription = translate("%(playerName)s (%(civ)s)");
 					else
 						// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 						playerDescription = translate("%(playerName)s (%(civ)s, %(state)s)");
 				else
 					if (isActive)
 						// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 						playerDescription = translate("%(playerName)s");
 					else
 						// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
 						playerDescription = translate("%(playerName)s (%(state)s)");
 			}
 		}
 
 		// Sort player descriptions by team
 		if (!playerDescriptions[teamIdx])
 			playerDescriptions[teamIdx] = [];
 
 		let playerNick = splitRatingFromNick(playerData.Name).nick;
 		playerDescriptions[teamIdx].push(sprintf(playerDescription, {
 			"playerName":
 			coloredText(
 				(g_Buddies.indexOf(playerNick) != -1 ? g_BuddySymbol + " " : "") +
 				escapeText(playerData.Name),
 				(typeof getPlayerColor == 'function' ?
 					(isAI ? "white" : getPlayerColor(playerNick)) :
 					rgbToGuiColor(playerData.Color || g_Settings.PlayerDefaults[playerIdx].Color))),
 
 			"civ":
 				!playerData.Civ ?
 					translate("Unknown Civilization") :
 					g_CivData && g_CivData[playerData.Civ] && g_CivData[playerData.Civ].Name ?
 						translate(g_CivData[playerData.Civ].Name) :
 						playerData.Civ,
 
 			"state":
 				playerState == "defeated" ?
 					translateWithContext("playerstate", "defeated") :
 					translateWithContext("playerstate", "won"),
 
 			"AIdescription": translateAISettings(playerData)
 		}));
 	}
 
 	let teams = Object.keys(playerDescriptions);
 	if (teams.indexOf("observer") > -1)
 		teams.splice(teams.indexOf("observer"), 1);
 
 	let teamDescription = [];
 
 	// If there are no teams, merge all playersDescriptions
 	if (teams.length == 1)
 		teamDescription.push(playerDescriptions[teams[0]].join("\n"));
 
 	// If there are teams, merge "Team N:" + playerDescriptions
 	else
 		teamDescription = teams.map(team => {
 
 			let teamCaption = team == -1 ?
 				translate("No Team") :
 				sprintf(translate("Team %(team)s"), { "team": +team + 1 });
 
 			// Translation: Describe players of one team in a selected game, f.e. in the replay- or savegame menu or lobby
 			return sprintf(translate("%(team)s:\n%(playerDescriptions)s"), {
 				"team": '[font="sans-bold-14"]' + teamCaption + "[/font]",
 				"playerDescriptions": playerDescriptions[team].join("\n")
 			});
 		});
 
 	if (playerDescriptions.observer)
 		teamDescription.push(sprintf(translate("%(team)s:\n%(playerDescriptions)s"), {
 			"team": '[font="sans-bold-14"]' + translatePlural("Observer", "Observers", playerDescriptions.observer.length) + "[/font]",
 			"playerDescriptions": playerDescriptions.observer.join("\n")
 		}));
 
 	return teamDescription.join("\n\n");
 }
 
 /**
  * Sets an additional map label, map preview image and describes the chosen gamesettings more closely.
  *
  * Requires g_GameAttributes and g_VictoryConditions.
  */
 function getGameDescription()
 {
 	let titles = [];
 	if (!g_GameAttributes.settings.VictoryConditions.length)
 		titles.push({
 			"label": translateWithContext("victory condition", "Endless Game"),
 			"value": translate("No winner will be determined, even if everyone is defeated.")
 		});
 
 	for (let victoryCondition of g_VictoryConditions)
 	{
 		if (g_GameAttributes.settings.VictoryConditions.indexOf(victoryCondition.Name) == -1)
 			continue;
 
 		let title = translateVictoryCondition(victoryCondition.Name);
 		if (victoryCondition.Name == "wonder")
 			title = sprintf(
 				translatePluralWithContext(
 					"victory condition",
 					"Wonder (%(min)s minute)",
 					"Wonder (%(min)s minutes)",
 					g_GameAttributes.settings.WonderDuration
 				),
 				{ "min": g_GameAttributes.settings.WonderDuration }
 			);
 
 		let isCaptureTheRelic = victoryCondition.Name == "capture_the_relic";
 		if (isCaptureTheRelic)
 			title = sprintf(
 				translatePluralWithContext(
 					"victory condition",
 					"Capture the Relic (%(min)s minute)",
 					"Capture the Relic (%(min)s minutes)",
 					g_GameAttributes.settings.RelicDuration
 				),
 				{ "min": g_GameAttributes.settings.RelicDuration }
 			);
 
 		titles.push({
 			"label": title,
 			"value": victoryCondition.Description
 		});
 
 		if (isCaptureTheRelic)
 			titles.push({
 				"label": translate("Relic Count"),
 				"value": g_GameAttributes.settings.RelicCount
 			});
 
 		if (victoryCondition.Name == "regicide")
 			if (g_GameAttributes.settings.RegicideGarrison)
 				titles.push({
 					"label": translate("Hero Garrison"),
 					"value": translate("Heroes can be garrisoned.")
 				});
 			else
 				titles.push({
 					"label": translate("Exposed Heroes"),
 					"value": translate("Heroes cannot be garrisoned and they are vulnerable to raids.")
 				});
 	}
 
 	if (g_GameAttributes.settings.RatingEnabled &&
 	    g_GameAttributes.settings.PlayerData.length == 2)
 		titles.push({
 			"label": translate("Rated game"),
 			"value": translate("When the winner of this match is determined, the lobby score will be adapted.")
 		});
 
 	if (g_GameAttributes.settings.LockTeams)
 		titles.push({
 			"label": translate("Locked Teams"),
 			"value": translate("Players can't change the initial teams.")
 		});
 	else
 		titles.push({
 			"label": translate("Diplomacy"),
 			"value": translate("Players can make alliances and declare war on allies.")
 		});
 
 	if (g_GameAttributes.settings.LastManStanding)
 		titles.push({
 			"label": translate("Last Man Standing"),
 			"value": translate("Only one player can win the game. If the remaining players are allies, the game continues until only one remains.")
 		});
 	else
 		titles.push({
 			"label": translate("Allied Victory"),
 			"value": translate("If one player wins, his or her allies win too. If one group of allies remains, they win.")
 		});
 
 	titles.push({
 		"label": translate("Ceasefire"),
 		"value":
 			g_GameAttributes.settings.Ceasefire == 0 ?
 				translate("disabled") :
 				sprintf(translatePlural(
 					"For the first minute, other players will stay neutral.",
 					"For the first %(min)s minutes, other players will stay neutral.",
 					g_GameAttributes.settings.Ceasefire),
 				{ "min": g_GameAttributes.settings.Ceasefire })
 	});
 
 	if (g_GameAttributes.map == "random")
 		titles.push({
 			"label": translateWithContext("Map Selection", "Random Map"),
 			"value": translate("Randomly select a map from the list.")
 		});
 	else
 	{
 		titles.push({
 			"label": translate("Map Name"),
 			"value": translate(g_GameAttributes.settings.Name)
 		});
 		titles.push({
 			"label": translate("Map Description"),
 			"value": g_GameAttributes.settings.Description ?
 					translate(g_GameAttributes.settings.Description) :
 					translate("Sorry, no description available.")
 		});
 	}
 
 	titles.push({
 		"label": translate("Map Type"),
 		"value": g_MapTypes.Title[g_MapTypes.Name.indexOf(g_GameAttributes.mapType)]
 	});
 
 	if (typeof g_MapFilterList !== "undefined")
 		titles.push({
 			"label": translate("Map Filter"),
 			"value": g_MapFilterList.name[g_MapFilterList.id.findIndex(id => id == g_GameAttributes.mapFilter)]
 		});
 
 	if (g_GameAttributes.mapType == "random")
 	{
 		let mapSize = g_MapSizes.Name[g_MapSizes.Tiles.indexOf(g_GameAttributes.settings.Size)];
 		if (mapSize)
 			titles.push({
 				"label": translate("Map Size"),
 				"value": mapSize
 			});
 	}
 
 	if (g_GameAttributes.settings.Biome)
 	{
 		let biome = g_Settings.Biomes.find(b => b.Id == g_GameAttributes.settings.Biome);
 		titles.push({
 			"label": biome ? biome.Title : translateWithContext("biome", "Random Biome"),
 			"value": biome ? biome.Description : translate("Randomly select a biome from the list.")
 		});
 	}
 
 	if (g_GameAttributes.settings.TriggerDifficulty !== undefined)
 	{
 		let triggerDifficulty = g_Settings.TriggerDifficulties.find(difficulty => difficulty.Difficulty == g_GameAttributes.settings.TriggerDifficulty);
 		titles.push({
 			"label": triggerDifficulty.Title,
 			"value": triggerDifficulty.Tooltip
 		});
 	}
 
 	titles.push({
 		"label": g_GameAttributes.settings.Nomad ? translate("Nomad Mode") : translate("Civic Centers"),
 		"value":
 			g_GameAttributes.settings.Nomad ?
 				translate("Players start with only few units and have to find a suitable place to build their city.") :
 				translate("Players start with a Civic Center.")
 	});
 
 	titles.push({
 		"label": translate("Starting Resources"),
 		"value": sprintf(translate("%(startingResourcesTitle)s (%(amount)s)"), {
 			"startingResourcesTitle":
 				g_StartingResources.Title[
 					g_StartingResources.Resources.indexOf(
 						g_GameAttributes.settings.StartingResources)],
 			"amount": g_GameAttributes.settings.StartingResources
 		})
 	});
 
 	titles.push({
 		"label": translate("Population Limit"),
 		"value":
 			g_PopulationCapacities.Title[
 				g_PopulationCapacities.Population.indexOf(
 					g_GameAttributes.settings.PopulationCap)]
 	});
 
 	titles.push({
 		"label": translate("Treasures"),
 		"value": g_GameAttributes.settings.DisableTreasures ?
 			translateWithContext("treasures", "Disabled") :
 			translateWithContext("treasures", "As defined by the map.")
 	});
 
 	titles.push({
 		"label": translate("Revealed Map"),
 		"value": g_GameAttributes.settings.RevealMap
 	});
 
 	titles.push({
 		"label": translate("Explored Map"),
 		"value": g_GameAttributes.settings.ExploreMap
 	});
 
 	titles.push({
 		"label": translate("Cheats"),
 		"value": g_GameAttributes.settings.CheatsEnabled
 	});
 
 	return titles.map(title => sprintf(translate("%(label)s %(details)s"), {
 		"label": coloredText(title.label, g_DescriptionHighlight),
 		"details":
 			title.value === true ? translateWithContext("gamesetup option", "enabled") :
 				title.value || translateWithContext("gamesetup option", "disabled")
 	})).join("\n");
 }
 
 /**
  * Sets the win/defeat icon to indicate current player's state.
  * @param {string} state - The current in-game state of the player.
  * @param {string} imageID - The name of the XML image object to update.
  */
 function setOutcomeIcon(state, imageID)
 {
 	let image = Engine.GetGUIObjectByName(imageID);
 
 	if (state == "won")
 	{
 		image.sprite = "stretched:session/icons/victory.png";
 		image.tooltip = translate("Victorious");
 	}
 	else if (state == "defeated")
 	{
 		image.sprite = "stretched:session/icons/defeat.png";
 		image.tooltip = translate("Defeated");
 	}
 }
 
 function translateAISettings(playerData)
 {
 	if (!playerData.AI)
 		return "";
 
 	return sprintf(translate("%(AIdifficulty)s %(AIbehavior)s %(AIname)s"), {
 		"AIname": translateAIName(playerData.AI),
 		"AIdifficulty": translateAIDifficulty(playerData.AIDiff),
 		"AIbehavior": translateAIBehavior(playerData.AIBehavior),
 	});
 }
Index: ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js	(revision 22825)
+++ ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js	(revision 22826)
@@ -1,2781 +1,2766 @@
 const g_MatchSettings_SP = "config/matchsettings.json";
 const g_MatchSettings_MP = "config/matchsettings.mp.json";
 
 const g_Ceasefire = prepareForDropdown(g_Settings && g_Settings.Ceasefire);
 const g_MapSizes = prepareForDropdown(g_Settings && g_Settings.MapSizes);
 const g_MapTypes = prepareForDropdown(g_Settings && g_Settings.MapTypes);
 const g_TriggerDifficulties = prepareForDropdown(g_Settings && g_Settings.TriggerDifficulties);
 const g_PopulationCapacities = prepareForDropdown(g_Settings && g_Settings.PopulationCapacities);
 const g_StartingResources = prepareForDropdown(g_Settings && g_Settings.StartingResources);
 const g_VictoryDurations = prepareForDropdown(g_Settings && g_Settings.VictoryDurations);
 const g_VictoryConditions = g_Settings && g_Settings.VictoryConditions;
 
 var g_GameSpeeds = getGameSpeedChoices(false);
 
 /**
  * Offer users to select playable civs only.
  * Load unselectable civs as they could appear in scenario maps.
  */
 const g_CivData = loadCivData(false, false);
 
 /**
  * Store civilization code and page (structree or history) opened in civilization info.
  */
 var g_CivInfo = {
 	"civ": "",
 	"page": "page_civinfo.xml"
 };
 
 /**
  * Highlight the "random" dropdownlist item.
  */
 var g_ColorRandom = "orange";
 
 /**
  * Color for regular dropdownlist items.
  */
 var g_ColorRegular = "white";
 
 /**
  * Color for "Unassigned"-placeholder item in the dropdownlist.
  */
 var g_PlayerAssignmentColors = {
 	"player": g_ColorRegular,
 	"observer": "170 170 250",
 	"unassigned": "140 140 140",
 	"AI": "70 150 70"
 };
 
 /**
  * Used for highlighting the sender of chat messages.
  */
 var g_SenderFont = "sans-bold-13";
 
 /**
  * This yields [1, 2, ..., MaxPlayers].
  */
 var g_NumPlayersList = Array(g_MaxPlayers).fill(0).map((v, i) => i + 1);
 
 /**
  * Used for generating the botnames.
  */
 var g_RomanNumbers = [undefined, "I", "II", "III", "IV", "V", "VI", "VII", "VIII"];
 
 var g_PlayerTeamList = prepareForDropdown([{
 		"label": translateWithContext("team", "None"),
 		"id": -1
 	}].concat(
 		Array(g_MaxTeams).fill(0).map((v, i) => ({
 			"label": i + 1,
 			"id": i
 		}))
 	)
 );
 
 /**
  * Number of relics: [1, ..., NumCivs]
  */
 var g_RelicCountList = Object.keys(g_CivData).map((civ, i) => i + 1);
 
 var g_PlayerCivList = g_CivData && prepareForDropdown([{
 		"name": translateWithContext("civilization", "Random"),
 		"tooltip": translate("Picks one civilization at random when the game starts."),
 		"color": g_ColorRandom,
 		"code": "random"
 	}].concat(
 		Object.keys(g_CivData).filter(
 			civ => g_CivData[civ].SelectableInGameSetup
 		).map(civ => ({
 			"name": g_CivData[civ].Name,
 			"tooltip": g_CivData[civ].History,
 			"color": g_ColorRegular,
 			"code": civ
 		})).sort(sortNameIgnoreCase)
 	)
 );
 
 /**
  * All selectable playercolors except gaia.
  */
 var g_PlayerColorPickerList = g_Settings && g_Settings.PlayerDefaults.slice(1).map(pData => pData.Color);
 
 /**
  * Directory containing all maps of the given type.
  */
 var g_MapPath = {
 	"random": "maps/random/",
 	"scenario": "maps/scenarios/",
 	"skirmish": "maps/skirmishes/"
 };
 
 /**
  * Containing the colors to highlight the ready status of players,
  * the chat ready messages and
  * the tooltips and captions for the ready button
  */
 
 var g_ReadyData = [
 	{
 		"color": g_ColorRegular,
 		"chat": translate("* %(username)s is not ready."),
 		"caption": translate("I'm ready"),
 		"tooltip": translate("State that you are ready to play.")
 	},
 	{
 		"color": "green",
 		"chat": translate("* %(username)s is ready!"),
 		"caption": translate("Stay ready"),
 		"tooltip": translate("Stay ready even when the game settings change.")
 	},
 	{
 		"color": "150 150 250",
 		"chat": "",
 		"caption": translate("I'm not ready!"),
 		"tooltip": translate("State that you are not ready to play.")
 	}
 ];
 
 /**
  * Processes a CNetMessage (see NetMessage.h, NetMessages.h) sent by the CNetServer.
  */
 var g_NetMessageTypes = {
 	"netstatus": msg => handleNetStatusMessage(msg),
 	"netwarn": msg => addNetworkWarning(msg),
 	"gamesetup": msg => handleGamesetupMessage(msg),
 	"players": msg => handlePlayerAssignmentMessage(msg),
 	"ready": msg => handleReadyMessage(msg),
 	"start": msg => handleGamestartMessage(msg),
 	"kicked": msg => addChatMessage({
 		"type": msg.banned ? "banned" : "kicked",
 		"username": msg.username
 	}),
 	"chat": msg => addChatMessage({ "type": "chat", "guid": msg.guid, "text": msg.text }),
 };
 
 var g_FormatChatMessage = {
 	"system": (msg, user) => systemMessage(msg.text),
 	"settings": (msg, user) => systemMessage(translate('Game settings have been changed')),
 	"connect": (msg, user) => systemMessage(sprintf(translate("%(username)s has joined"), { "username": user })),
 	"disconnect": (msg, user) => systemMessage(sprintf(translate("%(username)s has left"), { "username": user })),
 	"kicked": (msg, user) => systemMessage(sprintf(translate("%(username)s has been kicked"), { "username": user })),
 	"banned": (msg, user) => systemMessage(sprintf(translate("%(username)s has been banned"), { "username": user })),
 	"chat": (msg, user) => sprintf(translate("%(username)s %(message)s"), {
 		"username": senderFont(sprintf(translate("<%(username)s>"), { "username": user })),
 		"message": escapeText(msg.text || "")
 	}),
 	"ready": (msg, user) => sprintf(g_ReadyData[msg.status].chat, { "username": user }),
 	"clientlist": (msg, user) => getUsernameList(),
 };
 
 var g_MapFilters = [
 	{
 		"id": "default",
 		"name": translateWithContext("map filter", "Default"),
 		"tooltip": translateWithContext("map filter", "All maps except naval and demo maps."),
 		"filter": mapKeywords => mapKeywords.every(keyword => ["naval", "demo", "hidden"].indexOf(keyword) == -1),
 		"Default": true
 	},
 	{
 		"id": "naval",
 		"name": translate("Naval Maps"),
 		"tooltip": translateWithContext("map filter", "Maps where ships are needed to reach the enemy."),
 		"filter": mapKeywords => mapKeywords.indexOf("naval") != -1
 	},
 	{
 		"id": "demo",
 		"name": translate("Demo Maps"),
 		"tooltip": translateWithContext("map filter", "These maps are not playable but for demonstration purposes only."),
 		"filter": mapKeywords => mapKeywords.indexOf("demo") != -1
 	},
 	{
 		"id": "new",
 		"name": translate("New Maps"),
 		"tooltip": translateWithContext("map filter", "Maps that are brand new in this release of the game."),
 		"filter": mapKeywords => mapKeywords.indexOf("new") != -1
 	},
 	{
 		"id": "trigger",
 		"name": translate("Trigger Maps"),
 		"tooltip": translateWithContext("map filter", "Maps that come with scripted events and potentially spawn enemy units."),
 		"filter": mapKeywords => mapKeywords.indexOf("trigger") != -1
 	},
 	{
 		"id": "all",
 		"name": translate("All Maps"),
 		"tooltip": translateWithContext("map filter", "Every map of the chosen maptype."),
 		"filter": mapKeywords => true
 	},
 ];
 
 /**
  * This contains only filters that have at least one map matching them.
  */
 var g_MapFilterList;
 
 /**
  * Array of biome identifiers supported by the currently selected map.
  */
 var g_BiomeList;
 
 /**
  * Array of trigger difficulties identifiers supported by the currently selected map.
  */
 var g_TriggerDifficultyList;
 
 /**
  * Whether this is a single- or multiplayer match.
  */
 const g_IsNetworked = Engine.HasNetClient();
 
 /**
  * Is this user in control of game settings (i.e. is a network server, or offline player).
  */
 const g_IsController = !g_IsNetworked || Engine.HasNetServer();
 
 /**
  * Whether this is a tutorial.
  */
 var g_IsTutorial;
 
 /**
  * To report the game to the lobby bot.
  */
 var g_ServerName;
 var g_ServerPort;
 
 /**
  * IP address and port of the STUN endpoint.
  */
 var g_StunEndpoint;
 
 /**
  * States whether the GUI is currently updated in response to network messages instead of user input
  * and therefore shouldn't send further messages to the network.
  */
 var g_IsInGuiUpdate = false;
 
 /**
  * Whether the current player is ready to start the game.
  * 0 - not ready
  * 1 - ready
  * 2 - stay ready
  */
 var g_IsReady = 0;
 
 /**
  * Ignore duplicate ready commands on init.
  */
 var g_ReadyInit = true;
 
 /**
  * If noone has changed the ready status, we have no need to spam the settings changed message.
  *
  * <=0 - Suppressed settings message
  * 1 - Will show settings message
  * 2 - Host's initial ready, suppressed settings message
  */
 var g_ReadyChanged = 2;
 
 /**
  * Used to prevent calling resetReadyData when starting a game or doubleclicking on the "Start Game" button.
  */
 var g_GameStarted = false;
 
 /**
  * Selectable options (player, AI, unassigned) in the player assignment dropdowns and
  * their colorized, textual representation.
  */
 var g_PlayerAssignmentList = {};
 
 /**
  * Remembers which clients are assigned to which player slots and whether they are ready.
  * The keys are guids or "local" in Singleplayer.
  */
 var g_PlayerAssignments = {};
 
 var g_DefaultPlayerData = [];
 
 var g_GameAttributes = { "settings": {} };
 
 /**
  * List of translated words that can be used to autocomplete titles of settings
  * and their values (for example playernames).
  */
 var g_Autocomplete = [];
 
 /**
  * Array of strings formatted as displayed, including playername.
  */
 var g_ChatMessages = [];
 
 /**
  * Minimum amount of pixels required for the chat panel to be visible.
  */
 var g_MinChatWidth = 96;
 
 /**
  * Horizontal space between chat window and settings.
  */
 var g_ChatSettingsMargin = 10;
 
 /**
  * Filename and translated title of all maps, given the currently selected
  * maptype and filter. Sorted by title, shown in the dropdown.
  */
 var g_MapSelectionList = [];
 
 /**
  * Cache containing the mapsettings. Just-in-time loading.
  */
 var g_MapData = {};
 
 /**
  * Wait one tick before initializing the GUI objects and
  * don't process netmessages prior to that.
  */
 var g_LoadingState = 0;
 
 /**
  * Send the current gamesettings to the lobby bot if the settings didn't change for this number of seconds.
  */
 var g_GameStanzaTimeout = 2;
 
 /**
  * Index of the GUI timer.
  */
 var g_GameStanzaTimer;
 
 /**
  * Only send a lobby update if something actually changed.
  */
 var g_LastGameStanza;
 
 /**
  * Remembers if the current player viewed the AI settings of some playerslot.
  */
 var g_LastViewedAIPlayer = -1;
 
 /**
  * Total number of units that the engine can run with smoothly.
  * It means a 4v4 with 150 population can still run nicely, but more than that might "lag".
  */
 var g_PopulationCapacityRecommendation = 1200;
 
 /**
  * Horizontal space between tab buttons and lobby button.
  */
 var g_LobbyButtonSpacing = 8;
 
 /**
  * Vertical size of a tab button.
  */
 var g_TabButtonHeight = 30;
 
 /**
  * Vertical space between two tab buttons.
  */
 var g_TabButtonDist = 4;
 
 /**
  * Vertical size of a setting object.
  */
 var g_SettingHeight = 32;
 
 /**
  * Vertical space between two setting objects.
  */
 var g_SettingDist = 2;
 
 /**
  * Maximum width of a column in the settings panel.
  */
 var g_MaxColumnWidth = 470;
 
 /**
  * Pixels per millisecond the settings panel slides when opening/closing.
  */
 var g_SlideSpeed = 1.2;
 
 /**
  * Store last tick time.
  */
 var g_LastTickTime = Date.now();
 
 /**
  * Order in which the GUI elements will be shown.
  * All valid settings are required to appear here.
  */
 var g_SettingsTabsGUI = [
 	{
 		"label": translateWithContext("Match settings tab name", "Map"),
 		"settings": [
 			"mapType",
 			"mapFilter",
 			"mapSelection",
 			"mapSize",
 			"biome",
 			"triggerDifficulty",
 			"nomad",
 			"disableTreasures",
 			"exploreMap",
 			"revealMap"
 		]
 	},
 	{
 		"label": translateWithContext("Match settings tab name", "Player"),
 		"settings": [
 			"numPlayers",
 			"populationCap",
 			"startingResources",
 			"disableSpies",
 			"enableCheats"
 		]
 	},
 	{
 		"label": translateWithContext("Match settings tab name", "Game Type"),
 		"settings": [
 			...g_VictoryConditions.map(victoryCondition => victoryCondition.Name),
 			"relicCount",
 			"relicDuration",
 			"wonderDuration",
 			"regicideGarrison",
 			"gameSpeed",
 			"ceasefire",
 			"lockTeams",
 			"lastManStanding",
 			"enableRating"
 		]
 	}
 ];
 
 /**
  * Contains the logic of all multiple-choice gamesettings.
  *
  * Logic
  * ids     - Array of identifier strings that indicate the selected value.
  * default - Returns the index of the default value (not the value itself).
  * defined - Whether a value for the setting is actually specified.
  * get     - The identifier of the currently selected value.
  * select  - Saves and processes the value of the selected index of the ids array.
  *
  * GUI
  * title        - The caption shown in the label.
  * tooltip      - A description shown when hovering the dropdown or a specific item.
  * labels       - Array of translated strings selectable for this dropdown.
  * colors       - Optional array of colors to tint the according dropdown items with.
  * hidden       - If hidden, both the label and dropdown won't be visible. (default: false)
  * enabled      - Only the label will be shown if the setting is disabled. (default: true)
  * autocomplete - Marks whether to autocomplete translated values of the string. (default: undefined)
  *                If not undefined, must be a number that denotes the priority (higher numbers come first).
  *                If undefined, still autocompletes the translated title of the setting.
  * initOrder    - Settings with lower values will be initialized first.
  */
 var g_Dropdowns = {
 	"mapType": {
 		"title": () => translate("Map Type"),
 		"tooltip": (hoverIdx) => g_MapTypes.Description[hoverIdx] || translate("Select a map type."),
 		"labels": () => g_MapTypes.Title,
 		"ids": () => g_MapTypes.Name,
 		"default": () => g_MapTypes.Default,
 		"defined": () => g_GameAttributes.mapType !== undefined,
 		"get": () => g_GameAttributes.mapType,
 		"select": (itemIdx) => {
 			g_MapData = {};
 			g_GameAttributes.mapType = g_MapTypes.Name[itemIdx];
 			g_GameAttributes.mapPath = g_MapPath[g_GameAttributes.mapType];
 			delete g_GameAttributes.map;
 
 			if (g_GameAttributes.mapType != "scenario")
 				g_GameAttributes.settings = {
 					"PlayerData": clone(g_DefaultPlayerData.slice(0, 4))
 				};
 
 			reloadMapFilterList();
 		},
 		"autocomplete": 0,
 		"initOrder": 1
 	},
 	"mapFilter": {
 		"title": () => translate("Map Filter"),
 		"tooltip": (hoverIdx) => g_MapFilterList.tooltip[hoverIdx] || translate("Select a map filter."),
 		"labels": () => g_MapFilterList.name,
 		"ids": () => g_MapFilterList.id,
 		"default": () => g_MapFilterList.Default,
 		"defined": () => g_MapFilterList.id.indexOf(g_GameAttributes.mapFilter || "") != -1,
 		"get": () => g_GameAttributes.mapFilter,
 		"select": (itemIdx) => {
 			g_GameAttributes.mapFilter = g_MapFilterList.id[itemIdx];
 			delete g_GameAttributes.map;
 			reloadMapList();
 		},
 		"autocomplete": 0,
 		"initOrder": 2
 	},
 	"mapSelection": {
 		"title": () => translate("Select Map"),
 		"tooltip": (hoverIdx) => g_MapSelectionList.description[hoverIdx] || translate("Select a map to play on."),
 		"labels": () => g_MapSelectionList.name,
 		"colors": () => g_MapSelectionList.color,
 		"ids": () => g_MapSelectionList.file,
 		"default": () => 0,
 		"defined": () => g_GameAttributes.map !== undefined,
 		"get": () => g_GameAttributes.map,
 		"select": (itemIdx) => {
 			selectMap(g_MapSelectionList.file[itemIdx]);
 		},
 		"autocomplete": 0,
 		"initOrder": 3
 	},
 	"mapSize": {
 		"title": () => translate("Map Size"),
 		"tooltip": (hoverIdx) => g_MapSizes.Tooltip[hoverIdx] || translate("Select map size. (Larger sizes may reduce performance.)"),
 		"labels": () => g_MapSizes.Name,
 		"ids": () => g_MapSizes.Tiles,
 		"default": () => g_MapSizes.Default,
 		"defined": () => g_GameAttributes.settings.Size !== undefined,
 		"get": () => g_GameAttributes.settings.Size,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.Size = g_MapSizes.Tiles[itemIdx];
 		},
 		"hidden": () => g_GameAttributes.mapType != "random",
 		"autocomplete": 0,
 		"initOrder": 1000
 	},
 	"biome": {
 		"title": () => translate("Biome"),
 		"tooltip": (hoverIdx) => g_BiomeList && g_BiomeList.Description && g_BiomeList.Description[hoverIdx] || translate("Select the flora and fauna."),
 		"labels": () => g_BiomeList ? g_BiomeList.Title : [],
 		"colors": (itemIdx) => g_BiomeList ? g_BiomeList.Color : [],
 		"ids": () => g_BiomeList ? g_BiomeList.Id : [],
 		"default": () => 0,
 		"defined": () => g_GameAttributes.settings.Biome !== undefined,
 		"get": () => g_GameAttributes.settings.Biome,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.Biome = g_BiomeList && g_BiomeList.Id[itemIdx];
 		},
 		"hidden": () => !g_BiomeList,
 		"autocomplete": 0,
 		"initOrder": 1000
 	},
 	"numPlayers": {
 		"title": () => translate("Number of Players"),
 		"tooltip": (hoverIdx) => translate("Select number of players."),
 		"labels": () => g_NumPlayersList,
 		"ids": () => g_NumPlayersList,
 		"default": () => g_MaxPlayers - 1,
 		"defined": () => g_GameAttributes.settings.PlayerData !== undefined,
 		"get": () => g_GameAttributes.settings.PlayerData.length,
 		"enabled": () => g_GameAttributes.mapType == "random",
 		"select": (itemIdx) => {
 			let num = itemIdx + 1;
 			let pData = g_GameAttributes.settings.PlayerData;
 			g_GameAttributes.settings.PlayerData =
 				num > pData.length ?
 					pData.concat(clone(g_DefaultPlayerData.slice(pData.length, num))) :
 					pData.slice(0, num);
 			unassignInvalidPlayers(num);
 			sanitizePlayerData(g_GameAttributes.settings.PlayerData);
 		},
 		"initOrder": 1000
 	},
 	"populationCap": {
 		"title": () => translate("Population Cap"),
 		"tooltip": (hoverIdx) => {
 
 			let popCap = g_PopulationCapacities.Population[hoverIdx];
 			let players = g_GameAttributes.settings.PlayerData.length;
 
 			if (hoverIdx == -1 || popCap * players <= g_PopulationCapacityRecommendation)
 				return translate("Select population limit.");
 
 			return coloredText(
 				sprintf(translate("Warning: There might be performance issues if all %(players)s players reach %(popCap)s population."), {
 					"players": players,
 					"popCap": popCap
 				}),
 				"orange");
 		},
 		"labels": () => g_PopulationCapacities.Title,
 		"ids": () => g_PopulationCapacities.Population,
 		"default": () => g_PopulationCapacities.Default,
 		"defined": () => g_GameAttributes.settings.PopulationCap !== undefined,
 		"get": () => g_GameAttributes.settings.PopulationCap,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.PopulationCap = g_PopulationCapacities.Population[itemIdx];
 		},
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 		"initOrder": 1000
 	},
 	"startingResources": {
 		"title": () => translate("Starting Resources"),
 		"tooltip": (hoverIdx) => {
 			return hoverIdx >= 0 ?
 				sprintf(translate("Initial amount of each resource: %(resources)s."), {
 					"resources": g_StartingResources.Resources[hoverIdx]
 				}) :
 				translate("Select the game's starting resources.");
 		},
 		"labels": () => g_StartingResources.Title,
 		"ids": () => g_StartingResources.Resources,
 		"default": () => g_StartingResources.Default,
 		"defined": () => g_GameAttributes.settings.StartingResources !== undefined,
 		"get": () => g_GameAttributes.settings.StartingResources,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.StartingResources = g_StartingResources.Resources[itemIdx];
 		},
 		"hidden": () => g_GameAttributes.mapType == "scenario",
 		"autocomplete": 0,
 		"initOrder": 1000
 	},
 	"ceasefire": {
 		"title": () => translate("Ceasefire"),
 		"tooltip": (hoverIdx) => translate("Set time where no attacks are possible."),
 		"labels": () => g_Ceasefire.Title,
 		"ids": () => g_Ceasefire.Duration,
 		"default": () => g_Ceasefire.Default,
 		"defined": () => g_GameAttributes.settings.Ceasefire !== undefined,
 		"get": () => g_GameAttributes.settings.Ceasefire,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.Ceasefire = g_Ceasefire.Duration[itemIdx];
 		},
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 		"initOrder": 1000
 	},
 	"relicCount": {
 		"title": () => translate("Relic Count"),
 		"tooltip": (hoverIdx) => translate("Total number of relics spawned on the map. Relic victory is most realistic with only one or two relics. With greater numbers, the relics are important to capture to receive aura bonuses."),
 		"labels": () => g_RelicCountList,
 		"ids": () => g_RelicCountList,
 		"default": () => g_RelicCountList.indexOf(2),
 		"defined": () => g_GameAttributes.settings.RelicCount !== undefined,
 		"get": () => g_GameAttributes.settings.RelicCount,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.RelicCount = g_RelicCountList[itemIdx];
 		},
 		"hidden": () => g_GameAttributes.settings.VictoryConditions.indexOf("capture_the_relic") == -1,
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 		"initOrder": 1000
 	},
 	"relicDuration": {
 		"title": () => translate("Relic Duration"),
 		"tooltip": (hoverIdx) => translate("Minutes until the player has achieved Relic Victory."),
 		"labels": () => g_VictoryDurations.Title,
 		"ids": () => g_VictoryDurations.Duration,
 		"default": () => g_VictoryDurations.Default,
 		"defined": () => g_GameAttributes.settings.RelicDuration !== undefined,
 		"get": () => g_GameAttributes.settings.RelicDuration,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.RelicDuration = g_VictoryDurations.Duration[itemIdx];
 		},
 		"hidden": () => g_GameAttributes.settings.VictoryConditions.indexOf("capture_the_relic") == -1,
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 		"initOrder": 1000
 	},
 	"wonderDuration": {
 		"title": () => translate("Wonder Duration"),
 		"tooltip": (hoverIdx) => translate("Minutes until the player has achieved Wonder Victory."),
 		"labels": () => g_VictoryDurations.Title,
 		"ids": () => g_VictoryDurations.Duration,
 		"default": () => g_VictoryDurations.Default,
 		"defined": () => g_GameAttributes.settings.WonderDuration !== undefined,
 		"get": () => g_GameAttributes.settings.WonderDuration,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.WonderDuration = g_VictoryDurations.Duration[itemIdx];
 		},
 		"hidden": () => g_GameAttributes.settings.VictoryConditions.indexOf("wonder") == -1,
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 		"initOrder": 1000
 	},
 	"gameSpeed": {
 		"title": () => translate("Game Speed"),
 		"tooltip": (hoverIdx) => translate("Select game speed."),
 		"labels": () => g_GameSpeeds.Title,
 		"ids": () => g_GameSpeeds.Speed,
 		"default": () => g_GameSpeeds.Default,
 		"defined": () =>
 			g_GameAttributes.gameSpeed !== undefined &&
 			g_GameSpeeds.Speed.indexOf(g_GameAttributes.gameSpeed) != -1,
 		"get": () => g_GameAttributes.gameSpeed,
 		"select": (itemIdx) => {
 			g_GameAttributes.gameSpeed = g_GameSpeeds.Speed[itemIdx];
 		},
 		"initOrder": 1000
 	},
 	"triggerDifficulty": {
 		"title": () => translate("Difficulty"),
 		"tooltip": (hoverIdx) => g_TriggerDifficultyList && g_TriggerDifficultyList.Description[hoverIdx] ||
 			translate("Select the difficulty of this scenario."),
 		"labels": () => g_TriggerDifficultyList ? g_TriggerDifficultyList.Title : [],
 		"ids": () => g_TriggerDifficultyList ? g_TriggerDifficultyList.Id : [],
 		"default": () => g_TriggerDifficultyList ? g_TriggerDifficultyList.Default : 0,
 		"defined": () => g_GameAttributes.settings.TriggerDifficulty !== undefined,
 		"get": () => g_GameAttributes.settings.TriggerDifficulty,
 		"select": (itemIdx) => {
 			g_GameAttributes.settings.TriggerDifficulty = g_TriggerDifficultyList && g_TriggerDifficultyList.Id[itemIdx];
 		},
 		"hidden": () => !g_TriggerDifficultyList,
 		"initOrder": 1000
 	},
 };
 
 /**
  * These dropdowns provide a setting that is repeated once for each player
  * (where playerIdx is starting from 0 for player 1).
  */
 var g_PlayerDropdowns = {
 	"playerAssignment": {
 		"tooltip": (playerIdx) => translate("Select player."),
 		"labels": (playerIdx) => g_PlayerAssignmentList.Name || [],
 		"colors": (playerIdx) => g_PlayerAssignmentList.Color || [],
 		"ids": (playerIdx) => g_PlayerAssignmentList.Choice || [],
 		"default": (playerIdx) => "ai:petra",
 		"defined": (playerIdx) => playerIdx < g_GameAttributes.settings.PlayerData.length,
 		"get": (playerIdx) => {
 			for (let guid in g_PlayerAssignments)
 				if (g_PlayerAssignments[guid].player == playerIdx + 1)
 					return "guid:" + guid;
 
 			for (let ai of g_Settings.AIDescriptions)
 				if (g_GameAttributes.settings.PlayerData[playerIdx].AI == ai.id)
 					return "ai:" + ai.id;
 
 			return "unassigned";
 		},
 		"select": (selectedIdx, playerIdx) => {
 
 			let choice = g_PlayerAssignmentList.Choice[selectedIdx];
 			if (choice == "unassigned" || choice.startsWith("ai:"))
 			{
 				if (g_IsNetworked)
 					Engine.AssignNetworkPlayer(playerIdx+1, "");
 				else if (g_PlayerAssignments.local.player == playerIdx+1)
 					g_PlayerAssignments.local.player = -1;
 
 				g_GameAttributes.settings.PlayerData[playerIdx].AI = choice.startsWith("ai:") ? choice.substr(3) : "";
 			}
 			else
 				swapPlayers(choice.substr("guid:".length), playerIdx);
 		},
 		"autocomplete": 100,
 	},
 	"playerTeam": {
 		"tooltip": (playerIdx) => translate("Select player's team."),
 		"labels": (playerIdx) => g_PlayerTeamList.label,
 		"ids": (playerIdx) => g_PlayerTeamList.id,
 		"default": (playerIdx) => 0,
 		"defined": (playerIdx) => g_GameAttributes.settings.PlayerData[playerIdx].Team !== undefined,
 		"get": (playerIdx) => g_GameAttributes.settings.PlayerData[playerIdx].Team,
 		"select": (selectedIdx, playerIdx) => {
 			g_GameAttributes.settings.PlayerData[playerIdx].Team = selectedIdx - 1;
 		},
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 	},
 	"playerCiv": {
 		"tooltip": (hoverIdx, playerIdx) => g_PlayerCivList.tooltip[hoverIdx] || translate("Choose the civilization for this player."),
 		"labels": (playerIdx) => g_PlayerCivList.name,
 		"colors": (playerIdx) => g_PlayerCivList.color,
 		"ids": (playerIdx) => g_PlayerCivList.code,
 		"default": (playerIdx) => 0,
 		"defined": (playerIdx) => g_GameAttributes.settings.PlayerData[playerIdx].Civ !== undefined,
 		"get": (playerIdx) => g_GameAttributes.settings.PlayerData[playerIdx].Civ,
 		"select": (selectedIdx, playerIdx) => {
 			g_GameAttributes.settings.PlayerData[playerIdx].Civ = g_PlayerCivList.code[selectedIdx];
 		},
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 		"autocomplete": 90,
 	},
 	"playerColorPicker": {
 		"tooltip": (playerIdx) => translate("Pick a color."),
 		"labels": (playerIdx) => g_PlayerColorPickerList.map(color => "■"),
 		"colors": (playerIdx) => g_PlayerColorPickerList.map(color => rgbToGuiColor(color)),
 		"ids": (playerIdx) => g_PlayerColorPickerList.map((color, index) => index),
 		"default": (playerIdx) => playerIdx,
 		"defined": (playerIdx) => g_GameAttributes.settings.PlayerData[playerIdx].Color !== undefined,
 		"get": (playerIdx) => g_PlayerColorPickerList.indexOf(g_GameAttributes.settings.PlayerData[playerIdx].Color),
 		"select": (selectedIdx, playerIdx) => {
 			let playerData = g_GameAttributes.settings.PlayerData;
 
 			// If someone else has that color, give that player the old color
 			let sameColorPData = playerData.find(pData => sameColor(g_PlayerColorPickerList[selectedIdx], pData.Color));
 			if (sameColorPData)
 				sameColorPData.Color = playerData[playerIdx].Color;
 
 			playerData[playerIdx].Color = g_PlayerColorPickerList[selectedIdx];
 			ensureUniquePlayerColors(playerData);
 		},
 		"enabled": () => g_GameAttributes.mapType != "scenario",
 	},
 };
 
 /**
  * Contains the logic of all boolean gamesettings.
  */
 var g_Checkboxes = Object.assign(
 	{},
 	g_VictoryConditions.reduce((obj, victoryCondition) => {
 		obj[victoryCondition.Name] = {
 			"title": () => victoryCondition.Title,
 			"tooltip": () => victoryCondition.Description,
 			// Defaults are set in supplementDefault directly from g_VictoryConditions since we use an array
 			"defined": () => true,
 			"get": () => g_GameAttributes.settings.VictoryConditions.indexOf(victoryCondition.Name) != -1,
 			"set": checked => {
 				if (checked)
 				{
 					g_GameAttributes.settings.VictoryConditions.push(victoryCondition.Name);
 					if (victoryCondition.ChangeOnChecked)
 						for (let setting in victoryCondition.ChangeOnChecked)
 							g_Checkboxes[setting].set(victoryCondition.ChangeOnChecked[setting]);
 				}
 				else
 					g_GameAttributes.settings.VictoryConditions = g_GameAttributes.settings.VictoryConditions.filter(victoryConditionName => victoryConditionName != victoryCondition.Name);
 			},
 			"enabled": () =>
 				g_GameAttributes.mapType != "scenario" &&
 				(!victoryCondition.DisabledWhenChecked ||
 				victoryCondition.DisabledWhenChecked.every(victoryConditionName => g_GameAttributes.settings.VictoryConditions.indexOf(victoryConditionName) == -1))
 		};
 		return obj;
 	}, {}),
 	{
 		"regicideGarrison": {
 			"title": () => translate("Hero Garrison"),
 			"tooltip": () => translate("Toggle whether heroes can be garrisoned."),
 			"default": () => false,
 			"defined": () => g_GameAttributes.settings.RegicideGarrison !== undefined,
 			"get": () => g_GameAttributes.settings.RegicideGarrison,
 			"set": checked => {
 				g_GameAttributes.settings.RegicideGarrison = checked;
 			},
 			"hidden": () => g_GameAttributes.settings.VictoryConditions.indexOf("regicide") == -1,
 			"enabled": () => g_GameAttributes.mapType != "scenario",
 			"initOrder": 1000
 		},
 		"nomad": {
 			"title": () => translate("Nomad"),
 			"tooltip": () => translate("In Nomad mode, players start with only few units and have to find a suitable place to build their city. Ceasefire is recommended."),
 			"default": () => false,
 			"defined": () => g_GameAttributes.settings.Nomad !== undefined,
 			"get": () => g_GameAttributes.settings.Nomad,
 			"set": checked => {
 				g_GameAttributes.settings.Nomad = checked;
 			},
 			"hidden": () => g_GameAttributes.mapType != "random",
 			"initOrder": 1000
 		},
 		"revealMap": {
 			"title": () =>
 				// Translation: Make sure to differentiate between the revealed map and explored map settings!
 				translate("Revealed Map"),
 			"tooltip":
 				// Translation: Make sure to differentiate between the revealed map and explored map settings!
 				() => translate("Toggle revealed map (see everything)."),
 			"default": () => false,
 			"defined": () => g_GameAttributes.settings.RevealMap !== undefined,
 			"get": () => g_GameAttributes.settings.RevealMap,
 			"set": checked => {
 				g_GameAttributes.settings.RevealMap = checked;
 
 				if (checked)
 					g_Checkboxes.exploreMap.set(true);
 			},
 			"enabled": () => g_GameAttributes.mapType != "scenario",
 			"initOrder": 1000
 		},
 		"exploreMap": {
 			"title":
 				// Translation: Make sure to differentiate between the revealed map and explored map settings!
 				() => translate("Explored Map"),
 			"tooltip":
 				// Translation: Make sure to differentiate between the revealed map and explored map settings!
 				() => translate("Toggle explored map (see initial map)."),
 			"default": () => false,
 			"defined": () => g_GameAttributes.settings.ExploreMap !== undefined,
 			"get": () => g_GameAttributes.settings.ExploreMap,
 			"set": checked => {
 				g_GameAttributes.settings.ExploreMap = checked;
 			},
 			"enabled": () => g_GameAttributes.mapType != "scenario" && !g_GameAttributes.settings.RevealMap,
 			"initOrder": 1000
 		},
 		"disableTreasures": {
 			"title": () => translate("Disable Treasures"),
 			"tooltip": () => translate("Do not add treasures to the map."),
 			"default": () => false,
 			"defined": () => g_GameAttributes.settings.DisableTreasures !== undefined,
 			"get": () => g_GameAttributes.settings.DisableTreasures,
 			"set": checked => {
 				g_GameAttributes.settings.DisableTreasures = checked;
 			},
 			"enabled": () => g_GameAttributes.mapType != "scenario",
 			"initOrder": 1000
 		},
 		"disableSpies": {
 			"title": () => translate("Disable Spies"),
 			"tooltip": () => translate("Disable spies during the game."),
 			"default": () => false,
 			"defined": () => g_GameAttributes.settings.DisableSpies !== undefined,
 			"get": () => g_GameAttributes.settings.DisableSpies,
 			"set": checked => {
 				g_GameAttributes.settings.DisableSpies = checked;
 			},
 			"enabled": () => g_GameAttributes.mapType != "scenario",
 			"initOrder": 1000
 		},
 		"lockTeams": {
 			"title": () => translate("Teams Locked"),
 			"tooltip": () => translate("Toggle locked teams."),
 			"default": () => Engine.HasXmppClient(),
 			"defined": () => g_GameAttributes.settings.LockTeams !== undefined,
 			"get": () => g_GameAttributes.settings.LockTeams,
 			"set": checked => {
 				g_GameAttributes.settings.LockTeams = checked;
 				g_GameAttributes.settings.LastManStanding = false;
 			},
 			"enabled": () =>
 				g_GameAttributes.mapType != "scenario" &&
 				!g_GameAttributes.settings.RatingEnabled,
 			"initOrder": 1000
 		},
 		"lastManStanding": {
 			"title": () => translate("Last Man Standing"),
 			"tooltip": () => translate("Toggle whether the last remaining player or the last remaining set of allies wins."),
 			"default": () => false,
 			"defined": () => g_GameAttributes.settings.LastManStanding !== undefined,
 			"get": () => g_GameAttributes.settings.LastManStanding,
 			"set": checked => {
 				g_GameAttributes.settings.LastManStanding = checked;
 			},
 			"enabled": () =>
 				g_GameAttributes.mapType != "scenario" &&
 				!g_GameAttributes.settings.LockTeams,
 			"initOrder": 1000
 		},
 		"enableCheats": {
 			"title": () => translate("Cheats"),
 			"tooltip": () => translate("Toggle the usability of cheats."),
 			"default": () => !g_IsNetworked,
 			"hidden": () => !g_IsNetworked,
 			"defined": () => g_GameAttributes.settings.CheatsEnabled !== undefined,
 			"get": () => g_GameAttributes.settings.CheatsEnabled,
 			"set": checked => {
 				g_GameAttributes.settings.CheatsEnabled = !g_IsNetworked ||
 					checked && !g_GameAttributes.settings.RatingEnabled;
 			},
 			"enabled": () => !g_GameAttributes.settings.RatingEnabled,
 			"initOrder": 1000
 		},
 		"enableRating": {
 			"title": () => translate("Rated Game"),
 			"tooltip": () => translate("Toggle if this game will be rated for the leaderboard."),
 			"default": () => Engine.HasXmppClient(),
 			"hidden": () => !Engine.HasXmppClient(),
 			"defined": () => g_GameAttributes.settings.RatingEnabled !== undefined,
 			"get": () => !!g_GameAttributes.settings.RatingEnabled,
 			"set": checked => {
 				g_GameAttributes.settings.RatingEnabled = Engine.HasXmppClient() ? checked : undefined;
 				Engine.SetRankedGame(!!g_GameAttributes.settings.RatingEnabled);
 				if (checked)
 				{
 					g_Checkboxes.lockTeams.set(true);
 					g_Checkboxes.enableCheats.set(false);
 				}
 			},
 			"initOrder": 1000
 		},
 	}
 );
 
 /**
  * For setting up arbitrary GUI objects.
  */
 var g_MiscControls = {
 	"chatPanel": {
 		"hidden": () => {
 			if (!g_IsNetworked)
 				return true;
 
 			let size = Engine.GetGUIObjectByName("chatPanel").getComputedSize();
 			return size.right - size.left < g_MinChatWidth;
 		},
 	},
 	"chatInput": {
 		"tooltip": () => colorizeAutocompleteHotkey(translate("Press %(hotkey)s to autocomplete player names or settings.")),
 	},
+	"mapInfoName": {
+		"caption": () => translateMapTitle(getMapDisplayName(g_GameAttributes.map))
+	},
+	"mapInfoDescription": {
+		"caption": getGameDescription
+	},
+	"mapPreview": {
+		"sprite": () => {
+			let biomePreview = g_GameAttributes.settings.Biome && getBiomePreview(g_GameAttributes.map, g_GameAttributes.settings.Biome);
+			if (biomePreview)
+				return getMapPreviewImage(biomePreview);
+
+			let mapData = loadMapData(g_GameAttributes.map);
+			return getMapPreviewImage(mapData && mapData.settings && mapData.settings.Preview || "nopreview.png");
+		}
+	},
 	"cheatWarningText": {
 		"hidden": () => !g_IsNetworked || !g_GameAttributes.settings.CheatsEnabled,
 	},
 	"cancelGame": {
 		"tooltip": () =>
 			Engine.HasXmppClient() ?
 				translate("Return to the lobby.") :
 				translate("Return to the main menu."),
 	},
 	"startGame": {
 		"caption": () =>
 			g_IsController ? translate("Start Game!") : g_ReadyData[g_IsReady].caption,
 		"onPress": () => function() {
 			if (g_IsController)
 				launchGame();
 			else
 				toggleReady();
 		},
 		"onPressRight": () => function() {
 			if (!g_IsController && g_IsReady)
 				setReady(0, true);
 		},
 		"tooltip": (hoverIdx) =>
 			!g_IsController ?
 				g_ReadyData[g_IsReady].tooltip :
 				!g_IsNetworked || Object.keys(g_PlayerAssignments).every(guid =>
 					g_PlayerAssignments[guid].status || g_PlayerAssignments[guid].player == -1) ?
 					translate("Start a new game with the current settings.") :
 					translate("Start a new game with the current settings (disabled until all players are ready)."),
 		"enabled": () => !g_GameStarted && (
 		                   !g_IsController ||
 		                   Object.keys(g_PlayerAssignments).every(guid => g_PlayerAssignments[guid].status ||
 		                                                                  g_PlayerAssignments[guid].player == -1 ||
 		                                                                  guid == Engine.GetPlayerGUID() && g_IsController)),
 		"hidden": () =>
 			!g_PlayerAssignments[Engine.GetPlayerGUID()] ||
 			g_PlayerAssignments[Engine.GetPlayerGUID()].player == -1 && !g_IsController,
 	},
 	"civInfoButton": {
 		"tooltip": () => sprintf(
 			translate("%(hotkey_civinfo)s / %(hotkey_structree)s: View History / Structure Tree\nLast opened will be reopened on click."), {
 				"hotkey_civinfo": colorizeHotkey("%(hotkey)s", "civinfo"),
 				"hotkey_structree": colorizeHotkey("%(hotkey)s", "structree")
 			}),
 		"onPress": () => function() {
 			Engine.PushGuiPage(
 				g_CivInfo.page,
 				{ "civ": g_CivInfo.civ },
 				storeCivInfoPage);
 		}
 	},
 	"civResetButton": {
 		"hidden": () => g_GameAttributes.mapType == "scenario" || !g_IsController,
 	},
 	"teamResetButton": {
 		"hidden": () => g_GameAttributes.mapType == "scenario" || !g_IsController,
 	},
 	"lobbyButton": {
 		"onPress": () => function() {
 			if (Engine.HasXmppClient())
 				Engine.PushGuiPage("page_lobby.xml", { "dialog": true });
 		},
 		"hidden": () => !Engine.HasXmppClient()
 	},
 	"spTips": {
 		"hidden": () => {
 			let settingsPanel = Engine.GetGUIObjectByName("settingsPanel");
 			let spTips = Engine.GetGUIObjectByName("spTips");
 			return g_IsNetworked ||
 				Engine.ConfigDB_GetValue("user", "gui.gamesetup.enabletips") !== "true" ||
 				spTips.size.right > settingsPanel.getComputedSize().left;
 		}
 	}
 };
 
 /**
  * Contains gui elements that are repeated for every player.
  */
 var g_PlayerMiscElements = {
 	"playerBox": {
 		"size": (playerIdx) => ["0", 32 * playerIdx, "100%", 32 * (playerIdx + 1)].join(" "),
 	},
 	"playerName": {
 		"caption": (playerIdx) => {
 			let pData = g_GameAttributes.settings.PlayerData[playerIdx];
 
 			let assignedGUID = Object.keys(g_PlayerAssignments).find(
 				guid => g_PlayerAssignments[guid].player == playerIdx + 1);
 
 			let name = translate(pData.Name || g_DefaultPlayerData[playerIdx].Name);
 
 			if (g_IsNetworked)
 				name = coloredText(name, g_ReadyData[assignedGUID ? g_PlayerAssignments[assignedGUID].status : 2].color);
 
 			return name;
 		},
 	},
 	"playerColor": {
 		"sprite": (playerIdx) => "color:" + rgbToGuiColor(g_GameAttributes.settings.PlayerData[playerIdx].Color, 100),
 	},
 	"playerConfig": {
 		"hidden": (playerIdx) => !g_GameAttributes.settings.PlayerData[playerIdx].AI,
 		"onPress": (playerIdx) => function() {
 			openAIConfig(playerIdx);
 		},
 		"tooltip": (playerIdx) => sprintf(translate("Configure AI: %(description)s."), {
 			"description": translateAISettings(g_GameAttributes.settings.PlayerData[playerIdx])
 		}),
 	},
 };
 
 /**
  * Initializes some globals without touching the GUI.
  *
  * @param {Object} attribs - context data sent by the lobby / mainmenu
  */
 function init(attribs)
 {
 	if (!g_Settings)
 	{
 		cancelSetup();
 		return;
 	}
 
 	g_IsTutorial = !!attribs.tutorial;
 	g_ServerName = attribs.serverName;
 	g_ServerPort = attribs.serverPort;
 	g_StunEndpoint = attribs.stunEndpoint;
 
 	if (!g_IsNetworked)
 		g_PlayerAssignments = {
 			"local": {
 				"name": singleplayerName(),
 				"player": 1
 			}
 		};
 
 	// Replace empty playername when entering a singleplayermatch for the first time
 	if (!g_IsNetworked)
 		Engine.ConfigDB_CreateAndWriteValueToFile("user", "playername.singleplayer", singleplayerName(), "config/user.cfg");
 
 	initDefaults();
 	supplementDefaults();
 
 	setTimeout(displayGamestateNotifications, 1000);
 }
 
 function initDefaults()
 {
 	// Remove gaia from both arrays
 	g_DefaultPlayerData = clone(g_Settings.PlayerDefaults.slice(1));
 
 	let aiDifficulty = +Engine.ConfigDB_GetValue("user", "gui.gamesetup.aidifficulty");
 	let aiBehavior = Engine.ConfigDB_GetValue("user", "gui.gamesetup.aibehavior");
 
 	// Don't change the underlying defaults file, as Atlas uses that file too
 	for (let i in g_DefaultPlayerData)
 	{
 		g_DefaultPlayerData[i].Civ = "random";
 		g_DefaultPlayerData[i].Team = -1;
 		g_DefaultPlayerData[i].AIDiff = aiDifficulty;
 		g_DefaultPlayerData[i].AIBehavior = aiBehavior;
 	}
 
 	deepfreeze(g_DefaultPlayerData);
 }
 
 /**
  * Sets default values for all g_GameAttribute settings which don't have a value set.
  */
 function supplementDefaults()
 {
 	g_GameAttributes.settings.VictoryConditions = g_GameAttributes.settings.VictoryConditions ||
 		g_VictoryConditions.filter(victoryCondition => !!victoryCondition.Default).map(victoryCondition => victoryCondition.Name);
 
 	for (let dropdown in g_Dropdowns)
 		if (!g_Dropdowns[dropdown].defined())
 			g_Dropdowns[dropdown].select(g_Dropdowns[dropdown].default());
 
 	for (let checkbox in g_Checkboxes)
 		if (!g_Checkboxes[checkbox].defined())
 			g_Checkboxes[checkbox].set(g_Checkboxes[checkbox].default());
 
 	for (let dropdown in g_PlayerDropdowns)
 		for (let i = 0; i < g_GameAttributes.settings.PlayerData.length; ++i)
 			if (!isControlArrayElementHidden(i) && !g_PlayerDropdowns[dropdown].defined(i))
 				g_PlayerDropdowns[dropdown].select(g_PlayerDropdowns[dropdown].default(i), i);
 }
 
 /**
  * Called after the first tick.
  */
 function initGUIObjects()
 {
 	initSettingObjects();
 	initSettingsTabButtons();
 	initSPTips();
 
 	loadPersistMatchSettings();
 	updateGameAttributes();
 	sendRegisterGameStanzaImmediate();
 
 	if (g_IsTutorial)
 	{
 		launchTutorial();
 		return;
 	}
 
 	// Don't lift the curtain until the controls are updated the first time
 	if (!g_IsNetworked)
 		hideLoadingWindow();
 }
 
 /**
  * @param {number} dt - Time in milliseconds since last call.
  */
 function slideSettingsPanel(dt)
 {
 	let slideSpeed = Engine.ConfigDB_GetValue("user", "gui.gamesetup.settingsslide") == "true" ? g_SlideSpeed : Infinity;
 
 	let settingsPanel = Engine.GetGUIObjectByName("settingsPanel");
 	let rightBorder = Engine.GetGUIObjectByName("settingTabButtons").size.left;
 	let offset = 0;
 	if (g_TabCategorySelected === undefined)
 	{
 		let maxOffset = rightBorder - settingsPanel.size.left;
 		if (maxOffset > 0)
 			offset = Math.min(slideSpeed * dt, maxOffset);
 	}
 	else if (rightBorder > settingsPanel.size.right)
 		offset = Math.min(slideSpeed * dt, rightBorder - settingsPanel.size.right);
 	else
 	{
 		let maxOffset = settingsPanel.size.right - rightBorder;
 		if (maxOffset > 0)
 			offset = -Math.min(slideSpeed * dt, maxOffset);
 	}
 
 	updateSettingsPanelPosition(offset);	
 }
 
 /**
  * Directly change the position of the settingsPanel.
  * @param {number} offset - Number of pixels the panel needs to move.
  */
 function updateSettingsPanelPosition(offset)
 {
 	if (!offset)
 		return;
 
 	let settingsPanel = Engine.GetGUIObjectByName("settingsPanel");
 	let settingsPanelSize = settingsPanel.size;
 	settingsPanelSize.left += offset;
 	settingsPanelSize.right += offset;
 	settingsPanel.size = settingsPanelSize;
 
 	let settingsBackground = Engine.GetGUIObjectByName("settingsBackground");
 	let backgroundSize = settingsBackground.size;
 	backgroundSize.left = settingsPanelSize.left;
 	settingsBackground.size = backgroundSize;
 
 	let chatPanel = Engine.GetGUIObjectByName("chatPanel");
 	let chatSize = chatPanel.size;
 
 	chatSize.right = settingsPanelSize.left - g_ChatSettingsMargin;
 	chatPanel.size = chatSize;
 	chatPanel.hidden = g_MiscControls.chatPanel.hidden();
 
 	let spTips = Engine.GetGUIObjectByName("spTips");
 	spTips.hidden = g_MiscControls.spTips.hidden();
 }
 
 function hideLoadingWindow()
 {
 	let loadingWindow = Engine.GetGUIObjectByName("loadingWindow");
 	if (loadingWindow.hidden)
 		return;
 
 	loadingWindow.hidden = true;
 	Engine.GetGUIObjectByName("setupWindow").hidden = false;
 
 	if (!Engine.GetGUIObjectByName("chatPanel").hidden)
 		Engine.GetGUIObjectByName("chatInput").focus();
 }
 
 /**
  * Settings under the settings tabs use a generic name.
  * Player settings use custom names.
  */
 function getGUIObjectNameFromSetting(setting)
 {
 	let idxOffset = 0;
 	for (let category of g_SettingsTabsGUI)
 	{
 		let idx = category.settings.indexOf(setting);
 		if (idx != -1)
 			return [
 				"setting",
 				g_Dropdowns[setting] ? "Dropdown" : "Checkbox",
 				"[" + (idx + idxOffset) + "]"
 			];
 		idxOffset += category.settings.length;
 	}
 
 	// Assume there is a GUI object with exactly that setting name
 	return [setting, "", ""];
 }
 
 /**
  * Initialize all settings dropdowns and checkboxes.
  */
 function initSettingObjects()
 {
 	// Copy all initOrder values into one object
 	let initOrder = {};
 	for (let dropdown in g_Dropdowns)
 		initOrder[dropdown] = g_Dropdowns[dropdown].initOrder;
 	for (let checkbox in g_Checkboxes)
 		initOrder[checkbox] = g_Checkboxes[checkbox].initOrder;
 
 	// Sort the object on initOrder so we can init the settings in an arbitrary order
 	for (let setting of Object.keys(initOrder).sort((a, b) => initOrder[a] - initOrder[b]))
 		if (g_Dropdowns[setting])
 			initDropdown(setting);
 		else if (g_Checkboxes[setting])
 			initCheckbox(setting);
 		else
 			warn('The setting "' + setting + '" is not defined.');
 
 	for (let dropdown in g_PlayerDropdowns)
 		initPlayerDropdowns(dropdown);
 }
 
 function initDropdown(name, playerIdx)
 {
 	let [guiName, guiType, guiIdx] = getGUIObjectNameFromSetting(name);
 	let idxName = playerIdx === undefined ? "" : "[" + playerIdx + "]";
 	let data = (playerIdx === undefined ? g_Dropdowns : g_PlayerDropdowns)[name];
 
 	let dropdown = Engine.GetGUIObjectByName(guiName + guiType + guiIdx + idxName);
 
 	dropdown.list = data.labels(playerIdx).map((label, id) =>
 		data.colors && data.colors(playerIdx) ?
 			coloredText(label, data.colors(playerIdx)[id]) :
 			label);
 
 	dropdown.list_data = data.ids(playerIdx);
 
 	dropdown.onSelectionChange = function() {
 
 		if (!g_IsController ||
 		    g_IsInGuiUpdate ||
 		    !this.list_data[this.selected] ||
 		    data.hidden && data.hidden(playerIdx) ||
 		    data.enabled && !data.enabled(playerIdx))
 			return;
 
 		data.select(this.selected, playerIdx);
 
 		supplementDefaults();
 		updateGameAttributes();
 	};
 
 	if (data.tooltip)
 		dropdown.onHoverChange = function() {
 			this.tooltip = data.tooltip(this.hovered, playerIdx);
 		};
 }
 
 function initPlayerDropdowns(name)
 {
 	for (let i = 0; i < g_MaxPlayers; ++i)
 		initDropdown(name, i);
 }
 
 function initCheckbox(name)
 {
 	let [guiName, guiType, guiIdx] = getGUIObjectNameFromSetting(name);
 	Engine.GetGUIObjectByName(guiName + guiType + guiIdx).onPress = function() {
 
 		let obj = g_Checkboxes[name];
 
 		if (!g_IsController ||
 		    g_IsInGuiUpdate ||
 		    obj.enabled && !obj.enabled() ||
 		    obj.hidden && obj.hidden())
 			return;
 
 		obj.set(this.checked);
 
 		supplementDefaults();
 		updateGameAttributes();
 	};
 }
 
 function initSettingsTabButtons()
 {
 	for (let tab in g_SettingsTabsGUI)
 		g_SettingsTabsGUI[tab].tooltip =
 			sprintf(translate("Toggle the %(name)s settings tab."), { "name": g_SettingsTabsGUI[tab].label }) +
 			colorizeHotkey("\n" + translate("Use %(hotkey)s to move a settings tab down."), "tab.next") +
 			colorizeHotkey("\n" + translate("Use %(hotkey)s to move a settings tab up."), "tab.prev");
 
 	let settingTabButtons = Engine.GetGUIObjectByName("settingTabButtons");
 	let settingTabButtonsSize = settingTabButtons.size;
 	settingTabButtonsSize.bottom = settingTabButtonsSize.top + g_SettingsTabsGUI.length * (g_TabButtonHeight + g_TabButtonDist);
 	settingTabButtonsSize.right = g_MiscControls.lobbyButton.hidden() ?
 		settingTabButtonsSize.right :
 		Engine.GetGUIObjectByName("lobbyButton").size.left - g_LobbyButtonSpacing;
 	settingTabButtons.size = settingTabButtonsSize;
 
 	let settingTabButtonsBackground = Engine.GetGUIObjectByName("settingTabButtonsBackground");
 	settingTabButtonsBackground.size = settingTabButtonsSize;
 
 	let gameDescription = Engine.GetGUIObjectByName("mapInfoDescriptionFrame");
 	let gameDescriptionSize = gameDescription.size;
 	gameDescriptionSize.top = settingTabButtonsSize.bottom + 3;
 	gameDescription.size = gameDescriptionSize;
 
 	if (!g_IsController)
 	{
 		g_TabCategorySelected = undefined;
 		updateSettingsPanelPosition(Engine.GetGUIObjectByName("settingTabButtons").size.left - Engine.GetGUIObjectByName("settingsPanel").size.left);
 	}
 
 	placeTabButtons(
 		g_SettingsTabsGUI,
 		g_TabButtonHeight,
 		g_TabButtonDist,
 		category => {
 			selectPanel(category == g_TabCategorySelected ? undefined : category);
 		},
 		() => {
 			updateGUIObjects();
 			Engine.GetGUIObjectByName("settingsPanel").hidden = false;
 		});
 }
 
 function initSPTips()
 {
 	if (g_IsNetworked || Engine.ConfigDB_GetValue("user", "gui.gamesetup.enabletips") !== "true")
 		return;
 
 	Engine.GetGUIObjectByName("spTips").hidden = false;
 	Engine.GetGUIObjectByName("displaySPTips").checked = true;
 	Engine.GetGUIObjectByName("aiTips").caption = Engine.TranslateLines(Engine.ReadFile("gui/gamesetup/ai.txt"));
 }
 
 /**
  * Distribute the currently visible settings over the settings panel.
  * First calculate the number of columns required, then place the objects.
  */
 function distributeSettings()
 {
 	let setupWindowSize = Engine.GetGUIObjectByName("setupWindow").getComputedSize();
 	let columnWidth = Math.min(
 		g_MaxColumnWidth,
 		(setupWindowSize.right - setupWindowSize.left + Engine.GetGUIObjectByName("settingTabButtons").size.left) / 2);
 
 	let settingsPanel = Engine.GetGUIObjectByName("settingsPanel");
 	let actualSettingsPanelSize = settingsPanel.getComputedSize();
 
 	let maxPerColumn = Math.floor((actualSettingsPanelSize.bottom - actualSettingsPanelSize.top) / g_SettingHeight);
 	let childCount = settingsPanel.children.filter(child => !child.hidden).length;
 	let perColumn = childCount / Math.ceil(childCount / maxPerColumn);
 
 	let yPos = g_SettingDist;
 	let column = 0;
 	let thisColumn = 0;
 	let settingsPanelSize = settingsPanel.size;
 	for (let child of settingsPanel.children)
 	{
 		if (child.hidden)
 			continue;
 
 		if (thisColumn >= perColumn)
 		{
 			yPos = g_SettingDist;
 			++column;
 			thisColumn = 0;
 		}
 
-		let childSize = child.size;
 		child.size = new GUISize(
 			column * columnWidth,
 			yPos,
 			column * columnWidth + columnWidth - 10,
 			yPos + g_SettingHeight - g_SettingDist);
 
 		yPos += g_SettingHeight;
 		++thisColumn;
 	}
 
 	settingsPanelSize.right = settingsPanelSize.left + (column + 1) * columnWidth;
 	settingsPanel.size = settingsPanelSize;
 }
 
 /**
  * Called when the client disconnects.
  * The other cases from NetClient should never occur in the gamesetup.
  */
 function handleNetStatusMessage(message)
 {
 	if (message.status != "disconnected")
 	{
 		error("Unrecognised netstatus type " + message.status);
 		return;
 	}
 
 	cancelSetup();
 	reportDisconnect(message.reason, true);
 }
 
 /**
  * Called whenever a client clicks on ready (or not ready).
  */
 function handleReadyMessage(message)
 {
 	--g_ReadyChanged;
 
 	if (g_ReadyChanged < 1 && g_PlayerAssignments[message.guid].player != -1)
 		addChatMessage({
 			"type": "ready",
 			"status": message.status,
 			"guid": message.guid
 		});
 
 	g_PlayerAssignments[message.guid].status = message.status;
 	updateGUIObjects();
 }
 
 /**
  * Called after every player is ready and the host decided to finally start the game.
  */
 function handleGamestartMessage(message)
 {
 	// Immediately inform the lobby server instead of waiting for the load to finish
 	if (g_IsController && Engine.HasXmppClient())
 	{
 		sendRegisterGameStanzaImmediate();
 		let clients = formatClientsForStanza();
 		Engine.SendChangeStateGame(clients.connectedPlayers, clients.list);
 	}
 
 	Engine.SwitchGuiPage("page_loading.xml", {
 		"attribs": g_GameAttributes,
 		"playerAssignments": g_PlayerAssignments
 	});
 }
 
 /**
  * Called whenever the host changed any setting.
  */
 function handleGamesetupMessage(message)
 {
 	if (!message.data)
 		return;
 
 	g_GameAttributes = message.data;
 
 	if (!!g_GameAttributes.settings.RatingEnabled)
 	{
 		g_GameAttributes.settings.CheatsEnabled = false;
 		g_GameAttributes.settings.LockTeams = true;
 		g_GameAttributes.settings.LastManStanding = false;
 	}
 
 	Engine.SetRankedGame(!!g_GameAttributes.settings.RatingEnabled);
 
 	resetReadyData();
 
 	updateGUIObjects();
 
 	hideLoadingWindow();
 }
 
 /**
  * Called whenever a client joins/leaves or any gamesetting is changed.
  */
 function handlePlayerAssignmentMessage(message)
 {
 	let playerChange = false;
 
 	for (let guid in message.newAssignments)
 		if (!g_PlayerAssignments[guid])
 		{
 			onClientJoin(guid, message.newAssignments);
 			playerChange = true;
 		}
 
 	for (let guid in g_PlayerAssignments)
 		if (!message.newAssignments[guid])
 		{
 			onClientLeave(guid);
 			playerChange = true;
 		}
 
 	g_PlayerAssignments = message.newAssignments;
 
 	sanitizePlayerData(g_GameAttributes.settings.PlayerData);
 	updateGUIObjects();
 
 	if (playerChange)
 		sendRegisterGameStanzaImmediate();
 	else
 		sendRegisterGameStanza();
 }
 
 function onClientJoin(newGUID, newAssignments)
 {
 	let playername = newAssignments[newGUID].name;
 
 	addChatMessage({
 		"type": "connect",
 		"guid": newGUID,
 		"username": playername
 	});
 
 	if (newGUID != Engine.GetPlayerGUID() && Object.keys(g_PlayerAssignments).length)
 		soundNotification("gamesetup.join");
 
 	let isRejoiningPlayer = newAssignments[newGUID].player != -1;
 
 	// Assign the client (or only buddies if prefered) to an unused playerslot and rejoining players to their old slot
 	if (!isRejoiningPlayer && playername != newAssignments[Engine.GetPlayerGUID()].name)
 	{
 		let assignOption = Engine.ConfigDB_GetValue("user", "gui.gamesetup.assignplayers");
 		if (assignOption == "disabled" ||
 		    assignOption == "buddies" && g_Buddies.indexOf(splitRatingFromNick(playername).nick) == -1)
 			return;
 	}
 
 	let freeSlot = g_GameAttributes.settings.PlayerData.findIndex((v, i) =>
 		Object.keys(g_PlayerAssignments).every(guid => g_PlayerAssignments[guid].player != i + 1)
 	);
 
 	// Client is not and cannot become assigned as player
 	if (!isRejoiningPlayer && freeSlot == -1)
 		return;
 
 	// Assign the joining client to the free slot
 	if (g_IsController && !isRejoiningPlayer)
 		Engine.AssignNetworkPlayer(freeSlot + 1, newGUID);
 
 	resetReadyData();
 }
 
 function onClientLeave(guid)
 {
 	addChatMessage({
 		"type": "disconnect",
 		"guid": guid
 	});
 
 	if (g_PlayerAssignments[guid].player != -1)
 		resetReadyData();
 }
 
 /**
  * Doesn't translate, so that lobby clients can do that locally
  * (even if they don't have that map).
  */
 function getMapDisplayName(map)
 {
 	if (map == "random")
 		return map;
 
 	let mapData = loadMapData(map);
 	if (!mapData || !mapData.settings || !mapData.settings.Name)
 		return map;
 
 	return mapData.settings.Name;
 }
 
-function getMapPreview(map)
-{
-	let biomePreview = g_GameAttributes.settings.Biome && getBiomePreview(map, g_GameAttributes.settings.Biome);
-	if (biomePreview)
-		return biomePreview;
-
-	let mapData = loadMapData(map);
-	if (!mapData || !mapData.settings || !mapData.settings.Preview)
-		return "nopreview.png";
-
-	return mapData.settings.Preview;
-}
-
 /**
  * Filter maps with filterFunc and by chosen map type.
  *
  * @param {function} filterFunc - Filter function that should be applied.
  * @return {Array} the maps that match the filterFunc and the chosen map type.
  */
 function getFilteredMaps(filterFunc)
 {
 	if (!g_MapPath[g_GameAttributes.mapType])
 	{
 		error("Unexpected map type: " + g_GameAttributes.mapType);
 		return [];
 	}
 
 	let maps = [];
 	// TODO: Should verify these are valid maps before adding to list
 	for (let mapFile of listFiles(g_GameAttributes.mapPath, g_GameAttributes.mapType == "random" ? ".json" : ".xml", false))
 	{
 		if (mapFile.startsWith("_"))
 			continue;
 
 		let file = g_GameAttributes.mapPath + mapFile;
 		let mapData = loadMapData(file);
 
 		if (!mapData || !mapData.settings || filterFunc && !filterFunc(mapData.settings.Keywords || []))
 			continue;
 
 		maps.push({
 			"file": file,
 			"name": translate(getMapDisplayName(file)),
 			"color": g_ColorRegular,
 			"description": translate(mapData.settings.Description)
 		});
 	}
 	return maps;
 }
 
 /**
  * Initialize the dropdown containing all map filters for the selected maptype.
  */
 function reloadMapFilterList()
 {
 	g_MapFilterList = prepareForDropdown(g_MapFilters.filter(
 		mapFilter => getFilteredMaps(mapFilter.filter).length
 	));
 
 	initDropdown("mapFilter");
 	reloadMapList();
 }
 
 /**
  * Initialize the dropdown containing all maps for the selected maptype and mapfilter.
  */
 function reloadMapList()
 {
 	let filterID = g_MapFilterList.id.findIndex(id => id == g_GameAttributes.mapFilter);
 	let filterFunc = g_MapFilterList.filter[filterID];
 	let mapList = getFilteredMaps(filterFunc).sort(sortNameIgnoreCase);
 
 	if (g_GameAttributes.mapType == "random")
 		mapList.unshift({
 			"file": "random",
 			"name": translateWithContext("map selection", "Random"),
 			"color": g_ColorRandom,
 			"description": translate("Pick any of the given maps at random.")
 		});
 
 	g_MapSelectionList = prepareForDropdown(mapList);
 	initDropdown("mapSelection");
 }
 
 /**
  * Initialize the dropdowns specific to each map.
  */
 function reloadMapSpecific()
 {
 	reloadBiomeList();
 	reloadTriggerDifficulties();
 }
 
 function reloadBiomeList()
 {
 	let biomeList;
 
 	if (g_GameAttributes.mapType == "random" && g_GameAttributes.settings.SupportedBiomes)
 	{
 		if (typeof g_GameAttributes.settings.SupportedBiomes == "string")
 			biomeList = g_Settings.Biomes.filter(biome => biome.Id.startsWith(g_GameAttributes.settings.SupportedBiomes));
 		else
 			biomeList = g_Settings.Biomes.filter(
 				biome => g_GameAttributes.settings.SupportedBiomes.indexOf(biome.Id) != -1);
 	}
 
 	g_BiomeList = biomeList && prepareForDropdown(
 		[{
 			"Id": "random",
 			"Title": translateWithContext("biome", "Random"),
 			"Description": translate("Pick a biome at random."),
 			"Color": g_ColorRandom
 		}].concat(biomeList.map(biome => ({
 			"Id": biome.Id,
 			"Title": biome.Title,
 			"Description": biome.Description,
 			"Color": g_ColorRegular
 		}))));
 
 	initDropdown("biome");
 	updateGUIDropdown("biome");
 }
 
 function reloadTriggerDifficulties()
 {
 	g_TriggerDifficultyList = undefined;
 
 	if (!g_GameAttributes.settings.SupportedTriggerDifficulties)
 		return;
 
 	let triggerDifficultyList;
 	if (g_GameAttributes.settings.SupportedTriggerDifficulties.Values === true)
 		triggerDifficultyList = g_Settings.TriggerDifficulties;
 	else
 	{
 		triggerDifficultyList = g_Settings.TriggerDifficulties.filter(
 			diff => g_GameAttributes.settings.SupportedTriggerDifficulties.Values.indexOf(diff.Name) != -1);
 		if (!triggerDifficultyList.length)
 			return;
 	}
 
 	g_TriggerDifficultyList = prepareForDropdown(
 		triggerDifficultyList.map(diff => ({
 			"Id": diff.Difficulty,
 			"Title": diff.Title,
 			"Description": diff.Tooltip,
 			"Default": diff.Name == g_GameAttributes.settings.SupportedTriggerDifficulties.Default
 		})));
 
 	initDropdown("triggerDifficulty");
 	updateGUIDropdown("triggerDifficulty");
 }
 
 function reloadGameSpeedChoices()
 {
 	g_GameSpeeds = getGameSpeedChoices(Object.keys(g_PlayerAssignments).every(guid => g_PlayerAssignments[guid].player == -1));
 	initDropdown("gameSpeed");
 	supplementDefaults();
 }
 
 function loadMapData(name)
 {
 	if (!name || !g_MapPath[g_GameAttributes.mapType])
 		return undefined;
 
 	if (name == "random")
 		return { "settings": { "Name": "", "Description": "" } };
 
 	if (!g_MapData[name])
 		g_MapData[name] = g_GameAttributes.mapType == "random" ?
 			Engine.ReadJSONFile(name + ".json") :
 			Engine.LoadMapSettings(name);
 
 	return g_MapData[name];
 }
 
 /**
  * Sets the gameattributes the way they were the last time the user left the gamesetup.
  */
 function loadPersistMatchSettings()
 {
 	if (!g_IsController || Engine.ConfigDB_GetValue("user", "persistmatchsettings") != "true" || g_IsTutorial)
 		return;
 
 	let settingsFile = g_IsNetworked ? g_MatchSettings_MP : g_MatchSettings_SP;
 	if (!Engine.FileExists(settingsFile))
 		return;
 
 	let data = Engine.ReadJSONFile(settingsFile);
 	if (!data || !data.attributes || !data.attributes.settings)
 		return;
 
 	if (data.engine_info.engine_version != Engine.GetEngineInfo().engine_version ||
 	    !hasSameMods(data.engine_info.mods, Engine.GetEngineInfo().mods))
 		return;
 
 	g_IsInGuiUpdate = true;
 
 	let mapName = data.attributes.map || "";
 	let mapSettings = data.attributes.settings;
 
 	g_GameAttributes = data.attributes;
 
 	if (!g_IsNetworked)
 		mapSettings.CheatsEnabled = true;
 
 	// Replace unselectable civs with random civ
 	let playerData = mapSettings.PlayerData;
 	if (playerData && g_GameAttributes.mapType != "scenario")
 		for (let i in playerData)
 			if (!g_CivData[playerData[i].Civ] || !g_CivData[playerData[i].Civ].SelectableInGameSetup)
 				playerData[i].Civ = "random";
 
 	// Apply map settings
 	let newMapData = loadMapData(mapName);
 	if (newMapData && newMapData.settings)
 	{
 		for (let prop in newMapData.settings)
 			mapSettings[prop] = newMapData.settings[prop];
 
 		if (playerData)
 			mapSettings.PlayerData = playerData;
 	}
 
 	if (mapSettings.PlayerData)
 		sanitizePlayerData(mapSettings.PlayerData);
 
 	// Reload, as the maptype or mapfilter might have changed
 	reloadMapFilterList();
 	reloadMapSpecific();
 
 	g_GameAttributes.settings.RatingEnabled = Engine.HasXmppClient();
 	Engine.SetRankedGame(g_GameAttributes.settings.RatingEnabled);
 
 	supplementDefaults();
 
 	g_IsInGuiUpdate = false;
 }
 
 function savePersistMatchSettings()
 {
 	if (g_IsTutorial)
 		return;
 
 	Engine.WriteJSONFile(
 		g_IsNetworked ? g_MatchSettings_MP : g_MatchSettings_SP,
 		{
 			"attributes":
 				// Delete settings if disabled, so that players are not confronted with old settings after enabling the setting again
 				Engine.ConfigDB_GetValue("user", "persistmatchsettings") == "true" ?
 					g_GameAttributes :
 					{},
 			"engine_info": Engine.GetEngineInfo()
 		});
 }
 
 function sanitizePlayerData(playerData)
 {
 	// Remove gaia
 	if (playerData.length && !playerData[0])
 		playerData.shift();
 
 	playerData.forEach((pData, index) => {
 
 		// Use defaults if the map doesn't specify a value
 		for (let prop in g_DefaultPlayerData[index])
 			if (!(prop in pData))
 				pData[prop] = clone(g_DefaultPlayerData[index][prop]);
 
 		// Replace colors with the best matching color of PlayerDefaults
 		if (g_GameAttributes.mapType != "scenario")
 		{
 			let colorDistances = g_PlayerColorPickerList.map(color => colorDistance(color, pData.Color));
 			let smallestDistance = colorDistances.find(distance => colorDistances.every(distance2 => (distance2 >= distance)));
 			pData.Color = g_PlayerColorPickerList.find(color => colorDistance(color, pData.Color) == smallestDistance);
 		}
 
 		// If there is a player in that slot, then there can't be an AI
 		if (Object.keys(g_PlayerAssignments).some(guid => g_PlayerAssignments[guid].player == index + 1))
 			pData.AI = "";
 	});
 
 	ensureUniquePlayerColors(playerData);
 }
 
 function cancelSetup()
 {
 	if (g_IsController)
 		savePersistMatchSettings();
 
 	Engine.DisconnectNetworkGame();
 
 	if (Engine.HasXmppClient())
 	{
 		Engine.LobbySetPlayerPresence("available");
 
 		if (g_IsController)
 			Engine.SendUnregisterGame();
 
 		Engine.SwitchGuiPage("page_lobby.xml", { "dialog": false });
 	}
 	else
 		Engine.SwitchGuiPage("page_pregame.xml");
 }
 
 /**
  * Can't init the GUI before the first tick.
  * Process netmessages afterwards.
  */
 function onTick()
 {
 	if (!g_Settings)
 		return;
 
 	// First tick happens before first render, so don't load yet
 	if (g_LoadingState == 0)
 		++g_LoadingState;
 	else if (g_LoadingState == 1)
 	{
 		initGUIObjects();
 		++g_LoadingState;
 	}
 	else if (g_LoadingState == 2)
 		handleNetMessages();
 
 	updateTimers();
 
 	let now = Date.now();
 	let tickLength = now - g_LastTickTime;
 	g_LastTickTime = now;
 
 	slideSettingsPanel(tickLength);
 }
 
 /**
  * Handles all pending messages sent by the net client.
  */
 function handleNetMessages()
 {
 	if (!g_IsNetworked)
 		return;
 
 	while (true)
 	{
 		let message = Engine.PollNetworkClient();
 		if (!message)
 			break;
 
 		log("Net message: " + uneval(message));
 
 		if (g_NetMessageTypes[message.type])
 			g_NetMessageTypes[message.type](message);
 		else
 			error("Unrecognised net message type " + message.type);
 	}
 }
 
 /**
  * Called when the map or the number of players changes.
  */
 function unassignInvalidPlayers(maxPlayers)
 {
 	if (g_IsNetworked)
 		// Remove invalid playerIDs from the servers playerassignments copy
 		for (let playerID = +maxPlayers + 1; playerID <= g_MaxPlayers; ++playerID)
 			Engine.AssignNetworkPlayer(playerID, "");
 
 	else if (g_PlayerAssignments.local.player > maxPlayers)
 		g_PlayerAssignments.local.player = -1;
 }
 
 function ensureUniquePlayerColors(playerData)
 {
 	for (let i = playerData.length - 1; i >= 0; --i)
 		// If someone else has that color, assign an unused color
 		if (playerData.some((pData, j) => i != j && sameColor(playerData[i].Color, pData.Color)))
 			playerData[i].Color = g_PlayerColorPickerList.find(color => playerData.every(pData => !sameColor(color, pData.Color)));
 }
 
 function selectMap(name)
 {
 	// Reset some map specific properties which are not necessarily redefined on each map
 	for (let prop of ["TriggerScripts", "CircularMap", "Garrison", "DisabledTemplates", "Biome", "SupportedBiomes", "SupportedTriggerDifficulties", "TriggerDifficulty"])
 		g_GameAttributes.settings[prop] = undefined;
 
 	let mapData = loadMapData(name);
 	let mapSettings = mapData && mapData.settings ? clone(mapData.settings) : {};
 
 	if (g_GameAttributes.mapType != "random")
 		delete g_GameAttributes.settings.Nomad;
 
 	if (g_GameAttributes.mapType == "scenario")
 	{
 		delete g_GameAttributes.settings.RelicDuration;
 		delete g_GameAttributes.settings.WonderDuration;
 		delete g_GameAttributes.settings.LastManStanding;
 		delete g_GameAttributes.settings.RegicideGarrison;
 	}
 
 	if (mapSettings.PlayerData)
 		sanitizePlayerData(mapSettings.PlayerData);
 
 	// Copy any new settings
 	g_GameAttributes.map = name;
 	g_GameAttributes.script = mapSettings.Script;
 	if (g_GameAttributes.map !== "random")
 		for (let prop in mapSettings)
 			g_GameAttributes.settings[prop] = mapSettings[prop];
 
 	reloadMapSpecific();
 	unassignInvalidPlayers(g_GameAttributes.settings.PlayerData.length);
 	supplementDefaults();
 }
 
 function isControlArrayElementHidden(playerIdx)
 {
 	return playerIdx !== undefined && playerIdx >= g_GameAttributes.settings.PlayerData.length;
 }
 
 /**
  * @param playerIdx - Only specified for dropdown arrays.
  */
 function updateGUIDropdown(name, playerIdx = undefined)
 {
 	let [guiName, guiType, guiIdx] = getGUIObjectNameFromSetting(name);
 	let idxName = playerIdx === undefined ? "" : "[" + playerIdx + "]";
 
 	let dropdown = Engine.GetGUIObjectByName(guiName + guiType + guiIdx + idxName);
 	let label = Engine.GetGUIObjectByName(guiName + "Text" + guiIdx + idxName);
 	let frame = Engine.GetGUIObjectByName(guiName + "Frame" + guiIdx + idxName);
 	let title = Engine.GetGUIObjectByName(guiName + "Title" + guiIdx + idxName);
 
 	if (guiType == "Dropdown")
 		Engine.GetGUIObjectByName(guiName + "Checkbox" + guiIdx).hidden = true;
 
 	let indexHidden = isControlArrayElementHidden(playerIdx);
 	let obj = (playerIdx === undefined ? g_Dropdowns : g_PlayerDropdowns)[name];
 
 	let hidden = indexHidden || !!obj.hidden && obj.hidden(playerIdx);
 	let selected = hidden ? -1 : dropdown.list_data.indexOf(String(obj.get(playerIdx)));
 	let enabled = !indexHidden && (!obj.enabled || obj.enabled(playerIdx));
 
 	dropdown.enabled = g_IsController && enabled;
 	dropdown.hidden = !g_IsController || !enabled || hidden;
 	dropdown.selected = selected;
 	dropdown.tooltip = !indexHidden && obj.tooltip ? obj.tooltip(-1, playerIdx) : "";
 
 	if (frame)
 		frame.hidden = hidden;
 
 	if (title && obj.title && !indexHidden)
 		title.caption = sprintf(translateWithContext("Title for specific setting", "%(setting)s:"), { "setting": obj.title(playerIdx) });
 
 	if (label && !indexHidden)
 	{
 		label.hidden = g_IsController && enabled || hidden;
 		label.caption = selected == -1 ? translateWithContext("settings value", "Unknown") : dropdown.list[selected];
 	}
 }
 
 /**
  * Not used for the player assignments, so playerCheckboxes are not implemented,
  * hence no index.
  */
 function updateGUICheckbox(name)
 {
 	let obj = g_Checkboxes[name];
 
 	let checked = obj.get();
 	let hidden = !!obj.hidden && obj.hidden();
 	let enabled = !obj.enabled || obj.enabled();
 
 	let [guiName, guiType, guiIdx] = getGUIObjectNameFromSetting(name);
 	let checkbox = Engine.GetGUIObjectByName(guiName + guiType + guiIdx);
 	let label = Engine.GetGUIObjectByName(guiName + "Text" + guiIdx);
 	let frame = Engine.GetGUIObjectByName(guiName + "Frame" + guiIdx);
 	let title = Engine.GetGUIObjectByName(guiName + "Title" + guiIdx);
 
 	if (guiType == "Checkbox")
 		Engine.GetGUIObjectByName(guiName + "Dropdown" + guiIdx).hidden = true;
 
 	checkbox.checked = checked;
 	checkbox.enabled = g_IsController && enabled;
 	checkbox.hidden = hidden || !g_IsController;
 	checkbox.tooltip = obj.tooltip ? obj.tooltip() : "";
 
 	label.caption = checked ? translate("Yes") : translate("No");
 	label.hidden = hidden || g_IsController;
 
 	if (frame)
 		frame.hidden = hidden;
 
 	if (title && obj.title)
 		title.caption = sprintf(translate("%(setting)s:"), { "setting": obj.title() });
 }
 
 function updateGUIMiscControl(name, playerIdx)
 {
 	let idxName = playerIdx === undefined ? "" : "[" + playerIdx + "]";
 	let obj = (playerIdx === undefined ? g_MiscControls : g_PlayerMiscElements)[name];
 
 	let control = Engine.GetGUIObjectByName(name + idxName);
 	if (!control)
 		warn("No GUI object with name '" + name + "'");
 
 	let hide = isControlArrayElementHidden(playerIdx);
 	control.hidden = hide;
 
 	if (hide)
 		return;
 
 	for (let property in obj)
 		control[property] = obj[property](playerIdx);
 }
 
 function launchGame()
 {
-	if (!g_IsController)
-	{
-		error("Only host can start game");
-		return;
-	}
-
 	if (!g_GameAttributes.map || g_GameStarted)
 		return;
 
 	// Prevent reseting the readystate or calling this function twice
 	g_GameStarted = true;
 	updateGUIMiscControl("startGame");
 
 	savePersistMatchSettings();
 
 	// Select random map
 	if (g_GameAttributes.map == "random")
 		selectMap(pickRandom(g_Dropdowns.mapSelection.ids().slice(1)));
 
 	if (g_GameAttributes.settings.Biome == "random")
 		g_GameAttributes.settings.Biome = pickRandom(
 			typeof g_GameAttributes.settings.SupportedBiomes == "string" ?
 				g_BiomeList.Id.slice(1).filter(biomeID => biomeID.startsWith(g_GameAttributes.settings.SupportedBiomes)) :
 				g_GameAttributes.settings.SupportedBiomes);
 
 	g_GameAttributes.settings.VictoryScripts = g_GameAttributes.settings.VictoryConditions.reduce(
 		(scripts, victoryConditionName) => scripts.concat(g_VictoryConditions[g_VictoryConditions.map(data =>
 			data.Name).indexOf(victoryConditionName)].Scripts.filter(script => scripts.indexOf(script) == -1)),
 		[]);
 
 	g_GameAttributes.settings.TriggerScripts = g_GameAttributes.settings.VictoryScripts.concat(g_GameAttributes.settings.TriggerScripts || []);
 
 	g_GameAttributes.settings.mapType = g_GameAttributes.mapType;
 
 	// Get a unique array of selectable cultures
 	let cultures = Object.keys(g_CivData).filter(civ => g_CivData[civ].SelectableInGameSetup).map(civ => g_CivData[civ].Culture);
 	cultures = cultures.filter((culture, index) => cultures.indexOf(culture) === index);
 
 	// Determine random civs and botnames
 	for (let i in g_GameAttributes.settings.PlayerData)
 	{
 		// Pick a random civ of a random culture
 		let chosenCiv = g_GameAttributes.settings.PlayerData[i].Civ || "random";
 		if (chosenCiv == "random")
 		{
 			let culture = pickRandom(cultures);
 			chosenCiv = pickRandom(Object.keys(g_CivData).filter(civ =>
 				g_CivData[civ].Culture == culture && g_CivData[civ].SelectableInGameSetup));
 		}
 		g_GameAttributes.settings.PlayerData[i].Civ = chosenCiv;
 
 		// Pick one of the available botnames for the chosen civ
 		if (g_GameAttributes.mapType === "scenario" || !g_GameAttributes.settings.PlayerData[i].AI)
 			continue;
 
 		let chosenName = pickRandom(g_CivData[chosenCiv].AINames);
 
 		if (!g_IsNetworked)
 			chosenName = translate(chosenName);
 
 		// Count how many players use the chosenName
 		let usedName = g_GameAttributes.settings.PlayerData.filter(pData => pData.Name && pData.Name.indexOf(chosenName) !== -1).length;
 
 		g_GameAttributes.settings.PlayerData[i].Name = !usedName ? chosenName :
 			sprintf(translate("%(playerName)s %(romanNumber)s"), {
 				"playerName": chosenName,
 				"romanNumber": g_RomanNumbers[usedName+1]
 			});
 	}
 
 	// Copy playernames for the purpose of replays
 	for (let guid in g_PlayerAssignments)
 	{
 		let player = g_PlayerAssignments[guid];
 		if (player.player > 0)	// not observer or GAIA
 			g_GameAttributes.settings.PlayerData[player.player - 1].Name = player.name;
 	}
 
 	// Seed used for both map generation and simulation
 	g_GameAttributes.settings.Seed = randIntExclusive(0, Math.pow(2, 32));
 	g_GameAttributes.settings.AISeed = randIntExclusive(0, Math.pow(2, 32));
 
 	// Used for identifying rated game reports for the lobby
 	g_GameAttributes.matchID = Engine.GetMatchID();
 
 	if (g_IsNetworked)
 	{
 		Engine.SetNetworkGameAttributes(g_GameAttributes);
 		Engine.StartNetworkGame();
 	}
 	else
 	{
 		// Find the player ID which the user has been assigned to
 		let playerID = -1;
 		for (let i in g_GameAttributes.settings.PlayerData)
 		{
 			let assignBox = Engine.GetGUIObjectByName("playerAssignment[" + i + "]");
 			if (assignBox.list_data[assignBox.selected] == "guid:local")
 				playerID = +i + 1;
 		}
 
 		Engine.StartGame(g_GameAttributes, playerID);
 		Engine.SwitchGuiPage("page_loading.xml", {
 			"attribs": g_GameAttributes,
 			"playerAssignments": g_PlayerAssignments
 		});
 	}
 }
 
 function launchTutorial()
 {
 	g_GameAttributes.mapType = "scenario";
 	selectMap("maps/tutorials/starting_economy_walkthrough");
 	launchGame();
 }
 
 /**
  * Don't set any attributes here, just show the changes in the GUI.
  *
  * Unless the mapsettings don't specify a property and the user didn't set it in g_GameAttributes previously.
  */
 function updateGUIObjects()
 {
 	g_IsInGuiUpdate = true;
 
 	reloadMapFilterList();
 	reloadMapSpecific();
 	reloadGameSpeedChoices();
 	reloadPlayerAssignmentChoices();
 
 	// Hide exceeding dropdowns and checkboxes
 	for (let setting of Engine.GetGUIObjectByName("settingsPanel").children)
 		setting.hidden = true;
 
 	// Show the relevant ones
 	if (g_TabCategorySelected !== undefined)
 	{
 		for (let name in g_Dropdowns)
 			if (g_SettingsTabsGUI[g_TabCategorySelected].settings.indexOf(name) != -1)
 				updateGUIDropdown(name);
 
 		for (let name in g_Checkboxes)
 			if (g_SettingsTabsGUI[g_TabCategorySelected].settings.indexOf(name) != -1)
 				updateGUICheckbox(name);
 	}
 
 	for (let i = 0; i < g_MaxPlayers; ++i)
 	{
 		for (let name in g_PlayerDropdowns)
 			updateGUIDropdown(name, i);
 
 		for (let name in g_PlayerMiscElements)
 			updateGUIMiscControl(name, i);
 	}
 
 	for (let name in g_MiscControls)
 		updateGUIMiscControl(name);
 
-	updateGameDescription();
 	distributeSettings();
 	rightAlignCancelButton();
 	updateAutocompleteEntries();
 
 	g_IsInGuiUpdate = false;
 
 	// Refresh AI config page
 	if (g_LastViewedAIPlayer != -1)
 	{
 		Engine.PopGuiPage();
 		openAIConfig(g_LastViewedAIPlayer);
 	}
 }
 
 function rightAlignCancelButton()
 {
 	let offset = 10;
 
 	let startGame = Engine.GetGUIObjectByName("startGame");
 	let right = startGame.hidden ? startGame.size.right : startGame.size.left - offset;
 
 	let cancelGame = Engine.GetGUIObjectByName("cancelGame");
 	let cancelGameSize = cancelGame.size;
 	let buttonWidth = cancelGameSize.right - cancelGameSize.left;
 	cancelGameSize.right = right;
 	right -= buttonWidth;
 
 	for (let element of ["cheatWarningText", "onscreenToolTip"])
 	{
 		let elementSize = Engine.GetGUIObjectByName(element).size;
 		elementSize.right = right - (cancelGameSize.left - elementSize.right);
 		Engine.GetGUIObjectByName(element).size = elementSize;
 	}
 
 	cancelGameSize.left = right;
 	cancelGame.size = cancelGameSize;
 }
 
-function updateGameDescription()
-{
-	setMapPreviewImage("mapPreview", getMapPreview(g_GameAttributes.map));
-
-	Engine.GetGUIObjectByName("mapInfoName").caption =
-		translateMapTitle(getMapDisplayName(g_GameAttributes.map));
-
-	Engine.GetGUIObjectByName("mapInfoDescription").caption = getGameDescription();
-}
-
 /**
  * Broadcast the changed settings to all clients and the lobbybot.
  */
 function updateGameAttributes()
 {
 	if (g_IsInGuiUpdate || !g_IsController)
 		return;
 
 	if (g_IsNetworked)
 	{
 		Engine.SetNetworkGameAttributes(g_GameAttributes);
 		if (g_LoadingState >= 2)
 			sendRegisterGameStanza();
 		resetReadyData();
 	}
 	else
 		updateGUIObjects();
 }
 
 function openAIConfig(playerSlot)
 {
 	g_LastViewedAIPlayer = playerSlot;
 
 	Engine.PushGuiPage(
 		"page_aiconfig.xml",
 		{
 			"playerSlot": playerSlot,
 			"id": g_GameAttributes.settings.PlayerData[playerSlot].AI,
 			"difficulty": g_GameAttributes.settings.PlayerData[playerSlot].AIDiff,
 			"behavior": g_GameAttributes.settings.PlayerData[playerSlot].AIBehavior
 		},
 		ai => {
 			g_LastViewedAIPlayer = -1;
 
 			if (!ai.save || !g_IsController)
 				return;
 
 			g_GameAttributes.settings.PlayerData[ai.playerSlot].AI = ai.id;
 			g_GameAttributes.settings.PlayerData[ai.playerSlot].AIDiff = ai.difficulty;
 			g_GameAttributes.settings.PlayerData[ai.playerSlot].AIBehavior = ai.behavior;
 
 			updateGameAttributes();
 		});
 }
 
 function reloadPlayerAssignmentChoices()
 {
 	let playerChoices = sortGUIDsByPlayerID().map(guid => ({
 		"Choice": "guid:" + guid,
 		"Color": g_PlayerAssignments[guid].player == -1 ? g_PlayerAssignmentColors.observer : g_PlayerAssignmentColors.player,
 		"Name": g_PlayerAssignments[guid].name
 	}));
 
 	// Only display hidden AIs if the map preselects them
 	let aiChoices = g_Settings.AIDescriptions
 		.filter(ai => !ai.data.hidden || g_GameAttributes.settings.PlayerData.some(pData => pData.AI == ai.id))
 		.map(ai => ({
 			"Choice": "ai:" + ai.id,
 			"Name": sprintf(translate("AI: %(ai)s"), {
 				"ai": translate(ai.data.name)
 			}),
 			"Color": g_PlayerAssignmentColors.AI
 		}));
 
 	let unassignedSlot = [{
 		"Choice": "unassigned",
 		"Name": translate("Unassigned"),
 		"Color": g_PlayerAssignmentColors.unassigned
 	}];
 	g_PlayerAssignmentList = prepareForDropdown(playerChoices.concat(aiChoices).concat(unassignedSlot));
 
 	initPlayerDropdowns("playerAssignment");
 }
 
 function swapPlayers(guidToSwap, newSlot)
 {
 	// Player slots are indexed from 0 as Gaia is omitted.
 	let newPlayerID = newSlot + 1;
 	let playerID = g_PlayerAssignments[guidToSwap].player;
 
 	// Attempt to swap the player or AI occupying the target slot,
 	// if any, into the slot this player is currently in.
 	if (playerID != -1)
 	{
 		for (let guid in g_PlayerAssignments)
 		{
 			// Move the player in the destination slot into the current slot.
 			if (g_PlayerAssignments[guid].player != newPlayerID)
 				continue;
 
 			if (g_IsNetworked)
 				Engine.AssignNetworkPlayer(playerID, guid);
 			else
 				g_PlayerAssignments[guid].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;
 		g_GameAttributes.settings.PlayerData[playerID - 1].AIDiff = g_GameAttributes.settings.PlayerData[newSlot].AIDiff;
 		g_GameAttributes.settings.PlayerData[playerID - 1].AIBehavior = g_GameAttributes.settings.PlayerData[newSlot].AIBehavior;
 
 		// Swap civilizations and colors if they aren't fixed
 		if (g_GameAttributes.mapType != "scenario")
 		{
 			[g_GameAttributes.settings.PlayerData[playerID - 1].Civ, g_GameAttributes.settings.PlayerData[newSlot].Civ] =
 				[g_GameAttributes.settings.PlayerData[newSlot].Civ, g_GameAttributes.settings.PlayerData[playerID - 1].Civ];
 			[g_GameAttributes.settings.PlayerData[playerID - 1].Color, g_GameAttributes.settings.PlayerData[newSlot].Color] =
 				[g_GameAttributes.settings.PlayerData[newSlot].Color, g_GameAttributes.settings.PlayerData[playerID - 1].Color];
 		}
 	}
 
 	if (g_IsNetworked)
 		Engine.AssignNetworkPlayer(newPlayerID, guidToSwap);
 	else
 		g_PlayerAssignments[guidToSwap].player = newPlayerID;
 
 	g_GameAttributes.settings.PlayerData[newSlot].AI = "";
 }
 
 function submitChatInput()
 {
 	let chatInput = Engine.GetGUIObjectByName("chatInput");
 	let text = chatInput.caption;
 	if (!text.length)
 		return;
 
 	chatInput.caption = "";
 
 	if (!executeNetworkCommand(text))
 		Engine.SendNetworkChat(text);
 
 	chatInput.focus();
 }
 
 function senderFont(text)
 {
 	return '[font="' + g_SenderFont + '"]' + text + '[/font]';
 }
 
 function systemMessage(message)
 {
 	return senderFont(sprintf(translate("== %(message)s"), { "message": message }));
 }
 
 function colorizePlayernameByGUID(guid, username = "")
 {
 	// TODO: Maybe the host should have the moderator-prefix?
 	if (!username)
 		username = g_PlayerAssignments[guid] ? escapeText(g_PlayerAssignments[guid].name) : translate("Unknown Player");
 	let playerID = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].player : -1;
 
 	let color = g_ColorRegular;
 	if (playerID > 0)
 	{
 		color = g_GameAttributes.settings.PlayerData[playerID - 1].Color;
 
 		// Enlighten playercolor to improve readability
 		let [h, s, l] = rgbToHsl(color.r, color.g, color.b);
 		let [r, g, b] = hslToRgb(h, s, Math.max(0.6, l));
 
 		color = rgbToGuiColor({ "r": r, "g": g, "b": b });
 	}
 
 	return coloredText(username, color);
 }
 
 function addChatMessage(msg)
 {
 	if (!g_FormatChatMessage[msg.type])
 		return;
 
 	if (msg.type == "chat")
 	{
 		let userName = g_PlayerAssignments[Engine.GetPlayerGUID()].name;
 		if (userName != g_PlayerAssignments[msg.guid].name &&
 		    msg.text.toLowerCase().indexOf(splitRatingFromNick(userName).nick.toLowerCase()) != -1)
 			soundNotification("nick");
 	}
 
 	let user = colorizePlayernameByGUID(msg.guid || -1, msg.username || "");
 
 	let text = g_FormatChatMessage[msg.type](msg, user);
 
 	if (!text)
 		return;
 
 	if (Engine.ConfigDB_GetValue("user", "chat.timestamp") == "true")
 		text = sprintf(translate("%(time)s %(message)s"), {
 			"time": sprintf(translate("\\[%(time)s]"), {
 				"time": Engine.FormatMillisecondsIntoDateStringLocal(Date.now(), translate("HH:mm"))
 			}),
 			"message": text
 		});
 
 	g_ChatMessages.push(text);
 
 	Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 }
 
 function clearChatMessages()
 {
 	g_ChatMessages.length = 0;
 	Engine.GetGUIObjectByName("chatText").caption = "";
 }
 
 function resetCivilizations()
 {
 	for (let i in g_GameAttributes.settings.PlayerData)
 		g_GameAttributes.settings.PlayerData[i].Civ = "random";
 
 	updateGameAttributes();
 }
 
 function resetTeams()
 {
 	for (let i in g_GameAttributes.settings.PlayerData)
 		g_GameAttributes.settings.PlayerData[i].Team = -1;
 
 	updateGameAttributes();
 }
 
 function toggleReady()
 {
 	setReady((g_IsReady + 1) % 3, true);
 }
 
 function setReady(ready, sendMessage)
 {
 	g_IsReady = ready;
 
 	if (sendMessage)
 		Engine.SendNetworkReady(g_IsReady);
 
 	updateGUIObjects();
 }
 
 function resetReadyData()
 {
 	if (g_GameStarted)
 		return;
 
 	if (g_ReadyChanged < 1)
 		addChatMessage({ "type": "settings" });
 	else if (g_ReadyChanged == 2 && !g_ReadyInit)
 		return; // duplicate calls on init
 	else
 		g_ReadyInit = false;
 
 	g_ReadyChanged = 2;
 	if (!g_IsNetworked)
 		g_IsReady = 2;
 	else if (g_IsController)
 	{
 		Engine.ClearAllPlayerReady();
 		setReady(2, true);
 	}
 	else if (g_IsReady != 2)
 		setReady(0, false);
 }
 
 /**
  * Send a list of playernames and distinct between players and observers.
  * Don't send teams, AIs or anything else until the game was started.
  * The playerData format from g_GameAttributes is kept to reuse the GUI function presenting the data.
  */
 function formatClientsForStanza()
 {
 	let connectedPlayers = 0;
 	let playerData = [];
 
 	for (let guid in g_PlayerAssignments)
 	{
 		let pData = { "Name": g_PlayerAssignments[guid].name };
 
 		if (g_GameAttributes.settings.PlayerData[g_PlayerAssignments[guid].player - 1])
 			++connectedPlayers;
 		else
 			pData.Team = "observer";
 
 		playerData.push(pData);
 	}
 
 	return {
 		"list": playerDataToStringifiedTeamList(playerData),
 		"connectedPlayers": connectedPlayers
 	};
 }
 
 /**
  * Send the relevant gamesettings to the lobbybot immediately.
  */
 function sendRegisterGameStanzaImmediate()
 {
 	if (!g_IsController || !Engine.HasXmppClient())
 		return;
 
 	if (g_GameStanzaTimer !== undefined)
 	{
 		clearTimeout(g_GameStanzaTimer);
 		g_GameStanzaTimer = undefined;
 	}
 
 	let clients = formatClientsForStanza();
 
 	let stanza = {
 		"name": g_ServerName,
 		"port": g_ServerPort,
 		"hostUsername": Engine.LobbyGetNick(),
 		"mapName": g_GameAttributes.map,
 		"niceMapName": getMapDisplayName(g_GameAttributes.map),
 		"mapSize": g_GameAttributes.mapType == "random" ? g_GameAttributes.settings.Size : "Default",
 		"mapType": g_GameAttributes.mapType,
 		"victoryConditions": g_GameAttributes.settings.VictoryConditions.join(","),
 		"nbp": clients.connectedPlayers,
 		"maxnbp": g_GameAttributes.settings.PlayerData.length,
 		"players": clients.list,
 		"stunIP": g_StunEndpoint ? g_StunEndpoint.ip : "",
 		"stunPort": g_StunEndpoint ? g_StunEndpoint.port : "",
 		"mods": JSON.stringify(Engine.GetEngineInfo().mods),
 	};
 
 	// Only send the stanza if the relevant settings actually changed
 	if (g_LastGameStanza && Object.keys(stanza).every(prop => g_LastGameStanza[prop] == stanza[prop]))
 		return;
 
 	g_LastGameStanza = stanza;
 	Engine.SendRegisterGame(stanza);
 }
 
 /**
  * Send the relevant gamesettings to the lobbybot in a deferred manner.
  */
 function sendRegisterGameStanza()
 {
 	if (!g_IsController || !Engine.HasXmppClient())
 		return;
 
 	if (g_GameStanzaTimer !== undefined)
 		clearTimeout(g_GameStanzaTimer);
 
 	g_GameStanzaTimer = setTimeout(sendRegisterGameStanzaImmediate, g_GameStanzaTimeout * 1000);
 }
 
 /**
  * Figures out all strings that can be autocompleted and sorts
  * them by priority (so that playernames are always autocompleted first).
  */
 function updateAutocompleteEntries()
 {
 	let autocomplete = { "0": [] };
 
 	for (let control of [g_Dropdowns, g_Checkboxes])
 		for (let name in control)
 			autocomplete[0] = autocomplete[0].concat(control[name].title());
 
 	for (let dropdown of [g_Dropdowns, g_PlayerDropdowns])
 		for (let name in dropdown)
 		{
 			let priority = dropdown[name].autocomplete;
 			if (priority === undefined)
 				continue;
 
 			autocomplete[priority] = (autocomplete[priority] || []).concat(dropdown[name].labels());
 		}
 
 	g_Autocomplete = Object.keys(autocomplete).sort().reverse().reduce((all, priority) => all.concat(autocomplete[priority]), []);
 }
 
 function storeCivInfoPage(data)
 {
 	if (data.nextPage)
 		Engine.PushGuiPage(
 			data.nextPage,
 			{ "civ": data.civ },
 			storeCivInfoPage);
 	else
 		g_CivInfo = data;
 }
Index: ps/trunk/binaries/data/mods/public/gui/loadgame/load.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/loadgame/load.js	(revision 22825)
+++ ps/trunk/binaries/data/mods/public/gui/loadgame/load.js	(revision 22826)
@@ -1,202 +1,201 @@
 var g_SavedGamesMetadata = [];
 
 /**
  * Needed for formatPlayerInfo to show the player civs in the details.
  */
 const g_CivData = loadCivData(false, false);
 
 function init()
 {
 	let savedGames = Engine.GetSavedGames();
 
 	// Get current game version and loaded mods
 	let engineInfo = Engine.GetEngineInfo();
 
 	if (Engine.GetGUIObjectByName("compatibilityFilter").checked)
 		savedGames = savedGames.filter(game => isCompatibleSavegame(game.metadata, engineInfo));
 
 	let gameSelection = Engine.GetGUIObjectByName("gameSelection");
 	gameSelection.enabled = !!savedGames.length;
 	Engine.GetGUIObjectByName("gameSelectionFeedback").hidden = !!savedGames.length;
 
 	let selectedGameId = gameSelection.list_data[gameSelection.selected];
 
 	// Save metadata for the detailed view
 	g_SavedGamesMetadata = savedGames.map(game => {
 		game.metadata.id = game.id;
 		return game.metadata;
 	});
 
 	let sortKey = gameSelection.selected_column;
 	let sortOrder = gameSelection.selected_column_order;
 	g_SavedGamesMetadata = g_SavedGamesMetadata.sort((a, b) => {
 		let cmpA, cmpB;
 		switch (sortKey)
 		{
 		case 'date':
 			cmpA = +a.time;
 			cmpB = +b.time;
 			break;
 		case 'mapName':
 			cmpA = translate(a.initAttributes.settings.Name);
 			cmpB = translate(b.initAttributes.settings.Name);
 			break;
 		case 'mapType':
 			cmpA = translateMapType(a.initAttributes.mapType);
 			cmpB = translateMapType(b.initAttributes.mapType);
 			break;
 		case 'description':
 			cmpA = a.description;
 			cmpB = b.description;
 			break;
 		}
 
 		if (cmpA < cmpB)
 			return -sortOrder;
 		else if (cmpA > cmpB)
 			return +sortOrder;
 
 		return 0;
 	});
 
 	let list = g_SavedGamesMetadata.map(metadata => {
 		let isCompatible = isCompatibleSavegame(metadata, engineInfo);
 		return {
 			"date": generateSavegameDateString(metadata, engineInfo),
 			"mapName": compatibilityColor(translate(metadata.initAttributes.settings.Name), isCompatible),
 			"mapType": compatibilityColor(translateMapType(metadata.initAttributes.mapType), isCompatible),
 			"description": compatibilityColor(metadata.description, isCompatible)
 		};
 	});
 
 	if (list.length)
 		list = prepareForDropdown(list);
 
 	gameSelection.list_date = list.date || [];
 	gameSelection.list_mapName = list.mapName || [];
 	gameSelection.list_mapType = list.mapType || [];
 	gameSelection.list_description = list.description || [];
 
 	// Change these last, otherwise crash
 	// list strings used in the delete dialog
 	gameSelection.list = g_SavedGamesMetadata.map(metadata => generateSavegameLabel(metadata, engineInfo));
 	gameSelection.list_data = g_SavedGamesMetadata.map(metadata => metadata.id);
 
 	let selectedGameIndex = g_SavedGamesMetadata.findIndex(metadata => metadata.id == selectedGameId);
 	if (selectedGameIndex != -1)
 		gameSelection.selected = selectedGameIndex;
 	else if (gameSelection.selected >= g_SavedGamesMetadata.length) // happens when deleting the last saved game
 		gameSelection.selected = g_SavedGamesMetadata.length - 1;
 	else if (gameSelection.selected == -1 && g_SavedGamesMetadata.length)
 		gameSelection.selected = 0;
 	selectionChanged();
 
 	Engine.GetGUIObjectByName("deleteGameButton").tooltip = deleteTooltip();
 }
 
 function selectionChanged()
 {
 	let metadata = g_SavedGamesMetadata[Engine.GetGUIObjectByName("gameSelection").selected];
 	Engine.GetGUIObjectByName("invalidGame").hidden = !!metadata;
 	Engine.GetGUIObjectByName("validGame").hidden = !metadata;
 	Engine.GetGUIObjectByName("loadGameButton").enabled = !!metadata;
 	Engine.GetGUIObjectByName("deleteGameButton").enabled = !!metadata;
 
 	if (!metadata)
 		return;
 
 	Engine.GetGUIObjectByName("savedMapName").caption = translate(metadata.initAttributes.settings.Name);
-	let mapData = getMapDescriptionAndPreview(metadata.initAttributes.mapType, metadata.initAttributes.map, metadata.initAttributes);
-	setMapPreviewImage("savedInfoPreview", mapData.preview);
-
+	Engine.GetGUIObjectByName("savedInfoPreview").sprite = getMapPreviewImage(
+		getMapDescriptionAndPreview(metadata.initAttributes.mapType, metadata.initAttributes.map, metadata.initAttributes).preview);
 	Engine.GetGUIObjectByName("savedPlayers").caption = metadata.initAttributes.settings.PlayerData.length - 1;
 	Engine.GetGUIObjectByName("savedPlayedTime").caption = timeToString(metadata.gui.timeElapsed ? metadata.gui.timeElapsed : 0);
 	Engine.GetGUIObjectByName("savedMapType").caption = translateMapType(metadata.initAttributes.mapType);
 	Engine.GetGUIObjectByName("savedMapSize").caption = translateMapSize(metadata.initAttributes.settings.Size);
 	Engine.GetGUIObjectByName("savedVictory").caption = metadata.initAttributes.settings.VictoryConditions.map(victoryConditionName => translateVictoryCondition(victoryConditionName)).join(translate(", "));
 
 	let caption = sprintf(translate("Mods: %(mods)s"), { "mods": modsToString(metadata.mods) });
 	if (!hasSameMods(metadata.mods, Engine.GetEngineInfo().mods))
 		caption = coloredText(caption, "orange");
 	Engine.GetGUIObjectByName("savedMods").caption = caption;
 
 	Engine.GetGUIObjectByName("savedPlayersNames").caption = formatPlayerInfo(
 		metadata.initAttributes.settings.PlayerData,
 		metadata.gui.states
 	);
 }
 
 function loadGame()
 {
 	let gameSelection = Engine.GetGUIObjectByName("gameSelection");
 	let gameId = gameSelection.list_data[gameSelection.selected];
 	let metadata = g_SavedGamesMetadata[gameSelection.selected];
 
 	// Check compatibility before really loading it
 	let engineInfo = Engine.GetEngineInfo();
 	let sameMods = hasSameMods(metadata.mods, engineInfo.mods);
 	let sameEngineVersion = hasSameEngineVersion(metadata, engineInfo);
 
 	if (sameEngineVersion && sameMods)
 	{
 		reallyLoadGame(gameId);
 		return;
 	}
 
 	// Version not compatible ... ask for confirmation
 	let message = "";
 
 	if (!sameEngineVersion)
 		if (metadata.engine_version)
 			message += sprintf(translate("This savegame needs 0 A.D. version %(requiredVersion)s, while you are running version %(currentVersion)s."), {
 				"requiredVersion": metadata.engine_version,
 				"currentVersion": engineInfo.engine_version
 			}) + "\n";
 		else
 			message += translate("This savegame needs an older version of 0 A.D.") + "\n";
 
 	if (!sameMods)
 	{
 		if (!metadata.mods)
 			metadata.mods = [];
 
 		message += translate("This savegame needs a different sequence of mods:") + "\n" +
 			comparedModsString(metadata.mods, engineInfo.mods) + "\n";
 	}
 
 	message += translate("Do you still want to proceed?");
 
 	messageBox(
 		500, 250,
 		message,
 		translate("Warning"),
 		[translate("No"), translate("Yes")],
 		[init, function(){ reallyLoadGame(gameId); }]
 	);
 }
 
 function reallyLoadGame(gameId)
 {
 	let metadata = Engine.StartSavedGame(gameId);
 	if (!metadata)
 	{
 		// Probably the file wasn't found
 		// Show error and refresh saved game list
 		error("Could not load saved game: " + gameId);
 		init();
 		return;
 	}
 
 	let pData = metadata.initAttributes.settings.PlayerData[metadata.playerID];
 
 	Engine.SwitchGuiPage("page_loading.xml", {
 		"attribs": metadata.initAttributes,
 		"playerAssignments": {
 			"local": {
 				"name": pData ? pData.Name : singleplayerName(),
 				"player": metadata.playerID
 			}
 		},
 		"savedGUIData": metadata.gui
 	});
 }
Index: ps/trunk/binaries/data/mods/public/gui/lobby/lobby.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/lobby/lobby.js	(revision 22825)
+++ ps/trunk/binaries/data/mods/public/gui/lobby/lobby.js	(revision 22826)
@@ -1,1598 +1,1597 @@
 /**
  * Used for the gamelist-filtering.
  */
 const g_MapSizes = prepareForDropdown(g_Settings && g_Settings.MapSizes);
 
 /**
  * Used for the gamelist-filtering.
  */
 const g_MapTypes = prepareForDropdown(g_Settings && g_Settings.MapTypes);
 
 /**
  * Used for civ settings display of the selected game.
  */
 const g_CivData = loadCivData(false, false);
 
 /**
  * A symbol which is prepended to the username of moderators.
  */
 var g_ModeratorPrefix = "@";
 
 /**
  * Current username. Cannot contain whitespace.
  */
 const g_Username = Engine.LobbyGetNick();
 
 /**
  * Lobby server address to construct host JID.
  */
 const g_LobbyServer = Engine.ConfigDB_GetValue("user", "lobby.server");
 
 /**
  * Current games will be listed in these colors.
  */
 var g_GameColors = {
 	"init": "0 219 0",
 	"waiting": "255 127 0",
 	"running": "219 0 0",
 	"incompatible": "gray"
 };
 
 /**
  * Initial sorting order of the gamelist.
  */
 var g_GameStatusOrder = ["init", "waiting", "running", "incompatible"];
 
 /**
  * The playerlist will be assembled using these values.
  */
 var g_PlayerStatuses = {
 	"available": { "color": "0 219 0",     "status": translate("Online") },
 	"away":      { "color": "229 76 13",   "status": translate("Away") },
 	"playing":   { "color": "200 0 0",     "status": translate("Busy") },
 	"offline":   { "color": "0 0 0",       "status": translate("Offline") },
 	"unknown":   { "color": "178 178 178", "status": translateWithContext("lobby presence", "Unknown") }
 };
 
 var g_RoleNames = {
 	"moderator": translate("Moderator"),
 	"participant": translate("Player"),
 	"visitor": translate("Muted Player")
 };
 
 /**
  * Color for error messages in the chat.
  */
 var g_SystemColor = "150 0 0";
 
 /**
  * Color for private messages in the chat.
  */
 var g_PrivateMessageColor = "0 150 0";
 
 /**
  * Used for highlighting the sender of chat messages.
  */
 var g_SenderFont = "sans-bold-13";
 
 /**
  * Color to highlight chat commands in the explanation.
  */
 var g_ChatCommandColor = "200 200 255";
 
 /**
  * Indicates if the lobby is opened as a dialog or window.
  */
 var g_Dialog = false;
 
 /**
  * All chat messages received since init (i.e. after lobby join and after returning from a game).
  */
 var g_ChatMessages = [];
 
 /**
  * Rating of the current user.
  * Contains the number or an empty string in case the user has no rating.
  */
 var g_UserRating = "";
 
 /**
  * All games currently running.
  */
 var g_GameList = [];
 
 /**
  * Used to restore the selection after updating the playerlist.
  */
 var g_SelectedPlayer = "";
 
 /**
  * Used to restore the selection after updating the gamelist.
  */
 var g_SelectedGameIP = "";
 
 /**
  * Used to restore the selection after updating the gamelist.
  */
 var g_SelectedGamePort = "";
 
 /**
  * Whether the current user has been kicked or banned.
  */
 var g_Kicked = false;
 
 /**
  * Whether the player was already asked to reconnect to the lobby.
  * Ensures that no more than one message box is opened at a time.
  */
 var g_AskedReconnect = false;
 
 /**
  * Processing of notifications sent by XmppClient.cpp.
  *
  * @returns true if the playerlist GUI must be updated.
  */
 var g_NetMessageTypes = {
 	"system": {
 		// Three cases are handled in prelobby.js
 		"registered": msg => false,
 		"connected": msg => {
 
 			g_AskedReconnect = false;
 			updateConnectedState();
 			return false;
 		},
 		"disconnected": msg => {
 
 			updateGameList();
 			updateLeaderboard();
 			updateConnectedState();
 
 			if (!g_Kicked)
 			{
 				addChatMessage({
 					"from": "system",
 					"time": msg.time,
 					"text": translate("Disconnected.") + " " + msg.reason
 				});
 				reconnectMessageBox();
 			}
 
 			return true;
 		},
 		"error": msg => {
 			addChatMessage({
 				"from": "system",
 				"time": msg.time,
 				"text": msg.text
 			});
 			return false;
 		}
 	},
 	"chat": {
 		"subject": msg => {
 			updateSubject(msg.subject);
 
 			if (msg.nick)
 				addChatMessage({
 					"text": "/special " + sprintf(translate("%(nick)s changed the lobby subject to %(subject)s"), {
 						"nick": msg.nick,
 						"subject": msg.subject
 					}),
 					"time": msg.time,
 					"isSpecial": true
 				});
 			return false;
 		},
 		"join": msg => {
 			addChatMessage({
 				"text": "/special " + sprintf(translate("%(nick)s has joined."), {
 					"nick": msg.nick
 				}),
 				"time": msg.time,
 				"isSpecial": true
 			});
 			return true;
 		},
 		"leave": msg => {
 			addChatMessage({
 				"text": "/special " + sprintf(translate("%(nick)s has left."), {
 					"nick": msg.nick
 				}),
 				"time": msg.time,
 				"isSpecial": true
 			});
 
 			if (msg.nick == g_Username)
 				Engine.DisconnectXmppClient();
 
 			return true;
 		},
 		"presence": msg => true,
 		"role": msg => {
 			Engine.GetGUIObjectByName("chatInput").hidden = Engine.LobbyGetPlayerRole(g_Username) == "visitor";
 
 			let me = g_Username == msg.nick;
 			let newrole = Engine.LobbyGetPlayerRole(msg.nick);
 			let txt =
 				newrole == "visitor" ?
 					me ?
 						translate("You have been muted.") :
 						translate("%(nick)s has been muted.") :
 				newrole == "moderator" ?
 					me ?
 						translate("You are now a moderator.") :
 						translate("%(nick)s is now a moderator.") :
 				msg.oldrole == "visitor" ?
 					me ?
 						translate("You have been unmuted.") :
 						translate("%(nick)s has been unmuted.") :
 					me ?
 						translate("You are not a moderator anymore.") :
 						translate("%(nick)s is not a moderator anymore.");
 
 			addChatMessage({
 				"text": "/special " + sprintf(txt, { "nick": msg.nick }),
 				"time": msg.time,
 				"isSpecial": true
 			});
 
 			if (g_SelectedPlayer == msg.nick)
 				updateUserRoleText(g_SelectedPlayer);
 
 			return false;
 		},
 		"nick": msg => {
 			addChatMessage({
 				"text": "/special " + sprintf(translate("%(oldnick)s is now known as %(newnick)s."), {
 					"oldnick": msg.oldnick,
 					"newnick": msg.newnick
 				}),
 				"time": msg.time,
 				"isSpecial": true
 			});
 			return true;
 		},
 		"kicked": msg => {
 			handleKick(false, msg.nick, msg.reason, msg.time, msg.historic);
 			return true;
 		},
 		"banned": msg => {
 			handleKick(true, msg.nick, msg.reason, msg.time, msg.historic);
 			return true;
 		},
 		"room-message": msg => {
 			addChatMessage({
 				"from": escapeText(msg.from),
 				"text": escapeText(msg.text),
 				"time": msg.time,
 				"historic": msg.historic
 			});
 			return false;
 		},
 		"private-message": msg => {
 			// Announcements and the Message of the Day are sent by the server directly
 			if (!msg.from)
 				messageBox(
 					400, 250,
 					msg.text.trim(),
 					translate("Notice")
 				);
 
 			// We intend to not support private messages between users
 			if (!msg.from || Engine.LobbyGetPlayerRole(msg.from) == "moderator")
 				// some XMPP clients send trailing whitespace
 				addChatMessage({
 					"from": escapeText(msg.from || "system"),
 					"text": escapeText(msg.text.trim()),
 					"time": msg.time,
 					"historic": msg.historic,
 					"private": true
 				});
 			return false;
 		}
 	},
 	"game": {
 		"gamelist": msg => {
 			updateGameList();
 			return false;
 		},
 		"profile": msg => {
 			updateProfile();
 			return false;
 		},
 		"leaderboard": msg => {
 			updateLeaderboard();
 			return false;
 		},
 		"ratinglist": msg => {
 			return true;
 		}
 	}
 };
 
 /**
  * Commands that can be entered by clients via chat input.
  * A handler returns true if the user input should be sent as a chat message.
  */
 var g_ChatCommands = {
 	"away": {
 		"description": translate("Set your state to 'Away'."),
 		"handler": args => {
 			Engine.LobbySetPlayerPresence("away");
 			return false;
 		}
 	},
 	"back": {
 		"description": translate("Set your state to 'Online'."),
 		"handler": args => {
 			Engine.LobbySetPlayerPresence("available");
 			return false;
 		}
 	},
 	"kick": {
 		"description": translate("Kick a specified user from the lobby. Usage: /kick nick reason"),
 		"handler": args => {
 			Engine.LobbyKick(args[0] || "", args[1] || "");
 			return false;
 		},
 		"moderatorOnly": true
 	},
 	"ban": {
 		"description": translate("Ban a specified user from the lobby. Usage: /ban nick reason"),
 		"handler": args => {
 			Engine.LobbyBan(args[0] || "", args[1] || "");
 			return false;
 		},
 		"moderatorOnly": true
 	},
 	"help": {
 		"description": translate("Show this help."),
 		"handler": args => {
 			let isModerator = Engine.LobbyGetPlayerRole(g_Username) == "moderator";
 			let text = translate("Chat commands:");
 			for (let command in g_ChatCommands)
 				if (!g_ChatCommands[command].moderatorOnly || isModerator)
 					// Translation: Chat command help format
 					text += "\n" + sprintf(translate("%(command)s - %(description)s"), {
 						"command": coloredText(command, g_ChatCommandColor),
 						"description": g_ChatCommands[command].description
 					});
 
 			addChatMessage({
 				"from": "system",
 				"text": text
 			});
 			return false;
 		}
 	},
 	"me": {
 		"description": translate("Send a chat message about yourself. Example: /me goes swimming."),
 		"handler": args => true
 	},
 	"say": {
 		"description": translate("Send text as a chat message (even if it starts with slash). Example: /say /help is a great command."),
 		"handler": args => true
 	},
 	"clear": {
 		"description": translate("Clear all chat scrollback."),
 		"handler": args => {
 			clearChatMessages();
 			return false;
 		}
 	},
 	"quit": {
 		"description": translate("Return to the main menu."),
 		"handler": args => {
 			leaveLobby();
 			return false;
 		}
 	}
 };
 
 /**
  * Called after the XmppConnection succeeded and when returning from a game.
  *
  * @param {Object} attribs
  */
 function init(attribs)
 {
 	g_Dialog = attribs && attribs.dialog;
 
 	if (!g_Settings)
 	{
 		leaveLobby();
 		return;
 	}
 
 	initMusic();
 	global.music.setState(global.music.states.MENU);
 
 	initDialogStyle();
 	initGameFilters();
 	updateConnectedState();
 
 	Engine.LobbySetPlayerPresence("available");
 
 	// When rejoining the lobby after a game, we don't need to process presence changes
 	Engine.LobbyClearPresenceUpdates();
 	updatePlayerList();
 	updateSubject(Engine.LobbyGetRoomSubject());
 	updateLobbyColumns();
 
 	updateToggleBuddy();
 	Engine.GetGUIObjectByName("chatInput").tooltip = colorizeAutocompleteHotkey();
 
 	// Get all messages since the login
 	for (let msg of Engine.LobbyGuiPollHistoricMessages())
 		g_NetMessageTypes[msg.type][msg.level](msg);
 
 	if (!Engine.IsXmppClientConnected())
 		reconnectMessageBox();
 }
 
 function reconnectMessageBox()
 {
 	if (g_AskedReconnect)
 		return;
 
 	g_AskedReconnect = true;
 
 	messageBox(
 		400, 200,
 		translate("You have been disconnected from the lobby. Do you want to reconnect?"),
 		translate("Confirmation"),
 		[translate("No"), translate("Yes")],
 		[null, Engine.ConnectXmppClient]);
 }
 
 /**
  * Set style of GUI elements and the window style.
  */
 function initDialogStyle()
 {
 	let lobbyWindow = Engine.GetGUIObjectByName("lobbyWindow");
 	lobbyWindow.sprite = g_Dialog ? "ModernDialog" : "ModernWindow";
 	lobbyWindow.size = g_Dialog ? "42 42 100%-42 100%-42" : "0 0 100% 100%";
 	Engine.GetGUIObjectByName("lobbyWindowTitle").size = g_Dialog ? "50%-128 -16 50%+128 16" : "50%-128 4 50%+128 36";
 
 	Engine.GetGUIObjectByName("leaveButton").caption = g_Dialog ?
 		translateWithContext("previous page", "Back") :
 		translateWithContext("previous page", "Main Menu");
 
 	Engine.GetGUIObjectByName("hostButton").hidden = g_Dialog;
 	Engine.GetGUIObjectByName("joinGameButton").hidden = g_Dialog;
 	Engine.GetGUIObjectByName("gameInfoEmpty").size = "0 0 100% 100%-24" + (g_Dialog ? "" : "-30");
 	Engine.GetGUIObjectByName("gameInfo").size = "0 0 100% 100%-24" + (g_Dialog ? "" : "-60");
 
 	Engine.GetGUIObjectByName("middlePanel").size = "20%+5 " + (g_Dialog ? "18" : "40") + " 100%-255 100%-20";
 	Engine.GetGUIObjectByName("rightPanel").size = "100%-250 " + (g_Dialog ? "18" : "40") + " 100%-20 100%-20";
 	Engine.GetGUIObjectByName("leftPanel").size = "20 " + (g_Dialog ? "18" : "40") + " 20% 100%-315";
 
 	if (g_Dialog)
 	{
 		Engine.GetGUIObjectByName("lobbyDialogToggle").onPress = leaveLobby;
 		Engine.GetGUIObjectByName("cancelDialog").onPress = leaveLobby;
 	}
 }
 
 /**
  * Set style of GUI elements according to the connection state of the lobby.
  */
 function updateConnectedState()
 {
 	Engine.GetGUIObjectByName("chatInput").hidden = !Engine.IsXmppClientConnected();
 
 	for (let button of ["host", "leaderboard", "userprofile", "toggleBuddy"])
 		Engine.GetGUIObjectByName(button + "Button").enabled = Engine.IsXmppClientConnected();
 }
 
 function updateLobbyColumns()
 {
 	let gameRating = Engine.ConfigDB_GetValue("user", "lobby.columns.gamerating") == "true";
 
 	// Only show the selected columns
 	let gamesBox = Engine.GetGUIObjectByName("gamesBox");
 	gamesBox.hidden_mapType = gameRating;
 	gamesBox.hidden_gameRating = !gameRating;
 
 	// Only show the filters of selected columns
 	let mapTypeFilter = Engine.GetGUIObjectByName("mapTypeFilter");
 	mapTypeFilter.hidden = gameRating;
 	let gameRatingFilter = Engine.GetGUIObjectByName("gameRatingFilter");
 	gameRatingFilter.hidden = !gameRating;
 
 	// Keep filters right above the according column
 	let playersNumberFilter = Engine.GetGUIObjectByName("playersNumberFilter");
 	let size = playersNumberFilter.size;
 	size.rleft = gameRating ? 74 : 90;
 	size.rright = gameRating ? 84 : 100;
 	playersNumberFilter.size = size;
 }
 
 function leaveLobby()
 {
 	if (g_Dialog)
 	{
 		Engine.LobbySetPlayerPresence("playing");
 		Engine.PopGuiPage();
 	}
 	else
 	{
 		Engine.StopXmppClient();
 		Engine.SwitchGuiPage("page_pregame.xml");
 	}
 }
 
 function initGameFilters()
 {
 	let mapSizeFilter = Engine.GetGUIObjectByName("mapSizeFilter");
 	mapSizeFilter.list = [translateWithContext("map size", "Any")].concat(g_MapSizes.Name);
 	mapSizeFilter.list_data = [""].concat(g_MapSizes.Tiles);
 
 	let playersArray = Array(g_MaxPlayers).fill(0).map((v, i) => i + 1); // 1, 2, ... MaxPlayers
 	let playersNumberFilter = Engine.GetGUIObjectByName("playersNumberFilter");
 	playersNumberFilter.list = [translateWithContext("player number", "Any")].concat(playersArray);
 	playersNumberFilter.list_data = [""].concat(playersArray);
 
 	let mapTypeFilter = Engine.GetGUIObjectByName("mapTypeFilter");
 	mapTypeFilter.list = [translateWithContext("map", "Any")].concat(g_MapTypes.Title);
 	mapTypeFilter.list_data = [""].concat(g_MapTypes.Name);
 
 	let gameRatingOptions = [">1500", ">1400", ">1300", ">1200", "<1200", "<1100", "<1000"];
 	gameRatingOptions = prepareForDropdown(gameRatingOptions.map(r => ({
 		"value": r,
 		"label": sprintf(
 			r[0] == ">" ?
 				translateWithContext("gamelist filter", "> %(rating)s") :
 				translateWithContext("gamelist filter", "< %(rating)s"),
 			{ "rating": r.substr(1) })
 	})));
 
 	let gameRatingFilter = Engine.GetGUIObjectByName("gameRatingFilter");
 	gameRatingFilter.list = [translateWithContext("map", "Any")].concat(gameRatingOptions.label);
 	gameRatingFilter.list_data = [""].concat(gameRatingOptions.value);
 
 	resetFilters();
 }
 
 function resetFilters()
 {
 	Engine.GetGUIObjectByName("mapSizeFilter").selected = 0;
 	Engine.GetGUIObjectByName("playersNumberFilter").selected = 0;
 	Engine.GetGUIObjectByName("mapTypeFilter").selected = g_MapTypes.Default;
 	Engine.GetGUIObjectByName("gameRatingFilter").selected = 0;
 	Engine.GetGUIObjectByName("filterOpenGames").checked = false;
 
 	applyFilters();
 }
 
 function applyFilters()
 {
 	updateGameList();
 	updateGameSelection();
 }
 
 /**
  * Filter a game based on the status of the filter dropdowns.
  *
  * @param {Object} game
  * @returns {boolean} - True if game should not be displayed.
  */
 function filterGame(game)
 {
 	let mapSizeFilter = Engine.GetGUIObjectByName("mapSizeFilter");
 	let playersNumberFilter = Engine.GetGUIObjectByName("playersNumberFilter");
 	let mapTypeFilter = Engine.GetGUIObjectByName("mapTypeFilter");
 	let gameRatingFilter = Engine.GetGUIObjectByName("gameRatingFilter");
 	let filterOpenGames = Engine.GetGUIObjectByName("filterOpenGames");
 
 	// We assume index 0 means display all for any given filter.
 	if (mapSizeFilter.selected != 0 &&
 	    game.mapSize != mapSizeFilter.list_data[mapSizeFilter.selected])
 		return true;
 
 	if (playersNumberFilter.selected != 0 &&
 	    game.maxnbp != playersNumberFilter.list_data[playersNumberFilter.selected])
 		return true;
 
 	if (mapTypeFilter.selected != 0 &&
 	    game.mapType != mapTypeFilter.list_data[mapTypeFilter.selected])
 		return true;
 
 	if (filterOpenGames.checked && (game.nbp >= game.maxnbp || game.state != "init"))
 		return true;
 
 	if (gameRatingFilter.selected > 0)
 	{
 		let selected = gameRatingFilter.list_data[gameRatingFilter.selected];
 		if (selected.startsWith(">") && +selected.substr(1) >= game.gameRating ||
 		    selected.startsWith("<") && +selected.substr(1) <= game.gameRating)
 			return true;
 	}
 
 	return false;
 }
 
 function handleKick(banned, nick, reason, time, historic)
 {
 	let kickString = nick == g_Username ?
 		banned ?
 			translate("You have been banned from the lobby!") :
 			translate("You have been kicked from the lobby!") :
 		banned ?
 			translate("%(nick)s has been banned from the lobby.") :
 			translate("%(nick)s has been kicked from the lobby.");
 
 	if (reason)
 		reason = sprintf(translateWithContext("lobby kick", "Reason: %(reason)s"), {
 			"reason": reason
 		});
 
 	if (nick != g_Username)
 	{
 		addChatMessage({
 			"text": "/special " + sprintf(kickString, { "nick": nick }) + " " + reason,
 			"time": time,
 			"historic": historic,
 			"isSpecial": true
 		});
 		return;
 	}
 
 	addChatMessage({
 		"from": "system",
 		"time": time,
 		"text": kickString + " " + reason,
 	});
 
 	g_Kicked = true;
 
 	Engine.DisconnectXmppClient();
 
 	messageBox(
 		400, 250,
 		kickString + "\n" + reason,
 		banned ? translate("BANNED") : translate("KICKED")
 	);
 }
 
 /**
  * Update the subject GUI object.
  */
 function updateSubject(newSubject)
 {
 	Engine.GetGUIObjectByName("subject").caption = newSubject;
 
 	// If the subject is only whitespace, hide it and reposition the logo.
 	let subjectBox = Engine.GetGUIObjectByName("subjectBox");
 	subjectBox.hidden = !newSubject.trim();
 
 	let logo = Engine.GetGUIObjectByName("logo");
 	if (subjectBox.hidden)
 		logo.size = "50%-110 50%-50 50%+110 50%+50";
 	else
 		logo.size = "50%-110 40 50%+110 140";
 }
 
 /**
  * Update the caption of the toggle buddy button.
  */
 function updateToggleBuddy()
 {
 	let playerList = Engine.GetGUIObjectByName("playersBox");
 	let playerName = playerList.list[playerList.selected];
 
 	let toggleBuddyButton = Engine.GetGUIObjectByName("toggleBuddyButton");
 	toggleBuddyButton.caption = g_Buddies.indexOf(playerName) != -1 ? translate("Unmark as Buddy") : translate("Mark as Buddy");
 	toggleBuddyButton.enabled = !!playerName && playerName != g_Username;
 }
 
 /**
  * Do a full update of the player listing, including ratings from cached C++ information.
  */
 function updatePlayerList()
 {
 	let playersBox = Engine.GetGUIObjectByName("playersBox");
 	let sortBy = playersBox.selected_column || "name";
 	let sortOrder = playersBox.selected_column_order || 1;
 
 	let buddyStatusList = [];
 	let playerList = [];
 	let presenceList = [];
 	let nickList = [];
 	let ratingList = [];
 
 	let cleanPlayerList = Engine.GetPlayerList().map(player => {
 		player.isBuddy = g_Buddies.indexOf(player.name) != -1;
 		return player;
 	}).sort((a, b) => {
 		let sortA, sortB;
 		let statusOrder = Object.keys(g_PlayerStatuses);
 		let statusA = statusOrder.indexOf(a.presence) + a.name.toLowerCase();
 		let statusB = statusOrder.indexOf(b.presence) + b.name.toLowerCase();
 
 		switch (sortBy)
 		{
 		case 'buddy':
 			sortA = (a.isBuddy ? 1 : 2) + statusA;
 			sortB = (b.isBuddy ? 1 : 2) + statusB;
 			break;
 		case 'rating':
 			sortA = +a.rating;
 			sortB = +b.rating;
 			break;
 		case 'status':
 			sortA = statusA;
 			sortB = statusB;
 			break;
 		case 'name':
 		default:
 			sortA = a.name.toLowerCase();
 			sortB = b.name.toLowerCase();
 			break;
 		}
 		if (sortA < sortB) return -sortOrder;
 		if (sortA > sortB) return +sortOrder;
 		return 0;
 	});
 
 	// Colorize list entries
 	for (let player of cleanPlayerList)
 	{
 		if (player.rating && player.name == g_Username)
 			g_UserRating = player.rating;
 		let rating = player.rating ? ("     " + player.rating).substr(-5) : "     -";
 
 		let presence = g_PlayerStatuses[player.presence] ? player.presence : "unknown";
 		if (presence == "unknown")
 			warn("Unknown presence:" + player.presence);
 
 		let statusColor = g_PlayerStatuses[presence].color;
 		buddyStatusList.push(player.isBuddy ? coloredText(g_BuddySymbol, statusColor) : "");
 		playerList.push(colorPlayerName((player.role == "moderator" ? g_ModeratorPrefix : "") + player.name));
 		presenceList.push(coloredText(g_PlayerStatuses[presence].status, statusColor));
 		ratingList.push(coloredText(rating, statusColor));
 		nickList.push(player.name);
 	}
 
 	playersBox.list_buddy = buddyStatusList;
 	playersBox.list_name = playerList;
 	playersBox.list_status = presenceList;
 	playersBox.list_rating = ratingList;
 	playersBox.list = nickList;
 
 	playersBox.selected = playersBox.list.indexOf(g_SelectedPlayer);
 }
 
 /**
 * Toggle buddy state for a player in playerlist within the user config
 */
 function toggleBuddy()
 {
 	let playerList = Engine.GetGUIObjectByName("playersBox");
 	let name = playerList.list[playerList.selected];
 
 	if (!name || name == g_Username || name.indexOf(g_BuddyListDelimiter) != -1)
 		return;
 
 	let index = g_Buddies.indexOf(name);
 	if (index != -1)
 		g_Buddies.splice(index, 1);
 	else
 		g_Buddies.push(name);
 
 	updateToggleBuddy();
 
 	Engine.ConfigDB_CreateAndWriteValueToFile("user", "lobby.buddies", g_Buddies.filter(nick => nick).join(g_BuddyListDelimiter) || g_BuddyListDelimiter, "config/user.cfg");
 
 	updatePlayerList();
 	updateGameList();
 }
 
 /**
  * Select the game where the selected player is currently playing, observing or offline.
  * Selects in that order to account for players that occur in multiple games.
  */
 function selectGameFromPlayername()
 {
 	if (!g_SelectedPlayer)
 		return;
 
 	let gameList = Engine.GetGUIObjectByName("gamesBox");
 	let foundAsObserver = false;
 
 	for (let i = 0; i < g_GameList.length; ++i)
 		for (let player of stringifiedTeamListToPlayerData(g_GameList[i].players))
 		{
 			if (g_SelectedPlayer != splitRatingFromNick(player.Name).nick)
 				continue;
 
 			gameList.auto_scroll = true;
 			if (player.Team == "observer")
 			{
 				foundAsObserver = true;
 				gameList.selected = i;
 			}
 			else if (!player.Offline)
 			{
 				gameList.selected = i;
 				return;
 			}
 			else if (!foundAsObserver)
 				gameList.selected = i;
 		}
 }
 
 function onPlayerListSelection()
 {
 	let playerList = Engine.GetGUIObjectByName("playersBox");
 	if (playerList.selected == playerList.list.indexOf(g_SelectedPlayer))
 		return;
 
 	g_SelectedPlayer = playerList.list[playerList.selected];
 	lookupSelectedUserProfile("playersBox");
 	updateToggleBuddy();
 	selectGameFromPlayername();
 }
 
 function setLeaderboardVisibility(visible)
 {
 	if (visible)
 		Engine.SendGetBoardList();
 
 	lookupSelectedUserProfile(visible ? "leaderboardBox" : "playersBox");
 	Engine.GetGUIObjectByName("leaderboard").hidden = !visible;
 	Engine.GetGUIObjectByName("fade").hidden = !visible;
 }
 
 function setUserProfileVisibility(visible)
 {
 	Engine.GetGUIObjectByName("profileFetch").hidden = !visible;
 	Engine.GetGUIObjectByName("fade").hidden = !visible;
 }
 
 /**
  * Display the profile of the player in the user profile window.
  */
 function lookupUserProfile()
 {
 	Engine.SendGetProfile(Engine.GetGUIObjectByName("fetchInput").caption);
 }
 
 /**
  * Display the profile of the selected player in the main window.
  * Displays N/A for all stats until updateProfile is called when the stats
  * are actually received from the bot.
  */
 function lookupSelectedUserProfile(guiObjectName)
 {
 	let playerList = Engine.GetGUIObjectByName(guiObjectName);
 	let playerName = playerList.list[playerList.selected];
 
 	Engine.GetGUIObjectByName("profileArea").hidden = !playerName && !Engine.GetGUIObjectByName("usernameText").caption;
 	if (!playerName)
 		return;
 
 	Engine.SendGetProfile(playerName);
 
 	Engine.GetGUIObjectByName("usernameText").caption = playerName;
 	Engine.GetGUIObjectByName("rankText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("highestRatingText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("totalGamesText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("winsText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("lossesText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("ratioText").caption = translate("N/A");
 
 	updateUserRoleText(playerName);
 }
 
 function updateUserRoleText(playerName)
 {
 	Engine.GetGUIObjectByName("roleText").caption = g_RoleNames[Engine.LobbyGetPlayerRole(playerName) || "participant"];
 }
 
 /**
  * Update the profile of the selected player with data from the bot.
  */
 function updateProfile()
 {
 	let attributes = Engine.GetProfile()[0];
 
 	let user = colorPlayerName(attributes.player, attributes.rating);
 
 	if (!Engine.GetGUIObjectByName("profileFetch").hidden)
 	{
 		let profileFound = attributes.rating != "-2";
 		Engine.GetGUIObjectByName("profileWindowArea").hidden = !profileFound;
 		Engine.GetGUIObjectByName("profileErrorText").hidden = profileFound;
 
 		if (!profileFound)
 		{
 			Engine.GetGUIObjectByName("profileErrorText").caption = sprintf(
 				translate("Player \"%(nick)s\" not found."),
 				{ "nick": attributes.player }
 			);
 			return;
 		}
 
 		Engine.GetGUIObjectByName("profileUsernameText").caption = user;
 		Engine.GetGUIObjectByName("profileRankText").caption = attributes.rank;
 		Engine.GetGUIObjectByName("profileHighestRatingText").caption = attributes.highestRating;
 		Engine.GetGUIObjectByName("profileTotalGamesText").caption = attributes.totalGamesPlayed;
 		Engine.GetGUIObjectByName("profileWinsText").caption = attributes.wins;
 		Engine.GetGUIObjectByName("profileLossesText").caption = attributes.losses;
 		Engine.GetGUIObjectByName("profileRatioText").caption = formatWinRate(attributes);
 		return;
 	}
 
 	let playerList;
 	if (!Engine.GetGUIObjectByName("leaderboard").hidden)
 		playerList = Engine.GetGUIObjectByName("leaderboardBox");
 	else
 		playerList = Engine.GetGUIObjectByName("playersBox");
 
 	if (attributes.rating == "-2")
 		return;
 
 	// Make sure the stats we have received coincide with the selected player.
 	if (attributes.player != playerList.list[playerList.selected])
 		return;
 
 	Engine.GetGUIObjectByName("usernameText").caption = user;
 	Engine.GetGUIObjectByName("rankText").caption = attributes.rank;
 	Engine.GetGUIObjectByName("highestRatingText").caption = attributes.highestRating;
 	Engine.GetGUIObjectByName("totalGamesText").caption = attributes.totalGamesPlayed;
 	Engine.GetGUIObjectByName("winsText").caption = attributes.wins;
 	Engine.GetGUIObjectByName("lossesText").caption = attributes.losses;
 	Engine.GetGUIObjectByName("ratioText").caption = formatWinRate(attributes);
 }
 
 /**
  * Update the leaderboard from data cached in C++.
  */
 function updateLeaderboard()
 {
 	let leaderboard = Engine.GetGUIObjectByName("leaderboardBox");
 	let boardList = Engine.GetBoardList().sort((a, b) => b.rating - a.rating);
 
 	let list = [];
 	let list_name = [];
 	let list_rank = [];
 	let list_rating = [];
 
 	for (let i in boardList)
 	{
 		list_name.push(boardList[i].name);
 		list_rating.push(boardList[i].rating);
 		list_rank.push(+i + 1);
 		list.push(boardList[i].name);
 	}
 
 	leaderboard.list_name = list_name;
 	leaderboard.list_rating = list_rating;
 	leaderboard.list_rank = list_rank;
 	leaderboard.list = list;
 
 	if (leaderboard.selected >= leaderboard.list.length)
 		leaderboard.selected = -1;
 }
 
 /**
  * Update the game listing from data cached in C++.
  */
 function updateGameList()
 {
 	let gamesBox = Engine.GetGUIObjectByName("gamesBox");
 	let sortBy = gamesBox.selected_column;
 	let sortOrder = gamesBox.selected_column_order;
 
 	if (gamesBox.selected > -1)
 	{
 		g_SelectedGameIP = g_GameList[gamesBox.selected].ip;
 		g_SelectedGamePort = g_GameList[gamesBox.selected].port;
 	}
 
 	g_GameList = Engine.GetGameList().map(game => {
 
 		game.hasBuddies = 0;
 
 		// Compute average rating of participating players
 		let playerRatings = [];
 
 		for (let player of stringifiedTeamListToPlayerData(game.players))
 		{
 			let playerNickRating = splitRatingFromNick(player.Name);
 
 			if (player.Team != "observer")
 				playerRatings.push(playerNickRating.rating || g_DefaultLobbyRating);
 
 			// Sort games with playing buddies above games with spectating buddies
 			if (game.hasBuddies < 2 && g_Buddies.indexOf(playerNickRating.nick) != -1)
 				game.hasBuddies = player.Team == "observer" ? 1 : 2;
 		}
 
 		game.gameRating =
 			playerRatings.length ?
 				Math.round(playerRatings.reduce((sum, current) => sum + current) / playerRatings.length) :
 				g_DefaultLobbyRating;
 
 		try
 		{
 			game.mods = JSON.parse(game.mods);
 		}
 		catch (e)
 		{
 			game.mods = [];
 		}
 
 		if (!hasSameMods(game.mods, Engine.GetEngineInfo().mods))
 			game.state = "incompatible";
 
 		return game;
 	}).filter(game => !filterGame(game)).sort((a, b) => {
 		let sortA, sortB;
 		switch (sortBy)
 		{
 		case 'name':
 			sortA = g_GameStatusOrder.indexOf(a.state) + a.name.toLowerCase();
 			sortB = g_GameStatusOrder.indexOf(b.state) + b.name.toLowerCase();
 			break;
 		case 'gameRating':
 		case 'mapSize':
 		case 'mapType':
 			sortA = a[sortBy];
 			sortB = b[sortBy];
 			break;
 		case 'buddy':
 			sortA = String(b.hasBuddies) + g_GameStatusOrder.indexOf(a.state) + a.name.toLowerCase();
 			sortB = String(a.hasBuddies) + g_GameStatusOrder.indexOf(b.state) + b.name.toLowerCase();
 			break;
 		case 'mapName':
 			sortA = translate(a.niceMapName);
 			sortB = translate(b.niceMapName);
 			break;
 		case 'nPlayers':
 			sortA = a.maxnbp;
 			sortB = b.maxnbp;
 			break;
 		}
 		if (sortA < sortB) return -sortOrder;
 		if (sortA > sortB) return +sortOrder;
 		return 0;
 	});
 
 	let list_buddy = [];
 	let list_name = [];
 	let list_mapName = [];
 	let list_mapSize = [];
 	let list_mapType = [];
 	let list_nPlayers = [];
 	let list_gameRating = [];
 	let list = [];
 	let list_data = [];
 	let selectedGameIndex = -1;
 
 	for (let i in g_GameList)
 	{
 		let game = g_GameList[i];
 		let gameName = escapeText(game.name);
 		let mapTypeIdx = g_MapTypes.Name.indexOf(game.mapType);
 
 		if (game.ip == g_SelectedGameIP && game.port == g_SelectedGamePort)
 			selectedGameIndex = +i;
 
 		list_buddy.push(game.hasBuddies ? coloredText(g_BuddySymbol, g_GameColors[game.state]) : "");
 		list_name.push(coloredText(gameName, g_GameColors[game.state]));
 		list_mapName.push(translateMapTitle(game.niceMapName));
 		list_mapSize.push(translateMapSize(game.mapSize));
 		list_mapType.push(g_MapTypes.Title[mapTypeIdx] || "");
 		list_nPlayers.push(game.nbp + "/" + game.maxnbp);
 		list_gameRating.push(game.gameRating);
 		list.push(gameName);
 		list_data.push(i);
 	}
 
 	gamesBox.list_buddy = list_buddy;
 	gamesBox.list_name = list_name;
 	gamesBox.list_mapName = list_mapName;
 	gamesBox.list_mapSize = list_mapSize;
 	gamesBox.list_mapType = list_mapType;
 	gamesBox.list_nPlayers = list_nPlayers;
 	gamesBox.list_gameRating = list_gameRating;
 
 	// Change these last, otherwise crash
 	gamesBox.list = list;
 	gamesBox.list_data = list_data;
 
 	gamesBox.auto_scroll = false;
 	gamesBox.selected = selectedGameIndex;
 
 	updateGameSelection();
 }
 
 /**
  * Populate the game info area with information on the current game selection.
  */
 function updateGameSelection()
 {
 	let game = selectedGame();
 
 	Engine.GetGUIObjectByName("gameInfo").hidden = !game;
 	Engine.GetGUIObjectByName("joinGameButton").hidden = g_Dialog || !game;
 	Engine.GetGUIObjectByName("gameInfoEmpty").hidden = !!game;
 
 	if (!game)
 		return;
 
 	Engine.GetGUIObjectByName("sgMapName").caption = translateMapTitle(game.niceMapName);
 
 	let sgGameStartTime = Engine.GetGUIObjectByName("sgGameStartTime");
 	let sgNbPlayers = Engine.GetGUIObjectByName("sgNbPlayers");
 	let sgPlayersNames = Engine.GetGUIObjectByName("sgPlayersNames");
 
 	let playersNamesSize = sgPlayersNames.size;
 	playersNamesSize.top = game.startTime ? sgGameStartTime.size.bottom : sgNbPlayers.size.bottom;
 	playersNamesSize.rtop = game.startTime ? sgGameStartTime.size.rbottom : sgNbPlayers.size.rbottom;
 	sgPlayersNames.size = playersNamesSize;
 
 	sgGameStartTime.hidden = !game.startTime;
 	if (game.startTime)
 		sgGameStartTime.caption = sprintf(
 			// Translation: %(time)s is the hour and minute here.
 			translate("Game started at %(time)s"), {
 				"time": Engine.FormatMillisecondsIntoDateStringLocal(+game.startTime * 1000, translate("HH:mm"))
 			});
 
 	sgNbPlayers.caption = sprintf(
 		translate("Players: %(current)s/%(total)s"), {
 			"current": game.nbp,
 			"total": game.maxnbp
 		});
 
 	sgPlayersNames.caption = formatPlayerInfo(stringifiedTeamListToPlayerData(game.players));
 	Engine.GetGUIObjectByName("sgMapSize").caption = translateMapSize(game.mapSize);
 
 	let mapTypeIdx = g_MapTypes.Name.indexOf(game.mapType);
 	Engine.GetGUIObjectByName("sgMapType").caption = g_MapTypes.Title[mapTypeIdx] || "";
 
 	let mapData = getMapDescriptionAndPreview(game.mapType, game.mapName);
+	Engine.GetGUIObjectByName("sgMapPreview").sprite = getMapPreviewImage(mapData.preview);
 	Engine.GetGUIObjectByName("sgMapDescription").caption = mapData.description;
-
-	setMapPreviewImage("sgMapPreview", mapData.preview);
 }
 
 function selectedGame()
 {
 	let gamesBox = Engine.GetGUIObjectByName("gamesBox");
 	if (gamesBox.selected < 0)
 		return undefined;
 
 	return g_GameList[gamesBox.list_data[gamesBox.selected]];
 }
 
 /**
  * Immediately rejoin and join gamesetups. Otherwise confirm late-observer join attempt.
  */
 function joinButton()
 {
 	let game = selectedGame();
 	if (!game || g_Dialog)
 		return;
 
 	let rating = getRejoinRating(game);
 	let username = rating ? g_Username + " (" + rating + ")" : g_Username;
 
 	if (game.state == "incompatible")
 		messageBox(
 			400, 200,
 			translate("Your active mods do not match the mods of this game.") + "\n\n" +
 				comparedModsString(game.mods, Engine.GetEngineInfo().mods) + "\n\n" +
 				translate("Do you want to switch to the mod selection page?"),
 			translate("Incompatible mods"),
 			[translate("No"), translate("Yes")],
 			[
 				null,
 				() => {
 					Engine.StopXmppClient();
 					Engine.SwitchGuiPage("page_modmod.xml", {
 						"cancelbutton": true
 					});
 				}
 			]
 		);
 	else if (game.state == "init" || stringifiedTeamListToPlayerData(game.players).some(player => player.Name == username))
 		joinSelectedGame();
 	else
 		messageBox(
 			400, 200,
 			translate("The game has already started. Do you want to join as observer?"),
 			translate("Confirmation"),
 			[translate("No"), translate("Yes")],
 			[null, joinSelectedGame]
 		);
 }
 
 /**
  * Attempt to join the selected game without asking for confirmation.
  */
 function joinSelectedGame()
 {
 	let game = selectedGame();
 	if (!game)
 		return;
 
 	let ip;
 	let port;
 	if (game.stunIP)
 	{
 		ip = game.stunIP;
 		port = game.stunPort;
 	}
 	else
 	{
 		ip = game.ip;
 		port = game.port;
 	}
 
 	if (ip.split('.').length != 4)
 	{
 		addChatMessage({
 			"from": "system",
 			"text": sprintf(
 				translate("This game's address '%(ip)s' does not appear to be valid."),
 				{ "ip": game.ip }
 			)
 		});
 		return;
 	}
 
 	Engine.PushGuiPage("page_gamesetup_mp.xml", {
 		"multiplayerGameType": "join",
 		"ip": ip,
 		"port": port,
 		"name": g_Username,
 		"rating": getRejoinRating(game),
 		"useSTUN": !!game.stunIP,
 		"hostJID": game.hostUsername + "@" + g_LobbyServer + "/0ad"
 	});
 }
 
 /**
  * Rejoin games with the original playername, even if the rating changed meanwhile.
  */
 function getRejoinRating(game)
 {
 	for (let player of stringifiedTeamListToPlayerData(game.players))
 	{
 		let playerNickRating = splitRatingFromNick(player.Name);
 		if (playerNickRating.nick == g_Username)
 			return playerNickRating.rating;
 	}
 	return g_UserRating;
 }
 
 /**
  * Open the dialog box to enter the game name.
  */
 function hostGame()
 {
 	Engine.PushGuiPage("page_gamesetup_mp.xml", {
 		"multiplayerGameType": "host",
 		"name": g_Username,
 		"rating": g_UserRating
 	});
 }
 
 /**
  * Processes GUI messages sent by the XmppClient.
  */
 function onTick()
 {
 	updateTimers();
 
 	let updateList = false;
 
 	while (true)
 	{
 		let msg = Engine.LobbyGuiPollNewMessage();
 		if (!msg)
 			break;
 
 		if (!g_NetMessageTypes[msg.type])
 		{
 			warn("Unrecognised message type: " + msg.type);
 			continue;
 		}
 		if (!g_NetMessageTypes[msg.type][msg.level])
 		{
 			warn("Unrecognised message level: " + msg.level);
 			continue;
 		}
 
 		if (g_NetMessageTypes[msg.type][msg.level](msg))
 			updateList = true;
 	}
 
 	// To improve performance, only update the playerlist GUI when
 	// the last update in the current stack is processed
 	if (updateList)
 		updatePlayerList();
 }
 
 /**
  * Executes a lobby command or sends GUI input directly as chat.
  */
 function submitChatInput()
 {
 	let input = Engine.GetGUIObjectByName("chatInput");
 	let text = input.caption;
 
 	if (!text.length)
 		return;
 
 	if (handleChatCommand(text))
 		Engine.LobbySendMessage(text);
 
 	input.caption = "";
 }
 
 /**
  * Handle all '/' commands.
  *
  * @param {string} text - Text to be checked for commands.
  * @returns {boolean} true if the text should be sent via chat.
  */
 function handleChatCommand(text)
 {
 	if (text[0] != '/')
 		return true;
 
 	let [cmd, args] = ircSplit(text);
 	args = ircSplit("/" + args);
 
 	if (!g_ChatCommands[cmd])
 	{
 		addChatMessage({
 			"from": "system",
 			"text": sprintf(
 				translate("The command '%(cmd)s' is not supported."), {
 					"cmd": coloredText(cmd, g_ChatCommandColor)
 				})
 		});
 		return false;
 	}
 
 	if (g_ChatCommands[cmd].moderatorOnly && Engine.LobbyGetPlayerRole(g_Username) != "moderator")
 	{
 		addChatMessage({
 			"from": "system",
 			"text": sprintf(
 				translate("The command '%(cmd)s' is restricted to moderators."), {
 					"cmd": coloredText(cmd, g_ChatCommandColor)
 				})
 		});
 		return false;
 	}
 
 	return g_ChatCommands[cmd].handler(args);
 }
 
 /**
  * Process and if appropriate, display a formatted message.
  *
  * @param {Object} msg - The message to be processed.
  */
 function addChatMessage(msg)
 {
 	if (msg.from)
 	{
 		if (Engine.LobbyGetPlayerRole(msg.from) == "moderator")
 			msg.from = g_ModeratorPrefix + msg.from;
 
 		// Highlight local user's nick
 		if (g_Username != msg.from)
 		{
 			msg.text = msg.text.replace(g_Username, colorPlayerName(g_Username));
 
 			if (!msg.historic && msg.text.toLowerCase().indexOf(g_Username.toLowerCase()) != -1)
 				soundNotification("nick");
 		}
 	}
 
 	let formatted = ircFormat(msg);
 	if (!formatted)
 		return;
 
 	g_ChatMessages.push(formatted);
 	Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 }
 
 function clearChatMessages()
 {
 	g_ChatMessages.length = 0;
 	Engine.GetGUIObjectByName("chatText").caption = "";
 }
 
 /**
  * Splits given input into command and argument.
  */
 function ircSplit(string)
 {
 	let idx = string.indexOf(' ');
 
 	if (idx != -1)
 		return [string.substr(1, idx - 1), string.substr(idx + 1)];
 
 	return [string.substr(1), ""];
 }
 
 /**
  * Format text in an IRC-like way.
  *
  * @param {Object} msg - Received chat message.
  * @returns {string} - Formatted text.
  */
 function ircFormat(msg)
 {
 	let formattedMessage = "";
 	let coloredFrom = msg.from && colorPlayerName(msg.from);
 
 	// Handle commands allowed past handleChatCommand.
 	if (msg.text && msg.text[0] == '/')
 	{
 		let [command, message] = ircSplit(msg.text);
 		switch (command)
 		{
 		case "me":
 		{
 			// Translation: IRC message prefix when the sender uses the /me command.
 			let senderString = sprintf(translate("* %(sender)s"), {
 				"sender": coloredFrom
 			});
 
 			// Translation: IRC message issued using the ‘/me’ command.
 			formattedMessage = sprintf(translate("%(sender)s %(action)s"), {
 				"sender": senderFont(senderString),
 				"action": message
 			});
 			break;
 		}
 		case "say":
 		{
 			// Translation: IRC message prefix.
 			let senderString = sprintf(translate("<%(sender)s>"), {
 				"sender": coloredFrom
 			});
 
 			// Translation: IRC message.
 			formattedMessage = sprintf(translate("%(sender)s %(message)s"), {
 				"sender": senderFont(senderString),
 				"message": message
 			});
 			break;
 		}
 		case "special":
 		{
 			if (msg.isSpecial)
 				// Translation: IRC system message.
 				formattedMessage = senderFont(sprintf(translate("== %(message)s"), {
 					"message": message
 				}));
 			else
 			{
 				// Translation: IRC message prefix.
 				let senderString = sprintf(translate("<%(sender)s>"), {
 					"sender": coloredFrom
 				});
 
 				// Translation: IRC message.
 				formattedMessage = sprintf(translate("%(sender)s %(message)s"), {
 					"sender": senderFont(senderString),
 					"message": message
 				});
 			}
 			break;
 		}
 		default:
 			return "";
 		}
 	}
 	else
 	{
 		let senderString;
 
 		// Translation: IRC message prefix.
 		if (msg.private)
 			senderString = sprintf(translateWithContext("lobby private message", "(%(private)s) <%(sender)s>"), {
 				"private": coloredText(translate("Private"), g_PrivateMessageColor),
 				"sender": coloredFrom
 			});
 		else
 			senderString = sprintf(translate("<%(sender)s>"), {
 				"sender": coloredFrom
 			});
 
 		// Translation: IRC message.
 		formattedMessage = sprintf(translate("%(sender)s %(message)s"), {
 			"sender": senderFont(senderString),
 			"message": msg.text
 		});
 	}
 
 	// Add chat message timestamp
 	if (Engine.ConfigDB_GetValue("user", "chat.timestamp") != "true")
 		return formattedMessage;
 
 	// Translation: Time as shown in the multiplayer lobby (when you enable it in the options page).
 	// For a list of symbols that you can use, see:
 	// https://sites.google.com/site/icuprojectuserguide/formatparse/datetime?pli=1#TOC-Date-Field-Symbol-Table
 	let timeString = Engine.FormatMillisecondsIntoDateStringLocal(msg.time ? msg.time * 1000 : Date.now(), translate("HH:mm"));
 
 	// Translation: Time prefix as shown in the multiplayer lobby (when you enable it in the options page).
 	let timePrefixString = sprintf(translate("\\[%(time)s]"), {
 		"time": timeString
 	});
 
 	// Translation: IRC message format when there is a time prefix.
 	return sprintf(translate("%(time)s %(message)s"), {
 		"time": timePrefixString,
 		"message": formattedMessage
 	});
 }
 
 /**
  * Generate a (mostly) unique color for this player based on their name.
  * @see https://stackoverflow.com/questions/3426404/create-a-hexadecimal-colour-based-on-a-string-with-jquery-javascript
  * @param {string} playername
  */
 function getPlayerColor(playername)
 {
 	if (playername == "system")
 		return g_SystemColor;
 
 	// Generate a probably-unique hash for the player name and use that to create a color.
 	let hash = 0;
 	for (let i in playername)
 		hash = playername.charCodeAt(i) + ((hash << 5) - hash);
 
 	// First create the color in RGB then HSL, clamp the lightness so it's not too dark to read, and then convert back to RGB to display.
 	// The reason for this roundabout method is this algorithm can generate values from 0 to 255 for RGB but only 0 to 100 for HSL; this gives
 	// us much more variety if we generate in RGB. Unfortunately, enforcing that RGB values are a certain lightness is very difficult, so
 	// we convert to HSL to do the computation. Since our GUI code only displays RGB colors, we have to convert back.
 	let [h, s, l] = rgbToHsl(hash >> 24 & 0xFF, hash >> 16 & 0xFF, hash >> 8 & 0xFF);
 	return hslToRgb(h, s, Math.max(0.7, l)).join(" ");
 }
 
 /**
  * Returns the given playername wrapped in an appropriate color-tag.
  *
  * @param {string} playername
  * @param {string} rating
  */
 function colorPlayerName(playername, rating)
 {
 	return coloredText(
 		(rating ? sprintf(
 			translate("%(nick)s (%(rating)s)"), {
 				"nick": playername,
 				"rating": rating
 			}) : playername
 		),
 		getPlayerColor(playername.replace(g_ModeratorPrefix, "")));
 }
 
 function senderFont(text)
 {
 	return '[font="' + g_SenderFont + '"]' + text + "[/font]";
 }
 
 function formatWinRate(attr)
 {
 	if (!attr.totalGamesPlayed)
 		return translateWithContext("Used for an undefined winning rate", "-");
 
 	return sprintf(translate("%(percentage)s%%"), {
 		"percentage": (attr.wins / attr.totalGamesPlayed * 100).toFixed(2)
 	});
 }
Index: ps/trunk/binaries/data/mods/public/gui/replaymenu/replay_menu.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/replaymenu/replay_menu.js	(revision 22825)
+++ ps/trunk/binaries/data/mods/public/gui/replaymenu/replay_menu.js	(revision 22826)
@@ -1,357 +1,355 @@
 /**
  * Used for checking replay compatibility.
  */
 const g_EngineInfo = Engine.GetEngineInfo();
 
 /**
  * Needed for formatPlayerInfo to show the player civs in the details.
  */
 const g_CivData = loadCivData(false, false);
 
 /**
  * Used for creating the mapsize filter.
  */
 const g_MapSizes = prepareForDropdown(g_Settings && g_Settings.MapSizes);
 
 /**
  * All replays found in the directory.
  */
 var g_Replays = [];
 
 /**
  * List of replays after applying the display filter.
  */
 var g_ReplaysFiltered = [];
 
 /**
  * Array of unique usernames of all replays. Used for autocompleting usernames.
  */
 var g_Playernames = [];
 
 /**
  * Sorted list of unique maptitles. Used by mapfilter.
  */
 var g_MapNames = [];
 
 /**
  * Sorted list of the victory conditions occuring in the replays
  */
 var g_VictoryConditions = g_Settings && g_Settings.VictoryConditions;
 
 /**
  * Directory name of the currently selected replay. Used to restore the selection after changing filters.
  */
 var g_SelectedReplayDirectory = "";
 
 /**
  * Skip duplicate expensive GUI updates before init is complete.
  */
 var g_ReplaysLoaded = false;
 
 /**
  * Remember last viewed summary panel and charts.
  */
 var g_SummarySelectedData;
 
 /**
  * Initializes globals, loads replays and displays the list.
  */
 function init(data)
 {
 	if (!g_Settings)
 	{
 		Engine.SwitchGuiPage("page_pregame.xml");
 		return;
 	}
 
 	loadReplays(data && data.replaySelectionData, false);
 
 	if (!g_Replays)
 	{
 		Engine.SwitchGuiPage("page_pregame.xml");
 		return;
 	}
 
 	initHotkeyTooltips();
 	displayReplayList();
 
 	if (data && data.summarySelectedData)
 		g_SummarySelectedData = data.summarySelectedData;
 }
 
 /**
  * Store the list of replays loaded in C++ in g_Replays.
  * Check timestamp and compatibility and extract g_Playernames, g_MapNames, g_VictoryConditions.
  * Restore selected filters and item.
  * @param replaySelectionData - Currently selected filters and item to be restored after the loading.
  * @param compareFiles - If true, compares files briefly (which might be slow with optical harddrives),
  *                       otherwise blindly trusts the replay cache.
  */
 function loadReplays(replaySelectionData, compareFiles)
 {
 	g_Replays = Engine.GetReplays(compareFiles);
 
 	if (!g_Replays)
 		return;
 
 	g_Playernames = [];
 	for (let replay of g_Replays)
 	{
 		let nonAIPlayers = 0;
 
 		// Check replay for compatibility
 		replay.isCompatible = isReplayCompatible(replay);
 
 		sanitizeGameAttributes(replay.attribs);
 
 		// Extract map names
 		if (g_MapNames.indexOf(replay.attribs.settings.Name) == -1 && replay.attribs.settings.Name != "")
 			g_MapNames.push(replay.attribs.settings.Name);
 
 		// Extract playernames
 		for (let playerData of replay.attribs.settings.PlayerData)
 		{
 			if (!playerData || playerData.AI)
 				continue;
 
 			// Remove rating from nick
 			let playername = playerData.Name;
 			let ratingStart = playername.indexOf(" (");
 			if (ratingStart != -1)
 				playername = playername.substr(0, ratingStart);
 
 			if (g_Playernames.indexOf(playername) == -1)
 				g_Playernames.push(playername);
 
 			++nonAIPlayers;
 		}
 
 		replay.isMultiplayer = nonAIPlayers > 1;
 
 		replay.isRated = nonAIPlayers == 2 &&
 			replay.attribs.settings.PlayerData.length == 2 &&
 			replay.attribs.settings.RatingEnabled;
 	}
 
 	g_MapNames.sort();
 
 	// Reload filters (since they depend on g_Replays and its derivatives)
 	initFilters(replaySelectionData && replaySelectionData.filters);
 
 	// Restore user selection
 	if (replaySelectionData)
 	{
 		if (replaySelectionData.directory)
 			g_SelectedReplayDirectory = replaySelectionData.directory;
 
 		let replaySelection = Engine.GetGUIObjectByName("replaySelection");
 		if (replaySelectionData.column)
 			replaySelection.selected_column = replaySelectionData.column;
 		if (replaySelectionData.columnOrder)
 			replaySelection.selected_column_order = replaySelectionData.columnOrder;
 	}
 
 	g_ReplaysLoaded = true;
 }
 
 /**
  * We may encounter malformed replays.
  */
 function sanitizeGameAttributes(attribs)
 {
 	if (!attribs.settings)
 		attribs.settings = {};
 
 	if (!attribs.settings.Size)
 		attribs.settings.Size = -1;
 
 	if (!attribs.settings.Name)
 		attribs.settings.Name = "";
 
 	if (!attribs.settings.PlayerData)
 		attribs.settings.PlayerData = [];
 
 	if (!attribs.settings.PopulationCap)
 		attribs.settings.PopulationCap = 300;
 
 	if (!attribs.settings.mapType)
 		attribs.settings.mapType = "skirmish";
 
 	// Remove gaia
 	if (attribs.settings.PlayerData.length && attribs.settings.PlayerData[0] == null)
 		attribs.settings.PlayerData.shift();
 
 	attribs.settings.PlayerData.forEach((pData, index) => {
 		if (!pData.Name)
 			pData.Name = "";
 	});
 }
 
 function initHotkeyTooltips()
 {
 	Engine.GetGUIObjectByName("playersFilter").tooltip =
 		translate("Filter replays by typing one or more, partial or complete player names.") +
 		" " + colorizeAutocompleteHotkey();
 
 	Engine.GetGUIObjectByName("deleteReplayButton").tooltip = deleteTooltip();
 }
 
 /**
  * Filter g_Replays, fill the GUI list with that data and show the description of the current replay.
  */
 function displayReplayList()
 {
 	if (!g_ReplaysLoaded)
 		return;
 
 	// Remember previously selected replay
 	var replaySelection = Engine.GetGUIObjectByName("replaySelection");
 	if (replaySelection.selected != -1)
 		g_SelectedReplayDirectory = g_ReplaysFiltered[replaySelection.selected].directory;
 
 	filterReplays();
 
 	var list = g_ReplaysFiltered.map(replay => {
 		let works = replay.isCompatible;
 		return {
 			"directories": replay.directory,
 			"months": compatibilityColor(getReplayDateTime(replay), works),
 			"popCaps": compatibilityColor(translatePopulationCapacity(replay.attribs.settings.PopulationCap), works),
 			"mapNames": compatibilityColor(getReplayMapName(replay), works),
 			"mapSizes": compatibilityColor(translateMapSize(replay.attribs.settings.Size), works),
 			"durations": compatibilityColor(getReplayDuration(replay), works),
 			"playerNames": compatibilityColor(getReplayPlayernames(replay), works)
 		};
 	});
 
 	if (list.length)
 		list = prepareForDropdown(list);
 
 	// Push to GUI
 	replaySelection.selected = -1;
 	replaySelection.list_months = list.months || [];
 	replaySelection.list_players = list.playerNames || [];
 	replaySelection.list_mapName = list.mapNames || [];
 	replaySelection.list_mapSize = list.mapSizes || [];
 	replaySelection.list_popCapacity = list.popCaps || [];
 	replaySelection.list_duration = list.durations || [];
 
 	// Change these last, otherwise crash
 	replaySelection.list = list.directories || [];
 	replaySelection.list_data = list.directories || [];
 
 	replaySelection.selected = replaySelection.list.findIndex(directory => directory == g_SelectedReplayDirectory);
 
 	displayReplayDetails();
 }
 
 /**
  * Shows preview image, description and player text in the right panel.
  */
 function displayReplayDetails()
 {
 	let selected = Engine.GetGUIObjectByName("replaySelection").selected;
 	let replaySelected = selected > -1;
 
 	Engine.GetGUIObjectByName("replayInfo").hidden = !replaySelected;
 	Engine.GetGUIObjectByName("replayInfoEmpty").hidden = replaySelected;
 	Engine.GetGUIObjectByName("startReplayButton").enabled = replaySelected;
 	Engine.GetGUIObjectByName("deleteReplayButton").enabled = replaySelected;
 	Engine.GetGUIObjectByName("replayFilename").hidden = !replaySelected;
 	Engine.GetGUIObjectByName("summaryButton").hidden = true;
 
 	if (!replaySelected)
 		return;
 
 	let replay = g_ReplaysFiltered[selected];
 
 	Engine.GetGUIObjectByName("sgMapName").caption = translate(replay.attribs.settings.Name);
 	Engine.GetGUIObjectByName("sgMapSize").caption = translateMapSize(replay.attribs.settings.Size);
 	Engine.GetGUIObjectByName("sgMapType").caption = translateMapType(replay.attribs.settings.mapType);
 	Engine.GetGUIObjectByName("sgVictory").caption = replay.attribs.settings.VictoryConditions.map(victoryConditionName =>
 		translateVictoryCondition(victoryConditionName)).join(translate(", "));
 	Engine.GetGUIObjectByName("sgNbPlayers").caption = sprintf(translate("Players: %(numberOfPlayers)s"),
 		{ "numberOfPlayers": replay.attribs.settings.PlayerData.length });
 	Engine.GetGUIObjectByName("replayFilename").caption = Engine.GetReplayDirectoryName(replay.directory);
 
 	let metadata = Engine.GetReplayMetadata(replay.directory);
 	Engine.GetGUIObjectByName("sgPlayersNames").caption =
 		formatPlayerInfo(
 			replay.attribs.settings.PlayerData,
 			Engine.GetGUIObjectByName("showSpoiler").checked &&
 				metadata &&
 				metadata.playerStates &&
-				metadata.playerStates.map(pState => pState.state)
-		);
+				metadata.playerStates.map(pState => pState.state));
 
 	let mapData = getMapDescriptionAndPreview(replay.attribs.settings.mapType, replay.attribs.map, replay.attribs);
+	Engine.GetGUIObjectByName("sgMapPreview").sprite = getMapPreviewImage(mapData.preview);
 	Engine.GetGUIObjectByName("sgMapDescription").caption = mapData.description;
 
 	Engine.GetGUIObjectByName("summaryButton").hidden = !Engine.HasReplayMetadata(replay.directory);
-
-	setMapPreviewImage("sgMapPreview", mapData.preview);
 }
 
 /**
  * Returns a human-readable version of the replay date.
  */
 function getReplayDateTime(replay)
 {
 	return Engine.FormatMillisecondsIntoDateStringLocal(replay.attribs.timestamp * 1000, translate("yyyy-MM-dd HH:mm"));
 }
 
 /**
  * Returns a human-readable list of the playernames of that replay.
  *
  * @returns {string}
  */
 function getReplayPlayernames(replay)
 {
 	return replay.attribs.settings.PlayerData.map(pData => pData.Name).join(", ");
 }
 
 /**
  * Returns the name of the map of the given replay.
  *
  * @returns {string}
  */
 function getReplayMapName(replay)
 {
 	return translate(replay.attribs.settings.Name);
 }
 
 /**
  * Returns the month of the given replay in the format "yyyy-MM".
  *
  * @returns {string}
  */
 function getReplayMonth(replay)
 {
 	return Engine.FormatMillisecondsIntoDateStringLocal(replay.attribs.timestamp * 1000, translate("yyyy-MM"));
 }
 
 /**
  * Returns a human-readable version of the time when the replay started.
  *
  * @returns {string}
  */
 function getReplayDuration(replay)
 {
 	return timeToString(replay.duration * 1000);
 }
 
 /**
  * True if we can start the given replay with the currently loaded mods.
  */
 function isReplayCompatible(replay)
 {
 	return replayHasSameEngineVersion(replay) && hasSameMods(replay.attribs.mods, g_EngineInfo.mods);
 }
 
 /**
  * True if we can start the given replay with the currently loaded mods.
  */
 function replayHasSameEngineVersion(replay)
 {
 	return replay.attribs.engine_version && replay.attribs.engine_version == g_EngineInfo.engine_version;
 }