Index: ps/trunk/binaries/data/mods/public/gui/common/functions_global_object.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/common/functions_global_object.js	(revision 18203)
+++ ps/trunk/binaries/data/mods/public/gui/common/functions_global_object.js	(revision 18204)
@@ -1,169 +1,167 @@
 // We want to pass callback functions for the different buttons in a convenient way.
 // Because passing functions accross compartment boundaries is a pain, we just store them here together with some optional arguments.
 // The messageBox page will return the code of the pressed button and the according function will be called.
 var g_MessageBoxBtnFunctions = [];
 var g_MessageBoxCallbackArgs = [];
 
 var g_MessageBoxCallbackFunction = function(btnCode)
 {
 	if (btnCode !== undefined && g_MessageBoxBtnFunctions[btnCode])
 	{
 		// Cache the variables to make it possible to call a messageBox from a callback function.
 		let callbackFunction = g_MessageBoxBtnFunctions[btnCode];
 		let callbackArgs = g_MessageBoxCallbackArgs[btnCode];
 
 		g_MessageBoxBtnFunctions = [];
 		g_MessageBoxCallbackArgs = [];
 
 		if (callbackArgs !== undefined)
 			callbackFunction(callbackArgs);
 		else
 			callbackFunction();
 		return;
 	}
 
 	g_MessageBoxBtnFunctions = [];
 	g_MessageBoxCallbackArgs = [];
 };
 
 function messageBox(mbWidth, mbHeight, mbMessage, mbTitle, mbButtonCaptions, mbBtnCode, mbCallbackArgs)
 {
 	if (g_MessageBoxBtnFunctions && g_MessageBoxBtnFunctions.length)
 	{
 		warn("A messagebox was called when a previous callback function is still set, aborting!");
 		return;
 	}
 
 	g_MessageBoxBtnFunctions = mbBtnCode;
 	g_MessageBoxCallbackArgs = mbCallbackArgs || g_MessageBoxCallbackArgs;
 
 	Engine.PushGuiPage("page_msgbox.xml", {
 		"width": mbWidth,
 		"height": mbHeight,
 		"message": mbMessage,
 		"title": mbTitle,
 		"buttonCaptions": mbButtonCaptions,
 		"callback": mbBtnCode && "g_MessageBoxCallbackFunction"
 	});
 }
 
 function openURL(url)
 {
 	Engine.OpenURL(url);
 
 	messageBox(
 		600, 200,
 		sprintf(
 			translate("Opening %(url)s\n in default web browser. Please wait...."),
 			{ "url": url }
 		),
 		translate("Opening page")
 	);
 }
 
 function updateCounters()
 {
 	var caption = "";
 	var linesCount = 0;
 	var researchCount = 0;
 
 	if (Engine.ConfigDB_GetValue("user", "overlay.fps") === "true")
 	{
 		caption += sprintf(translate("FPS: %(fps)4s"), { "fps": Engine.GetFPS() }) + "\n";
 		++linesCount;
 	}
 	if (Engine.ConfigDB_GetValue("user", "overlay.realtime") === "true")
 	{
 		caption += (new Date()).toLocaleTimeString() + "\n";
 		++linesCount;
 	}
 
 	// If game has been started
 	if (typeof g_SimState != "undefined")
 	{
 		if (Engine.ConfigDB_GetValue("user", "gui.session.timeelapsedcounter") === "true")
 		{
 			var currentSpeed = Engine.GetSimRate();
 			if (currentSpeed != 1.0)
 				// Translation: The "x" means "times", with the mathematical meaning of multiplication.
 				caption += sprintf(translate("%(time)s (%(speed)sx)"), {
 					"time": timeToString(g_SimState.timeElapsed),
 					"speed": Engine.FormatDecimalNumberIntoString(currentSpeed)
 				});
 			else
 				caption += timeToString(g_SimState.timeElapsed);
 			caption += "\n";
 			++linesCount;
 		}
 
 		var diplomacyCeasefireCounter = Engine.GetGUIObjectByName("diplomacyCeasefireCounter");
 		if (g_SimState.ceasefireActive)
 		{
 			// Update ceasefire counter in the diplomacy window
 			var remainingTimeString = timeToString(g_SimState.ceasefireTimeRemaining);
 
 			diplomacyCeasefireCounter.caption = sprintf(
 				translateWithContext("ceasefire", "Time remaining until ceasefire is over: %(time)s."),
 				{ "time": remainingTimeString }
 			);
 
 			// Update ceasefire overlay counter
 			if (Engine.ConfigDB_GetValue("user", "gui.session.ceasefirecounter") === "true")
 			{
 				caption += remainingTimeString + "\n";
 				++linesCount;
 			}
 		}
 		else if (!diplomacyCeasefireCounter.hidden)
 		{
 			diplomacyCeasefireCounter.hidden = true;
 			updateDiplomacy();
 		}
 
 		g_ResearchListTop = 4;
 		if (linesCount)
 			g_ResearchListTop += 14 * linesCount;
 	}
 
 	var dataCounter = Engine.GetGUIObjectByName("dataCounter");
 	dataCounter.caption = caption;
 	dataCounter.size = sprintf("100%%-100 40 100%%-5 %(bottom)s", { "bottom": 40 + 14 * linesCount });
 	dataCounter.hidden = linesCount == 0;
 }
 
 /**
  * Update the overlay with the most recent network warning of each client.
  */
 function displayGamestateNotifications()
 {
 	let messages = [];
 	let maxTextWidth = 0;
 
-	// TODO: Players who paused the game should be added here
-
 	// Add network warnings
 	if (Engine.ConfigDB_GetValue("user", "overlay.netwarnings") == "true")
 	{
 		let netwarnings = getNetworkWarnings();
 		messages = messages.concat(netwarnings.messages);
 		maxTextWidth = Math.max(maxTextWidth, netwarnings.maxTextWidth);
 	}
 
 	// Resize textbox
 	let width = maxTextWidth + 20;
 	let height = 14 * messages.length;
 
 	// Position left of the dataCounter
 	let top = "40";
 	let right = Engine.GetGUIObjectByName("dataCounter").hidden ? "100%-15" : "100%-110";
 
 	let bottom = top + "+" + height;
 	let left = right + "-" + width;
 
 	let gameStateNotifications = Engine.GetGUIObjectByName("gameStateNotifications");
 	gameStateNotifications.caption = messages.join("\n");
 	gameStateNotifications.hidden = !messages.length;
 	gameStateNotifications.size = left + " " + top + " " + right + " " + bottom;
 
 	setTimeout(displayGamestateNotifications, 1000);
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/menu.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/menu.js	(revision 18203)
+++ ps/trunk/binaries/data/mods/public/gui/session/menu.js	(revision 18204)
@@ -1,754 +1,803 @@
 // Menu / panel border size
 const MARGIN = 4;
 
 // Includes the main menu button
 const NUM_BUTTONS = 9;
 
 // Regular menu buttons
 const BUTTON_HEIGHT = 32;
 
 // The position where the bottom of the menu will end up (currently 228)
 const END_MENU_POSITION = (BUTTON_HEIGHT * NUM_BUTTONS) + MARGIN;
 
 // Menu starting position: bottom
 const MENU_BOTTOM = 0;
 
 // Menu starting position: top
 const MENU_TOP = MENU_BOTTOM - END_MENU_POSITION;
 
 // Menu starting position: overall
 const INITIAL_MENU_POSITION = "100%-164 " + MENU_TOP + " 100% " + MENU_BOTTOM;
 
 // Number of pixels per millisecond to move
 const MENU_SPEED = 1.2;
 
 // Available resources in trade and tribute menu
 const RESOURCES = ["food", "wood", "stone", "metal"];
 
 // Trade menu: step for probability changes
 const STEP = 5;
 
 // Shown in the trade dialog.
 const g_IdleTraderTextColor = "orange";
 
 var g_IsMenuOpen = false;
 
 var g_IsDiplomacyOpen = false;
 var g_IsTradeOpen = false;
 
 // Redefined every time someone makes a tribute (so we can save some data in a closure). Called in input.js handleInputBeforeGui.
 var g_FlushTributing = function() {};
 
 // Ignore size defined in XML and set the actual menu size here
 function initMenuPosition()
 {
 	Engine.GetGUIObjectByName("menu").size = INITIAL_MENU_POSITION;
 }
 
 function updateMenuPosition(dt)
 {
 	let menu = Engine.GetGUIObjectByName("menu");
 
 	let maxOffset = g_IsMenuOpen ? (END_MENU_POSITION - menu.size.bottom) : (menu.size.top - MENU_TOP);
 	if (maxOffset <= 0)
 		return;
 
 	let offset = Math.min(MENU_SPEED * dt, maxOffset) * (g_IsMenuOpen ? +1 : -1);
 
 	let size = menu.size;
 	size.top += offset;
 	size.bottom += offset;
 	menu.size = size;
 }
 
 // Opens the menu by revealing the screen which contains the menu
 function openMenu()
 {
 	g_IsMenuOpen = true;
 }
 
 // Closes the menu and resets position
 function closeMenu()
 {
 	g_IsMenuOpen = false;
 }
 
 function toggleMenu()
 {
 	g_IsMenuOpen = !g_IsMenuOpen;
 }
 
 function optionsMenuButton()
 {
 	closeOpenDialogs();
 	openOptions();
 }
 
 function chatMenuButton()
 {
 	closeOpenDialogs();
 	openChat();
 }
 
 function diplomacyMenuButton()
 {
 	closeOpenDialogs();
 	openDiplomacy();
 }
 
 function pauseMenuButton()
 {
 	togglePause();
 }
 
 function resignMenuButton()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	messageBox(
 		400, 200,
 		translate("Are you sure you want to resign?"),
 		translate("Confirmation"),
 		[translate("No"), translate("Yes")],
 		[resumeGame, resignGame]
 	);
 }
 
 function exitMenuButton()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	let messageTypes = {
 		"host": {
 			"caption": translate("Are you sure you want to quit? Leaving will disconnect all other players."),
 			"buttons": [resumeGame, leaveGame]
 		},
 		"client": {
 			"caption": translate("Are you sure you want to quit?"),
 			"buttons": [resumeGame, resignQuestion]
 		},
 		"singleplayer": {
 			"caption": translate("Are you sure you want to quit?"),
 			"buttons": [resumeGame, leaveGame]
 		}
 	};
 
 	let messageType = g_IsNetworked && g_IsController ? "host" :
 		(g_IsNetworked && !g_IsObserver ? "client" : "singleplayer");
 
 	messageBox(
 		400, 200,
 		messageTypes[messageType].caption,
 		translate("Confirmation"),
 		[translate("No"), translate("Yes")],
 		messageTypes[messageType].buttons
 	);
 }
 
 function resignQuestion()
 {
 	messageBox(
 		400, 200,
 		translate("Do you want to resign or will you return soon?"),
 		translate("Confirmation"),
 		[translate("I will return"), translate("I resign")],
 		[leaveGame, resignGame],
 		[true, false]
 	);
 }
 
 function openDeleteDialog(selection)
 {
 	closeOpenDialogs();
 
 	let deleteSelectedEntities = function (selectionArg)
 	{
 		Engine.PostNetworkCommand({ "type": "delete-entities", "entities": selectionArg });
 	};
 
 	messageBox(
 		400, 200,
 		translate("Destroy everything currently selected?"),
 		translate("Delete"),
 		[translate("No"), translate("Yes")],
 		[resumeGame, deleteSelectedEntities],
 		[null, selection]
 	);
 }
 
 function openSave()
 {
 	closeOpenDialogs();
 	pauseGame();
 	Engine.PushGuiPage("page_savegame.xml", { "savedGameData": getSavedGameData(), "callback": "resumeGame" });
 }
 
 function openOptions()
 {
 	closeOpenDialogs();
 	pauseGame();
 	Engine.PushGuiPage("page_options.xml", { "callback": "resumeGame" });
 }
 
 function openChat()
 {
 	if (g_Disconnected)
 		return;
 
 	closeOpenDialogs();
 
 	setTeamChat(false);
 
 	Engine.GetGUIObjectByName("chatInput").focus(); // Grant focus to the input area
 	Engine.GetGUIObjectByName("chatDialogPanel").hidden = false;
 }
 
 function closeChat()
 {
 	Engine.GetGUIObjectByName("chatInput").caption = ""; // Clear chat input
 	Engine.GetGUIObjectByName("chatInput").blur(); // Remove focus
 	Engine.GetGUIObjectByName("chatDialogPanel").hidden = true;
 }
 
 /**
  * If the teamchat hotkey was pressed, set allies or observers as addressees,
  * otherwise send to everyone.
  */
 function setTeamChat(teamChat = false)
 {
 	let command = teamChat ? (g_IsObserver ? "/observers" : "/allies") : "";
 	let chatAddressee = Engine.GetGUIObjectByName("chatAddressee");
 	chatAddressee.selected = chatAddressee.list_data.indexOf(command);
 }
 
 /**
  * Opens chat-window or closes it and sends the userinput.
  */
 function toggleChatWindow(teamChat)
 {
 	if (g_Disconnected)
 		return;
 
 	let chatWindow = Engine.GetGUIObjectByName("chatDialogPanel");
 	let chatInput = Engine.GetGUIObjectByName("chatInput");
 	let hidden = chatWindow.hidden;
 
 	closeOpenDialogs();
 
 	if (hidden)
 	{
 		setTeamChat(teamChat);
 		chatInput.focus();
 	}
 	else
 	{
 		if (chatInput.caption.length)
 		{
 			submitChatInput();
 			return;
 		}
 		chatInput.caption = "";
 	}
 
 	chatWindow.hidden = !hidden;
 }
 
 function openDiplomacy()
 {
 	closeOpenDialogs();
 
 	if (g_ViewedPlayer < 1)
 		return;
 
 	g_IsDiplomacyOpen = true;
 
 	let isCeasefireActive = GetSimState().ceasefireActive;
 
 	// Get offset for one line
 	let onesize = Engine.GetGUIObjectByName("diplomacyPlayer[0]").size;
 	let rowsize = onesize.bottom - onesize.top;
 
 	// We don't include gaia
 	for (let i = 1; i < g_Players.length; ++i)
 	{
 		let myself = i == g_ViewedPlayer;
 		let playerInactive = isPlayerObserver(g_ViewedPlayer) || isPlayerObserver(i);
 		let hasAllies = g_Players.filter(player => player.isMutualAlly[g_ViewedPlayer]).length > 1;
 
 		diplomacySetupTexts(i, rowsize);
 		diplomacyFormatStanceButtons(i, myself || playerInactive || isCeasefireActive || g_Players[g_ViewedPlayer].teamsLocked);
 		diplomacyFormatTributeButtons(i, myself || playerInactive);
 		diplomacyFormatAttackRequestButton(i, myself || playerInactive || isCeasefireActive || !hasAllies || !g_Players[i].isEnemy[g_ViewedPlayer]);
 	}
 
 	Engine.GetGUIObjectByName("diplomacyDialogPanel").hidden = false;
 }
 
 function diplomacySetupTexts(i, rowsize)
 {
 	// Apply offset
 	let row = Engine.GetGUIObjectByName("diplomacyPlayer["+(i-1)+"]");
 	let size = row.size;
 	size.top = rowsize * (i-1);
 	size.bottom = rowsize * i;
 	row.size = size;
 
 	// Set background color
 	row.sprite = "color: " + rgbToGuiColor(g_Players[i].color) + " 32";
 
 	Engine.GetGUIObjectByName("diplomacyPlayerName["+(i-1)+"]").caption = colorizePlayernameByID(i);
 	Engine.GetGUIObjectByName("diplomacyPlayerCiv["+(i-1)+"]").caption = g_CivData[g_Players[i].civ].Name;
 
 	Engine.GetGUIObjectByName("diplomacyPlayerTeam["+(i-1)+"]").caption =
 		g_Players[i].team < 0 ? translateWithContext("team", "None") : g_Players[i].team+1;
 
 	Engine.GetGUIObjectByName("diplomacyPlayerTheirs["+(i-1)+"]").caption =
 		i == g_ViewedPlayer ? "" :
 		g_Players[i].isAlly[g_ViewedPlayer] ? translate("Ally") :
 		g_Players[i].isNeutral[g_ViewedPlayer] ? translate("Neutral") : translate("Enemy");
 }
 
 function diplomacyFormatStanceButtons(i, hidden)
 {
 	for (let stance of ["Ally", "Neutral", "Enemy"])
 	{
 		let button = Engine.GetGUIObjectByName("diplomacyPlayer"+stance+"["+(i-1)+"]");
 		button.hidden = hidden;
 		if (hidden)
 			continue;
 
 		button.caption = g_Players[g_ViewedPlayer]["is" + stance][i] ? translate("x") : "";
 		button.enabled = controlsPlayer(g_ViewedPlayer);
 		button.onpress = (function(player, stance) { return function() {
 			Engine.PostNetworkCommand({ "type": "diplomacy", "player": i, "to": stance.toLowerCase() });
 		}; })(i, stance);
 	}
 }
 
 function diplomacyFormatTributeButtons(i, hidden)
 {
 	for (let resource of RESOURCES)
 	{
 		let button = Engine.GetGUIObjectByName("diplomacyPlayerTribute"+resource[0].toUpperCase()+resource.substring(1)+"["+(i-1)+"]");
 		button.hidden = hidden;
 		if (hidden)
 			continue;
 
 		button.enabled = controlsPlayer(g_ViewedPlayer);
 		button.tooltip = formatTributeTooltip(i, resource, 100);
 		button.onpress = (function(i, resource, button) {
 			// Shift+click to send 500, shift+click+click to send 1000, etc.
 			// See INPUT_MASSTRIBUTING in input.js
 			let multiplier = 1;
 			return function() {
 				let isBatchTrainPressed = Engine.HotkeyIsPressed("session.masstribute");
 				if (isBatchTrainPressed)
 				{
 					inputState = INPUT_MASSTRIBUTING;
 					multiplier += multiplier == 1 ? 4 : 5;
 				}
 
 				let amounts = {};
 				for (let type of RESOURCES)
 					amounts[type] = 0;
 				amounts[resource] = 100 * multiplier;
 
 				button.tooltip = formatTributeTooltip(i, resource, amounts[resource]);
 
 				// This is in a closure so that we have access to `player`, `amounts`, and `multiplier` without some
 				// evil global variable hackery.
 				g_FlushTributing = function() {
 					Engine.PostNetworkCommand({ "type": "tribute", "player": i, "amounts":  amounts });
 					multiplier = 1;
 					button.tooltip = formatTributeTooltip(i, resource, 100);
 				};
 
 				if (!isBatchTrainPressed)
 					g_FlushTributing();
 			};
 		})(i, resource, button);
 	}
 }
 
 function diplomacyFormatAttackRequestButton(i, hidden)
 {
 	let button = Engine.GetGUIObjectByName("diplomacyAttackRequest["+(i-1)+"]");
 	button.hidden = hidden;
 	if (hidden)
 		return;
 
 	button.enabled = controlsPlayer(g_ViewedPlayer);
 	button.tooltip = translate("Request your allies to attack this enemy");
 	button.onpress = (function(i) { return function() {
 		Engine.PostNetworkCommand({ "type": "attack-request", "source": g_ViewedPlayer, "target": i });
 	}; })(i);
 }
 
 function closeDiplomacy()
 {
 	g_IsDiplomacyOpen = false;
 	Engine.GetGUIObjectByName("diplomacyDialogPanel").hidden = true;
 }
 
 function toggleDiplomacy()
 {
 	let open = g_IsDiplomacyOpen;
 	closeOpenDialogs();
 
 	if (!open)
 		openDiplomacy();
 }
 
 function openTrade()
 {
 	closeOpenDialogs();
 
 	if (g_ViewedPlayer < 1)
 		return;
 
 	g_IsTradeOpen = true;
 
 	var updateButtons = function()
 	{
 		for (var res in button)
 		{
 			button[res].label.caption = proba[res] + "%";
 
 			button[res].sel.hidden = !controlsPlayer(g_ViewedPlayer) || res != selec;
 			button[res].up.hidden = !controlsPlayer(g_ViewedPlayer) || res == selec || proba[res] == 100 || proba[selec] == 0;
 			button[res].dn.hidden = !controlsPlayer(g_ViewedPlayer) || res == selec || proba[res] == 0 || proba[selec] == 100;
 		}
 	};
 
 	var proba = Engine.GuiInterfaceCall("GetTradingGoods", g_ViewedPlayer);
 	var button = {};
 	var selec = RESOURCES[0];
 	for (var i = 0; i < RESOURCES.length; ++i)
 	{
 		var buttonResource = Engine.GetGUIObjectByName("tradeResource["+i+"]");
 		if (i > 0)
 		{
 			var size = Engine.GetGUIObjectByName("tradeResource["+(i-1)+"]").size;
 			var width = size.right - size.left;
 			size.left += width;
 			size.right += width;
 			Engine.GetGUIObjectByName("tradeResource["+i+"]").size = size;
 		}
 		var resource = RESOURCES[i];
 		proba[resource] = (proba[resource] ? proba[resource] : 0);
 		var buttonResource = Engine.GetGUIObjectByName("tradeResourceButton["+i+"]");
 		var icon = Engine.GetGUIObjectByName("tradeResourceIcon["+i+"]");
 		icon.sprite = "stretched:session/icons/resources/" + resource + ".png";
 		var label = Engine.GetGUIObjectByName("tradeResourceText["+i+"]");
 		var buttonUp = Engine.GetGUIObjectByName("tradeArrowUp["+i+"]");
 		var buttonDn = Engine.GetGUIObjectByName("tradeArrowDn["+i+"]");
 		var iconSel = Engine.GetGUIObjectByName("tradeResourceSelection["+i+"]");
 		button[resource] = { "up": buttonUp, "dn": buttonDn, "label": label, "sel": iconSel };
 
 		buttonResource.enabled = controlsPlayer(g_ViewedPlayer);
 		buttonResource.onpress = (function(resource){
 			return function() {
 				if (Engine.HotkeyIsPressed("session.fulltradeswap"))
 				{
 					for (var ress of RESOURCES)
 						proba[ress] = 0;
 					proba[resource] = 100;
 					Engine.PostNetworkCommand({"type": "set-trading-goods", "tradingGoods": proba});
 				}
 				selec = resource;
 				updateButtons();
 			};
 		})(resource);
 
 		buttonUp.enabled = controlsPlayer(g_ViewedPlayer);
 		buttonUp.onpress = (function(resource){
 			return function() {
 				proba[resource] += Math.min(STEP, proba[selec]);
 				proba[selec]    -= Math.min(STEP, proba[selec]);
 				Engine.PostNetworkCommand({"type": "set-trading-goods", "tradingGoods": proba});
 				updateButtons();
 			};
 		})(resource);
 
 		buttonDn.enabled = controlsPlayer(g_ViewedPlayer);
 		buttonDn.onpress = (function(resource){
 			return function() {
 				proba[selec]    += Math.min(STEP, proba[resource]);
 				proba[resource] -= Math.min(STEP, proba[resource]);
 				Engine.PostNetworkCommand({"type": "set-trading-goods", "tradingGoods": proba});
 				updateButtons();
 			};
 		})(resource);
 	}
 	updateButtons();
 
 	let traderNumber = Engine.GuiInterfaceCall("GetTraderNumber", g_ViewedPlayer);
 	Engine.GetGUIObjectByName("landTraders").caption = getIdleLandTradersText(traderNumber);
 	Engine.GetGUIObjectByName("shipTraders").caption = getIdleShipTradersText(traderNumber);
 
 	Engine.GetGUIObjectByName("tradeDialogPanel").hidden = false;
 }
 
 function getIdleLandTradersText(traderNumber)
 {
 	let active = traderNumber.landTrader.trading;
 	let garrisoned = traderNumber.landTrader.garrisoned;
 	let inactive = traderNumber.landTrader.total - active - garrisoned;
 
 	let messageTypes = {
 		"active": {
 			"garrisoned": {
 				"no-inactive": translate("%(openingTradingString)s, and %(garrisonedString)s."),
 				"inactive":    translate("%(openingTradingString)s, %(garrisonedString)s, and %(inactiveString)s.")
 			},
 			"no-garrisoned": {
 				"no-inactive": translate("%(openingTradingString)s."),
 				"inactive":    translate("%(openingTradingString)s, and %(inactiveString)s.")
 			}
 		},
 		"no-active": {
 			"garrisoned": {
 				"no-inactive": translate("%(openingGarrisonedString)s."),
 				"inactive": translate("%(openingGarrisonedString)s, and %(inactiveString)s.")
 			},
 			"no-garrisoned": {
 				"inactive": translatePlural("There is %(inactiveString)s.", "There are %(inactiveString)s.", inactive),
 				"no-inactive": translate("There are no land traders.")
 			}
 		}
 	};
 
 	let message = messageTypes[active ? "active" : "no-active"][garrisoned ? "garrisoned" : "no-garrisoned"][inactive ? "inactive" : "no-inactive"];
 
 	let activeString = sprintf(
 		translatePlural(
 			"There is %(numberTrading)s land trader trading",
 			"There are %(numberTrading)s land traders trading",
 			active
 		),
 		{ "numberTrading": active }
 	);
 
 	let inactiveString = sprintf(active || garrisoned ?
 		translatePlural(
 			"%(numberOfLandTraders)s inactive",
 			"%(numberOfLandTraders)s inactive",
 			inactive
 		) :
 		translatePlural(
 			"%(numberOfLandTraders)s land trader inactive",
 			"%(numberOfLandTraders)s land traders inactive",
 			inactive
 		),
 		{ "numberOfLandTraders": inactive }
 	);
 
 	let garrisonedString = sprintf(active || inactive ?
 		translatePlural(
 			"%(numberGarrisoned)s garrisoned on a trading merchant ship",
 			"%(numberGarrisoned)s garrisoned on a trading merchant ship",
 			garrisoned
 		) :
 		translatePlural(
 			"There is %(numberGarrisoned)s land trader garrisoned on a trading merchant ship",
 			"There are %(numberGarrisoned)s land traders garrisoned on a trading merchant ship",
 			garrisoned
 		),
 		{ "numberGarrisoned": garrisoned }
 	);
 
 	return sprintf(message, {
 		"openingTradingString": activeString,
 		"openingGarrisonedString": garrisonedString,
 		"garrisonedString": garrisonedString,
 		"inactiveString": "[color=\"" + g_IdleTraderTextColor + "\"]" + inactiveString + "[/color]"
 	});
 }
 
 function getIdleShipTradersText(traderNumber)
 {
 	let active = traderNumber.shipTrader.trading;
 	let inactive = traderNumber.shipTrader.total - active;
 
 	let messageTypes = {
 		"active": {
 			"inactive": translate("%(openingTradingString)s, and %(inactiveString)s."),
 			"no-inactive": translate("%(openingTradingString)s.")
 		},
 		"no-active": {
 			"inactive": translatePlural("There is %(inactiveString)s.", "There are %(inactiveString)s.", inactive),
 			"no-inactive": translate("There are no merchant ships.")
 		}
 	};
 
 	let message = messageTypes[active ? "active" : "no-active"][inactive ? "inactive" : "no-inactive"];
 
 	let activeString = sprintf(
 		translatePlural(
 			"There is %(numberTrading)s merchant ship trading",
 			"There are %(numberTrading)s merchant ships trading",
 			active
 		),
 		{ "numberTrading": active }
 	);
 
 	let inactiveString = sprintf(active ?
 		translatePlural(
 			"%(numberOfShipTraders)s inactive",
 			"%(numberOfShipTraders)s inactive",
 			inactive
 		) :
 		translatePlural(
 			"%(numberOfShipTraders)s merchant ship inactive",
 			"%(numberOfShipTraders)s merchant ships inactive",
 			inactive
 		),
 		{ "numberOfShipTraders": inactive }
 	);
 
 	return sprintf(message, {
 		"openingTradingString": activeString,
 		"inactiveString": "[color=\"" + g_IdleTraderTextColor + "\"]" + inactiveString + "[/color]"
 	});
 }
 
 function closeTrade()
 {
 	g_IsTradeOpen = false;
 	Engine.GetGUIObjectByName("tradeDialogPanel").hidden = true;
 }
 
 function toggleTrade()
 {
 	let open = g_IsTradeOpen;
 	closeOpenDialogs();
 
 	if (!open)
 		openTrade();
 }
 
 function toggleGameSpeed()
 {
 	let gameSpeed = Engine.GetGUIObjectByName("gameSpeed");
 	gameSpeed.hidden = !gameSpeed.hidden;
 }
 
 function openGameSummary()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 
 	Engine.PushGuiPage("page_summary.xml", {
 		"timeElapsed" : extendedSimState.timeElapsed,
 		"playerStates": extendedSimState.players,
 		"players": g_Players,
 		"mapSettings": Engine.GetMapSettings(),
 		"isInGame": true,
 		"gameResult": translate("Current Scores"),
 		"callback": "resumeGame"
 	});
 }
 
 function openStrucTree()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	// TODO add info about researched techs and unlocked entities
 	Engine.PushGuiPage("page_structree.xml", {
 		"civ" : g_Players[g_ViewedPlayer].civ,
 		"callback": "resumeGame",
 	});
 }
 
 /**
- * Pause the game in single player mode.
+ * Pause or resume the game.
+ *
+ * @param explicit - true if the player explicitly wants to pause or resume.
+ * If this argument isn't set, a multiplayer game won't be paused and the pause overlay
+ * won't be shown in single player.
  */
-function pauseGame()
+function pauseGame(pause = true, explicit = false)
 {
+	if (g_IsNetworked && !explicit)
+		return;
+
+	if (explicit)
+		g_Paused = pause;
+
+	Engine.SetPaused(g_Paused || pause, !!explicit);
+
 	if (g_IsNetworked)
+	{
+		setClientPauseState(Engine.GetPlayerGUID(), g_Paused);
 		return;
+	}
 
-	Engine.GetGUIObjectByName("pauseButtonText").caption = translate("Resume");
-	Engine.GetGUIObjectByName("pauseOverlay").hidden = false;
-	Engine.SetPaused(true);
+	updatePauseOverlay();
 }
 
-function resumeGame()
+/**
+ * Resume the game.
+ *
+ * @param explicit - true if the player explicitly wants to resume the game.
+ * If this argument isn't set, a multiplayer game won't be resumed and the pause overlay won't
+ * be closed in single player.
+ */
+function resumeGame(explicit = false)
 {
-	Engine.GetGUIObjectByName("pauseButtonText").caption = translate("Pause");
-	Engine.GetGUIObjectByName("pauseOverlay").hidden = true;
-	Engine.SetPaused(false);
+	pauseGame(false, explicit);
 }
 
+/**
+ * Called when the current player toggles a pause button.
+ */
 function togglePause()
 {
 	if (!Engine.GetGUIObjectByName("pauseButton").enabled)
 		return;
 
 	closeOpenDialogs();
 
-	let pauseOverlay = Engine.GetGUIObjectByName("pauseOverlay");
+	pauseGame(!g_Paused, true);
+}
+
+/**
+ * Called when a client pauses or resumes in a multiplayer game.
+ */
+function setClientPauseState(guid, paused)
+{
+	// Update the list of pausing clients.
+	let index = g_PausingClients.indexOf(guid)
+	if (paused && index == -1)
+		g_PausingClients.push(guid);
+	else if (!paused && index != -1)
+		g_PausingClients.splice(index, 1);
+
+	updatePauseOverlay();
+
+	Engine.SetPaused(!!g_PausingClients.length, false);
+}
+
+/**
+ * Update the pause overlay.
+ */
+function updatePauseOverlay()
+{
+	Engine.GetGUIObjectByName("pauseButtonText").caption = g_Paused ? translate("Resume") : translate("Pause");
+	Engine.GetGUIObjectByName("resumeMessage").hidden = !g_Paused;
 
-	Engine.SetPaused(pauseOverlay.hidden);
-	Engine.GetGUIObjectByName("pauseButtonText").caption = pauseOverlay.hidden ? translate("Resume") : translate("Pause");
+	Engine.GetGUIObjectByName("pausedByText").hidden = !g_IsNetworked;
+	Engine.GetGUIObjectByName("pausedByText").caption = sprintf(translate("Paused by %(players)s"),
+		{ "players": g_PausingClients.map(guid => colorizePlayernameByGUID(guid)).join(translate(", ")) });
 
-	pauseOverlay.hidden = !pauseOverlay.hidden;
+	Engine.GetGUIObjectByName("pauseOverlay").hidden = !(g_Paused || g_PausingClients.length);
+	Engine.GetGUIObjectByName("pauseOverlay").onPress = g_Paused ? togglePause : function() {};
 }
 
 function openManual()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	Engine.PushGuiPage("page_manual.xml", {
 		"page": "manual/intro",
 		"title": translate("Manual"),
 		"url": "http://trac.wildfiregames.com/wiki/0adManual",
 		"callback": "resumeGame"
 	});
 }
 
 function toggleDeveloperOverlay()
 {
 	// The developer overlay is disabled in ranked games
 	if (Engine.HasXmppClient() && Engine.IsRankedGame())
 		return;
 
 	let devCommands = Engine.GetGUIObjectByName("devCommands");
 	devCommands.hidden = !devCommands.hidden;
 
 	let message = devCommands.hidden ?
 		markForTranslation("The Developer Overlay was closed.") :
 		markForTranslation("The Developer Overlay was opened.");
 
 	Engine.PostNetworkCommand({
 		"type": "aichat",
 		"message": message,
 		"translateMessage": true,
 		"translateParameters": [],
 		"parameters": {}
 	});
 }
 
 function closeOpenDialogs()
 {
 	closeMenu();
 	closeChat();
 	closeDiplomacy();
 	closeTrade();
 }
 
 function formatTributeTooltip(playerID, resource, amount)
 {
 	return sprintf(translate("Tribute %(resourceAmount)s %(resourceType)s to %(playerName)s. Shift-click to tribute %(greaterAmount)s."), {
 		"resourceAmount": amount,
 		"resourceType": getLocalizedResourceName(resource, "withinSentence"),
 		"playerName": colorizePlayernameByID(playerID),
 		"greaterAmount": amount < 500 ? 500 : amount + 500
 	});
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/messages.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/messages.js	(revision 18203)
+++ ps/trunk/binaries/data/mods/public/gui/session/messages.js	(revision 18204)
@@ -1,900 +1,907 @@
 /**
  * All known cheat commands.
  * @type {Object}
  */
 const g_Cheats = getCheatsData();
 
 /**
  * Number of seconds after which chatmessages will disappear.
  */
 const g_ChatTimeout = 30;
 
 /**
  * Maximum number of lines to display simultaneously.
  */
 const g_ChatLines = 20;
 
 /**
  * The strings to be displayed including sender and formating.
  */
 var g_ChatMessages = [];
 
 /**
  * Holds the timer-IDs used for hiding the chat after g_ChatTimeout seconds.
  */
 var g_ChatTimers = [];
 
 /**
  * Handle all netmessage types that can occur.
  */
 var g_NetMessageTypes = {
 	"netstatus": msg => handleNetStatusMessage(msg),
 	"netwarn": msg => addNetworkWarning(msg),
 	"players": msg => handlePlayerAssignmentsMessage(msg),
+	"paused": msg => setClientPauseState(msg.guid, msg.pause),
 	"rejoined": msg => addChatMessage({ "type": "rejoined", "guid": msg.guid }),
 	"kicked": msg => addChatMessage({ "type": "system", "text": sprintf(translate("%(username)s has been kicked"), { "username": msg.username }) }),
 	"banned": msg => addChatMessage({ "type": "system", "text": sprintf(translate("%(username)s has been banned"), { "username": msg.username }) }),
 	"chat": msg => addChatMessage({ "type": "message", "guid": msg.guid, "text": msg.text }),
 	"aichat": msg => addChatMessage({ "type": "message", "guid": msg.guid, "text": msg.text, "translate": true }),
 	"gamesetup": msg => "", // Needed for autostart
 	"start": msg => ""
 };
 
 var g_FormatChatMessage = {
 	"system": msg => msg.text,
 	"connect": msg => sprintf(translate("%(player)s is starting to rejoin the game."), { "player": colorizePlayernameByGUID(msg.guid) }),
 	"disconnect": msg => sprintf(translate("%(player)s has left the game."), { "player": colorizePlayernameByGUID(msg.guid) }),
 	"rejoined": msg => sprintf(translate("%(player)s has rejoined the game."), { "player": colorizePlayernameByGUID(msg.guid) }),
 	"clientlist": msg => getUsernameList(),
 	"message": msg => formatChatCommand(msg),
 	"defeat": msg => formatDefeatMessage(msg),
 	"diplomacy": msg => formatDiplomacyMessage(msg),
 	"tribute": msg => formatTributeMessage(msg),
 	"attack": msg => formatAttackMessage(msg)
 };
 
 /**
  * Show a label and grey overlay or hide both on connection change.
  */
 var g_StatusMessageTypes = {
 	"authenticated": msg => translate("Connection to the server has been authenticated."),
 	"connected": msg => translate("Connected to the server."),
 	"disconnected": msg => translate("Connection to the server has been lost.") + "\n" +
 		// Translation: States the reason why the client disconnected from the server.
 		sprintf(translate("Reason: %(reason)s."), { "reason": getDisconnectReason(msg.reason, true) }),
 	"waiting_for_players": msg => translate("Waiting for other players to connect..."),
 	"join_syncing": msg => translate("Synchronising gameplay with other players..."),
 	"active": msg => ""
 };
 
 /**
  * Chatmessage shown after commands like /me or /enemies.
  */
 var g_ChatCommands = {
 	"regular": {
 		"context": translate("(%(context)s) %(userTag)s %(message)s"),
 		"no-context": translate("%(userTag)s %(message)s")
 	},
 	"me": {
 		"context": translate("(%(context)s) * %(user)s %(message)s"),
 		"no-context": translate("* %(user)s %(message)s")
 	}
 };
 
 var g_ChatAddresseeContext = {
 	"/team": translate("Team"),
 	"/allies": translate("Ally"),
 	"/enemies": translate("Enemy"),
 	"/observers": translate("Observer"),
 	"/msg": translate("Private")
 };
 
 /**
  * Returns true if the current player is an addressee, given the chat message type and sender.
  */
 var g_IsChatAddressee = {
 	"/team": senderID =>
 		g_Players[senderID] &&
 		g_Players[Engine.GetPlayerID()] &&
 		g_Players[Engine.GetPlayerID()].team != -1 &&
 		g_Players[Engine.GetPlayerID()].team == g_Players[senderID].team,
 
 	"/allies": senderID =>
 		g_Players[senderID] &&
 		g_Players[Engine.GetPlayerID()] &&
 		g_Players[senderID].isMutualAlly[Engine.GetPlayerID()],
 
 	"/enemies": senderID =>
 		g_Players[senderID] &&
 		g_Players[Engine.GetPlayerID()] &&
 		g_Players[senderID].isEnemy[Engine.GetPlayerID()],
 
 	"/observers": senderID =>
 		g_IsObserver,
 
 	"/msg": (senderID, addresseeGUID) =>
 		addresseeGUID == Engine.GetPlayerGUID()
 };
 
 /**
  * Chatmessage shown on diplomacy change.
  */
 var g_DiplomacyMessages = {
 	"active": {
 		"ally": translate("You are now allied with %(player)s."),
 		"enemy": translate("You are now at war with %(player)s."),
 		"neutral": translate("You are now neutral with %(player)s.")
 	},
 	"passive": {
 		"ally": translate("%(player)s is now allied with you."),
 		"enemy": translate("%(player)s is now at war with you."),
 		"neutral": translate("%(player)s is now neutral with you.")
 	},
 	"observer": {
 		"ally": translate("%(player)s is now allied with %(player2)s."),
 		"enemy": translate("%(player)s is now at war with %(player2)s."),
 		"neutral": translate("%(player)s is now neutral with %(player2)s.")
 	}
 };
 
 /**
  * Defines how the GUI reacts to notifications that are sent by the simulation.
  */
 var g_NotificationsTypes =
 {
 	"chat": function(notification, player)
 	{
 		let message = {
 			"type": "message",
 			"guid": findGuidForPlayerID(player) || -1,
 			"text": notification.message
 		};
 
 		if (message.guid == -1)
 			message.player = player;
 
 		addChatMessage(message);
 	},
 	"aichat": function(notification, player)
 	{
 		let message = {
 			"guid": findGuidForPlayerID(player) || -1,
 			"type": "message",
 			"text": notification.message,
 			"translate": true
 		};
 
 		if (message.guid == -1)
 			message.player = player;
 
 		if (notification.translateParameters)
 		{
 			message.translateParameters = notification.translateParameters;
 			message.parameters = notification.parameters;
 			// special case for formatting of player names which are transmitted as _player_num
 			for (let param in message.parameters)
 			{
 				if (!param.startsWith("_player_"))
 					continue;
 
 				message.parameters[param] = colorizePlayernameByID(message.parameters[param]);
 			}
 		}
 
 		addChatMessage(message);
 	},
 	"defeat": function(notification, player)
 	{
 		addChatMessage({
 			"type": "defeat",
 			"guid": findGuidForPlayerID(player),
 			"player": player,
 			"resign": !!notification.resign
 		});
 
 		updateDiplomacy();
 		updateChatAddressees();
 	},
 	"diplomacy": function(notification, player)
 	{
 		addChatMessage({
 			"type": "diplomacy",
 			"sourcePlayer": player,
 			"targetPlayer": notification.targetPlayer,
 			"status": notification.status
 		});
 
 		updateDiplomacy();
 	},
 	"quit": function(notification, player)
 	{
 		Engine.Exit();
 	},
 	"tribute": function(notification, player)
 	{
 		addChatMessage({
 			"type": "tribute",
 			"sourcePlayer": notification.donator,
 			"targetPlayer": player,
 			"amounts": notification.amounts
 		});
 	},
 	"attack": function(notification, player)
 	{
 		if (player != g_ViewedPlayer)
 			return;
 
 		// Focus camera on attacks
 		if (g_FollowPlayer)
 		{
 			setCameraFollow(notification.target);
 
 			g_Selection.reset();
 			if (notification.target)
 				g_Selection.addList([notification.target]);
 		}
 
 		if (Engine.ConfigDB_GetValue("user", "gui.session.attacknotificationmessage") !== "true")
 			return;
 
 		addChatMessage({
 			"type": "attack",
 			"player": player,
 			"attacker": notification.attacker,
 			"targetIsDomesticAnimal": notification.targetIsDomesticAnimal
 		});
 	},
 	"dialog": function(notification, player)
 	{
 		if (player == Engine.GetPlayerID())
 			openDialog(notification.dialogName, notification.data, player);
 	},
 	"resetselectionpannel": function(notification, player)
 	{
 		if (player != Engine.GetPlayerID())
 			return;
 		g_Selection.rebuildSelection({});
 	},
 	"playercommand": function(notification, player)
 	{
 		// For observers, focus the camera on units commanded by the selected player
 		if (!g_FollowPlayer || player != g_ViewedPlayer)
 			return;
 
 		let cmd = notification.cmd;
 
 		// Ignore boring animals
 		let entState = cmd.entities && cmd.entities[0] && GetEntityState(cmd.entities[0]);
 		if (entState && entState.identity && entState.identity.classes &&
 				entState.identity.classes.indexOf("Animal") != -1)
 			return;
 
 		// Focus the building to construct
 		if (cmd.type == "repair")
 		{
 			let targetState = GetEntityState(cmd.target);
 			if (targetState)
 				Engine.CameraMoveTo(targetState.position.x, targetState.position.z);
 		}
 		// Focus commanded entities, but don't lose previous focus when training units
 		else if (cmd.type != "train" && cmd.type != "research" && entState)
 			setCameraFollow(cmd.entities[0]);
 
 		// Select units affected by that command
 		let selection = [];
 		if (cmd.entities)
 			selection = cmd.entities;
 		if (cmd.target)
 			selection.push(cmd.target);
 
 		// Allow gaia in selection when gathering
 		g_Selection.reset();
 		g_Selection.addList(selection, false, cmd.type == "gather");
 	}
 };
 
 /**
  * Loads all known cheat commands.
  *
  * @returns {Object}
  */
 function getCheatsData()
 {
 	let cheats = {};
 	for (let fileName of getJSONFileList("simulation/data/cheats/"))
 	{
 		let currentCheat = Engine.ReadJSONFile("simulation/data/cheats/"+fileName+".json");
 		if (!currentCheat)
 			continue;
 		if (Object.keys(cheats).indexOf(currentCheat.Name) !== -1)
 			warn("Cheat name '" + currentCheat.Name + "' is already present");
 		else
 			cheats[currentCheat.Name] = currentCheat.Data;
 	}
 	return cheats;
 }
 
 /**
  * Reads userinput from the chat and sends a simulation command in case it is a known cheat.
  * Hence cheats won't be sent as chat over network.
  *
  * @param {string} text
  * @returns {boolean} - True if a cheat was executed.
  */
 function executeCheat(text)
 {
 	if (g_IsObserver || !g_Players[Engine.GetPlayerID()].cheatsEnabled)
 		return false;
 
 	// Find the cheat code that is a prefix of the user input
 	let cheatCode = Object.keys(g_Cheats).find(cheatCode => text.indexOf(cheatCode) == 0);
 	if (!cheatCode)
 		return false;
 
 	let cheat = g_Cheats[cheatCode];
 
 	let parameter = text.substr(cheatCode.length);
 	if (cheat.isNumeric)
 		parameter = +parameter;
 
 	if (cheat.DefaultParameter && (isNaN(parameter) || parameter <= 0))
 		parameter = cheat.DefaultParameter;
 
 	Engine.PostNetworkCommand({
 		"type": "cheat",
 		"action": cheat.Action,
 		"text": cheat.Type,
 		"player": Engine.GetPlayerID(),
 		"parameter": parameter,
 		"templates": cheat.Templates,
 		"selected": g_Selection.toList()
 	});
 
 	return true;
 }
 
 function findGuidForPlayerID(playerID)
 {
 	return Object.keys(g_PlayerAssignments).find(guid => g_PlayerAssignments[guid].player == playerID);
 }
 
 /**
  * Processes all pending notifications sent from the GUIInterface simulation component.
  */
 function handleNotifications()
 {
 	let notifications = Engine.GuiInterfaceCall("GetNotifications");
 	for (let notification of notifications)
 	{
 		if (!notification.players || !notification.type || !g_NotificationsTypes[notification.type])
 		{
 			error("Invalid GUI notification: " + uneval(notification));
 			continue;
 		}
 
 		for (let player of notification.players)
 			g_NotificationsTypes[notification.type](notification, player);
 	}
 }
 
 /**
  * Updates playerdata cache and refresh diplomacy panel.
  */
 function updateDiplomacy()
 {
 	g_Players = getPlayerData(g_PlayerAssignments, g_Players);
 
 	if (g_IsDiplomacyOpen)
 		openDiplomacy();
 }
 
 /**
  * Displays all active counters (messages showing the remaining time) for wonder-victory, ceasefire etc.
  */
 function updateTimeNotifications()
 {
 	let notifications =  Engine.GuiInterfaceCall("GetTimeNotifications", g_ViewedPlayer);
 	let notificationText = "";
 	for (let n of notifications)
 	{
 		let message = n.message;
 		if (n.translateMessage)
 			message = translate(message);
 
 		let parameters = n.parameters || {};
 		if (n.translateParameters)
 			translateObjectKeys(parameters, n.translateParameters);
 
 		parameters.time = timeToString(n.endTime - g_SimState.timeElapsed);
 
 		notificationText += sprintf(message, parameters) + "\n";
 	}
 	Engine.GetGUIObjectByName("notificationText").caption = notificationText;
 }
 
 /**
  * Processes a CNetMessage (see NetMessage.h, NetMessages.h) sent by the CNetServer.
  * Saves the received object to mainlog.html.
  *
  * @param {Object} msg
  */
 function handleNetMessage(msg)
 {
 	log("Net message: " + uneval(msg));
 
 	if (g_NetMessageTypes[msg.type])
 		g_NetMessageTypes[msg.type](msg);
 	else
 		error("Unrecognised net message type '" + msg.type + "'");
 }
 
 /**
  * @param {Object} message
  */
 function handleNetStatusMessage(message)
 {
 	if (g_Disconnected)
 		return;
 
 	if (!g_StatusMessageTypes[message.status])
 	{
 		error("Unrecognised netstatus type '" + message.status + "'");
 		return;
 	}
 
 	let label = Engine.GetGUIObjectByName("netStatus");
 	let statusMessage = g_StatusMessageTypes[message.status](message);
 	label.caption = statusMessage;
 	label.hidden = !statusMessage;
 
 	if (message.status == "disconnected")
 	{
+		// Hide the pause overlay, and pause animations.
+		Engine.GetGUIObjectByName("pauseOverlay").hidden = true;
+		Engine.SetPaused(true, false);
+
 		g_Disconnected = true;
 		closeOpenDialogs();
 	}
 }
 
 function handlePlayerAssignmentsMessage(message)
 {
 	// Find and report all leavings
 	for (let guid in g_PlayerAssignments)
 	{
 		if (message.hosts[guid])
 			continue;
 
+		setClientPauseState(guid, false);
+
 		addChatMessage({ "type": "disconnect", "guid": guid });
 
 		for (let id in g_Players)
 			if (g_Players[id].guid == guid)
 				g_Players[id].offline = true;
 	}
 
 	let joins = Object.keys(message.hosts).filter(guid => !g_PlayerAssignments[guid]);
 
 	g_PlayerAssignments = message.hosts;
 
 	// Report all joinings
 	joins.forEach(guid => {
 
 		let playerID = g_PlayerAssignments[guid].player;
 		if (g_Players[playerID])
 		{
 			g_Players[playerID].guid = guid;
 			g_Players[playerID].name = g_PlayerAssignments[guid].name;
 			g_Players[playerID].offline = false;
 		}
 
 		addChatMessage({ "type": "connect", "guid": guid });
 	});
 
 	updateChatAddressees();
 
 	// Update lobby gamestatus
 	if (g_IsController && Engine.HasXmppClient())
 	{
 		let players = Object.keys(g_PlayerAssignments).map(guid => g_PlayerAssignments[guid].name);
 		Engine.SendChangeStateGame(Object.keys(g_PlayerAssignments).length, players.join(", "));
 	}
 }
 
 function updateChatAddressees()
 {
 	let addressees = [
 		{
 			"label": translateWithContext("chat addressee", "Everyone"),
 			"cmd": ""
 		}
 	];
 
 	if (!g_IsObserver)
 	{
 		addressees.push({
 			"label": translateWithContext("chat addressee", "Allies"),
 			"cmd": "/allies"
 		});
 		addressees.push({
 			"label": translateWithContext("chat addressee", "Enemies"),
 			"cmd": "/enemies"
 		});
 	}
 
 	addressees.push({
 		"label": translateWithContext("chat addressee", "Observers"),
 		"cmd": "/observers"
 	});
 
 	// Add playernames for private messages
 	for (let guid of sortGUIDsByPlayerID())
 	{
 		if (guid == Engine.GetPlayerGUID())
 			continue;
 
 		let playerID = g_PlayerAssignments[guid].player;
 
 		// Don't provide option for PM from observer to player
 		if (g_IsObserver && !isPlayerObserver(playerID))
 			continue;
 
 		let colorBox = isPlayerObserver(playerID) ? "" : colorizePlayernameHelper("■", playerID) + " ";
 
 		addressees.push({
 			"cmd": "/msg " + g_PlayerAssignments[guid].name,
 			"label": colorBox + g_PlayerAssignments[guid].name
 		});
 	}
 
 	let chatAddressee = Engine.GetGUIObjectByName("chatAddressee");
 	chatAddressee.list = addressees.map(adressee => adressee.label);
 	chatAddressee.list_data = addressees.map(adressee => adressee.cmd);
 	chatAddressee.selected = 0;
 }
 
 /**
  * Send text as chat. Don't look for commands.
  *
  * @param {string} text
  */
 function submitChatDirectly(text)
 {
 	if (!text.length)
 		return;
 
 	if (g_IsNetworked)
 		Engine.SendNetworkChat(text);
 	else
 		addChatMessage({ "type": "message", "guid": "local", "text": text });
 }
 
 /**
  * Loads the text from the GUI window, checks if it is a local command
  * or cheat and executes it. Otherwise sends it as chat.
  */
 function submitChatInput()
 {
 	let input = Engine.GetGUIObjectByName("chatInput");
 	let text = input.caption;
 
 	input.blur(); // Remove focus
 	input.caption = ""; // Clear chat input
 	toggleChatWindow();
 
 	if (!text.length)
 		return;
 
 	if (executeNetworkCommand(text))
 		return;
 
 	if (executeCheat(text))
 		return;
 
 	let chatAddressee = Engine.GetGUIObjectByName("chatAddressee");
 	if (chatAddressee.selected > 0 && (text.indexOf("/") != 0 || text.indexOf("/me ") == 0))
 		text = chatAddressee.list_data[chatAddressee.selected] + " " + text;
 
 	submitChatDirectly(text);
 }
 
 /**
  * Displays the prepared chatmessage.
  *
  * @param msg {Object}
  */
 function addChatMessage(msg)
 {
 	if (!g_FormatChatMessage[msg.type])
 		return;
 
 	let formatted = g_FormatChatMessage[msg.type](msg);
 	if (!formatted)
 		return;
 
 	g_ChatMessages.push(formatted);
 	g_ChatTimers.push(setTimeout(removeOldChatMessage, g_ChatTimeout * 1000));
 
 	if (g_ChatMessages.length > g_ChatLines)
 		removeOldChatMessage();
 	else
 		Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 }
 
 /**
  * Called when the timer has run out for the oldest chatmessage or when the message limit is reached.
  */
 function removeOldChatMessage()
 {
 	clearTimeout(g_ChatTimers[0]);
 	g_ChatTimers.shift();
 	g_ChatMessages.shift();
 	Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 }
 
 /**
  * This function is used for AIs, whose names don't exist in g_PlayerAssignments.
  */
 function colorizePlayernameByID(playerID)
 {
 	let username = g_Players[playerID] && escapeText(g_Players[playerID].name);
 	return colorizePlayernameHelper(username, playerID);
 }
 
 function colorizePlayernameByGUID(guid)
 {
 	let username = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].name : "";
 	let playerID = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].player : -1;
 	return colorizePlayernameHelper(username, playerID);
 }
 
 function colorizePlayernameHelper(username, playerID)
 {
 	let playerColor = playerID > -1 ? rgbToGuiColor(g_Players[playerID].color) : "white";
 	return '[color="' + playerColor + '"]' + (username || translate("Unknown Player")) + "[/color]";
 }
 
 function formatDefeatMessage(msg)
 {
 	return sprintf(
 		msg.resign ?
 			translate("%(player)s has resigned.") :
 			translate("%(player)s has been defeated."),
 		{ "player": colorizePlayernameByID(msg.player) }
 	);
 }
 
 function formatDiplomacyMessage(msg)
 {
 	let messageType;
 
 	if (g_IsObserver)
 		messageType = "observer";
 	else if (Engine.GetPlayerID() == msg.sourcePlayer)
 		messageType = "active";
 	else if (Engine.GetPlayerID() == msg.targetPlayer)
 		messageType = "passive";
 	else
 		return "";
 
 	return sprintf(g_DiplomacyMessages[messageType][msg.status], {
 		"player": colorizePlayernameByID(messageType == "active" ? msg.targetPlayer : msg.sourcePlayer),
 		"player2": colorizePlayernameByID(messageType == "active" ? msg.sourcePlayer : msg.targetPlayer)
 	});
 }
 
 function formatTributeMessage(msg)
 {
 	// Check observer first, since we also want to see if the selected player in the developer-overlay has sent tributes
 	let message = "";
 	if (g_IsObserver)
 		message = translate("%(player)s has sent %(player2)s %(amounts)s.");
 	else if (msg.targetPlayer == Engine.GetPlayerID())
 		message = translate("%(player)s has sent you %(amounts)s.");
 
 	return sprintf(message, {
 		"player": colorizePlayernameByID(msg.sourcePlayer),
 		"player2": colorizePlayernameByID(msg.targetPlayer),
 		"amounts": getLocalizedResourceAmounts(msg.amounts)
 	});
 }
 
 function formatAttackMessage(msg)
 {
 	if (msg.player != g_ViewedPlayer)
 		return "";
 
 	let message = msg.targetIsDomesticAnimal ?
 			translate("Your livestock has been attacked by %(attacker)s!") :
 			translate("You have been attacked by %(attacker)s!");
 
 	return sprintf(message, {
 		"attacker": colorizePlayernameByID(msg.attacker)
 	});
 }
 
 function formatChatCommand(msg)
 {
 	if (!msg.text)
 		return "";
 
 	let isMe = msg.text.indexOf("/me ") == 0;
 	if (!isMe && !parseChatAddressee(msg))
 		return "";
 
 	isMe = msg.text.indexOf("/me ") == 0;
 	if (isMe)
 		msg.text = msg.text.substr("/me ".length);
 
 	// Translate or escape text
 	if (!msg.text)
 		return "";
 	if (msg.translate)
 	{
 		msg.text = translate(msg.text);
 		if (msg.translateParameters)
 		{
 			let parameters = msg.parameters || {};
 			translateObjectKeys(parameters, msg.translateParameters);
 			msg.text = sprintf(msg.text, parameters);
 		}
 	}
 	else
 		msg.text = escapeText(msg.text);
 
 	// GUID for players, playerID for AIs
 	let coloredUsername = msg.guid != -1 ? colorizePlayernameByGUID(msg.guid) : colorizePlayernameByID(msg.player);
 
 	return sprintf(g_ChatCommands[isMe ? "me" : "regular"][msg.context ? "context" : "no-context"], {
 		"message": msg.text,
 		"context": msg.context || undefined,
 		"user": coloredUsername,
 		"userTag": sprintf(translate("<%(user)s>"), { "user": coloredUsername })
 	});
 }
 
 /**
  * Checks if the current user is an addressee of the chatmessage sent by another player.
  * Sets the context of that message.
  * Returns true if the message should be displayed.
  *
  * @param {Object} msg
  */
 function parseChatAddressee(msg)
 {
 	if (msg.text[0] != '/')
 		return true;
 
 	// Split addressee command and message-text
 	let cmd = msg.text.split(/\s/)[0];
 	msg.text = msg.text.substr(cmd.length + 1);
 
 	if (cmd == "/ally")
 		cmd = "/allies";
 
 	if (cmd == "/enemy")
 		cmd = "/enemies";
 
 	if (cmd == "/observer")
 		cmd = "/observers";
 
 	// GUID for players and observers, ID for bots
 	let senderID = (g_PlayerAssignments[msg.guid] || msg).player;
 	let isSender = msg.guid ? msg.guid == Engine.GetPlayerGUID() : senderID == Engine.GetPlayerID();
 
 	// Parse private message
 	let isPM = cmd == "/msg";
 	let addresseeGUID;
 	let addresseeIndex;
 	if (isPM)
 	{
 		addresseeGUID = matchUsername(msg.text);
 		let addressee = g_PlayerAssignments[addresseeGUID];
 		if (!addressee)
 		{
 			if (isSender)
 				warn("Couldn't match username: " + msg.text);
 			return false;
 		}
 
 		// Prohibit PM if addressee and sender are identical
 		if (isSender && addresseeGUID == Engine.GetPlayerGUID())
 			return false;
 
 		msg.text = msg.text.substr(addressee.name.length + 1);
 		addresseeIndex = addressee.player;
 	}
 
 	// Set context string
 	if (!g_ChatAddresseeContext[cmd])
 	{
 		if (isSender)
 			warn("Unknown chat command: " + cmd);
 		return false;
 	}
 	msg.context = g_ChatAddresseeContext[cmd];
 
 	// For observers only permit public- and observer-chat and PM to observers
 	if (isPlayerObserver(senderID) &&
 	    (isPM && !isPlayerObserver(addresseeIndex) || !isPM && cmd != "/observers"))
 		return false;
 
 	return isSender || g_IsChatAddressee[cmd](senderID, addresseeGUID);
 }
 
 /**
  * Returns the guid of the user with the longest name that is a prefix of the given string.
  */
 function matchUsername(text)
 {
 	if (!text)
 		return "";
 
 	let match = "";
 	let playerGUID = "";
 	for (let guid in g_PlayerAssignments)
 	{
 		let pName = g_PlayerAssignments[guid].name;
 		if (text.indexOf(pName + " ") == 0 && pName.length > match.length)
 		{
 			match = pName;
 			playerGUID = guid;
 		}
 	}
 	return playerGUID;
 }
 
 /**
  * Custom dialog response handling, usable by trigger maps.
  */
 function sendDialogAnswer(guiObject, dialogName)
 {
 	Engine.GetGUIObjectByName(dialogName+"-dialog").hidden = true;
 
 	Engine.PostNetworkCommand({
 		"type": "dialog-answer",
 		"dialog": dialogName,
 		"answer": guiObject.name.split("-").pop(),
 	});
 
 	resumeGame();
 }
 
 /**
  * Custom dialog opening, usable by trigger maps.
  */
 function openDialog(dialogName, data, player)
 {
 	let dialog = Engine.GetGUIObjectByName(dialogName + "-dialog");
 	if (!dialog)
 	{
 		warn("messages.js: Unknow dialog with name " + dialogName);
 		return;
 	}
 	dialog.hidden = false;
 
 	for (let objName in data)
 	{
 		let obj = Engine.GetGUIObjectByName(dialogName + "-dialog-" + objName);
 		if (!obj)
 		{
 			warn("messages.js: Key '" + objName + "' not found in '" + dialogName + "' dialog.");
 			continue;
 		}
 
 		for (let key in data[objName])
 		{
 			let n = data[objName][key];
 			if (typeof n == "object" && n.message)
 			{
 				let message = n.message;
 				if (n.translateMessage)
 					message = translate(message);
 				let parameters = n.parameters || {};
 				if (n.translateParameters)
 					translateObjectKeys(parameters, n.translateParameters);
 				obj[key] = sprintf(message, parameters);
 			}
 			else
 				obj[key] = n;
 		}
 	}
 
 	pauseGame();
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/session.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 18203)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.js	(revision 18204)
@@ -1,1253 +1,1263 @@
 const g_IsReplay = Engine.IsVisualReplay();
 const g_GameSpeeds = prepareForDropdown(g_Settings && g_Settings.GameSpeeds.filter(speed => !speed.ReplayOnly || g_IsReplay));
 
 /**
  * Colors to flash when pop limit reached.
  */
 const g_DefaultPopulationColor = "white";
 const g_PopulationAlertColor = "orange";
 
 /**
  * A random file will be played. TODO: more variety
  */
 const g_Ambient = [ "audio/ambient/dayscape/day_temperate_gen_03.ogg" ];
 
 /**
  * Is this user in control of game settings (i.e. is a network server, or offline player).
  */
 var g_IsController;
 
 /**
  * True if this is a multiplayer game.
  */
 var g_IsNetworked = false;
 
 /**
  * True if the connection to the server has been lost.
  */
 var g_Disconnected = false;
 
 /**
  * True if the current user has observer capabilities.
  */
 var g_IsObserver = false;
 
 /**
  * True if the current user has rejoined (or joined the game after it started).
  */
 var g_HasRejoined = false;
 
 /**
+ * True if the current player has paused the game explicitly.
+ */
+var g_Paused = false;
+
+/**
+ * The list of GUIDs of players who have currently paused the game, if the game is networked.
+ */
+var g_PausingClients = [];
+
+/**
  * The playerID selected in the change perspective tool.
  */
 var g_ViewedPlayer = Engine.GetPlayerID();
 
 /**
  * True if the camera should focus on attacks and player commands
  * and select the affected units.
  */
 var g_FollowPlayer = false;
 
 /**
  * Unique ID for lobby reports.
  */
 var g_MatchID;
 
 /**
  * Cache the basic player data (name, civ, color).
  */
 var g_Players = [];
 
 /**
  * Last time when onTick was called().
  * Used for animating the main menu.
  */
 var lastTickTime = new Date();
 
 /**
  * Not constant as we add "gaia".
  */
 var g_CivData = {};
 
 /**
  * For restoring selection, order and filters when returning to the replay menu
  */
 var g_ReplaySelectionData;
 
 var g_PlayerAssignments = {
 	"local": {
 		"name": singleplayerName(),
 		"player": 1
 	}
 };
 
 /**
  * Cache dev-mode settings that are frequently or widely used.
  */
 var g_DevSettings = {
 	"changePerspective": false,
 	"controlAll": false
 };
 
 /**
  * Whether status bars should be shown for all of the player's units.
  */
 var g_ShowAllStatusBars = false;
 
 /**
  * Blink the population counter if the player can't train more units.
  */
 var g_IsTrainingBlocked = false;
 
 /**
  * Cache simulation state (updated on every simulation update).
  */
 var g_SimState;
 var g_EntityStates = {};
 var g_TemplateData = {};
 var g_TemplateDataWithoutLocalization = {};
 var g_TechnologyData = {};
 
 /**
  * Cache concatenated list of player states ("active", "defeated" or "won").
  */
 var g_CachedLastStates = "";
 
 /**
  * Whether the current player has lost/won and reached the end of their game.
  * Used for reporting the gamestate and showing the game-end message only once.
  */
 var g_GameEnded = false;
 
 /**
  * Top coordinate of the research list.
  * Changes depending on the number of displayed counters.
  */
 var g_ResearchListTop = 4;
 
 /**
  * List of additional entities to highlight.
  */
 var g_ShowGuarding = false;
 var g_ShowGuarded = false;
 var g_AdditionalHighlight = [];
 
 /**
  * Blink the hero selection if that entity has lost health since the last turn.
  */
 var g_PreviousHeroHitPoints;
 
 /**
  * Unit classes to be checked for the idle-worker-hotkey.
  */
 var g_WorkerTypes = ["Female", "Trader", "FishingBoat", "CitizenSoldier", "Healer"];
 
 /**
  * Cache the idle worker status.
  */
 var g_HasIdleWorker = false;
 
 function GetSimState()
 {
 	if (!g_SimState)
 		g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	return g_SimState;
 }
 
 function GetEntityState(entId)
 {
 	if (!g_EntityStates[entId])
 		g_EntityStates[entId] = Engine.GuiInterfaceCall("GetEntityState", entId);
 
 	return g_EntityStates[entId];
 }
 
 function GetExtendedEntityState(entId)
 {
 	let entState = GetEntityState(entId);
 	if (!entState || entState.extended)
 		return entState;
 
 	let extension = Engine.GuiInterfaceCall("GetExtendedEntityState", entId);
 	for (let prop in extension)
 		entState[prop] = extension[prop];
 	entState.extended = true;
 	g_EntityStates[entId] = entState;
 	return entState;
 }
 
 function GetTemplateData(templateName)
 {
 	if (!(templateName in g_TemplateData))
 	{
 		let template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		translateObjectKeys(template, ["specific", "generic", "tooltip"]);
 		g_TemplateData[templateName] = template;
 	}
 
 	return g_TemplateData[templateName];
 }
 
 function GetTemplateDataWithoutLocalization(templateName)
 {
 	if (!(templateName in g_TemplateDataWithoutLocalization))
 	{
 		let template = Engine.GuiInterfaceCall("GetTemplateData", templateName);
 		g_TemplateDataWithoutLocalization[templateName] = template;
 	}
 
 	return g_TemplateDataWithoutLocalization[templateName];
 }
 
 function GetTechnologyData(technologyName)
 {
 	if (!(technologyName in g_TechnologyData))
 	{
 		let template = Engine.GuiInterfaceCall("GetTechnologyData", technologyName);
 		translateObjectKeys(template, ["specific", "generic", "description", "tooltip", "requirementsTooltip"]);
 		g_TechnologyData[technologyName] = template;
 	}
 
 	return g_TechnologyData[technologyName];
 }
 
 function init(initData, hotloadData)
 {
 	if (!g_Settings)
 	{
 		Engine.EndGame();
 		Engine.SwitchGuiPage("page_pregame.xml");
 		return;
 	}
 
 	if (initData)
 	{
 		g_IsNetworked = initData.isNetworked;
 		g_IsController = initData.isController;
 		g_PlayerAssignments = initData.playerAssignments;
 		g_MatchID = initData.attribs.matchID;
 		g_ReplaySelectionData = initData.replaySelectionData;
 		g_HasRejoined = initData.isRejoining;
 
 		// Cache the player data
 		// (This may be updated at runtime by handleNetMessage)
 		g_Players = getPlayerData(g_PlayerAssignments);
 
 		if (initData.savedGUIData)
 			restoreSavedGameData(initData.savedGUIData);
 
 		Engine.GetGUIObjectByName("gameSpeedButton").hidden = g_IsNetworked;
 	}
 	else // Needed for autostart loading option
 	{
 		if (g_IsReplay)
 			g_PlayerAssignments.local.player = -1;
 
 		g_Players = getPlayerData(null);
 	}
 
 	g_CivData = loadCivData();
 	g_CivData.gaia = { "Code": "gaia", "Name": translate("Gaia") };
 
 	initializeMusic(); // before changing the perspective
 	selectViewPlayer(g_ViewedPlayer);
 
 	let gameSpeed = Engine.GetGUIObjectByName("gameSpeed");
 	gameSpeed.list = g_GameSpeeds.Title;
 	gameSpeed.list_data = g_GameSpeeds.Speed;
 	let gameSpeedIdx = g_GameSpeeds.Speed.indexOf(Engine.GetSimRate());
 	gameSpeed.selected = gameSpeedIdx != -1 ? gameSpeedIdx : g_GameSpeeds.Default;
 	gameSpeed.onSelectionChange = function() { changeGameSpeed(+this.list_data[this.selected]); };
 	initMenuPosition();
 
 	// Populate player selection dropdown
 	let playerNames = [translate("Observer")];
 	let playerIDs = [-1];
 	for (let player in g_Players)
 	{
 		playerIDs.push(player);
 		playerNames.push(colorizePlayernameHelper("■", player) + " " + g_Players[player].name);
 	}
 
 	let viewPlayerDropdown = Engine.GetGUIObjectByName("viewPlayer");
 	viewPlayerDropdown.list = playerNames;
 	viewPlayerDropdown.list_data = playerIDs;
 	viewPlayerDropdown.selected = Engine.GetPlayerID() + 1;
 
 	// If in Atlas editor, disable the exit button
 	if (Engine.IsAtlasRunning())
 		Engine.GetGUIObjectByName("menuExitButton").enabled = false;
 
 	if (hotloadData)
 		g_Selection.selected = hotloadData.selection;
 
 	onSimulationUpdate();
 
 	setTimeout(displayGamestateNotifications, 1000);
 
 	// Report the performance after 5 seconds (when we're still near
 	// the initial camera view) and a minute (when the profiler will
 	// have settled down if framerates as very low), to give some
 	// extremely rough indications of performance
 	//
 	// DISABLED: this information isn't currently useful for anything much,
 	// and it generates a massive amount of data to transmit and store
 	//setTimeout(function() { reportPerformance(5); }, 5000);
 	//setTimeout(function() { reportPerformance(60); }, 60000);
 }
 
 function initializeMusic()
 {
 	initMusic();
 	if (g_ViewedPlayer != -1)
 		global.music.storeTracks(g_CivData[g_Players[g_ViewedPlayer].civ].Music);
 	global.music.setState(global.music.states.PEACE);
 	playAmbient();
 }
 
 function toggleChangePerspective(enabled)
 {
 	g_DevSettings.changePerspective = enabled;
 	selectViewPlayer(g_ViewedPlayer);
 }
 
 /**
  * Change perspective tool.
  * Shown to observers or when enabling the developers option.
  */
 function selectViewPlayer(playerID)
 {
 	if (playerID < -1 || playerID > g_Players.length - 1)
 		return;
 
 	g_IsObserver = isPlayerObserver(Engine.GetPlayerID());
 
 	let changeView = g_IsObserver || g_DevSettings.changePerspective;
 	if (changeView)
 	{
 		g_ViewedPlayer = playerID;
 
 		if (g_DevSettings.changePerspective)
 		{
 			Engine.SetPlayerID(g_ViewedPlayer);
 			g_IsObserver = isPlayerObserver(g_ViewedPlayer);
 		}
 	}
 
 	Engine.SetViewedPlayer(g_ViewedPlayer);
 
 	updateTopPanel();
 
 	updateChatAddressees();
 
 	// Update GUI and clear player-dependent cache
 	onSimulationUpdate();
 
 	let viewPlayer = Engine.GetGUIObjectByName("viewPlayer");
 	viewPlayer.hidden = !changeView;
 
 	let alphaLabel = Engine.GetGUIObjectByName("alphaLabel");
 	alphaLabel.hidden = g_ViewedPlayer > 0 && !viewPlayer.hidden;
 	alphaLabel.size = g_ViewedPlayer > 0 ? "50%+20 0 100%-226 100%" : "200 0 100%-475 100%";
 
 	Engine.GetGUIObjectByName("optionFollowPlayer").hidden = !g_IsObserver || g_ViewedPlayer < 1;
 
 	if (g_IsDiplomacyOpen)
 		openDiplomacy();
 
 	if (g_IsTradeOpen)
 		openTrade();
 }
 
 /**
  * Returns true if the player with that ID is in observermode.
  */
 function isPlayerObserver(playerID)
 {
 	let playerStates = GetSimState().players;
 	return !playerStates[playerID] || playerStates[playerID].state != "active";
 }
 
 /**
  * Returns true if the current user can issue commands for that player.
  */
 function controlsPlayer(playerID)
 {
 	return Engine.GetPlayerID() == playerID && !g_IsObserver || g_DevSettings.controlAll;
 }
 
 /**
  * Sets civ icon for the currently viewed player.
  * Hides most gui objects for observers.
  */
 function updateTopPanel()
 {
 	let isPlayer = g_ViewedPlayer > 0;
 	if (isPlayer)
 	{
 		let civName = g_CivData[g_Players[g_ViewedPlayer].civ].Name;
 		Engine.GetGUIObjectByName("civIcon").sprite = "stretched:" + g_CivData[g_Players[g_ViewedPlayer].civ].Emblem;
 		Engine.GetGUIObjectByName("civIconOverlay").tooltip = sprintf(translate("%(civ)s - Structure Tree"), { "civ": civName });
 	}
 
 	// Hide stuff gaia/observers don't use.
 	Engine.GetGUIObjectByName("food").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("wood").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("stone").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("metal").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("population").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("civIcon").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("diplomacyButton1").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("tradeButton1").hidden = !isPlayer;
 	Engine.GetGUIObjectByName("observerText").hidden = isPlayer;
 
 	// Disable stuff observers shouldn't use
 	Engine.GetGUIObjectByName("pauseButton").enabled = !g_IsObserver || !g_IsNetworked;
 	Engine.GetGUIObjectByName("menuResignButton").enabled = !g_IsObserver;
 	Engine.GetGUIObjectByName("summaryButton").enabled = g_IsObserver;
 }
 
 function reportPerformance(time)
 {
 	let settings = Engine.GetMapSettings();
 	Engine.SubmitUserReport("profile", 3, JSON.stringify({
 		"time": time,
 		"map": settings.Name,
 		"seed": settings.Seed, // only defined for random maps
 		"size": settings.Size, // only defined for random maps
 		"profiler": Engine.GetProfilerState()
 	}));
 }
 
 /**
  * Resign a player.
  * @param leaveGameAfterResign If player is quitting after resignation.
  */
 function resignGame(leaveGameAfterResign)
 {
 	if (g_IsObserver || g_Disconnected)
 		return;
 
 	Engine.PostNetworkCommand({
 		"type": "defeat-player",
 		"playerId": Engine.GetPlayerID(),
 		"resign": true
 	});
 
 	updateTopPanel();
 
 	global.music.setState(global.music.states.DEFEAT);
 
 	if (!leaveGameAfterResign)
-		resumeGame();
+		resumeGame(true);
 }
 
 /**
  * Leave the game
  * @param willRejoin If player is going to be rejoining a networked game.
  */
 function leaveGame(willRejoin)
 {
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 	let mapSettings = Engine.GetMapSettings();
 	let gameResult;
 
 	if (Engine.GetPlayerID() == -1)
 	{
 		gameResult = translate("You have left the game.");
 		global.music.setState(global.music.states.VICTORY);
 	}
 	else
 	{
 		let playerState = extendedSimState.players[Engine.GetPlayerID()];
 		if (g_Disconnected)
 			gameResult = translate("You have been disconnected.");
 		else if (playerState.state == "won")
 			gameResult = translate("You have won the battle!");
 		else if (playerState.state == "defeated")
 			gameResult = translate("You have been defeated...");
 		else // "active"
 		{
 			global.music.setState(global.music.states.DEFEAT);
 			if (willRejoin)
 				gameResult = translate("You have left the game.");
 			else
 			{
 				gameResult = translate("You have abandoned the game.");
 				resignGame(true);
 			}
 		}
 	}
 
 	let summary = {
 		"timeElapsed" : extendedSimState.timeElapsed,
 		"playerStates": extendedSimState.players,
 		"players": g_Players,
 		"mapSettings": Engine.GetMapSettings(),
 	};
 
 	if (!g_IsReplay)
 		Engine.SaveReplayMetadata(JSON.stringify(summary));
 
 	if (!g_HasRejoined)
 		summary.replayDirectory = Engine.GetCurrentReplayDirectory();
 	summary.replaySelectionData = g_ReplaySelectionData;
 
 	Engine.EndGame();
 
 	if (g_IsController && Engine.HasXmppClient())
 		Engine.SendUnregisterGame();
 
 	summary.gameResult = gameResult;
 	summary.isReplay = g_IsReplay;
 	Engine.SwitchGuiPage("page_summary.xml", summary);
 }
 
 // Return some data that we'll use when hotloading this file after changes
 function getHotloadData()
 {
 	return { "selection": g_Selection.selected };
 }
 
 // Return some data that will be stored in saved game files
 function getSavedGameData()
 {
 	// TODO: any other gui state?
 	return {
 		"playerAssignments": g_PlayerAssignments,
 		"groups": g_Groups.groups
 	};
 }
 
 function restoreSavedGameData(data)
 {
 	// Restore camera if any
 	if (data.camera)
 		Engine.SetCameraData(data.camera.PosX, data.camera.PosY, data.camera.PosZ,
 			data.camera.RotX, data.camera.RotY, data.camera.Zoom);
 
 	// Clear selection when loading a game
 	g_Selection.reset();
 
 	// Restore control groups
 	for (let groupNumber in data.groups)
 	{
 		g_Groups.groups[groupNumber].groups = data.groups[groupNumber].groups;
 		g_Groups.groups[groupNumber].ents = data.groups[groupNumber].ents;
 	}
 	updateGroups();
 }
 
 /**
  * Called every frame.
  */
 function onTick()
 {
 	if (!g_Settings)
 		return;
 
 	let now = new Date();
 	let tickLength = new Date() - lastTickTime;
 	lastTickTime = now;
 
 	checkPlayerState();
 	while (true)
 	{
 		let message = Engine.PollNetworkClient();
 		if (!message)
 			break;
 		handleNetMessage(message);
 	}
 
 	updateCursorAndTooltip();
 
 	if (g_Selection.dirty)
 	{
 		g_Selection.dirty = false;
 
 		updateGUIObjects();
 
 		// Display rally points for selected buildings
 		if (Engine.GetPlayerID() != -1)
 			Engine.GuiInterfaceCall("DisplayRallyPoint", { "entities": g_Selection.toList() });
 	}
 
 	updateTimers();
 
 	updateMenuPosition(tickLength);
 
 	// When training is blocked, flash population (alternates color every 500msec)
 	Engine.GetGUIObjectByName("resourcePop").textcolor = g_IsTrainingBlocked && Date.now() % 1000 < 500 ? g_PopulationAlertColor : g_DefaultPopulationColor;
 
 	Engine.GuiInterfaceCall("ClearRenamedEntities");
 }
 
 function checkPlayerState()
 {
 	if (g_GameEnded || Engine.GetPlayerID() < 1)
 		return;
 
 	// Send a game report for each player in this game.
 	let m_simState = GetSimState();
 	let playerState = m_simState.players[Engine.GetPlayerID()];
 	let tempStates = "";
 	for (let player of m_simState.players)
 		tempStates += player.state + ",";
 
 	if (g_CachedLastStates != tempStates)
 	{
 		g_CachedLastStates = tempStates;
 		reportGame();
 	}
 
 	if (playerState.state == "active")
 		return;
 
 	// Make sure nothing is open to avoid stacking.
 	closeOpenDialogs();
 
 	// Make sure this doesn't run again.
 	g_GameEnded = true;
 
 	// Select observermode
 	Engine.GetGUIObjectByName("viewPlayer").selected = playerState.state == "won" ? g_ViewedPlayer + 1 : 0;
 
 	let btCaptions;
 	let btCode;
 	let message;
 	let title;
 	if (Engine.IsAtlasRunning())
 	{
 		// If we're in Atlas, we can't leave the game
 		btCaptions = [translate("OK")];
 		btCode = [null];
 		message = translate("Press OK to continue");
 	}
 	else
 	{
 		btCaptions = [translate("No"), translate("Yes")];
 		btCode = [null, leaveGame];
 		message = translate("Do you want to quit?");
 	}
 
 	if (playerState.state == "defeated")
 	{
 		title = translate("DEFEATED!");
 		global.music.setState(global.music.states.DEFEAT);
 	}
 	else if (playerState.state == "won")
 	{
 		title = translate("VICTORIOUS!");
 		global.music.setState(global.music.states.VICTORY);
 		// TODO: Reveal map directly instead of this silly proxy.
 		if (!Engine.GetGUIObjectByName("devCommandsRevealMap").checked)
 			Engine.GetGUIObjectByName("devCommandsRevealMap").checked = true;
 	}
 
 	messageBox(400, 200, message, title, btCaptions, btCode);
 }
 
 function changeGameSpeed(speed)
 {
 	if (!g_IsNetworked)
 		Engine.SetSimRate(speed);
 }
 
 function hasIdleWorker()
 {
 	return Engine.GuiInterfaceCall("HasIdleUnits", {
 			"viewedPlayer": g_ViewedPlayer,
 			"idleClasses": g_WorkerTypes,
 			"excludeUnits": []
 	});
 }
 
 function updateIdleWorkerButton()
 {
 	g_HasIdleWorker = hasIdleWorker();
 
 	let idleWorkerButton = Engine.GetGUIObjectByName("idleOverlay");
 	let prefix = "stretched:session/";
 
 	if (!g_HasIdleWorker)
 		idleWorkerButton.sprite = prefix + "minimap-idle-disabled.png";
 	else if (idleWorkerButton.sprite != prefix + "minimap-idle-highlight.png")
 		idleWorkerButton.sprite = prefix + "minimap-idle.png";
 }
 
 function onSimulationUpdate()
 {
 	g_EntityStates = {};
 	g_TemplateData = {};
 	g_TechnologyData = {};
 
 	g_SimState = Engine.GuiInterfaceCall("GetSimulationState");
 
 	if (!g_SimState)
 		return;
 
 	handleNotifications();
 
 	updateGUIObjects();
 }
 
 function updateGUIObjects()
 {
 	g_Selection.update();
 
 	if (g_ShowAllStatusBars)
 		recalculateStatusBarDisplay();
 
 	if (g_ShowGuarding || g_ShowGuarded)
 		updateAdditionalHighlight();
 
 	updateHero();
 	updateGroups();
 	updateDebug();
 	updatePlayerDisplay();
 	updateResearchDisplay();
 	updateSelectionDetails();
 	updateBuildingPlacementPreview();
 	updateTimeNotifications();
 	updateIdleWorkerButton();
 
 	if (g_ViewedPlayer > 0)
 	{
 		let playerState = GetSimState().players[g_ViewedPlayer];
 		g_DevSettings.controlAll = playerState && playerState.controlsAll;
 		Engine.GetGUIObjectByName("devControlAll").checked = g_DevSettings.controlAll;
 	}
 
 	if (g_ViewedPlayer != -1 && !g_GameEnded)
 	{
 		// Update music state on basis of battle state.
 		let battleState = Engine.GuiInterfaceCall("GetBattleState", g_ViewedPlayer);
 		if (battleState)
 			global.music.setState(global.music.states[battleState]);
 	}
 }
 
 function onReplayFinished()
 {
 	closeOpenDialogs();
 	pauseGame();
 
 	messageBox(400, 200,
 		translateWithContext("replayFinished", "The replay has finished. Do you want to quit?"),
 		translateWithContext("replayFinished", "Confirmation"),
 		[translateWithContext("replayFinished", "No"), translateWithContext("replayFinished", "Yes")],
 		[resumeGame, leaveGame]);
 }
 
 /**
 * updates a status bar on the GUI
 * nameOfBar: name of the bar
 * points: points to show
 * maxPoints: max points
 * direction: gets less from (right to left) 0; (top to bottom) 1; (left to right) 2; (bottom to top) 3;
 */
 function updateGUIStatusBar(nameOfBar, points, maxPoints, direction)
 {
 	// check, if optional direction parameter is valid.
 	if (!direction || !(direction >= 0 && direction < 4))
 		direction = 0;
 
 	// get the bar and update it
 	let statusBar = Engine.GetGUIObjectByName(nameOfBar);
 	if (!statusBar)
 		return;
 
 	let healthSize = statusBar.size;
 	let value = 100*Math.max(0, Math.min(1, points / maxPoints));
 
 	// inverse bar
 	if (direction == 2 || direction == 3)
 		value = 100 - value;
 
 	if (direction == 0)
 		healthSize.rright = value;
 	else if (direction == 1)
 		healthSize.rbottom = value;
 	else if (direction == 2)
 		healthSize.rleft = value;
 	else if (direction == 3)
 		healthSize.rtop = value;
 
 	statusBar.size = healthSize;
 }
 
 
 function updateHero()
 {
 	let unitHeroPanel = Engine.GetGUIObjectByName("unitHeroPanel");
 	let heroButton = Engine.GetGUIObjectByName("unitHeroButton");
 
 	let playerState = GetSimState().players[g_ViewedPlayer];
 	if (!playerState || playerState.heroes.length <= 0)
 	{
 		g_PreviousHeroHitPoints = undefined;
 		unitHeroPanel.hidden = true;
 		return;
 	}
 
 	let heroImage = Engine.GetGUIObjectByName("unitHeroImage");
 	let heroState = GetExtendedEntityState(playerState.heroes[0]);
 	let template = GetTemplateData(heroState.template);
 	heroImage.sprite = "stretched:session/portraits/" + template.icon;
 	let hero = playerState.heroes[0];
 
 	heroButton.onpress = function()
 	{
 		if (!Engine.HotkeyIsPressed("selection.add"))
 			g_Selection.reset();
 		g_Selection.addList([hero]);
 	};
 	heroButton.ondoublepress = function() { selectAndMoveTo(getEntityOrHolder(hero)); };
 	unitHeroPanel.hidden = false;
 
 	// Setup tooltip
 	let tooltip = "[font=\"sans-bold-16\"]" + template.name.specific + "[/font]";
 	let healthLabel = "[font=\"sans-bold-13\"]" + translate("Health:") + "[/font]";
 	tooltip += "\n" + sprintf(translate("%(label)s %(current)s / %(max)s"), { 
 		"label": healthLabel,
 		"current": Math.ceil(heroState.hitpoints),
 		"max": Math.ceil(heroState.maxHitpoints)
 	});
 	if (heroState.attack)
 		tooltip += "\n" + getAttackTooltip(heroState);
 
 	tooltip += "\n" + getArmorTooltip(heroState.armour);
 	if (template.tooltip)
 		tooltip += "\n" + template.tooltip;
 
 	heroButton.tooltip = tooltip;
 
 	// update heros health bar
 	updateGUIStatusBar("heroHealthBar", heroState.hitpoints, heroState.maxHitpoints);
 
 	let heroHP = {
 		"hitpoints": heroState.hitpoints,
 		"player": g_ViewedPlayer
 	};
 
 	if (!g_PreviousHeroHitPoints)
 		g_PreviousHeroHitPoints = heroHP;
 
 	// if the health of the hero changed since the last update, trigger the animation
 	if (g_PreviousHeroHitPoints.player == heroHP.player && g_PreviousHeroHitPoints.hitpoints > heroHP.hitpoints)
 		startColorFade("heroHitOverlay", 100, 0, colorFade_attackUnit, true, smoothColorFadeRestart_attackUnit);
 
 	g_PreviousHeroHitPoints = heroHP;
 }
 
 function updateGroups()
 {
 	let guiName = "Group";
 	g_Groups.update();
 	for (let i = 0; i < 10; ++i)
 	{
 		let button = Engine.GetGUIObjectByName("unit"+guiName+"Button["+i+"]");
 		let label = Engine.GetGUIObjectByName("unit"+guiName+"Label["+i+"]").caption = i;
 		button.hidden = g_Groups.groups[i].getTotalCount() == 0;
 		button.onpress = (function(i) { return function() { performGroup((Engine.HotkeyIsPressed("selection.add") ? "add" : "select"), i); }; })(i);
 		button.ondoublepress = (function(i) { return function() { performGroup("snap", i); }; })(i);
 		button.onpressright = (function(i) { return function() { performGroup("breakUp", i); }; })(i);
 		setPanelObjectPosition(button, i, 1);
 	}
 }
 
 function updateDebug()
 {
 	let debug = Engine.GetGUIObjectByName("debug");
 
 	if (!Engine.GetGUIObjectByName("devDisplayState").checked)
 	{
 		debug.hidden = true;
 		return;
 	}
 
 	debug.hidden = false;
 
 	let conciseSimState = deepcopy(GetSimState());
 	conciseSimState.players = "<<<omitted>>>";
 	let text = "simulation: " + uneval(conciseSimState);
 
 	let selection = g_Selection.toList();
 	if (selection.length)
 	{
 		let entState = GetExtendedEntityState(selection[0]);
 		if (entState)
 		{
 			let template = GetTemplateData(entState.template);
 			text += "\n\nentity: {\n";
 			for (let k in entState)
 				text += "  "+k+":"+uneval(entState[k])+"\n";
 			text += "}\n\ntemplate: " + uneval(template);
 		}
 	}
 
 	debug.caption = text.replace(/\[/g, "\\[");
 }
 
 function updatePlayerDisplay()
 {
 	let playerState = GetSimState().players[g_ViewedPlayer];
 	if (!playerState)
 		return;
 
 	Engine.GetGUIObjectByName("resourceFood").caption = Math.floor(playerState.resourceCounts.food);
 	Engine.GetGUIObjectByName("resourceWood").caption = Math.floor(playerState.resourceCounts.wood);
 	Engine.GetGUIObjectByName("resourceStone").caption = Math.floor(playerState.resourceCounts.stone);
 	Engine.GetGUIObjectByName("resourceMetal").caption = Math.floor(playerState.resourceCounts.metal);
 	Engine.GetGUIObjectByName("resourcePop").caption = playerState.popCount + "/" + playerState.popLimit;
 	Engine.GetGUIObjectByName("population").tooltip = translate("Population (current / limit)") + "\n" +
 					sprintf(translate("Maximum population: %(popCap)s"), { "popCap": playerState.popMax });
 
 	g_IsTrainingBlocked = playerState.trainingBlocked;
 }
 
 function selectAndMoveTo(ent)
 {
 	let entState = GetEntityState(ent);
 	if (!entState || !entState.position)
 		return;
 
 	g_Selection.reset();
 	g_Selection.addList([ent]);
 
 	let position = entState.position;
 	Engine.CameraMoveTo(position.x, position.z);
 }
 
 function updateResearchDisplay()
 {
 	let researchStarted = Engine.GuiInterfaceCall("GetStartedResearch", g_ViewedPlayer);
 
 	// Set up initial positioning.
 	let buttonSideLength = Engine.GetGUIObjectByName("researchStartedButton[0]").size.right;
 	for (let i = 0; i < 10; ++i)
 	{
 		let button = Engine.GetGUIObjectByName("researchStartedButton[" + i + "]");
 		let size = button.size;
 		size.top = g_ResearchListTop + (4 + buttonSideLength) * i;
 		size.bottom = size.top + buttonSideLength;
 		button.size = size;
 	}
 
 	let numButtons = 0;
 	for (let tech in researchStarted)
 	{
 		// Show at most 10 in-progress techs.
 		if (numButtons >= 10)
 			break;
 
 		let template = GetTechnologyData(tech);
 		let button = Engine.GetGUIObjectByName("researchStartedButton[" + numButtons + "]");
 		button.hidden = false;
 		button.tooltip = getEntityNames(template);
 		button.onpress = (function(e) { return function() { selectAndMoveTo(e); }; })(researchStarted[tech].researcher);
 
 		let icon = "stretched:session/portraits/" + template.icon;
 		Engine.GetGUIObjectByName("researchStartedIcon[" + numButtons + "]").sprite = icon;
 
 		// Scale the progress indicator.
 		let size = Engine.GetGUIObjectByName("researchStartedProgressSlider[" + numButtons + "]").size;
 
 		// Buttons are assumed to be square, so left/right offsets can be used for top/bottom.
 		size.top = size.left + Math.round(researchStarted[tech].progress * (size.right - size.left));
 		Engine.GetGUIObjectByName("researchStartedProgressSlider[" + numButtons + "]").size = size;
 
 		++numButtons;
 	}
 
 	// Hide unused buttons.
 	for (let i = numButtons; i < 10; ++i)
 		Engine.GetGUIObjectByName("researchStartedButton[" + i + "]").hidden = true;
 }
 
 /**
  * Toggles the display of status bars for all of the player's entities.
  */
 function recalculateStatusBarDisplay()
 {
 	let entities;
 	if (g_ShowAllStatusBars)
 		entities = g_IsObserver ? Engine.PickNonGaiaEntitiesOnScreen() : Engine.PickPlayerEntitiesOnScreen(Engine.GetPlayerID());
 	else
 	{
 		let selected = g_Selection.toList();
 		for (let ent in g_Selection.highlighted)
 			selected.push(g_Selection.highlighted[ent]);
 
 		// Remove selected entities from the 'all entities' array, to avoid disabling their status bars.
 		entities = Engine.GuiInterfaceCall(g_IsObserver ? "GetNonGaiaEntities" : "GetPlayerEntities").filter(idx => selected.indexOf(idx) == -1);
 	}
 
 	Engine.GuiInterfaceCall("SetStatusBars", { "entities": entities, "enabled": g_ShowAllStatusBars });
 }
 
 // Update the additional list of entities to be highlighted.
 function updateAdditionalHighlight()
 {
 	let entsAdd = []; // list of entities units to be highlighted
 	let entsRemove = [];
 	let highlighted = g_Selection.toList();
 	for (let ent in g_Selection.highlighted)
 		highlighted.push(g_Selection.highlighted[ent]);
 
 	if (g_ShowGuarding)
 	{
 		// flag the guarding entities to add in this additional highlight
 		for (let sel in g_Selection.selected)
 		{
 			let state = GetEntityState(g_Selection.selected[sel]);
 			if (!state.guard || !state.guard.entities.length)
 				continue;
 
 			for (let ent of state.guard.entities)
 				if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
 					entsAdd.push(ent);
 		}
 	}
 
 	if (g_ShowGuarded)
 	{
 		// flag the guarded entities to add in this additional highlight
 		for (let sel in g_Selection.selected)
 		{
 			let state = GetEntityState(g_Selection.selected[sel]);
 			if (!state.unitAI || !state.unitAI.isGuarding)
 				continue;
 			let ent = state.unitAI.isGuarding;
 			if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
 				entsAdd.push(ent);
 		}
 	}
 
 	// flag the entities to remove (from the previously added) from this additional highlight
 	for (let ent of g_AdditionalHighlight)
 		if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1 && entsRemove.indexOf(ent) == -1)
 			entsRemove.push(ent);
 
 	_setHighlight(entsAdd, g_HighlightedAlpha, true);
 	_setHighlight(entsRemove, 0, false);
 	g_AdditionalHighlight = entsAdd;
 }
 
 function playAmbient()
 {
 	Engine.PlayAmbientSound(g_Ambient[Math.floor(Math.random() * g_Ambient.length)], true);
 }
 
 function getBuildString()
 {
 	return sprintf(translate("Build: %(buildDate)s (%(revision)s)"), { "buildDate": Engine.GetBuildTimestamp(0), revision: Engine.GetBuildTimestamp(2) });
 }
 
 function showTimeWarpMessageBox()
 {
 	messageBox(
 		500, 250,
 		translate("Note: time warp mode is a developer option, and not intended for use over long periods of time. Using it incorrectly may cause the game to run out of memory or crash."),
 		translate("Time warp mode")
 	);
 }
 
 /**
  * Send a report on the gamestatus to the lobby.
  */
 function reportGame()
 {
 	// Only 1v1 games are rated (and Gaia is part of g_Players)
 	if (!Engine.HasXmppClient() || !Engine.IsRankedGame() || g_Players.length != 3)
 		return;
 
 	let extendedSimState = Engine.GuiInterfaceCall("GetExtendedSimulationState");
 
 	let unitsClasses = [
 		"total",
 		"Infantry",
 		"Worker",
 		"Female",
 		"Cavalry",
 		"Champion",
 		"Hero",
 		"Ship",
 		"Trader"
 	];
 
 	let unitsCountersTypes = [
 		"unitsTrained",
 		"unitsLost",
 		"enemyUnitsKilled"
 	];
 
 	let buildingsClasses = [
 		"total",
 		"CivCentre",
 		"House",
 		"Economic",
 		"Outpost",
 		"Military",
 		"Fortress",
 		"Wonder"
 	];
 
 	let buildingsCountersTypes = [
 		"buildingsConstructed",
 		"buildingsLost",
 		"enemyBuildingsDestroyed"
 	];
 
 	let resourcesTypes = [
 		"wood",
 		"food",
 		"stone",
 		"metal"
 	];
 
 	let resourcesCounterTypes = [
 		"resourcesGathered",
 		"resourcesUsed",
 		"resourcesSold",
 		"resourcesBought"
 	];
 
 	let playerStatistics = {};
 
 	// Unit Stats
 	for (let unitCounterType of unitsCountersTypes)
 	{
 		if (!playerStatistics[unitCounterType])
 			playerStatistics[unitCounterType] = { };
 		for (let unitsClass of unitsClasses)
 			playerStatistics[unitCounterType][unitsClass] = "";
 	}
 
 	playerStatistics.unitsLostValue = "";
 	playerStatistics.unitsKilledValue = "";
 	// Building stats
 	for (let buildingCounterType of buildingsCountersTypes)
 	{
 		if (!playerStatistics[buildingCounterType])
 			playerStatistics[buildingCounterType] = { };
 		for (let buildingsClass of buildingsClasses)
 			playerStatistics[buildingCounterType][buildingsClass] = "";
 	}
 
 	playerStatistics.buildingsLostValue = "";
 	playerStatistics.enemyBuildingsDestroyedValue = "";
 	// Resources
 	for (let resourcesCounterType of resourcesCounterTypes)
 	{
 		if (!playerStatistics[resourcesCounterType])
 			playerStatistics[resourcesCounterType] = { };
 		for (let resourcesType of resourcesTypes)
 			playerStatistics[resourcesCounterType][resourcesType] = "";
 	}
 	playerStatistics.resourcesGathered.vegetarianFood = "";
 
 	playerStatistics.tradeIncome = "";
 	// Tribute
 	playerStatistics.tributesSent = "";
 	playerStatistics.tributesReceived = "";
 	// Total
 	playerStatistics.economyScore = "";
 	playerStatistics.militaryScore = "";
 	playerStatistics.totalScore = "";
 	// Various
 	playerStatistics.treasuresCollected = "";
 	playerStatistics.lootCollected = "";
 	playerStatistics.feminisation = "";
 	playerStatistics.percentMapExplored = "";
 
 	let mapName = Engine.GetMapSettings().Name;
 	let playerStates = "";
 	let playerCivs = "";
 	let teams = "";
 	let teamsLocked = true;
 
 	// Serialize the statistics for each player into a comma-separated list.
 	// Ignore gaia
 	for (let i = 1; i < extendedSimState.players.length; ++i)
 	{
 		let player = extendedSimState.players[i];
 
 		playerStates += player.state + ",";
 		playerCivs += player.civ + ",";
 		teams += player.team + ",";
 		teamsLocked = teamsLocked && player.teamsLocked;
 		for (let resourcesCounterType of resourcesCounterTypes)
 			for (let resourcesType of resourcesTypes)
 				playerStatistics[resourcesCounterType][resourcesType] += player.statistics[resourcesCounterType][resourcesType] + ",";
 		playerStatistics.resourcesGathered.vegetarianFood += player.statistics.resourcesGathered.vegetarianFood + ",";
 
 		for (let unitCounterType of unitsCountersTypes)
 			for (let unitsClass of unitsClasses)
 				playerStatistics[unitCounterType][unitsClass] += player.statistics[unitCounterType][unitsClass] + ",";
 
 		for (let buildingCounterType of buildingsCountersTypes)
 			for (let buildingsClass of buildingsClasses)
 				playerStatistics[buildingCounterType][buildingsClass] += player.statistics[buildingCounterType][buildingsClass] + ",";
 		let total = 0;
 		for (let type in player.statistics.resourcesGathered)
 			total += player.statistics.resourcesGathered[type];
 
 		playerStatistics.economyScore += total + ",";
 		playerStatistics.militaryScore += Math.round((player.statistics.enemyUnitsKilledValue +
 			player.statistics.enemyBuildingsDestroyedValue) / 10)  + ",";
 		playerStatistics.totalScore += (total + Math.round((player.statistics.enemyUnitsKilledValue +
 			player.statistics.enemyBuildingsDestroyedValue) / 10)) + ",";
 		playerStatistics.tradeIncome += player.statistics.tradeIncome + ",";
 		playerStatistics.tributesSent += player.statistics.tributesSent + ",";
 		playerStatistics.tributesReceived += player.statistics.tributesReceived + ",";
 		playerStatistics.percentMapExplored += player.statistics.percentMapExplored + ",";
 		playerStatistics.treasuresCollected += player.statistics.treasuresCollected + ",";
 		playerStatistics.lootCollected += player.statistics.lootCollected + ",";
 	}
 
 	// Send the report with serialized data
 	let reportObject = {};
 	reportObject.timeElapsed = extendedSimState.timeElapsed;
 	reportObject.playerStates = playerStates;
 	reportObject.playerID = Engine.GetPlayerID();
 	reportObject.matchID = g_MatchID;
 	reportObject.civs = playerCivs;
 	reportObject.teams = teams;
 	reportObject.teamsLocked = String(teamsLocked);
 	reportObject.ceasefireActive = String(extendedSimState.ceasefireActive);
 	reportObject.ceasefireTimeRemaining = String(extendedSimState.ceasefireTimeRemaining);
 	reportObject.mapName = mapName;
 	reportObject.economyScore = playerStatistics.economyScore;
 	reportObject.militaryScore = playerStatistics.militaryScore;
 	reportObject.totalScore = playerStatistics.totalScore;
 	for (let rct of resourcesCounterTypes)
 	{
 		for (let rt of resourcesTypes)
 			reportObject[rt+rct.substr(9)] = playerStatistics[rct][rt];
 			// eg. rt = food rct.substr = Gathered rct = resourcesGathered
 	}
 	reportObject.vegetarianFoodGathered = playerStatistics.resourcesGathered.vegetarianFood;
 	for (let type of unitsClasses)
 	{
 		// eg. type = Infantry (type.substr(0,1)).toLowerCase()+type.substr(1) = infantry
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"UnitsTrained"] = playerStatistics.unitsTrained[type];
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"UnitsLost"] = playerStatistics.unitsLost[type];
 		reportObject["enemy"+type+"UnitsKilled"] = playerStatistics.enemyUnitsKilled[type];
 	}
 	for (let type of buildingsClasses)
 	{
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"BuildingsConstructed"] = playerStatistics.buildingsConstructed[type];
 		reportObject[(type.substr(0,1)).toLowerCase()+type.substr(1)+"BuildingsLost"] = playerStatistics.buildingsLost[type];
 		reportObject["enemy"+type+"BuildingsDestroyed"] = playerStatistics.enemyBuildingsDestroyed[type];
 	}
 	reportObject.tributesSent = playerStatistics.tributesSent;
 	reportObject.tributesReceived = playerStatistics.tributesReceived;
 	reportObject.percentMapExplored = playerStatistics.percentMapExplored;
 	reportObject.treasuresCollected = playerStatistics.treasuresCollected;
 	reportObject.lootCollected = playerStatistics.lootCollected;
 	reportObject.tradeIncome = playerStatistics.tradeIncome;
 
 	Engine.SendGameReport(reportObject);
 }
Index: ps/trunk/binaries/data/mods/public/gui/session/session.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.xml	(revision 18203)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.xml	(revision 18204)
@@ -1,368 +1,363 @@
 <?xml version="1.0" encoding="utf-8"?>
 
 <objects>
 
 <script file="gui/common/color.js"/>
 <script file="gui/common/colorFades.js"/>
 <script file="gui/common/functions_civinfo.js"/>
 <script file="gui/common/functions_global_object.js"/>
 <script file="gui/common/functions_utility.js"/>
 <script file="gui/common/l10n.js"/>
 <script file="gui/common/music.js"/>
 <script file="gui/common/network.js"/>
 <script file="gui/common/settings.js"/>
 <script file="gui/common/timer.js"/>
 <script file="gui/common/tooltips.js"/>
 <!-- load all scripts in this directory -->
 <script directory="gui/session/"/>
 
 <object name="sn" hotkey="session.gui.toggle">
 	<action on="Tick">
 		onTick();
 	</action>
 
 	<action on="SimulationUpdate">
 		onSimulationUpdate();
 	</action>
 
 	<action on="ReplayFinished">
 		onReplayFinished();
 	</action>
 
 	<action on="Press">
 		this.hidden = !this.hidden;
 	</action>
 
 	<!-- ================================  ================================ -->
 	<!-- HOTKEYS (For some reason, they won't work properly unless outside menu) -->
 	<!-- ================================  ================================ -->
 
 	<!-- hotkeys are in a separate directory -->
 	<include directory="gui/session/hotkeys/"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Developer / Debug items -->
 	<!-- ================================  ================================ -->
 
 	<!-- Debug text -->
 	<object name="debug"
 		type="text"
 		size="0 70 80% 100%"
 		ghost="true"
 		textcolor="yellow"
 		font="mono-stroke-10"
 	/>
 
 	<!-- Dev/cheat commands -->
 	<object name="devCommands" size="100%-225 50%-88 100%-8 50%+120" type="image" sprite="devCommandsBackground" z="40"
 		hidden="true" hotkey="session.devcommands.toggle">
 		<action on="Press">toggleDeveloperOverlay();</action>
 
 		<object size="0 0 100%-18 16" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Control all units</translatableAttribute>
 		</object>
 		<object size="100%-16 0 100% 16" type="checkbox" name="devControlAll" style="ModernTickBox">
 			<action on="Press">
 				Engine.PostNetworkCommand({ "type": "control-all", "flag": this.checked });
 			</action>
 		</object>
 
 		<object size="0 16 100%-18 32" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Change perspective</translatableAttribute>
 		</object>
 		<object size="100%-16 16 100% 32" type="checkbox" style="ModernTickBox">
 			<action on="Press">toggleChangePerspective(this.checked);</action>
 		</object>
 
 		<object size="0 32 100%-18 48" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Display selection state</translatableAttribute>
 		</object>
 		<object size="100%-16 32 100% 48" type="checkbox" name="devDisplayState" style="ModernTickBox"/>
 
 		<object size="0 48 100%-18 64" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Pathfinder overlay</translatableAttribute>
 		</object>
 		<object size="100%-16 48 100% 64" type="checkbox" style="ModernTickBox">
 			<action on="Press">Engine.GuiInterfaceCall("SetPathfinderDebugOverlay", this.checked);</action>
 		</object>
 
 		<object size="0 64 100%-18 80" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Obstruction overlay</translatableAttribute>
 		</object>
 		<object size="100%-16 64 100% 80" type="checkbox" style="ModernTickBox">
 			<action on="Press">Engine.GuiInterfaceCall("SetObstructionDebugOverlay", this.checked);</action>
 		</object>
 
 		<object size="0 80 100%-18 96" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Unit motion overlay</translatableAttribute>
 		</object>
 		<object size="100%-16 80 100% 96" type="checkbox" style="ModernTickBox">
 			<action on="Press">g_Selection.SetMotionDebugOverlay(this.checked);</action>
 		</object>
 
 		<object size="0 96 100%-18 112" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Range overlay</translatableAttribute>
 		</object>
 		<object size="100%-16 96 100% 112" type="checkbox" style="ModernTickBox">
 			<action on="Press">Engine.GuiInterfaceCall("SetRangeDebugOverlay", this.checked);</action>
 		</object>
 
 		<object size="0 112 100%-18 128" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Bounding box overlay</translatableAttribute>
 		</object>
 		<object size="100%-16 112 100% 128" type="checkbox" style="ModernTickBox">
 			<action on="Press">Engine.SetBoundingBoxDebugOverlay(this.checked);</action>
 		</object>
 
 		<object size="0 128 100%-18 144" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Restrict camera</translatableAttribute>
 		</object>
 		<object size="100%-16 128 100% 144" type="checkbox" style="ModernTickBox" checked="true">
 			<action on="Press">
 				Engine.GameView_SetConstrainCameraEnabled(this.checked);
 			</action>
 		</object>
 
 		<object size="0 144 100%-18 160" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Reveal map</translatableAttribute>
 		</object>
 		<object size="100%-16 144 100% 160" type="checkbox" name="devCommandsRevealMap" style="ModernTickBox">
 			<action on="Load">this.checked = Engine.GuiInterfaceCall("IsMapRevealed");</action>
 			<action on="Press">Engine.PostNetworkCommand({"type": "reveal-map", "enable": this.checked});</action>
 		</object>
 
 		<object size="0 160 100%-18 176" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Enable time warp</translatableAttribute>
 		</object>
 			<object size="100%-16 160 100% 176" type="checkbox" name="devTimeWarp" style="ModernTickBox">
 			<action on="Press">
 				if (this.checked)
 				showTimeWarpMessageBox();
 				Engine.EnableTimeWarpRecording(this.checked ? 10 : 0);</action>
 		</object>
 
 		<object size="0 176 100%-18 192" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Promote selected units</translatableAttribute>
 		</object>
 		<object size="100%-16 176 100% 192" type="button" style="ModernTickBox">
 			<action on="Press">Engine.PostNetworkCommand({"type": "promote", "entities": g_Selection.toList()});</action>
 		</object>
 
 	    <object size="0 192 100%-18 208" type="text" style="devCommandsText">
 			<translatableAttribute id="caption">Hierarchical pathfinder overlay</translatableAttribute>
 		</object>
 	    <object size="100%-16 192 100% 208" type="checkbox" style="ModernTickBox">
 			<action on="Press">Engine.GuiInterfaceCall("SetPathfinderHierDebugOverlay", this.checked);</action>
 	    </object>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Time elapsed counter -->
 	<!-- ================================  ================================ -->
 
 	<object size="100%-250 45 100%-140 65" type="text" name="timeElapsedCounter" style="SettingsText" hotkey="timeelapsedcounter.toggle" hidden="true">
 			<action on="Press">
 				Engine.ConfigDB_CreateValue("user", "gui.session.timeelapsedcounter", ""+(Engine.ConfigDB_GetValue("user", "gui.session.timeelapsedcounter") !== "true"));
 			</action>
 	</object>
 	<object size="100%-250 80 100%-140 100" type="text" name="ceasefireCounter" style="SettingsText" hotkey="ceasefirecounter.toggle" hidden="true">
 			<action on="Press">
 				Engine.ConfigDB_CreateValue("user", "gui.session.ceasefirecounter", ""+(Engine.ConfigDB_GetValue("user", "gui.session.ceasefirecounter") !== "true"));
 			</action>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Pause Overlay -->
 	<!-- ================================  ================================ -->
-	<object type="button"
-		name="pauseOverlay"
-		size="0 0 100% 100%"
-		tooltip_style="sessionToolTip"
-		hidden="true"
-		z="0"
-	>
+	<object type="button" name="pauseOverlay" size="0 0 100% 100%" tooltip_style="sessionToolTip" hidden="true" z="0">
 	    <object size="0 0 100% 100%" type="image" sprite="devCommandsBackground" ghost="true" z="0"/>
-	    <object size="50%-128 50%-20 50%+128 50%+20" type="text" style="PauseText" ghost="true" z="0">
+	    <object size="50%-128 40%-20 50%+128 40%+20" type="text" style="PauseText" ghost="true" z="0">
 			<translatableAttribute id="caption">Game Paused</translatableAttribute>
 		</object>
-		<object size="50%-128 50%+20 50%+128 50%+30" type="text" style="PauseMessageText" ghost="true" z="0">
+		<object name="resumeMessage" size="50%-128 40%+20 50%+128 40%+40" type="text" style="ResumeMessageText" ghost="true" z="0">
 			<translatableAttribute id="caption">Click to Resume Game</translatableAttribute>
 		</object>
+	    <object name="pausedByText" size="30% 40%+50 70% 100%" type="text" style="PausedByText" ghost="true" hidden="true" z="0"/>
 	    <action on="Press">togglePause();</action>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Notification Area -->
 	<!-- ================================  ================================ -->
 	<object name="notificationPanel" type="image" size="50%-300 60 50%+300 120" ghost="true">
 	    <object name="notificationText" size="0 0 100% 100%" type="text" style="notificationPanel" ghost="true"/>
 	</object>
 
 
 	<!-- ================================  ================================ -->
 	<!-- Chat -->
 	<!-- ================================  ================================ -->
 
 	<!-- Chat panel -->
 	<object name="chatPanel" size="0 130 100% 100%-240" type="image" ghost="true" z="0" absolute="true">
 	    <object name="chatText" size="3 1 100%-1 100%-1" type="text" style="chatPanel" ghost="true"/>
 	</object>
 
 	<!-- Chat window -->
 	<object name="chatDialogPanel" size="50%-180 50%-66 50%+180 50%+54" type="image" hidden="true" sprite="genericPanel">
 
 		<!-- Message addressee -->
 		<object size="16 14 50 38" type="text" style="chatPanel">
 			<translatableAttribute id="caption" context="chat input">To:</translatableAttribute>
 		</object>
 		<object size="75 12 100%-16 36" name="chatAddressee" type="dropdown" style="ModernDropDown" tooltip_style="sessionToolTipBold">
 			<translatableAttribute id="tooltip" context="chat input">Select chatmessage addressee</translatableAttribute>
 		</object>
 
 		<!-- Message text -->
 		<object size="16 46 50 70" type="text" style="chatPanel">
 			<translatableAttribute id="caption" context="chat input">Text:</translatableAttribute>
 		</object>
 		<object name="chatInput" size="75 44 100%-16 68" type="input" style="ModernInput" max_length="80">
 			<translatableAttribute id="tooltip" context="chat input">Type the message to send.</translatableAttribute>
 			<action on="Press">submitChatInput();</action>
 			<action on="Tab">
 				var players = [];
 				for (var player in g_PlayerAssignments)
 					players.push(g_PlayerAssignments[player]);
 				autoCompleteNick("chatInput", players);
 			</action>
 		</object>
 
 		<!-- Cancel -->
 		<object size="16 100%-40 30%+16 100%-12" type="button" style="StoneButton">
 			<translatableAttribute id="caption">Cancel</translatableAttribute>
 			<action on="Press">closeChat();</action>
 		</object>
 
 		<!-- Send -->
 		<object size="60%+16 100%-40 100%-16 100%-12" type="button" style="StoneButton">
 			<translatableAttribute id="caption">Send</translatableAttribute>
 			<action on="Press">submitChatInput();</action>
 		</object>
 	</object>
 
 	<!-- ================================  ================================ -->
 	<!-- Custom dialogs -->
 	<!-- ================================  ================================ -->
 	<include directory="gui/session/dialogs/"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Diplomacy Window -->
 	<!-- ================================  ================================ -->
 	<include file="gui/session/diplomacy_window.xml"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Trade Window -->
 	<!-- ================================  ================================ -->
 	<include file="gui/session/trade_window.xml"/>
-	
+
 	<!-- ================================  ================================ -->
 	<!-- Top Panel  -->
 	<!-- ================================  ================================ -->
 	<include file="gui/session/top_panel.xml"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Menu -->
 	<!-- ================================  ================================ -->
 	<include file="gui/session/menu.xml"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Session objects                                                    -->
 	<!-- Contains miscellanious objects s.a.: the technology research -->
 	<!-- progress, group selection icons, and the hero selection icon -->
 	<!-- ================================  ================================ -->
 	<include directory="gui/session/session_objects/"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Information tooltip -->
 	<!-- Follows the mouse around if 'independent' is set to 'true'. -->
 	<!-- ================================  ================================ -->
 	<object name="informationTooltip" type="tooltip" independent="true" style="informationTooltip"/>
 
 	<!-- ================================  ================================ -->
 	<!-- Building placement info tooltip -->
 	<!-- ================================  ================================ -->
 	<object name="placementTooltip" type="tooltip" independent="true" style="informationTooltip"/>
 
 	<!-- ================================  ================================ -->
 	<!-- START of BOTTOM PANEL -->
 	<!-- limit to the minimal supported width of 1024px -->
 	<!-- ================================  ================================ -->
 	<object size="50%-512 0 50%+512 100%">
 
 		<!-- ================================  ================================ -->
 		<!-- Minimap -->
 		<!-- ================================  ================================ -->
 		<include file="gui/session/minimap_panel.xml"/>
 
 
 		<!-- ================================  ================================ -->
 		<!-- Supplemental Details Panel (Left of Selection Details) -->
 		<!-- ================================  ================================ -->
-		<object 
+		<object
 			size="50%-304 100%-170 50%-110 100%"
 			name="supplementalSelectionDetails"
 			type="image"
 			sprite="supplementalDetailsPanel"
 			z="20"
 		>
 			<include directory="gui/session/selection_panels_left/"/>
 		</object>
 
 
 	    <!-- ================================  ================================ -->
 	    <!-- Selection Details Panel (Middle) -->
 	    <!-- ================================  ================================ -->
 	    <object name="selectionDetails"
 		    type="image"
 		    sprite="selectionDetailsPanel"
 		    size="50%-114 100%-205 50%+114 100%"
 		    hidden="false"
 	    >
 			<include directory="gui/session/selection_panels_middle/"/>
 	    </object>
 
 	    <!-- ================================  ================================ -->
 	    <!-- Commands Panel (Right of Selection Details) -->
 	    <!-- ================================  ================================ -->
 	    <object name="unitCommands"
 		    type="image"
 		    sprite="unitCommandsPanel"
 		    size="50%+110 100%-170 50%+512 100%"
 		    hidden="false"
 		    z="20"
 	    >
 			<include directory="gui/session/selection_panels_right/"/>
 		</object>
 	</object><!-- END OF BOTTOM PANEL -->
 </object> <!-- END OF SN OBJECT -->
 
 <!-- ================================  ================================ -->
 <!-- Selection bandbox -->
 <!-- ================================  ================================ -->
 <object name="bandbox" type="image" sprite="bandbox" ghost="true" hidden="true" z="200"/>
 
 <!-- ================================  ================================ -->
 <!-- Network status -->
 <!-- ================================  ================================ -->
 <object name="netStatus" type="text" style="netStatus" z="200" hidden="true">
 	<object type="button"
 		name="disconnectedExitButton"
 		style="StoneButton"
 		size="50%-84 50%+128 50%+84 50%+160"
 		tooltip_style="sessionToolTip"
 	>
 		<object size="0 0 100% 100%" type="text" style="CenteredButtonText" name="disconnectedExitButtonText" ghost="true">
 			<translatableAttribute id="caption">Exit</translatableAttribute>
 		</object>
 		<action on="Press">leaveGame()</action>
 	</object>
 </object>
 
 </objects>
Index: ps/trunk/binaries/data/mods/public/gui/session/styles.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/styles.xml	(revision 18203)
+++ ps/trunk/binaries/data/mods/public/gui/session/styles.xml	(revision 18204)
@@ -1,252 +1,259 @@
 <?xml version="1.0" encoding="utf-8"?>
 
 <styles>
 
     <!-- ================================  ================================ -->
     <!-- Text Styles -->
     <!-- ================================  ================================ -->
     <style name="PauseText"
 	   font="sans-bold-24"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
     />
 
-    <style name="PauseMessageText"
+    <style name="ResumeMessageText"
 	   font="sans-bold-12"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
     />
 
+    <style name="PausedByText"
+	   font="sans-bold-16"
+	   textcolor="white"
+	   text_align="center"
+	   text_valign="top"
+    />
+
     <style name="BuildNameText"
 	   font="sans-stroke-12"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="bottom"
 	   ghost="true"
     />
 
     <style name="leftAlignedText"
 	   textcolor="white"
 	   text_align="left"
 	   text_valign="center"
     />
 
     <style name="rightAlignedText"
 	   textcolor="white"
 	   text_align="right"
 	   text_valign="top"
     />
 
     <style name="centeredText"
 	   textcolor="black"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <style name="largeBoldCenteredText"
 	   font="sans-bold-18"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <style name="largeCenteredOutlinedText"
 	   font="sans-bold-stroke-14"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <style name="largeLeftOutlinedText"
 	   font="sans-bold-stroke-14"
 	   textcolor="white"
 	   text_align="left"
 	   text_valign="center"
     />
 
     <style name="iconButtonCount"
 	   textcolor="255 255 255"
 	   font="sans-9"
 	   text_align="right"
 	   text_valign="top"
 	   buffer_zone="4"
     />
 
     <style name="iconButtonProgress"
 	   textcolor="255 255 255"
 	   font="sans-stroke-14"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <style name="groupIconsText"
 	   font="sans-bold-stroke-14"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <style name="groupIconsCenteredText"
 	   font="mono-stroke-10"
 	   textcolor="255 255 255"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <style name="devCommandsText"
 	   font="sans-10"
 	   textcolor="255 255 255"
 	   text_align="right"
     />
 
     <style name="resourceText"
 	   textcolor="white"
 	   font="sans-bold-stroke-14"
 	   ghost="true"
 	   text_align="left"
 	   text_valign="center"
     />
 
     <style name="StatsTextLeft"
 	   font="sans-stroke-12"
 	   textcolor="white"
 	   text_align="left"
 	   text_valign="center"
 	   ghost="true"
     />
-    
+
     <style name="StatsTextCentered"
 	   font="sans-stroke-12"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
 	   ghost="true"
     />
-    
+
     <style name="StatsTextRight"
 	   font="sans-stroke-12"
 	   textcolor="white"
 	   text_align="right"
 	   text_valign="center"
 	   ghost="true"
     />
-    
+
     <style name="CarryingTextRight"
 	   font="sans-bold-stroke-13"
 	   textcolor="white"
 	   text_align="right"
 	   text_valign="center"
 	   ghost="true"
     />
-    
+
     <style name="SpecificNameCentered"
 	   font="sans-bold-stroke-13"
 	   textcolor="gold"
 	   text_align="center"
 	   text_valign="center"
 	   ghost="true"
     />
-    
+
     <style name="GenericNameCentered"
 	   font="sans-stroke-12"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
 	   ghost="true"
     />
-    
+
     <style name="SettingsText"
 	   font="sans-stroke-16"
 	   textcolor="white"
 	   text_align="right"
 	   text_valign="center"
     />
 
     <style name="dialogTitleText"
 	   font="sans-bold-18"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <style name="dialogText"
 	   font="sans-16"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="center"
     />
 
     <!-- ================================  ================================ -->
     <!-- Icon Styles -->
     <!-- ================================  ================================ -->
     <style name="commandIcon"
 	   sprite="command"
 	   ghost="true"
     />
 
     <style name="iconButton"
 	   sprite="snIconPortrait"
 	   sprite_over="snIconPortraitOver"
 	   sprite_disabled="snIconPortraitDisabled"
 	   tooltip_style="snToolTipBottom"
 	   sound_pressed="audio/interface/ui/ui_button_click.ogg"
     />
 
     <!-- ================================  ================================ -->
     <!-- Tooltip Styles -->
     <!-- ================================  ================================ -->
     <style name="resourceCounter"
 	   tooltip_style="snToolTip"
     />
 
     <style name="resourceCounter"
 	   tooltip_style="snToolTip"
     />
 
     <style name="informationTooltip"
 	   anchor="top"
 	   buffer_zone="6"
 	   font="sans-bold-14"
 	   maxwidth="300"
 	   offset="16 32"
 	   sprite="BackgroundInformationTooltip"
 	   textcolor="255 255 255"
     />
 
     <!-- ================================  ================================ -->
     <!-- Misc Styles -->
     <!-- ================================  ================================ -->
     <style name="chatPanel"
 	   buffer_zone="5"
 	   font="sans-bold-stroke-14"
 	   textcolor="white"
 	   textcolor_selected="white"
 	   text_align="left"
 	   text_valign="top"
     />
 
     <style  name="chatInput"
 	    sprite="chatInput"
 	    sprite_selectarea="chatInputHighlight"
 	    textcolor="white"
 	    textcolor_selected="darkgray"
     />
 
     <style name="notificationPanel"
 	   buffer_zone="5"
 	   font="sans-bold-stroke-14"
 	   textcolor="white"
 	   text_align="center"
 	   text_valign="bottom"
     />
 
     <style name="netStatus"
 	   font="sans-bold-18"
 	   textcolor="255 255 255"
 	   text_align="center"
 	   text_valign="center"
 	   sprite="netStatusBackground"
     />
 </styles>
Index: ps/trunk/source/gui/scripting/ScriptFunctions.cpp
===================================================================
--- ps/trunk/source/gui/scripting/ScriptFunctions.cpp	(revision 18203)
+++ ps/trunk/source/gui/scripting/ScriptFunctions.cpp	(revision 18204)
@@ -1,1117 +1,1120 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "scriptinterface/ScriptInterface.h"
 
 #include "graphics/Camera.h"
 #include "graphics/FontMetrics.h"
 #include "graphics/GameView.h"
 #include "graphics/MapReader.h"
 #include "graphics/scripting/JSInterface_GameView.h"
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
 #include "gui/IGUIObject.h"
 #include "gui/scripting/JSInterface_GUITypes.h"
 #include "i18n/L10n.h"
 #include "i18n/scripting/JSInterface_L10n.h"
 #include "lib/svn_revision.h"
 #include "lib/sysdep/sysdep.h"
 #include "lib/timer.h"
 #include "lib/utf8.h"
 #include "lobby/scripting/JSInterface_Lobby.h"
 #include "maths/FixedVector3D.h"
 #include "network/NetClient.h"
 #include "network/NetServer.h"
 #include "network/NetTurnManager.h"
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/Errors.h"
 #include "ps/GUID.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/Atlas.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Globals.h"	// g_frequencyFilter
 #include "ps/Hotkey.h"
 #include "ps/ProfileViewer.h"
 #include "ps/Pyrogenesis.h"
 #include "ps/Replay.h"
 #include "ps/SavedGame.h"
 #include "ps/UserReport.h"
 #include "ps/World.h"
 #include "ps/scripting/JSInterface_ConfigDB.h"
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/scripting/JSInterface_Mod.h"
 #include "ps/scripting/JSInterface_VFS.h"
 #include "ps/scripting/JSInterface_VisualReplay.h"
 #include "renderer/scripting/JSInterface_Renderer.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpAIManager.h"
 #include "simulation2/components/ICmpCommandQueue.h"
 #include "simulation2/components/ICmpGuiInterface.h"
 #include "simulation2/components/ICmpPlayerManager.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpSelectable.h"
 #include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/helpers/Selection.h"
 #include "soundmanager/SoundManager.h"
 #include "soundmanager/scripting/JSInterface_Sound.h"
 #include "tools/atlas/GameInterface/GameLoop.h"
 
 /*
  * This file defines a set of functions that are available to GUI scripts, to allow
  * interaction with the rest of the engine.
  * Functions are exposed to scripts within the global object 'Engine', so
  * scripts should call "Engine.FunctionName(...)" etc.
  */
 
 extern void restart_mainloop_in_atlas(); // from main.cpp
 extern void EndGame();
 extern void kill_mainloop();
 
 namespace {
 
 // Note that the initData argument may only contain clonable data.
 // Functions aren't supported for example!
 // TODO: Use LOGERROR to print a friendly error message when the requirements aren't met instead of failing with debug_warn when cloning.
 void PushGuiPage(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& name, JS::HandleValue initData)
 {
 	g_GUI->PushPage(name, pCxPrivate->pScriptInterface->WriteStructuredClone(initData));
 }
 
 void SwitchGuiPage(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& name, JS::HandleValue initData)
 {
 	g_GUI->SwitchPage(name, pCxPrivate->pScriptInterface, initData);
 }
 
 void PopGuiPage(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_GUI->PopPage();
 }
 
 // Note that the args argument may only contain clonable data.
 // Functions aren't supported for example!
 // TODO: Use LOGERROR to print a friendly error message when the requirements aren't met instead of failing with debug_warn when cloning.
 void PopGuiPageCB(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue args)
 {
 	g_GUI->PopPageCB(pCxPrivate->pScriptInterface->WriteStructuredClone(args));
 }
 
 JS::Value GuiInterfaceCall(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& name, JS::HandleValue data)
 {
 	if (!g_Game)
 		return JS::UndefinedValue();
 	CSimulation2* sim = g_Game->GetSimulation2();
 	ENSURE(sim);
 
 	CmpPtr<ICmpGuiInterface> cmpGuiInterface(*sim, SYSTEM_ENTITY);
 	if (!cmpGuiInterface)
 		return JS::UndefinedValue();
 
 	int player = g_Game->GetPlayerID();
 
 	JSContext* cxSim = sim->GetScriptInterface().GetContext();
 	JSAutoRequest rqSim(cxSim);
 	JS::RootedValue arg(cxSim, sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), data));
 	JS::RootedValue ret(cxSim);
 	cmpGuiInterface->ScriptCall(player, name, arg, &ret);
 
 	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(sim->GetScriptInterface(), ret);
 }
 
 void PostNetworkCommand(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue cmd)
 {
 	if (!g_Game)
 		return;
 	CSimulation2* sim = g_Game->GetSimulation2();
 	ENSURE(sim);
 
 	CmpPtr<ICmpCommandQueue> cmpCommandQueue(*sim, SYSTEM_ENTITY);
 	if (!cmpCommandQueue)
 		return;
 
 	JSContext* cxSim = sim->GetScriptInterface().GetContext();
 	JSAutoRequest rqSim(cxSim);
 	JS::RootedValue cmd2(cxSim, sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), cmd));
 
 	cmpCommandQueue->PostNetworkCommand(cmd2);
 }
 
 entity_id_t PickEntityAtPoint(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x, int y)
 {
 	return EntitySelection::PickEntityAtPoint(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x, y, g_Game->GetPlayerID(), false);
 }
 
 std::vector<entity_id_t> PickPlayerEntitiesInRect(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x0, int y0, int x1, int y1, int player)
 {
 	return EntitySelection::PickEntitiesInRect(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x0, y0, x1, y1, player, false);
 }
 
 std::vector<entity_id_t> PickPlayerEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate, int player)
 {
 	return PickPlayerEntitiesInRect(pCxPrivate, 0, 0, g_xres, g_yres, player);
 }
 
 std::vector<entity_id_t> PickNonGaiaEntitiesOnScreen(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	std::vector<entity_id_t> entities;
 
 	CmpPtr<ICmpPlayerManager> cmpPlayerManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
 	if (!cmpPlayerManager)
 		return entities;
 
 	i32 numPlayers = cmpPlayerManager->GetNumPlayers();
 	for (i32 player = 1; player < numPlayers; ++player)
 	{
 		std::vector<entity_id_t> ents = PickPlayerEntitiesOnScreen(pCxPrivate, player);
 		entities.insert(entities.end(), ents.begin(), ents.end());
 	}
 
 	return entities;
 }
 
 std::vector<entity_id_t> PickSimilarPlayerEntities(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& templateName, bool includeOffScreen, bool matchRank, bool allowFoundations)
 {
 	return EntitySelection::PickSimilarEntities(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), templateName, g_Game->GetPlayerID(), includeOffScreen, matchRank, false, allowFoundations);
 }
 
 CFixedVector3D GetTerrainAtScreenPoint(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int x, int y)
 {
 	CVector3D pos = g_Game->GetView()->GetCamera()->GetWorldCoordinates(x, y, true);
 	return CFixedVector3D(fixed::FromFloat(pos.X), fixed::FromFloat(pos.Y), fixed::FromFloat(pos.Z));
 }
 
 std::wstring SetCursor(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& name)
 {
 	std::wstring old = g_CursorName;
 	g_CursorName = name;
 	return old;
 }
 
 bool IsVisualReplay(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (!g_Game)
 		return false;
 
 	return g_Game->IsVisualReplay();
 }
 
 std::wstring GetCurrentReplayDirectory(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (!g_Game)
 		return std::wstring();
 
 	if (g_Game->IsVisualReplay())
 		return OsPath(g_Game->GetReplayPath()).Parent().Filename().string();
 
 	return g_Game->GetReplayLogger().GetDirectory().Filename().string();
 }
 
 int GetPlayerID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game)
 		return g_Game->GetPlayerID();
 	return -1;
 }
 
 void SetPlayerID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int id)
 {
 	if (g_Game)
 		g_Game->SetPlayerID(id);
 }
 
 void SetViewedPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int id)
 {
 	if (g_Game)
 		g_Game->SetViewedPlayerID(id);
 }
 
 JS::Value GetEngineInfo(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return SavedGames::GetEngineInfo(*(pCxPrivate->pScriptInterface));
 }
 
 void StartNetworkGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	ENSURE(g_NetServer);
 	g_NetServer->StartGame();
 }
 
 void StartGame(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue attribs, int playerID)
 {
 	ENSURE(!g_NetServer);
 	ENSURE(!g_NetClient);
 
 	ENSURE(!g_Game);
 	g_Game = new CGame();
 
 	// Convert from GUI script context to sim script context
 	CSimulation2* sim = g_Game->GetSimulation2();
 	JSContext* cxSim = sim->GetScriptInterface().GetContext();
 	JSAutoRequest rqSim(cxSim);
 
 	JS::RootedValue gameAttribs(cxSim,
 		sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), attribs));
 
 	g_Game->SetPlayerID(playerID);
 	g_Game->StartGame(&gameAttribs, "");
 }
 
 JS::Value StartSavedGame(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& name)
 {
 	// We need to be careful with different compartments and contexts.
 	// The GUI calls this function from the GUI context and expects the return value in the same context.
 	// The game we start from here creates another context and expects data in this context.
 
 	JSContext* cxGui = pCxPrivate->pScriptInterface->GetContext();
 	JSAutoRequest rq(cxGui);
 
 	ENSURE(!g_NetServer);
 	ENSURE(!g_NetClient);
 
 	ENSURE(!g_Game);
 
 	// Load the saved game data from disk
 	JS::RootedValue guiContextMetadata(cxGui);
 	std::string savedState;
 	Status err = SavedGames::Load(name, *(pCxPrivate->pScriptInterface), &guiContextMetadata, savedState);
 	if (err < 0)
 		return JS::UndefinedValue();
 
 	g_Game = new CGame();
 
 	{
 		CSimulation2* sim = g_Game->GetSimulation2();
 		JSContext* cxGame = sim->GetScriptInterface().GetContext();
 		JSAutoRequest rq(cxGame);
 
 		JS::RootedValue gameContextMetadata(cxGame,
 			sim->GetScriptInterface().CloneValueFromOtherContext(*(pCxPrivate->pScriptInterface), guiContextMetadata));
 		JS::RootedValue gameInitAttributes(cxGame);
 		sim->GetScriptInterface().GetProperty(gameContextMetadata, "initAttributes", &gameInitAttributes);
 
 		int playerID;
 		sim->GetScriptInterface().GetProperty(gameContextMetadata, "player", playerID);
 
 		// Start the game
 		g_Game->SetPlayerID(playerID);
 		g_Game->StartGame(&gameInitAttributes, savedState);
 	}
 
 	return guiContextMetadata;
 }
 
 void SaveGame(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& filename, const std::wstring& description, JS::HandleValue GUIMetadata)
 {
 	shared_ptr<ScriptInterface::StructuredClone> GUIMetadataClone = pCxPrivate->pScriptInterface->WriteStructuredClone(GUIMetadata);
 	if (SavedGames::Save(filename, description, *g_Game->GetSimulation2(), GUIMetadataClone, g_Game->GetPlayerID()) < 0)
 		LOGERROR("Failed to save game");
 }
 
 void SaveGamePrefix(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& prefix, const std::wstring& description, JS::HandleValue GUIMetadata)
 {
 	shared_ptr<ScriptInterface::StructuredClone> GUIMetadataClone = pCxPrivate->pScriptInterface->WriteStructuredClone(GUIMetadata);
 	if (SavedGames::SavePrefix(prefix, description, *g_Game->GetSimulation2(), GUIMetadataClone, g_Game->GetPlayerID()) < 0)
 		LOGERROR("Failed to save game");
 }
 
 void SetNetworkGameAttributes(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue attribs1)
 {
 	ENSURE(g_NetServer);
 	//TODO: This is a workaround because we need to pass a MutableHandle to a JSAPI functions somewhere
 	// (with no obvious reason).
 	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue attribs(cx, attribs1);
 
 	g_NetServer->UpdateGameAttributes(&attribs, *(pCxPrivate->pScriptInterface));
 }
 
 void StartNetworkHost(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& playerName)
 {
 	ENSURE(!g_NetClient);
 	ENSURE(!g_NetServer);
 	ENSURE(!g_Game);
 
 	g_NetServer = new CNetServer();
 	if (!g_NetServer->SetupConnection())
 	{
 		pCxPrivate->pScriptInterface->ReportError("Failed to start server");
 		SAFE_DELETE(g_NetServer);
 		return;
 	}
 
 	g_Game = new CGame();
 	g_NetClient = new CNetClient(g_Game, true);
 	g_NetClient->SetUserName(playerName);
 
 	if (!g_NetClient->SetupConnection("127.0.0.1"))
 	{
 		pCxPrivate->pScriptInterface->ReportError("Failed to connect to server");
 		SAFE_DELETE(g_NetClient);
 		SAFE_DELETE(g_Game);
 	}
 }
 
 void StartNetworkJoin(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& playerName, const std::string& serverAddress)
 {
 	ENSURE(!g_NetClient);
 	ENSURE(!g_NetServer);
 	ENSURE(!g_Game);
 
 	g_Game = new CGame();
 	g_NetClient = new CNetClient(g_Game, false);
 	g_NetClient->SetUserName(playerName);
 	if (!g_NetClient->SetupConnection(serverAddress))
 	{
 		pCxPrivate->pScriptInterface->ReportError("Failed to connect to server");
 		SAFE_DELETE(g_NetClient);
 		SAFE_DELETE(g_Game);
 	}
 }
 
 void DisconnectNetworkGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	// TODO: we ought to do async reliable disconnections
 
 	SAFE_DELETE(g_NetServer);
 	SAFE_DELETE(g_NetClient);
 	SAFE_DELETE(g_Game);
 }
 
 std::string GetPlayerGUID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (!g_NetClient)
 		return std::string();
 
 	return g_NetClient->GetGUID();
 }
 
 bool KickPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& playerName, bool ban)
 {
 	if (!g_NetServer)
 		return false;
 
 	return g_NetServer->KickPlayer(playerName, ban);
 }
 
 JS::Value PollNetworkClient(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	if (!g_NetClient)
 		return JS::UndefinedValue();
 
 	// Convert from net client context to GUI script context
 	JSContext* cxNet = g_NetClient->GetScriptInterface().GetContext();
 	JSAutoRequest rqNet(cxNet);
 	JS::RootedValue pollNet(cxNet);
 	g_NetClient->GuiPoll(&pollNet);
 	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(g_NetClient->GetScriptInterface(), pollNet);
 }
 
 void AssignNetworkPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int playerID, const std::string& guid)
 {
 	ENSURE(g_NetServer);
 
 	g_NetServer->AssignPlayer(playerID, guid);
 }
 
 void SetNetworkPlayerStatus(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& guid, int ready)
 {
 	ENSURE(g_NetServer);
 
 	g_NetServer->SetPlayerReady(guid, ready);
 }
 
 void ClearAllPlayerReady (ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	ENSURE(g_NetServer);
 
 	g_NetServer->ClearAllPlayerReady();
 }
 
 void SendNetworkChat(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& message)
 {
 	ENSURE(g_NetClient);
 
 	g_NetClient->SendChatMessage(message);
 }
 
 void SendNetworkReady(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int message)
 {
 	ENSURE(g_NetClient);
 
 	g_NetClient->SendReadyMessage(message);
 }
 
 JS::Value GetAIs(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return ICmpAIManager::GetAIs(*(pCxPrivate->pScriptInterface));
 }
 
 JS::Value GetSavedGames(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return SavedGames::GetSavedGames(*(pCxPrivate->pScriptInterface));
 }
 
 bool DeleteSavedGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& name)
 {
 	return SavedGames::DeleteSavedGame(name);
 }
 
 void OpenURL(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& url)
 {
 	sys_open_url(url);
 }
 
 std::wstring GetMatchID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return ps_generate_guid().FromUTF8();
 }
 
 void RestartInAtlas(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	restart_mainloop_in_atlas();
 }
 
 bool AtlasIsAvailable(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return ATLAS_IsAvailable();
 }
 
 bool IsAtlasRunning(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return (g_AtlasGameLoop && g_AtlasGameLoop->running);
 }
 
 JS::Value LoadMapSettings(ScriptInterface::CxPrivate* pCxPrivate, const VfsPath& pathname)
 {
 	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	CMapSummaryReader reader;
 
 	if (reader.LoadMap(pathname) != PSRETURN_OK)
 		return JS::UndefinedValue();
 
 	JS::RootedValue settings(cx);
 	reader.GetMapSettings(*(pCxPrivate->pScriptInterface), &settings);
 	return settings;
 }
 
 JS::Value GetMapSettings(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	if (!g_Game)
 		return JS::UndefinedValue();
 
 	JSContext* cx = g_Game->GetSimulation2()->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue mapSettings(cx);
 	g_Game->GetSimulation2()->GetMapSettings(&mapSettings);
 	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(
 		g_Game->GetSimulation2()->GetScriptInterface(),
 		mapSettings);
 }
 
 /**
  * Get the current X coordinate of the camera.
  */
 float CameraGetX(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game && g_Game->GetView())
 		return g_Game->GetView()->GetCameraX();
 	return -1;
 }
 
 /**
  * Get the current Z coordinate of the camera.
  */
 float CameraGetZ(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game && g_Game->GetView())
 		return g_Game->GetView()->GetCameraZ();
 	return -1;
 }
 
 /**
  * Start / stop camera following mode
  * @param entityid unit id to follow. If zero, stop following mode
  */
 void CameraFollow(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_id_t entityid)
 {
 	if (g_Game && g_Game->GetView())
 		g_Game->GetView()->CameraFollow(entityid, false);
 }
 
 /**
  * Start / stop first-person camera following mode
  * @param entityid unit id to follow. If zero, stop following mode
  */
 void CameraFollowFPS(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_id_t entityid)
 {
 	if (g_Game && g_Game->GetView())
 		g_Game->GetView()->CameraFollow(entityid, true);
 }
 
 /**
  * Set the data (position, orientation and zoom) of the camera
  */
 void SetCameraData(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_pos_t x, entity_pos_t y, entity_pos_t z, entity_pos_t rotx, entity_pos_t roty, entity_pos_t zoom)
 {
 	// called from JS; must not fail
 	if(!(g_Game && g_Game->GetWorld() && g_Game->GetView() && g_Game->GetWorld()->GetTerrain()))
 		return;
 
 	CVector3D Pos = CVector3D(x.ToFloat(), y.ToFloat(), z.ToFloat());
 	float RotX = rotx.ToFloat();
 	float RotY = roty.ToFloat();
 	float Zoom = zoom.ToFloat();
 
 	g_Game->GetView()->SetCamera(Pos, RotX, RotY, Zoom);
 }
 
 /// Move camera to a 2D location
 void CameraMoveTo(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), entity_pos_t x, entity_pos_t z)
 {
 	// called from JS; must not fail
 	if(!(g_Game && g_Game->GetWorld() && g_Game->GetView() && g_Game->GetWorld()->GetTerrain()))
 		return;
 
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	CVector3D target;
 	target.X = x.ToFloat();
 	target.Z = z.ToFloat();
 	target.Y = terrain->GetExactGroundLevel(target.X, target.Z);
 
 	g_Game->GetView()->MoveCameraTarget(target);
 }
 
 entity_id_t GetFollowedEntity(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	if (g_Game && g_Game->GetView())
 		return g_Game->GetView()->GetFollowedEntity();
 
 	return INVALID_ENTITY;
 }
 
 bool HotkeyIsPressed_(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& hotkeyName)
 {
 	return HotkeyIsPressed(hotkeyName);
 }
 
 void DisplayErrorDialog(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& msg)
 {
 	debug_DisplayError(msg.c_str(), DE_NO_DEBUG_INFO, NULL, NULL, NULL, 0, NULL, NULL);
 }
 
 JS::Value GetProfilerState(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	return g_ProfileViewer.SaveToJS(*(pCxPrivate->pScriptInterface));
 }
 
 bool IsUserReportEnabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return g_UserReporter.IsReportingEnabled();
 }
 
 void SetUserReportEnabled(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool enabled)
 {
 	g_UserReporter.SetReportingEnabled(enabled);
 }
 
 std::string GetUserReportStatus(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return g_UserReporter.GetStatus();
 }
 
 void SubmitUserReport(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& type, int version, const std::wstring& data)
 {
 	g_UserReporter.SubmitReport(type.c_str(), version, utf8_from_wstring(data));
 }
 
 void SetSimRate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), float rate)
 {
 	g_Game->SetSimRate(rate);
 }
 
 float GetSimRate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return g_Game->GetSimRate();
 }
 
 void SetTurnLength(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int length)
 {
 	if (g_NetServer)
 		g_NetServer->SetTurnLength(length);
 	else
 		LOGERROR("Only network host can change turn length");
 }
 
 // Focus the game camera on a given position.
 void SetCameraTarget(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), float x, float y, float z)
 {
 	g_Game->GetView()->ResetCameraTarget(CVector3D(x, y, z));
 }
 
 // Deliberately cause the game to crash.
 // Currently implemented via access violation (read of address 0).
 // Useful for testing the crashlog/stack trace code.
 int Crash(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	debug_printf("Crashing at user's request.\n");
 	return *(volatile int*)0;
 }
 
 void DebugWarn(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	debug_warn(L"Warning at user's request.");
 }
 
 // Force a JS garbage collection cycle to take place immediately.
 // Writes an indication of how long this took to the console.
 void ForceGC(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	double time = timer_Time();
 	JS_GC(pCxPrivate->pScriptInterface->GetJSRuntime());
 	time = timer_Time() - time;
 	g_Console->InsertMessage(fmt::sprintf("Garbage collection completed in: %f", time));
 }
 
 void DumpSimState(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	OsPath path = psLogDir()/"sim_dump.txt";
 	std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
 	g_Game->GetSimulation2()->DumpDebugState(file);
 }
 
 void DumpTerrainMipmap(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	VfsPath filename(L"screenshots/terrainmipmap.png");
 	g_Game->GetWorld()->GetTerrain()->GetHeightMipmap().DumpToDisk(filename);
 	OsPath realPath;
 	g_VFS->GetRealPath(filename, realPath);
 	LOGMESSAGERENDER("Terrain mipmap written to '%s'", realPath.string8());
 }
 
 void EnableTimeWarpRecording(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), unsigned int numTurns)
 {
 	g_Game->GetTurnManager()->EnableTimeWarpRecording(numTurns);
 }
 
 void RewindTimeWarp(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_Game->GetTurnManager()->RewindTimeWarp();
 }
 
 void QuickSave(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_Game->GetTurnManager()->QuickSave();
 }
 
 void QuickLoad(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	g_Game->GetTurnManager()->QuickLoad();
 }
 
 void SetBoundingBoxDebugOverlay(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), bool enabled)
 {
 	ICmpSelectable::ms_EnableDebugOverlays = enabled;
 }
 
 void Script_EndGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	EndGame();
 }
 
 CStrW GetSystemUsername(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	return sys_get_user_name();
 }
 
 
 // Cause the game to exit gracefully.
 // params:
 // returns:
 // notes:
 // - Exit happens after the current main loop iteration ends
 //   (since this only sets a flag telling it to end)
 void ExitProgram(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	kill_mainloop();
 }
 
 // Is the game paused?
 bool IsPaused(ScriptInterface::CxPrivate* pCxPrivate)
 {
 	if (!g_Game)
 	{
 		JS_ReportError(pCxPrivate->pScriptInterface->GetContext(), "Game is not started");
 		return false;
 	}
 
 	return g_Game->m_Paused;
 }
 
 // Pause/unpause the game
-void SetPaused(ScriptInterface::CxPrivate* pCxPrivate, bool pause)
+void SetPaused(ScriptInterface::CxPrivate* pCxPrivate, bool pause, bool sendMessage)
 {
 	if (!g_Game)
 	{
 		JS_ReportError(pCxPrivate->pScriptInterface->GetContext(), "Game is not started");
 		return;
 	}
 	g_Game->m_Paused = pause;
 #if CONFIG2_AUDIO
 	if (g_SoundManager)
 		g_SoundManager->Pause(pause);
 #endif
+
+	if (g_NetClient && sendMessage)
+		g_NetClient->SendPausedMessage(pause);
 }
 
 // Return the global frames-per-second value.
 // params:
 // returns: FPS [int]
 // notes:
 // - This value is recalculated once a frame. We take special care to
 //   filter it, so it is both accurate and free of jitter.
 int GetFps(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
 	int freq = 0;
 	if (g_frequencyFilter)
 		freq = g_frequencyFilter->StableFrequency();
 	return freq;
 }
 
 JS::Value GetGUIObjectByName(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStr& name)
 {
 	IGUIObject* guiObj = g_GUI->FindObjectByName(name);
 	if (guiObj)
 		return JS::ObjectValue(*guiObj->GetJSObject());
 	else
 		return JS::UndefinedValue();
 }
 
 // Return the date/time at which the current executable was compiled.
 // params: mode OR an integer specifying
 //   what to display: -1 for "date time (svn revision)", 0 for date, 1 for time, 2 for svn revision
 // returns: string with the requested timestamp info
 // notes:
 // - Displayed on main menu screen; tells non-programmers which auto-build
 //   they are running. Could also be determined via .EXE file properties,
 //   but that's a bit more trouble.
 // - To be exact, the date/time returned is when scriptglue.cpp was
 //   last compiled, but the auto-build does full rebuilds.
 // - svn revision is generated by calling svnversion and cached in
 //   lib/svn_revision.cpp. it is useful to know when attempting to
 //   reproduce bugs (the main EXE and PDB should be temporarily reverted to
 //   that revision so that they match user-submitted crashdumps).
 std::wstring GetBuildTimestamp(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int mode)
 {
 	char buf[200];
 	if (mode == -1) // Date, time and revision.
 	{
 		UDate dateTime = g_L10n.ParseDateTime(__DATE__ " " __TIME__, "MMM d yyyy HH:mm:ss", Locale::getUS());
 		std::string dateTimeString = g_L10n.LocalizeDateTime(dateTime, L10n::DateTime, SimpleDateFormat::DATE_TIME);
 		char svnRevision[32];
 		sprintf_s(svnRevision, ARRAY_SIZE(svnRevision), "%ls", svn_revision);
 		if (strcmp(svnRevision, "custom build") == 0)
 		{
 			// Translation: First item is a date and time, item between parenthesis is the Subversion revision number of the current build.
 			sprintf_s(buf, ARRAY_SIZE(buf), g_L10n.Translate("%s (custom build)").c_str(), dateTimeString.c_str());
 		}
 		else
 		{
 			// Translation: First item is a date and time, item between parenthesis is the Subversion revision number of the current build.
 			sprintf_s(buf, ARRAY_SIZE(buf), g_L10n.Translate("%s (%ls)").c_str(), dateTimeString.c_str(), svn_revision);
 		}
 	}
 	else if (mode == 0) // Date.
 	{
 		UDate dateTime = g_L10n.ParseDateTime(__DATE__, "MMM d yyyy", Locale::getUS());
 		std::string dateTimeString = g_L10n.LocalizeDateTime(dateTime, L10n::Date, SimpleDateFormat::MEDIUM);
 		sprintf_s(buf, ARRAY_SIZE(buf), "%s", dateTimeString.c_str());
 	}
 	else if (mode == 1) // Time.
 	{
 		UDate dateTime = g_L10n.ParseDateTime(__TIME__, "HH:mm:ss", Locale::getUS());
 		std::string dateTimeString = g_L10n.LocalizeDateTime(dateTime, L10n::Time, SimpleDateFormat::MEDIUM);
 		sprintf_s(buf, ARRAY_SIZE(buf), "%s", dateTimeString.c_str());
 	}
 	else if (mode == 2) // Revision.
 	{
 		char svnRevision[32];
 		sprintf_s(svnRevision, ARRAY_SIZE(svnRevision), "%ls", svn_revision);
 		if (strcmp(svnRevision, "custom build") == 0)
 		{
 			sprintf_s(buf, ARRAY_SIZE(buf), "%s", g_L10n.Translate("custom build").c_str());
 		}
 		else
 		{
 			sprintf_s(buf, ARRAY_SIZE(buf), "%ls", svn_revision);
 		}
 	}
 
 	return wstring_from_utf8(buf);
 }
 
 JS::Value ReadJSONFile(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& filePath)
 {
 	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue out(cx);
 	pCxPrivate->pScriptInterface->ReadJSONFile(filePath, &out);
 	return out;
 }
 
 void WriteJSONFile(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& filePath, JS::HandleValue val1)
 {
 	JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	// TODO: This is a workaround because we need to pass a MutableHandle to StringifyJSON.
 	JS::RootedValue val(cx, val1);
 
 	std::string str(pCxPrivate->pScriptInterface->StringifyJSON(&val, false));
 
 	VfsPath path(filePath);
 	WriteBuffer buf;
 	buf.Append(str.c_str(), str.length());
 	g_VFS->CreateFile(path, buf.Data(), buf.Size());
 }
 
 bool TemplateExists(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& templateName)
 {
 	return g_GUI->TemplateExists(templateName);
 }
 
 CParamNode GetTemplate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& templateName)
 {
 	return g_GUI->GetTemplate(templateName);
 }
 
 int GetTextWidth(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStr& fontName, const CStrW& text)
 {
 	int width = 0;
 	int height = 0;
 	CStrIntern _fontName(fontName);
 	CFontMetrics fontMetrics(_fontName);
 	fontMetrics.CalculateStringSize(text.c_str(), width, height);
 	return width;
 }
 
 //-----------------------------------------------------------------------------
 // Timer
 //-----------------------------------------------------------------------------
 
 
 // Script profiling functions: Begin timing a piece of code with StartJsTimer(num)
 // and stop timing with StopJsTimer(num). The results will be printed to stdout
 // when the game exits.
 
 static const size_t MAX_JS_TIMERS = 20;
 static TimerUnit js_start_times[MAX_JS_TIMERS];
 static TimerUnit js_timer_overhead;
 static TimerClient js_timer_clients[MAX_JS_TIMERS];
 static wchar_t js_timer_descriptions_buf[MAX_JS_TIMERS * 12];	// depends on MAX_JS_TIMERS and format string below
 
 static void InitJsTimers(ScriptInterface& scriptInterface)
 {
 	wchar_t* pos = js_timer_descriptions_buf;
 	for(size_t i = 0; i < MAX_JS_TIMERS; i++)
 	{
 		const wchar_t* description = pos;
 		pos += swprintf_s(pos, 12, L"js_timer %d", (int)i)+1;
 		timer_AddClient(&js_timer_clients[i], description);
 	}
 
 	// call several times to get a good approximation of 'hot' performance.
 	// note: don't use a separate timer slot to warm up and then judge
 	// overhead from another: that causes worse results (probably some
 	// caching effects inside JS, but I don't entirely understand why).
 	std::wstring calibration_script =
 		L"Engine.StartXTimer(0);\n" \
 		L"Engine.StopXTimer (0);\n" \
 		L"\n";
 	scriptInterface.LoadGlobalScript("timer_calibration_script", calibration_script);
 	// slight hack: call LoadGlobalScript twice because we can't average several
 	// TimerUnit values because there's no operator/. this way is better anyway
 	// because it hopefully avoids the one-time JS init overhead.
 	js_timer_clients[0].sum.SetToZero();
 	scriptInterface.LoadGlobalScript("timer_calibration_script", calibration_script);
 	js_timer_clients[0].sum.SetToZero();
 	js_timer_clients[0].num_calls = 0;
 }
 
 void StartJsTimer(ScriptInterface::CxPrivate* pCxPrivate, unsigned int slot)
 {
 	ONCE(InitJsTimers(*(pCxPrivate->pScriptInterface)));
 
 	if (slot >= MAX_JS_TIMERS)
 	{
 		LOGERROR("Exceeded the maximum number of timer slots for scripts!");
 		return;
 	}
 
 	js_start_times[slot].SetFromTimer();
 }
 
 void StopJsTimer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), unsigned int slot)
 {
 	if (slot >= MAX_JS_TIMERS)
 	{
 		LOGERROR("Exceeded the maximum number of timer slots for scripts!");
 		return;
 	}
 
 	TimerUnit now;
 	now.SetFromTimer();
 	now.Subtract(js_timer_overhead);
 	BillingPolicy_Default()(&js_timer_clients[slot], js_start_times[slot], now);
 	js_start_times[slot].SetToZero();
 }
 } // namespace
 
 
 
 void GuiScriptingInit(ScriptInterface& scriptInterface)
 {
 	JSI_IGUIObject::init(scriptInterface);
 	JSI_GUITypes::init(scriptInterface);
 
 	JSI_GameView::RegisterScriptFunctions(scriptInterface);
 	JSI_Renderer::RegisterScriptFunctions(scriptInterface);
 	JSI_Console::RegisterScriptFunctions(scriptInterface);
 	JSI_ConfigDB::RegisterScriptFunctions(scriptInterface);
 	JSI_Mod::RegisterScriptFunctions(scriptInterface);
 	JSI_Sound::RegisterScriptFunctions(scriptInterface);
 	JSI_L10n::RegisterScriptFunctions(scriptInterface);
 	JSI_Lobby::RegisterScriptFunctions(scriptInterface);
 	JSI_VisualReplay::RegisterScriptFunctions(scriptInterface);
 
 	// VFS (external)
 	scriptInterface.RegisterFunction<JS::Value, std::wstring, std::wstring, bool, &JSI_VFS::BuildDirEntList>("BuildDirEntList");
 	scriptInterface.RegisterFunction<bool, CStrW, JSI_VFS::FileExists>("FileExists");
 	scriptInterface.RegisterFunction<double, std::wstring, &JSI_VFS::GetFileMTime>("GetFileMTime");
 	scriptInterface.RegisterFunction<unsigned int, std::wstring, &JSI_VFS::GetFileSize>("GetFileSize");
 	scriptInterface.RegisterFunction<JS::Value, std::wstring, &JSI_VFS::ReadFile>("ReadFile");
 	scriptInterface.RegisterFunction<JS::Value, std::wstring, &JSI_VFS::ReadFileLines>("ReadFileLines");
 	// GUI manager functions:
 	scriptInterface.RegisterFunction<void, std::wstring, JS::HandleValue, &PushGuiPage>("PushGuiPage");
 	scriptInterface.RegisterFunction<void, std::wstring, JS::HandleValue, &SwitchGuiPage>("SwitchGuiPage");
 	scriptInterface.RegisterFunction<void, &PopGuiPage>("PopGuiPage");
 	scriptInterface.RegisterFunction<void, JS::HandleValue, &PopGuiPageCB>("PopGuiPageCB");
 	scriptInterface.RegisterFunction<JS::Value, CStr, &GetGUIObjectByName>("GetGUIObjectByName");
 
 	// Simulation<->GUI interface functions:
 	scriptInterface.RegisterFunction<JS::Value, std::wstring, JS::HandleValue, &GuiInterfaceCall>("GuiInterfaceCall");
 	scriptInterface.RegisterFunction<void, JS::HandleValue, &PostNetworkCommand>("PostNetworkCommand");
 
 	// Entity picking
 	scriptInterface.RegisterFunction<entity_id_t, int, int, &PickEntityAtPoint>("PickEntityAtPoint");
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickPlayerEntitiesInRect>("PickPlayerEntitiesInRect");
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, &PickPlayerEntitiesOnScreen>("PickPlayerEntitiesOnScreen");
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, &PickNonGaiaEntitiesOnScreen>("PickNonGaiaEntitiesOnScreen");
 	scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarPlayerEntities>("PickSimilarPlayerEntities");
 	scriptInterface.RegisterFunction<CFixedVector3D, int, int, &GetTerrainAtScreenPoint>("GetTerrainAtScreenPoint");
 
 	// Network / game setup functions
 	scriptInterface.RegisterFunction<void, &StartNetworkGame>("StartNetworkGame");
 	scriptInterface.RegisterFunction<void, JS::HandleValue, int, &StartGame>("StartGame");
 	scriptInterface.RegisterFunction<void, &Script_EndGame>("EndGame");
 	scriptInterface.RegisterFunction<void, std::wstring, &StartNetworkHost>("StartNetworkHost");
 	scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");
 	scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
 	scriptInterface.RegisterFunction<std::string, &GetPlayerGUID>("GetPlayerGUID");
 	scriptInterface.RegisterFunction<bool, CStrW, bool, &KickPlayer>("KickPlayer");
 	scriptInterface.RegisterFunction<JS::Value, &PollNetworkClient>("PollNetworkClient");
 	scriptInterface.RegisterFunction<void, JS::HandleValue, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
 	scriptInterface.RegisterFunction<void, int, std::string, &AssignNetworkPlayer>("AssignNetworkPlayer");
 	scriptInterface.RegisterFunction<void, std::string, int, &SetNetworkPlayerStatus>("SetNetworkPlayerStatus");
 	scriptInterface.RegisterFunction<void, &ClearAllPlayerReady>("ClearAllPlayerReady");
 	scriptInterface.RegisterFunction<void, std::wstring, &SendNetworkChat>("SendNetworkChat");
 	scriptInterface.RegisterFunction<void, int, &SendNetworkReady>("SendNetworkReady");
 	scriptInterface.RegisterFunction<JS::Value, &GetAIs>("GetAIs");
 	scriptInterface.RegisterFunction<JS::Value, &GetEngineInfo>("GetEngineInfo");
 
 	// Saved games
 	scriptInterface.RegisterFunction<JS::Value, std::wstring, &StartSavedGame>("StartSavedGame");
 	scriptInterface.RegisterFunction<JS::Value, &GetSavedGames>("GetSavedGames");
 	scriptInterface.RegisterFunction<bool, std::wstring, &DeleteSavedGame>("DeleteSavedGame");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, JS::HandleValue, &SaveGame>("SaveGame");
 	scriptInterface.RegisterFunction<void, std::wstring, std::wstring, JS::HandleValue, &SaveGamePrefix>("SaveGamePrefix");
 	scriptInterface.RegisterFunction<void, &QuickSave>("QuickSave");
 	scriptInterface.RegisterFunction<void, &QuickLoad>("QuickLoad");
 
 	// Misc functions
 	scriptInterface.RegisterFunction<std::wstring, std::wstring, &SetCursor>("SetCursor");
 	scriptInterface.RegisterFunction<bool, &IsVisualReplay>("IsVisualReplay");
 	scriptInterface.RegisterFunction<std::wstring, &GetCurrentReplayDirectory>("GetCurrentReplayDirectory");
 	scriptInterface.RegisterFunction<int, &GetPlayerID>("GetPlayerID");
 	scriptInterface.RegisterFunction<void, int, &SetPlayerID>("SetPlayerID");
 	scriptInterface.RegisterFunction<void, int, &SetViewedPlayer>("SetViewedPlayer");
 	scriptInterface.RegisterFunction<void, std::string, &OpenURL>("OpenURL");
 	scriptInterface.RegisterFunction<std::wstring, &GetMatchID>("GetMatchID");
 	scriptInterface.RegisterFunction<void, &RestartInAtlas>("RestartInAtlas");
 	scriptInterface.RegisterFunction<bool, &AtlasIsAvailable>("AtlasIsAvailable");
 	scriptInterface.RegisterFunction<bool, &IsAtlasRunning>("IsAtlasRunning");
 	scriptInterface.RegisterFunction<JS::Value, VfsPath, &LoadMapSettings>("LoadMapSettings");
 	scriptInterface.RegisterFunction<JS::Value, &GetMapSettings>("GetMapSettings");
 	scriptInterface.RegisterFunction<float, &CameraGetX>("CameraGetX");
 	scriptInterface.RegisterFunction<float, &CameraGetZ>("CameraGetZ");
 	scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollow>("CameraFollow");
 	scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollowFPS>("CameraFollowFPS");
 	scriptInterface.RegisterFunction<void, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t, entity_pos_t, &SetCameraData>("SetCameraData");
 	scriptInterface.RegisterFunction<void, entity_pos_t, entity_pos_t, &CameraMoveTo>("CameraMoveTo");
 	scriptInterface.RegisterFunction<entity_id_t, &GetFollowedEntity>("GetFollowedEntity");
 	scriptInterface.RegisterFunction<bool, std::string, &HotkeyIsPressed_>("HotkeyIsPressed");
 	scriptInterface.RegisterFunction<void, std::wstring, &DisplayErrorDialog>("DisplayErrorDialog");
 	scriptInterface.RegisterFunction<JS::Value, &GetProfilerState>("GetProfilerState");
 	scriptInterface.RegisterFunction<void, &ExitProgram>("Exit");
 	scriptInterface.RegisterFunction<bool, &IsPaused>("IsPaused");
-	scriptInterface.RegisterFunction<void, bool, &SetPaused>("SetPaused");
+	scriptInterface.RegisterFunction<void, bool, bool, &SetPaused>("SetPaused");
 	scriptInterface.RegisterFunction<int, &GetFps>("GetFPS");
 	scriptInterface.RegisterFunction<std::wstring, int, &GetBuildTimestamp>("GetBuildTimestamp");
 	scriptInterface.RegisterFunction<JS::Value, std::wstring, &ReadJSONFile>("ReadJSONFile");
 	scriptInterface.RegisterFunction<void, std::wstring, JS::HandleValue, &WriteJSONFile>("WriteJSONFile");
 	scriptInterface.RegisterFunction<bool, std::string, &TemplateExists>("TemplateExists");
 	scriptInterface.RegisterFunction<CParamNode, std::string, &GetTemplate>("GetTemplate");
 	scriptInterface.RegisterFunction<int, CStr, CStrW, &GetTextWidth>("GetTextWidth");
 
 	// User report functions
 	scriptInterface.RegisterFunction<bool, &IsUserReportEnabled>("IsUserReportEnabled");
 	scriptInterface.RegisterFunction<void, bool, &SetUserReportEnabled>("SetUserReportEnabled");
 	scriptInterface.RegisterFunction<std::string, &GetUserReportStatus>("GetUserReportStatus");
 	scriptInterface.RegisterFunction<void, std::string, int, std::wstring, &SubmitUserReport>("SubmitUserReport");
 
 	// Development/debugging functions
 	scriptInterface.RegisterFunction<void, unsigned int, &StartJsTimer>("StartXTimer");
 	scriptInterface.RegisterFunction<void, unsigned int, &StopJsTimer>("StopXTimer");
 	scriptInterface.RegisterFunction<void, float, &SetSimRate>("SetSimRate");
 	scriptInterface.RegisterFunction<float, &GetSimRate>("GetSimRate");
 	scriptInterface.RegisterFunction<void, int, &SetTurnLength>("SetTurnLength");
 	scriptInterface.RegisterFunction<void, float, float, float, &SetCameraTarget>("SetCameraTarget");
 	scriptInterface.RegisterFunction<int, &Crash>("Crash");
 	scriptInterface.RegisterFunction<void, &DebugWarn>("DebugWarn");
 	scriptInterface.RegisterFunction<void, &ForceGC>("ForceGC");
 	scriptInterface.RegisterFunction<void, &DumpSimState>("DumpSimState");
 	scriptInterface.RegisterFunction<void, &DumpTerrainMipmap>("DumpTerrainMipmap");
 	scriptInterface.RegisterFunction<void, unsigned int, &EnableTimeWarpRecording>("EnableTimeWarpRecording");
 	scriptInterface.RegisterFunction<void, &RewindTimeWarp>("RewindTimeWarp");
 	scriptInterface.RegisterFunction<void, bool, &SetBoundingBoxDebugOverlay>("SetBoundingBoxDebugOverlay");
 	scriptInterface.RegisterFunction<CStrW, &GetSystemUsername>("GetSystemUsername");
 }
Index: ps/trunk/source/network/NetClient.cpp
===================================================================
--- ps/trunk/source/network/NetClient.cpp	(revision 18203)
+++ ps/trunk/source/network/NetClient.cpp	(revision 18204)
@@ -1,780 +1,805 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "NetClient.h"
 
 #include "NetMessage.h"
 #include "NetSession.h"
 #include "NetTurnManager.h"
 
 #include "lib/byte_order.h"
 #include "lib/sysdep/sysdep.h"
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/Compress.h"
 #include "ps/CStr.h"
 #include "ps/Game.h"
 #include "ps/GUID.h"
 #include "ps/Loader.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 
 CNetClient *g_NetClient = NULL;
 
 /**
  * Async task for receiving the initial game state when rejoining an
  * in-progress network game.
  */
 class CNetFileReceiveTask_ClientRejoin : public CNetFileReceiveTask
 {
 	NONCOPYABLE(CNetFileReceiveTask_ClientRejoin);
 public:
 	CNetFileReceiveTask_ClientRejoin(CNetClient& client)
 		: m_Client(client)
 	{
 	}
 
 	virtual void OnComplete()
 	{
 		// We've received the game state from the server
 
 		// Save it so we can use it after the map has finished loading
 		m_Client.m_JoinSyncBuffer = m_Buffer;
 
 		// Pretend the server told us to start the game
 		CGameStartMessage start;
 		m_Client.HandleMessage(&start);
 	}
 
 private:
 	CNetClient& m_Client;
 };
 
 CNetClient::CNetClient(CGame* game, bool isLocalClient) :
 	m_Session(NULL),
 	m_UserName(L"anonymous"),
 	m_GUID(ps_generate_guid()), m_HostID((u32)-1), m_ClientTurnManager(NULL), m_Game(game),
 	m_GameAttributes(game->GetSimulation2()->GetScriptInterface().GetContext()),
 	m_IsLocalClient(isLocalClient),
 	m_LastConnectionCheck(0),
 	m_Rejoin(false)
 {
 	m_Game->SetTurnManager(NULL); // delete the old local turn manager so we don't accidentally use it
 
 	void* context = this;
 
 	JS_AddExtraGCRootsTracer(GetScriptInterface().GetJSRuntime(), CNetClient::Trace, this);
 
 	// Set up transitions for session
 	AddTransition(NCS_UNCONNECTED, (uint)NMT_CONNECT_COMPLETE, NCS_CONNECT, (void*)&OnConnect, context);
 
 	AddTransition(NCS_CONNECT, (uint)NMT_SERVER_HANDSHAKE, NCS_HANDSHAKE, (void*)&OnHandshake, context);
 
 	AddTransition(NCS_HANDSHAKE, (uint)NMT_SERVER_HANDSHAKE_RESPONSE, NCS_AUTHENTICATE, (void*)&OnHandshakeResponse, context);
 
 	AddTransition(NCS_AUTHENTICATE, (uint)NMT_AUTHENTICATE_RESULT, NCS_INITIAL_GAMESETUP, (void*)&OnAuthenticate, context);
 
 	AddTransition(NCS_INITIAL_GAMESETUP, (uint)NMT_GAME_SETUP, NCS_PREGAME, (void*)&OnGameSetup, context);
 
 	AddTransition(NCS_PREGAME, (uint)NMT_CHAT, NCS_PREGAME, (void*)&OnChat, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_READY, NCS_PREGAME, (void*)&OnReady, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_GAME_SETUP, NCS_PREGAME, (void*)&OnGameSetup, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_PLAYER_ASSIGNMENT, NCS_PREGAME, (void*)&OnPlayerAssignment, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_KICKED, NCS_PREGAME, (void*)&OnKicked, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_CLIENT_TIMEOUT, NCS_PREGAME, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_CLIENT_PERFORMANCE, NCS_PREGAME, (void*)&OnClientPerformance, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_GAME_START, NCS_LOADING, (void*)&OnGameStart, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_JOIN_SYNC_START, NCS_JOIN_SYNCING, (void*)&OnJoinSyncStart, context);
 
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CHAT, NCS_JOIN_SYNCING, (void*)&OnChat, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_GAME_SETUP, NCS_JOIN_SYNCING, (void*)&OnGameSetup, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_PLAYER_ASSIGNMENT, NCS_JOIN_SYNCING, (void*)&OnPlayerAssignment, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CLIENT_TIMEOUT, NCS_JOIN_SYNCING, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CLIENT_PERFORMANCE, NCS_JOIN_SYNCING, (void*)&OnClientPerformance, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_GAME_START, NCS_JOIN_SYNCING, (void*)&OnGameStart, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_SIMULATION_COMMAND, NCS_JOIN_SYNCING, (void*)&OnInGame, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_END_COMMAND_BATCH, NCS_JOIN_SYNCING, (void*)&OnJoinSyncEndCommandBatch, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_LOADED_GAME, NCS_INGAME, (void*)&OnLoadedGame, context);
 
 	AddTransition(NCS_LOADING, (uint)NMT_CHAT, NCS_LOADING, (void*)&OnChat, context);
 	AddTransition(NCS_LOADING, (uint)NMT_GAME_SETUP, NCS_LOADING, (void*)&OnGameSetup, context);
 	AddTransition(NCS_LOADING, (uint)NMT_PLAYER_ASSIGNMENT, NCS_LOADING, (void*)&OnPlayerAssignment, context);
 	AddTransition(NCS_LOADING, (uint)NMT_CLIENT_TIMEOUT, NCS_LOADING, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_LOADING, (uint)NMT_CLIENT_PERFORMANCE, NCS_LOADING, (void*)&OnClientPerformance, context);
 	AddTransition(NCS_LOADING, (uint)NMT_LOADED_GAME, NCS_INGAME, (void*)&OnLoadedGame, context);
 
 	AddTransition(NCS_INGAME, (uint)NMT_REJOINED, NCS_INGAME, (void*)&OnRejoined, context);
 	AddTransition(NCS_INGAME, (uint)NMT_KICKED, NCS_INGAME, (void*)&OnKicked, context);
 	AddTransition(NCS_INGAME, (uint)NMT_CLIENT_TIMEOUT, NCS_INGAME, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_INGAME, (uint)NMT_CLIENT_PERFORMANCE, NCS_INGAME, (void*)&OnClientPerformance, context);
+	AddTransition(NCS_INGAME, (uint)NMT_CLIENT_PAUSED, NCS_INGAME, (void*)&OnClientPaused, context);
 	AddTransition(NCS_INGAME, (uint)NMT_CHAT, NCS_INGAME, (void*)&OnChat, context);
 	AddTransition(NCS_INGAME, (uint)NMT_GAME_SETUP, NCS_INGAME, (void*)&OnGameSetup, context);
 	AddTransition(NCS_INGAME, (uint)NMT_PLAYER_ASSIGNMENT, NCS_INGAME, (void*)&OnPlayerAssignment, context);
 	AddTransition(NCS_INGAME, (uint)NMT_SIMULATION_COMMAND, NCS_INGAME, (void*)&OnInGame, context);
 	AddTransition(NCS_INGAME, (uint)NMT_SYNC_ERROR, NCS_INGAME, (void*)&OnInGame, context);
 	AddTransition(NCS_INGAME, (uint)NMT_END_COMMAND_BATCH, NCS_INGAME, (void*)&OnInGame, context);
 
 	// Set first state
 	SetFirstState(NCS_UNCONNECTED);
 }
 
 CNetClient::~CNetClient()
 {
 	DestroyConnection();
 	JS_RemoveExtraGCRootsTracer(GetScriptInterface().GetJSRuntime(), CNetClient::Trace, this);
 }
 
 void CNetClient::TraceMember(JSTracer *trc)
 {
 	for (JS::Heap<JS::Value>& guiMessage : m_GuiMessageQueue)
 		JS_CallHeapValueTracer(trc, &guiMessage, "m_GuiMessageQueue");
 }
 
 void CNetClient::SetUserName(const CStrW& username)
 {
 	ENSURE(!m_Session); // must be called before we start the connection
 
 	m_UserName = username;
 }
 
 bool CNetClient::SetupConnection(const CStr& server)
 {
 	CNetClientSession* session = new CNetClientSession(*this);
 	bool ok = session->Connect(PS_DEFAULT_PORT, server, m_IsLocalClient);
 	SetAndOwnSession(session);
 	return ok;
 }
 
 void CNetClient::SetAndOwnSession(CNetClientSession* session)
 {
 	delete m_Session;
 	m_Session = session;
 }
 
 void CNetClient::DestroyConnection()
 {
 	// Send network messages from the current frame before connection is destroyed.
 	if (m_ClientTurnManager)
 	{
 		m_ClientTurnManager->OnDestroyConnection(); // End sending of commands for scheduled turn.
 		Flush(); // Make sure the messages are sent.
 	}
 	SAFE_DELETE(m_Session);
 }
 
 void CNetClient::Poll()
 {
 	if (!m_Session)
 		return;
 
 	CheckServerConnection();
 	m_Session->Poll();
 }
 
 void CNetClient::CheckServerConnection()
 {
 	// Trigger local warnings if the connection to the server is bad.
 	// At most once per second.
 	std::time_t now = std::time(nullptr);
 	if (now <= m_LastConnectionCheck)
 		return;
 
 	m_LastConnectionCheck = now;
 
 	JSContext* cx = GetScriptInterface().GetContext();
 
 	// Report if we are losing the connection to the server
 	u32 lastReceived = m_Session->GetLastReceivedTime();
 	if (lastReceived > NETWORK_WARNING_TIMEOUT)
 	{
 		JS::RootedValue msg(cx);
 		GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'server-timeout' })", &msg);
 		GetScriptInterface().SetProperty(msg, "lastReceivedTime", lastReceived);
 		PushGuiMessage(msg);
 		return;
 	}
 
 	// Report if we have a bad ping to the server
 	u32 meanRTT = m_Session->GetMeanRTT();
 	if (meanRTT > DEFAULT_TURN_LENGTH_MP)
 	{
 		JS::RootedValue msg(cx);
 		GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'server-latency' })", &msg);
 		GetScriptInterface().SetProperty(msg, "meanRTT", meanRTT);
 		PushGuiMessage(msg);
 	}
 }
 
 void CNetClient::Flush()
 {
 	if (m_Session)
 		m_Session->Flush();
 }
 
 void CNetClient::GuiPoll(JS::MutableHandleValue ret)
 {
 	if (m_GuiMessageQueue.empty())
 	{
 		ret.setUndefined();
 		return;
 	}
 
 	ret.set(m_GuiMessageQueue.front());
 	m_GuiMessageQueue.pop_front();
 }
 
 void CNetClient::PushGuiMessage(const JS::HandleValue message)
 {
 	ENSURE(!message.isUndefined());
 
 	m_GuiMessageQueue.push_back(JS::Heap<JS::Value>(message));
 }
 
 std::string CNetClient::TestReadGuiMessages()
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	std::string r;
 	JS::RootedValue msg(cx);
 	while (true)
 	{
 		GuiPoll(&msg);
 		if (msg.isUndefined())
 			break;
 		r += GetScriptInterface().ToString(&msg) + "\n";
 	}
 	return r;
 }
 
 ScriptInterface& CNetClient::GetScriptInterface()
 {
 	return m_Game->GetSimulation2()->GetScriptInterface();
 }
 
 void CNetClient::PostPlayerAssignmentsToScript()
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue msg(cx);
 	GetScriptInterface().Eval("({'type':'players', 'hosts':{}})", &msg);
 
 	JS::RootedValue hosts(cx);
 	GetScriptInterface().GetProperty(msg, "hosts", &hosts);
 
 	for (const std::pair<CStr, PlayerAssignment>& p : m_PlayerAssignments)
 	{
 		JS::RootedValue host(cx);
 		GetScriptInterface().Eval("({})", &host);
 		GetScriptInterface().SetProperty(host, "name", std::wstring(p.second.m_Name), false);
 		GetScriptInterface().SetProperty(host, "player", p.second.m_PlayerID, false);
 		GetScriptInterface().SetProperty(host, "status", p.second.m_Status, false);
 		GetScriptInterface().SetProperty(hosts, p.first.c_str(), host, false);
 	}
 
 	PushGuiMessage(msg);
 }
 
 bool CNetClient::SendMessage(const CNetMessage* message)
 {
 	if (!m_Session)
 		return false;
 
 	return m_Session->SendMessage(message);
 }
 
 void CNetClient::HandleConnect()
 {
 	Update((uint)NMT_CONNECT_COMPLETE, NULL);
 }
 
 void CNetClient::HandleDisconnect(u32 reason)
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue msg(cx);
 	GetScriptInterface().Eval("({'type':'netstatus','status':'disconnected'})", &msg);
 	GetScriptInterface().SetProperty(msg, "reason", (int)reason, false);
 	PushGuiMessage(msg);
 
 	SAFE_DELETE(m_Session);
 
 	// Update the state immediately to UNCONNECTED (don't bother with FSM transitions since
 	// we'd need one for every single state, and we don't need to use per-state actions)
 	SetCurrState(NCS_UNCONNECTED);
 }
 
 void CNetClient::SendChatMessage(const std::wstring& text)
 {
 	CChatMessage chat;
 	chat.m_Message = text;
 	SendMessage(&chat);
 }
 
 void CNetClient::SendReadyMessage(const int status)
 {
 	CReadyMessage readyStatus;
 	readyStatus.m_Status = status;
 	SendMessage(&readyStatus);
 }
 
 void CNetClient::SendRejoinedMessage()
 {
 	CRejoinedMessage rejoinedMessage;
 	SendMessage(&rejoinedMessage);
 }
 
+void CNetClient::SendPausedMessage(bool pause)
+{
+	CClientPausedMessage pausedMessage;
+	pausedMessage.m_Pause = pause;
+	SendMessage(&pausedMessage);
+}
+
 bool CNetClient::HandleMessage(CNetMessage* message)
 {
 	// Handle non-FSM messages first
 
 	Status status = m_Session->GetFileTransferer().HandleMessageReceive(message);
 	if (status == INFO::OK)
 		return true;
 	if (status != INFO::SKIPPED)
 		return false;
 
 	if (message->GetType() == NMT_FILE_TRANSFER_REQUEST)
 	{
 		CFileTransferRequestMessage* reqMessage = (CFileTransferRequestMessage*)message;
 
 		// TODO: we should support different transfer request types, instead of assuming
 		// it's always requesting the simulation state
 
 		std::stringstream stream;
 
 		LOGMESSAGERENDER("Serializing game at turn %u for rejoining player", m_ClientTurnManager->GetCurrentTurn());
 		u32 turn = to_le32(m_ClientTurnManager->GetCurrentTurn());
 		stream.write((char*)&turn, sizeof(turn));
 
 		bool ok = m_Game->GetSimulation2()->SerializeState(stream);
 		ENSURE(ok);
 
 		// Compress the content with zlib to save bandwidth
 		// (TODO: if this is still too large, compressing with e.g. LZMA works much better)
 		std::string compressed;
 		CompressZLib(stream.str(), compressed, true);
 
 		m_Session->GetFileTransferer().StartResponse(reqMessage->m_RequestID, compressed);
 
 		return true;
 	}
 
 	// Update FSM
 	bool ok = Update(message->GetType(), message);
 	if (!ok)
 		LOGERROR("Net client: Error running FSM update (type=%d state=%d)", (int)message->GetType(), (int)GetCurrState());
 	return ok;
 }
 
 void CNetClient::LoadFinished()
 {
 	JSContext* cx = GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	if (!m_JoinSyncBuffer.empty())
 	{
 		// We're rejoining a game, and just finished loading the initial map,
 		// so deserialize the saved game state now
 
 		std::string state;
 		DecompressZLib(m_JoinSyncBuffer, state, true);
 
 		std::stringstream stream(state);
 
 		u32 turn;
 		stream.read((char*)&turn, sizeof(turn));
 		turn = to_le32(turn);
 
 		LOGMESSAGE("Rejoining client deserializing state at turn %u\n", turn);
 
 		bool ok = m_Game->GetSimulation2()->DeserializeState(stream);
 		ENSURE(ok);
 
 		m_ClientTurnManager->ResetState(turn, turn);
 
 		JS::RootedValue msg(cx);
 		GetScriptInterface().Eval("({'type':'netstatus','status':'join_syncing'})", &msg);
 		PushGuiMessage(msg);
 	}
 	else
 	{
 		// Connecting at the start of a game, so we'll wait for other players to finish loading
 		JS::RootedValue msg(cx);
 		GetScriptInterface().Eval("({'type':'netstatus','status':'waiting_for_players'})", &msg);
 		PushGuiMessage(msg);
 	}
 
 	CLoadedGameMessage loaded;
 	loaded.m_CurrentTurn = m_ClientTurnManager->GetCurrentTurn();
 	SendMessage(&loaded);
 }
 
 bool CNetClient::OnConnect(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_CONNECT_COMPLETE);
 
 	CNetClient* client = (CNetClient*)context;
 
 	JSContext* cx = client->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'netstatus','status':'connected'})", &msg);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnHandshake(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_SERVER_HANDSHAKE);
 
 	CNetClient* client = (CNetClient*)context;
 
 	CCliHandshakeMessage handshake;
 	handshake.m_MagicResponse = PS_PROTOCOL_MAGIC_RESPONSE;
 	handshake.m_ProtocolVersion = PS_PROTOCOL_VERSION;
 	handshake.m_SoftwareVersion = PS_PROTOCOL_VERSION;
 	client->SendMessage(&handshake);
 
 	return true;
 }
 
 bool CNetClient::OnHandshakeResponse(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_SERVER_HANDSHAKE_RESPONSE);
 
 	CNetClient* client = (CNetClient*)context;
 
 	CAuthenticateMessage authenticate;
 	authenticate.m_GUID = client->m_GUID;
 	authenticate.m_Name = client->m_UserName;
 	authenticate.m_Password = L""; // TODO
 	authenticate.m_IsLocalClient = client->m_IsLocalClient;
 	client->SendMessage(&authenticate);
 
 	return true;
 }
 
 bool CNetClient::OnAuthenticate(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_AUTHENTICATE_RESULT);
 
 	CNetClient* client = (CNetClient*)context;
 
 	JSContext* cx = client->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	CAuthenticateResultMessage* message = (CAuthenticateResultMessage*)event->GetParamRef();
 
 	LOGMESSAGE("Net: Authentication result: host=%u, %s", message->m_HostID, utf8_from_wstring(message->m_Message));
 
 	client->m_HostID = message->m_HostID;
 	client->m_Rejoin = message->m_Code == ARC_OK_REJOINING;
 
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'netstatus','status':'authenticated'})", &msg);
 	client->GetScriptInterface().SetProperty(msg, "rejoining", client->m_Rejoin);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnChat(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_CHAT);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	CChatMessage* message = (CChatMessage*)event->GetParamRef();
 
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'chat'})", &msg);
 	client->GetScriptInterface().SetProperty(msg, "guid", std::string(message->m_GUID), false);
 	client->GetScriptInterface().SetProperty(msg, "text", std::wstring(message->m_Message), false);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnReady(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_READY);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	CReadyMessage* message = (CReadyMessage*)event->GetParamRef();
 
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'ready'})", &msg);
 	client->GetScriptInterface().SetProperty(msg, "guid", std::string(message->m_GUID), false);
 	client->GetScriptInterface().SetProperty(msg, "status", int (message->m_Status), false);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnGameSetup(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_GAME_SETUP);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	CGameSetupMessage* message = (CGameSetupMessage*)event->GetParamRef();
 
 	client->m_GameAttributes = message->m_Data;
 
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'gamesetup'})", &msg);
 	client->GetScriptInterface().SetProperty(msg, "data", message->m_Data, false);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnPlayerAssignment(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_PLAYER_ASSIGNMENT);
 
 	CNetClient* client = (CNetClient*)context;
 
 	CPlayerAssignmentMessage* message = (CPlayerAssignmentMessage*)event->GetParamRef();
 
 	// Unpack the message
 	PlayerAssignmentMap newPlayerAssignments;
 	for (size_t i = 0; i < message->m_Hosts.size(); ++i)
 	{
 		PlayerAssignment assignment;
 		assignment.m_Enabled = true;
 		assignment.m_Name = message->m_Hosts[i].m_Name;
 		assignment.m_PlayerID = message->m_Hosts[i].m_PlayerID;
 		assignment.m_Status = message->m_Hosts[i].m_Status;
 		newPlayerAssignments[message->m_Hosts[i].m_GUID] = assignment;
 	}
 
 	client->m_PlayerAssignments.swap(newPlayerAssignments);
 
 	client->PostPlayerAssignmentsToScript();
 
 	return true;
 }
 
 bool CNetClient::OnGameStart(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_GAME_START);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	// Find the player assigned to our GUID
 	int player = -1;
 	if (client->m_PlayerAssignments.find(client->m_GUID) != client->m_PlayerAssignments.end())
 		player = client->m_PlayerAssignments[client->m_GUID].m_PlayerID;
 
 	client->m_ClientTurnManager = new CNetClientTurnManager(
 			*client->m_Game->GetSimulation2(), *client, client->m_HostID, client->m_Game->GetReplayLogger());
 
 	client->m_Game->SetPlayerID(player);
 	client->m_Game->StartGame(&client->m_GameAttributes, "");
 
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'start'})", &msg);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnJoinSyncStart(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_JOIN_SYNC_START);
 
 	CNetClient* client = (CNetClient*)context;
 
 	// The server wants us to start downloading the game state from it, so do so
 	client->m_Session->GetFileTransferer().StartTask(
 		shared_ptr<CNetFileReceiveTask>(new CNetFileReceiveTask_ClientRejoin(*client))
 	);
 
 	return true;
 }
 
 bool CNetClient::OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_END_COMMAND_BATCH);
 
 	CNetClient* client = (CNetClient*)context;
 
 	CEndCommandBatchMessage* endMessage = (CEndCommandBatchMessage*)event->GetParamRef();
 
 	client->m_ClientTurnManager->FinishedAllCommands(endMessage->m_Turn, endMessage->m_TurnLength);
 
 	// Execute all the received commands for the latest turn
 	client->m_ClientTurnManager->UpdateFastForward();
 
 	return true;
 }
 
 bool CNetClient::OnRejoined(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_REJOINED);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 
 	CRejoinedMessage* message = (CRejoinedMessage*)event->GetParamRef();
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'rejoined'})", &msg);
 	client->GetScriptInterface().SetProperty(msg, "guid", std::string(message->m_GUID), false);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnKicked(void *context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_KICKED);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 
 	CKickedMessage* message = (CKickedMessage*)event->GetParamRef();
 	JS::RootedValue msg(cx);
 
 	client->GetScriptInterface().Eval("({})", &msg);
 	client->GetScriptInterface().SetProperty(msg, "username", message->m_Name);
 	client->GetScriptInterface().SetProperty(msg, "type", message->m_Ban ? std::string("banned") : std::string("kicked"));
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnClientTimeout(void *context, CFsmEvent* event)
 {
 	// Report the timeout of some other client
 
 	ENSURE(event->GetType() == (uint)NMT_CLIENT_TIMEOUT);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 
 	if (client->GetCurrState() == NCS_LOADING)
 		return true;
 
 	CClientTimeoutMessage* message = (CClientTimeoutMessage*)event->GetParamRef();
 	JS::RootedValue msg(cx);
 
 	client->GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'client-timeout' })", &msg);
 	client->GetScriptInterface().SetProperty(msg, "guid", std::string(message->m_GUID));
 	client->GetScriptInterface().SetProperty(msg, "lastReceivedTime", message->m_LastReceivedTime);
 	client->PushGuiMessage(msg);
 
 	return true;
 }
 
 bool CNetClient::OnClientPerformance(void *context, CFsmEvent* event)
 {
 	// Performance statistics for one or multiple clients
 
 	ENSURE(event->GetType() == (uint)NMT_CLIENT_PERFORMANCE);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 
 	if (client->GetCurrState() == NCS_LOADING)
 		return true;
 
 	CClientPerformanceMessage* message = (CClientPerformanceMessage*)event->GetParamRef();
 
 	// Display warnings for other clients with bad ping
 	for (size_t i = 0; i < message->m_Clients.size(); ++i)
 	{
 		if (message->m_Clients[i].m_MeanRTT < DEFAULT_TURN_LENGTH_MP || message->m_Clients[i].m_GUID == client->m_GUID)
 			continue;
 
 		JS::RootedValue msg(cx);
 		client->GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'client-latency' })", &msg);
 		client->GetScriptInterface().SetProperty(msg, "guid", message->m_Clients[i].m_GUID);
 		client->GetScriptInterface().SetProperty(msg, "meanRTT", message->m_Clients[i].m_MeanRTT);
 		client->PushGuiMessage(msg);
 	}
 
 	return true;
 }
 
+bool CNetClient::OnClientPaused(void *context, CFsmEvent *event)
+{
+	ENSURE(event->GetType() == (uint)NMT_CLIENT_PAUSED);
+
+	CNetClient* client = (CNetClient*)context;
+	JSContext* cx = client->GetScriptInterface().GetContext();
+	CClientPausedMessage* message = (CClientPausedMessage*)event->GetParamRef();
+
+	JS::RootedValue msg(cx);
+	client->GetScriptInterface().Eval("({ 'type':'paused' })", &msg);
+	client->GetScriptInterface().SetProperty(msg, "pause", message->m_Pause != 0);
+	client->GetScriptInterface().SetProperty(msg, "guid", message->m_GUID);
+	client->PushGuiMessage(msg);
+
+	return true;
+}
+
 bool CNetClient::OnLoadedGame(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
 	CNetClient* client = (CNetClient*)context;
 	JSContext* cx = client->GetScriptInterface().GetContext();
 	JSAutoRequest rq(cx);
 
 	// All players have loaded the game - start running the turn manager
 	// so that the game begins
 	client->m_Game->SetTurnManager(client->m_ClientTurnManager);
 
 	JS::RootedValue msg(cx);
 	client->GetScriptInterface().Eval("({'type':'netstatus','status':'active'})", &msg);
 	client->PushGuiMessage(msg);
 
 	// If we have rejoined an in progress game, send the rejoined message to the server.
 	if (client->m_Rejoin)
 		client->SendRejoinedMessage();
 
 	return true;
 }
 
 bool CNetClient::OnInGame(void *context, CFsmEvent* event)
 {
 	// TODO: should split each of these cases into a separate method
 
 	CNetClient* client = (CNetClient*)context;
 
 	CNetMessage* message = (CNetMessage*)event->GetParamRef();
 	if (message)
 	{
 		if (message->GetType() == NMT_SIMULATION_COMMAND)
 		{
 			CSimulationMessage* simMessage = static_cast<CSimulationMessage*> (message);
 			client->m_ClientTurnManager->OnSimulationMessage(simMessage);
 		}
 		else if (message->GetType() == NMT_SYNC_ERROR)
 		{
 			CSyncErrorMessage* syncMessage = static_cast<CSyncErrorMessage*> (message);
 			client->m_ClientTurnManager->OnSyncError(syncMessage->m_Turn, syncMessage->m_HashExpected, syncMessage->m_PlayerNames);
 		}
 		else if (message->GetType() == NMT_END_COMMAND_BATCH)
 		{
 			CEndCommandBatchMessage* endMessage = static_cast<CEndCommandBatchMessage*> (message);
 			client->m_ClientTurnManager->FinishedAllCommands(endMessage->m_Turn, endMessage->m_TurnLength);
 		}
 	}
 
 	return true;
 }
Index: ps/trunk/source/network/NetClient.h
===================================================================
--- ps/trunk/source/network/NetClient.h	(revision 18203)
+++ ps/trunk/source/network/NetClient.h	(revision 18204)
@@ -1,270 +1,276 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef NETCLIENT_H
 #define NETCLIENT_H
 
 #include "network/fsm.h"
 #include "network/NetFileTransfer.h"
 #include "network/NetHost.h"
 #include "scriptinterface/ScriptVal.h"
 
 #include "ps/CStr.h"
 
 #include <deque>
 
 class CGame;
 class CNetClientSession;
 class CNetClientTurnManager;
 class CNetServer;
 class ScriptInterface;
 
 // NetClient session FSM states
 enum
 {
 	NCS_UNCONNECTED,
 	NCS_CONNECT,
 	NCS_HANDSHAKE,
 	NCS_AUTHENTICATE,
 	NCS_INITIAL_GAMESETUP,
 	NCS_PREGAME,
 	NCS_LOADING,
 	NCS_JOIN_SYNCING,
 	NCS_INGAME
 };
 
 /**
  * Network client.
  * This code is run by every player (including the host, if they are not
  * a dedicated server).
  * It provides an interface between the GUI, the network (via CNetClientSession),
  * and the game (via CGame and CNetClientTurnManager).
  */
 class CNetClient : public CFsm
 {
 	NONCOPYABLE(CNetClient);
 
 	friend class CNetFileReceiveTask_ClientRejoin;
 
 public:
 	/**
 	 * Construct a client associated with the given game object.
 	 * The game must exist for the lifetime of this object.
 	 */
 	CNetClient(CGame* game, bool isLocalClient);
 
 	virtual ~CNetClient();
 
 	/**
 	 * We assume that adding a tracing function that's only called
 	 * during GC is better for performance than using a
 	 * PersistentRooted<T> where each value needs to be added to
 	 * the root set.
 	 */
 	static void Trace(JSTracer *trc, void *data)
 	{
 		reinterpret_cast<CNetClient*>(data)->TraceMember(trc);
 	}
 
 	void TraceMember(JSTracer *trc);
 
 	/**
 	 * Set the user's name that will be displayed to all players.
 	 * This must not be called after the connection setup.
 	 */
 	void SetUserName(const CStrW& username);
 
 	/**
 	 * Returns the GUID of the local client.
 	 * Used for distinguishing observers.
 	 */
 	CStr GetGUID() const { return m_GUID; }
 
 	/**
 	 * Set up a connection to the remote networked server.
 	 * @param server IP address or host name to connect to
 	 * @return true on success, false on connection failure
 	 */
 	bool SetupConnection(const CStr& server);
 
 	/**
 	 * Destroy the connection to the server.
 	 * This client probably cannot be used again.
 	 */
 	void DestroyConnection();
 
 	/**
 	 * Poll the connection for messages from the server and process them, and send
 	 * any queued messages.
 	 * This must be called frequently (i.e. once per frame).
 	 */
 	void Poll();
 
 	/**
 	 * Locally triggers a GUI message if the connection to the server is being lost or has bad latency.
 	 */
 	void CheckServerConnection();
 
 	/**
 	 * Flush any queued outgoing network messages.
 	 * This should be called soon after sending a group of messages that may be batched together.
 	 */
 	void Flush();
 
 	/**
 	 * Retrieves the next queued GUI message, and removes it from the queue.
 	 * The returned value is in the GetScriptInterface() JS context.
 	 *
 	 * This is the only mechanism for the networking code to send messages to
 	 * the GUI - it is pull-based (instead of push) so the engine code does not
 	 * need to know anything about the code structure of the GUI scripts.
 	 *
 	 * The structure of the messages is <code>{ "type": "...", ... }</code>.
 	 * The exact types and associated data are not specified anywhere - the
 	 * implementation and GUI scripts must make the same assumptions.
 	 *
 	 * @return next message, or the value 'undefined' if the queue is empty
 	 */
 	void GuiPoll(JS::MutableHandleValue);
 
 	/**
 	 * Add a message to the queue, to be read by GuiPoll.
 	 * The script value must be in the GetScriptInterface() JS context.
 	 */
 	void PushGuiMessage(const JS::HandleValue message);
 
 	/**
 	 * Return a concatenation of all messages in the GUI queue,
 	 * for test cases to easily verify the queue contents.
 	 */
 	std::string TestReadGuiMessages();
 
 	/**
 	 * Get the script interface associated with this network client,
 	 * which is equivalent to the one used by the CGame in the constructor.
 	 */
 	ScriptInterface& GetScriptInterface();
 
 	/**
 	 * Send a message to the server.
 	 * @param message message to send
 	 * @return true on success
 	 */
 	bool SendMessage(const CNetMessage* message);
 
 	/**
 	 * Call when the network connection has been successfully initiated.
 	 */
 	void HandleConnect();
 
 	/**
 	 * Call when the network connection has been lost.
 	 */
 	void HandleDisconnect(u32 reason);
 
 	/**
 	 * Call when a message has been received from the network.
 	 */
 	bool HandleMessage(CNetMessage* message);
 
 	/**
 	 * Call when the game has started and all data files have been loaded,
 	 * to signal to the server that we are ready to begin the game.
 	 */
 	void LoadFinished();
 
 	void SendChatMessage(const std::wstring& text);
 
 	void SendReadyMessage(const int status);
 
 	/**
 	 * Call when the client has rejoined a running match and finished
 	 * the loading screen.
 	 */
 	void SendRejoinedMessage();
 
+	/**
+	 * Call when the client has paused or unpaused the game.
+	 */
+	void SendPausedMessage(bool pause);
+
 private:
 	// Net message / FSM transition handlers
 	static bool OnConnect(void* context, CFsmEvent* event);
 	static bool OnHandshake(void* context, CFsmEvent* event);
 	static bool OnHandshakeResponse(void* context, CFsmEvent* event);
 	static bool OnAuthenticate(void* context, CFsmEvent* event);
 	static bool OnChat(void* context, CFsmEvent* event);
 	static bool OnReady(void* context, CFsmEvent* event);
 	static bool OnGameSetup(void* context, CFsmEvent* event);
 	static bool OnPlayerAssignment(void* context, CFsmEvent* event);
 	static bool OnInGame(void* context, CFsmEvent* event);
 	static bool OnGameStart(void* context, CFsmEvent* event);
 	static bool OnJoinSyncStart(void* context, CFsmEvent* event);
 	static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
 	static bool OnRejoined(void* context, CFsmEvent* event);
 	static bool OnKicked(void* context, CFsmEvent* event);
 	static bool OnClientTimeout(void* context, CFsmEvent* event);
 	static bool OnClientPerformance(void* context, CFsmEvent* event);
+	static bool OnClientPaused(void* context, CFsmEvent* event);
 	static bool OnLoadedGame(void* context, CFsmEvent* event);
 
 	/**
 	 * Take ownership of a session object, and use it for all network communication.
 	 */
 	void SetAndOwnSession(CNetClientSession* session);
 
 	/**
 	 * Push a message onto the GUI queue listing the current player assignments.
 	 */
 	void PostPlayerAssignmentsToScript();
 
 	CGame *m_Game;
 	CStrW m_UserName;
 
 	/// Current network session (or NULL if not connected)
 	CNetClientSession* m_Session;
 
 	/// Turn manager associated with the current game (or NULL if we haven't started the game yet)
 	CNetClientTurnManager* m_ClientTurnManager;
 
 	/// Unique-per-game identifier of this client, used to identify the sender of simulation commands
 	u32 m_HostID;
 
 	/// True if the player is currently rejoining or has already rejoined the game.
 	bool m_Rejoin;
 
 	/// Whether to prevent the client of the host from timing out
 	bool m_IsLocalClient;
 
 	/// Latest copy of game setup attributes heard from the server
 	JS::PersistentRootedValue m_GameAttributes;
 
 	/// Latest copy of player assignments heard from the server
 	PlayerAssignmentMap m_PlayerAssignments;
 
 	/// Globally unique identifier to distinguish users beyond the lifetime of a single network session
 	CStr m_GUID;
 
 	/// Queue of messages for GuiPoll
 	std::deque<JS::Heap<JS::Value>> m_GuiMessageQueue;
 
 	/// Serialized game state received when joining an in-progress game
 	std::string m_JoinSyncBuffer;
 
 	/// Time when the server was last checked for timeouts and bad latency
 	std::time_t m_LastConnectionCheck;
 };
 
 /// Global network client for the standard game
 extern CNetClient *g_NetClient;
 
 #endif	// NETCLIENT_H
Index: ps/trunk/source/network/NetMessage.cpp
===================================================================
--- ps/trunk/source/network/NetMessage.cpp	(revision 18203)
+++ ps/trunk/source/network/NetMessage.cpp	(revision 18204)
@@ -1,211 +1,215 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 #include "NetMessage.h"
 
 #include "ps/CLogger.h"
 
 #include "ps/Game.h"
 #include "simulation2/Simulation2.h"
 
 #undef ALLNETMSGS_DONT_CREATE_NMTS
 #define ALLNETMSGS_IMPLEMENT
 #include "NetMessages.h"
 
 CNetMessage::CNetMessage()
 {
 	m_Type	= NMT_INVALID;
 }
 
 CNetMessage::CNetMessage(NetMessageType type)
 {
 	m_Type  = type;
 }
 
 CNetMessage::~CNetMessage()
 {
 }
 
 u8* CNetMessage::Serialize(u8* pBuffer) const
 {
 	size_t size = GetSerializedLength();
 	Serialize_int_1(pBuffer, m_Type);
 	Serialize_int_2(pBuffer, size);
 
 	return pBuffer;
 }
 
 const u8* CNetMessage::Deserialize(const u8* pStart, const u8* pEnd)
 {
 	if (pStart + 3 > pEnd)
 	{
 		LOGERROR("CNetMessage: Corrupt packet (smaller than header)");
 		return NULL;
 	}
 
 	const u8* pBuffer = pStart;
 
 	int type;
 	size_t size;
 	Deserialize_int_1(pBuffer, type);
 	Deserialize_int_2(pBuffer, size);
 	m_Type = (NetMessageType)type;
 
 	if (pStart + size != pEnd)
 	{
 		LOGERROR("CNetMessage: Corrupt packet (incorrect size)");
 		return NULL;
 	}
 
 	return pBuffer;
 }
 
 size_t CNetMessage::GetSerializedLength() const
 {
 	// By default, return header size
 	return 3;
 }
 
 CStr CNetMessage::ToString() const
 {
 	// This is called only when the subclass doesn't override it
 
 	if (GetType() == NMT_INVALID)
 		return "MESSAGE_TYPE_NONE { Undefined Message }";
 	else
 		return "Unknown Message " + CStr::FromInt(GetType());
 }
 
 CNetMessage* CNetMessageFactory::CreateMessage(const void* pData,
 											   size_t dataSize,
 											   ScriptInterface& scriptInterface)
 {
 	CNetMessage* pNewMessage = NULL;
 	CNetMessage header;
 
 	// Figure out message type
 	header.Deserialize((const u8*)pData, (const u8*)pData + dataSize);
 
 	switch (header.GetType())
 	{
 	case NMT_GAME_SETUP:
 		pNewMessage = new CGameSetupMessage(scriptInterface);
 		break;
 
 	case NMT_PLAYER_ASSIGNMENT:
 		pNewMessage = new CPlayerAssignmentMessage;
 		break;
 
 	case NMT_FILE_TRANSFER_REQUEST:
 		pNewMessage = new CFileTransferRequestMessage;
 		break;
 
 	case NMT_FILE_TRANSFER_RESPONSE:
 		pNewMessage = new CFileTransferResponseMessage;
 		break;
 
 	case NMT_FILE_TRANSFER_DATA:
 		pNewMessage = new CFileTransferDataMessage;
 		break;
 
 	case NMT_FILE_TRANSFER_ACK:
 		pNewMessage = new CFileTransferAckMessage;
 		break;
 
 	case NMT_JOIN_SYNC_START:
 		pNewMessage = new CJoinSyncStartMessage;
 		break;
 
 	case NMT_REJOINED:
 		pNewMessage = new CRejoinedMessage;
 		break;
 
 	case NMT_KICKED:
 		pNewMessage = new CKickedMessage;
 		break;
 
 	case NMT_CLIENT_TIMEOUT:
 		pNewMessage = new CClientTimeoutMessage;
 		break;
 
 	case NMT_CLIENT_PERFORMANCE:
 		pNewMessage = new CClientPerformanceMessage;
 		break;
 
+	case NMT_CLIENT_PAUSED:
+		pNewMessage = new CClientPausedMessage;
+		break;
+
 	case NMT_LOADED_GAME:
 		pNewMessage = new CLoadedGameMessage;
 		break;
 
 	case NMT_SERVER_HANDSHAKE:
 		pNewMessage = new CSrvHandshakeMessage;
 		break;
 
 	case NMT_SERVER_HANDSHAKE_RESPONSE:
 		pNewMessage = new CSrvHandshakeResponseMessage;
 		break;
 
 	case NMT_CLIENT_HANDSHAKE:
 		pNewMessage = new CCliHandshakeMessage;
 		break;
 
 	case NMT_AUTHENTICATE:
 		pNewMessage = new CAuthenticateMessage;
 		break;
 
 	case NMT_AUTHENTICATE_RESULT:
 		pNewMessage = new CAuthenticateResultMessage;
 		break;
 
 	case NMT_GAME_START:
 		pNewMessage = new CGameStartMessage;
 		break;
 
 	case NMT_END_COMMAND_BATCH:
 		pNewMessage = new CEndCommandBatchMessage;
 		break;
 
 	case NMT_SYNC_CHECK:
 		pNewMessage = new CSyncCheckMessage;
 		break;
 
 	case NMT_SYNC_ERROR:
 		pNewMessage = new CSyncErrorMessage;
 		break;
 
 	case NMT_CHAT:
 		pNewMessage = new CChatMessage;
 		break;
 
 	case NMT_READY:
 		pNewMessage = new CReadyMessage;
 		break;
 
 	case NMT_SIMULATION_COMMAND:
 		pNewMessage = new CSimulationMessage(scriptInterface);
 		break;
 
 	default:
 		LOGERROR("CNetMessageFactory::CreateMessage(): Unknown message type '%d' received", header.GetType());
 		break;
 	}
 
 	if (pNewMessage)
 		pNewMessage->Deserialize((const u8*)pData, (const u8*)pData + dataSize);
 
 	return pNewMessage;
 }
Index: ps/trunk/source/network/NetMessages.h
===================================================================
--- ps/trunk/source/network/NetMessages.h	(revision 18203)
+++ ps/trunk/source/network/NetMessages.h	(revision 18204)
@@ -1,224 +1,230 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /**
  * @file
  * The list of messages used by the network subsystem.
  */
 
 #ifndef NETMESSAGES_H
 #define NETMESSAGES_H
 
 #include "ps/CStr.h"
 #include "scriptinterface/ScriptVal.h"
 
 #define PS_PROTOCOL_MAGIC				0x5073013f		// 'P', 's', 0x01, '?'
 #define PS_PROTOCOL_MAGIC_RESPONSE		0x50630121		// 'P', 'c', 0x01, '!'
-#define PS_PROTOCOL_VERSION				0x01010012		// Arbitrary protocol
+#define PS_PROTOCOL_VERSION				0x01010013		// Arbitrary protocol
 #define PS_DEFAULT_PORT					0x5073			// 'P', 's'
 
 // Defines the list of message types. The order of the list must not change.
 // The message types having a negative value are used internally and not sent
 // over the network. The message types used for network communication have
 // positive values.
 enum NetMessageType
 {
 	NMT_CONNECT_COMPLETE = -256,	// Connection is complete
 	NMT_CONNECTION_LOST,
 	NMT_INVALID = 0,		// Invalid message
 	NMT_SERVER_HANDSHAKE,	// Handshake stage
 	NMT_CLIENT_HANDSHAKE,
 	NMT_SERVER_HANDSHAKE_RESPONSE,
 	NMT_AUTHENTICATE,		// Authentication stage
 	NMT_AUTHENTICATE_RESULT,
 	NMT_CHAT,		// Common chat message
 	NMT_READY,
 	NMT_GAME_SETUP,
 	NMT_PLAYER_ASSIGNMENT,
 
 	NMT_FILE_TRANSFER_REQUEST,
 	NMT_FILE_TRANSFER_RESPONSE,
 	NMT_FILE_TRANSFER_DATA,
 	NMT_FILE_TRANSFER_ACK,
 
 	NMT_JOIN_SYNC_START,
 
 	NMT_REJOINED,
 	NMT_KICKED,
 
 	NMT_CLIENT_TIMEOUT,
 	NMT_CLIENT_PERFORMANCE,
+	NMT_CLIENT_PAUSED,
 
 	NMT_LOADED_GAME,
 	NMT_GAME_START,
 	NMT_END_COMMAND_BATCH,
 	NMT_SYNC_CHECK,	// OOS-detection hash checking
 	NMT_SYNC_ERROR,	// OOS-detection error
 	NMT_SIMULATION_COMMAND,
 	NMT_LAST				// Last message in the list
 };
 
 // Authentication result codes
 enum AuthenticateResultCode
 {
 	ARC_OK,
 	ARC_OK_REJOINING,
 	ARC_PASSWORD_INVALID,
 };
 
 #endif //	NETMESSAGES_H
 
 #ifdef CREATING_NMT
 
 #define ALLNETMSGS_DONT_CREATE_NMTS
 #define START_NMT_CLASS_(_nm, _message) START_NMT_CLASS(C##_nm##Message, _message)
 #define DERIVE_NMT_CLASS_(_base, _nm, _message) START_NMT_CLASS_DERIVED(C ## _base ## Message, C ## _nm ## Message, _message)
 
 START_NMTS()
 
 START_NMT_CLASS_(SrvHandshake, NMT_SERVER_HANDSHAKE)
 	NMT_FIELD_INT(m_Magic, u32, 4)
 	NMT_FIELD_INT(m_ProtocolVersion, u32, 4)
 	NMT_FIELD_INT(m_SoftwareVersion, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(CliHandshake, NMT_CLIENT_HANDSHAKE)
 	NMT_FIELD_INT(m_MagicResponse, u32, 4)
 	NMT_FIELD_INT(m_ProtocolVersion, u32, 4)
 	NMT_FIELD_INT(m_SoftwareVersion, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(SrvHandshakeResponse, NMT_SERVER_HANDSHAKE_RESPONSE)
 	NMT_FIELD_INT(m_UseProtocolVersion, u32, 4)
 	NMT_FIELD_INT(m_Flags, u32, 4)
 	NMT_FIELD(CStrW, m_Message)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(Authenticate, NMT_AUTHENTICATE)
 	NMT_FIELD(CStr8, m_GUID)
 	NMT_FIELD(CStrW, m_Name)
 	NMT_FIELD(CStrW, m_Password)
 	NMT_FIELD_INT(m_IsLocalClient, u8, 1)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(AuthenticateResult, NMT_AUTHENTICATE_RESULT)
 	NMT_FIELD_INT(m_Code, u32, 4)
 	NMT_FIELD_INT(m_HostID, u32, 2)
 	NMT_FIELD(CStrW, m_Message)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(Chat, NMT_CHAT)
 	NMT_FIELD(CStr8, m_GUID) // ignored when client->server, valid when server->client
 	NMT_FIELD(CStrW, m_Message)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(Ready, NMT_READY)
 	NMT_FIELD(CStr8, m_GUID)
 	NMT_FIELD_INT(m_Status, u8, 1)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(PlayerAssignment, NMT_PLAYER_ASSIGNMENT)
 	NMT_START_ARRAY(m_Hosts)
 		NMT_FIELD(CStr8, m_GUID)
 		NMT_FIELD(CStrW, m_Name)
 		NMT_FIELD_INT(m_PlayerID, i8, 1)
 		NMT_FIELD_INT(m_Status, u8, 1)
 	NMT_END_ARRAY()
 END_NMT_CLASS()
 
 START_NMT_CLASS_(FileTransferRequest, NMT_FILE_TRANSFER_REQUEST)
 	NMT_FIELD_INT(m_RequestID, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(FileTransferResponse, NMT_FILE_TRANSFER_RESPONSE)
 	NMT_FIELD_INT(m_RequestID, u32, 4)
 	NMT_FIELD_INT(m_Length, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(FileTransferData, NMT_FILE_TRANSFER_DATA)
 	NMT_FIELD_INT(m_RequestID, u32, 4)
 	NMT_FIELD(CStr8, m_Data)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(FileTransferAck, NMT_FILE_TRANSFER_ACK)
 	NMT_FIELD_INT(m_RequestID, u32, 4)
 	NMT_FIELD_INT(m_NumPackets, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(JoinSyncStart, NMT_JOIN_SYNC_START)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(Rejoined, NMT_REJOINED)
 	NMT_FIELD(CStr8, m_GUID)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(Kicked, NMT_KICKED)
 	NMT_FIELD(CStrW, m_Name)
 	NMT_FIELD_INT(m_Ban, u8, 1)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(ClientTimeout, NMT_CLIENT_TIMEOUT)
 	NMT_FIELD(CStr8, m_GUID)
 	NMT_FIELD_INT(m_LastReceivedTime, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(ClientPerformance, NMT_CLIENT_PERFORMANCE)
 	NMT_START_ARRAY(m_Clients)
 		NMT_FIELD(CStr8, m_GUID)
 		NMT_FIELD_INT(m_MeanRTT, u32, 4)
 	NMT_END_ARRAY()
 END_NMT_CLASS()
 
+START_NMT_CLASS_(ClientPaused, NMT_CLIENT_PAUSED)
+	NMT_FIELD(CStr, m_GUID)
+	NMT_FIELD_INT(m_Pause, u8, 1)
+END_NMT_CLASS()
+
 START_NMT_CLASS_(LoadedGame, NMT_LOADED_GAME)
 	NMT_FIELD_INT(m_CurrentTurn, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(GameStart, NMT_GAME_START)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(EndCommandBatch, NMT_END_COMMAND_BATCH)
 	NMT_FIELD_INT(m_Turn, u32, 4)
 	NMT_FIELD_INT(m_TurnLength, u32, 2)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(SyncCheck, NMT_SYNC_CHECK)
 	NMT_FIELD_INT(m_Turn, u32, 4)
 	NMT_FIELD(CStr, m_Hash)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(SyncError, NMT_SYNC_ERROR)
 	NMT_FIELD_INT(m_Turn, u32, 4)
 	NMT_FIELD(CStr, m_HashExpected)
 	NMT_START_ARRAY(m_PlayerNames)
 		NMT_FIELD(CStrW, m_Name)
 	NMT_END_ARRAY()
 END_NMT_CLASS()
 
 END_NMTS()
 
 #else
 #ifndef ALLNETMSGS_DONT_CREATE_NMTS
 
 # ifdef ALLNETMSGS_IMPLEMENT
 #  define NMT_CREATOR_IMPLEMENT
 # endif
 
 # define NMT_CREATE_HEADER_NAME "NetMessages.h"
 # include "NMTCreator.h"
 
 #endif // #ifndef ALLNETMSGS_DONT_CREATE_NMTS
 #endif // #ifdef CREATING_NMT
Index: ps/trunk/source/network/NetServer.cpp
===================================================================
--- ps/trunk/source/network/NetServer.cpp	(revision 18203)
+++ ps/trunk/source/network/NetServer.cpp	(revision 18204)
@@ -1,1365 +1,1418 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "NetServer.h"
 
 #include "NetClient.h"
 #include "NetMessage.h"
 #include "NetSession.h"
 #include "NetStats.h"
 #include "NetTurnManager.h"
 
 #include "lib/external_libraries/enet.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "scriptinterface/ScriptRuntime.h"
 #include "simulation2/Simulation2.h"
 
 #if CONFIG2_MINIUPNPC
 #include <miniupnpc/miniwget.h>
 #include <miniupnpc/miniupnpc.h>
 #include <miniupnpc/upnpcommands.h>
 #include <miniupnpc/upnperrors.h>
 #endif
 
 /**
  * Number of peers to allocate for the enet host.
  * Limited by ENET_PROTOCOL_MAXIMUM_PEER_ID (4096).
  *
  * At most 8 players, 16 observers and 1 temporary connection to send the "server full" disconnect-reason.
  */
 #define MAX_CLIENTS 25
 
 #define	DEFAULT_SERVER_NAME			L"Unnamed Server"
 #define DEFAULT_WELCOME_MESSAGE		L"Welcome"
 
 static const int CHANNEL_COUNT = 1;
 
 /**
  * enet_host_service timeout (msecs).
  * Smaller numbers may hurt performance; larger numbers will
  * hurt latency responding to messages from game thread.
  */
 static const int HOST_SERVICE_TIMEOUT = 50;
 
 CNetServer* g_NetServer = NULL;
 
 static CStr DebugName(CNetServerSession* session)
 {
 	if (session == NULL)
 		return "[unknown host]";
 	if (session->GetGUID().empty())
 		return "[unauthed host]";
 	return "[" + session->GetGUID().substr(0, 8) + "...]";
 }
 
 /**
  * Async task for receiving the initial game state to be forwarded to another
  * client that is rejoining an in-progress network game.
  */
 class CNetFileReceiveTask_ServerRejoin : public CNetFileReceiveTask
 {
 	NONCOPYABLE(CNetFileReceiveTask_ServerRejoin);
 public:
 	CNetFileReceiveTask_ServerRejoin(CNetServerWorker& server, u32 hostID)
 		: m_Server(server), m_RejoinerHostID(hostID)
 	{
 	}
 
 	virtual void OnComplete()
 	{
 		// We've received the game state from an existing player - now
 		// we need to send it onwards to the newly rejoining player
 
 		// Find the session corresponding to the rejoining host (if any)
 		CNetServerSession* session = NULL;
 		for (CNetServerSession* serverSession : m_Server.m_Sessions)
 		{
 			if (serverSession->GetHostID() == m_RejoinerHostID)
 			{
 				session = serverSession;
 				break;
 			}
 		}
 
 		if (!session)
 		{
 			LOGMESSAGE("Net server: rejoining client disconnected before we sent to it");
 			return;
 		}
 
 		// Store the received state file, and tell the client to start downloading it from us
 		// TODO: this will get kind of confused if there's multiple clients downloading in parallel;
 		// they'll race and get whichever happens to be the latest received by the server,
 		// which should still work but isn't great
 		m_Server.m_JoinSyncFile = m_Buffer;
 		CJoinSyncStartMessage message;
 		session->SendMessage(&message);
 	}
 
 private:
 	CNetServerWorker& m_Server;
 	u32 m_RejoinerHostID;
 };
 
 /*
  * XXX: We use some non-threadsafe functions from the worker thread.
  * See http://trac.wildfiregames.com/ticket/654
  */
 
 CNetServerWorker::CNetServerWorker(int autostartPlayers) :
 	m_AutostartPlayers(autostartPlayers),
 	m_Shutdown(false),
 	m_ScriptInterface(NULL),
 	m_NextHostID(1), m_Host(NULL), m_HostGUID(), m_Stats(NULL),
 	m_LastConnectionCheck(0)
 {
 	m_State = SERVER_STATE_UNCONNECTED;
 
 	m_ServerTurnManager = NULL;
 
 	m_ServerName = DEFAULT_SERVER_NAME;
 	m_WelcomeMessage = DEFAULT_WELCOME_MESSAGE;
 }
 
 CNetServerWorker::~CNetServerWorker()
 {
 	if (m_State != SERVER_STATE_UNCONNECTED)
 	{
 		// Tell the thread to shut down
 		{
 			CScopeLock lock(m_WorkerMutex);
 			m_Shutdown = true;
 		}
 
 		// Wait for it to shut down cleanly
 		pthread_join(m_WorkerThread, NULL);
 	}
 
 	// Clean up resources
 
 	delete m_Stats;
 
 	for (CNetServerSession* session : m_Sessions)
 	{
 		session->DisconnectNow(NDR_SERVER_SHUTDOWN);
 		delete session;
 	}
 
 	if (m_Host)
 		enet_host_destroy(m_Host);
 
 	delete m_ServerTurnManager;
 }
 
 bool CNetServerWorker::SetupConnection()
 {
 	ENSURE(m_State == SERVER_STATE_UNCONNECTED);
 	ENSURE(!m_Host);
 
 	// Bind to default host
 	ENetAddress addr;
 	addr.host = ENET_HOST_ANY;
 	addr.port = PS_DEFAULT_PORT;
 
 	// Create ENet server
 	m_Host = enet_host_create(&addr, MAX_CLIENTS, CHANNEL_COUNT, 0, 0);
 	if (!m_Host)
 	{
 		LOGERROR("Net server: enet_host_create failed");
 		return false;
 	}
 
 	m_Stats = new CNetStatsTable();
 	if (CProfileViewer::IsInitialised())
 		g_ProfileViewer.AddRootTable(m_Stats);
 
 	m_State = SERVER_STATE_PREGAME;
 
 	// Launch the worker thread
 	int ret = pthread_create(&m_WorkerThread, NULL, &RunThread, this);
 	ENSURE(ret == 0);
 
 #if CONFIG2_MINIUPNPC
 	// Launch the UPnP thread
 	ret = pthread_create(&m_UPnPThread, NULL, &SetupUPnP, NULL);
 	ENSURE(ret == 0);
 #endif
 
 	return true;
 }
 
 #if CONFIG2_MINIUPNPC
 void* CNetServerWorker::SetupUPnP(void*)
 {
 	// Values we want to set.
 	char psPort[6];
 	sprintf_s(psPort, ARRAY_SIZE(psPort), "%d", PS_DEFAULT_PORT);
 	const char* leaseDuration = "0"; // Indefinite/permanent lease duration.
 	const char* description = "0AD Multiplayer";
 	const char* protocall = "UDP";
 	char internalIPAddress[64];
 	char externalIPAddress[40];
 	// Variables to hold the values that actually get set.
 	char intClient[40];
 	char intPort[6];
 	char duration[16];
 	// Intermediate variables.
 	struct UPNPUrls urls;
 	struct IGDdatas data;
 	struct UPNPDev* devlist = NULL;
 
 	// Cached root descriptor URL.
 	std::string rootDescURL;
 	CFG_GET_VAL("network.upnprootdescurl", rootDescURL);
 	if (!rootDescURL.empty())
 		LOGMESSAGE("Net server: attempting to use cached root descriptor URL: %s", rootDescURL.c_str());
 
 	int ret = 0;
 	bool allocatedUrls = false;
 
 	// Try a cached URL first
 	if (!rootDescURL.empty() && UPNP_GetIGDFromUrl(rootDescURL.c_str(), &urls, &data, internalIPAddress, sizeof(internalIPAddress)))
 	{
 		LOGMESSAGE("Net server: using cached IGD = %s", urls.controlURL);
 		ret = 1;
 	}
 	// No cached URL, or it did not respond. Try getting a valid UPnP device for 10 seconds.
 #if defined(MINIUPNPC_API_VERSION) && MINIUPNPC_API_VERSION >= 14
 	else if ((devlist = upnpDiscover(10000, 0, 0, 0, 0, 2, 0)) != NULL)
 #else
 	else if ((devlist = upnpDiscover(10000, 0, 0, 0, 0, 0)) != NULL)
 #endif
 	{
 		ret = UPNP_GetValidIGD(devlist, &urls, &data, internalIPAddress, sizeof(internalIPAddress));
 		allocatedUrls = ret != 0; // urls is allocated on non-zero return values
 	}
 	else
 	{
 		LOGMESSAGE("Net server: upnpDiscover failed and no working cached URL.");
 		return NULL;
 	}
 
 	switch (ret)
 	{
 	case 0:
 		LOGMESSAGE("Net server: No IGD found");
 		break;
 	case 1:
 		LOGMESSAGE("Net server: found valid IGD = %s", urls.controlURL);
 		break;
 	case 2:
 		LOGMESSAGE("Net server: found a valid, not connected IGD = %s, will try to continue anyway", urls.controlURL);
 		break;
 	case 3:
 		LOGMESSAGE("Net server: found a UPnP device unrecognized as IGD = %s, will try to continue anyway", urls.controlURL);
 		break;
 	default:
 		debug_warn(L"Unrecognized return value from UPNP_GetValidIGD");
 	}
 
 	// Try getting our external/internet facing IP. TODO: Display this on the game-setup page for conviniance.
 	ret = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
 	if (ret != UPNPCOMMAND_SUCCESS)
 	{
 		LOGMESSAGE("Net server: GetExternalIPAddress failed with code %d (%s)", ret, strupnperror(ret));
 		return NULL;
 	}
 	LOGMESSAGE("Net server: ExternalIPAddress = %s", externalIPAddress);
 
 	// Try to setup port forwarding.
 	ret = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype, psPort, psPort,
 							internalIPAddress, description, protocall, 0, leaseDuration);
 	if (ret != UPNPCOMMAND_SUCCESS)
 	{
 		LOGMESSAGE("Net server: AddPortMapping(%s, %s, %s) failed with code %d (%s)",
 			   psPort, psPort, internalIPAddress, ret, strupnperror(ret));
 		return NULL;
 	}
 
 	// Check that the port was actually forwarded.
 	ret = UPNP_GetSpecificPortMappingEntry(urls.controlURL,
 									 data.first.servicetype,
 									 psPort, protocall,
 #if defined(MINIUPNPC_API_VERSION) && MINIUPNPC_API_VERSION >= 10
 									 NULL/*remoteHost*/,
 #endif
 									 intClient, intPort, NULL/*desc*/,
 									 NULL/*enabled*/, duration);
 
 	if (ret != UPNPCOMMAND_SUCCESS)
 	{
 		LOGMESSAGE("Net server: GetSpecificPortMappingEntry() failed with code %d (%s)", ret, strupnperror(ret));
 		return NULL;
 	}
 
 	LOGMESSAGE("Net server: External %s:%s %s is redirected to internal %s:%s (duration=%s)",
 				   externalIPAddress, psPort, protocall, intClient, intPort, duration);
 
 	// Cache root descriptor URL to try to avoid discovery next time.
 	g_ConfigDB.SetValueString(CFG_USER, "network.upnprootdescurl", urls.controlURL);
 	g_ConfigDB.WriteValueToFile(CFG_USER, "network.upnprootdescurl", urls.controlURL);
 	LOGMESSAGE("Net server: cached UPnP root descriptor URL as %s", urls.controlURL);
 
 	// Make sure everything is properly freed.
 	if (allocatedUrls)
 		FreeUPNPUrls(&urls);
 
 	freeUPNPDevlist(devlist);
 
 	return NULL;
 }
 #endif // CONFIG2_MINIUPNPC
 
 bool CNetServerWorker::SendMessage(ENetPeer* peer, const CNetMessage* message)
 {
 	ENSURE(m_Host);
 
 	CNetServerSession* session = static_cast<CNetServerSession*>(peer->data);
 
 	return CNetHost::SendMessage(message, peer, DebugName(session).c_str());
 }
 
 bool CNetServerWorker::Broadcast(const CNetMessage* message)
 {
 	ENSURE(m_Host);
 
 	bool ok = true;
 
 	// Send to all sessions that are active and has finished authentication
 	// TODO: this does lots of repeated message serialisation if we have lots
 	// of remote peers; could do it more efficiently if that's a real problem
 	for (CNetServerSession* session : m_Sessions)
 		if (session->GetCurrState() == NSS_PREGAME || session->GetCurrState() == NSS_INGAME)
 			if (!session->SendMessage(message))
 				ok = false;
 
 	return ok;
 }
 
 void* CNetServerWorker::RunThread(void* data)
 {
 	debug_SetThreadName("NetServer");
 
 	static_cast<CNetServerWorker*>(data)->Run();
 
 	return NULL;
 }
 
 void CNetServerWorker::Run()
 {
 	// The script runtime uses the profiler and therefore the thread must be registered before the runtime is created
 	g_Profiler2.RegisterCurrentThread("Net server");
 
 	// To avoid the need for JS_SetContextThread, we create and use and destroy
 	// the script interface entirely within this network thread
 	m_ScriptInterface = new ScriptInterface("Engine", "Net server", ScriptInterface::CreateRuntime(g_ScriptRuntime));
 	m_GameAttributes.set(m_ScriptInterface->GetJSRuntime(), JS::UndefinedValue());
 
 	while (true)
 	{
 		if (!RunStep())
 			break;
 
 		// Implement autostart mode
 		if (m_State == SERVER_STATE_PREGAME && (int)m_PlayerAssignments.size() == m_AutostartPlayers)
 			StartGame();
 
 		// Update profiler stats
 		m_Stats->LatchHostState(m_Host);
 	}
 
 	// Clear roots before deleting their context
 	m_GameAttributes.clear();
 	m_SavedCommands.clear();
 
 	SAFE_DELETE(m_ScriptInterface);
 }
 
 bool CNetServerWorker::RunStep()
 {
 	// Check for messages from the game thread.
 	// (Do as little work as possible while the mutex is held open,
 	// to avoid performance problems and deadlocks.)
 
 	m_ScriptInterface->GetRuntime()->MaybeIncrementalGC(0.5f);
 
 	JSContext* cx = m_ScriptInterface->GetContext();
 	JSAutoRequest rq(cx);
 
 	std::vector<std::pair<int, CStr>> newAssignPlayer;
 	std::vector<bool> newStartGame;
 	std::vector<std::pair<CStr, int>> newPlayerReady;
 	std::vector<bool> newPlayerResetReady;
 	std::vector<std::string> newGameAttributes;
 	std::vector<u32> newTurnLength;
 
 	{
 		CScopeLock lock(m_WorkerMutex);
 
 		if (m_Shutdown)
 			return false;
 
 		newStartGame.swap(m_StartGameQueue);
 		newPlayerReady.swap(m_PlayerReadyQueue);
 		newPlayerResetReady.swap(m_PlayerResetReadyQueue);
 		newAssignPlayer.swap(m_AssignPlayerQueue);
 		newGameAttributes.swap(m_GameAttributesQueue);
 		newTurnLength.swap(m_TurnLengthQueue);
 	}
 
 	for (const std::pair<int, CStr8>& p : newAssignPlayer)
 		AssignPlayer(p.first, p.second);
 
 	for (const std::pair<CStr8, int>& p : newPlayerReady)
 		SetPlayerReady(p.first, p.second);
 
 	if (!newPlayerResetReady.empty())
 		ClearAllPlayerReady();
 
 	if (!newGameAttributes.empty())
 	{
 		JS::RootedValue gameAttributesVal(cx);
 		GetScriptInterface().ParseJSON(newGameAttributes.back(), &gameAttributesVal);
 		UpdateGameAttributes(&gameAttributesVal);
 	}
 
 	if (!newTurnLength.empty())
 		SetTurnLength(newTurnLength.back());
 
 	// Do StartGame last, so we have the most up-to-date game attributes when we start
 	if (!newStartGame.empty())
 		StartGame();
 
 	// Perform file transfers
 	for (CNetServerSession* session : m_Sessions)
 		session->GetFileTransferer().Poll();
 
 	CheckClientConnections();
 
 	// Process network events:
 
 	ENetEvent event;
 	int status = enet_host_service(m_Host, &event, HOST_SERVICE_TIMEOUT);
 	if (status < 0)
 	{
 		LOGERROR("CNetServerWorker: enet_host_service failed (%d)", status);
 		// TODO: notify game that the server has shut down
 		return false;
 	}
 
 	if (status == 0)
 	{
 		// Reached timeout with no events - try again
 		return true;
 	}
 
 	// Process the event:
 
 	switch (event.type)
 	{
 	case ENET_EVENT_TYPE_CONNECT:
 	{
 		// Report the client address
 		char hostname[256] = "(error)";
 		enet_address_get_host_ip(&event.peer->address, hostname, ARRAY_SIZE(hostname));
 		LOGMESSAGE("Net server: Received connection from %s:%u", hostname, (unsigned int)event.peer->address.port);
 
 		// Set up a session object for this peer
 
 		CNetServerSession* session = new CNetServerSession(*this, event.peer);
 
 		m_Sessions.push_back(session);
 
 		SetupSession(session);
 
 		ENSURE(event.peer->data == NULL);
 		event.peer->data = session;
 
 		HandleConnect(session);
 
 		break;
 	}
 
 	case ENET_EVENT_TYPE_DISCONNECT:
 	{
 		// If there is an active session with this peer, then reset and delete it
 
 		CNetServerSession* session = static_cast<CNetServerSession*>(event.peer->data);
 		if (session)
 		{
 			LOGMESSAGE("Net server: Disconnected %s", DebugName(session).c_str());
 
 			// Remove the session first, so we won't send player-update messages to it
 			// when updating the FSM
 			m_Sessions.erase(remove(m_Sessions.begin(), m_Sessions.end(), session), m_Sessions.end());
 
 			session->Update((uint)NMT_CONNECTION_LOST, NULL);
 
 			delete session;
 			event.peer->data = NULL;
 		}
 
 		break;
 	}
 
 	case ENET_EVENT_TYPE_RECEIVE:
 	{
 		// If there is an active session with this peer, then process the message
 
 		CNetServerSession* session = static_cast<CNetServerSession*>(event.peer->data);
 		if (session)
 		{
 			// Create message from raw data
 			CNetMessage* msg = CNetMessageFactory::CreateMessage(event.packet->data, event.packet->dataLength, GetScriptInterface());
 			if (msg)
 			{
 				LOGMESSAGE("Net server: Received message %s of size %lu from %s", msg->ToString().c_str(), (unsigned long)msg->GetSerializedLength(), DebugName(session).c_str());
 
 				HandleMessageReceive(msg, session);
 
 				delete msg;
 			}
 		}
 
 		// Done using the packet
 		enet_packet_destroy(event.packet);
 
 		break;
 	}
 
 	case ENET_EVENT_TYPE_NONE:
 		break;
 	}
 
 	return true;
 }
 
 void CNetServerWorker::CheckClientConnections()
 {
 	if (m_State == SERVER_STATE_LOADING)
 		return;
 
 	// Send messages at most once per second
 	std::time_t now = std::time(nullptr);
 	if (now <= m_LastConnectionCheck)
 		return;
 
 	m_LastConnectionCheck = now;
 
 	for (size_t i = 0; i < m_Sessions.size(); ++i)
 	{
 		u32 lastReceived = m_Sessions[i]->GetLastReceivedTime();
 		u32 meanRTT = m_Sessions[i]->GetMeanRTT();
 
 		CNetMessage* message = nullptr;
 
 		// Report if we didn't hear from the client since few seconds
 		if (lastReceived > NETWORK_WARNING_TIMEOUT)
 		{
 			CClientTimeoutMessage* msg = new CClientTimeoutMessage();
 			msg->m_GUID = m_Sessions[i]->GetGUID();
 			msg->m_LastReceivedTime = lastReceived;
 			message = msg;
 		}
 		// Report if the client has bad ping
 		else if (meanRTT > DEFAULT_TURN_LENGTH_MP)
 		{
 			CClientPerformanceMessage* msg = new CClientPerformanceMessage();
 			CClientPerformanceMessage::S_m_Clients client;
 			client.m_GUID = m_Sessions[i]->GetGUID();
 			client.m_MeanRTT = meanRTT;
 			msg->m_Clients.push_back(client);
 			message = msg;
 		}
 
 		// Send to all clients except the affected one
 		// (since that will show the locally triggered warning instead)
 		if (message)
 			for (size_t j = 0; j < m_Sessions.size(); ++j)
 			{
 				if (i != j && (
 				    m_Sessions[j]->GetCurrState() == NSS_PREGAME ||
 				    m_Sessions[j]->GetCurrState() == NSS_INGAME))
 				{
 					m_Sessions[j]->SendMessage(message);
 				}
 			}
 
 		SAFE_DELETE(message);
 	}
 }
 
 void CNetServerWorker::HandleMessageReceive(const CNetMessage* message, CNetServerSession* session)
 {
 	// Handle non-FSM messages first
 	Status status = session->GetFileTransferer().HandleMessageReceive(message);
 	if (status != INFO::SKIPPED)
 		return;
 
 	if (message->GetType() == NMT_FILE_TRANSFER_REQUEST)
 	{
 		CFileTransferRequestMessage* reqMessage = (CFileTransferRequestMessage*)message;
 
 		// Rejoining client got our JoinSyncStart after we received the state from
 		// another client, and has now requested that we forward it to them
 
 		ENSURE(!m_JoinSyncFile.empty());
 		session->GetFileTransferer().StartResponse(reqMessage->m_RequestID, m_JoinSyncFile);
 
 		return;
 	}
 
 	// Update FSM
 	if (!session->Update(message->GetType(), (void*)message))
 		LOGERROR("Net server: Error running FSM update (type=%d state=%d)", (int)message->GetType(), (int)session->GetCurrState());
 }
 
 void CNetServerWorker::SetupSession(CNetServerSession* session)
 {
 	void* context = session;
 
 	// Set up transitions for session
 
 	session->AddTransition(NSS_UNCONNECTED, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED);
 
 	session->AddTransition(NSS_HANDSHAKE, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED);
 	session->AddTransition(NSS_HANDSHAKE, (uint)NMT_CLIENT_HANDSHAKE, NSS_AUTHENTICATE, (void*)&OnClientHandshake, context);
 
 	session->AddTransition(NSS_AUTHENTICATE, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED);
 	session->AddTransition(NSS_AUTHENTICATE, (uint)NMT_AUTHENTICATE, NSS_PREGAME, (void*)&OnAuthenticate, context);
 
 	session->AddTransition(NSS_PREGAME, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
 	session->AddTransition(NSS_PREGAME, (uint)NMT_CHAT, NSS_PREGAME, (void*)&OnChat, context);
 	session->AddTransition(NSS_PREGAME, (uint)NMT_READY, NSS_PREGAME, (void*)&OnReady, context);
 	session->AddTransition(NSS_PREGAME, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnLoadedGame, context);
 
 	session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
 	session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnJoinSyncingLoadedGame, context);
 
 	session->AddTransition(NSS_INGAME, (uint)NMT_REJOINED, NSS_INGAME, (void*)&OnRejoined, context);
+	session->AddTransition(NSS_INGAME, (uint)NMT_CLIENT_PAUSED, NSS_INGAME, (void*)&OnClientPaused, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_CHAT, NSS_INGAME, (void*)&OnChat, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_SIMULATION_COMMAND, NSS_INGAME, (void*)&OnInGame, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_SYNC_CHECK, NSS_INGAME, (void*)&OnInGame, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_END_COMMAND_BATCH, NSS_INGAME, (void*)&OnInGame, context);
 
 	// Set first state
 	session->SetFirstState(NSS_HANDSHAKE);
 }
 
 bool CNetServerWorker::HandleConnect(CNetServerSession* session)
 {
 	if (std::find(m_BannedIPs.begin(), m_BannedIPs.end(), session->GetIPAddress()) != m_BannedIPs.end())
 	{
 		session->Disconnect(NDR_BANNED);
 		return false;
 	}
 
 	CSrvHandshakeMessage handshake;
 	handshake.m_Magic = PS_PROTOCOL_MAGIC;
 	handshake.m_ProtocolVersion = PS_PROTOCOL_VERSION;
 	handshake.m_SoftwareVersion = PS_PROTOCOL_VERSION;
 	return session->SendMessage(&handshake);
 }
 
 void CNetServerWorker::OnUserJoin(CNetServerSession* session)
 {
 	AddPlayer(session->GetGUID(), session->GetUserName());
 
 	if (m_HostGUID.empty() && session->IsLocalClient())
 		m_HostGUID = session->GetGUID();
 
 	CGameSetupMessage gameSetupMessage(GetScriptInterface());
 	gameSetupMessage.m_Data = m_GameAttributes.get();
 	session->SendMessage(&gameSetupMessage);
 
 	CPlayerAssignmentMessage assignMessage;
 	ConstructPlayerAssignmentMessage(assignMessage);
 	session->SendMessage(&assignMessage);
 }
 
 void CNetServerWorker::OnUserLeave(CNetServerSession* session)
 {
+	std::vector<CStr>::iterator pausing = std::find(m_PausingPlayers.begin(), m_PausingPlayers.end(), session->GetGUID());
+	if (pausing != m_PausingPlayers.end())
+		m_PausingPlayers.erase(pausing);
+
 	RemovePlayer(session->GetGUID());
 
 	if (m_ServerTurnManager && session->GetCurrState() != NSS_JOIN_SYNCING)
 		m_ServerTurnManager->UninitialiseClient(session->GetHostID()); // TODO: only for non-observers
 
 	// TODO: ought to switch the player controlled by that client
 	// back to AI control, or something?
 }
 
 void CNetServerWorker::AddPlayer(const CStr& guid, const CStrW& name)
 {
 	// Find all player IDs in active use; we mustn't give them to a second player (excluding the unassigned ID: -1)
 	std::set<i32> usedIDs;
 	for (const std::pair<CStr, PlayerAssignment>& p : m_PlayerAssignments)
 		if (p.second.m_Enabled && p.second.m_PlayerID != -1)
 			usedIDs.insert(p.second.m_PlayerID);
 
 	// If the player is rejoining after disconnecting, try to give them
 	// back their old player ID
 
 	i32 playerID = -1;
 
 	// Try to match GUID first
 	for (PlayerAssignmentMap::iterator it = m_PlayerAssignments.begin(); it != m_PlayerAssignments.end(); ++it)
 	{
 		if (!it->second.m_Enabled && it->first == guid && usedIDs.find(it->second.m_PlayerID) == usedIDs.end())
 		{
 			playerID = it->second.m_PlayerID;
 			m_PlayerAssignments.erase(it); // delete the old mapping, since we've got a new one now
 			goto found;
 		}
 	}
 
 	// Try to match username next
 	for (PlayerAssignmentMap::iterator it = m_PlayerAssignments.begin(); it != m_PlayerAssignments.end(); ++it)
 	{
 		if (!it->second.m_Enabled && it->second.m_Name == name && usedIDs.find(it->second.m_PlayerID) == usedIDs.end())
 		{
 			playerID = it->second.m_PlayerID;
 			m_PlayerAssignments.erase(it); // delete the old mapping, since we've got a new one now
 			goto found;
 		}
 	}
 
 	// Otherwise leave the player ID as -1 (observer) and let gamesetup change it as needed.
 
 found:
 	PlayerAssignment assignment;
 	assignment.m_Enabled = true;
 	assignment.m_Name = name;
 	assignment.m_PlayerID = playerID;
 	assignment.m_Status = 0;
 	m_PlayerAssignments[guid] = assignment;
 
 	// Send the new assignments to all currently active players
 	// (which does not include the one that's just joining)
 	SendPlayerAssignments();
 }
 
 void CNetServerWorker::RemovePlayer(const CStr& guid)
 {
 	m_PlayerAssignments[guid].m_Enabled = false;
 
 	SendPlayerAssignments();
 }
 
 void CNetServerWorker::SetPlayerReady(const CStr& guid, const int ready)
 {
 	m_PlayerAssignments[guid].m_Status = ready;
 
 	SendPlayerAssignments();
 }
 
 void CNetServerWorker::ClearAllPlayerReady()
 {
 	for (PlayerAssignmentMap::iterator it = m_PlayerAssignments.begin(); it != m_PlayerAssignments.end(); ++it)
 		it->second.m_Status = 0;
 
 	SendPlayerAssignments();
 }
 
 bool CNetServerWorker::KickPlayer(const CStrW& playerName, const bool ban)
 {
 	// Find the user with that name
 	std::vector<CNetServerSession*>::iterator it = std::find_if(m_Sessions.begin(), m_Sessions.end(),
 		[&](CNetServerSession* session) { return session->GetUserName() == playerName; });
 
 	// and return if no one or the host has that name
 	if (it == m_Sessions.end() || (*it)->GetGUID() == m_HostGUID)
 		return false;
 
 	if (ban)
 	{
 		// Remember name
 		if (std::find(m_BannedPlayers.begin(), m_BannedPlayers.end(), playerName) == m_BannedPlayers.end())
 			m_BannedPlayers.push_back(playerName);
 
 		// Remember IP address
 		u32 ipAddress = (*it)->GetIPAddress();
 		if (std::find(m_BannedIPs.begin(), m_BannedIPs.end(), ipAddress) == m_BannedIPs.end())
 			m_BannedIPs.push_back(ipAddress);
 	}
 
 	// Disconnect that user
 	(*it)->Disconnect(ban ? NDR_BANNED : NDR_KICKED);
 
 	// Send message notifying other clients
 	CKickedMessage kickedMessage;
 	kickedMessage.m_Name = playerName;
 	kickedMessage.m_Ban = ban;
 	Broadcast(&kickedMessage);
 
 	return true;
 }
 
 void CNetServerWorker::AssignPlayer(int playerID, const CStr& guid)
 {
 	// Remove anyone who's already assigned to this player
 	for (std::pair<const CStr, PlayerAssignment>& p : m_PlayerAssignments)
 	{
 		if (p.second.m_PlayerID == playerID)
 			p.second.m_PlayerID = -1;
 	}
 
 	// Update this host's assignment if it exists
 	if (m_PlayerAssignments.find(guid) != m_PlayerAssignments.end())
 		m_PlayerAssignments[guid].m_PlayerID = playerID;
 
 	SendPlayerAssignments();
 }
 
 void CNetServerWorker::ConstructPlayerAssignmentMessage(CPlayerAssignmentMessage& message)
 {
 	for (const std::pair<CStr, PlayerAssignment>& p : m_PlayerAssignments)
 	{
 		if (!p.second.m_Enabled)
 			continue;
 
 		CPlayerAssignmentMessage::S_m_Hosts h;
 		h.m_GUID = p.first;
 		h.m_Name = p.second.m_Name;
 		h.m_PlayerID = p.second.m_PlayerID;
 		h.m_Status = p.second.m_Status;
 		message.m_Hosts.push_back(h);
 	}
 }
 
 void CNetServerWorker::SendPlayerAssignments()
 {
 	CPlayerAssignmentMessage message;
 	ConstructPlayerAssignmentMessage(message);
 	Broadcast(&message);
 }
 
 ScriptInterface& CNetServerWorker::GetScriptInterface()
 {
 	return *m_ScriptInterface;
 }
 
 void CNetServerWorker::SetTurnLength(u32 msecs)
 {
 	if (m_ServerTurnManager)
 		m_ServerTurnManager->SetTurnLength(msecs);
 }
 
 bool CNetServerWorker::OnClientHandshake(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_CLIENT_HANDSHAKE);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	CCliHandshakeMessage* message = (CCliHandshakeMessage*)event->GetParamRef();
 	if (message->m_ProtocolVersion != PS_PROTOCOL_VERSION)
 	{
 		session->Disconnect(NDR_INCORRECT_PROTOCOL_VERSION);
 		return false;
 	}
 
 	CSrvHandshakeResponseMessage handshakeResponse;
 	handshakeResponse.m_UseProtocolVersion = PS_PROTOCOL_VERSION;
 	handshakeResponse.m_Message = server.m_WelcomeMessage;
 	handshakeResponse.m_Flags = 0;
 	session->SendMessage(&handshakeResponse);
 
 	return true;
 }
 
 bool CNetServerWorker::OnAuthenticate(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_AUTHENTICATE);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	// Prohibit joins while the game is loading
 	if (server.m_State == SERVER_STATE_LOADING)
 	{
 		LOGMESSAGE("Refused connection while the game is loading");
 		session->Disconnect(NDR_SERVER_LOADING);
 		return true;
 	}
 
 	CAuthenticateMessage* message = (CAuthenticateMessage*)event->GetParamRef();
 	CStrW username = SanitisePlayerName(message->m_Name);
 
 	// Either deduplicate or prohibit join if name is in use
 	bool duplicatePlayernames = false;
 	CFG_GET_VAL("network.duplicateplayernames", duplicatePlayernames);
 	if (duplicatePlayernames)
 		username = server.DeduplicatePlayerName(username);
 	else if (std::find_if(
 			server.m_Sessions.begin(), server.m_Sessions.end(),
 			[&username] (const CNetServerSession* session)
 			{ return session->GetUserName() == username; })
 		!= server.m_Sessions.end())
 	{
 		session->Disconnect(NDR_PLAYERNAME_IN_USE);
 		return true;
 	}
 
 	// Disconnect banned usernames
 	if (std::find(server.m_BannedPlayers.begin(), server.m_BannedPlayers.end(), username) != server.m_BannedPlayers.end())
 	{
 		session->Disconnect(NDR_BANNED);
 		return true;
 	}
 
 	// Optionally allow observers to join after the game has started
 	bool observerLateJoin = false;
 	CFG_GET_VAL("network.lateobserverjoins", observerLateJoin);
 
 	int maxObservers = 0;
 	CFG_GET_VAL("network.observerlimit", maxObservers);
 
 	bool isRejoining = false;
 	bool serverFull = false;
 	if (server.m_State == SERVER_STATE_PREGAME)
 	{
 		// Don't check for maxObservers in the gamesetup, as we don't know yet who will be assigned
 		serverFull = server.m_Sessions.size() >= MAX_CLIENTS;
 	}
 	else
 	{
 		isRejoining = observerLateJoin;
 		bool isObserver = true;
 		int disconnectedPlayers = 0;
 		int connectedPlayers = 0;
 		// (TODO: if GUIDs were stable, we should use them instead)
 		for (const std::pair<CStr, PlayerAssignment>& p : server.m_PlayerAssignments)
 		{
 			const PlayerAssignment& assignment = p.second;
 
 			if (!assignment.m_Enabled && assignment.m_Name == username)
 			{
 				isObserver = assignment.m_PlayerID == -1;
 				isRejoining = true;
 			}
 
 			if (assignment.m_PlayerID == -1)
 				continue;
 
 			if (assignment.m_Enabled)
 				++connectedPlayers;
 			else
 				++disconnectedPlayers;
 		}
 
 		// Players who weren't already in the game are not allowed to join now that it's started
 		if (!isRejoining)
 		{
 			LOGMESSAGE("Refused connection after game start from not-previously-known user \"%s\"", utf8_from_wstring(username));
 			session->Disconnect(NDR_SERVER_ALREADY_IN_GAME);
 			return true;
 		}
 
 		// Ensure all players will be able to rejoin
 		serverFull = isObserver && (
 			(int) server.m_Sessions.size() - connectedPlayers > maxObservers ||
 			(int) server.m_Sessions.size() + disconnectedPlayers >= MAX_CLIENTS);
 	}
 
 	if (serverFull)
 	{
 		session->Disconnect(NDR_SERVER_FULL);
 		return true;
 	}
 
 	// TODO: check server password etc?
 
 	u32 newHostID = server.m_NextHostID++;
 
 	session->SetUserName(username);
 	session->SetGUID(message->m_GUID);
 	session->SetHostID(newHostID);
 	session->SetLocalClient(message->m_IsLocalClient);
 
 	CAuthenticateResultMessage authenticateResult;
 	authenticateResult.m_Code = isRejoining ? ARC_OK_REJOINING : ARC_OK;
 	authenticateResult.m_HostID = newHostID;
 	authenticateResult.m_Message = L"Logged in";
 	session->SendMessage(&authenticateResult);
 
 	server.OnUserJoin(session);
 
 	if (isRejoining)
 	{
 		// Request a copy of the current game state from an existing player,
 		// so we can send it on to the new player
 
 		// Assume session 0 is most likely the local player, so they're
 		// the most efficient client to request a copy from
 		CNetServerSession* sourceSession = server.m_Sessions.at(0);
 		sourceSession->GetFileTransferer().StartTask(
 			shared_ptr<CNetFileReceiveTask>(new CNetFileReceiveTask_ServerRejoin(server, newHostID))
 		);
 
 		session->SetNextState(NSS_JOIN_SYNCING);
 	}
 
 	return true;
 }
 
 bool CNetServerWorker::OnInGame(void* context, CFsmEvent* event)
 {
 	// TODO: should split each of these cases into a separate method
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	CNetMessage* message = (CNetMessage*)event->GetParamRef();
 	if (message->GetType() == (uint)NMT_SIMULATION_COMMAND)
 	{
 		CSimulationMessage* simMessage = static_cast<CSimulationMessage*> (message);
 
 		// Ignore messages sent by one player on behalf of another player
 		// unless cheating is enabled
 		bool cheatsEnabled = false;
 		ScriptInterface& scriptInterface = server.GetScriptInterface();
 		JSContext* cx = scriptInterface.GetContext();
 		JSAutoRequest rq(cx);
 		JS::RootedValue settings(cx);
 		scriptInterface.GetProperty(server.m_GameAttributes.get(), "settings", &settings);
 		if (scriptInterface.HasProperty(settings, "CheatsEnabled"))
 			scriptInterface.GetProperty(settings, "CheatsEnabled", cheatsEnabled);
 
 		PlayerAssignmentMap::iterator it = server.m_PlayerAssignments.find(session->GetGUID());
 		// When cheating is disabled, fail if the player the message claims to
 		// represent does not exist or does not match the sender's player name
 		if (!cheatsEnabled && (it == server.m_PlayerAssignments.end() || it->second.m_PlayerID != simMessage->m_Player))
 			return true;
 
 		// Send it back to all clients immediately
 		server.Broadcast(simMessage);
 
 		// Save all the received commands
 		if (server.m_SavedCommands.size() < simMessage->m_Turn + 1)
 			server.m_SavedCommands.resize(simMessage->m_Turn + 1);
 		server.m_SavedCommands[simMessage->m_Turn].push_back(*simMessage);
 
 		// TODO: we shouldn't send the message back to the client that first sent it
 	}
 	else if (message->GetType() == (uint)NMT_SYNC_CHECK)
 	{
 		CSyncCheckMessage* syncMessage = static_cast<CSyncCheckMessage*> (message);
 		server.m_ServerTurnManager->NotifyFinishedClientUpdate(session->GetHostID(), session->GetUserName(), syncMessage->m_Turn, syncMessage->m_Hash);
 	}
 	else if (message->GetType() == (uint)NMT_END_COMMAND_BATCH)
 	{
 		CEndCommandBatchMessage* endMessage = static_cast<CEndCommandBatchMessage*> (message);
 		server.m_ServerTurnManager->NotifyFinishedClientCommands(session->GetHostID(), endMessage->m_Turn);
 	}
 
 	return true;
 }
 
 bool CNetServerWorker::OnChat(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_CHAT);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	CChatMessage* message = (CChatMessage*)event->GetParamRef();
 
 	message->m_GUID = session->GetGUID();
 
 	server.Broadcast(message);
 
 	return true;
 }
 
 bool CNetServerWorker::OnReady(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_READY);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	CReadyMessage* message = (CReadyMessage*)event->GetParamRef();
 
 	message->m_GUID = session->GetGUID();
 
 	server.Broadcast(message);
 
 	return true;
 }
 
 bool CNetServerWorker::OnLoadedGame(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	// We're in the loading state, so wait until every player has loaded before
 	// starting the game
 	ENSURE(server.m_State == SERVER_STATE_LOADING);
 	server.CheckGameLoadStatus(session);
 
 	return true;
 }
 
 bool CNetServerWorker::OnJoinSyncingLoadedGame(void* context, CFsmEvent* event)
 {
 	// A client rejoining an in-progress game has now finished loading the
 	// map and deserialized the initial state.
 	// The simulation may have progressed since then, so send any subsequent
 	// commands to them and set them as an active player so they can participate
 	// in all future turns.
 	//
 	// (TODO: if it takes a long time for them to receive and execute all these
 	// commands, the other players will get frozen for that time and may be unhappy;
 	// we could try repeating this process a few times until the client converges
 	// on the up-to-date state, before setting them as active.)
 
 	ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	CLoadedGameMessage* message = (CLoadedGameMessage*)event->GetParamRef();
 
 	u32 turn = message->m_CurrentTurn;
 	u32 readyTurn = server.m_ServerTurnManager->GetReadyTurn();
 
 	// Send them all commands received since their saved state,
 	// and turn-ended messages for any turns that have already been processed
 	for (size_t i = turn + 1; i < std::max(readyTurn+1, (u32)server.m_SavedCommands.size()); ++i)
 	{
 		if (i < server.m_SavedCommands.size())
 			for (size_t j = 0; j < server.m_SavedCommands[i].size(); ++j)
 				session->SendMessage(&server.m_SavedCommands[i][j]);
 
 		if (i <= readyTurn)
 		{
 			CEndCommandBatchMessage endMessage;
 			endMessage.m_Turn = i;
 			endMessage.m_TurnLength = server.m_ServerTurnManager->GetSavedTurnLength(i);
 			session->SendMessage(&endMessage);
 		}
 	}
 
 	// Tell the turn manager to expect commands from this new client
 	server.m_ServerTurnManager->InitialiseClient(session->GetHostID(), readyTurn);
 
 	// Tell the client that everything has finished loading and it should start now
 	CLoadedGameMessage loaded;
 	loaded.m_CurrentTurn = readyTurn;
 	session->SendMessage(&loaded);
 
 	return true;
 }
 
 bool CNetServerWorker::OnRejoined(void* context, CFsmEvent* event)
 {
 	// A client has finished rejoining and the loading screen disappeared.
 	ENSURE(event->GetType() == (uint)NMT_REJOINED);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	CRejoinedMessage* message = (CRejoinedMessage*)event->GetParamRef();
 
 	message->m_GUID = session->GetGUID();
 
 	server.Broadcast(message);
 
+	// Send all pausing players to the rejoined client.
+	for (const CStr& guid : server.m_PausingPlayers)
+	{
+		CClientPausedMessage pausedMessage;
+		pausedMessage.m_GUID = guid;
+		pausedMessage.m_Pause = true;
+		session->SendMessage(&pausedMessage);
+	}
+
 	return true;
 }
 
 bool CNetServerWorker::OnDisconnect(void* context, CFsmEvent* event)
 {
 	ENSURE(event->GetType() == (uint)NMT_CONNECTION_LOST);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
 	server.OnUserLeave(session);
 
 	return true;
 }
 
+bool CNetServerWorker::OnClientPaused(void *context, CFsmEvent *event)
+{
+	ENSURE(event->GetType() == (uint)NMT_CLIENT_PAUSED);
+
+	CNetServerSession* session = (CNetServerSession*)context;
+	CNetServerWorker& server = session->GetServer();
+
+	CClientPausedMessage* message = (CClientPausedMessage*)event->GetParamRef();
+
+	message->m_GUID = session->GetGUID();
+
+	// Update the list of pausing players.
+	std::vector<CStr>::iterator player = std::find(server.m_PausingPlayers.begin(), server.m_PausingPlayers.end(), session->GetGUID());
+
+	if (message->m_Pause)
+	{
+		if (player != server.m_PausingPlayers.end())
+			return true;
+
+		server.m_PausingPlayers.push_back(session->GetGUID());
+	}
+	else
+	{
+		if (player == server.m_PausingPlayers.end())
+			return true;
+
+		server.m_PausingPlayers.erase(player);
+	}
+
+	// Send messages to clients that are in game, and are not the client who paused.
+	for (CNetServerSession* session : server.m_Sessions)
+	{
+		if (session->GetCurrState() == NSS_INGAME && message->m_GUID != session->GetGUID())
+			session->SendMessage(message);
+	}
+
+	return true;
+}
+
 void CNetServerWorker::CheckGameLoadStatus(CNetServerSession* changedSession)
 {
 	for (const CNetServerSession* session : m_Sessions)
 	{
 		if (session != changedSession && session->GetCurrState() != NSS_INGAME)
 			return;
 	}
 
 	CLoadedGameMessage loaded;
 	loaded.m_CurrentTurn = 0;
 	Broadcast(&loaded);
 
 	m_State = SERVER_STATE_INGAME;
 }
 
 void CNetServerWorker::StartGame()
 {
 	m_ServerTurnManager = new CNetServerTurnManager(*this);
 
 	for (const CNetServerSession* session : m_Sessions)
 		m_ServerTurnManager->InitialiseClient(session->GetHostID(), 0); // TODO: only for non-observers
 
 	m_State = SERVER_STATE_LOADING;
 
 	// Send the final setup state to all clients
 	UpdateGameAttributes(&m_GameAttributes.get());
 
 	// Remove players and observers that are not present when the game starts
 	for (PlayerAssignmentMap::iterator it = m_PlayerAssignments.begin(); it != m_PlayerAssignments.end();)
 		if (it->second.m_Enabled)
 			++it;
 		else
 			it = m_PlayerAssignments.erase(it);
 
 	SendPlayerAssignments();
 
 	CGameStartMessage gameStart;
 	Broadcast(&gameStart);
 }
 
 void CNetServerWorker::UpdateGameAttributes(JS::MutableHandleValue attrs)
 {
 	m_GameAttributes.set(m_ScriptInterface->GetJSRuntime(), attrs);
 
 	if (!m_Host)
 		return;
 
 	CGameSetupMessage gameSetupMessage(GetScriptInterface());
 	gameSetupMessage.m_Data.set(m_GameAttributes.get());
 	Broadcast(&gameSetupMessage);
 }
 
 CStrW CNetServerWorker::SanitisePlayerName(const CStrW& original)
 {
 	const size_t MAX_LENGTH = 32;
 
 	CStrW name = original;
 	name.Replace(L"[", L"{"); // remove GUI tags
 	name.Replace(L"]", L"}"); // remove for symmetry
 
 	// Restrict the length
 	if (name.length() > MAX_LENGTH)
 		name = name.Left(MAX_LENGTH);
 
 	// Don't allow surrounding whitespace
 	name.Trim(PS_TRIM_BOTH);
 
 	// Don't allow empty name
 	if (name.empty())
 		name = L"Anonymous";
 
 	return name;
 }
 
 CStrW CNetServerWorker::DeduplicatePlayerName(const CStrW& original)
 {
 	CStrW name = original;
 
 	// Try names "Foo", "Foo (2)", "Foo (3)", etc
 	size_t id = 2;
 	while (true)
 	{
 		bool unique = true;
 		for (const CNetServerSession* session : m_Sessions)
 		{
 			if (session->GetUserName() == name)
 			{
 				unique = false;
 				break;
 			}
 		}
 
 		if (unique)
 			return name;
 
 		name = original + L" (" + CStrW::FromUInt(id++) + L")";
 	}
 }
 
 
 
 
 CNetServer::CNetServer(int autostartPlayers) :
 	m_Worker(new CNetServerWorker(autostartPlayers))
 {
 }
 
 CNetServer::~CNetServer()
 {
 	delete m_Worker;
 }
 
 bool CNetServer::SetupConnection()
 {
 	return m_Worker->SetupConnection();
 }
 
 bool CNetServer::KickPlayer(const CStrW& playerName, const bool ban)
 {
 	CScopeLock lock(m_Worker->m_WorkerMutex);
 	return m_Worker->KickPlayer(playerName, ban);
 }
 
 void CNetServer::AssignPlayer(int playerID, const CStr& guid)
 {
 	CScopeLock lock(m_Worker->m_WorkerMutex);
 	m_Worker->m_AssignPlayerQueue.emplace_back(playerID, guid);
 }
 
 void CNetServer::SetPlayerReady(const CStr& guid, int ready)
 {
 	CScopeLock lock(m_Worker->m_WorkerMutex);
 	m_Worker->m_PlayerReadyQueue.emplace_back(guid, ready);
 }
 
 void CNetServer::ClearAllPlayerReady()
 {
 	CScopeLock lock(m_Worker->m_WorkerMutex);
 	m_Worker->m_PlayerResetReadyQueue.push_back(false);
 }
 
 void CNetServer::StartGame()
 {
 	CScopeLock lock(m_Worker->m_WorkerMutex);
 	m_Worker->m_StartGameQueue.push_back(true);
 }
 
 void CNetServer::UpdateGameAttributes(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface)
 {
 	// Pass the attributes as JSON, since that's the easiest safe
 	// cross-thread way of passing script data
 	std::string attrsJSON = scriptInterface.StringifyJSON(attrs, false);
 
 	CScopeLock lock(m_Worker->m_WorkerMutex);
 	m_Worker->m_GameAttributesQueue.push_back(attrsJSON);
 }
 
 void CNetServer::SetTurnLength(u32 msecs)
 {
 	CScopeLock lock(m_Worker->m_WorkerMutex);
 	m_Worker->m_TurnLengthQueue.push_back(msecs);
 }
Index: ps/trunk/source/network/NetServer.h
===================================================================
--- ps/trunk/source/network/NetServer.h	(revision 18203)
+++ ps/trunk/source/network/NetServer.h	(revision 18204)
@@ -1,375 +1,381 @@
 /* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef NETSERVER_H
 #define NETSERVER_H
 
 #include "NetFileTransfer.h"
 #include "NetHost.h"
 
 #include "lib/config2.h"
 #include "ps/ThreadUtil.h"
 #include "scriptinterface/ScriptVal.h"
 
 #include <vector>
 
 class CNetServerSession;
 class CNetServerTurnManager;
 class CFsmEvent;
 class ScriptInterface;
 class CPlayerAssignmentMessage;
 class CNetStatsTable;
 class CSimulationMessage;
 
 class CNetServerWorker;
 
 enum NetServerState
 {
 	// We haven't opened the port yet, we're just setting some stuff up.
 	// The worker thread has not been started.
 	SERVER_STATE_UNCONNECTED,
 
 	// The server is open and accepting connections. This is the screen where
 	// rules are set up by the operator and where players join and select civs
 	// and stuff.
 	SERVER_STATE_PREGAME,
 
 	// All the hosts are connected and are loading the game
 	SERVER_STATE_LOADING,
 
 	// The one with all the killing ;-)
 	SERVER_STATE_INGAME,
 
 	// The game is over and someone has won. Players might linger to chat or
 	// download the replay log.
 	SERVER_STATE_POSTGAME
 };
 
 /**
  * Server session representation of client state
  */
 enum NetServerSessionState
 {
 	// The client has disconnected or been disconnected
 	NSS_UNCONNECTED,
 
 	// The client has just connected and we're waiting for its handshake message,
 	// to agree on the protocol version
 	NSS_HANDSHAKE,
 
 	// The client has handshook and we're waiting for its authentication message,
 	// to find its name and check its password etc
 	NSS_AUTHENTICATE,
 
 	// The client has fully joined, and is in the pregame setup stage
 	// or is loading the game.
 	// Server must be in SERVER_STATE_PREGAME or SERVER_STATE_LOADING.
 	NSS_PREGAME,
 
 	// The client has authenticated but the game was already started,
 	// so it's synchronising with the game state from other clients
 	NSS_JOIN_SYNCING,
 
 	// The client is running the game.
 	// Server must be in SERVER_STATE_LOADING or SERVER_STATE_INGAME.
 	NSS_INGAME
 };
 
 /**
  * Network server interface. Handles all the coordination between players.
  * One person runs this object, and every player (including the host) connects their CNetClient to it.
  *
  * The actual work is performed by CNetServerWorker in a separate thread.
  */
 class CNetServer
 {
 	NONCOPYABLE(CNetServer);
 public:
 	/**
 	 * Construct a new network server.
 	 * @param autostartPlayers if positive then StartGame will be called automatically
 	 * once this many players are connected (intended for the command-line testing mode).
 	 */
 	CNetServer(int autostartPlayers = -1);
 
 	~CNetServer();
 
 	/**
 	 * Begin listening for network connections.
 	 * This function is synchronous (it won't return until the connection is established).
 	 * @return true on success, false on error (e.g. port already in use)
 	 */
 	bool SetupConnection();
 
 	/**
 	 * Call from the GUI to update the player assignments.
 	 * The given GUID will be (re)assigned to the given player ID.
 	 * Any player currently using that ID will be unassigned.
 	 * The changes will be asynchronously propagated to all clients.
 	 */
 	void AssignPlayer(int playerID, const CStr& guid);
 
 	/**
 	 * Call from the GUI to update the player readiness.
 	 * The changes will be asynchronously propagated to all clients.
 	 */
 	void SetPlayerReady(const CStr& guid, int ready);
 
 	/**
 	 * Call from the GUI to set the all player readiness to 0.
 	 * The changes will be asynchronously propagated to all clients.
 	 */
 	void ClearAllPlayerReady();
 
 	/**
 	 * Disconnects a player from gamesetup or session.
 	 */
 	bool KickPlayer(const CStrW& playerName, const bool ban);
 
 	/**
 	 * Call from the GUI to asynchronously notify all clients that they should start loading the game.
 	 */
 	void StartGame();
 
 	/**
 	 * Call from the GUI to update the game setup attributes.
 	 * This must be called at least once before starting the game.
 	 * The changes will be asynchronously propagated to all clients.
 	 * @param attrs game attributes, in the script context of scriptInterface
 	 */
 	void UpdateGameAttributes(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface);
 
 	/**
 	 * Set the turn length to a fixed value.
 	 * TODO: we should replace this with some adapative lag-dependent computation.
 	 */
 	void SetTurnLength(u32 msecs);
 
 private:
 	CNetServerWorker* m_Worker;
 };
 
 /**
  * Network server worker thread.
  * (This is run in a thread so that client/server communication is not delayed
  * by the host player's framerate - the only delay should be the network latency.)
  *
  * Thread-safety:
  * - SetupConnection and constructor/destructor must be called from the main thread.
  * - The main thread may push commands onto the Queue members,
  *   while holding the m_WorkerMutex lock.
  * - Public functions (SendMessage, Broadcast) must be called from the network
  *   server thread.
  */
 class CNetServerWorker
 {
 	NONCOPYABLE(CNetServerWorker);
 
 public:
 	// Public functions for CNetSession/CNetServerTurnManager to use:
 
 	/**
 	 * Send a message to the given network peer.
 	 */
 	bool SendMessage(ENetPeer* peer, const CNetMessage* message);
 
 	/**
 	 * Disconnects a player from gamesetup or session.
 	 */
 	bool KickPlayer(const CStrW& playerName, const bool ban);
 
 	/**
 	 * Send a message to all clients who have completed the full connection process
 	 * (i.e. are in the pre-game or in-game states).
 	 */
 	bool Broadcast(const CNetMessage* message);
 
 private:
 	friend class CNetServer;
 	friend class CNetFileReceiveTask_ServerRejoin;
 
 	CNetServerWorker(int autostartPlayers);
 	~CNetServerWorker();
 
 	/**
 	 * Begin listening for network connections.
 	 * @return true on success, false on error (e.g. port already in use)
 	 */
 	bool SetupConnection();
 
 	/**
 	 * Call from the GUI to update the player assignments.
 	 * The given GUID will be (re)assigned to the given player ID.
 	 * Any player currently using that ID will be unassigned.
 	 * The changes will be propagated to all clients.
 	 */
 	void AssignPlayer(int playerID, const CStr& guid);
 
 	/**
 	 * Call from the GUI to notify all clients that they should start loading the game.
 	 */
 	void StartGame();
 
 	/**
 	 * Call from the GUI to update the game setup attributes.
 	 * This must be called at least once before starting the game.
 	 * The changes will be propagated to all clients.
 	 * @param attrs game attributes, in the script context of GetScriptInterface()
 	 */
 	void UpdateGameAttributes(JS::MutableHandleValue attrs);
 
 	/**
 	 * Make a player name 'nicer' by limiting the length and removing forbidden characters etc.
 	 */
 	static CStrW SanitisePlayerName(const CStrW& original);
 
 	/**
 	 * Make a player name unique, if it matches any existing session's name.
 	 */
 	CStrW DeduplicatePlayerName(const CStrW& original);
 
 	/**
 	 * Get the script context used for game attributes.
 	 */
 	ScriptInterface& GetScriptInterface();
 
 	/**
 	 * Set the turn length to a fixed value.
 	 * TODO: we should replace this with some adaptive lag-dependent computation.
 	 */
 	void SetTurnLength(u32 msecs);
 
 	void AddPlayer(const CStr& guid, const CStrW& name);
 	void RemovePlayer(const CStr& guid);
 	void SetPlayerReady(const CStr& guid, const int ready);
 	void SendPlayerAssignments();
 	void ClearAllPlayerReady();
 
 	void SetupSession(CNetServerSession* session);
 	bool HandleConnect(CNetServerSession* session);
 
 	void OnUserJoin(CNetServerSession* session);
 	void OnUserLeave(CNetServerSession* session);
 
 	static bool OnClientHandshake(void* context, CFsmEvent* event);
 	static bool OnAuthenticate(void* context, CFsmEvent* event);
 	static bool OnInGame(void* context, CFsmEvent* event);
 	static bool OnChat(void* context, CFsmEvent* event);
 	static bool OnReady(void* context, CFsmEvent* event);
 	static bool OnLoadedGame(void* context, CFsmEvent* event);
 	static bool OnJoinSyncingLoadedGame(void* context, CFsmEvent* event);
 	static bool OnRejoined(void* context, CFsmEvent* event);
 	static bool OnDisconnect(void* context, CFsmEvent* event);
+	static bool OnClientPaused(void* context, CFsmEvent* event);
 
 	void CheckGameLoadStatus(CNetServerSession* changedSession);
 
 	void ConstructPlayerAssignmentMessage(CPlayerAssignmentMessage& message);
 
 	void HandleMessageReceive(const CNetMessage* message, CNetServerSession* session);
 
 	/**
 	 * Send a network warning if the connection to a client is being lost or has bad latency.
 	 */
 	void CheckClientConnections();
 
 	/**
 	 * Internal script context for (de)serializing script messages,
 	 * and for storing game attributes.
 	 * (TODO: we shouldn't bother deserializing (except for debug printing of messages),
 	 * we should just forward messages blindly and efficiently.)
 	 */
 	ScriptInterface* m_ScriptInterface;
 
 	PlayerAssignmentMap m_PlayerAssignments;
 
 	/**
 	 * Stores the most current game attributes.
 	 */
 	DefPersistentRooted<JS::Value> m_GameAttributes;
 
 	int m_AutostartPlayers;
 
 	ENetHost* m_Host;
 	std::vector<CNetServerSession*> m_Sessions;
 
 	CNetStatsTable* m_Stats;
 
 	NetServerState m_State;
 
 	CStrW m_ServerName;
 	CStrW m_WelcomeMessage;
 
 	std::vector<u32> m_BannedIPs;
 	std::vector<CStrW> m_BannedPlayers;
 
+	/**
+	 * Holds the GUIDs of all currently paused players.
+	 */
+	std::vector<CStr> m_PausingPlayers;
+
 	u32 m_NextHostID;
 
 	CNetServerTurnManager* m_ServerTurnManager;
 
 	CStr m_HostGUID;
 
 	/**
 	 * A copy of all simulation commands received so far, indexed by
 	 * turn number, to simplify support for rejoining etc.
 	 * TODO: verify this doesn't use too much RAM.
 	 */
 	std::vector<std::vector<CSimulationMessage>> m_SavedCommands;
 
 	/**
 	 * The latest copy of the simulation state, received from an existing
 	 * client when a new client has asked to rejoin the game.
 	 */
 	std::string m_JoinSyncFile;
 
 	/**
 	 *  Time when the clients connections were last checked for timeouts and latency.
 	 */
 	std::time_t m_LastConnectionCheck;
 
 private:
 	// Thread-related stuff:
 
 #if CONFIG2_MINIUPNPC
 	/**
 	 * Try to find a UPnP root on the network and setup port forwarding.
 	 */
 	static void* SetupUPnP(void*);
 	pthread_t m_UPnPThread;
 #endif
 
 	static void* RunThread(void* data);
 	void Run();
 	bool RunStep();
 
 	pthread_t m_WorkerThread;
 	CMutex m_WorkerMutex;
 
 	bool m_Shutdown; // protected by m_WorkerMutex
 
 	// Queues for messages sent by the game thread:
 	std::vector<std::pair<int, CStr>> m_AssignPlayerQueue; // protected by m_WorkerMutex
 	std::vector<bool> m_StartGameQueue; // protected by m_WorkerMutex
 	std::vector<std::pair<CStr, int>> m_PlayerReadyQueue; // protected by m_WorkerMutex
 	std::vector<bool> m_PlayerResetReadyQueue; // protected by m_WorkerMutex
 	std::vector<std::string> m_GameAttributesQueue; // protected by m_WorkerMutex
 	std::vector<u32> m_TurnLengthQueue; // protected by m_WorkerMutex
 };
 
 /// Global network server for the standard game
 extern CNetServer *g_NetServer;
 
 #endif // NETSERVER_H