Index: ps/trunk/binaries/data/mods/public/gui/lobby/lobby.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/lobby/lobby.js	(revision 17940)
+++ ps/trunk/binaries/data/mods/public/gui/lobby/lobby.js	(revision 17941)
@@ -1,1029 +1,1019 @@
 /**
  * Used for the gamelist-filtering.
  */
 const g_MapSizes = prepareForDropdown(g_Settings ? g_Settings.MapSizes : undefined);
 
 /**
  * Used for the gamelist-filtering.
  */
 const g_MapTypes = prepareForDropdown(g_Settings ? g_Settings.MapTypes : undefined);
 
 /**
  * Whether or not to display timestamps in the chat window.
  */
 const g_ShowTimestamp = Engine.ConfigDB_GetValue("user", "lobby.chattimestamp") == "true";
 
 /**
  * Mute clients who exceed the rate of 1 message per second for this time
  */
 const g_SpamBlockTimeframe = 5;
 
 /**
  * Mute spammers for this time.
  */
 const g_SpamBlockDuration = 30;
 
 /**
  * A symbol which is prepended to the username of moderators.
  */
 const g_ModeratorPrefix = "@";
 
 /**
  * Current username. Cannot contain whitespace.
  */
 const g_Username = Engine.LobbyGetNick();
 
 /**
  * Current games will be listed in these colors.
  */
 const g_GameColors = {
 	"init": "0 219 0",
 	"waiting": "255 127 0",
 	"running": "219 0 0"
 };
 
 /**
  * Initial sorting order of the gamelist.
  */
 const g_GameStatusOrder = ["init", "waiting", "running"];
 
 /**
  * The playerlist will be assembled using these values.
  */
 const g_PlayerStatuses = {
 	"available": { "color": "0 219 0",     "status": translate("Online") },
 	"away":      { "color": "229 76 13",   "status": translate("Away") },
 	"playing":   { "color": "200 0 0",     "status": translate("Busy") },
 	"offline":   { "color": "0 0 0",       "status": translate("Offline") },
 	"unknown":   { "color": "178 178 178", "status": translateWithContext("lobby presence", "Unknown") }
 };
 
 /**
  * Color for error messages in the chat.
  */
 const g_SystemColor = "150 0 0";
 
 /**
  * Used for highlighting the sender of chat messages.
  */
 const g_SenderFont = "sans-bold-13";
 
 /**
  * All chat messages received since init (i.e. after lobby join and after returning from a game).
  */
 var g_ChatMessages = [];
 
 /**
  * Rating of the current user.
  * Contains the number or an empty string in case the user has no rating.
  */
 var g_UserRating = "";
 
 /**
  * All games currently running.
  */
 var g_GameList = {};
 
 /**
  * Remembers how many messages were sent by each user since the last reset.
  *
  * For example { "username": [numMessagesSinceReset, lastReset, timeBlocked] }
  */
 var g_SpamMonitor = {};
 
 /**
  * Used to restore the selection after updating the playerlist.
  */
 var g_SelectedPlayer = "";
 
 /**
  * Used to restore the selection after updating the gamelist.
  */
 var g_SelectedGameIP = "";
 
 /**
  * Notifications sent by XmppClient.cpp
  */
 var g_NetMessageTypes = {
 	"system": {
 		// Three cases are handled in prelobby.js
 		"registered": msg => {
 		},
 		"connected": msg => {
 		},
 		"disconnected": msg => {
 			updateGameList();
 			updateLeaderboard();
 			updatePlayerList();
 			Engine.GetGUIObjectByName("hostButton").enabled = false;
-			addChatMessage({
-				"from": "system",
-				"text": translate("Disconnected.") + msg.text,
-				"color": g_SystemColor,
-				"time": msg.time
-			});
+			addChatMessage({ "from": "system", "text": translate("Disconnected.") + msg.text, "color": g_SystemColor });
 		},
 		"error": msg => {
-			addChatMessage({
-				"from": "system",
-				"text": msg.text,
-				"color": g_SystemColor,
-				"time": msg.time
-			});
+			addChatMessage({ "from": "system", "text": msg.text, "color": g_SystemColor });
 		}
 	},
 	"chat": {
 		"subject": msg => {
 			updateSubject(msg.text);
 		},
 		"join": msg => {
 			addChatMessage({
 				"text": "/special " + sprintf(translate("%(nick)s has joined."), { "nick": msg.text }),
-				"isSpecial": true,
-				"time": msg.time
+				"isSpecial": true
 			});
 			Engine.SendGetRatingList();
 		},
 		"leave": msg => {
 			addChatMessage({
 				"text": "/special " + sprintf(translate("%(nick)s has left."), { "nick": msg.text }),
-				"isSpecial": true,
-				"time": msg.time
+				"isSpecial": true
 			});
 		},
 		"presence": msg => {
 		},
 		"nick": msg => {
 			addChatMessage({
 				"text": "/special " + sprintf(translate("%(oldnick)s is now known as %(newnick)s."), {
 					"oldnick": msg.text,
 					"newnick": msg.data
 				}),
-				"isSpecial": true,
-				"time": msg.time
+				"isSpecial": true
 			});
 		},
 		"room-message": msg => {
 			addChatMessage({
 				"from": escapeText(msg.from),
 				"text": escapeText(msg.text),
-				"time": msg.time
+				"datetime": msg.datetime
 			});
 		},
 		"private-message": msg => {
 			if (Engine.LobbyGetPlayerRole(msg.from) == "moderator")
 				addChatMessage({
 					"from": "(Private) " + escapeText(msg.from), // TODO: placeholder
 					"text": escapeText(msg.text.trim()), // some XMPP clients send trailing whitespace
-					"time": msg.time
+					"datetime": msg.datetime
 				});
 		}
 	},
 	"game": {
 		"gamelist": msg => updateGameList(),
 		"profile": msg => updateProfile(),
 		"leaderboard": msg => updateLeaderboard(),
 		"ratinglist": msg => updatePlayerList()
 	}
 };
 
 /**
  * Called after the XmppConnection succeeded and when returning from a game.
  *
  * @param {Object} attribs
  */
 function init(attribs)
 {
 	if (!g_Settings)
 	{
 		returnToMainMenu();
 		return;
 	}
 
 	initMusic();
 	global.music.setState(global.music.states.MENU);
 
 	initGameFilters();
 
 	Engine.LobbySetPlayerPresence("available");
 	Engine.SendGetGameList();
 
 	// When rejoining the lobby after a game, we don't need to process presence changes
 	Engine.LobbyClearPresenceUpdates();
 	updatePlayerList();
 	updateSubject(Engine.LobbyGetRoomSubject());
 }
 
 function returnToMainMenu()
 {
 	Engine.StopXmppClient();
 	Engine.SwitchGuiPage("page_pregame.xml");
 }
 
 function initGameFilters()
 {
 	var mapSizeFilter = Engine.GetGUIObjectByName("mapSizeFilter");
 	mapSizeFilter.list = [translateWithContext("map size", "Any")].concat(g_MapSizes.Name);
 	mapSizeFilter.list_data = [""].concat(g_MapSizes.Tiles);
 
 	var playersArray = Array(g_MaxPlayers).fill(0).map((v, i) => i + 1); // 1, 2, ... MaxPlayers
 	var playersNumberFilter = Engine.GetGUIObjectByName("playersNumberFilter");
 	playersNumberFilter.list = [translateWithContext("player number", "Any")].concat(playersArray);
 	playersNumberFilter.list_data = [""].concat(playersArray);
 
 	var mapTypeFilter = Engine.GetGUIObjectByName("mapTypeFilter");
 	mapTypeFilter.list = [translateWithContext("map", "Any")].concat(g_MapTypes.Title);
 	mapTypeFilter.list_data = [""].concat(g_MapTypes.Name);
 
 	resetFilters();
 }
 
 function resetFilters()
 {
 	Engine.GetGUIObjectByName("mapSizeFilter").selected = 0;
 	Engine.GetGUIObjectByName("playersNumberFilter").selected = 0;
 	Engine.GetGUIObjectByName("mapTypeFilter").selected = g_MapTypes.Default;
 	Engine.GetGUIObjectByName("showFullFilter").checked = false;
 
 	applyFilters();
 }
 
 function applyFilters()
 {
 	updateGameList();
 	updateGameSelection();
 }
 
 /**
  * Filter a game based on the status of the filter dropdowns.
  *
  * @param {Object} game
  * @returns {boolean} - True if game should not be displayed.
  */
 function filterGame(game)
 {
 	var mapSizeFilter = Engine.GetGUIObjectByName("mapSizeFilter");
 	var playersNumberFilter = Engine.GetGUIObjectByName("playersNumberFilter");
 	var mapTypeFilter = Engine.GetGUIObjectByName("mapTypeFilter");
 	var showFullFilter = Engine.GetGUIObjectByName("showFullFilter");
 
 	// We assume index 0 means display all for any given filter.
 	if (mapSizeFilter.selected != 0 && game.mapSize != mapSizeFilter.list_data[mapSizeFilter.selected])
 		return true;
 	if (playersNumberFilter.selected != 0 && game.tnbp != playersNumberFilter.list_data[playersNumberFilter.selected])
 		return true;
 	if (mapTypeFilter.selected != 0 && game.mapType != mapTypeFilter.list_data[mapTypeFilter.selected])
 		return true;
 	if (!showFullFilter.checked && game.tnbp <= game.nbp)
 		return true;
 
 	return false;
 }
 
 /**
  * Update the subject GUI object.
  *
  * @param {string} newSubject
  */
 function updateSubject(newSubject)
 {
 	var subject = Engine.GetGUIObjectByName("subject").caption = newSubject;
 	var subjectBox = Engine.GetGUIObjectByName("subjectBox");
 	var logo = Engine.GetGUIObjectByName("logo");
 
 	// If the subject is only whitespace, hide it and reposition the logo.
 	if (!newSubject.trim())
 	{
 		subjectBox.hidden = true;
 		logo.size = "50%-110 50%-50 50%+110 50%+50";
 	}
 	else
 	{
 		subjectBox.hidden = false;
 		logo.size = "50%-110 40 50%+110 140";
 	}
 }
 
 /**
  * Do a full update of the player listing, including ratings from cached C++ information.
  */
 function updatePlayerList()
 {
 	var playersBox = Engine.GetGUIObjectByName("playersBox");
 	var sortBy = playersBox.selected_column || "name";
 	var sortOrder = playersBox.selected_column_order || 1;
 
 	if (playersBox.selected > -1)
 		g_SelectedPlayer = playersBox.list[playersBox.selected];
 
 	var playerList = [];
 	var presenceList = [];
 	var nickList = [];
 	var ratingList = [];
 
 	var cleanPlayerList = Engine.GetPlayerList().sort((a, b) => {
 		var sortA, sortB;
 		switch (sortBy)
 		{
 		case 'rating':
 			sortA = +a.rating;
 			sortB = +b.rating;
 			break;
 		case 'status':
 			let statusOrder = Object.keys(g_PlayerStatuses);
 			sortA = statusOrder.indexOf(a.presence);
 			sortB = statusOrder.indexOf(b.presence);
 			break;
 		case 'name':
 		default:
 			sortA = a.name.toLowerCase();
 			sortB = b.name.toLowerCase();
 			break;
 		}
 		if (sortA < sortB) return -sortOrder;
 		if (sortA > sortB) return +sortOrder;
 		return 0;
 	});
 
 	// Colorize list entries
 	for (let player of cleanPlayerList)
 	{
 		if (player.rating && player.name == g_Username)
 			g_UserRating = player.rating;
 		let rating = player.rating ? ("     " + player.rating).substr(-5) : "     -";
 
 		let presence = g_PlayerStatuses[player.presence] ? player.presence : "unknown";
 		if (presence == "unknown")
 			warn("Unknown presence:" + player.presence);
 
 		let statusColor = g_PlayerStatuses[presence].color;
 		let coloredName = colorPlayerName((player.role == "moderator" ? g_ModeratorPrefix : "") + player.name);
 		let coloredPresence = '[color="' + statusColor + '"]' + g_PlayerStatuses[presence].status + "[/color]";
 		let coloredRating = '[color="' + statusColor + '"]' + rating + "[/color]";
 
 		playerList.push(coloredName);
 		presenceList.push(coloredPresence);
 		ratingList.push(coloredRating);
 		nickList.push(player.name);
 	}
 
 	playersBox.list_name = playerList;
 	playersBox.list_status = presenceList;
 	playersBox.list_rating = ratingList;
 	playersBox.list = nickList;
 
 	// To reduce rating-server load, only send the GUI event if the selection actually changed
 	if (playersBox.selected != playersBox.list.indexOf(g_SelectedPlayer))
 		playersBox.selected = playersBox.list.indexOf(g_SelectedPlayer);
 }
 
 /**
  * Display the profile of the selected player.
  * Displays N/A for all stats until updateProfile is called when the stats
  * 	are actually received from the bot.
  *
  * @param {string} caller - From which screen is the user requesting data from?
  */
 function displayProfile(caller)
 {
 	var playerList, rating;
 	if (caller == "leaderboard")
 		playerList = Engine.GetGUIObjectByName("leaderboardBox");
 	else if (caller == "lobbylist")
 		playerList = Engine.GetGUIObjectByName("playersBox");
 	else if (caller == "fetch")
 	{
 		Engine.SendGetProfile(Engine.GetGUIObjectByName("fetchInput").caption);
 		return;
 	}
 	else
 		return;
 
 	var playerName = playerList.list[playerList.selected];
 	Engine.GetGUIObjectByName("profileArea").hidden = !playerName;
 	if (!playerName)
 		return;
 	Engine.SendGetProfile(playerName);
 
 	var isModerator = Engine.LobbyGetPlayerRole(playerName) == "moderator";
 	Engine.GetGUIObjectByName("usernameText").caption = playerList.list_name[playerList.selected];
 	Engine.GetGUIObjectByName("roleText").caption = isModerator ? translate("Moderator") : translate("Player");
 	Engine.GetGUIObjectByName("rankText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("highestRatingText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("totalGamesText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("winsText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("lossesText").caption = translate("N/A");
 	Engine.GetGUIObjectByName("ratioText").caption = translate("N/A");
 }
 
 /**
  * Update the profile of the selected player with data from the bot.
  */
 function updateProfile()
 {
 	var user;
 	var playerList;
 	var attributes = Engine.GetProfile();
 
 	if (!Engine.GetGUIObjectByName("profileFetch").hidden)
 	{
 		let profileFound = attributes[0].rating != "-2";
 		Engine.GetGUIObjectByName("profileWindowArea").hidden = !profileFound;
 		Engine.GetGUIObjectByName("profileErrorText").hidden = profileFound;
 
 		if (!profileFound)
 			return;
 
 		user = attributes[0].player;
 		if (attributes[0].rating != "")
 			user = sprintf(translate("%(nick)s (%(rating)s)"), { "nick": user, "rating": attributes[0].rating });
 
 		Engine.GetGUIObjectByName("profileUsernameText").caption = user;
 		Engine.GetGUIObjectByName("profileRankText").caption = attributes[0].rank;
 		Engine.GetGUIObjectByName("profileHighestRatingText").caption = attributes[0].highestRating;
 		Engine.GetGUIObjectByName("profileTotalGamesText").caption = attributes[0].totalGamesPlayed;
 		Engine.GetGUIObjectByName("profileWinsText").caption = attributes[0].wins;
 		Engine.GetGUIObjectByName("profileLossesText").caption = attributes[0].losses;
 
 		var winRate = (attributes[0].wins / attributes[0].totalGamesPlayed * 100).toFixed(2);
 		if (attributes[0].totalGamesPlayed != 0)
 			Engine.GetGUIObjectByName("profileRatioText").caption = sprintf(translate("%(percentage)s%%"), { "percentage": winRate });
 		else
 			Engine.GetGUIObjectByName("profileRatioText").caption = translateWithContext("Used for an undefined winning rate", "-");
 		return;
 	}
 	else if (!Engine.GetGUIObjectByName("leaderboard").hidden)
 		playerList = Engine.GetGUIObjectByName("leaderboardBox");
 	else
 		playerList = Engine.GetGUIObjectByName("playersBox");
 
 	if (attributes[0].rating == "-2")
 		return;
 
 	// Make sure the stats we have received coincide with the selected player.
 	if (attributes[0].player != playerList.list[playerList.selected])
 		return;
 
 	user = playerList.list_name[playerList.selected];
 	if (attributes[0].rating != "")
 		user = sprintf(translate("%(nick)s (%(rating)s)"), { "nick": user, "rating": attributes[0].rating });
 
 	Engine.GetGUIObjectByName("usernameText").caption = user;
 	Engine.GetGUIObjectByName("rankText").caption = attributes[0].rank;
 	Engine.GetGUIObjectByName("highestRatingText").caption = attributes[0].highestRating;
 	Engine.GetGUIObjectByName("totalGamesText").caption = attributes[0].totalGamesPlayed;
 	Engine.GetGUIObjectByName("winsText").caption = attributes[0].wins;
 	Engine.GetGUIObjectByName("lossesText").caption = attributes[0].losses;
 
 	var winRate = (attributes[0].wins / attributes[0].totalGamesPlayed * 100).toFixed(2);
 	if (attributes[0].totalGamesPlayed != 0)
 		Engine.GetGUIObjectByName("ratioText").caption = sprintf(translate("%(percentage)s%%"), { "percentage": winRate });
 	else
 		Engine.GetGUIObjectByName("ratioText").caption = translateWithContext("Used for an undefined winning rate", "-");
 }
 
 /**
  * Update the leaderboard from data cached in C++.
  */
 function updateLeaderboard()
 {
 	var leaderboard = Engine.GetGUIObjectByName("leaderboardBox");
 	var boardList = Engine.GetBoardList().sort((a, b) => b.rating - a.rating);
 
 	var list = [];
 	var list_name = [];
 	var list_rank = [];
 	var list_rating = [];
 
 	for (let i in boardList)
 	{
 		list_name.push(boardList[i].name);
 		list_rating.push(boardList[i].rating);
 		list_rank.push(+i+1);
 		list.push(boardList[i].name);
 	}
 
 	leaderboard.list_name = list_name;
 	leaderboard.list_rating = list_rating;
 	leaderboard.list_rank = list_rank;
 	leaderboard.list = list;
 
 	if (leaderboard.selected >= leaderboard.list.length)
 		leaderboard.selected = -1;
 }
 
 /**
  * Update the game listing from data cached in C++.
  */
 function updateGameList()
 {
 	var gamesBox = Engine.GetGUIObjectByName("gamesBox");
 	var sortBy = gamesBox.selected_column || "status";
 	var sortOrder = gamesBox.selected_column_order || 1;
 
 	if (gamesBox.selected > -1)
 		g_SelectedGameIP = g_GameList[gamesBox.selected].ip;
 
 	g_GameList = Engine.GetGameList().filter(game => !filterGame(game)).sort((a, b) => {
 		var sortA, sortB;
 		switch (sortBy)
 		{
 		case 'name':
 		case 'mapSize':
 		case 'mapType':
 			sortA = a[sortBy];
 			sortB = b[sortBy];
 			break;
 		case 'mapName':
 			sortA = translate(a.niceMapName);
 			sortB = translate(b.niceMapName);
 			break;
 		case 'nPlayers':
 			// Compare playercount ratio
 			sortA = a.nbp * b.tnbp;
 			sortB = b.nbp * a.tnbp;
 			break;
 		case 'status':
 		default:
 			sortA = g_GameStatusOrder.indexOf(a.state);
 			sortB = g_GameStatusOrder.indexOf(b.state);
 			break;
 		}
 		if (sortA < sortB) return -sortOrder;
 		if (sortA > sortB) return +sortOrder;
 		return 0;
 	});
 
 	var list_name = [];
 	var list_mapName = [];
 	var list_mapSize = [];
 	var list_mapType = [];
 	var list_nPlayers = [];
 	var list = [];
 	var list_data = [];
 	var selectedGameIndex = -1;
 
 	for (let i in g_GameList)
 	{
 		let game = g_GameList[i];
 		let gameName = escapeText(game.name);
 		let mapTypeIdx = g_MapTypes.Name.indexOf(game.mapType);
 
 		if (game.ip == g_SelectedGameIP)
 			selectedGameIndex = +i;
 
 		list_name.push('[color="' + g_GameColors[game.state] + '"]' + gameName);
 		list_mapName.push(translate(game.niceMapName));
 		list_mapSize.push(translateMapSize(game.mapSize));
 		list_mapType.push(mapTypeIdx != -1 ? g_MapTypes.Title[mapTypeIdx] : "");
 		list_nPlayers.push(game.nbp + "/" + game.tnbp);
 		list.push(gameName);
 		list_data.push(i);
 	}
 
 	gamesBox.list_name = list_name;
 	gamesBox.list_mapName = list_mapName;
 	gamesBox.list_mapSize = list_mapSize;
 	gamesBox.list_mapType = list_mapType;
 	gamesBox.list_nPlayers = list_nPlayers;
 	// Change these last, otherwise crash
 	gamesBox.list = list;
 	gamesBox.list_data = list_data;
 	gamesBox.selected = selectedGameIndex;
 
 	updateGameSelection();
 }
 
 /**
  * Populate the game info area with information on the current game selection.
  */
 function updateGameSelection()
 {
 	let game = selectedGame();
 	if (!game)
 	{
 		Engine.GetGUIObjectByName("gameInfo").hidden = true;
 		Engine.GetGUIObjectByName("joinGameButton").hidden = true;
 		Engine.GetGUIObjectByName("gameInfoEmpty").hidden = false;
 		return;
 	}
 
 	// Show the game info panel and join button.
 	Engine.GetGUIObjectByName("gameInfo").hidden = false;
 	Engine.GetGUIObjectByName("joinGameButton").hidden = false;
 	Engine.GetGUIObjectByName("gameInfoEmpty").hidden = true;
 
 	// Display the map name, number of players, the names of the players, the map size and the map type.
 	Engine.GetGUIObjectByName("sgMapName").caption = translate(game.niceMapName);
 	Engine.GetGUIObjectByName("sgNbPlayers").caption = translate("Players:") + " " + game.nbp + "/" + game.tnbp;
 	Engine.GetGUIObjectByName("sgPlayersNames").caption = game.players;
 	Engine.GetGUIObjectByName("sgMapSize").caption = translateMapSize(game.mapSize);
 	let mapTypeIdx = g_MapTypes.Name.indexOf(game.mapType);
 	Engine.GetGUIObjectByName("sgMapType").caption = mapTypeIdx != -1 ? g_MapTypes.Title[mapTypeIdx] : "";
 
 	var mapData = getMapDescriptionAndPreview(game.mapType, game.mapName);
 	Engine.GetGUIObjectByName("sgMapDescription").caption = mapData.description;
 	setMapPreviewImage("sgMapPreview", mapData.preview);
 }
 
 function selectedGame()
 {
 	let gamesBox = Engine.GetGUIObjectByName("gamesBox");
 	if (gamesBox.selected < 0)
 		return undefined;
 
 	return g_GameList[gamesBox.list_data[gamesBox.selected]];
 }
 
 /**
  * Immediately rejoin and join gamesetups. Otherwise confirm late-observer join attempt.
  */
 function joinButton()
 {
 	let game = selectedGame();
 	if (!game)
 		return;
 
 	let username = g_UserRating ? g_Username + " (" + g_UserRating + ")" : g_Username;
 
 	if (game.state == "init" || game.players.split(", ").indexOf(username) > -1)
 		joinSelectedGame();
 	else
 		messageBox(
 			400, 200,
 			translate("The game has already started.") + "\n" +
 				translate("Do you want to join as observer?"),
 			translate("Confirmation"),
 			0,
 			[translate("No"), translate("Yes")],
 			[null, joinSelectedGame]
 		);
 }
 
 /**
  * Attempt to join the selected game without asking for confirmation.
  */
 function joinSelectedGame()
 {
 	let game = selectedGame();
 	if (!game)
 		return;
 
 	if (game.ip.split('.').length != 4)
 	{
 		addChatMessage({
 			"from": "system",
 			"text": sprintf(
 				translate("This game's address '%(ip)s' does not appear to be valid."),
 				{ "ip": game.ip }
-			),
-			"time": Date.now() / 1000
+			)
 		});
 		return;
 	}
 
 	Engine.PushGuiPage("page_gamesetup_mp.xml", {
 		"multiplayerGameType": "join",
 		"ip": game.ip,
 		"name": g_Username,
 		"rating": g_UserRating
 	});
 }
 
 /**
  * Open the dialog box to enter the game name.
  */
 function hostGame()
 {
 	Engine.PushGuiPage("page_gamesetup_mp.xml", {
 		"multiplayerGameType": "host",
 		"name": g_Username,
 		"rating": g_UserRating
 	});
 }
 
 /**
  * Processes GUI messages sent by the XmppClient.
  */
 function onTick()
 {
 	updateTimers();
 	checkSpamMonitor();
 
 	while (true)
 	{
 		let msg = Engine.LobbyGuiPollMessage();
 		if (!msg)
 			break;
 
 		if (!g_NetMessageTypes[msg.type])
 		{
 			warn("Unrecognised message type: " + msg.type);
 			continue;
 		}
 		if (!g_NetMessageTypes[msg.type][msg.level])
 		{
 			warn("Unrecognised message level: " + msg.level);
 			continue;
 		}
 		g_NetMessageTypes[msg.type][msg.level](msg);
 
 		// To improve performance, only update the playerlist GUI when the last update in the current stack is processed
 		if (msg.type == "chat" && Engine.LobbyGetMucMessageCount() == 0)
 			updatePlayerList();
 	}
 }
 
 /**
  * Executes a lobby command or sends GUI input directly as chat.
  */
 function submitChatInput()
 {
 	var input = Engine.GetGUIObjectByName("chatInput");
 	var text = input.caption;
 	if (!text.length)
 		return;
 	if (!handleSpecialCommand(text) && !isSpam(text, g_Username))
 		Engine.LobbySendMessage(text);
 	input.caption = "";
 }
 
 /**
  * Handle all '/' commands.
  *
  * @param {string} text - Text to be checked for commands.
  * @returns {boolean} true if more text processing is needed, false otherwise.
  */
 function handleSpecialCommand(text)
 {
 	if (text[0] != '/')
 		return false;
 
 	var [cmd, nick] = ircSplit(text);
 
 	switch (cmd)
 	{
 	case "away":
 		Engine.LobbySetPlayerPresence("away");
 		break;
 	case "back":
 		Engine.LobbySetPlayerPresence("available");
 		break;
 	case "kick": // TODO: Split reason from nick and pass it too, for now just support "/kick nick"
 			// also allow quoting nicks (and/or prevent users from changing it here, but that doesn't help if the spammer uses a different client)
 		Engine.LobbyKick(nick, "");
 		break;
 	case "ban": // TODO: Split reason from nick and pass it too, for now just support "/ban nick"
 		Engine.LobbyBan(nick, "");
 		break;
 	case "quit":
 		returnToMainMenu();
 		break;
 	case "clear":
 		clearChatMessages();
 		break;
 	case "say":
 	case "me":
 		return false;
 	default:
 		addChatMessage({
 			"from": "system",
-			"text": sprintf(translate("We're sorry, the '%(cmd)s' command is not supported."), { "cmd": cmd }),
-			"time": Date.now() / 1000
+			"text": sprintf(translate("We're sorry, the '%(cmd)s' command is not supported."), { "cmd": cmd })
 		});
 	}
 	return true;
 }
 
 /**
  * Process and if appropriate, display a formatted message.
  *
  * @param {Object} msg - The message to be processed.
  */
 function addChatMessage(msg)
 {
 	if (msg.from)
 	{
 		if (Engine.LobbyGetPlayerRole(msg.from) == "moderator")
 			msg.from = g_ModeratorPrefix + msg.from;
 
 		// Highlight local user's nick
 		if (g_Username != msg.from)
 			msg.text = msg.text.replace(g_Username, colorPlayerName(g_Username));
 
-		updateSpamMonitor(msg);
-
-		if (isSpam(msg.text, msg.from))
-			return;
+		// Run spam test if it's not a historical message
+		if (!msg.datetime)
+		{
+			updateSpamMonitor(msg.from);
+			if (isSpam(msg.text, msg.from))
+				return;
+		}
 	}
 
 	var formatted = ircFormat(msg);
 	if (!formatted)
 		return;
 
 	g_ChatMessages.push(formatted);
 	Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
 }
 
 
 /**
  * Splits given input into command and argument.
  *
  * @param {string} string
  * @returns {Array}
  */
 function ircSplit(string)
 {
 	var idx = string.indexOf(' ');
 	if (idx != -1)
 		return [string.substr(1,idx-1), string.substr(idx+1)];
 	return [string.substr(1), ""];
 }
 
 /**
  * Format text in an IRC-like way.
  *
  * @param {Object} msg - Received chat message.
  * @returns {string} - Formatted text.
  */
 function ircFormat(msg)
 {
 	var senderString = "";
 	var formattedMessage = "";
 	var coloredFrom = !msg.from ? "" : (msg.color ? '[color="' + msg.color + '"]' + msg.from + "[/color]" : colorPlayerName(msg.from));
 
 	// Handle commands allowed past handleSpecialCommand.
 	if (msg.text[0] == '/')
 	{
 		var [command, message] = ircSplit(msg.text);
 		switch (command)
 		{
 		case "me":
 			// Translation: IRC message prefix when the sender uses the /me command.
 			senderString = '[font="' + g_SenderFont + '"]' + sprintf(translate("* %(sender)s"), { "sender": coloredFrom }) + '[/font]';
 			// Translation: IRC message issued using the ‘/me’ command.
 			formattedMessage = sprintf(translate("%(sender)s %(action)s"), { "sender": senderString, "action": message });
 			break;
 		case "say":
 			// Translation: IRC message prefix.
 			senderString = '[font="' + g_SenderFont + '"]' + sprintf(translate("<%(sender)s>"), { "sender": coloredFrom }) + '[/font]';
 			// Translation: IRC message.
 			formattedMessage = sprintf(translate("%(sender)s %(message)s"), { "sender": senderString, "message": message });
 			break;
 		case "special":
 			if (msg.isSpecial)
 				// Translation: IRC system message.
 				formattedMessage = '[font="' + g_SenderFont + '"]' + sprintf(translate("== %(message)s"), { "message": message }) + '[/font]';
 			else
 			{
 				// Translation: IRC message prefix.
 				senderString = '[font="' + g_SenderFont + '"]' + sprintf(translate("<%(sender)s>"), { "sender": coloredFrom }) + '[/font]';
 				// Translation: IRC message.
 				formattedMessage = sprintf(translate("%(sender)s %(message)s"), { "sender": senderString, "message": message });
 			}
 			break;
 		}
 	}
 	else
 	{
 		// Translation: IRC message prefix.
 		senderString = '[font="' + g_SenderFont + '"]' + sprintf(translate("<%(sender)s>"), { "sender": coloredFrom }) + '[/font]';
 		// Translation: IRC message.
 		formattedMessage = sprintf(translate("%(sender)s %(message)s"), { "sender": senderString, "message": msg.text });
 	}
 
 	// Add chat message timestamp
 	if (!g_ShowTimestamp)
 		return formattedMessage;
 
-	// Convert from UTC to localtime
-	 var time = msg.time - new Date().getTimezoneOffset() * 60;
+	var time;
+	if (msg.datetime)
+	{
+		let dTime = msg.datetime.split("T");
+		let parserDate = dTime[0].split("-");
+		let parserTime = dTime[1].split(":");
+		// See http://xmpp.org/extensions/xep-0082.html#sect-idp285136 for format of datetime
+		// Date takes Year, Month, Day, Hour, Minute, Second
+		time = new Date(Date.UTC(parserDate[0], parserDate[1], parserDate[2], parserTime[0], parserTime[1], parserTime[2].split("Z")[0]));
+	}
+	else
+		time = new Date(Date.now());
 
 	// Translation: Time as shown in the multiplayer lobby (when you enable it in the options page).
 	// For a list of symbols that you can use, see:
 	// https://sites.google.com/site/icuprojectuserguide/formatparse/datetime?pli=1#TOC-Date-Field-Symbol-Table
-	var timeString = Engine.FormatMillisecondsIntoDateString(time * 1000, translate("HH:mm"));
+	var timeString = Engine.FormatMillisecondsIntoDateString(time.getTime(), translate("HH:mm"));
 
 	// Translation: Time prefix as shown in the multiplayer lobby (when you enable it in the options page).
 	var timePrefixString = '[font="' + g_SenderFont + '"]' + sprintf(translate("\\[%(time)s]"), { "time": timeString }) + '[/font]';
 
 	// Translation: IRC message format when there is a time prefix.
 	return sprintf(translate("%(time)s %(message)s"), { "time": timePrefixString, "message": formattedMessage });
  }
 
 /**
  * Update the spam monitor.
  *
- * @param {Object} msg - Message containing user to update.
+ * @param {string} from - User to update.
  */
-function updateSpamMonitor(msg)
+function updateSpamMonitor(from)
 {
-	// Ignore historical messages
-	if (msg.time < Date.now() / 1000 - g_SpamBlockDuration)
-		return;
-
-	if (g_SpamMonitor[msg.from])
-		++g_SpamMonitor[msg.from].count;
+	if (g_SpamMonitor[from])
+		++g_SpamMonitor[from].count;
 	else
-		g_SpamMonitor[msg.from] = {
+		g_SpamMonitor[from] = {
 			"count": 1,
 			"lastSend": Math.floor(Date.now() / 1000),
 			"lastBlock": 0
 		};
 }
 
 /**
  * Check if a message is spam.
  *
  * @param {string} text - Body of message.
  * @param {string} from - Sender of message.
  *
  * @returns {boolean} - True if message should be blocked.
  */
 function isSpam(text, from)
 {
 	// Integer time in seconds.
 	var time = Math.floor(Date.now() / 1000);
 
 	// Initialize if not already in the database.
 	if (!g_SpamMonitor[from])
 		g_SpamMonitor[from] = {
 			"count": 1,
 			"lastSend": time,
 			"lastBlock": 0
 		};
 
 	// Block blank lines.
 	if (!text.trim())
 		return true;
 
 	// Block users who are still within their spam block period.
 	if (g_SpamMonitor[from].lastBlock + g_SpamBlockDuration >= time)
 		return true;
 
 	// Block users who exceed the rate of 1 message per second for five seconds and are not already blocked.
 	if (g_SpamMonitor[from].count == g_SpamBlockTimeframe + 1)
 	{
 		g_SpamMonitor[from].lastBlock = time;
 
 		if (from == g_Username)
-			addChatMessage({
-				"from": "system",
-				"text": translate("Please do not spam. You have been blocked for thirty seconds."),
-				"time": Date.now() / 1000
-			});
+			addChatMessage({ "from": "system", "text": translate("Please do not spam. You have been blocked for thirty seconds.") });
 
 		return true;
 	}
 
 	return false;
 }
 
 /**
  * Reset timer used to measure message send speed.
  * Clear message count every 5 seconds.
  */
 function checkSpamMonitor()
 {
 	var time = Math.floor(Date.now() / 1000);
 	for (let i in g_SpamMonitor)
 	{
 		// Reset the spam-status after being silent long enough
 		if (g_SpamMonitor[i].lastSend + g_SpamBlockTimeframe <= time)
 		{
 			g_SpamMonitor[i].count = 0;
 			g_SpamMonitor[i].lastSend = time;
 		}
 	}
 }
 
 /**
  *  Generate a (mostly) unique color for this player based on their name.
  *  See http://stackoverflow.com/questions/3426404/create-a-hexadecimal-colour-based-on-a-string-with-jquery-javascript
  *
  *  @param {string} playername
  */
 function getPlayerColor(playername)
 {
 	// Generate a probably-unique hash for the player name and use that to create a color.
 	var hash = 0;
 	for (var i = 0; i < playername.length; ++i)
 		hash = playername.charCodeAt(i) + ((hash << 5) - hash);
 
 	// First create the color in RGB then HSL, clamp the lightness so it's not too dark to read, and then convert back to RGB to display.
 	// The reason for this roundabout method is this algorithm can generate values from 0 to 255 for RGB but only 0 to 100 for HSL; this gives
 	// us much more variety if we generate in RGB. Unfortunately, enforcing that RGB values are a certain lightness is very difficult, so
 	// we convert to HSL to do the computation. Since our GUI code only displays RGB colors, we have to convert back.
 	var [h, s, l] = rgbToHsl(hash >> 24 & 0xFF, hash >> 16 & 0xFF, hash >> 8 & 0xFF);
 	return hslToRgb(h, s, Math.max(0.7, l)).join(" ");
 }
 
 /**
  * Returns the given playername wrapped in an appropriate color-tag.
  *
  *  @param {string} playername
  */
 function colorPlayerName(playername)
 {
 	return '[color="' + getPlayerColor(playername.replace(g_ModeratorPrefix, "")) + '"]' + playername + '[/color]';
 }
Index: ps/trunk/source/lobby/XmppClient.cpp
===================================================================
--- ps/trunk/source/lobby/XmppClient.cpp	(revision 17940)
+++ ps/trunk/source/lobby/XmppClient.cpp	(revision 17941)
@@ -1,1119 +1,1101 @@
 /* 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 "XmppClient.h"
 #include "StanzaExtensions.h"
 
 #include "glooxwrapper/glooxwrapper.h"
 #include "i18n/L10n.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Pyrogenesis.h"
 #include "scriptinterface/ScriptInterface.h"
 
 //debug
 #if 1
 #define DbgXMPP(x)
 #else
 #define DbgXMPP(x) std::cout << x << std::endl;
 
 static std::string tag_xml(const glooxwrapper::IQ& iq)
 {
 	std::string ret;
 	glooxwrapper::Tag* tag = iq.tag();
 	ret = tag->xml().to_string();
 	glooxwrapper::Tag::free(tag);
 	return ret;
 }
 #endif
 
 static std::string tag_name(const glooxwrapper::IQ& iq)
 {
 	std::string ret;
 	glooxwrapper::Tag* tag = iq.tag();
 	ret = tag->name().to_string();
 	glooxwrapper::Tag::free(tag);
 	return ret;
 }
 
 IXmppClient* IXmppClient::create(const std::string& sUsername, const std::string& sPassword, const std::string& sRoom, const std::string& sNick, const int historyRequestSize,bool regOpt)
 {
 	return new XmppClient(sUsername, sPassword, sRoom, sNick, historyRequestSize, regOpt);
 }
 
 /**
  * Construct the XMPP client.
  *
  * @param sUsername Username to login with of register.
  * @param sPassword Password to login with or register.
  * @param sRoom MUC room to join.
  * @param sNick Nick to join with.
  * @param historyRequestSize Number of stanzas of room history to request.
  * @param regOpt If we are just registering or not.
  */
 XmppClient::XmppClient(const std::string& sUsername, const std::string& sPassword, const std::string& sRoom, const std::string& sNick, const int historyRequestSize, bool regOpt)
 	: m_client(NULL), m_mucRoom(NULL), m_registration(NULL), m_username(sUsername), m_password(sPassword), m_nick(sNick), m_initialLoadComplete(false)
 {
 	// Read lobby configuration from default.cfg
 	std::string sServer;
 	std::string sXpartamupp;
 	CFG_GET_VAL("lobby.server", sServer);
 	CFG_GET_VAL("lobby.xpartamupp", sXpartamupp);
 
 	m_xpartamuppId = sXpartamupp + "@" + sServer + "/CC";
 	glooxwrapper::JID clientJid(sUsername + "@" + sServer + "/0ad");
 	glooxwrapper::JID roomJid(sRoom + "@conference." + sServer + "/" + sNick);
 
 	// If we are connecting, use the full jid and a password
 	// If we are registering, only use the server name
 	if (!regOpt)
 		m_client = new glooxwrapper::Client(clientJid, sPassword);
 	else
 		m_client = new glooxwrapper::Client(sServer);
 
 	// Disable TLS as we haven't set a certificate on the server yet
 	m_client->setTls(gloox::TLSDisabled);
 
 	// Disable use of the SASL PLAIN mechanism, to prevent leaking credentials
 	// if the server doesn't list any supported SASL mechanism or the response
 	// has been modified to exclude those.
 	const int mechs = gloox::SaslMechAll ^ gloox::SaslMechPlain;
 	m_client->setSASLMechanisms(mechs);
 
 	m_client->registerConnectionListener(this);
 	m_client->setPresence(gloox::Presence::Available, -1);
 	m_client->disco()->setVersion("Pyrogenesis", engine_version);
 	m_client->disco()->setIdentity("client", "bot");
 	m_client->setCompression(false);
 
 	m_client->registerStanzaExtension(new GameListQuery());
 	m_client->registerIqHandler(this, EXTGAMELISTQUERY);
 
 	m_client->registerStanzaExtension(new BoardListQuery());
 	m_client->registerIqHandler(this, EXTBOARDLISTQUERY);
 
 	m_client->registerStanzaExtension(new ProfileQuery());
 	m_client->registerIqHandler(this, EXTPROFILEQUERY);
 
 	m_client->registerMessageHandler(this);
 
 	// Uncomment to see the raw stanzas
 	//m_client->getWrapped()->logInstance().registerLogHandler( gloox::LogLevelDebug, gloox::LogAreaAll, this );
 
 	if (!regOpt)
 	{
 		// Create a Multi User Chat Room
 		m_mucRoom = new glooxwrapper::MUCRoom(m_client, roomJid, this, 0);
 		// Get room history.
 		m_mucRoom->setRequestHistory(historyRequestSize, gloox::MUCRoom::HistoryMaxStanzas);
 	}
 	else
 	{
 		// Registration
 		m_registration = new glooxwrapper::Registration(m_client);
 		m_registration->registerRegistrationHandler(this);
 	}
 }
 
 /**
  * Destroy the xmpp client
  */
 XmppClient::~XmppClient()
 {
 	DbgXMPP("XmppClient destroyed");
 	delete m_registration;
 	delete m_mucRoom;
 
 	// Workaround for memory leak in gloox 1.0/1.0.1
 	m_client->removePresenceExtension(gloox::ExtCaps);
 
 	delete m_client;
 
 	for (const glooxwrapper::Tag* const& t : m_GameList)
 		glooxwrapper::Tag::free(t);
 	for (const glooxwrapper::Tag* const& t : m_BoardList)
 		glooxwrapper::Tag::free(t);
 	for (const glooxwrapper::Tag* const& t : m_Profile)
 		glooxwrapper::Tag::free(t);
 }
 
 /// Network
 void XmppClient::connect()
 {
 	m_initialLoadComplete = false;
 	m_client->connect(false);
 }
 
 void XmppClient::disconnect()
 {
 	m_client->disconnect();
 }
 
 void XmppClient::recv()
 {
 	m_client->recv(1);
 }
 
 /**
  * Log (debug) Handler
  */
 void XmppClient::handleLog(gloox::LogLevel level, gloox::LogArea area, const std::string& message)
 {
 	std::cout << "log: level: " << level << ", area: " << area << ", message: " << message << std::endl;
 }
 
 /*****************************************************
  * Connection handlers                               *
  *****************************************************/
 
 /**
  * Handle connection
  */
 void XmppClient::onConnect()
 {
 	if (m_mucRoom)
 	{
 		CreateGUIMessage("system", "connected");
 		m_mucRoom->join();
 	}
 
 	if (m_registration)
 		m_registration->fetchRegistrationFields();
 }
 
 /**
  * Handle disconnection
  */
 void XmppClient::onDisconnect(gloox::ConnectionError error)
 {
 	// Make sure we properly leave the room so that
 	// everything works if we decide to come back later
 	if (m_mucRoom)
 		m_mucRoom->leave();
 
 	// Clear game, board and player lists.
 	for (const glooxwrapper::Tag* const& t : m_GameList)
 		glooxwrapper::Tag::free(t);
 	for (const glooxwrapper::Tag* const& t : m_BoardList)
 		glooxwrapper::Tag::free(t);
 	for (const glooxwrapper::Tag* const& t : m_Profile)
 		glooxwrapper::Tag::free(t);
 	m_BoardList.clear();
 	m_GameList.clear();
 	m_PlayerMap.clear();
 	m_Profile.clear();
 
 	CreateGUIMessage("system", "disconnected", ConnectionErrorToString(error));
 }
 
 /**
  * Handle TLS connection
  */
 bool XmppClient::onTLSConnect(const glooxwrapper::CertInfo& info)
 {
 	UNUSED2(info);
 	DbgXMPP("onTLSConnect");
 	DbgXMPP(
 		"status: " << info.status <<
 		"\nissuer: " << info.issuer <<
 		"\npeer: " << info.server <<
 		"\nprotocol: " << info.protocol <<
 		"\nmac: " << info.mac <<
 		"\ncipher: " << info.cipher <<
 		"\ncompression: " << info.compression );
 	return true;
 }
 
 /**
  * Handle MUC room errors
  */
 void XmppClient::handleMUCError(glooxwrapper::MUCRoom*, gloox::StanzaError err)
 {
 	CreateGUIMessage("system", "error", StanzaErrorToString(err));
 }
 
 /*****************************************************
  * Requests to server                                *
  *****************************************************/
 
 /**
  * Request a listing of active games from the server.
  */
 void XmppClient::SendIqGetGameList()
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Send IQ
 	glooxwrapper::IQ iq(gloox::IQ::Get, xpartamuppJid);
 	iq.addExtension(new GameListQuery());
 	DbgXMPP("SendIqGetGameList [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 }
 
 /**
  * Request the leaderboard data from the server.
  */
 void XmppClient::SendIqGetBoardList()
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Send IQ
 	BoardListQuery* b = new BoardListQuery();
 	b->m_Command = "getleaderboard";
 	glooxwrapper::IQ iq(gloox::IQ::Get, xpartamuppJid);
 	iq.addExtension(b);
 	DbgXMPP("SendIqGetBoardList [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 }
 
 /**
  * Request the profile data from the server.
  */
 void XmppClient::SendIqGetProfile(const std::string& player)
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Send IQ
 	ProfileQuery* b = new ProfileQuery();
 	b->m_Command = player;
 	glooxwrapper::IQ iq(gloox::IQ::Get, xpartamuppJid);
 	iq.addExtension(b);
 	DbgXMPP("SendIqGetProfile [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 }
 
 /**
  * Request the rating data from the server.
  */
 void XmppClient::SendIqGetRatingList()
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Send IQ
 	BoardListQuery* b = new BoardListQuery();
 	b->m_Command = "getratinglist";
 	glooxwrapper::IQ iq(gloox::IQ::Get, xpartamuppJid);
 	iq.addExtension(b);
 	DbgXMPP("SendIqGetRatingList [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 }
 
 /**
  * Send game report containing numerous game properties to the server.
  *
  * @param data A JS array of game statistics
  */
 void XmppClient::SendIqGameReport(ScriptInterface& scriptInterface, JS::HandleValue data)
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Setup some base stanza attributes
 	GameReport* game = new GameReport();
 	glooxwrapper::Tag* report = glooxwrapper::Tag::allocate("game");
 
 	// Iterate through all the properties reported and add them to the stanza.
 	std::vector<std::string> properties;
 	scriptInterface.EnumeratePropertyNamesWithPrefix(data, "", properties);
 	for (const std::string& p : properties)
 	{
 		std::wstring value;
 		scriptInterface.GetProperty(data, p.c_str(), value);
 		report->addAttribute(p, utf8_from_wstring(value));
 	}
 
 	// Add stanza to IQ
 	game->m_GameReport.emplace_back(report);
 
 	// Send IQ
 	glooxwrapper::IQ iq(gloox::IQ::Set, xpartamuppJid);
 	iq.addExtension(game);
 	DbgXMPP("SendGameReport [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 };
 
 /**
  * Send a request to register a game to the server.
  *
  * @param data A JS array of game attributes
  */
 void XmppClient::SendIqRegisterGame(ScriptInterface& scriptInterface, JS::HandleValue data)
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Setup some base stanza attributes
 	GameListQuery* g = new GameListQuery();
 	g->m_Command = "register";
 	glooxwrapper::Tag* game = glooxwrapper::Tag::allocate("game");
 	// Add a fake ip which will be overwritten by the ip stamp XMPP module on the server.
 	game->addAttribute("ip", "fake");
 
 	// Iterate through all the properties reported and add them to the stanza.
 	std::vector<std::string> properties;
 	scriptInterface.EnumeratePropertyNamesWithPrefix(data, "", properties);
 	for (const std::string& p : properties)
 	{
 		std::wstring value;
 		scriptInterface.GetProperty(data, p.c_str(), value);
 		game->addAttribute(p, utf8_from_wstring(value));
 	}
 
 	// Push the stanza onto the IQ
 	g->m_GameList.emplace_back(game);
 
 	// Send IQ
 	glooxwrapper::IQ iq(gloox::IQ::Set, xpartamuppJid);
 	iq.addExtension(g);
 	DbgXMPP("SendIqRegisterGame [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 }
 
 /**
  * Send a request to unregister a game to the server.
  */
 void XmppClient::SendIqUnregisterGame()
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Send IQ
 	GameListQuery* g = new GameListQuery();
 	g->m_Command = "unregister";
 	g->m_GameList.emplace_back(glooxwrapper::Tag::allocate("game"));
 
 	glooxwrapper::IQ iq( gloox::IQ::Set, xpartamuppJid );
 	iq.addExtension(g);
 	DbgXMPP("SendIqUnregisterGame [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 }
 
 /**
  * Send a request to change the state of a registered game on the server.
  *
  * A game can either be in the 'running' or 'waiting' state - the server
  * decides which - but we need to update the current players that are
  * in-game so the server can make the calculation.
  */
 void XmppClient::SendIqChangeStateGame(const std::string& nbp, const std::string& players)
 {
 	glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
 
 	// Send IQ
 	GameListQuery* g = new GameListQuery();
 	g->m_Command = "changestate";
 	glooxwrapper::Tag* game = glooxwrapper::Tag::allocate("game");
 	game->addAttribute("nbp", nbp);
 	game->addAttribute("players", players);
 	g->m_GameList.emplace_back(game);
 
 	glooxwrapper::IQ iq(gloox::IQ::Set, xpartamuppJid);
 	iq.addExtension(g);
 	DbgXMPP("SendIqChangeStateGame [" << tag_xml(iq) << "]");
 	m_client->send(iq);
 }
 
 /*****************************************************
  * Account registration                              *
  *****************************************************/
 
 void XmppClient::handleRegistrationFields(const glooxwrapper::JID&, int fields, glooxwrapper::string)
 {
 	glooxwrapper::RegistrationFields vals;
 	vals.username = m_username;
 	vals.password = m_password;
 	m_registration->createAccount(fields, vals);
 }
 
 void XmppClient::handleRegistrationResult(const glooxwrapper::JID&, gloox::RegistrationResult result)
 {
 	if (result == gloox::RegistrationSuccess)
 		CreateGUIMessage("system", "registered");
 	else
 		CreateGUIMessage("system", "error", RegistrationResultToString(result));
 	disconnect();
 }
 
 void XmppClient::handleAlreadyRegistered(const glooxwrapper::JID&)
 {
 	DbgXMPP("the account already exists");
 }
 
 void XmppClient::handleDataForm(const glooxwrapper::JID&, const glooxwrapper::DataForm&)
 {
 	DbgXMPP("dataForm received");
 }
 
 void XmppClient::handleOOB(const glooxwrapper::JID&, const glooxwrapper::OOB&)
 {
 	DbgXMPP("OOB registration requested");
 }
 
 /*****************************************************
  * Requests from GUI                                 *
  *****************************************************/
 
 /**
  * Handle requests from the GUI for the list of players.
  *
  * @return A JS array containing all known players and their presences
  */
 void XmppClient::GUIGetPlayerList(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	scriptInterface.Eval("([])", ret);
 
 	// Convert the internal data structure to a Javascript object.
 	for (const std::pair<std::string, std::vector<std::string> >& p : m_PlayerMap)
 	{
 		JS::RootedValue player(cx);
 		scriptInterface.Eval("({})", &player);
 		scriptInterface.SetProperty(player, "name", wstring_from_utf8(p.first));
 		scriptInterface.SetProperty(player, "presence", wstring_from_utf8(p.second[0]));
 		scriptInterface.SetProperty(player, "rating", wstring_from_utf8(p.second[1]));
 		scriptInterface.SetProperty(player, "role", wstring_from_utf8(p.second[2]));
 		scriptInterface.CallFunctionVoid(ret, "push", player);
 	}
 }
 
 /**
  * Handle requests from the GUI for the list of all active games.
  *
  * @return A JS array containing all known games
  */
 void XmppClient::GUIGetGameList(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	scriptInterface.Eval("([])", ret);
 	const char* stats[] = { "name", "ip", "state", "nbp", "tnbp", "players", "mapName", "niceMapName", "mapSize", "mapType", "victoryCondition" };
 	for(const glooxwrapper::Tag* const& t : m_GameList)
 	{
 		JS::RootedValue game(cx);
 		scriptInterface.Eval("({})", &game);
 
 		for (size_t i = 0; i < ARRAY_SIZE(stats); ++i)
 			scriptInterface.SetProperty(game, stats[i], wstring_from_utf8(t->findAttribute(stats[i]).to_string()));
 
 		scriptInterface.CallFunctionVoid(ret, "push", game);
 	}
 }
 
 /**
  * Handle requests from the GUI for leaderboard data.
  *
  * @return A JS array containing all known leaderboard data
  */
 void XmppClient::GUIGetBoardList(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	scriptInterface.Eval("([])", ret);
 	const char* attributes[] = { "name", "rank", "rating" };
 	for(const glooxwrapper::Tag* const& t : m_BoardList)
 	{
 		JS::RootedValue board(cx);
 		scriptInterface.Eval("({})", &board);
 
 		for (size_t i = 0; i < ARRAY_SIZE(attributes); ++i)
 			scriptInterface.SetProperty(board, attributes[i], wstring_from_utf8(t->findAttribute(attributes[i]).to_string()));
 
 		scriptInterface.CallFunctionVoid(ret, "push", board);
 	}
 }
 
 /**
  * Handle requests from the GUI for profile data.
  *
  * @return A JS array containing the specific user's profile data
  */
 void XmppClient::GUIGetProfile(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	scriptInterface.Eval("([])", ret);
 	const char* stats[] = { "player", "rating", "totalGamesPlayed", "highestRating", "wins", "losses", "rank" };
 	for (const glooxwrapper::Tag* const& t : m_Profile)
 	{
 		JS::RootedValue profile(cx);
 		scriptInterface.Eval("({})", &profile);
 
 		for (size_t i = 0; i < ARRAY_SIZE(stats); ++i)
 			scriptInterface.SetProperty(profile, stats[i], wstring_from_utf8(t->findAttribute(stats[i]).to_string()));
 
 		scriptInterface.CallFunctionVoid(ret, "push", profile);
 	}
 }
 
 /*****************************************************
  * Message interfaces                                *
  *****************************************************/
 
 /**
  * Send GUI message queue when queried.
  */
 void XmppClient::GuiPollMessage(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	if (m_GuiMessageQueue.empty())
 	{
 		ret.setUndefined();
 		return;
 	}
 
 	GUIMessage message = m_GuiMessageQueue.front();
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	scriptInterface.Eval("({})", ret);
 	scriptInterface.SetProperty(ret, "type", message.type);
 	if (!message.from.empty())
 		scriptInterface.SetProperty(ret, "from", message.from);
 	if (!message.text.empty())
 		scriptInterface.SetProperty(ret, "text", message.text);
 	if (!message.level.empty())
 		scriptInterface.SetProperty(ret, "level", message.level);
 	if (!message.data.empty())
 		scriptInterface.SetProperty(ret, "data", message.data);
-	scriptInterface.SetProperty(ret, "time", message.time);
+	if (!message.datetime.empty())
+		scriptInterface.SetProperty(ret, "datetime", message.datetime);
 
 	m_GuiMessageQueue.pop_front();
 }
 
 /**
  * Send a standard MUC textual message.
  */
 void XmppClient::SendMUCMessage(const std::string& message)
 {
 	m_mucRoom->send(message);
 }
 
 /**
  * Push a message onto the GUI queue.
  *
  * @param message Message to add to the queue
  */
 void XmppClient::PushGuiMessage(XmppClient::GUIMessage message)
 {
 	m_GuiMessageQueue.push_back(std::move(message));
 }
 
 /**
  * Clears all presence updates from the message queue.
  * Used when rejoining the lobby, since we don't need to handle past presence changes.
  */
 void XmppClient::ClearPresenceUpdates()
 {
 	m_GuiMessageQueue.erase(
 		std::remove_if(m_GuiMessageQueue.begin(), m_GuiMessageQueue.end(),
 			[](XmppClient::GUIMessage& message)
 			{
 				return message.type == L"chat" && message.level == L"presence";
 			}
 	), m_GuiMessageQueue.end());
 }
 
 /**
  * Used in order to update the GUI only once when multiple updates are queued.
  */
 int XmppClient::GetMucMessageCount()
 {
 	return std::count_if(m_GuiMessageQueue.begin(), m_GuiMessageQueue.end(),
 		[](XmppClient::GUIMessage& message)
 		{
 			return message.type == L"chat";
 		});
 }
 
 /**
  * Handle a room message.
  */
 void XmppClient::handleMUCMessage(glooxwrapper::MUCRoom*, const glooxwrapper::Message& msg, bool)
 {
 	DbgXMPP(msg.from().resource() << " said " << msg.body());
 
 	GUIMessage message;
 	message.type = L"chat";
 	message.level = L"room-message";
 	message.from = wstring_from_utf8(msg.from().resource().to_string());
 	message.text = wstring_from_utf8(msg.body().to_string());
-	message.time = ComputeTimestamp(msg);
+	if (msg.when())
+		// See http://xmpp.org/extensions/xep-0082.html#sect-idp285136 for format
+		message.datetime = msg.when()->stamp().to_string();
 	PushGuiMessage(message);
 }
 
 /**
  * Handle a private message.
  */
 void XmppClient::handleMessage(const glooxwrapper::Message& msg, glooxwrapper::MessageSession *)
 {
 	DbgXMPP("type " << msg.subtype() << ", subject " << msg.subject()
 	  << ", message " << msg.body() << ", thread id " << msg.thread());
 
 	GUIMessage message;
 	message.type = L"chat";
 	message.level = L"private-message";
 	message.from = wstring_from_utf8(msg.from().username().to_string());
 	message.text = wstring_from_utf8(msg.body().to_string());
-	message.time = ComputeTimestamp(msg);
+	if (msg.when())
+		//See http://xmpp.org/extensions/xep-0082.html#sect-idp285136 for format
+		message.datetime = msg.when()->stamp().to_string();
 	PushGuiMessage(message);
 }
 
 /**
  * Handle portions of messages containing custom stanza extensions.
  */
 bool XmppClient::handleIq(const glooxwrapper::IQ& iq)
 {
 	DbgXMPP("handleIq [" << tag_xml(iq) << "]");
 
 	if (iq.subtype() == gloox::IQ::Result)
 	{
 		const GameListQuery* gq = iq.findExtension<GameListQuery>(EXTGAMELISTQUERY);
 		const BoardListQuery* bq = iq.findExtension<BoardListQuery>(EXTBOARDLISTQUERY);
 		const ProfileQuery* pq = iq.findExtension<ProfileQuery>(EXTPROFILEQUERY);
 		if (gq)
 		{
 			for (const glooxwrapper::Tag* const& t : m_GameList)
 				glooxwrapper::Tag::free(t);
 			m_GameList.clear();
 
 			for (const glooxwrapper::Tag* const& t : gq->m_GameList)
 				m_GameList.emplace_back(t->clone());
 
 			CreateGUIMessage("game", "gamelist");
 		}
 		if (bq)
 		{
 			if (bq->m_Command == "boardlist")
 			{
 				for (const glooxwrapper::Tag* const& t : m_BoardList)
 					glooxwrapper::Tag::free(t);
 				m_BoardList.clear();
 
 				for (const glooxwrapper::Tag* const& t : bq->m_StanzaBoardList)
 					m_BoardList.emplace_back(t->clone());
 
 				CreateGUIMessage("game", "leaderboard");
 			}
 			else if (bq->m_Command == "ratinglist")
 			{
 				for (const glooxwrapper::Tag* const& t : bq->m_StanzaBoardList)
 				{
 					std::string name = t->findAttribute("name").to_string();
 					if (m_PlayerMap.find(name) != m_PlayerMap.end())
 						m_PlayerMap[name][1] = t->findAttribute("rating").to_string();
 				}
 
 				CreateGUIMessage("game", "ratinglist");
 			}
 		}
 		if (pq)
 		{
 			for (const glooxwrapper::Tag* const& t : m_Profile)
 				glooxwrapper::Tag::free(t);
 			m_Profile.clear();
 
 			for (const glooxwrapper::Tag* const& t : pq->m_StanzaProfile)
 				m_Profile.emplace_back(t->clone());
 
 			CreateGUIMessage("game", "profile");
 		}
 	}
 	else if (iq.subtype() == gloox::IQ::Error)
 	{
 		gloox::StanzaError err = iq.error_error();
 		CreateGUIMessage("system", "error", StanzaErrorToString(err));
 	}
 	else
 	{
 		CreateGUIMessage("system", "error", g_L10n.Translate("unknown subtype (see logs)"));
 		std::string tag = tag_name(iq);
 		LOGMESSAGE("unknown subtype '%s'", tag.c_str());
 	}
 	return true;
 }
 
 /**
  * Create a new detail message for the GUI.
  *
  * @param type General message type
  * @param level Detailed message type
  * @param text Body of the message
  * @param data Optional field, used for auxiliary data
  */
 void XmppClient::CreateGUIMessage(const std::string& type, const std::string& level, const std::string& text, const std::string& data)
 {
 	GUIMessage message;
 	message.type = wstring_from_utf8(type);
 	message.level = wstring_from_utf8(level);
 	message.text = wstring_from_utf8(text);
 	message.data = wstring_from_utf8(data);
-	message.time = time(NULL);
 	PushGuiMessage(message);
 }
 
 /*****************************************************
  * Presence, nickname, and subject                   *
  *****************************************************/
 
 /**
  * Update local data when a user changes presence.
  */
 void XmppClient::handleMUCParticipantPresence(glooxwrapper::MUCRoom*, const glooxwrapper::MUCRoomParticipant participant, const glooxwrapper::Presence& presence)
 {
 	//std::string jid = participant.jid->full();
 	std::string nick = participant.nick->resource().to_string();
 	gloox::Presence::PresenceType presenceType = presence.presence();
 	std::string presenceString, roleString;
 	GetPresenceString(presenceType, presenceString);
 	GetRoleString(participant.role, roleString);
 	if (presenceType == gloox::Presence::Unavailable)
 	{
 		if (!participant.newNick.empty() && (participant.flags & (gloox::UserNickChanged | gloox::UserSelf)))
 		{
 			// we have a nick change
 			std::string newNick = participant.newNick.to_string();
 			m_PlayerMap[newNick].resize(3);
 			m_PlayerMap[newNick][0] = presenceString;
 			m_PlayerMap[newNick][2] = roleString;
 			CreateGUIMessage("chat", "nick", nick, participant.newNick.to_string());
 		}
 		else
 			CreateGUIMessage("chat", "leave", nick);
 
 		DbgXMPP(nick << " left the room");
 		m_PlayerMap.erase(nick);
 	}
 	else
 	{
 		/* During the initialization process, we recieve join messages for everyone
 		 * currently in the room. We don't want to display these, so we filter them
 		 * out. We will always be the last to join during initialization.
 		 */
 		if (!m_initialLoadComplete)
 		{
 			if (m_mucRoom->nick().to_string() == nick)
 				m_initialLoadComplete = true;
 		}
 		else if (m_PlayerMap.find(nick) == m_PlayerMap.end())
 			CreateGUIMessage("chat", "join", nick);
 		else
 			CreateGUIMessage("chat", "presence", nick);
 
 		DbgXMPP(nick << " is in the room, presence : " << (int)presenceType);
 		m_PlayerMap[nick].resize(3);
 		m_PlayerMap[nick][0] = presenceString;
 		m_PlayerMap[nick][2] = roleString;
 	}
 }
 
 /**
  * Update local cache when subject changes.
  */
 void XmppClient::handleMUCSubject(glooxwrapper::MUCRoom*, const glooxwrapper::string& UNUSED(nick), const glooxwrapper::string& subject)
 {
 	m_Subject = subject.c_str();
 	CreateGUIMessage("chat", "subject", m_Subject);
 }
 
 /**
  * Get current subject.
  *
  * @param topic Variable to store subject in.
  */
 void XmppClient::GetSubject(std::string& subject)
 {
 	subject = m_Subject;
 }
 
 /**
  * Request nick change, real change via mucRoomHandler.
  *
  * @param nick Desired nickname
  */
 void XmppClient::SetNick(const std::string& nick)
 {
 	m_mucRoom->setNick(nick);
 }
 
 /**
  * Get current nickname.
  *
  * @param nick Variable to store the nickname in.
  */
 void XmppClient::GetNick(std::string& nick)
 {
 	nick = m_mucRoom->nick().to_string();
 }
 
 /**
  * Kick a player from the current room.
  *
  * @param nick Nickname to be kicked
  * @param reason Reason the player was kicked
  */
 void XmppClient::kick(const std::string& nick, const std::string& reason)
 {
 	m_mucRoom->kick(nick, reason);
 }
 
 /**
  * Ban a player from the current room.
  *
  * @param nick Nickname to be banned
  * @param reason Reason the player was banned
  */
 void XmppClient::ban(const std::string& nick, const std::string& reason)
 {
 	m_mucRoom->ban(nick, reason);
 }
 
 /**
  * Change the xmpp presence of the client.
  *
  * @param presence A string containing the desired presence
  */
 void XmppClient::SetPresence(const std::string& presence)
 {
 #define IF(x,y) if (presence == x) m_mucRoom->setPresence(gloox::Presence::y)
 	IF("available", Available);
 	else IF("chat", Chat);
 	else IF("away", Away);
 	else IF("playing", DND);
 	else IF("offline", Unavailable);
 	// The others are not to be set
 #undef IF
 	else LOGERROR("Unknown presence '%s'", presence.c_str());
 }
 
 /**
  * Get the current xmpp presence of the given nick.
  *
  * @param nick Nickname to look up presence for
  * @param presence Variable to store the presence in
  */
 void XmppClient::GetPresence(const std::string& nick, std::string& presence)
 {
 	if (m_PlayerMap.find(nick) != m_PlayerMap.end())
 		presence = m_PlayerMap[nick][0];
 	else
 		presence = "offline";
 }
 
 /**
  * Get the current xmpp role of the given nick.
  *
  * @param nick Nickname to look up presence for
  * @param role Variable to store the role in
  */
 void XmppClient::GetRole(const std::string& nick, std::string& role)
 {
 	if (m_PlayerMap.find(nick) != m_PlayerMap.end())
 		role = m_PlayerMap[nick][2];
 	else
 		role = "";
 }
 
 /*****************************************************
  * Utilities                                         *
  *****************************************************/
 
 /**
- * Compute the POSIX timestamp of a message. Uses message datetime when possible, current time otherwise.
- *
- * @param msg The message on which to base the computation
- * @returns POSIX GMT/UTC seconds since Jan. 1st 1970
- */
-time_t XmppClient::ComputeTimestamp(const glooxwrapper::Message& msg)
-{
-	if (!msg.when())
-		return time(NULL);
-
-	glooxwrapper::string timestampStr = msg.when()->stamp();
-	struct tm timestamp = {0};
-
-	// See http://xmpp.org/extensions/xep-0082.html#sect-idp285136 for format
-	void * res = strptime(timestampStr.c_str(), "%Y-%m-%dT%H:%M:%SZ", &timestamp);
-	if (res == NULL)
-		LOGERROR("Recived delayed message with corrupted timestamp %s", timestampStr.to_string());
-
-	return mktime(&timestamp) - timezone;
-}
-
-/**
  * Convert a gloox presence type to string.
  *
  * @param p Presence to be converted
  * @param presence Variable to store the converted presence string in
  */
 void XmppClient::GetPresenceString(const gloox::Presence::PresenceType p, std::string& presence) const
 {
 	switch(p)
 	{
 #define CASE(x,y) case gloox::Presence::x: presence = y; break
 	CASE(Available, "available");
 	CASE(Chat, "chat");
 	CASE(Away, "away");
 	CASE(DND, "playing");
 	CASE(XA, "away");
 	CASE(Unavailable, "offline");
 	CASE(Probe, "probe");
 	CASE(Error, "error");
 	CASE(Invalid, "invalid");
 	default:
 		LOGERROR("Unknown presence type '%d'", (int)p);
 		break;
 #undef CASE
 	}
 }
 
 /**
  * Convert a gloox role type to string.
  *
  * @param p Role to be converted
  * @param presence Variable to store the converted role string in
  */
 void XmppClient::GetRoleString(const gloox::MUCRoomRole r, std::string& role) const
 {
 	switch(r)
 	{
 #define CASE(X, Y) case gloox::X: role = Y; break
 	CASE(RoleNone, "none");
 	CASE(RoleVisitor, "visitor");
 	CASE(RoleParticipant, "participant");
 	CASE(RoleModerator, "moderator");
 	CASE(RoleInvalid, "invalid");
 	default:
 		LOGERROR("Unknown role type '%d'", (int)r);
 		break;
 #undef CASE
 	}
 }
 
 /**
  * Convert a gloox stanza error type to string.
  * Keep in sync with Gloox documentation
  *
  * @param err Error to be converted
  * @return Converted error string
  */
 std::string XmppClient::StanzaErrorToString(gloox::StanzaError err) const
 {
 #define CASE(X, Y) case gloox::X: return Y
 #define DEBUG_CASE(X, Y) case gloox::X: return g_L10n.Translate("Error") + " (" + Y + ")"
 	switch (err)
 	{
 	CASE(StanzaErrorUndefined, g_L10n.Translate("No error"));
 	DEBUG_CASE(StanzaErrorBadRequest, "Server recieved malformed XML");
 	CASE(StanzaErrorConflict, g_L10n.Translate("Player already logged in"));
 	DEBUG_CASE(StanzaErrorFeatureNotImplemented, "Server does not implement requested feature");
 	CASE(StanzaErrorForbidden, g_L10n.Translate("Forbidden"));
 	DEBUG_CASE(StanzaErrorGone, "Unable to find message receipiant");
 	CASE(StanzaErrorInternalServerError, g_L10n.Translate("Internal server error"));
 	DEBUG_CASE(StanzaErrorItemNotFound, "Message receipiant does not exist");
 	DEBUG_CASE(StanzaErrorJidMalformed, "JID (XMPP address) malformed");
 	DEBUG_CASE(StanzaErrorNotAcceptable, "Receipiant refused message. Possible policy issue");
 	CASE(StanzaErrorNotAllowed, g_L10n.Translate("Not allowed"));
 	CASE(StanzaErrorNotAuthorized, g_L10n.Translate("Not authorized"));
 	DEBUG_CASE(StanzaErrorNotModified, "Requested item has not changed since last request");
 	DEBUG_CASE(StanzaErrorPaymentRequired, "This server requires payment");
 	CASE(StanzaErrorRecipientUnavailable, g_L10n.Translate("Recipient temporarily unavailable"));
 	DEBUG_CASE(StanzaErrorRedirect, "Request redirected");
 	CASE(StanzaErrorRegistrationRequired, g_L10n.Translate("Registration required"));
 	DEBUG_CASE(StanzaErrorRemoteServerNotFound, "Remote server not found");
 	DEBUG_CASE(StanzaErrorRemoteServerTimeout, "Remote server timed out");
 	DEBUG_CASE(StanzaErrorResourceConstraint, "The recipient is unable to process the message due to resource constraints");
 	CASE(StanzaErrorServiceUnavailable, g_L10n.Translate("Service unavailable"));
 	DEBUG_CASE(StanzaErrorSubscribtionRequired, "Service requires subscription");
 	DEBUG_CASE(StanzaErrorUnexpectedRequest, "Attempt to send from invalid stanza address");
 	DEBUG_CASE(StanzaErrorUnknownSender, "Invalid 'from' address");
 	default:
 		return g_L10n.Translate("Unknown error");
 	}
 #undef DEBUG_CASE
 #undef CASE
 }
 
 /**
  * Convert a gloox connection error enum to string
  * Keep in sync with Gloox documentation
  * 
  * @param err Error to be converted
  * @return Converted error string
  */
 std::string XmppClient::ConnectionErrorToString(gloox::ConnectionError err) const
 {
 #define CASE(X, Y) case gloox::X: return Y
 #define DEBUG_CASE(X, Y) case gloox::X: return g_L10n.Translate("Error") + " (" + Y + ")"
 	switch (err)
 	{
 	CASE(ConnNoError, g_L10n.Translate("No error"));
 	CASE(ConnStreamError, g_L10n.Translate("Stream error"));
 	CASE(ConnStreamVersionError, g_L10n.Translate("The incoming stream version is unsupported"));
 	CASE(ConnStreamClosed, g_L10n.Translate("The stream has been closed by the server"));
 	DEBUG_CASE(ConnProxyAuthRequired, "The HTTP/SOCKS5 proxy requires authentication");
 	DEBUG_CASE(ConnProxyAuthFailed, "HTTP/SOCKS5 proxy authentication failed");
 	DEBUG_CASE(ConnProxyNoSupportedAuth, "The HTTP/SOCKS5 proxy requires an unsupported authentication mechanism");
 	CASE(ConnIoError, g_L10n.Translate("An I/O error occured"));
 	DEBUG_CASE(ConnParseError, "An XML parse error occured");
 	CASE(ConnConnectionRefused, g_L10n.Translate("The connection was refused by the server"));
 	CASE(ConnDnsError, g_L10n.Translate("Resolving the server's hostname failed"));
 	CASE(ConnOutOfMemory, g_L10n.Translate("This system is out of memory"));
 	DEBUG_CASE(ConnNoSupportedAuth, "The authentication mechanisms the server offered are not supported or no authentication mechanisms were available");
 	CASE(ConnTlsFailed, g_L10n.Translate("The server's certificate could not be verified or the TLS handshake did not complete successfully"));
 	CASE(ConnTlsNotAvailable, g_L10n.Translate("The server did not offer required TLS encryption"));
 	DEBUG_CASE(ConnCompressionFailed, "Negotiation/initializing compression failed");
 	CASE(ConnAuthenticationFailed, g_L10n.Translate("Authentication failed. Incorrect password or account does not exist"));
 	CASE(ConnUserDisconnected, g_L10n.Translate("The user or system requested a disconnect"));
 	CASE(ConnNotConnected, g_L10n.Translate("There is no active connection"));
 	default:
 		return g_L10n.Translate("Unknown error");
 	}
 #undef DEBUG_CASE
 #undef CASE
 }
 
 /**
  * Convert a gloox registration result enum to string
  * Keep in sync with Gloox documentation
  * 
  * @param err Enum to be converted
  * @return Converted string
  */
 std::string XmppClient::RegistrationResultToString(gloox::RegistrationResult res) const
 {
 #define CASE(X, Y) case gloox::X: return Y
 #define DEBUG_CASE(X, Y) case gloox::X: return g_L10n.Translate("Error") + " (" + Y + ")"
 	switch (res)
 	{
 	CASE(RegistrationSuccess, g_L10n.Translate("Success"));
 	CASE(RegistrationNotAcceptable, g_L10n.Translate("Not all necessary information provided"));
 	CASE(RegistrationConflict, g_L10n.Translate("Username already exists"));
 	DEBUG_CASE(RegistrationNotAuthorized, "Account removal timeout or insufficiently secure channel for password change");
 	DEBUG_CASE(RegistrationBadRequest, "Server recieved incomplete request");
 	DEBUG_CASE(RegistrationForbidden, "This client has insufficient permissions to remove an account");
 	DEBUG_CASE(RegistrationRequired, "Account cannot be removed as it does not exist");
 	DEBUG_CASE(RegistrationUnexpectedRequest, "This client is unregistered with the server");
 	DEBUG_CASE(RegistrationNotAllowed, "Server does not permit password changes");
 	default:
 		return g_L10n.Translate("Unknown error");
 	}
 #undef DEBUG_CASE
 #undef CASE
 }
Index: ps/trunk/source/lobby/XmppClient.h
===================================================================
--- ps/trunk/source/lobby/XmppClient.h	(revision 17940)
+++ ps/trunk/source/lobby/XmppClient.h	(revision 17941)
@@ -1,167 +1,166 @@
 /* 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 XXXMPPCLIENT_H
 #define XXXMPPCLIENT_H
 
 #include "IXmppClient.h"
 
 #include <deque>
 
 #include "glooxwrapper/glooxwrapper.h"
 #include "scriptinterface/ScriptVal.h"
 
 class ScriptInterface;
 
 namespace glooxwrapper
 {
 	class Client;
 	struct CertInfo;
 }
 
 class XmppClient : public IXmppClient, public glooxwrapper::ConnectionListener, public glooxwrapper::MUCRoomHandler, public glooxwrapper::IqHandler, public glooxwrapper::RegistrationHandler, public glooxwrapper::MessageHandler
 {
 	NONCOPYABLE(XmppClient);
 
 private:
 	// Components
 	glooxwrapper::Client* m_client;
 	glooxwrapper::MUCRoom* m_mucRoom;
 	glooxwrapper::Registration* m_registration;
 
 	// Account infos
 	std::string m_username;
 	std::string m_password;
 	std::string m_nick;
 	std::string m_xpartamuppId;
 
 	// State
 	bool m_initialLoadComplete;
 
 public:
 	// Basic
 	XmppClient(const std::string& sUsername, const std::string& sPassword, const std::string& sRoom, const std::string& sNick, const int historyRequestSize = 0, const bool regOpt = false);
 	virtual ~XmppClient();
 
 	// Network
 	void connect();
 	void disconnect();
 	void recv();
 	void SendIqGetGameList();
 	void SendIqGetBoardList();
 	void SendIqGetRatingList();
 	void SendIqGetProfile(const std::string& player);
 	void SendIqGameReport(ScriptInterface& scriptInterface, JS::HandleValue data);
 	void SendIqRegisterGame(ScriptInterface& scriptInterface, JS::HandleValue data);
 	void SendIqUnregisterGame();
 	void SendIqChangeStateGame(const std::string& nbp, const std::string& players);
 	void SetNick(const std::string& nick);
 	void GetNick(std::string& nick);
 	void kick(const std::string& nick, const std::string& reason);
 	void ban(const std::string& nick, const std::string& reason);
 	void SetPresence(const std::string& presence);
 	void GetPresence(const std::string& nickname, std::string& presence);
 	void GetRole(const std::string& nickname, std::string& role);
 	void GetSubject(std::string& subject);
 
 	void GUIGetPlayerList(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
 	void GUIGetGameList(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
 	void GUIGetBoardList(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
 	void GUIGetProfile(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
 
 	//Script
 	ScriptInterface& GetScriptInterface();
 
 protected:
 	/* Xmpp handlers */
 	/* MUC handlers */
 	virtual void handleMUCParticipantPresence(glooxwrapper::MUCRoom*, const glooxwrapper::MUCRoomParticipant, const glooxwrapper::Presence&);
 	virtual void handleMUCError(glooxwrapper::MUCRoom*, gloox::StanzaError);
 	virtual void handleMUCMessage(glooxwrapper::MUCRoom* room, const glooxwrapper::Message& msg, bool priv);
 	virtual void handleMUCSubject(glooxwrapper::MUCRoom*, const glooxwrapper::string& nick, const glooxwrapper::string& subject);
 	/* MUC handlers not supported by glooxwrapper */
 	// virtual bool handleMUCRoomCreation(glooxwrapper::MUCRoom*) {return false;}
 	// virtual void handleMUCInviteDecline(glooxwrapper::MUCRoom*, const glooxwrapper::JID&, const std::string&) {}
 	// virtual void handleMUCInfo(glooxwrapper::MUCRoom*, int, const std::string&, const glooxwrapper::DataForm*) {}
 	// virtual void handleMUCItems(glooxwrapper::MUCRoom*, const std::list<gloox::Disco::Item*, std::allocator<gloox::Disco::Item*> >&) {}
 
 	/* Log handler */
 	virtual void handleLog(gloox::LogLevel level, gloox::LogArea area, const std::string& message);
 
 	/* ConnectionListener handlers*/
 	virtual void onConnect();
 	virtual void onDisconnect(gloox::ConnectionError e);
 	virtual bool onTLSConnect(const glooxwrapper::CertInfo& info);
 
 	/* Iq Handlers */
 	virtual bool handleIq(const glooxwrapper::IQ& iq);
 	virtual void handleIqID(const glooxwrapper::IQ&, int) {}
 
 	/* Registration Handlers */
 	virtual void handleRegistrationFields(const glooxwrapper::JID& /*from*/, int fields, glooxwrapper::string instructions );
 	virtual void handleRegistrationResult(const glooxwrapper::JID& /*from*/, gloox::RegistrationResult result);
 	virtual void handleAlreadyRegistered(const glooxwrapper::JID& /*from*/);
 	virtual void handleDataForm(const glooxwrapper::JID& /*from*/, const glooxwrapper::DataForm& /*form*/);
 	virtual void handleOOB(const glooxwrapper::JID& /*from*/, const glooxwrapper::OOB& oob);
 
 	/* Message Handler */
 	virtual void handleMessage(const glooxwrapper::Message& msg, glooxwrapper::MessageSession * session);
 
 	// Helpers
 	void GetPresenceString(const gloox::Presence::PresenceType p, std::string& presence) const;
 	void GetRoleString(const gloox::MUCRoomRole r, std::string& role) const;
 	std::string StanzaErrorToString(gloox::StanzaError err) const;
 	std::string ConnectionErrorToString(gloox::ConnectionError err) const;
 	std::string RegistrationResultToString(gloox::RegistrationResult res) const;
-	time_t ComputeTimestamp(const glooxwrapper::Message& msg);
 
 public:
 	/* Messages */
 	struct GUIMessage
 	{
 		std::wstring type;
 		std::wstring level;
 		std::wstring text;
 		std::wstring data;
 		std::wstring from;
 		std::wstring message;
-		time_t time;
+		std::string datetime;
 	};
 	void GuiPollMessage(ScriptInterface& scriptInterface, JS::MutableHandleValue ret);
 	void SendMUCMessage(const std::string& message);
 	void ClearPresenceUpdates();
 	int GetMucMessageCount();
 protected:
 	void PushGuiMessage(XmppClient::GUIMessage message);
 	void CreateGUIMessage(const std::string& type, const std::string& level, const std::string& text = "", const std::string& data = "");
 
 private:
 	/// Map of players
 	std::map<std::string, std::vector<std::string> > m_PlayerMap;
 	/// List of games
 	std::vector<const glooxwrapper::Tag*> m_GameList;
 	/// List of rankings
 	std::vector<const glooxwrapper::Tag*> m_BoardList;
 	/// Profile data
 	std::vector<const glooxwrapper::Tag*> m_Profile;
 	/// Queue of messages for the GUI
 	std::deque<GUIMessage> m_GuiMessageQueue;
 	/// Current room subject/topic.
 	std::string m_Subject;
 };
 
 #endif // XMPPCLIENT_H