Index: ps/trunk/source/ps/Shapes.cpp
===================================================================
--- ps/trunk/source/ps/Shapes.cpp	(revision 25164)
+++ ps/trunk/source/ps/Shapes.cpp	(nonexistent)
@@ -1,221 +0,0 @@
-/* Copyright (C) 2021 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 "Shapes.h"
-
-#include "maths/Size2D.h"
-#include "maths/Vector2D.h"
-
-CRect::CRect() :
-	left(0.f), top(0.f), right(0.f), bottom(0.f)
-{
-}
-
-CRect::CRect(const CRect& rect) :
-	left(rect.left), top(rect.top), right(rect.right), bottom(rect.bottom)
-{
-}
-
-CRect::CRect(const CVector2D& pos) :
-	left(pos.X), top(pos.Y), right(pos.X), bottom(pos.Y)
-{
-}
-
-CRect::CRect(const CSize2D& size) :
-	left(0.f), top(0.f), right(size.Width), bottom(size.Height)
-{
-}
-
-CRect::CRect(const CVector2D& upperleft, const CVector2D& bottomright) :
-	left(upperleft.X), top(upperleft.Y), right(bottomright.X), bottom(bottomright.Y)
-{
-}
-
-CRect::CRect(const CVector2D& pos, const CSize2D& size) :
-	left(pos.X), top(pos.Y), right(pos.X + size.Width), bottom(pos.Y + size.Height)
-{
-}
-
-CRect::CRect(const float l, const float t, const float r, const float b) :
-	left(l), top(t), right(r), bottom(b)
-{
-}
-
-CRect& CRect::operator=(const CRect& a)
-{
-	left = a.left;
-	top = a.top;
-	right = a.right;
-	bottom = a.bottom;
-	return *this;
-}
-
-bool CRect::operator==(const CRect &a) const
-{
-	return	(left == a.left &&
-			 top == a.top &&
-			 right == a.right &&
-			 bottom == a.bottom);
-}
-
-bool CRect::operator!=(const CRect& a) const
-{
-	return !(*this == a);
-}
-
-CRect CRect::operator-() const
-{
-	return CRect(-left, -top, -right, -bottom);
-}
-
-CRect CRect::operator+() const
-{
-	return *this;
-}
-
-CRect CRect::operator+(const CRect& a) const
-{
-	return CRect(left + a.left, top + a.top, right + a.right, bottom + a.bottom);
-}
-
-CRect CRect::operator+(const CVector2D& a) const
-{
-	return CRect(left + a.X, top + a.Y, right + a.X, bottom + a.Y);
-}
-
-CRect CRect::operator+(const CSize2D& a) const
-{
-	return CRect(left + a.Width, top + a.Height, right + a.Width, bottom + a.Height);
-}
-
-CRect CRect::operator-(const CRect& a) const
-{
-	return CRect(left - a.left, top - a.top, right - a.right, bottom - a.bottom);
-}
-
-CRect CRect::operator-(const CVector2D& a) const
-{
-	return CRect(left - a.X, top - a.Y, right - a.X, bottom - a.Y);
-}
-
-CRect CRect::operator-(const CSize2D& a) const
-{
-	return CRect(left - a.Width, top - a.Height, right - a.Width, bottom - a.Height);
-}
-
-void CRect::operator+=(const CRect& a)
-{
-	left += a.left;
-	top += a.top;
-	right += a.right;
-	bottom += a.bottom;
-}
-
-void CRect::operator+=(const CVector2D& a)
-{
-	left += a.X;
-	top += a.Y;
-	right += a.X;
-	bottom += a.Y;
-}
-
-void CRect::operator+=(const CSize2D& a)
-{
-	left += a.Width;
-	top += a.Height;
-	right += a.Width;
-	bottom += a.Height;
-}
-
-void CRect::operator-=(const CRect& a)
-{
-	left -= a.left;
-	top -= a.top;
-	right -= a.right;
-	bottom -= a.bottom;
-}
-
-void CRect::operator-=(const CVector2D& a)
-{
-	left -= a.X;
-	top -= a.Y;
-	right -= a.X;
-	bottom -= a.Y;
-}
-
-void CRect::operator-=(const CSize2D& a)
-{
-	left -= a.Width;
-	top -= a.Height;
-	right -= a.Width;
-	bottom -= a.Height;
-}
-
-float CRect::GetWidth() const
-{
-	return right-left;
-}
-
-float CRect::GetHeight() const
-{
-	return bottom-top;
-}
-
-CSize2D CRect::GetSize() const
-{
-	return CSize2D(right - left, bottom - top);
-}
-
-CVector2D CRect::TopLeft() const
-{
-	return CVector2D(left, top);
-}
-
-CVector2D CRect::TopRight() const
-{
-	return CVector2D(right, top);
-}
-
-CVector2D CRect::BottomLeft() const
-{
-	return CVector2D(left, bottom);
-}
-
-CVector2D CRect::BottomRight() const
-{
-	return CVector2D(right, bottom);
-}
-
-CVector2D CRect::CenterPoint() const
-{
-	return CVector2D((left + right) / 2.f, (top + bottom) / 2.f);
-}
-
-bool CRect::PointInside(const CVector2D& point) const
-{
-	return (point.X >= left &&
-			point.X <= right &&
-			point.Y >= top &&
-			point.Y <= bottom);
-}
-
-CRect CRect::Scale(float x, float y) const
-{
-	return CRect(left * x, top * y, right * x, bottom * y);
-}

Property changes on: ps/trunk/source/ps/Shapes.cpp
___________________________________________________________________
Deleted: svn:eol-style
## -1 +0,0 ##
-native
\ No newline at end of property
Index: ps/trunk/source/ps/Shapes.h
===================================================================
--- ps/trunk/source/ps/Shapes.h	(revision 25164)
+++ ps/trunk/source/ps/Shapes.h	(nonexistent)
@@ -1,121 +0,0 @@
-/* Copyright (C) 2021 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 INCLUDED_SHAPES
-#define INCLUDED_SHAPES
-
-class CSize2D;
-class CVector2D;
-
-
-/**
- * Rectangle class used for screen rectangles. It's very similar to the MS
- * CRect, but with FLOATS because it's meant to be used with OpenGL which
- * takes float values.
- */
-class CRect
-{
-public:
-	CRect();
-	CRect(const CVector2D& pos);
-	CRect(const CSize2D& size);
-	CRect(const CVector2D& upperleft, const CVector2D& bottomright);
-	CRect(const CVector2D& pos, const CSize2D& size);
-	CRect(const float l, const float t, const float r, const float b);
-	CRect(const CRect&);
-
-	CRect& operator=(const CRect& a);
-	bool operator==(const CRect& a) const;
-	bool operator!=(const CRect& a) const;
-	CRect operator-() const;
-	CRect operator+() const;
-
-	CRect operator+(const CRect& a) const;
-	CRect operator+(const CVector2D& a) const;
-	CRect operator+(const CSize2D& a) const;
-	CRect operator-(const CRect& a) const;
-	CRect operator-(const CVector2D& a) const;
-	CRect operator-(const CSize2D& a) const;
-
-	void operator+=(const CRect& a);
-	void operator+=(const CVector2D& a);
-	void operator+=(const CSize2D& a);
-	void operator-=(const CRect& a);
-	void operator-=(const CVector2D& a);
-	void operator-=(const CSize2D& a);
-
-	/**
-	 * @return Width of Rectangle
-	 */
-	float GetWidth() const;
-
-	/**
-	 * @return Height of Rectangle
-	 */
-	float GetHeight() const;
-
-	/**
-	 * Get Size
-	 */
-	CSize2D GetSize() const;
-
-	/**
-	 * Get Position equivalent to top/left corner
-	 */
-	CVector2D TopLeft() const;
-
-	/**
-	 * Get Position equivalent to top/right corner
-	 */
-	CVector2D TopRight() const;
-
-	/**
-	 * Get Position equivalent to bottom/left corner
-	 */
-	CVector2D BottomLeft() const;
-
-	/**
-	 * Get Position equivalent to bottom/right corner
-	 */
-	CVector2D BottomRight() const;
-
-	/**
-	 * Get Position equivalent to the center of the rectangle
-	 */
-	CVector2D CenterPoint() const;
-
-	/**
-	 * Evalutates if point is within the rectangle
-	 * @param point CVector2D representing point
-	 * @return true if inside.
-	 */
-	bool PointInside(const CVector2D &point) const;
-
-	CRect Scale(float x, float y) const;
-
-	/**
-	 * Returning CVector2D representing each corner.
-	 */
-
-public:
-	/**
-	 * Dimensions
-	 */
-	float left, top, right, bottom;
-};
-
-#endif // INCLUDED_SHAPES

Property changes on: ps/trunk/source/ps/Shapes.h
___________________________________________________________________
Deleted: svn:eol-style
## -1 +0,0 ##
-native
\ No newline at end of property
Index: ps/trunk/source/graphics/TextRenderer.h
===================================================================
--- ps/trunk/source/graphics/TextRenderer.h	(revision 25164)
+++ ps/trunk/source/graphics/TextRenderer.h	(revision 25165)
@@ -1,181 +1,181 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 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 INCLUDED_TEXTRENDERER
 #define INCLUDED_TEXTRENDERER
 
 #include "graphics/Color.h"
 #include "graphics/ShaderProgramPtr.h"
 #include "maths/Matrix3D.h"
+#include "maths/Rect.h"
 #include "ps/CStrIntern.h"
-#include "ps/Shapes.h"
 
 #include <list>
 
 class CFont;
 
 class CTextRenderer
 {
 public:
 	CTextRenderer(const CShaderProgramPtr& shader);
 
 	/**
 	 * Reset the text transform to the default, with (0,0) in the top-left of the screen.
 	 */
 	void ResetTransform();
 
 	CMatrix3D GetTransform();
 
 	void SetTransform(const CMatrix3D& transform);
 
 	void Translate(float x, float y, float z);
 
 	/**
 	 * Set clipping rectangle, in pre-transform coordinates (i.e. text is clipped against
 	 * this rect based purely on the x,y values passed into Put()). Text fully outside the
 	 * clipping rectangle may not be rendered. Should be used in conjunction with glScissor
 	 * for precise clipping - this is just an optimisation.
 	 */
 	void SetClippingRect(const CRect& rect);
 
 	/**
 	 * Set the color for subsequent print calls.
 	 */
 	void Color(const CColor& color);
 
 	/**
 	 * Set the color for subsequent print calls.
 	 */
 	void Color(float r, float g, float b, float a = 1.0);
 
 	/**
 	 * Set the font for subsequent print calls.
 	 */
 	void Font(CStrIntern font);
 
 	/**
 	 * Print formatted text at (0,0) under the current transform,
 	 * and advance the transform by the width of the text.
 	 */
 	void PrintfAdvance(const wchar_t* fmt, ...);
 
 	/**
 	 * Print formatted text at (x,y) under the current transform.
 	 * Does not alter the current transform.
 	 */
 	void PrintfAt(float x, float y, const wchar_t* fmt, ...);
 
 	/**
 	 * Print text at (0,0) under the current transform,
 	 * and advance the transform by the width of the text.
 	 */
 	void PutAdvance(const wchar_t* buf);
 
 	/**
 	 * Print text at (x,y) under the current transform.
 	 * Does not alter the current transform.
 	 */
 	void Put(float x, float y, const wchar_t* buf);
 
 	/**
 	 * Print text at (x,y) under the current transform.
 	 * Does not alter the current transform.
 	 * @p buf must be a UTF-8 string.
 	 */
 	void Put(float x, float y, const char* buf);
 
 	/**
 	 * Print text at (x,y) under the current transform.
 	 * Does not alter the current transform.
 	 * @p buf must remain valid until Render() is called.
 	 * (This should be used to minimise memory copies when possible.)
 	 */
 	void Put(float x, float y, const std::wstring* buf);
 
 	/**
 	 * Render all of the previously printed text calls.
 	 */
 	void Render();
 
 private:
 	friend struct SBatchCompare;
 
 	/**
 	 * A string (optionally owned by this object, or else pointing to an
 	 * externally-owned string) with a position.
 	 */
 	struct SBatchRun
 	{
 	private:
 		SBatchRun& operator=(const SBatchRun&);
 	public:
 		SBatchRun()
 			: text(NULL), owned(false)
 		{
 		}
 
 		SBatchRun(const SBatchRun& str)
 			: x(str.x), y(str.y), owned(str.owned)
 		{
 			if (owned)
 				text = new std::wstring(*str.text);
 			else
 				text = str.text;
 		}
 
 		~SBatchRun()
 		{
 			if (owned)
 				delete text;
 		}
 
 		float x, y;
 
 		const std::wstring* text;
 		bool owned;
 	};
 
 	/**
 	 * A list of SBatchRuns, with a single font/color/transform,
 	 * to be rendered in a single GL call.
 	 */
 	struct SBatch
 	{
 		size_t chars; // sum of runs[i].text->size()
 		CMatrix3D transform;
 		CColor color;
 		shared_ptr<CFont> font;
 		std::list<SBatchRun> runs;
 	};
 
 	void PutString(float x, float y, const std::wstring* buf, bool owned);
 
 	CShaderProgramPtr m_Shader;
 
 	CMatrix3D m_Transform;
 	CRect m_Clipping;
 
 	CColor m_Color;
 	CStrIntern m_FontName;
 	shared_ptr<CFont> m_Font;
 
 	bool m_Dirty;
 
 	std::list<SBatch> m_Batches;
 };
 
 #endif // INCLUDED_TEXTRENDERER
Index: ps/trunk/source/gui/CGUI.h
===================================================================
--- ps/trunk/source/gui/CGUI.h	(revision 25164)
+++ ps/trunk/source/gui/CGUI.h	(revision 25165)
@@ -1,686 +1,686 @@
 /* Copyright (C) 2021 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 "gui/GUITooltip.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SGUIIcon.h"
 #include "gui/SGUIStyle.h"
 #include "lib/input.h"
+#include "maths/Rect.h"
 #include "maths/Size2D.h"
 #include "maths/Vector2D.h"
-#include "ps/Shapes.h"
 #include "ps/XML/Xeromyces.h"
 #include "scriptinterface/ScriptInterface.h"
 
 #include <map>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 extern const double SELECT_DBLCLICK_RATE;
 
 class CGUISpriteInstance;
 class CGUISprite;
 class IGUIObject;
 struct SGUIImageEffects;
 struct SGUIScrollBarStyle;
 
 namespace js { class BaseProxyHandler; }
 class GUIProxyProps;
 
 using map_pObjects = std::map<CStr, IGUIObject*>;
 
 /**
  * The main object that represents a whole GUI page.
  */
 class CGUI
 {
 	NONCOPYABLE(CGUI);
 
 private:
 	// Private typedefs
 	using ConstructObjectFunction = IGUIObject* (*)(CGUI&);
 
 public:
 	CGUI(const shared_ptr<ScriptContext>& context);
 	~CGUI();
 
 	/**
 	 * Informs the GUI page which GUI object types may be constructed from XML.
 	 */
 	void AddObjectTypes();
 
 	/**
 	 * 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);
 
 	/**
 	 * Sends a specified script event to every object
 	 *
 	 * @param eventName String representation of event name
 	 * @param paramData JS::HandleValueArray storing the arguments passed to the event handler.
 	 */
 	void SendEventToAll(const CStr& eventName, const JS::HandleValueArray& paramData);
 
 	/**
 	 * Displays the whole GUI
 	 */
 	void Draw();
 
 	/**
 	 * Draw GUI Sprite
 	 *
 	 * @param Sprite Object referring to the sprite (which also caches
 	 *        calculations for faster rendering)
 	 * @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, const float& Z, const CRect& Rect, const CRect& Clipping = CRect());
 
 	/**
 	 * 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, std::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Called after all XML files linked in the page file were loaded.
 	 */
 	void LoadedXmlFiles();
 
 	/**
 	 * Allows the JS side to modify the hotkey setting assigned to a GUI object.
 	 */
 	void SetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag);
 	void UnsetObjectHotkey(IGUIObject* pObject, const CStr& hotkeyTag);
 
 	/**
 	 * Allows the JS side to modify the style setting assigned to a GUI object.
 	 */
 	void SetObjectStyle(IGUIObject* pObject, const CStr& styleName);
 	void UnsetObjectStyle(IGUIObject* pObject);
 
 	/**
 	 * Allows the JS side to add or remove global hotkeys.
 	 */
 	void SetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName, JS::HandleValue function);
 	void UnsetGlobalHotkey(const CStr& hotkeyTag, const CStr& eventName);
 
 	/**
 	 * Return the object which is an ancestor of every other GUI object.
 	 */
 	IGUIObject* GetBaseObject();
 
 	/**
 	 * 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 nullptr
 	 * if no match is found,
 	 *
 	 * @param Name String name of object
 	 * @return Matching object, or nullptr
 	 */
 	IGUIObject* FindObjectByName(const CStr& Name) const;
 
 	/**
 	 * Returns the GUI object under the mouse, or nullptr if none.
 	 */
 	IGUIObject* FindObjectUnderMouse();
 
 	/**
 	 * Returns the current screen coordinates of the cursor.
 	 */
 	const CVector2D& GetMousePos() const { return m_MousePos; };
 
 	/**
 	 * Returns the currently pressed mouse buttons.
 	 */
 	const unsigned int& GetMouseButtons() { return m_MouseButtons; };
 
 	const SGUIScrollBarStyle* GetScrollBarStyle(const CStr& style) 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();
 
 	/**
 	 * Check if an icon exists
 	 */
 	bool HasIcon(const CStr& name) const { return (m_Icons.find(name) != m_Icons.end()); }
 
 	/**
 	 * Get Icon (a const reference, can never be changed)
 	 */
 	const SGUIIcon& GetIcon(const CStr& name) const { return m_Icons.at(name); }
 
 	/**
 	 * Check if a style exists
 	 */
 	bool HasStyle(const CStr& name) const { return (m_Styles.find(name) != m_Styles.end()); }
 
 	/**
 	 * Get Style if it exists, otherwise throws an exception.
 	 */
 	const SGUIStyle& GetStyle(const CStr& name) const { return m_Styles.at(name); }
 
 	/**
 	 * Check if a predefined color of that name exists.
 	 */
 	bool HasPreDefinedColor(const CStr& name) const { return (m_PreDefinedColors.find(name) != m_PreDefinedColors.end()); }
 
 	/**
 	 * Resolve the predefined color if it exists, otherwise throws an exception.
 	 */
 	const CGUIColor& GetPreDefinedColor(const CStr& name) const { return m_PreDefinedColors.at(name); }
 
 	GUIProxyProps* GetProxyData(const js::BaseProxyHandler* ptr) { return m_ProxyData.at(ptr).get(); }
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 
 private:
 	/**
 	 * The CGUI takes ownership of the child object and links the parent with the child.
 	 * Returns false on failure to take over ownership of the child object.
 	 */
 	bool AddObject(IGUIObject& parent, IGUIObject& child);
 
 	/**
 	 * 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);
 
 public:
 	/**
 	 * Get Focused Object.
 	 */
 	IGUIObject* GetFocusedObject() { return m_FocusedObject; }
 
 	/**
 	 * Change focus to new object.
 	 * Will send LOST_FOCUS/GOT_FOCUS messages as appropriate.
 	 * pObject can be nullptr to remove all focus.
 	 */
 	void SetFocusedObject(IGUIObject* pObject);
 
 	/**
 	 * Reads a string value and modifies the given value of type T if successful.
 	 * Does not change the value upon conversion failure.
 	 *
 	 * @param pGUI The GUI page which may contain data relevant to the parsing
 	 *             (for example predefined colors).
 	 * @param Value The value in string form, like "0 0 100% 100%"
 	 * @param tOutput Parsed value of type T
 	 * @return True at success.
 	 */
 	template <typename T>
 	static bool ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput);
 
 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, std::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, std::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, std::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, std::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
 	 */
 	CVector2D m_MousePos;
 
 	/**
 	 * Indicates which buttons are pressed (bit 0 = LMB,
 	 * bit 1 = RMB, bit 2 = MMB)
 	 */
 	unsigned int m_MouseButtons;
 
 	// Tooltip
 	GUITooltip m_Tooltip;
 
 	//@}
 	//--------------------------------------------------------
 	/** @name Objects */
 	//--------------------------------------------------------
 	//@{
 
 	/**
 	 * Base Object, all its children are considered parentless
 	 * because this is not a real object per se.
 	 */
 	std::unique_ptr<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;
 
 	/**
 	 * This is intended to store the JSFunction when accessing certain properties.
 	 * The problem is that these functions are per-scriptInterface, and proxy handlers aren't.
 	 * So we know what we want to store, but we don't really have anywhere to store it.
 	 * It would be simpler to recreate the functions on every JS call, but that is slower
 	 * (this may or may not matter now and in the future).
 	 * It's not a great solution, but I can't find a better one at the moment.
 	 * An alternative would be to store these on the proxy's prototype,
 	 * but that embarks a lot of un-necessary code.
 	 */
 	std::unordered_map<const js::BaseProxyHandler*, std::unique_ptr<GUIProxyProps>> m_ProxyData;
 
 	/**
 	 * 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).
 	 */
 	std::map<CStr, std::vector<IGUIObject*> > m_HotkeyObjects;
 
 	/**
 	 * Map from hotkey names to maps of eventNames to functions that are triggered
 	 * when the hotkey goes through the event. Contrary to object hotkeys, this
 	 * allows for only one global function per hotkey name per event type.
 	 */
 	std::map<CStr, std::map<CStr, JS::PersistentRootedValue>> m_GlobalHotkeys;
 
 	/**
 	 * XML and JS can subscribe handlers to events identified by these names.
 	 * Store in static const members to avoid string copies, gain compile errors when misspelling and
 	 * to allow reuse in other classes.
 	 */
 	static const CStr EventNameLoad;
 	static const CStr EventNameTick;
 	static const CStr EventNamePress;
 	static const CStr EventNameKeyDown;
 	static const CStr EventNameRelease;
 	static const CStr EventNameMouseRightPress;
 	static const CStr EventNameMouseLeftPress;
 	static const CStr EventNameMouseWheelDown;
 	static const CStr EventNameMouseWheelUp;
 	static const CStr EventNameMouseLeftDoubleClick;
 	static const CStr EventNameMouseLeftRelease;
 	static const CStr EventNameMouseRightDoubleClick;
 	static const CStr EventNameMouseRightRelease;
 
 	//--------------------------------------------------------
 	//	Databases
 	//	These are loaded from XML files and marked as noncopyable and const to
 	//	rule out unintentional modification and copy, especially during Draw calls.
 	//--------------------------------------------------------
 
 	// Colors
 	std::map<CStr, const CGUIColor> m_PreDefinedColors;
 
 	// Sprites
 	std::map<CStr, const CGUISprite*> m_Sprites;
 
 	// Styles
 	std::map<CStr, const SGUIStyle> m_Styles;
 
 	// Scroll-bar styles
 	std::map<CStr, const SGUIScrollBarStyle> m_ScrollBarStyles;
 
 	// Icons
 	std::map<CStr, const SGUIIcon> m_Icons;
 
 public:
 	/**
 	 * Map from event names to object which listen to a given event.
 	 */
 	std::unordered_map<CStr, std::vector<IGUIObject*>> m_EventObjects;
 };
 
 #endif // INCLUDED_CGUI
Index: ps/trunk/source/gui/CGUIText.h
===================================================================
--- ps/trunk/source/gui/CGUIText.h	(revision 25164)
+++ ps/trunk/source/gui/CGUIText.h	(revision 25165)
@@ -1,285 +1,285 @@
 /* Copyright (C) 2021 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 INCLUDED_GUITEXT
 #define INCLUDED_GUITEXT
 
 #include "gui/CGUISprite.h"
 #include "gui/SettingTypes/CGUIColor.h"
 #include "gui/SettingTypes/EAlign.h"
+#include "maths/Rect.h"
 #include "maths/Size2D.h"
 #include "maths/Vector2D.h"
 #include "ps/CStrIntern.h"
-#include "ps/Shapes.h"
 
 #include <array>
 #include <list>
 #include <vector>
 
 class CGUI;
 class CGUIString;
 class IGUIObject;
 struct SGenerateTextImage;
 
 using SGenerateTextImages = std::array<std::vector<SGenerateTextImage>, 2>;
 
 /**
  * An CGUIText object is a parsed string, divided into
  * text-rendering components. Each component, being a
  * call to the Renderer. For instance, if you by tags
  * change the color, then the GUI will have to make
  * individual calls saying it want that color on the
  * text.
  *
  * For instance:
  * "Hello [b]there[/b] bunny!"
  *
  * That without word-wrapping would mean 3 components.
  * i.e. 3 calls to CRenderer. One drawing "Hello",
  * one drawing "there" in bold, and one drawing "bunny!".
  */
 class CGUIText
 {
 public:
 	/**
 	 * A sprite call to the CRenderer
 	 */
 	struct SSpriteCall
 	{
 		// The CGUISpriteInstance makes this uncopyable to avoid invalidating its draw cache
 		NONCOPYABLE(SSpriteCall);
 		MOVABLE(SSpriteCall);
 
 		SSpriteCall() {}
 
 		/**
 		 * Size and position of sprite
 		 */
 		CRect m_Area;
 
 		/**
 		 * Sprite from global GUI sprite database.
 		 */
 		CGUISpriteInstance m_Sprite;
 
 		/**
 		 * Tooltip text
 		 */
 		CStrW m_Tooltip;
 
 		/**
 		 * Tooltip style
 		 */
 		CStrW m_TooltipStyle;
 	};
 
 	/**
 	 * A text call to the CRenderer
 	 */
 	struct STextCall
 	{
 		NONCOPYABLE(STextCall);
 		MOVABLE(STextCall);
 
 		STextCall() :
 			m_UseCustomColor(false),
 			m_Bold(false), m_Italic(false), m_Underlined(false),
 			m_pSpriteCall(nullptr) {}
 
 		/**
 		 * Position
 		 */
 		CVector2D m_Pos;
 
 		/**
 		 * Size
 		 */
 		CSize2D m_Size;
 
 		/**
 		 * The string that is suppose to be rendered.
 		 */
 		CStrW m_String;
 
 		/**
 		 * Use custom color? If true then m_Color is used,
 		 * else the color inputted will be used.
 		 */
 		bool m_UseCustomColor;
 
 		/**
 		 * Color setup
 		 */
 		CGUIColor m_Color;
 
 		/**
 		 * Font name
 		 */
 		CStrIntern m_Font;
 
 		/**
 		 * Settings
 		 */
 		bool m_Bold, m_Italic, m_Underlined;
 
 		/**
 		 * *IF* an icon, then this is not nullptr.
 		 */
 		std::list<SSpriteCall>::pointer m_pSpriteCall;
 	};
 
 	// The SSpriteCall CGUISpriteInstance makes this uncopyable to avoid invalidating its draw cache.
 	// Also take advantage of exchanging the containers directly with move semantics.
 	NONCOPYABLE(CGUIText);
 	MOVABLE(CGUIText);
 
 	/**
 	 * Generates empty text.
 	 */
 	CGUIText() = default;
 
 	/**
 	 * Generate a CGUIText 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.
 	 *
 	 * @param Text Text to generate CGUIText 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 occurred in to aid the user.
 	 */
 	CGUIText(const CGUI& pGUI, const CGUIString& string, const CStrW& FontW, const float Width, const float BufferZone, const IGUIObject* pObject);
 
 	/**
 	 * Draw this CGUIText object
 	 */
 	void Draw(CGUI& pGUI, const CGUIColor& DefaultColor, const CVector2D& pos, const float z, const CRect& clipping) const;
 
 	const CSize2D& GetSize() const { return m_Size; }
 
 	const std::list<SSpriteCall>& GetSpriteCalls() const { return m_SpriteCalls; }
 
 	const std::vector<STextCall>& GetTextCalls() const { return m_TextCalls; }
 
 	// Helper functions of the constructor
 	bool ProcessLine(
 		const CGUI& pGUI,
 		const CGUIString& string,
 		const CStrIntern& Font,
 		const IGUIObject* pObject,
 		const SGenerateTextImages& Images,
 		const EAlign align,
 		const float prelim_line_height,
 		const float Width,
 		const float BufferZone,
 		bool& FirstLine,
 		float& x,
 		float& y,
 		int& i,
 		int& from);
 
 	void SetupSpriteCalls(
 		const CGUI& pGUI,
 		const std::array<std::vector<CStr>, 2>& FeedbackImages,
 		const float y,
 		const float Width,
 		const float BufferZone,
 		const int i,
 		const int pos_last_img,
 		SGenerateTextImages& Images);
 
 	float GetLineOffset(
 		const EAlign align,
 		const float width_range_from,
 		const float width_range_to,
 		const CSize2D& line_size) const;
 
 	void ComputeLineRange(
 		const SGenerateTextImages& Images,
 		const float y,
 		const float Width,
 		const float prelim_line_height,
 		float& width_range_from,
 		float& width_range_to) const;
 
 	void ComputeLineSize(
 		const CGUI& pGUI,
 		const CGUIString& string,
 		const CStrIntern& Font,
 		const bool FirstLine,
 		const float Width,
 		const float width_range_to,
 		const int i,
 		const int temp_from,
 		float& x,
 		CSize2D& line_size) const;
 
 	bool AssembleCalls(
 		const CGUI& pGUI,
 		const CGUIString& string,
 		const CStrIntern& Font,
 		const IGUIObject* pObject,
 		const bool FirstLine,
 		const float Width,
 		const float width_range_to,
 		const float dx,
 		const float y,
 		const int temp_from,
 		const int i,
 		float& x,
 		int& from);
 
 	/**
 	 * List of TextCalls, for instance "Hello", "there!"
 	 */
 	std::vector<STextCall> m_TextCalls;
 
 	/**
 	 * List of sprites, or "icons" that should be rendered
 	 * along with the text.
 	 */
 	std::list<SSpriteCall> m_SpriteCalls; // list for consistent mem addresses
 										  // so that we can point to elements.
 	/**
 	 * Width and height of the whole output, used when setting up
 	 * scrollbars and such.
 	 */
 	CSize2D m_Size;
 };
 
 struct SGenerateTextImage
 {
 	// The image's starting location in Y
 	float m_YFrom;
 
 	// The image's end location in Y
 	float m_YTo;
 
 	// The image width in other words
 	float m_Indentation;
 
 	void SetupSpriteCall(
 		const bool Left, CGUIText::SSpriteCall& SpriteCall, const float width, const float y,
 		const CSize2D& Size, const CStr& TextureName, const float BufferZone);
 };
 
 #endif // INCLUDED_GUITEXT
Index: ps/trunk/source/gui/GUIRenderer.h
===================================================================
--- ps/trunk/source/gui/GUIRenderer.h	(revision 25164)
+++ ps/trunk/source/gui/GUIRenderer.h	(revision 25165)
@@ -1,76 +1,76 @@
 /* Copyright (C) 2021 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 INCLUDED_GUIRENDERER
 #define INCLUDED_GUIRENDERER
 
 #include "graphics/Color.h"
 #include "graphics/ShaderTechniquePtr.h"
 #include "graphics/Texture.h"
 #include "lib/res/handle.h"
-#include "ps/Shapes.h"
+#include "maths/Rect.h"
 
 #include <map>
 #include <vector>
 
 class CGUI;
 class CGUISprite;
 class CStr8;
 struct CGUIColor;
 struct SGUIImage;
 
 namespace GUIRenderer
 {
 	struct SDrawCall
 	{
 		SDrawCall(const SGUIImage* image) : m_Image(image) {}
 		CRect ComputeTexCoords() const;
 
 		const SGUIImage* m_Image;
 
 		bool m_HasTexture;
 		CTexturePtr m_Texture;
 
 		CRect m_ObjectSize;
 
 		bool m_EnableBlending;
 
 		CShaderTechniquePtr m_Shader;
 		CColor m_ShaderColorParameter;
 
 		CRect m_Vertices;
 		float m_DeltaZ;
 
 		CGUIColor* m_BorderColor; // == nullptr for no border
 		CGUIColor* m_BackColor;
 	};
 
 	class DrawCalls : public std::vector<SDrawCall>
 	{
 	public:
 		DrawCalls();
 		// Copy/assignment results in an empty list, not an actual copy
 		DrawCalls(const DrawCalls&);
 		DrawCalls& operator=(const DrawCalls&);
 	};
 
 	void UpdateDrawCallCache(const CGUI& pGUI, DrawCalls& Calls, const CStr8& SpriteName, const CRect& Size, std::map<CStr8, const CGUISprite*>& Sprites);
 
 	void Draw(DrawCalls& Calls, float Z);
 }
 
 #endif // INCLUDED_GUIRENDERER
Index: ps/trunk/source/gui/ObjectBases/IGUITextOwner.h
===================================================================
--- ps/trunk/source/gui/ObjectBases/IGUITextOwner.h	(revision 25164)
+++ ps/trunk/source/gui/ObjectBases/IGUITextOwner.h	(revision 25165)
@@ -1,128 +1,128 @@
 /* Copyright (C) 2021 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/>.
  */
 
 /*
 GUI Object Base - Text Owner
 
 --Overview--
 
 	Interface class that enhance the IGUIObject with
 	 cached CGUIStrings. This class is not at all needed,
 	 and many controls that will use CGUIStrings might
 	 not use this, but does help for regular usage such
 	 as a text-box, a button, a radio button etc.
 */
 
 #ifndef INCLUDED_IGUITEXTOWNER
 #define INCLUDED_IGUITEXTOWNER
 
-#include "ps/Shapes.h"
+#include "maths/Rect.h"
 
 #include <vector>
 
 struct CGUIColor;
 struct SGUIMessage;
 class CGUIText;
 class CGUIString;
 class IGUIObject;
 
 class CStrW;
 class CVector2D;
 
 /**
  * Framework for handling Output text.
  */
 class IGUITextOwner
 {
 	NONCOPYABLE(IGUITextOwner);
 
 public:
 	IGUITextOwner(IGUIObject& pObject);
 	virtual ~IGUITextOwner();
 
 	/**
 	 * Adds a text object.
 	 */
 	CGUIText& AddText();
 
 	/**
 	 * Adds a text generated by the given arguments.
 	 */
 	CGUIText& AddText(const CGUIString& Text, const CStrW& Font, const float& Width, const float& BufferZone);
 
 	/**
 	 * @see IGUIObject#HandleMessage()
 	 */
 	virtual void HandleMessage(SGUIMessage& Message);
 
 	/**
 	 * @see IGUIObject#UpdateCachedSize()
 	 */
 	virtual void UpdateCachedSize();
 
 	/**
 	 * Draws the Text.
 	 *
 	 * @param index Index value of text. Mostly this will be 0
 	 * @param color
 	 * @param pos Position
 	 * @param z Z value
 	 * @param clipping Clipping rectangle, don't even add a parameter
 	 *		  to get no clipping.
 	 */
 	virtual void DrawText(size_t index, const CGUIColor& color, const CVector2D& pos, float z, const CRect& clipping = CRect());
 
 	/**
 	 * Test if mouse position is over an icon
 	 */
 	virtual bool MouseOverIcon();
 
 protected:
 	/**
 	 * Setup texts. Functions that sets up all texts when changes have been made.
 	 */
 	virtual void SetupText() = 0;
 
 	/**
 	 * Regenerate the text in case it is invalid. Should only be called when inevitable.
 	 */
 	virtual void UpdateText();
 
 	/**
 	 * Whether the cached text is currently valid (if not then SetupText will be called by Draw)
 	 */
 	bool m_GeneratedTextsValid;
 
 	/**
 	 * Texts that are generated and ready to be rendered.
 	 */
 	std::vector<CGUIText> m_GeneratedTexts;
 
 	/**
 	 * Calculate the position for the text, based on the alignment.
 	 */
 	void CalculateTextPosition(CRect& ObjSize, CVector2D& TextPos, CGUIText& Text);
 
 private:
 	/**
 	 * Reference to the IGUIObject.
 	 * Private, because we don't want to inherit it in multiple classes.
 	 */
 	IGUIObject& m_pObject;
 };
 
 #endif // INCLUDED_IGUITEXTOWNER
Index: ps/trunk/source/gui/SettingTypes/CGUISize.h
===================================================================
--- ps/trunk/source/gui/SettingTypes/CGUISize.h	(revision 25164)
+++ ps/trunk/source/gui/SettingTypes/CGUISize.h	(revision 25165)
@@ -1,75 +1,75 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2021 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 INCLUDED_CGUISIZE
 #define INCLUDED_CGUISIZE
 
-#include "ps/Shapes.h"
+#include "maths/Rect.h"
 #include "scriptinterface/ScriptForward.h"
 
 class CStr8;
 
 /**
  * This class represents a rectangle relative to a parent rectangle
  * The value can be initialized from a string or JS object.
  */
 class CGUISize
 {
 public:
 	// COPYABLE, since there are only primitives involved, making move and copy identical,
 	// and since some temporaries cannot be avoided.
 	CGUISize();
 	CGUISize(const CRect& pixel, const CRect& percent);
 
 	static CGUISize Full();
 
 	/// Pixel modifiers
 	CRect pixel;
 
 	/// Percent modifiers
 	CRect percent;
 
 	/**
 	 * Get client area rectangle when the parent is given
 	 */
 	CRect GetSize(const CRect& parent) const;
 
 	/**
 	 * The value can be set from a string looking like:
 	 *
 	 * "0 0 100% 100%"
 	 * "50%-10 50%-10 50%+10 50%+10"
 	 *
 	 * i.e. First percent modifier, then + or - and the pixel modifier.
 	 * Although you can use just the percent or the pixel modifier. Notice
 	 * though that the percent modifier must always be the first when
 	 * both modifiers are inputted.
 	 *
 	 * @return true if success, otherwise size will remain unchanged.
 	 */
 	bool FromString(const CStr8& Value);
 
 	bool operator==(const CGUISize& other) const
 	{
 		return pixel == other.pixel && percent == other.percent;
 	}
 
 	void ToJSVal(const ScriptRequest& rq, JS::MutableHandleValue ret) const;
 	bool FromJSVal(const ScriptRequest& rq, JS::HandleValue v);
 };
 
 #endif // INCLUDED_CGUISIZE
Index: ps/trunk/source/maths/Rect.cpp
===================================================================
--- ps/trunk/source/maths/Rect.cpp	(nonexistent)
+++ ps/trunk/source/maths/Rect.cpp	(revision 25165)
@@ -0,0 +1,221 @@
+/* Copyright (C) 2021 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 "Rect.h"
+
+#include "maths/Size2D.h"
+#include "maths/Vector2D.h"
+
+CRect::CRect() :
+	left(0.f), top(0.f), right(0.f), bottom(0.f)
+{
+}
+
+CRect::CRect(const CRect& rect) :
+	left(rect.left), top(rect.top), right(rect.right), bottom(rect.bottom)
+{
+}
+
+CRect::CRect(const CVector2D& pos) :
+	left(pos.X), top(pos.Y), right(pos.X), bottom(pos.Y)
+{
+}
+
+CRect::CRect(const CSize2D& size) :
+	left(0.f), top(0.f), right(size.Width), bottom(size.Height)
+{
+}
+
+CRect::CRect(const CVector2D& upperleft, const CVector2D& bottomright) :
+	left(upperleft.X), top(upperleft.Y), right(bottomright.X), bottom(bottomright.Y)
+{
+}
+
+CRect::CRect(const CVector2D& pos, const CSize2D& size) :
+	left(pos.X), top(pos.Y), right(pos.X + size.Width), bottom(pos.Y + size.Height)
+{
+}
+
+CRect::CRect(const float l, const float t, const float r, const float b) :
+	left(l), top(t), right(r), bottom(b)
+{
+}
+
+CRect& CRect::operator=(const CRect& a)
+{
+	left = a.left;
+	top = a.top;
+	right = a.right;
+	bottom = a.bottom;
+	return *this;
+}
+
+bool CRect::operator==(const CRect &a) const
+{
+	return	(left == a.left &&
+			 top == a.top &&
+			 right == a.right &&
+			 bottom == a.bottom);
+}
+
+bool CRect::operator!=(const CRect& a) const
+{
+	return !(*this == a);
+}
+
+CRect CRect::operator-() const
+{
+	return CRect(-left, -top, -right, -bottom);
+}
+
+CRect CRect::operator+() const
+{
+	return *this;
+}
+
+CRect CRect::operator+(const CRect& a) const
+{
+	return CRect(left + a.left, top + a.top, right + a.right, bottom + a.bottom);
+}
+
+CRect CRect::operator+(const CVector2D& a) const
+{
+	return CRect(left + a.X, top + a.Y, right + a.X, bottom + a.Y);
+}
+
+CRect CRect::operator+(const CSize2D& a) const
+{
+	return CRect(left + a.Width, top + a.Height, right + a.Width, bottom + a.Height);
+}
+
+CRect CRect::operator-(const CRect& a) const
+{
+	return CRect(left - a.left, top - a.top, right - a.right, bottom - a.bottom);
+}
+
+CRect CRect::operator-(const CVector2D& a) const
+{
+	return CRect(left - a.X, top - a.Y, right - a.X, bottom - a.Y);
+}
+
+CRect CRect::operator-(const CSize2D& a) const
+{
+	return CRect(left - a.Width, top - a.Height, right - a.Width, bottom - a.Height);
+}
+
+void CRect::operator+=(const CRect& a)
+{
+	left += a.left;
+	top += a.top;
+	right += a.right;
+	bottom += a.bottom;
+}
+
+void CRect::operator+=(const CVector2D& a)
+{
+	left += a.X;
+	top += a.Y;
+	right += a.X;
+	bottom += a.Y;
+}
+
+void CRect::operator+=(const CSize2D& a)
+{
+	left += a.Width;
+	top += a.Height;
+	right += a.Width;
+	bottom += a.Height;
+}
+
+void CRect::operator-=(const CRect& a)
+{
+	left -= a.left;
+	top -= a.top;
+	right -= a.right;
+	bottom -= a.bottom;
+}
+
+void CRect::operator-=(const CVector2D& a)
+{
+	left -= a.X;
+	top -= a.Y;
+	right -= a.X;
+	bottom -= a.Y;
+}
+
+void CRect::operator-=(const CSize2D& a)
+{
+	left -= a.Width;
+	top -= a.Height;
+	right -= a.Width;
+	bottom -= a.Height;
+}
+
+float CRect::GetWidth() const
+{
+	return right-left;
+}
+
+float CRect::GetHeight() const
+{
+	return bottom-top;
+}
+
+CSize2D CRect::GetSize() const
+{
+	return CSize2D(right - left, bottom - top);
+}
+
+CVector2D CRect::TopLeft() const
+{
+	return CVector2D(left, top);
+}
+
+CVector2D CRect::TopRight() const
+{
+	return CVector2D(right, top);
+}
+
+CVector2D CRect::BottomLeft() const
+{
+	return CVector2D(left, bottom);
+}
+
+CVector2D CRect::BottomRight() const
+{
+	return CVector2D(right, bottom);
+}
+
+CVector2D CRect::CenterPoint() const
+{
+	return CVector2D((left + right) / 2.f, (top + bottom) / 2.f);
+}
+
+bool CRect::PointInside(const CVector2D& point) const
+{
+	return (point.X >= left &&
+			point.X <= right &&
+			point.Y >= top &&
+			point.Y <= bottom);
+}
+
+CRect CRect::Scale(float x, float y) const
+{
+	return CRect(left * x, top * y, right * x, bottom * y);
+}

Property changes on: ps/trunk/source/maths/Rect.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/maths/Rect.h
===================================================================
--- ps/trunk/source/maths/Rect.h	(nonexistent)
+++ ps/trunk/source/maths/Rect.h	(revision 25165)
@@ -0,0 +1,121 @@
+/* Copyright (C) 2021 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 INCLUDED_RECT
+#define INCLUDED_RECT
+
+class CSize2D;
+class CVector2D;
+
+
+/**
+ * Rectangle class used for screen rectangles. It's very similar to the MS
+ * CRect, but with FLOATS because it's meant to be used with OpenGL which
+ * takes float values.
+ */
+class CRect
+{
+public:
+	CRect();
+	CRect(const CVector2D& pos);
+	CRect(const CSize2D& size);
+	CRect(const CVector2D& upperleft, const CVector2D& bottomright);
+	CRect(const CVector2D& pos, const CSize2D& size);
+	CRect(const float l, const float t, const float r, const float b);
+	CRect(const CRect&);
+
+	CRect& operator=(const CRect& a);
+	bool operator==(const CRect& a) const;
+	bool operator!=(const CRect& a) const;
+	CRect operator-() const;
+	CRect operator+() const;
+
+	CRect operator+(const CRect& a) const;
+	CRect operator+(const CVector2D& a) const;
+	CRect operator+(const CSize2D& a) const;
+	CRect operator-(const CRect& a) const;
+	CRect operator-(const CVector2D& a) const;
+	CRect operator-(const CSize2D& a) const;
+
+	void operator+=(const CRect& a);
+	void operator+=(const CVector2D& a);
+	void operator+=(const CSize2D& a);
+	void operator-=(const CRect& a);
+	void operator-=(const CVector2D& a);
+	void operator-=(const CSize2D& a);
+
+	/**
+	 * @return Width of Rectangle
+	 */
+	float GetWidth() const;
+
+	/**
+	 * @return Height of Rectangle
+	 */
+	float GetHeight() const;
+
+	/**
+	 * Get Size
+	 */
+	CSize2D GetSize() const;
+
+	/**
+	 * Get Position equivalent to top/left corner
+	 */
+	CVector2D TopLeft() const;
+
+	/**
+	 * Get Position equivalent to top/right corner
+	 */
+	CVector2D TopRight() const;
+
+	/**
+	 * Get Position equivalent to bottom/left corner
+	 */
+	CVector2D BottomLeft() const;
+
+	/**
+	 * Get Position equivalent to bottom/right corner
+	 */
+	CVector2D BottomRight() const;
+
+	/**
+	 * Get Position equivalent to the center of the rectangle
+	 */
+	CVector2D CenterPoint() const;
+
+	/**
+	 * Evalutates if point is within the rectangle
+	 * @param point CVector2D representing point
+	 * @return true if inside.
+	 */
+	bool PointInside(const CVector2D &point) const;
+
+	CRect Scale(float x, float y) const;
+
+	/**
+	 * Returning CVector2D representing each corner.
+	 */
+
+public:
+	/**
+	 * Dimensions
+	 */
+	float left, top, right, bottom;
+};
+
+#endif // INCLUDED_RECT

Property changes on: ps/trunk/source/maths/Rect.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/ps/Game.cpp
===================================================================
--- ps/trunk/source/ps/Game.cpp	(revision 25164)
+++ ps/trunk/source/ps/Game.cpp	(revision 25165)
@@ -1,471 +1,470 @@
 /* Copyright (C) 2021 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 "Game.h"
 
 #include "graphics/GameView.h"
 #include "graphics/LOSTexture.h"
 #include "graphics/ParticleManager.h"
 #include "graphics/UnitManager.h"
 #include "gui/GUIManager.h"
 #include "gui/CGUI.h"
 #include "lib/config2.h"
 #include "lib/timer.h"
 #include "network/NetClient.h"
 #include "network/NetServer.h"
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/Loader.h"
 #include "ps/LoaderThunks.h"
 #include "ps/Profile.h"
 #include "ps/Replay.h"
-#include "ps/Shapes.h"
 #include "ps/World.h"
 #include "ps/GameSetup/GameSetup.h"
 #include "renderer/Renderer.h"
 #include "renderer/TimeManager.h"
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpPlayer.h"
 #include "simulation2/components/ICmpPlayerManager.h"
 #include "simulation2/system/ReplayTurnManager.h"
 #include "soundmanager/ISoundManager.h"
 
 #include "tools/atlas/GameInterface/GameLoop.h"
 
 #include <fstream>
 
 extern bool g_GameRestarted;
 extern GameLoopState* g_AtlasGameLoop;
 
 /**
  * Globally accessible pointer to the CGame object.
  **/
 CGame *g_Game=NULL;
 
 const CStr CGame::EventNameSimulationUpdate = "SimulationUpdate";
 
 /**
  * Constructor
  *
  **/
 CGame::CGame(bool replayLog):
 	m_World(new CWorld(this)),
 	m_Simulation2(new CSimulation2(&m_World->GetUnitManager(), g_ScriptContext, m_World->GetTerrain())),
 	m_GameView(CRenderer::IsInitialised() ? new CGameView(this) : nullptr),
 	m_GameStarted(false),
 	m_Paused(false),
 	m_SimRate(1.0f),
 	m_PlayerID(-1),
 	m_ViewedPlayerID(-1),
 	m_IsSavedGame(false),
 	m_IsVisualReplay(false),
 	m_ReplayStream(NULL)
 {
 	// TODO: should use CDummyReplayLogger unless activated by cmd-line arg, perhaps?
 	if (replayLog)
 		m_ReplayLogger = new CReplayLogger(m_Simulation2->GetScriptInterface());
 	else
 		m_ReplayLogger = new CDummyReplayLogger();
 
 	// Need to set the CObjectManager references after various objects have
 	// been initialised, so do it here rather than via the initialisers above.
 	if (m_GameView)
 		m_World->GetUnitManager().SetObjectManager(m_GameView->GetObjectManager());
 
 	m_TurnManager = new CLocalTurnManager(*m_Simulation2, GetReplayLogger()); // this will get replaced if we're a net server/client
 
 	m_Simulation2->LoadDefaultScripts();
 }
 
 /**
  * Destructor
  *
  **/
 CGame::~CGame()
 {
 	// Again, the in-game call tree is going to be different to the main menu one.
 	if (CProfileManager::IsInitialised())
 		g_Profiler.StructuralReset();
 
 	if (m_ReplayLogger && m_GameStarted)
 		m_ReplayLogger->SaveMetadata(*m_Simulation2);
 
 	delete m_TurnManager;
 	delete m_GameView;
 	delete m_Simulation2;
 	delete m_World;
 	delete m_ReplayLogger;
 	delete m_ReplayStream;
 }
 
 void CGame::SetTurnManager(CTurnManager* turnManager)
 {
 	if (m_TurnManager)
 		delete m_TurnManager;
 
 	m_TurnManager = turnManager;
 
 	if (m_TurnManager)
 		m_TurnManager->SetPlayerID(m_PlayerID);
 }
 
 int CGame::LoadVisualReplayData()
 {
 	ENSURE(m_IsVisualReplay);
 	ENSURE(!m_ReplayPath.empty());
 	ENSURE(m_ReplayStream);
 
 	CReplayTurnManager* replayTurnMgr = static_cast<CReplayTurnManager*>(GetTurnManager());
 
 	u32 currentTurn = 0;
 	std::string type;
 	while ((*m_ReplayStream >> type).good())
 	{
 		if (type == "turn")
 		{
 			u32 turn = 0;
 			u32 turnLength = 0;
 			*m_ReplayStream >> turn >> turnLength;
 			ENSURE(turn == currentTurn && "You tried to replay a commands.txt file of a rejoined client. Please use the host's file.");
 			replayTurnMgr->StoreReplayTurnLength(currentTurn, turnLength);
 		}
 		else if (type == "cmd")
 		{
 			player_id_t player;
 			*m_ReplayStream >> player;
 
 			std::string line;
 			std::getline(*m_ReplayStream, line);
 			replayTurnMgr->StoreReplayCommand(currentTurn, player, line);
 		}
 		else if (type == "hash" || type == "hash-quick")
 		{
 			bool quick = (type == "hash-quick");
 			std::string replayHash;
 			*m_ReplayStream >> replayHash;
 			replayTurnMgr->StoreReplayHash(currentTurn, replayHash, quick);
 		}
 		else if (type == "end")
 			++currentTurn;
 		else
 			CancelLoad(L"Failed to load replay data (unrecognized content)");
 	}
 	SAFE_DELETE(m_ReplayStream);
 	m_FinalReplayTurn = currentTurn > 0 ? currentTurn - 1 : 0;
 	replayTurnMgr->StoreFinalReplayTurn(m_FinalReplayTurn);
 	return 0;
 }
 
 bool CGame::StartVisualReplay(const OsPath& replayPath)
 {
 	debug_printf("Starting to replay %s\n", replayPath.string8().c_str());
 
 	m_IsVisualReplay = true;
 
 	SetTurnManager(new CReplayTurnManager(*m_Simulation2, GetReplayLogger()));
 
 	m_ReplayPath = replayPath;
 	m_ReplayStream = new std::ifstream(OsString(replayPath).c_str());
 
 	std::string type;
 	ENSURE((*m_ReplayStream >> type).good() && type == "start");
 
 	std::string line;
 	std::getline(*m_ReplayStream, line);
 
 	const ScriptInterface& scriptInterface = m_Simulation2->GetScriptInterface();
 	ScriptRequest rq(scriptInterface);
 
 	JS::RootedValue attribs(rq.cx);
 	scriptInterface.ParseJSON(line, &attribs);
 	StartGame(&attribs, "");
 
 	return true;
 }
 
 /**
  * Initializes the game with the set of attributes provided.
  * Makes calls to initialize the game view, world, and simulation objects.
  * Calls are made to facilitate progress reporting of the initialization.
  **/
 void CGame::RegisterInit(const JS::HandleValue attribs, const std::string& savedState)
 {
 	const ScriptInterface& scriptInterface = m_Simulation2->GetScriptInterface();
 	ScriptRequest rq(scriptInterface);
 
 	m_InitialSavedState = savedState;
 	m_IsSavedGame = !savedState.empty();
 
 	m_Simulation2->SetInitAttributes(attribs);
 
 	std::string mapType;
 	scriptInterface.GetProperty(attribs, "mapType", mapType);
 
 	float speed;
 	if (scriptInterface.HasProperty(attribs, "gameSpeed") && scriptInterface.GetProperty(attribs, "gameSpeed", speed))
 		SetSimRate(speed);
 
 	LDR_BeginRegistering();
 
 	RegMemFun(m_Simulation2, &CSimulation2::ProgressiveLoad, L"Simulation init", 1000);
 
 	// RC, 040804 - GameView needs to be initialized before World, otherwise GameView initialization
 	// overwrites anything stored in the map file that gets loaded by CWorld::Initialize with default
 	// values.  At the minute, it's just lighting settings, but could be extended to store camera position.
 	// Storing lighting settings in the game view seems a little odd, but it's no big deal; maybe move it at
 	// some point to be stored in the world object?
 	if (m_GameView)
 		m_GameView->RegisterInit();
 
 	if (mapType == "random")
 	{
 		// Load random map attributes
 		std::wstring scriptFile;
 		JS::RootedValue settings(rq.cx);
 
 		scriptInterface.GetProperty(attribs, "script", scriptFile);
 		scriptInterface.GetProperty(attribs, "settings", &settings);
 
 		m_World->RegisterInitRMS(scriptFile, *scriptInterface.GetContext(), settings, m_PlayerID);
 	}
 	else
 	{
 		std::wstring mapFile;
 		JS::RootedValue settings(rq.cx);
 		scriptInterface.GetProperty(attribs, "map", mapFile);
 		scriptInterface.GetProperty(attribs, "settings", &settings);
 
 		m_World->RegisterInit(mapFile, *scriptInterface.GetContext(), settings, m_PlayerID);
 	}
 	if (m_GameView)
 		RegMemFun(g_Renderer.GetSingletonPtr()->GetWaterManager(), &WaterManager::LoadWaterTextures, L"LoadWaterTextures", 80);
 
 	if (m_IsSavedGame)
 		RegMemFun(this, &CGame::LoadInitialState, L"Loading game", 1000);
 
 	if (m_IsVisualReplay)
 		RegMemFun(this, &CGame::LoadVisualReplayData, L"Loading visual replay data", 1000);
 
 	LDR_EndRegistering();
 }
 
 int CGame::LoadInitialState()
 {
 	ENSURE(m_IsSavedGame);
 	ENSURE(!m_InitialSavedState.empty());
 
 	std::string state;
 	m_InitialSavedState.swap(state); // deletes the original to save a bit of memory
 
 	std::stringstream stream(state);
 
 	bool ok = m_Simulation2->DeserializeState(stream);
 	if (!ok)
 	{
 		CancelLoad(L"Failed to load saved game state. It might have been\nsaved with an incompatible version of the game.");
 		return 0;
 	}
 
 	return 0;
 }
 
 /**
  * Game initialization has been completed. Set game started flag and start the session.
  *
  * @return PSRETURN 0
  **/
 PSRETURN CGame::ReallyStartGame()
 {
 	// Call the script function InitGame only for new games, not saved games
 	if (!m_IsSavedGame)
 	{
 		// Perform some simulation initializations (replace skirmish entities, explore territories, etc.)
 		// that needs to be done before setting up the AI and shouldn't be done in Atlas
 		if (!g_AtlasGameLoop->running)
 			m_Simulation2->PreInitGame();
 
 		m_Simulation2->InitGame();
 	}
 
 	// We need to do an initial Interpolate call to set up all the models etc,
 	// because Update might never interpolate (e.g. if the game starts paused)
 	// and we could end up rendering before having set up any models (so they'd
 	// all be invisible)
 	Interpolate(0, 0);
 
 	m_GameStarted=true;
 
 	// Render a frame to begin loading assets
 	if (CRenderer::IsInitialised())
 		Render();
 
 	if (g_NetClient)
 		g_NetClient->LoadFinished();
 
 	// Call the reallyStartGame GUI function, but only if it exists
 	if (g_GUI && g_GUI->GetPageCount())
 	{
 		shared_ptr<ScriptInterface> scriptInterface = g_GUI->GetActiveGUI()->GetScriptInterface();
 		ScriptRequest rq(scriptInterface);
 
 		JS::RootedValue global(rq.cx, rq.globalValue());
 		if (scriptInterface->HasProperty(global, "reallyStartGame"))
 			scriptInterface->CallFunctionVoid(global, "reallyStartGame");
 	}
 
 	debug_printf("GAME STARTED, ALL INIT COMPLETE\n");
 
 	// The call tree we've built for pregame probably isn't useful in-game.
 	if (CProfileManager::IsInitialised())
 		g_Profiler.StructuralReset();
 
 	g_GameRestarted = true;
 
 	return 0;
 }
 
 int CGame::GetPlayerID()
 {
 	return m_PlayerID;
 }
 
 void CGame::SetPlayerID(player_id_t playerID)
 {
 	m_PlayerID = playerID;
 	m_ViewedPlayerID = playerID;
 
 	if (m_TurnManager)
 		m_TurnManager->SetPlayerID(m_PlayerID);
 }
 
 int CGame::GetViewedPlayerID()
 {
 	return m_ViewedPlayerID;
 }
 
 void CGame::SetViewedPlayerID(player_id_t playerID)
 {
 	m_ViewedPlayerID = playerID;
 }
 
 void CGame::StartGame(JS::MutableHandleValue attribs, const std::string& savedState)
 {
 	if (m_ReplayLogger)
 		m_ReplayLogger->StartGame(attribs);
 
 	RegisterInit(attribs, savedState);
 }
 
 // TODO: doInterpolate is optional because Atlas interpolates explicitly,
 // so that it has more control over the update rate. The game might want to
 // do the same, and then doInterpolate should be redundant and removed.
 
 void CGame::Update(const double deltaRealTime, bool doInterpolate)
 {
 	if (m_Paused || !m_TurnManager)
 		return;
 
 	const double deltaSimTime = deltaRealTime * m_SimRate;
 
 	if (deltaSimTime)
 	{
 		// To avoid confusing the profiler, we need to trigger the new turn
 		// while we're not nested inside any PROFILE blocks
 		if (m_TurnManager->WillUpdate(deltaSimTime))
 			g_Profiler.Turn();
 
 		// At the normal sim rate, we currently want to render at least one
 		// frame per simulation turn, so let maxTurns be 1. But for fast-forward
 		// sim rates we want to allow more, so it's not bounded by framerate,
 		// so just use the sim rate itself as the number of turns per frame.
 		size_t maxTurns = (size_t)m_SimRate;
 
 		if (m_TurnManager->Update(deltaSimTime, maxTurns))
 		{
 			{
 				PROFILE3("gui sim update");
 				g_GUI->SendEventToAll(EventNameSimulationUpdate);
 			}
 
 			GetView()->GetLOSTexture().MakeDirty();
 		}
 
 		if (CRenderer::IsInitialised())
 			g_Renderer.GetTimeManager().Update(deltaSimTime);
 	}
 
 	if (doInterpolate)
 		m_TurnManager->Interpolate(deltaSimTime, deltaRealTime);
 }
 
 void CGame::Interpolate(float simFrameLength, float realFrameLength)
 {
 	if (!m_TurnManager)
 		return;
 
 	m_TurnManager->Interpolate(simFrameLength, realFrameLength);
 }
 
 
 static CColor BrokenColor(0.3f, 0.3f, 0.3f, 1.0f);
 
 void CGame::CachePlayerColors()
 {
 	m_PlayerColors.clear();
 
 	CmpPtr<ICmpPlayerManager> cmpPlayerManager(*m_Simulation2, SYSTEM_ENTITY);
 	if (!cmpPlayerManager)
 		return;
 
 	int numPlayers = cmpPlayerManager->GetNumPlayers();
 	m_PlayerColors.resize(numPlayers);
 
 	for (int i = 0; i < numPlayers; ++i)
 	{
 		CmpPtr<ICmpPlayer> cmpPlayer(*m_Simulation2, cmpPlayerManager->GetPlayerByID(i));
 		if (!cmpPlayer)
 			m_PlayerColors[i] = BrokenColor;
 		else
 			m_PlayerColors[i] = cmpPlayer->GetDisplayedColor();
 	}
 }
 
 
 CColor CGame::GetPlayerColor(player_id_t player) const
 {
 	if (player < 0 || player >= (int)m_PlayerColors.size())
 		return BrokenColor;
 
 	return m_PlayerColors[player];
 }
 
 bool CGame::IsGameFinished() const
 {
 	for (const std::pair<entity_id_t, IComponent*>& p : m_Simulation2->GetEntitiesWithInterface(IID_Player))
 	{
 		CmpPtr<ICmpPlayer> cmpPlayer(*m_Simulation2, p.first);
 		if (cmpPlayer && cmpPlayer->GetState() == "won")
 			return true;
 	}
 
 	return false;
 }
Index: ps/trunk/source/simulation2/scripting/EngineScriptConversions.cpp
===================================================================
--- ps/trunk/source/simulation2/scripting/EngineScriptConversions.cpp	(revision 25164)
+++ ps/trunk/source/simulation2/scripting/EngineScriptConversions.cpp	(revision 25165)
@@ -1,333 +1,333 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "scriptinterface/ScriptConversions.h"
 
 #include "graphics/Color.h"
 #include "maths/Fixed.h"
 #include "maths/FixedVector2D.h"
 #include "maths/FixedVector3D.h"
+#include "maths/Rect.h"
 #include "ps/CLogger.h"
-#include "ps/Shapes.h"
 #include "ps/utf16string.h"
 #include "simulation2/helpers/CinemaPath.h"
 #include "simulation2/helpers/Grid.h"
 #include "simulation2/system/IComponent.h"
 #include "simulation2/system/ParamNode.h"
 
 #define FAIL(msg) STMT(LOGERROR(msg); return false)
 #define FAIL_VOID(msg) STMT(ScriptException::Raise(rq, msg); return)
 
 template<> void ScriptInterface::ToJSVal<IComponent*>(const ScriptRequest& rq,  JS::MutableHandleValue ret, IComponent* const& val)
 {
 	if (val == NULL)
 	{
 		ret.setNull();
 		return;
 	}
 
 	// If this is a scripted component, just return the JS object directly
 	JS::RootedValue instance(rq.cx, val->GetJSInstance());
 	if (!instance.isNull())
 	{
 		ret.set(instance);
 		return;
 	}
 
 	// Otherwise we need to construct a wrapper object
 	// (TODO: cache wrapper objects?)
 	JS::RootedObject obj(rq.cx);
 	if (!val->NewJSObject(*ScriptInterface::GetScriptInterfaceAndCBData(rq.cx)->pScriptInterface, &obj))
 	{
 		// Report as an error, since scripts really shouldn't try to use unscriptable interfaces
 		LOGERROR("IComponent does not have a scriptable interface");
 		ret.setUndefined();
 		return;
 	}
 
 	JS_SetPrivate(obj, static_cast<void*>(val));
 	ret.setObject(*obj);
 }
 
 template<> void ScriptInterface::ToJSVal<CParamNode>(const ScriptRequest& rq,  JS::MutableHandleValue ret, CParamNode const& val)
 {
 	val.ToJSVal(rq, true, ret);
 
 	// Prevent modifications to the object, so that it's safe to share between
 	// components and to reconstruct on deserialization
 	if (ret.isObject())
 	{
 		JS::RootedObject obj(rq.cx, &ret.toObject());
 		JS_DeepFreezeObject(rq.cx, obj);
 	}
 }
 
 template<> void ScriptInterface::ToJSVal<const CParamNode*>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const CParamNode* const& val)
 {
 	if (val)
 		ToJSVal(rq, ret, *val);
 	else
 		ret.setUndefined();
 }
 
 template<> bool ScriptInterface::FromJSVal<CColor>(const ScriptRequest& rq,  JS::HandleValue v, CColor& out)
 {
 	if (!v.isObject())
 		FAIL("CColor has to be an object");
 
 	JS::RootedObject obj(rq.cx, &v.toObject());
 
 	JS::RootedValue r(rq.cx);
 	JS::RootedValue g(rq.cx);
 	JS::RootedValue b(rq.cx);
 	JS::RootedValue a(rq.cx);
 	if (!JS_GetProperty(rq.cx, obj, "r", &r) || !FromJSVal(rq, r, out.r))
 		FAIL("Failed to get property CColor.r");
 	if (!JS_GetProperty(rq.cx, obj, "g", &g) || !FromJSVal(rq, g, out.g))
 		FAIL("Failed to get property CColor.g");
 	if (!JS_GetProperty(rq.cx, obj, "b", &b) || !FromJSVal(rq, b, out.b))
 		FAIL("Failed to get property CColor.b");
 	if (!JS_GetProperty(rq.cx, obj, "a", &a) || !FromJSVal(rq, a, out.a))
 		FAIL("Failed to get property CColor.a");
 
 	return true;
 }
 
 template<> void ScriptInterface::ToJSVal<CColor>(const ScriptRequest& rq,  JS::MutableHandleValue ret, CColor const& val)
 {
 	CreateObject(
 		rq,
 		ret,
 		"r", val.r,
 		"g", val.g,
 		"b", val.b,
 		"a", val.a);
 }
 
 template<> bool ScriptInterface::FromJSVal<fixed>(const ScriptRequest& rq,  JS::HandleValue v, fixed& out)
 {
 	double ret;
 	if (!JS::ToNumber(rq.cx, v, &ret))
 		return false;
 	out = fixed::FromDouble(ret);
 	// double can precisely represent the full range of fixed, so this is a non-lossy conversion
 
 	return true;
 }
 
 template<> void ScriptInterface::ToJSVal<fixed>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const fixed& val)
 {
 	ret.set(JS::NumberValue(val.ToDouble()));
 }
 
 template<> bool ScriptInterface::FromJSVal<CFixedVector3D>(const ScriptRequest& rq,  JS::HandleValue v, CFixedVector3D& out)
 {
 	if (!v.isObject())
 		return false; // TODO: report type error
 
 	JS::RootedObject obj(rq.cx, &v.toObject());
 	JS::RootedValue p(rq.cx);
 
 	if (!JS_GetProperty(rq.cx, obj, "x", &p)) return false; // TODO: report type errors
 	if (!FromJSVal(rq, p, out.X)) return false;
 
 	if (!JS_GetProperty(rq.cx, obj, "y", &p)) return false;
 	if (!FromJSVal(rq, p, out.Y)) return false;
 
 	if (!JS_GetProperty(rq.cx, obj, "z", &p)) return false;
 	if (!FromJSVal(rq, p, out.Z)) return false;
 
 	return true;
 }
 
 template<> void ScriptInterface::ToJSVal<CFixedVector3D>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const CFixedVector3D& val)
 {
 	JS::RootedObject global(rq.cx, rq.glob);
 	JS::RootedValue valueVector3D(rq.cx);
 	if (!ScriptInterface::GetGlobalProperty(rq, "Vector3D", &valueVector3D))
 		FAIL_VOID("Failed to get Vector3D constructor");
 
 	JS::RootedValueArray<3> args(rq.cx);
 	args[0].setNumber(val.X.ToDouble());
 	args[1].setNumber(val.Y.ToDouble());
 	args[2].setNumber(val.Z.ToDouble());
 
 	JS::RootedObject objVec(rq.cx);
 	if (!JS::Construct(rq.cx, valueVector3D, args, &objVec))
 		FAIL_VOID("Failed to construct Vector3D object");
 
 	ret.setObject(*objVec);
 }
 
 template<> bool ScriptInterface::FromJSVal<CFixedVector2D>(const ScriptRequest& rq,  JS::HandleValue v, CFixedVector2D& out)
 {
 	if (!v.isObject())
 		return false; // TODO: report type error
 	JS::RootedObject obj(rq.cx, &v.toObject());
 
 	JS::RootedValue p(rq.cx);
 
 	if (!JS_GetProperty(rq.cx, obj, "x", &p)) return false; // TODO: report type errors
 	if (!FromJSVal(rq, p, out.X)) return false;
 
 	if (!JS_GetProperty(rq.cx, obj, "y", &p)) return false;
 	if (!FromJSVal(rq, p, out.Y)) return false;
 
 	return true;
 }
 
 template<> void ScriptInterface::ToJSVal<CFixedVector2D>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const CFixedVector2D& val)
 {
 	JS::RootedObject global(rq.cx, rq.glob);
 	JS::RootedValue valueVector2D(rq.cx);
 	if (!ScriptInterface::GetGlobalProperty(rq, "Vector2D", &valueVector2D))
 		FAIL_VOID("Failed to get Vector2D constructor");
 
 	JS::RootedValueArray<2> args(rq.cx);
 	args[0].setNumber(val.X.ToDouble());
 	args[1].setNumber(val.Y.ToDouble());
 
 	JS::RootedObject objVec(rq.cx);
 	if (!JS::Construct(rq.cx, valueVector2D, args, &objVec))
 		FAIL_VOID("Failed to construct Vector2D object");
 
 	ret.setObject(*objVec);
 }
 
 template<> void ScriptInterface::ToJSVal<Grid<u8> >(const ScriptRequest& rq,  JS::MutableHandleValue ret, const Grid<u8>& val)
 {
 	u32 length = (u32)(val.m_W * val.m_H);
 	u32 nbytes = (u32)(length * sizeof(u8));
 	JS::RootedObject objArr(rq.cx, JS_NewUint8Array(rq.cx, length));
 	// Copy the array data and then remove the no-GC check to allow further changes to the JS data
 	{
 		JS::AutoCheckCannotGC nogc;
 		bool sharedMemory;
 		memcpy((void*)JS_GetUint8ArrayData(objArr, &sharedMemory, nogc), val.m_Data, nbytes);
 	}
 
 	JS::RootedValue data(rq.cx, JS::ObjectValue(*objArr));
 	CreateObject(
 		rq,
 		ret,
 		"width", val.m_W,
 		"height", val.m_H,
 		"data", data);
 }
 
 template<> void ScriptInterface::ToJSVal<Grid<u16> >(const ScriptRequest& rq,  JS::MutableHandleValue ret, const Grid<u16>& val)
  {
 	u32 length = (u32)(val.m_W * val.m_H);
 	u32 nbytes = (u32)(length * sizeof(u16));
 	JS::RootedObject objArr(rq.cx, JS_NewUint16Array(rq.cx, length));
 	// Copy the array data and then remove the no-GC check to allow further changes to the JS data
 	{
 		JS::AutoCheckCannotGC nogc;
 		bool sharedMemory;
 		memcpy((void*)JS_GetUint16ArrayData(objArr, &sharedMemory, nogc), val.m_Data, nbytes);
 	}
 
 	JS::RootedValue data(rq.cx, JS::ObjectValue(*objArr));
 	CreateObject(
 		rq,
 		ret,
 		"width", val.m_W,
 		"height", val.m_H,
 		"data", data);
 }
 
 template<> bool ScriptInterface::FromJSVal<TNSpline>(const ScriptRequest& rq,  JS::HandleValue v, TNSpline& out)
 {
 	if (!v.isObject())
 		FAIL("Argument must be an object");
 
 	JS::RootedObject obj(rq.cx, &v.toObject());
 	bool isArray;
 	if (!JS::IsArrayObject(rq.cx, obj, &isArray) || !isArray)
 		FAIL("Argument must be an array");
 
 	u32 numberOfNodes = 0;
 	if (!JS::GetArrayLength(rq.cx, obj, &numberOfNodes))
 		FAIL("Failed to get array length");
 
 	for (u32 i = 0; i < numberOfNodes; ++i)
 	{
 		JS::RootedValue node(rq.cx);
 		if (!JS_GetElement(rq.cx, obj, i, &node))
 			FAIL("Failed to read array element");
 
 		fixed deltaTime;
 		if (!FromJSProperty(rq, node, "deltaTime", deltaTime))
 			FAIL("Failed to read Spline.deltaTime property");
 
 		CFixedVector3D position;
 		if (!FromJSProperty(rq, node, "position", position))
 			FAIL("Failed to read Spline.position property");
 
 		out.AddNode(position, CFixedVector3D(), deltaTime);
 	}
 
 	if (out.GetAllNodes().empty())
 		FAIL("Spline must contain at least one node");
 
 	return true;
 }
 
 template<> bool ScriptInterface::FromJSVal<CCinemaPath>(const ScriptRequest& rq,  JS::HandleValue v, CCinemaPath& out)
 {
 	if (!v.isObject())
 		FAIL("Argument must be an object");
 
 	JS::RootedObject obj(rq.cx, &v.toObject());
 
 	CCinemaData pathData;
 	TNSpline positionSpline, targetSpline;
 
 	if (!FromJSProperty(rq, v, "name", pathData.m_Name))
 		FAIL("Failed to get CCinemaPath.name property");
 
 	if (!FromJSProperty(rq, v, "orientation", pathData.m_Orientation))
 		FAIL("Failed to get CCinemaPath.orientation property");
 
 	if (!FromJSProperty(rq, v, "positionNodes", positionSpline))
 		FAIL("Failed to get CCinemaPath.positionNodes property");
 
 	if (pathData.m_Orientation == L"target" && !FromJSProperty(rq, v, "targetNodes", targetSpline))
 		FAIL("Failed to get CCinemaPath.targetNodes property");
 
 	// Other properties are not necessary to be defined
 	if (!FromJSProperty(rq, v, "timescale", pathData.m_Timescale))
 		pathData.m_Timescale = fixed::FromInt(1);
 
 	if (!FromJSProperty(rq, v, "mode", pathData.m_Mode))
 		pathData.m_Mode = L"ease_inout";
 
 	if (!FromJSProperty(rq, v, "style", pathData.m_Style))
 		pathData.m_Style = L"default";
 
 	out = CCinemaPath(pathData, positionSpline, targetSpline);
 
 	return true;
 }
 
 // define vectors
 JSVAL_VECTOR(CFixedVector2D)
 
 #undef FAIL
 #undef FAIL_VOID
Index: ps/trunk/source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp
===================================================================
--- ps/trunk/source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp	(revision 25164)
+++ ps/trunk/source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp	(revision 25165)
@@ -1,642 +1,641 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 2021 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 "MessageHandler.h"
 #include "../CommandProc.h"
 #include "../GameLoop.h"
 #include "../MessagePasser.h"
 
 #include "graphics/GameView.h"
 #include "graphics/LOSTexture.h"
 #include "graphics/MapIO.h"
 #include "graphics/MapWriter.h"
 #include "graphics/Patch.h"
 #include "graphics/Terrain.h"
 #include "graphics/TerrainTextureEntry.h"
 #include "graphics/TerrainTextureManager.h"
 #include "gui/ObjectTypes/CMiniMap.h"
 #include "lib/bits.h"
 #include "lib/file/vfs/vfs_path.h"
 #include "lib/status.h"
 #include "maths/MathUtil.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/Loader.h"
-#include "ps/Shapes.h"
 #include "ps/World.h"
 #include "renderer/Renderer.h"
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpOwnership.h"
 #include "simulation2/components/ICmpPlayer.h"
 #include "simulation2/components/ICmpPlayerManager.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/components/ICmpTerrain.h"
 #include "simulation2/components/ICmpVisual.h"
 #include "simulation2/system/ParamNode.h"
 
 
 #ifdef _MSC_VER
 # pragma warning(disable: 4458) // Declaration hides class member.
 #endif
 
 namespace
 {
 	void InitGame()
 	{
 		if (g_Game)
 		{
 			delete g_Game;
 			g_Game = NULL;
 		}
 
 		g_Game = new CGame(false);
 
 		// Default to player 1 for playtesting
 		g_Game->SetPlayerID(1);
 	}
 
 	void StartGame(JS::MutableHandleValue attrs)
 	{
 		g_Game->StartGame(attrs, "");
 
 		// TODO: Non progressive load can fail - need a decent way to handle this
 		LDR_NonprogressiveLoad();
 
 		// Disable fog-of-war - this must be done before starting the game,
 		// as visual actors cache their visibility state on first render.
 		CmpPtr<ICmpRangeManager> cmpRangeManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
 		if (cmpRangeManager)
 			cmpRangeManager->SetLosRevealAll(-1, true);
 
 		PSRETURN ret = g_Game->ReallyStartGame();
 		ENSURE(ret == PSRETURN_OK);
 	}
 }
 
 namespace AtlasMessage {
 
 QUERYHANDLER(GenerateMap)
 {
 	try
 	{
 		InitGame();
 
 		// Random map
 		const ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 		ScriptRequest rq(scriptInterface);
 
 		JS::RootedValue settings(rq.cx);
 		scriptInterface.ParseJSON(*msg->settings, &settings);
 		scriptInterface.SetProperty(settings, "mapType", "random");
 
 		JS::RootedValue attrs(rq.cx);
 		ScriptInterface::CreateObject(
 			rq,
 			&attrs,
 			"mapType", "random",
 			"script", *msg->filename,
 			"settings", settings);
 
 		StartGame(&attrs);
 
 		msg->status = 0;
 	}
 	catch (PSERROR_Game_World_MapLoadFailed&)
 	{
 		// Cancel loading
 		LDR_Cancel();
 
 		// Since map generation failed and we don't know why, use the blank map as a fallback
 
 		InitGame();
 
 		const ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 		ScriptRequest rq(scriptInterface);
 
 		// Set up 8-element array of empty objects to satisfy init
 		JS::RootedValue playerData(rq.cx);
 		ScriptInterface::CreateArray(rq, &playerData);
 
 		for (int i = 0; i < 8; ++i)
 		{
 			JS::RootedValue player(rq.cx);
 			ScriptInterface::CreateObject(rq, &player);
 			scriptInterface.SetPropertyInt(playerData, i, player);
 		}
 
 		JS::RootedValue settings(rq.cx);
 		ScriptInterface::CreateObject(
 			rq,
 			&settings,
 			"mapType", "scenario",
 			"PlayerData", playerData);
 
 		JS::RootedValue attrs(rq.cx);
 		ScriptInterface::CreateObject(
 			rq,
 			&attrs,
 			"mapType", "scenario",
 			"map", "maps/scenarios/_default",
 			"settings", settings);
 
 		StartGame(&attrs);
 
 		msg->status = -1;
 	}
 }
 
 MESSAGEHANDLER(LoadMap)
 {
 	InitGame();
 
 	const ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
 	ScriptRequest rq(scriptInterface);
 
 	// Scenario
 	CStrW map = *msg->filename;
 	CStrW mapBase = map.BeforeLast(L".pmp"); // strip the file extension, if any
 
 	JS::RootedValue attrs(rq.cx);
 
 	ScriptInterface::CreateObject(
 		rq,
 		&attrs,
 		"mapType", "scenario",
 		"map", mapBase);
 
 	StartGame(&attrs);
 }
 
 MESSAGEHANDLER(ImportHeightmap)
 {
 	std::vector<u16> heightmap_source;
 	if (LoadHeightmapImageOs(*msg->filename, heightmap_source) != INFO::OK)
 	{
 		LOGERROR("Failed to decode heightmap.");
 		return;
 	}
 
 	// resize terrain to heightmap size
 	// Notice that the number of tiles/pixels per side of the heightmap image is
 	// one less than the number of vertices per side of the heightmap.
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 	const ssize_t newSize = (sqrt(heightmap_source.size()) - 1) / PATCH_SIZE;
 	const ssize_t offset = (newSize - terrain->GetPatchesPerSide()) / 2;
 	terrain->ResizeAndOffset(newSize, offset, offset);
 
 	// copy heightmap data into map
 	u16* heightmap = g_Game->GetWorld()->GetTerrain()->GetHeightMap();
 	ENSURE(heightmap_source.size() == (std::size_t) SQR(g_Game->GetWorld()->GetTerrain()->GetVerticesPerSide()));
 	std::copy(heightmap_source.begin(), heightmap_source.end(), heightmap);
 
 	// update simulation
 	CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
 	if (cmpTerrain)
 		cmpTerrain->ReloadTerrain();
 
 	g_Game->GetView()->GetLOSTexture().MakeDirty();
 }
 
 MESSAGEHANDLER(SaveMap)
 {
 	CMapWriter writer;
 	VfsPath pathname = VfsPath(*msg->filename).ChangeExtension(L".pmp");
 	writer.SaveMap(pathname,
 		g_Game->GetWorld()->GetTerrain(),
 		g_Renderer.GetWaterManager(), g_Renderer.GetSkyManager(),
 		&g_LightEnv, g_Game->GetView()->GetCamera(), g_Game->GetView()->GetCinema(),
 		&g_Renderer.GetPostprocManager(),
 		g_Game->GetSimulation2());
 }
 
 QUERYHANDLER(GetMapSettings)
 {
 	msg->settings = g_Game->GetSimulation2()->GetMapSettingsString();
 }
 
 BEGIN_COMMAND(SetMapSettings)
 {
 	std::string m_OldSettings, m_NewSettings;
 
 	void SetSettings(const std::string& settings)
 	{
 		g_Game->GetSimulation2()->SetMapSettings(settings);
 	}
 
 	void Do()
 	{
 		m_OldSettings = g_Game->GetSimulation2()->GetMapSettingsString();
 		m_NewSettings = *msg->settings;
 
 		SetSettings(m_NewSettings);
 	}
 
 	// TODO: we need some way to notify the Atlas UI when the settings are changed
 	//	externally, otherwise this will have no visible effect
 	void Undo()
 	{
 		// SetSettings(m_OldSettings);
 	}
 
 	void Redo()
 	{
 		// SetSettings(m_NewSettings);
 	}
 
 	void MergeIntoPrevious(cSetMapSettings* prev)
 	{
 		prev->m_NewSettings = m_NewSettings;
 	}
 };
 END_COMMAND(SetMapSettings)
 
 MESSAGEHANDLER(LoadPlayerSettings)
 {
 	g_Game->GetSimulation2()->LoadPlayerSettings(msg->newplayers);
 }
 
 QUERYHANDLER(GetMapSizes)
 {
 	msg->sizes = g_Game->GetSimulation2()->GetMapSizes();
 }
 
 QUERYHANDLER(RasterizeMinimap)
 {
 	// TODO: remove the code duplication of the rasterization algorithm, using
 	// CMinimap version.
 	const CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 	const ssize_t dimension = terrain->GetVerticesPerSide() - 1;
 	const ssize_t bpp = 24;
 	const ssize_t imageDataSize = dimension * dimension * (bpp / 8);
 
 	std::vector<u8> imageBytes(imageDataSize);
 
 	float shallowPassageHeight = CMiniMap::GetShallowPassageHeight();
 
 	ssize_t w = dimension;
 	ssize_t h = dimension;
 	float waterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
 
 	for (ssize_t j = 0; j < h; ++j)
 	{
 		// Work backwards to vertically flip the image.
 		ssize_t position = 3 * (h - j - 1) * dimension;
 		for (ssize_t i = 0; i < w; ++i)
 		{
 			float avgHeight = (terrain->GetVertexGroundLevel(i, j)
 				+ terrain->GetVertexGroundLevel(i + 1, j)
 				+ terrain->GetVertexGroundLevel(i, j + 1)
 				+ terrain->GetVertexGroundLevel(i + 1, j + 1)
 				) / 4.0f;
 
 			if (avgHeight < waterHeight && avgHeight > waterHeight - shallowPassageHeight)
 			{
 				// shallow water
 				imageBytes[position++] = 0x70;
 				imageBytes[position++] = 0x98;
 				imageBytes[position++] = 0xc0;
 			}
 			else if (avgHeight < waterHeight)
 			{
 				// Set water as constant color for consistency on different maps
 				imageBytes[position++] = 0x50;
 				imageBytes[position++] = 0x78;
 				imageBytes[position++] = 0xa0;
 			}
 			else
 			{
 				u32 color = std::numeric_limits<u32>::max();
 				u32 hmap = static_cast<u32>(terrain->GetHeightMap()[j * dimension + i]) >> 8;
 				float scale = hmap / 3.0f + 170.0f / 255.0f;
 
 				CMiniPatch* mp = terrain->GetTile(i, j);
 				if (mp)
 				{
 					CTerrainTextureEntry* tex = mp->GetTextureEntry();
 					if (tex)
 						color = tex->GetBaseColor();
 				}
 
 				// Convert
 				imageBytes[position++] = static_cast<u8>(static_cast<float>(color & 0xff) * scale);
 				imageBytes[position++] = static_cast<u8>(static_cast<float>((color >> 8) & 0xff) * scale);
 				imageBytes[position++] = static_cast<u8>(static_cast<float>((color >> 16) & 0xff) * scale);
 			}
 		}
 	}
 
 	msg->imageBytes = std::move(imageBytes);
 	msg->dimension = dimension;
 }
 
 QUERYHANDLER(GetRMSData)
 {
 	msg->data = g_Game->GetSimulation2()->GetRMSData();
 }
 
 QUERYHANDLER(GetCurrentMapSize)
 {
 	msg->size = g_Game->GetWorld()->GetTerrain()->GetTilesPerSide();
 }
 
 BEGIN_COMMAND(ResizeMap)
 {
 	bool Within(const CFixedVector3D& pos, const int centerX, const int centerZ, const int radius)
 	{
 		int dx = abs(pos.X.ToInt_RoundToZero() - centerX);
 		if (dx > radius)
 			return false;
 		int dz = abs(pos.Z.ToInt_RoundToZero() - centerZ);
 		if (dz > radius)
 			return false;
 		if (dx + dz <= radius)
 			return true;
 		return dx * dx + dz * dz <= radius * radius;
 	}
 
 	struct DeletedObject
 	{
 		entity_id_t entityId;
 		CStr templateName;
 		player_id_t owner;
 		CFixedVector3D pos;
 		CFixedVector3D rot;
 		u32 actorSeed;
 	};
 
 	ssize_t m_OldPatches, m_NewPatches;
 	int m_OffsetX, m_OffsetY;
 
 	u16* m_Heightmap;
 	CPatch*	m_Patches;
 
 	std::vector<DeletedObject> m_DeletedObjects;
 	std::vector<std::pair<entity_id_t, CFixedVector3D>> m_OldPositions;
 	std::vector<std::pair<entity_id_t, CFixedVector3D>> m_NewPositions;
 
 	cResizeMap() : m_Heightmap(nullptr), m_Patches(nullptr)
 	{
 	}
 
 	~cResizeMap()
 	{
 		delete[] m_Heightmap;
 		delete[] m_Patches;
 	}
 
 	void MakeDirty()
 	{
 		CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
 		if (cmpTerrain)
 			cmpTerrain->ReloadTerrain();
 
 		// The LOS texture won't normally get updated when running Atlas
 		// (since there's no simulation updates), so explicitly dirty it
 		g_Game->GetView()->GetLOSTexture().MakeDirty();
 	}
 
 	void ResizeTerrain(ssize_t patches, int offsetX, int offsetY)
 	{
 		CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 		terrain->ResizeAndOffset(patches, -offsetX, -offsetY);
 	}
 
 	void DeleteObjects(const std::vector<DeletedObject>& deletedObjects)
 	{
 		for (const DeletedObject& deleted : deletedObjects)
 			g_Game->GetSimulation2()->DestroyEntity(deleted.entityId);
 
 		g_Game->GetSimulation2()->FlushDestroyedEntities();
 	}
 
 	void RestoreObjects(const std::vector<DeletedObject>& deletedObjects)
 	{
 		CSimulation2& sim = *g_Game->GetSimulation2();
 
 		for (const DeletedObject& deleted : deletedObjects)
 		{
 			entity_id_t ent = sim.AddEntity(deleted.templateName.FromUTF8(), deleted.entityId);
 			if (ent == INVALID_ENTITY)
 			{
 				LOGERROR("Failed to load entity template '%s'", deleted.templateName.c_str());
 			}
 			else
 			{
 				CmpPtr<ICmpPosition> cmpPosition(sim, deleted.entityId);
 				if (cmpPosition)
 				{
 					cmpPosition->JumpTo(deleted.pos.X, deleted.pos.Z);
 					cmpPosition->SetXZRotation(deleted.rot.X, deleted.rot.Z);
 					cmpPosition->SetYRotation(deleted.rot.Y);
 				}
 
 				CmpPtr<ICmpOwnership> cmpOwnership(sim, deleted.entityId);
 				if (cmpOwnership)
 					cmpOwnership->SetOwner(deleted.owner);
 
 				CmpPtr<ICmpVisual> cmpVisual(sim, deleted.entityId);
 				if (cmpVisual)
 					cmpVisual->SetActorSeed(deleted.actorSeed);
 			}
 		}
 	}
 
 	void SetMovedEntitiesPosition(const std::vector<std::pair<entity_id_t, CFixedVector3D>>& movedObjects)
 	{
 		for (const std::pair<entity_id_t, CFixedVector3D>& obj : movedObjects)
 		{
 			const entity_id_t id = obj.first;
 			const CFixedVector3D position = obj.second;
 			CmpPtr<ICmpPosition> cmpPosition(*g_Game->GetSimulation2(), id);
 			ENSURE(cmpPosition);
 			cmpPosition->JumpTo(position.X, position.Z);
 		}
 	}
 
 	void Do()
 	{
 		CSimulation2& sim = *g_Game->GetSimulation2();
 		CmpPtr<ICmpTemplateManager> cmpTemplateManager(sim, SYSTEM_ENTITY);
 		ENSURE(cmpTemplateManager);
 
 		CmpPtr<ICmpTerrain> cmpTerrain(sim, SYSTEM_ENTITY);
 		if (!cmpTerrain)
 		{
 			m_OldPatches = m_NewPatches = 0;
 			m_OffsetX = m_OffsetY = 0;
 		}
 		else
 		{
 			m_OldPatches = static_cast<ssize_t>(cmpTerrain->GetTilesPerSide() / PATCH_SIZE);
 			m_NewPatches = msg->tiles / PATCH_SIZE;
 			m_OffsetX = msg->offsetX / PATCH_SIZE;
 			// Need to flip direction of vertical offset, due to screen mapping order.
 			m_OffsetY = -(msg->offsetY / PATCH_SIZE);
 
 			CTerrain* terrain = cmpTerrain->GetCTerrain();
 			m_Heightmap = new u16[(m_OldPatches * PATCH_SIZE + 1) * (m_OldPatches * PATCH_SIZE + 1)];
 			std::copy_n(terrain->GetHeightMap(), (m_OldPatches * PATCH_SIZE + 1) * (m_OldPatches * PATCH_SIZE + 1), m_Heightmap);
 			m_Patches = new CPatch[m_OldPatches * m_OldPatches];
 			for (ssize_t j = 0; j < m_OldPatches; ++j)
 				for (ssize_t i = 0; i < m_OldPatches; ++i)
 				{
 					CPatch& src = *(terrain->GetPatch(i, j));
 					CPatch& dst = m_Patches[j * m_OldPatches + i];
 					std::copy_n(&src.m_MiniPatches[0][0], PATCH_SIZE * PATCH_SIZE, &dst.m_MiniPatches[0][0]);
 				}
 		}
 
 		const int radiusInTerrainUnits = m_NewPatches * PATCH_SIZE * TERRAIN_TILE_SIZE / 2 * (1.f - 1e-6f);
 		// Opposite direction offset, as we move the destination onto the source, not the source into the destination.
 		const int mapCenterX = (m_OldPatches / 2 - m_OffsetX) * PATCH_SIZE * TERRAIN_TILE_SIZE;
 		const int mapCenterZ = (m_OldPatches / 2 - m_OffsetY) * PATCH_SIZE * TERRAIN_TILE_SIZE;
 		// The offset to move units by is opposite the direction the map is moved, and from the corner.
 		const int offsetX = ((m_NewPatches - m_OldPatches) / 2 + m_OffsetX) * PATCH_SIZE * TERRAIN_TILE_SIZE;
 		const int offsetZ = ((m_NewPatches - m_OldPatches) / 2 + m_OffsetY) * PATCH_SIZE * TERRAIN_TILE_SIZE;
 		const CFixedVector3D offset = CFixedVector3D(fixed::FromInt(offsetX), fixed::FromInt(0), fixed::FromInt(offsetZ));
 
 		const CSimulation2::InterfaceListUnordered& ents = sim.GetEntitiesWithInterfaceUnordered(IID_Selectable);
 		for (const std::pair<const entity_id_t, IComponent*>& ent : ents)
 		{
 			const entity_id_t entityId = ent.first;
 			CmpPtr<ICmpPosition> cmpPosition(sim, entityId);
 
 			if (cmpPosition && cmpPosition->IsInWorld() && Within(cmpPosition->GetPosition(), mapCenterX, mapCenterZ, radiusInTerrainUnits))
 			{
 				CFixedVector3D position = cmpPosition->GetPosition();
 
 				m_NewPositions.emplace_back(entityId, position + offset);
 				m_OldPositions.emplace_back(entityId, position);
 			}
 			else
 			{
 				DeletedObject deleted;
 				deleted.entityId = entityId;
 				deleted.templateName = cmpTemplateManager->GetCurrentTemplateName(entityId);
 
 				// If the entity has a position, but the ending position is not valid;
 				if (cmpPosition)
 				{
 					deleted.pos = cmpPosition->GetPosition();
 					deleted.rot = cmpPosition->GetRotation();
 				}
 
 				CmpPtr<ICmpOwnership> cmpOwnership(sim, entityId);
 				if (cmpOwnership)
 					deleted.owner = cmpOwnership->GetOwner();
 
 				CmpPtr<ICmpVisual> cmpVisual(sim, deleted.entityId);
 				if (cmpVisual)
 					deleted.actorSeed = cmpVisual->GetActorSeed();
 
 				m_DeletedObjects.push_back(deleted);
 			}
 		}
 
 		DeleteObjects(m_DeletedObjects);
 		ResizeTerrain(m_NewPatches, m_OffsetX, m_OffsetY);
 		SetMovedEntitiesPosition(m_NewPositions);
 		MakeDirty();
 	}
 
 	void Undo()
 	{
 		if (m_Heightmap == nullptr || m_Patches == nullptr)
 		{
 			// If there previously was no data, just resize to old (probably not originally valid).
 			ResizeTerrain(m_OldPatches, -m_OffsetX, -m_OffsetY);
 		}
 		else
 		{
 			CSimulation2& sim = *g_Game->GetSimulation2();
 			CmpPtr<ICmpTerrain> cmpTerrain(sim, SYSTEM_ENTITY);
 			CTerrain* terrain = cmpTerrain->GetCTerrain();
 
 			terrain->Initialize(m_OldPatches, m_Heightmap);
 			// Copy terrain data back.
 			for (ssize_t j = 0; j < m_OldPatches; ++j)
 				for (ssize_t i = 0; i < m_OldPatches; ++i)
 				{
 					CPatch& src = m_Patches[j * m_OldPatches + i];
 					CPatch& dst = *(terrain->GetPatch(i, j));
 					std::copy_n(&src.m_MiniPatches[0][0], PATCH_SIZE * PATCH_SIZE, &dst.m_MiniPatches[0][0]);
 				}
 		}
 		RestoreObjects(m_DeletedObjects);
 		SetMovedEntitiesPosition(m_OldPositions);
 		MakeDirty();
 	}
 
 	void Redo()
 	{
 		DeleteObjects(m_DeletedObjects);
 		ResizeTerrain(m_NewPatches, m_OffsetX, m_OffsetY);
 		SetMovedEntitiesPosition(m_NewPositions);
 		MakeDirty();
 	}
 };
 END_COMMAND(ResizeMap)
 
 QUERYHANDLER(VFSFileExists)
 {
 	msg->exists = VfsFileExists(*msg->path);
 }
 
 QUERYHANDLER(VFSFileRealPath)
 {
 	VfsPath pathname(*msg->path);
 	if (pathname.empty())
 		return;
 	OsPath realPathname;
 	if (g_VFS->GetRealPath(pathname, realPathname) == INFO::OK)
 		msg->realPath = realPathname.string();
 }
 
 static Status AddToFilenames(const VfsPath& pathname, const CFileInfo& UNUSED(fileInfo), const uintptr_t cbData)
 {
 	std::vector<std::wstring>& filenames = *(std::vector<std::wstring>*)cbData;
 	filenames.push_back(pathname.string().c_str());
 	return INFO::OK;
 }
 
 QUERYHANDLER(GetMapList)
 {
 #define GET_FILE_LIST(path, list) \
 	std::vector<std::wstring> list; \
 	vfs::ForEachFile(g_VFS, path, AddToFilenames, (uintptr_t)&list, L"*.xml", vfs::DIR_RECURSIVE); \
 	msg->list = list;
 
 	GET_FILE_LIST(L"maps/scenarios/", scenarioFilenames);
 	GET_FILE_LIST(L"maps/skirmishes/", skirmishFilenames);
 	GET_FILE_LIST(L"maps/tutorials/", tutorialFilenames);
 #undef GET_FILE_LIST
 }
 
 QUERYHANDLER(GetVictoryConditionData)
 {
 	msg->data = g_Game->GetSimulation2()->GetVictoryConditiondData();
 }
 
 }