Index: ps/trunk/source/graphics/ColladaManager.cpp
===================================================================
--- ps/trunk/source/graphics/ColladaManager.cpp	(revision 20368)
+++ ps/trunk/source/graphics/ColladaManager.cpp	(revision 20369)
@@ -1,433 +1,433 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2017 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 "ColladaManager.h"
 
 #include <boost/algorithm/string.hpp>
 
 #include "graphics/ModelDef.h"
 #include "lib/fnv_hash.h"
 #include "maths/MD5.h"
 #include "ps/CacheLoader.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/DllLoader.h"
 #include "ps/Filesystem.h"
 
 namespace Collada
 {
 	#include "collada/DLL.h"
 }
 
 namespace
 {
 	void ColladaLog(void* cb_data, int severity, const char* text)
 	{
 		VfsPath* path = static_cast<VfsPath*>(cb_data);
 
 		if (severity == LOG_INFO)
 			LOGMESSAGE("%s: %s", path->string8(), text);
 		else if (severity == LOG_WARNING)
 			LOGWARNING("%s: %s", path->string8(), text);
 		else
 			LOGERROR("%s: %s", path->string8(), text);
 	}
 
 	void ColladaOutput(void* cb_data, const char* data, unsigned int length)
 	{
 		WriteBuffer* writeBuffer = static_cast<WriteBuffer*>(cb_data);
 		writeBuffer->Append(data, (size_t)length);
 	}
 }
 
 class CColladaManagerImpl
 {
 	DllLoader dll;
 
 	void (*set_logger)(Collada::LogFn logger, void* cb_data);
 	int (*set_skeleton_definitions)(const char* xml, int length);
 	int (*convert_dae_to_pmd)(const char* dae, Collada::OutputFn pmd_writer, void* cb_data);
 	int (*convert_dae_to_psa)(const char* dae, Collada::OutputFn psa_writer, void* cb_data);
 
 public:
 	CColladaManagerImpl(const PIVFS& vfs)
 		: dll("Collada"), m_VFS(vfs), m_skeletonHashInvalidated(true)
 	{
 		// Support hotloading
 		RegisterFileReloadFunc(ReloadChangedFileCB, this);
 	}
 
 	~CColladaManagerImpl()
 	{
 		if (dll.IsLoaded())
 			set_logger(NULL, NULL); // unregister the log handler
 		UnregisterFileReloadFunc(ReloadChangedFileCB, this);
 	}
 
 	Status ReloadChangedFile(const VfsPath& path)
 	{
 		// Ignore files that aren't in the right path
 		if (!boost::algorithm::starts_with(path.string(), L"art/skeletons/"))
 			return INFO::OK;
 
 		if (path.Extension() != L".xml")
 			return INFO::OK;
 
 		m_skeletonHashInvalidated = true;
 
 		// If the file doesn't exist (e.g. it was deleted), don't bother reloading
 		// or 'unloading' since that isn't possible
 		if (!VfsFileExists(path))
 			return INFO::OK;
 
 		if (!dll.IsLoaded() && !TryLoadDLL())
 			return ERR::FAIL;
 
 		LOGMESSAGE("Hotloading skeleton definitions from '%s'", path.string8());
 		// Set the filename for the logger to report
 		set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&path)));
 
 		CVFSFile skeletonFile;
 		if (skeletonFile.Load(m_VFS, path) != PSRETURN_OK)
 		{
-			LOGERROR("Failed to read skeleton defintions from '%s'", path.string8());
+			LOGERROR("Failed to read skeleton definitions from '%s'", path.string8());
 			return ERR::FAIL;
 		}
 
 		int ok = set_skeleton_definitions((const char*)skeletonFile.GetBuffer(), (int)skeletonFile.GetBufferSize());
 		if (ok < 0)
 		{
 			LOGERROR("Failed to load skeleton definitions from '%s'", path.string8());
 			return ERR::FAIL;
 		}
 
 		return INFO::OK;
 	}
 
 	static Status ReloadChangedFileCB(void* param, const VfsPath& path)
 	{
 		return static_cast<CColladaManagerImpl*>(param)->ReloadChangedFile(path);
 	}
 
 	bool Convert(const VfsPath& daeFilename, const VfsPath& pmdFilename, CColladaManager::FileType type)
 	{
 		// To avoid always loading the DLL when it's usually not going to be
 		// used (and to do the same on Linux where delay-loading won't help),
 		// and to avoid compile-time dependencies (because it's a minor pain
 		// to get all the right libraries to build the COLLADA DLL), we load
 		// it dynamically when it is required, instead of using the exported
 		// functions and binding at link-time.
 		if (!dll.IsLoaded())
 		{
 			if (!TryLoadDLL())
 				return false;
 
 			if (!LoadSkeletonDefinitions())
 			{
 				dll.Unload(); // Error should have been logged already
 				return false;
 			}
 		}
 
 		// Set the filename for the logger to report
 		set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&daeFilename)));
 
 		// We need to null-terminate the buffer, so do it (possibly inefficiently)
 		// by converting to a CStr
 		CStr daeData;
 		{
 			CVFSFile daeFile;
 			if (daeFile.Load(m_VFS, daeFilename) != PSRETURN_OK)
 				return false;
 			daeData = daeFile.GetAsString();
 		}
 
 		// Do the conversion into a memory buffer
 		// We need to check the result, as archive builder needs to know if the source dae
 		//	was sucessfully converted to .pmd/psa
 		int result = -1;
 		WriteBuffer writeBuffer;
 		switch (type)
 		{
 		case CColladaManager::PMD:
 			result = convert_dae_to_pmd(daeData.c_str(), ColladaOutput, &writeBuffer);
 			break;
 		case CColladaManager::PSA:
 			result = convert_dae_to_psa(daeData.c_str(), ColladaOutput, &writeBuffer);
 			break;
 		}
 
 		// don't create zero-length files (as happens in test_invalid_dae when
 		// we deliberately pass invalid XML data) because the VFS caching
 		// logic warns when asked to load such.
 		if (writeBuffer.Size())
 		{
 			Status ret = m_VFS->CreateFile(pmdFilename, writeBuffer.Data(), writeBuffer.Size());
 			ENSURE(ret == INFO::OK);
 		}
 
 		return (result == 0);
 	}
 
 	bool TryLoadDLL()
 	{
 		if (!dll.LoadDLL())
 		{
 			LOGERROR("Failed to load COLLADA conversion DLL");
 			return false;
 		}
 
 		try
 		{
 			dll.LoadSymbol("set_logger", set_logger);
 			dll.LoadSymbol("set_skeleton_definitions", set_skeleton_definitions);
 			dll.LoadSymbol("convert_dae_to_pmd", convert_dae_to_pmd);
 			dll.LoadSymbol("convert_dae_to_psa", convert_dae_to_psa);
 		}
 		catch (PSERROR_DllLoader&)
 		{
 			LOGERROR("Failed to load symbols from COLLADA conversion DLL");
 			dll.Unload();
 			return false;
 		}
 		return true;
 	}
 
 	bool LoadSkeletonDefinitions()
 	{
 		VfsPaths pathnames;
 		if (vfs::GetPathnames(m_VFS, L"art/skeletons/", L"*.xml", pathnames) < 0)
 		{
 			LOGERROR("No skeleton definition files present");
 			return false;
 		}
 
 		bool loaded = false;
 		for (const VfsPath& path : pathnames)
 		{
 			LOGMESSAGE("Loading skeleton definitions from '%s'", path.string8());
 			// Set the filename for the logger to report
 			set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&path)));
 
 			CVFSFile skeletonFile;
 			if (skeletonFile.Load(m_VFS, path) != PSRETURN_OK)
 			{
-				LOGERROR("Failed to read skeleton defintions from '%s'", path.string8());
+				LOGERROR("Failed to read skeleton definitions from '%s'", path.string8());
 				continue;
 			}
 
 			int ok = set_skeleton_definitions((const char*)skeletonFile.GetBuffer(), (int)skeletonFile.GetBufferSize());
 			if (ok < 0)
 			{
 				LOGERROR("Failed to load skeleton definitions from '%s'", path.string8());
 				continue;
 			}
 
 			loaded = true;
 		}
 
 		if (!loaded)
 			LOGERROR("Failed to load any skeleton definitions");
 
 		return loaded;
 	}
 
 	/**
 	 * Creates MD5 hash key from skeletons.xml info and COLLADA converter version,
 	 * used to invalidate cached .pmd/psas
 	 *
 	 * @param[out] hash resulting MD5 hash
 	 * @param[out] version version passed to CCacheLoader, used if code change should force
 	 *		  cache invalidation
 	 */
 	void PrepareCacheKey(MD5& hash, u32& version)
 	{
 		// Add converter version to the hash
 		version = COLLADA_CONVERTER_VERSION;
 
 		// Cache the skeleton files hash data
 		if (m_skeletonHashInvalidated)
 		{
 			VfsPaths paths;
 			if (vfs::GetPathnames(m_VFS, L"art/skeletons/", L"*.xml", paths) != INFO::OK)
 			{
 				LOGWARNING("Failed to load skeleton definitions");
 				return;
 			}
 
 			// Sort the paths to not invalidate the cache if mods are mounted in different order
 			// (No need to stable_sort as the VFS gurantees that we have no duplicates)
 			std::sort(paths.begin(), paths.end());
 
 			// We need two u64s per file
 			m_skeletonHashes.clear();
 			m_skeletonHashes.reserve(paths.size()*2);
 
 			CFileInfo fileInfo;
 			for (const VfsPath& path : paths)
 			{
 				// This will cause an assertion failure if *it doesn't exist,
 				//	because fileinfo is not a NULL pointer, which is annoying but that
 				//	should never happen, unless there really is a problem
 				if (m_VFS->GetFileInfo(path, &fileInfo) != INFO::OK)
 				{
 					LOGERROR("Failed to stat '%s' for DAE caching", path.string8());
 				}
 				else
 				{
 					m_skeletonHashes.push_back((u64)fileInfo.MTime() & ~1); //skip lowest bit, since zip and FAT don't preserve it
 					m_skeletonHashes.push_back((u64)fileInfo.Size());
 				}
 			}
 
 			// Check if we were able to load any skeleton files
 			if (m_skeletonHashes.empty())
 				LOGERROR("Failed to stat any skeleton definitions for DAE caching");
 				// We can continue, something else will break if we try loading a skeletal model
 
 			m_skeletonHashInvalidated = false;
 		}
 
 		for (const u64& h : m_skeletonHashes)
 			hash.Update((const u8*)&h, sizeof(h));
 	}
 
 private:
 	PIVFS m_VFS;
 	bool m_skeletonHashInvalidated;
 	std::vector<u64> m_skeletonHashes;
 };
 
 CColladaManager::CColladaManager(const PIVFS& vfs)
 : m(new CColladaManagerImpl(vfs)), m_VFS(vfs)
 {
 }
 
 CColladaManager::~CColladaManager()
 {
 	delete m;
 }
 
 VfsPath CColladaManager::GetLoadablePath(const VfsPath& pathnameNoExtension, FileType type)
 {
 	std::wstring extn;
 	switch (type)
 	{
 	case PMD: extn = L".pmd"; break;
 	case PSA: extn = L".psa"; break;
 		// no other alternatives
 	}
 
 	/*
 
 	Algorithm:
 	* Calculate hash of skeletons.xml and converter version.
 	* Use CCacheLoader to check for archived or loose cached .pmd/psa.
 	* If cached version exists:
 		* Return pathname of cached .pmd/psa.
 	* Else, if source .dae for this model exists:
 		* Convert it to cached .pmd/psa.
 		* If converter succeeded:
 			* Return pathname of cached .pmd/psa.
 		* Else, fail (return empty path).
 	* Else, if uncached .pmd/psa exists:
 		* Return pathname of uncached .pmd/psa.
 	* Else, fail (return empty path).
 
 	Since we use CCacheLoader which automatically hashes file size and mtime,
 	and handles archived files and loose cache, when preparing the cache key
 	we add converter version number (so updates of the converter cause
 	regeneration of the .pmd/psa) and the global skeletons.xml file size and
 	mtime, as modelers frequently change the contents of skeletons.xml and get
 	perplexed if the in-game models haven't updated as expected (we don't know
 	which models were affected by the skeletons.xml change, if any, so we just
 	regenerate all of them)
 
 	TODO (maybe): The .dae -> .pmd/psa conversion may fail (e.g. if the .dae is
 	invalid or unsupported), but it may take a long time to start the conversion
 	then realise it's not going to work. That will delay the loading of the game
 	every time, which is annoying, so maybe it should cache the error message
 	until the .dae is updated and fixed. (Alternatively, avoid having that many
 	broken .daes in the game.)
 
 	*/
 
 	// Now we're looking for cached files
 	CCacheLoader cacheLoader(m_VFS, extn);
 	MD5 hash;
 	u32 version;
 	m->PrepareCacheKey(hash, version);
 
 	VfsPath cachePath;
 	VfsPath sourcePath = pathnameNoExtension.ChangeExtension(L".dae");
 	Status ret = cacheLoader.TryLoadingCached(sourcePath, hash, version, cachePath);
 
 	if (ret == INFO::OK)
 		// Found a valid cached version
 		return cachePath;
 
 	// No valid cached version, check if we have a source .dae
 	if (ret != INFO::SKIPPED)
 	{
 		// No valid cached version was found, and no source .dae exists
 		ENSURE(ret < 0);
 
 		// Check if source (uncached) .pmd/psa exists
 		sourcePath = pathnameNoExtension.ChangeExtension(extn);
 		if (m_VFS->GetFileInfo(sourcePath, NULL) != INFO::OK)
 		{
 			// Broken reference, the caller will need to handle this
 			return L"";
 		}
 		else
 		{
 			return sourcePath;
 		}
 	}
 
 	// No valid cached version was found - but source .dae exists
 	// We'll try converting it
 
 	// We have a source .dae and invalid cached version, so regenerate cached version
 	if (! m->Convert(sourcePath, cachePath, type))
 	{
 		// The COLLADA converter failed for some reason, this will need to be handled
 		//	by the caller
 		return L"";
 	}
 
 	return cachePath;
 }
 
 bool CColladaManager::GenerateCachedFile(const VfsPath& sourcePath, FileType type, VfsPath& archiveCachePath)
 {
 	std::wstring extn;
 	switch (type)
 	{
 	case PMD: extn = L".pmd"; break;
 	case PSA: extn = L".psa"; break;
 		// no other alternatives
 	}
 
 	CCacheLoader cacheLoader(m_VFS, extn);
 
 	archiveCachePath = cacheLoader.ArchiveCachePath(sourcePath);
 
 	return m->Convert(sourcePath, VfsPath("cache") / archiveCachePath, type);
 }
Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 20368)
+++ ps/trunk/source/gui/CGUI.h	(revision 20369)
@@ -1,638 +1,638 @@
 /* Copyright (C) 2017 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/>.
  */
 
 /*
  * This is the top class of the whole GUI, all objects
  * and settings are stored within this class.
  */
 
 #ifndef INCLUDED_CGUI
 #define INCLUDED_CGUI
 
 #include "GUITooltip.h"
 #include "GUIbase.h"
 
 #include "lib/input.h"
 #include "ps/Shapes.h"
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <boost/unordered_set.hpp>
 
 ERROR_TYPE(GUI, JSOpenFailed);
 
 extern const double SELECT_DBLCLICK_RATE;
 
 /**
  * Contains a list of values for new defaults to objects.
  */
 struct SGUIStyle
 {
 	std::map<CStr, CStrW> m_SettingsDefaults;
 };
 
 class JSObject; // The GUI stores a JSObject*, so needs to know that JSObject exists
 class IGUIObject;
 class CGUISpriteInstance;
 struct SGUIText;
 struct CColor;
 struct SGUIText;
 struct SGUIIcon;
 class CGUIString;
 class CGUISprite;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
 class GUITooltip;
 
 /**
  * The main object that represents a whole GUI page.
  *
  * No interfacial functions throws.
  */
 class CGUI
 {
 	NONCOPYABLE(CGUI);
 
 	friend class IGUIObject;
 	friend class IGUIScrollBarOwner;
 	friend class CInternalCGUIAccessorBase;
 
 private:
 	// Private typedefs
 	typedef IGUIObject *(*ConstructObjectFunction)();
 
 public:
 	CGUI(const shared_ptr<ScriptRuntime>& runtime);
 	~CGUI();
 
 	/**
 	 * Initializes the GUI, needs to be called before the GUI is used
 	 */
 	void Initialize();
 
 	/**
 	 * Performs processing that should happen every frame
 	 * (including sending the "Tick" event to scripts)
 	 */
 	void TickObjects();
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param EventName String representation of event name
 	 */
 	void SendEventToAll(const CStr& EventName);
 
 	/**
 	 * Displays the whole GUI
 	 */
 	void Draw();
 
 	/**
 	 * Draw GUI Sprite
 	 *
 	 * @param Sprite Object referring to the sprite (which also caches
 	 *        calculations for faster rendering)
 	 * @param CellID Number of the icon cell to use. (Ignored if this sprite doesn't
 	 *        have any images with "cell-size")
 	 * @param Z Drawing order, depth value
 	 * @param Rect Position and Size
 	 * @param Clipping The sprite shouldn't be drawn outside this rectangle
 	 */
 	void DrawSprite(const CGUISpriteInstance& Sprite, int CellID, const float& Z, const CRect& Rect, const CRect& Clipping = CRect());
 
 	/**
 	 * Draw a SGUIText object
 	 *
 	 * @param Text Text object.
 	 * @param DefaultColor Color used if no tag applied.
 	 * @param pos position
 	 * @param z z value.
 	 * @param clipping
 	 */
 	void DrawText(SGUIText& Text, const CColor& DefaultColor, const CPos& pos, const float& z, const CRect& clipping);
 
 	/**
 	 * Clean up, call this to clean up all memory allocated
 	 * within the GUI.
 	 */
 	void Destroy();
 
 	/**
 	 * The replacement of Process(), handles an SDL_Event_
 	 *
 	 * @param ev SDL Event, like mouse/keyboard input
 	 */
 	InReaction HandleEvent(const SDL_Event_* ev);
 
 	/**
 	 * Load a GUI XML file into the GUI.
 	 *
 	 * <b>VERY IMPORTANT!</b> All \<styles\>-files must be read before
 	 * everything else!
 	 *
 	 * @param Filename Name of file
 	 * @param Paths Set of paths; all XML and JS files loaded will be added to this
 	 */
 	void LoadXmlFile(const VfsPath& Filename, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Checks if object exists and return true or false accordingly
 	 *
 	 * @param Name String name of object
 	 * @return true if object exists
 	 */
 	bool ObjectExists(const CStr& Name) const;
 
 
 	/**
 	 * Returns the GUI object with the desired name, or NULL
 	 * if no match is found,
 	 *
 	 * @param Name String name of object
 	 * @return Matching object, or NULL
 	 */
 	IGUIObject* FindObjectByName(const CStr& Name) const;
 
 	/**
 	 * Returns the GUI object under the mouse, or NULL if none.
 	 */
 	IGUIObject* FindObjectUnderMouse() const;
 
 	/**
 	 * The GUI needs to have all object types inputted and
 	 * their constructors. Also it needs to associate a type
 	 * by a string name of the type.
 	 *
 	 * To add a type:
 	 * @code
 	 * AddObjectType("button", &CButton::ConstructObject);
 	 * @endcode
 	 *
 	 * @param str Reference name of object type
 	 * @param pFunc Pointer of function ConstuctObject() in the object
 	 *
 	 * @see CGUI#ConstructObject()
 	 */
 	void AddObjectType(const CStr& str, ConstructObjectFunction pFunc) { m_ObjectTypes[str] = pFunc; }
 
 	/**
 	 * Update Resolution, should be called every time the resolution
 	 * of the OpenGL screen has been changed, this is because it needs
 	 * to re-cache all its actual sizes
 	 *
 	 * Needs no input since screen resolution is global.
 	 *
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	void UpdateResolution();
 
 	/**
 	 * Generate a SGUIText object from the inputted string.
 	 * The function will break down the string and its
 	 * tags to calculate exactly which rendering queries
 	 * will be sent to the Renderer. Also, horizontal alignment
 	 * is taken into acount in this method but NOT vertical alignment.
 	 *
 	 * Done through the CGUI since it can communicate with
 	 *
 	 * @param Text Text to generate SGUIText object from
 	 * @param Font Default font, notice both Default color and default font
 	 *		  can be changed by tags.
 	 * @param Width Width, 0 if no word-wrapping.
 	 * @param BufferZone space between text and edge, and space between text and images.
 	 * @param pObject Optional parameter for error output. Used *only* if error parsing fails,
-	 *		  and we need to be able to output which object the error occured in to aid the user.
+	 *		  and we need to be able to output which object the error occurred in to aid the user.
 	 */
 	SGUIText GenerateText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone, const IGUIObject* pObject = NULL);
 
 
 	/**
 	 * Check if an icon exists
 	 */
 	bool IconExists(const CStr& str) const { return (m_Icons.count(str) != 0); }
 
 	/**
 	 * Get Icon (a copy, can never be changed)
 	 */
 	SGUIIcon GetIcon(const CStr& str) const { return m_Icons.find(str)->second; }
 
 	/**
 	 * Get pre-defined color (if it exists)
 	 * Returns false if it fails.
 	 */
 	bool GetPreDefinedColor(const CStr& name, CColor& Output) const;
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 	JS::Value GetGlobalObject() { return m_ScriptInterface->GetGlobalObject(); };
 
 private:
 
 	/**
 	 * Updates the object pointers, needs to be called each
 	 * time an object has been added or removed.
 	 *
 	 * This function is atomic, meaning if it throws anything, it will
 	 * have seen it through that nothing was ultimately changed.
 	 *
 	 * @throws PSERROR_GUI that is thrown from IGUIObject::AddToPointersMap().
 	 */
 	void UpdateObjects();
 
 	/**
 	 * Adds an object to the GUI's object database
 	 * Private, since you can only add objects through
 	 * XML files. Why? Because it enables the GUI to
 	 * be much more encapsulated and safe.
 	 *
 	 * @throws	Rethrows PSERROR_GUI from IGUIObject::AddChild().
 	 */
 	void AddObject(IGUIObject* pObject);
 
 	/**
 	 * You input the name of the object type, and let's
 	 * say you input "button", then it will construct a
 	 * CGUIObjet* as a CButton.
 	 *
 	 * @param str Name of object type
 	 * @return Newly constructed IGUIObject (but constructed as a subclass)
 	 */
 	IGUIObject* ConstructObject(const CStr& str);
 
 	/**
 	 * Get Focused Object.
 	 */
 	IGUIObject* GetFocusedObject() { return m_FocusedObject; }
 
 public:
 	/**
 	 * Change focus to new object.
 	 * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 	 * pObject can be NULL to remove all focus.
 	 */
 	void SetFocusedObject(IGUIObject* pObject);
 
 private:
 	//--------------------------------------------------------
 	/** @name XML Reading Xeromyces specific subroutines
 	 *
 	 * These does not throw!
 	 * Because when reading in XML files, it won't be fatal
 	 * if an error occurs, perhaps one particular object
 	 * fails, but it'll still continue reading in the next.
 	 * All Error are reported with ReportParseError
 	 */
 	//--------------------------------------------------------
 
 	/*
 		Xeromyces_* functions tree
 		<objects> (ReadRootObjects)
 		 |
 		 +-<script> (ReadScript)
 		 |
 		 +-<object> (ReadObject)
 			|
 			+-<action>
 			|
 			+-Optional Type Extensions (IGUIObject::ReadExtendedElement) TODO
 			|
 			+-<<object>> *recursive*
 
 
 		<styles> (ReadRootStyles)
 		 |
 		 +-<style> (ReadStyle)
 
 
 		<sprites> (ReadRootSprites)
 		 |
 		 +-<sprite> (ReadSprite)
 			|
 			+-<image> (ReadImage)
 
 
 		<setup> (ReadRootSetup)
 		 |
 		 +-<tooltip> (ReadToolTip)
 		 |
 		 +-<scrollbar> (ReadScrollBar)
 		 |
 		 +-<icon> (ReadIcon)
 		 |
 		 +-<color> (ReadColor)
 	*/
 	//@{
 
 	// Read Roots
 
 	/**
 	 * Reads in the root element \<objects\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the objects-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Collects the set of all XML/JS files that are loaded
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the root element \<sprites\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprites-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<styles\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the styles-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the root element \<setup\> (the DOMElement).
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the setup-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile);
 
 	// Read Subs
 
 	/**
 	 * Notice! Recursive function!
 	 *
 	 * Read in an \<object\> (the XMBElement) and stores it
 	 * as a child in the pParent.
 	 *
 	 * It will also check the object's children and call this function
 	 * on them too. Also it will call all other functions that reads
 	 * in other stuff that can be found within an object. Check the
 	 * tree in the beginning of this class' Xeromyces_* section.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the object-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param pParent	Parent to add this object as child in.
 	 * @param NameSubst	A set of substitution strings that will be
 	 * 					applied to all object names within this object.
 	 * @param Paths		Output set of file paths that this GUI object
 	 * 					relies on.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
 	 * 'count' times, replacing the string "[n]" (or the value of the attribute
 	 * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 	 * "[1]", etc.
 	 */
 	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, boost::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<script\> (the XMBElement) and executes
 	 * the script's code.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the script-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param Paths		Output set of file paths that this script is loaded from.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, boost::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<sprite\> (the XMBElement) and stores the
 	 * result in a new CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the sprite-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<image\> (the XMBElement) and stores the
 	 * result within the CGUISprite.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param parent	Parent sprite.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent);
 
 	/**
 	 * Reads in the element \<effect\> (the XMBElement) and stores the
 	 * result within the SGUIImageEffects.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the image-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 * @param effects	Effects object to add this effect to.
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects);
 
 	/**
 	 * Reads in the element \<style\> (the XMBElement) and stores the
 	 * result in m_Styles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the style-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<scrollbar\> (the XMBElement) and stores the
 	 * result in m_ScrollBarStyles.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<icon\> (the XMBElement) and stores the
 	 * result in m_Icons.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<tooltip\> (the XMBElement) and stores the
 	 * result as an object with the name __tooltip_#.
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile);
 
 	/**
 	 * Reads in the element \<color\> (the XMBElement) and stores the
 	 * result in m_PreDefinedColors
 	 *
 	 * @param Element	The Xeromyces object that represents
 	 *					the scrollbar-tag.
 	 * @param pFile		The Xeromyces object for the file being read
 	 *
 	 * @see LoadXmlFile()
 	 */
 	void Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile);
 
 	//@}
 
 private:
 
 	// Variables
 
 	//--------------------------------------------------------
 	/** @name Miscellaneous */
 	//--------------------------------------------------------
 	//@{
 
 	shared_ptr<ScriptInterface> m_ScriptInterface;
 
 	/**
 	 * don't want to pass this around with the
 	 * ChooseMouseOverAndClosest broadcast -
 	 * we'd need to pack this and pNearest in a struct
 	 */
 	CPos m_MousePos;
 
 	/**
 	 * Indicates which buttons are pressed (bit 0 = LMB,
 	 * bit 1 = RMB, bit 2 = MMB)
 	 */
 	unsigned int m_MouseButtons;
 
 	// Tooltip
 	GUITooltip m_Tooltip;
 
 	/**
 	 * This is a bank of custom colors, it is simply a look up table that
 	 * will return a color object when someone inputs the name of that
 	 * color. Of course the colors have to be declared in XML, there are
 	 * no hard-coded values.
 	 */
 	std::map<CStr, CColor>	m_PreDefinedColors;
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Objects */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Base Object, all its children are considered parentless
 	 * because this is not a real object per se.
 	 */
 	IGUIObject* m_BaseObject;
 
 	/**
 	 * Focused object!
 	 * Say an input box that is selected. That one is focused.
 	 * There can only be one focused object.
 	 */
 	IGUIObject* m_FocusedObject;
 
 	/**
 	 * Just pointers for fast name access, each object
 	 * is really constructed within its parent for easy
 	 * recursive management.
 	 * Notice m_BaseObject won't belong here since it's
 	 * not considered a real object.
 	 */
 	map_pObjects m_pAllObjects;
 
 	/**
 	 * Number of object that has been given name automatically.
 	 * the name given will be '__internal(#)', the number (#)
 	 * being this variable. When an object's name has been set
 	 * as followed, the value will increment.
 	 */
 	int m_InternalNameNumber;
 
 	/**
 	 * Function pointers to functions that constructs
 	 * IGUIObjects by name... For instance m_ObjectTypes["button"]
 	 * is filled with a function that will "return new CButton();"
 	 */
 	std::map<CStr, ConstructObjectFunction>	m_ObjectTypes;
 
 	/**
 	 * Map from hotkey names to objects that listen to the hotkey.
 	 * (This is an optimisation to avoid recursing over the whole GUI
 	 * tree every time a hotkey is pressed).
 	 * Currently this is only set at load time - dynamic changes to an
 	 * object's hotkey property will be ignored.
 	 */
 	std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 
 	//--------------------------------------------------------
 	//	Databases
 	//--------------------------------------------------------
 
 	// Sprites
 	std::map<CStr, CGUISprite*> m_Sprites;
 
 	// Styles
 	std::map<CStr, SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, SGUIIcon> m_Icons;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/lobby/XmppClient.cpp
===================================================================
--- ps/trunk/source/lobby/XmppClient.cpp	(revision 20368)
+++ ps/trunk/source/lobby/XmppClient.cpp	(revision 20369)
@@ -1,1136 +1,1136 @@
 /* Copyright (C) 2017 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"
 
 #ifdef WIN32
 #  include <winsock2.h>
 #endif
 
 #include "i18n/L10n.h"
 
 #include "lib/external_libraries/enet.h"
 #include "lib/utf8.h"
 #include "network/NetServer.h"
 #include "network/StunClient.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), m_sessionManager()
 {
 	// 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);
 	}
 
 	m_sessionManager = new glooxwrapper::SessionManager(m_client, this);
 	// Register plugins to allow gloox parse them in incoming sessions
 	m_sessionManager->registerPlugins();
 }
 
 /**
  * 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();
 	m_HistoricGuiMessages.clear();
 
 	CreateGUIMessage("system", "disconnected", "reason", 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", "text", StanzaErrorToString(err));
 }
 
 /*****************************************************
  * Requests to server                                *
  *****************************************************/
 
 /**
  * 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, m_client->getID());
 	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, m_client->getID());
 	iq.addExtension(b);
 	DbgXMPP("SendIqGetProfile [" << 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(const 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, m_client->getID());
 	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(const 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, m_client->getID());
 	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, m_client->getID());
 	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, m_client->getID());
 	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", "text", 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(const 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(const ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
 {
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 
 	scriptInterface.Eval("([])", ret);
 	const char* stats[] = { "name", "ip", "port", "stunIP", "stunPort", "hostUsername", "state", "nbp", "maxnbp", "players", "mapName", "niceMapName", "mapSize", "mapType", "victoryCondition", "startTime" };
 	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(const 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(const 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                                *
  *****************************************************/
 
 void XmppClient::CreateGUIMessage(
 	const std::string& type,
 	const std::string& level,
 	const std::string& property1_name,
 	const std::string& property1_value,
 	const std::string& property2_name,
 	const std::string& property2_value,
 	const std::time_t time)
 {
 	GUIMessage message;
 	message.type = type;
 	message.level = level;
 	message.property1_name = property1_name;
 	message.property1_value = property1_value;
 	message.property2_name = property2_name;
 	message.property2_value = property2_value;
 	message.time = time;
 	m_GuiMessageQueue.push_back(std::move(message));
 }
 
 JS::Value XmppClient::GuiMessageToJSVal(const ScriptInterface& scriptInterface, const GUIMessage& message, const bool historic)
 {
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue ret(cx);
 	scriptInterface.Eval("({})", &ret);
 	scriptInterface.SetProperty(ret, "type", wstring_from_utf8(message.type));
 	if (!message.level.empty())
 		scriptInterface.SetProperty(ret, "level", wstring_from_utf8(message.level));
 	if (!message.property1_name.empty())
 		scriptInterface.SetProperty(ret, message.property1_name.c_str(), wstring_from_utf8(message.property1_value));
 	if (!message.property2_name.empty())
 		scriptInterface.SetProperty(ret, message.property2_name.c_str(), wstring_from_utf8(message.property2_value));
 	scriptInterface.SetProperty(ret, "time", (double)message.time);
 	scriptInterface.SetProperty(ret, "historic", historic);
 	return ret;
 }
 
 JS::Value XmppClient::GuiPollNewMessage(const ScriptInterface& scriptInterface)
 {
 	if (m_GuiMessageQueue.empty())
 		return JS::UndefinedValue();
 
 	GUIMessage message = m_GuiMessageQueue.front();
 	m_GuiMessageQueue.pop_front();
 
 	// Since there can be hundreds of presence changes while playing a game, ignore these for performance
 	if (message.type == "chat" && message.level != "presence")
 		m_HistoricGuiMessages.push_back(message);
 
 	return GuiMessageToJSVal(scriptInterface, message, false);
 }
 
 JS::Value XmppClient::GuiPollHistoricMessages(const ScriptInterface& scriptInterface)
 {
 	JSContext* cx = scriptInterface.GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedObject ret(cx, JS_NewArrayObject(cx, 0));
 
 	uint32_t i = 0;
 	for (const GUIMessage& message : m_HistoricGuiMessages)
 	{
 		JS::RootedValue msg(cx, GuiMessageToJSVal(scriptInterface, message, true));
 		JS_SetElement(cx, ret, i++, msg);
 	}
 	return JS::ObjectValue(*ret);
 }
 
 /**
  * Send a standard MUC textual message.
  */
 void XmppClient::SendMUCMessage(const std::string& message)
 {
 	m_mucRoom->send(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 == "chat" && message.level == "presence";
 			}
 	), m_GuiMessageQueue.end());
 }
 
 /**
  * Handle a room message.
  */
 void XmppClient::handleMUCMessage(glooxwrapper::MUCRoom*, const glooxwrapper::Message& msg, bool priv)
 {
 	DbgXMPP(msg.from().resource() << " said " << msg.body());
 
 	CreateGUIMessage(
 		"chat",
 		priv ? "private-message" : "room-message",
 		"from", msg.from().resource().to_string(),
 		"text", msg.body().to_string(),
 		ComputeTimestamp(msg));
 }
 
 /**
  * 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());
 
 	CreateGUIMessage(
 		"chat",
 		"private-message",
 		"from", msg.from().resource().to_string(),
 		"text", msg.body().to_string(),
 		ComputeTimestamp(msg));
 }
 
 /**
  * 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)
 		CreateGUIMessage("system", "error", "text", StanzaErrorToString(iq.error_error()));
 	else
 	{
 		CreateGUIMessage("system", "error", "text", g_L10n.Translate("unknown subtype (see logs)"));
 		LOGMESSAGE("unknown subtype '%s'", tag_name(iq).c_str());
 	}
 	return true;
 }
 
 /*****************************************************
  * 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 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;
 
 			DbgXMPP(nick << " is now known as " << participant.newNick.to_string());
 			CreateGUIMessage("chat", "nick", "oldnick", nick, "newnick", participant.newNick.to_string());
 		}
 		else if (participant.flags & gloox::UserKicked)
 		{
 			DbgXMPP(nick << " was kicked. Reason: " << participant.reason.to_string());
 			CreateGUIMessage("chat", "kicked", "nick", nick, "reason", participant.reason.to_string());
 		}
 		else if (participant.flags & gloox::UserBanned)
 		{
 			DbgXMPP(nick << " was banned. Reason: " << participant.reason.to_string());
 			CreateGUIMessage("chat", "banned", "nick", nick, "reason", participant.reason.to_string());
 		}
 		else
 		{
 			DbgXMPP(nick << " left the room (flags " << participant.flags << ")");
 			CreateGUIMessage("chat", "leave", "nick", nick);
 		}
 		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", nick);
 		else if (m_PlayerMap[nick][2] != roleString)
 			CreateGUIMessage("chat", "role", "nick", nick, "oldrole", m_PlayerMap[nick][2]);
 		else
 			CreateGUIMessage("chat", "presence", "nick", 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& nick, const glooxwrapper::string& subject)
 {
 	m_Subject = subject.c_str();
 	CreateGUIMessage("chat", "subject", "nick", nick.c_str(), "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                                         *
  *****************************************************/
 
 /**
  * Parse and return the timestamp of a historic chat message and return the current time for new chat messages.
  * Historic chat messages are implement as DelayedDelivers as specified in XEP-0203.
  * Hence, their timestamp MUST be in UTC and conform to the DateTime format XEP-0082.
  *
  * @returns Seconds since the epoch.
  */
 std::time_t XmppClient::ComputeTimestamp(const glooxwrapper::Message& msg) const
 {
 	// Only historic messages contain a timestamp!
 	if (!msg.when())
 		return std::time(nullptr);
 
 	// The locale is irrelevant, because the XMPP date format doesn't contain written month names
 	return g_L10n.ParseDateTime(msg.when()->stamp().to_string(), "Y-M-d'T'H:m:sZ", Locale::getUS()) / 1000.0;
 }
 
 /**
  * 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");
+	DEBUG_CASE(StanzaErrorBadRequest, "Server received 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(ConnIoError, g_L10n.Translate("An I/O error occurred"));
+	DEBUG_CASE(ConnParseError, "An XML parse error occurred");
 	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(RegistrationBadRequest, "Server received an incomplete request");
 	DEBUG_CASE(RegistrationForbidden, "Registration forbidden");
 	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 "";
 	}
 #undef DEBUG_CASE
 #undef CASE
 }
 
 void XmppClient::SendStunEndpointToHost(StunClient::StunEndpoint* stunEndpoint, const std::string& hostJIDStr)
 {
 	ENSURE(stunEndpoint);
 
 	char ipStr[256] = "(error)";
 	ENetAddress addr;
 	addr.host = ntohl(stunEndpoint->ip);
 	enet_address_get_host_ip(&addr, ipStr, ARRAY_SIZE(ipStr));
 
 	glooxwrapper::JID hostJID(hostJIDStr);
 	glooxwrapper::Jingle::Session session = m_sessionManager->createSession(hostJID);
 	session.sessionInitiate(ipStr, stunEndpoint->port);
 }
 
 void XmppClient::handleSessionAction(gloox::Jingle::Action action, glooxwrapper::Jingle::Session* UNUSED(session), const glooxwrapper::Jingle::Session::Jingle* jingle)
 {
 	if (action == gloox::Jingle::SessionInitiate)
 		handleSessionInitiation(jingle);
 }
 
 void XmppClient::handleSessionInitiation(const glooxwrapper::Jingle::Session::Jingle* jingle)
 {
 	glooxwrapper::Jingle::ICEUDP::Candidate candidate = jingle->getCandidate();
 
 	if (candidate.ip.empty())
 	{
 		LOGERROR("Failed to retrieve Jingle candidate");
 		return;
 	}
 
 	g_NetServer->SendHolePunchingMessage(candidate.ip.to_string(), candidate.port);
 }
Index: ps/trunk/source/network/NetMessage.h
===================================================================
--- ps/trunk/source/network/NetMessage.h	(revision 20368)
+++ ps/trunk/source/network/NetMessage.h	(revision 20369)
@@ -1,160 +1,160 @@
 /* Copyright (C) 2017 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 NETMESSAGE_H
 #define NETMESSAGE_H
 
 #include "Serialization.h"
 
 // We need the enum from NetMessages.h, but we can't create any classes in
 // NetMessages.h, since they in turn require CNetMessage to be defined
 #define ALLNETMSGS_DONT_CREATE_NMTS
 #include "NetMessages.h"
 #undef ALLNETMSGS_DONT_CREATE_NMTS
 
 /**
  * The base class for all network messages exchanged within the game.
  */
 class CNetMessage : public ISerializable
 {
 	friend class CNetSession;
 
 public:
 
 	CNetMessage();
 	CNetMessage(NetMessageType type);
 	virtual ~CNetMessage();
 
 	/**
 	 * Retrieves the message type.
 	 * @return						Message type
 	 */
 	NetMessageType GetType() const { return m_Type; }
 
 	/**
 	 * Serialize the message into the specified buffer parameter. The size
 	 * required by the buffer parameter can be found by a call to
 	 * GetSerializedLength method. The information contained within the message
 	 * must be serialized before the message is sent. By default only the
 	 * message type and its size are serialized in the buffer parameter.
 	 *
 	 * @param pBuffer				Buffer where to serialize the message
 	 * @return						The position in the buffer right after the
 	 *								serialized message
 	 */
 	virtual u8* Serialize(u8* pBuffer) const;
 
 	/**
 	 * Deserializes the message from the specified buffer.
 	 *
 	 * @param pStart				Message start within the serialized buffer
 	 * @param pEnd					Message end within the serialized buffer
 	 * @return						The position in the buffer right after the
-	 *								message or NULL if an error occured
+	 *								message or NULL if an error occurred
 	 */
 	virtual const u8* Deserialize(const u8* pStart, const u8* pEnd);
 
 	/**
 	 * Retrieves the size in bytes of the serialized message. Before calling
 	 * Serialize, the memory size for the buffer where to serialize the message
 	 * object can be found by calling this method.
 	 *
 	 * @return							The size of serialized message
 	 */
 	virtual size_t GetSerializedLength() const;
 
 	/**
 	 * Returns a string representation for the message
 	 *
 	 * @return							The message as a string
 	 */
 	virtual CStr ToString() const;
 
 private:
 	NetMessageType	m_Type;				// Message type
 };
 
 /**
  * Creates messages from data received through the network.
  */
 class CNetMessageFactory
 {
 public:
 
 	/**
 	 * Factory method which creates a message object based on the given data
 	 *
 	 * @param pData						Data buffer
 	 * @param dataSize					Size of data buffer
 	 * @param scriptInterface			Script instance to use when constructing scripted messages
 	 * @return							The new message created
 	 */
 	static CNetMessage* CreateMessage(const void* pData, size_t dataSize, const ScriptInterface& scriptInterface);
 };
 
 /**
  * Special message type for simulation commands.
  * These commands are exposed as arbitrary JS objects, associated with a specific player.
  */
 class CSimulationMessage : public CNetMessage
 {
 public:
 	CSimulationMessage(const ScriptInterface& scriptInterface);
 	CSimulationMessage(const ScriptInterface& scriptInterface, u32 client, i32 player, u32 turn, JS::HandleValue data);
 
 	/** The compiler can't create a copy constructor because of the PersistentRooted member,
 	 * so we have to write it manually.
 	 * NOTE: It doesn't clone the m_Data member and the copy will reference the same JS::Value!
 	 */
 	CSimulationMessage(const CSimulationMessage& orig);
 
 	virtual u8* Serialize(u8* pBuffer) const;
 	virtual const u8* Deserialize(const u8* pStart, const u8* pEnd);
 	virtual size_t GetSerializedLength() const;
 	virtual CStr ToString() const;
 
 	u32 m_Client;
 	i32 m_Player;
 	u32 m_Turn;
 	JS::PersistentRooted<JS::Value> m_Data;
 private:
 	const ScriptInterface& m_ScriptInterface;
 };
 
 /**
  * Special message type for updated to game startup settings.
  */
 class CGameSetupMessage : public CNetMessage
 {
 	NONCOPYABLE(CGameSetupMessage);
 public:
 	CGameSetupMessage(const ScriptInterface& scriptInterface);
 	CGameSetupMessage(const ScriptInterface& scriptInterface, JS::HandleValue data);
 	virtual u8* Serialize(u8* pBuffer) const;
 	virtual const u8* Deserialize(const u8* pStart, const u8* pEnd);
 	virtual size_t GetSerializedLength() const;
 	virtual CStr ToString() const;
 
 	JS::PersistentRootedValue m_Data;
 private:
 	const ScriptInterface& m_ScriptInterface;
 };
 
 // This time, the classes are created
 #include "NetMessages.h"
 
 #endif // NETMESSAGE_H