SWORD25: Converted the math folder files

svn-id: r53197

17 files changed, 1018 insertions, 1432 deletions

diff --git a/engines/sword25/kernel/inputpersistenceblock.cpp b/engines/sword25/kernel/inputpersistenceblock.cpp
index 377b0bd994..6528d041ad 100644
--- a/engines/sword25/kernel/inputpersistenceblock.cpp
+++ b/engines/sword25/kernel/inputpersistenceblock.cpp
@@ -40,23 +40,21 @@
 
 #include "sword25/kernel/inputpersistenceblock.h"
 
-using namespace std;
+namespace Sword25 {
 
 // -----------------------------------------------------------------------------
-// Construction / Destruction
+// Constructor / Destructor
 // -----------------------------------------------------------------------------
 
 BS_InputPersistenceBlock::BS_InputPersistenceBlock(const void * Data, unsigned int DataLength) :
-	m_Data(static_cast<const unsigned char *>(Data), static_cast<const unsigned char *>(Data) + DataLength),
-	m_ErrorState(NONE)
-{
+		m_Data(static_cast<const unsigned char *>(Data), DataLength),
+		m_ErrorState(NONE) {
 	m_Iter = m_Data.begin();
 }
 
 // -----------------------------------------------------------------------------
 
-BS_InputPersistenceBlock::~BS_InputPersistenceBlock()
-{
+BS_InputPersistenceBlock::~BS_InputPersistenceBlock() {
 	if (m_Iter != m_Data.end()) BS_LOG_WARNINGLN("Persistence block was not read to the end.");
 }
 
@@ -64,80 +62,69 @@ BS_InputPersistenceBlock::~BS_InputPersistenceBlock()
 // Reading
 // -----------------------------------------------------------------------------
 
-void BS_InputPersistenceBlock::Read(signed int & Value)
-{
-	if (CheckMarker(SINT_MARKER))
-	{
+void BS_InputPersistenceBlock::Read(int16 &Value) {
+	signed int v;
+	Read(v);
+	Value = static_cast<int16>(v);
+}
+
+// -----------------------------------------------------------------------------
+
+void BS_InputPersistenceBlock::Read(signed int &Value) {
+	if (CheckMarker(SINT_MARKER)) {
 		RawRead(&Value, sizeof(signed int));
 		Value = ConvertEndianessFromStorageToSystem(Value);
-	}
-	else
-	{
+	} else {
 		Value = 0;
 	}
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_InputPersistenceBlock::Read(unsigned int & Value)
-{
-	if (CheckMarker(UINT_MARKER))
-	{
+void BS_InputPersistenceBlock::Read(unsigned int &Value) {
+	if (CheckMarker(UINT_MARKER)) {
 		RawRead(&Value, sizeof(unsigned int));
 		Value = ConvertEndianessFromStorageToSystem(Value);
-	}
-	else
-	{
+	} else {
 		Value = 0;
 	}
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_InputPersistenceBlock::Read(float & Value)
-{
-	if (CheckMarker(FLOAT_MARKER))
-	{
+void BS_InputPersistenceBlock::Read(float &Value) {
+	if (CheckMarker(FLOAT_MARKER)) {
 		RawRead(&Value, sizeof(float));
 		Value = ConvertEndianessFromStorageToSystem(Value);
-	}
-	else
-	{
+	} else {
 		Value = 0.0f;
 	}
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_InputPersistenceBlock::Read(bool & Value)
-{
-	if (CheckMarker(BOOL_MARKER))
-	{
+void BS_InputPersistenceBlock::Read(bool &Value) {
+	if (CheckMarker(BOOL_MARKER)) {
 		unsigned int UIntBool;
 		RawRead(&UIntBool, sizeof(float));
 		UIntBool = ConvertEndianessFromStorageToSystem(UIntBool);
 		Value = UIntBool == 0 ? false : true;
-	}
-	else
-	{
+	} else {
 		Value = 0.0f;
 	}
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_InputPersistenceBlock::Read(std::string & Value)
-{
+void BS_InputPersistenceBlock::Read(Common::String &Value) {
 	Value = "";
 	
-	if (CheckMarker(STRING_MARKER))
-	{
+	if (CheckMarker(STRING_MARKER)) {
 		unsigned int Size;
 		Read(Size);
 
-		if (CheckBlockSize(Size))
-		{
-			Value = std::string(reinterpret_cast<const char *>(&*m_Iter), Size);
+		if (CheckBlockSize(Size)) {
+			Value = Common::String(reinterpret_cast<const char *>(&*m_Iter), Size);
 			m_Iter += Size;
 		}
 	}
@@ -145,16 +132,13 @@ void BS_InputPersistenceBlock::Read(std::string & Value)
 
 // -----------------------------------------------------------------------------
 
-void BS_InputPersistenceBlock::Read(vector<unsigned char> & Value)
-{
-	if (CheckMarker(BLOCK_MARKER))
-	{
+void BS_InputPersistenceBlock::Read(Common::Array<unsigned char> &Value) {
+	if (CheckMarker(BLOCK_MARKER)) {
 		unsigned int Size;
 		Read(Size);
 
-		if (CheckBlockSize(Size))
-		{
-			Value = vector<unsigned char>(m_Iter, m_Iter + Size);
+		if (CheckBlockSize(Size)) {
+			Value = Common::Array<unsigned char>(m_Iter, Size);
 			m_Iter += Size;
 		}
 	}
@@ -162,10 +146,8 @@ void BS_InputPersistenceBlock::Read(vector<unsigned char> & Value)
 
 // -----------------------------------------------------------------------------
 
-void BS_InputPersistenceBlock::RawRead(void * DestPtr, size_t Size)
-{
-	if (CheckBlockSize(Size))
-	{
+void BS_InputPersistenceBlock::RawRead(void * DestPtr, size_t Size) {
+	if (CheckBlockSize(Size)) {
 		memcpy(DestPtr, &*m_Iter, Size);
 		m_Iter += Size;
 	}
@@ -173,14 +155,10 @@ void BS_InputPersistenceBlock::RawRead(void * DestPtr, size_t Size)
 
 // -----------------------------------------------------------------------------
 
-bool BS_InputPersistenceBlock::CheckBlockSize(int Size)
-{
-	if (m_Data.end() - m_Iter >= Size)
-	{
+bool BS_InputPersistenceBlock::CheckBlockSize(int Size) {
+	if (m_Data.end() - m_Iter >= Size) {
 		return true;
-	}
-	else
-	{
+	} else {
 		m_ErrorState = END_OF_DATA;
 		BS_LOG_ERRORLN("Unexpected end of persistence block.");
 		return false;
@@ -189,18 +167,16 @@ bool BS_InputPersistenceBlock::CheckBlockSize(int Size)
 
 // -----------------------------------------------------------------------------
 
-bool BS_InputPersistenceBlock::CheckMarker(unsigned char Marker)
-{
+bool BS_InputPersistenceBlock::CheckMarker(unsigned char Marker) {
 	if (!IsGood() || !CheckBlockSize(1)) return false;
 
-	if (*m_Iter++ == Marker)
-	{
+	if (*m_Iter++ == Marker) {
 		return true;
-	}
-	else
-	{
+	} else {
 		m_ErrorState = OUT_OF_SYNC;
 		BS_LOG_ERRORLN("Wrong type marker found in persistence block.");
 		return false;
 	}
 }
+
+} // End of namespace Sword25
diff --git a/engines/sword25/kernel/inputpersistenceblock.h b/engines/sword25/kernel/inputpersistenceblock.h
index 6e1ec39943..b30429771b 100644
--- a/engines/sword25/kernel/inputpersistenceblock.h
+++ b/engines/sword25/kernel/inputpersistenceblock.h
@@ -62,12 +62,13 @@ public:
 	BS_InputPersistenceBlock(const void *Data, unsigned int DataLength);
 	virtual ~BS_InputPersistenceBlock();
 
+	void Read(int16 &Value);
 	void Read(signed int &Value);
 	void Read(unsigned int &Value);
 	void Read(float &Value);
 	void Read(bool &Value);
-	void Read(std::string &Value);
-	void Read(std::vector<unsigned char> &Value);
+	void Read(Common::String &Value);
+	void Read(Common::Array<unsigned char> &Value);
 
 	bool IsGood() const { return m_ErrorState == NONE; }
 	ErrorState GetErrorState() const { return m_ErrorState; }
diff --git a/engines/sword25/kernel/kernel.h b/engines/sword25/kernel/kernel.h
index 692a4a215d..d09cf68ab6 100644
--- a/engines/sword25/kernel/kernel.h
+++ b/engines/sword25/kernel/kernel.h
@@ -339,6 +339,18 @@ public:
 	BS_Service* (*CreateMethod)(BS_Kernel *);
 };
 
+template<class T>
+void ReverseArray(Common::Array<T> Arr) {
+	if (Arr.size() < 2)
+		return;
+
+	for (uint i = 0; i < (Arr.size() / 2 - 1); ++i) {
+		T temp = Arr[i];
+		Arr[i] = Arr[Arr.size() - i - 1];
+		Arr[Arr.size() - i - 1] = temp;
+	}
 }
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/math/geometry_script.cpp b/engines/sword25/math/geometry_script.cpp
index 96606a7206..e656e5f548 100644
--- a/engines/sword25/math/geometry_script.cpp
+++ b/engines/sword25/math/geometry_script.cpp
@@ -36,11 +36,7 @@
 // Includes
 // -----------------------------------------------------------------------------
 
-#include "sword25/kernel/memlog_off.h"
-#include <memory>
-#include <vector>
-#include "sword25/kernel/memlog_on.h"
-
+#include "common/array.h"
 #include "sword25/gfx/graphicengine.h"
 #include "sword25/kernel/common.h"
 #include "sword25/kernel/kernel.h"
@@ -55,21 +51,20 @@
 
 // -----------------------------------------------------------------------------
 
-using namespace std;
+namespace Sword25 {
 
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
 
-// Die Strings werden als #defines definiert um Stringkomposition zur Compilezeit zu ermöglichen.
+// These strings are defined as #defines to enable compile-time string composition
 #define REGION_CLASS_NAME "Geo.Region"
 #define WALKREGION_CLASS_NAME "Geo.WalkRegion"
 
 // -----------------------------------------------------------------------------
 
-// Wie luaL_checkudata, nur ohne dass kein Fehler erzeugt wird.
-static void * my_checkudata (lua_State *L, int ud, const char *tname)
-{
+// How luaL_checkudata, only without that no error is generated.
+static void *my_checkudata(::lua_State *L, int ud, const char *tname) {
 	int top = lua_gettop(L);
 
 	void * p = lua_touserdata(L, ud);
@@ -79,8 +74,8 @@ static void * my_checkudata (lua_State *L, int ud, const char *tname)
 		{  
 			// lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
 			BS_LuaBindhelper::GetMetatable(L, tname);
-			if (lua_rawequal(L, -1, -2)) /* does it have the correct mt? */
-			{
+			/* does it have the correct mt? */
+			if (lua_rawequal(L, -1, -2)) {
 				lua_settop(L, top);
 				return p;
 			}
@@ -93,50 +88,43 @@ static void * my_checkudata (lua_State *L, int ud, const char *tname)
 
 // -----------------------------------------------------------------------------
 
-static void NewUintUserData(lua_State * L, unsigned int Value)
-{
+static void NewUintUserData(::lua_State *L, unsigned int Value) {
 	void * UserData = lua_newuserdata(L, sizeof(Value));
 	memcpy(UserData, &Value, sizeof(Value));
 }
 
 // -----------------------------------------------------------------------------
 
-static bool IsValidPolygonDefinition(lua_State * L)
-{
+static bool IsValidPolygonDefinition(::lua_State *L) {
 #ifdef DEBUG
 	int __startStackDepth = lua_gettop(L);
 #endif
 
-	// Sicherstellen, dass wir wirklich eine Tabelle betrachten
-	if (!lua_istable(L, -1))
-	{
+	// Ensure that we actually consider a table
+	if (!lua_istable(L, -1)) {
 		luaL_error(L, "Invalid polygon definition. Unexpected type, \"table\" needed.");
 		return false;
 	}
 
 	int TableSize = luaL_getn(L, -1);
 
-	// Sicherstellen, dass mindestens 3 Vertecies existieren.
-	if (TableSize < 6)
-	{
+	// Make sure that there are at least three Vertecies
+	if (TableSize < 6) {
 		luaL_error(L, "Invalid polygon definition. At least three vertecies needed.");
 		return false;
 	}
 
-	// Sicherstellen, dass die Anzahl der Tabellenelemente durch zwei teilbar ist.
-	// Da je zwei Elemente ein Vertex definieren, ist eine ungerade Anzahl an Elementen nicht zulässig.
-	if ((TableSize % 2) != 0)
-	{
+	// Make sure that the number of table elements is divisible by two.
+	// Since any two elements is a vertex, an odd number of elements is not allowed
+	if ((TableSize % 2) != 0) {
 		luaL_error(L, "Invalid polygon definition. Even number of table elements needed.");
 		return false;
 	}
 
-	// Sicherstellen, dass alle Elemente der Tabelle vom Typ Number sind.
-	for (int i = 1; i <= TableSize; i += 1)
-	{
+	// Ensure that all elements in the table are of type Number
+	for (int i = 1; i <= TableSize; i += 1) {
 		lua_rawgeti(L, -1, i);
-		if (!lua_isnumber(L, -1))
-		{
+		if (!lua_isnumber(L, -1)) {
 			luaL_error(L, "Invalid polygon definition. All table elements have to be numbers.");
 			return false;
 		}
@@ -152,32 +140,31 @@ static bool IsValidPolygonDefinition(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static void TablePolygonToPolygon(lua_State * L, BS_Polygon & Polygon)
-{
+static void TablePolygonToPolygon(::lua_State *L, BS_Polygon &Polygon) {
 #ifdef DEBUG
 	int __startStackDepth = lua_gettop(L);
 #endif
 
-	// Sicherstellen, dass eine gültige Polygon-Definition auf dem Stack liegt.
-	// Es ist nicht notwendig den Rückgabewert abzufangen, da alle Fehler über luaL_error ausgegeben werden und somit die Ausführung des
-	// Skriptes beenden.
+	// Ensure that a valid polygon definition is on the stack.
+	// It is not necessary to catch the return value, since all errors are reported on luaL_error
+	// End script.
 	IsValidPolygonDefinition(L);
 
 	int VertexCount = luaL_getn(L, -1) / 2;
 
-	// Speicher für Vertecies reservieren
-	vector<BS_Vertex> Vertecies;
+	// Memory is reserved for Vertecies
+	Common::Array<BS_Vertex> Vertecies;
 	Vertecies.reserve(VertexCount);
 
-	// Vertecies erstellen
+	// Create Vertecies
 	for (int i = 0; i < VertexCount; i++)
 	{
-		// X-Wert
+		// X Value
 		lua_rawgeti(L, -1, (i * 2) + 1);
 		int X = static_cast<int>(lua_tonumber(L, -1));
 		lua_pop(L, 1);
 
-		// Y-Wert
+		// Y Value
 		lua_rawgeti(L, -1, (i * 2) + 2);
 		int Y = static_cast<int>(lua_tonumber(L, -1));
 		lua_pop(L, 1);
@@ -185,72 +172,63 @@ static void TablePolygonToPolygon(lua_State * L, BS_Polygon & Polygon)
 		// Vertex
 		Vertecies.push_back(BS_Vertex(X, Y));
 	}
-	BS_ASSERT(Vertecies.size() == VertexCount);
+	BS_ASSERT((int)Vertecies.size() == VertexCount);
 
 #ifdef DEBUG
 	BS_ASSERT(__startStackDepth == lua_gettop(L));
 #endif
 
-	// Polygon erstellen
+	// Create polygon
 	Polygon.Init(VertexCount, &Vertecies[0]);
 }
 
 // -----------------------------------------------------------------------------
 
-static unsigned int TableRegionToRegion(lua_State * L, const char * ClassName)
-{
+static unsigned int TableRegionToRegion(::lua_State *L, const char *ClassName) {
 #ifdef DEBUG
 	int __startStackDepth = lua_gettop(L);
 #endif
 
-	// Man kann eine Region in Lua auf zwei Arten definieren:
-	// 1. Eine Tabelle, die ein Polygon definiert (Polygon = Tabelle mit Zahlen, wobei je zwei aufeinander folgende Zahlen ein Vertex definieren)
-	//    Das eine Polygon definiert die Region vollständig (=> keine Löcher möglich)
-	// 2. Eine Tabelle, die mehrere Polygondefinitionen (wiederum Tabellen (siehe 1.)) enthält.
-	//    Dann definiert das erste Polygon den Umriss der Region und die folgenden Löcher im ersten Polygon.
+	// You can define a region in Lua in two ways:
+	// 1. A table that defines a polygon (polgon = table with numbers, which define
+	// two consecutive numbers per vertex)
+	// 2. A table containing more polygon definitions
+	// Then the first polygon is the contour of the region, and the following are holes
+	// defined in the first polygon.
 
-	// Es darf nur ein Parameter übergeben werden und dieser muss eine Tabelle sein.
-	if (lua_gettop(L) != 1 || !lua_istable(L, -1))
-	{
+	// It may be passed only one parameter, and this must be a table
+	if (lua_gettop(L) != 1 || !lua_istable(L, -1)) {
 		luaL_error(L, "First and only parameter has to be of type \"table\".");
 		return 0;
 	}
 
 	unsigned int RegionHandle;
-	if (ClassName == REGION_CLASS_NAME)
-	{
+	if (ClassName == REGION_CLASS_NAME) {
 		RegionHandle = BS_Region::Create(BS_Region::RT_REGION);
-	}
-	else if (ClassName == WALKREGION_CLASS_NAME)
-	{
+	} else if (ClassName == WALKREGION_CLASS_NAME) {
 		RegionHandle = BS_WalkRegion::Create(BS_Region::RT_WALKREGION);
-	}
-	else
-	{
+	} else {
 		BS_ASSERT(false);
 	}
 
 	BS_ASSERT(RegionHandle);
 
-	// Wenn das erste Element des Parameters eine Zahl ist, wird der 1. Fall angenommen.
-	// Wenn das erste Element des Parameters eine Tabelle ist, wird der 2. Fall angenommen.
-	// Wenn das erste Element des Parameters einen anderen Typ hat, liegt ein Fehler vor.
+	// If the first element of the parameter is a number, then case 1 is accepted
+	// If the first element of the parameter is a table, then case 2 is accepted
+	// If the first element of the parameter has a different type, there is an error
 	lua_rawgeti(L, -1, 1);
 	int FirstElementType = lua_type(L, -1);
 	lua_pop(L, 1);
 
-	switch(FirstElementType)
-	{
-		case LUA_TNUMBER:
-			{
+	switch(FirstElementType) {
+		case LUA_TNUMBER: {
 				BS_Polygon Polygon;
 				TablePolygonToPolygon(L, Polygon);
 				BS_RegionRegistry::GetInstance().ResolveHandle(RegionHandle)->Init(Polygon);
 			}
 			break;
 		
-		case LUA_TTABLE:
-			{
+		case LUA_TTABLE: {
 				lua_rawgeti(L, -1, 1);
 				BS_Polygon Polygon;
 				TablePolygonToPolygon(L, Polygon);
@@ -259,19 +237,17 @@ static unsigned int TableRegionToRegion(lua_State * L, const char * ClassName)
 				int PolygonCount = luaL_getn(L, -1);
 				if (PolygonCount == 1)
 					BS_RegionRegistry::GetInstance().ResolveHandle(RegionHandle)->Init(Polygon);
-				else
-				{
-					vector<BS_Polygon> Holes;
+				else {
+					Common::Array<BS_Polygon> Holes;
 					Holes.reserve(PolygonCount - 1);
 
-					for (int i = 2; i <= PolygonCount; i++)
-					{
+					for (int i = 2; i <= PolygonCount; i++) {
 						lua_rawgeti(L, -1, i);
 						Holes.resize(Holes.size() + 1);
 						TablePolygonToPolygon(L, Holes.back());
 						lua_pop(L, 1);
 					}
-					BS_ASSERT(Holes.size() == PolygonCount - 1);
+					BS_ASSERT((int)Holes.size() == PolygonCount - 1);
 
 					BS_RegionRegistry::GetInstance().ResolveHandle(RegionHandle)->Init(Polygon, &Holes);
 				}
@@ -292,10 +268,10 @@ static unsigned int TableRegionToRegion(lua_State * L, const char * ClassName)
 
 // -----------------------------------------------------------------------------
 
-static void NewUserdataRegion(lua_State * L, const char * ClassName)
+static void NewUserdataRegion(::lua_State *L, const char *ClassName)
 {
-	// Region aufgrund des Lua-Codes erstellen.
-	// Fehler treten nicht auf, sondern werden von der Funktion über luaL_error abgefangen.
+	// Region due to the Lua code to create
+	// Any errors that occur will be intercepted to the luaL_error
 	unsigned int RegionHandle = TableRegionToRegion(L, ClassName);
 	BS_ASSERT(RegionHandle);
 
@@ -308,26 +284,23 @@ static void NewUserdataRegion(lua_State * L, const char * ClassName)
 
 // -----------------------------------------------------------------------------
 
-static int NewRegion(lua_State * L)
-{
+static int NewRegion(::lua_State *L) {
 	NewUserdataRegion(L, REGION_CLASS_NAME);
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static int NewWalkRegion(lua_State * L)
-{
+static int NewWalkRegion(::lua_State *L) {
 	NewUserdataRegion(L, WALKREGION_CLASS_NAME);
 	return 1;
 }
 
 // -----------------------------------------------------------------------------
 
-static const char * GEO_LIBRARY_NAME = "Geo";
+static const char *GEO_LIBRARY_NAME = "Geo";
 
-static const luaL_reg GEO_FUNCTIONS[] =
-{
+static const luaL_reg GEO_FUNCTIONS[] = {
 	"NewRegion", NewRegion,
 	"NewWalkRegion", NewWalkRegion,
 	0, 0,
@@ -335,28 +308,23 @@ static const luaL_reg GEO_FUNCTIONS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_Region * CheckRegion(lua_State * L)
-{
-	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Geo.Region oder Geo.WalkRegion
-	unsigned int * RegionHandlePtr;
+static BS_Region * CheckRegion(::lua_State *L) {
+	// The first parameter must be of type 'userdata', and the Metatable class Geo.Region or Geo.WalkRegion
+	unsigned int *RegionHandlePtr;
 	if ((RegionHandlePtr = reinterpret_cast<unsigned int *>(my_checkudata(L, 1, REGION_CLASS_NAME))) != 0 ||
-		(RegionHandlePtr = reinterpret_cast<unsigned int *>(my_checkudata(L, 1, WALKREGION_CLASS_NAME))) != 0)
-	{
+		(RegionHandlePtr = reinterpret_cast<unsigned int *>(my_checkudata(L, 1, WALKREGION_CLASS_NAME))) != 0) {
 		return BS_RegionRegistry::GetInstance().ResolveHandle(*RegionHandlePtr);
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 1, "'" REGION_CLASS_NAME "' expected");
 	}
 
-	// Compiler ruhigstellen. Ausführung kommt nie an diesem Punkt an.
+	// Compilation fix. Execution never reaches this point
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static int R_IsValid(lua_State * L)
-{
+static int R_IsValid(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -366,8 +334,7 @@ static int R_IsValid(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_GetX(lua_State * L)
-{
+static int R_GetX(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -377,8 +344,7 @@ static int R_GetX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_GetY(lua_State * L)
-{
+static int R_GetY(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -388,8 +354,7 @@ static int R_GetY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_GetPos(lua_State * L)
-{
+static int R_GetPos(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -399,8 +364,7 @@ static int R_GetPos(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_IsPointInRegion(lua_State * L)
-{
+static int R_IsPointInRegion(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -412,8 +376,7 @@ static int R_IsPointInRegion(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_SetPos(lua_State * L)
-{
+static int R_SetPos(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -426,8 +389,7 @@ static int R_SetPos(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_SetX(lua_State * L)
-{
+static int R_SetX(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -438,8 +400,7 @@ static int R_SetX(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_SetY(lua_State * L)
-{
+static int R_SetY(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
@@ -450,9 +411,8 @@ static int R_SetY(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static void DrawPolygon(const BS_Polygon & Polygon, unsigned int Color, const BS_Vertex & Offset)
-{
-	BS_GraphicEngine * pGE = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
+static void DrawPolygon(const BS_Polygon &Polygon, unsigned int Color, const BS_Vertex &Offset) {
+	BS_GraphicEngine *pGE = static_cast<BS_GraphicEngine *>(BS_Kernel::GetInstance()->GetService("gfx"));
 	BS_ASSERT(pGE);
 
 	for (int i = 0; i < Polygon.VertexCount - 1; i++)
@@ -463,8 +423,7 @@ static void DrawPolygon(const BS_Polygon & Polygon, unsigned int Color, const BS
 
 // -----------------------------------------------------------------------------
 
-static void DrawRegion(const BS_Region & Region, unsigned int Color, const BS_Vertex & Offset)
-{
+static void DrawRegion(const BS_Region &Region, unsigned int Color, const BS_Vertex &Offset) {
 	DrawPolygon(Region.GetContour(), Color, Offset);
 	for (int i = 0; i < Region.GetHoleCount(); i++)
 		DrawPolygon(Region.GetHole(i), Color, Offset);
@@ -472,15 +431,12 @@ static void DrawRegion(const BS_Region & Region, unsigned int Color, const BS_Ve
 
 // -----------------------------------------------------------------------------
 
-static int R_Draw(lua_State * L)
-{
+static int R_Draw(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 
-	switch (lua_gettop(L))
-	{
-		case 3:
-			{
+	switch (lua_gettop(L)) {
+		case 3: {
 				BS_Vertex Offset;
 				BS_Vertex::LuaVertexToVertex(L, 3, Offset);
 				DrawRegion(*pR, BS_GraphicEngine::LuaColorToARGBColor(L, 2), Offset);
@@ -500,8 +456,7 @@ static int R_Draw(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_GetCentroid(lua_State * L)
-{
+static int R_GetCentroid(::lua_State *L) {
 	BS_Region * RPtr = CheckRegion(L);
 	BS_ASSERT(RPtr);
 
@@ -512,8 +467,7 @@ static int R_GetCentroid(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static int R_Delete(lua_State * L)
-{
+static int R_Delete(::lua_State *L) {
 	BS_Region * pR = CheckRegion(L);
 	BS_ASSERT(pR);
 	delete pR;
@@ -522,8 +476,7 @@ static int R_Delete(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg REGION_METHODS[] =
-{
+static const luaL_reg REGION_METHODS[] = {
 	"SetPos", R_SetPos,
 	"SetX", R_SetX,
 	"SetY", R_SetY,
@@ -539,28 +492,23 @@ static const luaL_reg REGION_METHODS[] =
 
 // -----------------------------------------------------------------------------
 
-static BS_WalkRegion * CheckWalkRegion(lua_State * L)
-{
-	// Der erste Parameter muss vom Typ userdata sein und die Metatable der Klasse Geo.WalkRegion
+static BS_WalkRegion *CheckWalkRegion(::lua_State *L) {
+	// The first parameter must be of type 'userdate', and the Metatable class Geo.WalkRegion
 	unsigned int RegionHandle;
-	if ((RegionHandle = *reinterpret_cast<unsigned int *>(my_checkudata(L, 1, WALKREGION_CLASS_NAME))) != 0)
-	{
+	if ((RegionHandle = *reinterpret_cast<unsigned int *>(my_checkudata(L, 1, WALKREGION_CLASS_NAME))) != 0) {
 		return reinterpret_cast<BS_WalkRegion *>(BS_RegionRegistry::GetInstance().ResolveHandle(RegionHandle));
-	}
-	else
-	{
+	} else {
 		luaL_argcheck(L, 0, 1, "'" WALKREGION_CLASS_NAME "' expected");
 	}
 
-	// Compiler ruhigstellen. Ausführung kommt nie an diesem Punkt an.
+	// Compilation fix. Execution never reaches this point
 	return 0;
 }
 
 // -----------------------------------------------------------------------------
 
-static int WR_GetPath(lua_State * L)
-{
-	BS_WalkRegion * pWR = CheckWalkRegion(L);
+static int WR_GetPath(::lua_State *L) {
+	BS_WalkRegion *pWR = CheckWalkRegion(L);
 	BS_ASSERT(pWR);
 
 	BS_Vertex Start;
@@ -568,18 +516,15 @@ static int WR_GetPath(lua_State * L)
 	BS_Vertex End;
 	BS_Vertex::LuaVertexToVertex(L, 3, End);
 	BS_Path Path;
-	if (pWR->QueryPath(Start, End, Path))
-	{
+	if (pWR->QueryPath(Start, End, Path)) {
 		lua_newtable(L);
 		BS_Path::const_iterator it = Path.begin();
-		for (; it != Path.end(); it++)
-		{
+		for (; it != Path.end(); it++) {
 			lua_pushnumber(L, (it - Path.begin()) + 1);
 			BS_Vertex::VertexToLuaVertex(L, *it);
 			lua_settable(L, -3);
 		}
-	}
-	else
+	} else
 		lua_pushnil(L);
 
 	return 1;
@@ -587,21 +532,19 @@ static int WR_GetPath(lua_State * L)
 
 // -----------------------------------------------------------------------------
 
-static const luaL_reg WALKREGION_METHODS[] =
-{
+static const luaL_reg WALKREGION_METHODS[] = {
 	"GetPath", WR_GetPath,
 	0, 0,
 };
 
 // -----------------------------------------------------------------------------
 
-bool BS_Geometry::_RegisterScriptBindings()
-{
+bool BS_Geometry::_RegisterScriptBindings() {
 	BS_Kernel * pKernel = BS_Kernel::GetInstance();
 	BS_ASSERT(pKernel);
 	BS_ScriptEngine * pScript = static_cast<BS_ScriptEngine *>(pKernel->GetService("script"));
 	BS_ASSERT(pScript);
-	lua_State * L = static_cast<lua_State *>(pScript->GetScriptObject());
+	::lua_State *L = static_cast< ::lua_State *>(pScript->GetScriptObject());
 	BS_ASSERT(L);
 
 	if (!BS_LuaBindhelper::AddMethodsToClass(L, REGION_CLASS_NAME, REGION_METHODS)) return false;
@@ -615,3 +558,5 @@ bool BS_Geometry::_RegisterScriptBindings()
 
 	return true;
 }
+
+} // End of namespace Sword25
diff --git a/engines/sword25/math/line.h b/engines/sword25/math/line.h
index 3dd178adb5..86bcbd6537 100644
--- a/engines/sword25/math/line.h
+++ b/engines/sword25/math/line.h
@@ -35,11 +35,11 @@
 /*
 	BS_Line
 	-------
-	Diese Klasse enthält nur statische Methoden, die mit Geradensegmenten zu tun haben.
-    Es gibt keine wirkliche Geradensegment-Klasse, da diese Klasse vor allem zu
-	Berechnungen mit Polygonen herangezogen wird und es dabei wichtig ist, Start- und
-	Endpunkte der Linien dynamisch wählen zu können. Dieses würde sich verbieten, wenn
-	ein Polygon aus einer Menge von festen Geradensegmenten gebildet wäre.
+	This class contains only static methods, which have to do with straight line
+	segments. There is no real straight line segment class. Calculations will be
+	used with polygons, and it is important the process of starting and selecting
+	endpoints of lines is dynamic. This would prhobit a polygon from a set
+	being formed by fixed line segments
 
 	Autor: Malte Thiesen
 */
@@ -55,77 +55,69 @@
 
 // -----------------------------------------------------------------------------
 
-class BS_Line
-{
+namespace Sword25 {
+
+class BS_Line {
 public:
 	/**
-	    @brief Bestimmt ob sich ein Punkt links von einer Linie befindet.
-		@param a der Startpunkt der	Linie
-		@param b der Endpunkt der Linie
-		@param c der Testpunkt
-		@return Gibt true zurück, wenn sich der Punkt links von der Linie befindet.<br>
-				Falls sich der Punkt rechts von der Linie oder auf der Linie befindet wird false zurückgegeben.<br>
-		@remark Ein Punkt liegt links von einer Linie, wenn er vom Startpunkt aus betrachtet links neben der Linie liegt.
-	*/
-	static bool IsVertexLeft(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
+	 * Determines whether a piont is left of a line
+	 * @param a			The start point of a line
+	 * @param b			The end point of a line
+	 * @param c			The test point
+	 * @return			Returns true if the point is to the left of the line.
+	 * If the point is to the right of the line or on the line, false is returned.
+	 */
+	static bool IsVertexLeft(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
 		return _TriangleArea2(a, b, c) > 0;
 	}
 
-	static bool IsVertexLeftOn(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
+	static bool IsVertexLeftOn(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
 		return _TriangleArea2(a, b, c) >= 0;
 	}
 
 	/**
-		@brief Bestimmt ob sich ein Punkt rechts von einer Linie befindet.
-		@param a der Startpunkt der	Linie
-		@param b der Endpunkt der Linie
-		@param c der Testpunkt
-		@return Gibt true zurück, wenn sich der Punkt recht von der Linie befindet.<br>
-		Falls sich der Punkt links von der Linie oder auf der Linie befindet wird false zurückgegeben.<br>
-		@remark Ein Punkt liegt rechts von einer Linie, wenn er vom Startpunkt aus betrachtet rechts neben der Linie liegt.
-	*/
-	static bool IsVertexRight(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
+	 * Determines whether a piont is right of a line
+	 * @param a			The start point of a line
+	 * @param b			The end point of a line
+	 * @param c			The test point
+	 * @return			Returns true if the point is to the right of the line.
+	 * If the point is to the right of the line or on the line, false is returned.
+	 */
+	static bool IsVertexRight(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
 		return _TriangleArea2(a, b, c) < 0;
 	}
 
-	static bool IsVertexRightOn(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
+	static bool IsVertexRightOn(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
 		return _TriangleArea2(a, b, c) <= 0;
 	}
 
 	/**
-		@brief Bestimmt ob sich ein Punkt auf einer Linie befindet.
-		@param a der Startpunkt der	Linie
-		@param b der Endpunkt der Linie
-		@param c der Testpunkt
-		@return Gibt true zurück, wenn sich der Punkt auf der Linie befindet.
-	*/
-	static bool IsVertexOn(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
+	 * Determines whether a piont is on a line
+	 * @param a			The start point of a line
+	 * @param b			The end point of a line
+	 * @param c			The test point
+	 * @return			Returns true if the point is on the line, false otherwise.
+	 */
+	static bool IsVertexOn(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
 		return _TriangleArea2(a, b, c) == 0;
 	}
 
-	enum VERTEX_CLASSIFICATION
-	{
+	enum VERTEX_CLASSIFICATION {
 		LEFT,
 		RIGHT,
 		ON
 	};
 
 	/**
-	    @brief Bestimmt wo sich ein Punkt relativ zu einer Linie befindet.
-		@param a der Startpunkt der	Linie
-		@param b der Endpunkt der Linie
-		@param c der Testpunkt
-		@return Gibt LEFT zurück, wenn sich der Punkt links von der Line befindet.<br>
-				Gibt RIGHT zurück, wenn sich der Punkt links von der Line befindet.<br>
-				Gibt ON zurück, wenn sich der Punkt auf der Linie befindet.
-	*/
-	static VERTEX_CLASSIFICATION ClassifyVertexToLine(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
+	 * Determines where a point is relative to a line.
+	 * @param a			The start point of a line
+	 * @param b			The end point of a line
+	 * @param c			The test point
+	 * @return			LEFT is returned if the point is to the left of the line.
+	 * RIGHT is returned if the point is to the right of the line.
+	 * ON is returned if the point is on the line.
+	 */
+	static VERTEX_CLASSIFICATION ClassifyVertexToLine(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
 		int Area = _TriangleArea2(a, b, c);
 		if (Area > 0) return LEFT;
 		if (Area < 0) return RIGHT;
@@ -133,15 +125,14 @@ public:
 	}
 
 	/**
-	    @brief Bestimmt ob sich zwei Linien schneiden.
-		@param a der Startpunkt der ersten Linie
-		@param b der Endpunkt der ersten Linie
-		@param c der Startpunkt der zweiten Linie
-		@param d der Endpunkt der zweiten Linie
-		@remark In den Fällen in denen eine Linie die andere nur berührt, wird false zurückgegeben (improper intersection).
-	*/
-	static bool DoesIntersectProperly(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c, const BS_Vertex & d)
-	{
+	 * Determines whether two lines intersect
+	 * @param a			The start point of the first line
+	 * @param b			The end point of the first line
+	 * @param c			The start point of the second line
+	 * @param d			The end point of the second line
+	 * @remark			In cases where a line only touches the other, false is returned (improper intersection)
+	 */
+	static bool DoesIntersectProperly(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c, const BS_Vertex &d) {
 		VERTEX_CLASSIFICATION Class1 = ClassifyVertexToLine(a, b, c);
 		VERTEX_CLASSIFICATION Class2 = ClassifyVertexToLine(a, b, d);
 		VERTEX_CLASSIFICATION Class3 = ClassifyVertexToLine(c, d, a);
@@ -153,26 +144,22 @@ public:
 	}
 
 	/**
-	    @brief Bestimmt ob sich ein Punkt auf einem Liniensegment befindet
-		@param a der Startpunkt der	Liniensegmentes
-		@param b der Endpunkt der Liniensegmentes
-		@param c der Testpunkt
-	*/
-	static bool IsOnLine(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
-		// Die Punkte müssen alle Kollinear sein, sonst liegt der Testpunkt nicht auf dem Liniensegment
+	 * Determines whether a point is on a line segment
+	 * @param a			The start point of a line
+	 * @param b			The end point of a line
+	 * @param c			The test point
+	 */
+	static bool IsOnLine(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
+		// The items must all be Collinear, otherwise don't bothering testing the point
 		if (_TriangleArea2(a, b, c) != 0) return false;
 
-		// Falls das Liniensegment nicht vertikal ist prüfe auf der X-Achse, ansonsten auf der Y-Achse
-		if (a.X != b.X)
-		{
+		// If the line segment is not vertical, check on the x-axis, otherwise the y-axis
+		if (a.X != b.X) {
 			return ((a.X <= c.X) &&
 					(c.X <= b.X)) ||
 				   ((a.X >= c.X) &&
 					(c.X >= b.X));
-		}
-		else
-		{
+		} else {
 			return ((a.Y <= c.Y) &&
 					(c.Y <= b.Y)) ||
 				   ((a.Y >= c.Y) &&
@@ -180,21 +167,17 @@ public:
 		}
 	}
 
-	static bool IsOnLineStrict(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
-		// Die Punkte müssen alle Kollinear sein, sonst liegt der Testpunkt nicht auf dem Liniensegment
+	static bool IsOnLineStrict(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
+		// The items must all be Collinear, otherwise don't bothering testing the point
 		if (_TriangleArea2(a, b, c) != 0) return false;
 
-		// Falls das Liniensegment nicht vertikal ist prüfe auf der X-Achse, ansonsten auf der Y-Achse
-		if (a.X != b.X)
-		{
+		// If the line segment is not vertical, check on the x-axis, otherwise the y-axis
+		if (a.X != b.X) {
 			return ((a.X < c.X) &&
 				(c.X < b.X)) ||
 				((a.X > c.X) &&
 				(c.X > b.X));
-		}
-		else
-		{
+		} else {
 			return ((a.Y < c.Y) &&
 				(c.Y < b.Y)) ||
 				((a.Y > c.Y) &&
@@ -203,19 +186,19 @@ public:
 	}
 
 private:
-
 	/**
-	    @brief Gibt die doppelte Größe des durch a, b und c definierten Dreiecks zurück.
-
-		Das Ergebnis ist positiv wenn die Punkte entgegen dem Uhrzeigersinn angeordnet sind und negativ wenn sie mit dem
-		Uhrzeigersinn angeordnet sind.
-	*/
-	static int _TriangleArea2(const BS_Vertex & a, const BS_Vertex & b, const BS_Vertex & c)
-	{
+	 * Return double the size of the triangle defined by the three passed points.
+	 *
+	 * The result is positive if the points are arrange counterclockwise, 
+	 * and negative if they are arranged counter-clockwise.
+	 */
+	static int _TriangleArea2(const BS_Vertex &a, const BS_Vertex &b, const BS_Vertex &c) {
 		return a.X * b.Y - a.Y * b.X +
 			   a.Y * c.X - a.X * c.Y +
 			   b.X * c.Y - c.X * b.Y;
 	}
 };
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/math/polygon.cpp b/engines/sword25/math/polygon.cpp
index ab5ce0d96d..6d416ea080 100644
--- a/engines/sword25/math/polygon.cpp
+++ b/engines/sword25/math/polygon.cpp
@@ -32,11 +32,6 @@
  *
  */
 
-#include "sword25/kernel/memlog_off.h"
-#include <utility>
-#include <vector>
-#include "sword25/kernel/memlog_on.h"
-
 #include <math.h>
 
 #include "sword25/kernel/outputpersistenceblock.h"
@@ -45,58 +40,52 @@
 #include "sword25/math/polygon.h"
 #include "sword25/math/line.h"
 
+namespace Sword25 {
+
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 
-// Konstruktion / Destruktion
+// Constructor / Destructor
 // --------------------------
 
-BS_Polygon::BS_Polygon() : VertexCount(0), Vertecies(NULL)
-{
+BS_Polygon::BS_Polygon() : VertexCount(0), Vertecies(NULL) {
 }
 
-BS_Polygon::BS_Polygon(int VertexCount, const BS_Vertex* Vertecies) : VertexCount(0), Vertecies(NULL)
-{ 
+BS_Polygon::BS_Polygon(int VertexCount, const BS_Vertex *Vertecies) : VertexCount(0), Vertecies(NULL) { 
 	Init(VertexCount, Vertecies);
 }
 
-BS_Polygon::BS_Polygon(const BS_Polygon& Other) : VertexCount(0), Vertecies(NULL)
-{
+BS_Polygon::BS_Polygon(const BS_Polygon &Other) : VertexCount(0), Vertecies(NULL) {
 	Init(Other.VertexCount, Other.Vertecies);
 }
 
-BS_Polygon::BS_Polygon(BS_InputPersistenceBlock & Reader) : VertexCount(0), Vertecies(NULL)
-{
+BS_Polygon::BS_Polygon(BS_InputPersistenceBlock &Reader) : VertexCount(0), Vertecies(NULL) {
 	Unpersist(Reader);
 }
 
-BS_Polygon::~BS_Polygon()
-{
+BS_Polygon::~BS_Polygon() {
 	delete[] Vertecies;
 }
 
-// Initialisierung
+// Initialisation
 // ---------------
 
-bool BS_Polygon::Init(int VertexCount, const BS_Vertex* Vertecies)
-{
-	// Alten Objektzustand merken um ihn wieder herstellen zu können, falls beim Initialisieren mit den neuen Daten ein Fehler auftreten
-	// sollte.
+bool BS_Polygon::Init(int VertexCount, const BS_Vertex *Vertecies) {
+	// Rember the old obstate to restore it if an error occurs whilst initialising it with the new data
 	int OldVertexCount = this->VertexCount;
-	BS_Vertex* OldVertecies = this->Vertecies;
+	BS_Vertex *OldVertecies = this->Vertecies;
 
 	this->VertexCount = VertexCount;
 	this->Vertecies = new BS_Vertex[VertexCount + 1];
 	memcpy(this->Vertecies, Vertecies, sizeof(BS_Vertex) * VertexCount);
 	// TODO:
-	// Doppelte und überflüssige Vertecies entfernen (überflüssig = 3 Verts kollinear)
+	// Duplicate and remove redundant vertecies (Superflous = 3 co-linear verts)
 	// _WeedRepeatedVertecies();
-	// Das erste Vertex wird am Ende des Vertex-Arrays wiederholt, dieses vereinfacht einige Algorithmen, die alle Edges durchgehen und
-	// sich so die Überlaufkontrolle sparen können.
+	// The first vertex is repeated at the end of the vertex array; this simplifies
+	// some algorithms, running through the edges and thus can save the overflow control.
 	this->Vertecies[VertexCount] = this->Vertecies[0];
 
-	// Falls das Polygon selbstüberschneidend ist, wird der alte Objektzustand wieder hergestellt und ein Fehler signalisiert.
-	if (CheckForSelfIntersection())
-	{
+	// If the polygon is self-intersecting, the object state is restore, and an error signalled
+	if (CheckForSelfIntersection()) {
 		delete[] this->Vertecies;
 		this->Vertecies = OldVertecies;
 		this->VertexCount = OldVertexCount;
@@ -105,10 +94,10 @@ bool BS_Polygon::Init(int VertexCount, const BS_Vertex* Vertecies)
 		return false;
 	}
 
-	// Alte Vertexliste freigeben
+	// Release old vertex list
 	delete[] OldVertecies;
 
-	// Eigenschaften des Polygons berechnen.
+	// Calculate properties of the polygon
 	m_IsCW = ComputeIsCW();
 	m_IsConvex = ComputeIsConvex();
 	m_Centroid = ComputeCentroid();
@@ -116,52 +105,44 @@ bool BS_Polygon::Init(int VertexCount, const BS_Vertex* Vertecies)
 	return true;
 }
 
-// Überprüfung der Reihenfolge der Vertecies
-// -----------------------------------------
+// Review the order of the Vertecies
+// ---------------------------------
 
-bool BS_Polygon::IsCW() const
-{
+bool BS_Polygon::IsCW() const {
 	return m_IsCW;
 }
 
-bool BS_Polygon::IsCCW() const
-{
+bool BS_Polygon::IsCCW() const {
 	return !IsCW();
 }
 
-bool BS_Polygon::ComputeIsCW() const
-{
-	if (VertexCount)
-	{
-		// Vertex finden, dass am weitesten rechts unten liegt.
+bool BS_Polygon::ComputeIsCW() const {
+	if (VertexCount) {
+		// Find the vertex on extreme bottom right
 		int V2Index = FindLRVertexIndex();
 
-		// Vertex vorher und nachher finden.
+		// Find the vertex before and after it
 		int V1Index = (V2Index + (VertexCount - 1)) % VertexCount;
 		int V3Index = (V2Index + 1) % VertexCount;
 
-		// Kreuzprodukt bilden.
-		// Wenn das Kreuzprodukt des am weitesten unten links liegenden Vertex positiv ist, sind die Vertecies im Uhrzeigersinn angeordnet
-		// ansonsten entgegen des Uhrzeigersinns.
+		// Cross product form
+		// If the cross product of the vertex lying fartherest bottom left is positive,
+		// the vertecies arrranged in a clockwise order. Otherwise counter-clockwise
 		if (CrossProduct(Vertecies[V1Index], Vertecies[V2Index], Vertecies[V3Index]) >= 0) return true;
 	}
 
 	return false;
 }
 
-int BS_Polygon::FindLRVertexIndex() const
-{
-	if (VertexCount)
-	{
+int BS_Polygon::FindLRVertexIndex() const {
+	if (VertexCount) {
 		int CurIndex = 0;
 		int MaxX = Vertecies[0].X;
 		int MaxY = Vertecies[0].Y;
 
-		for (int i = 1; i < VertexCount; i++)
-		{
+		for (int i = 1; i < VertexCount; i++) {
 			if (Vertecies[i].Y > MaxY ||
-			   (Vertecies[i].Y == MaxY && Vertecies[i].X > MaxX))
-			{
+			   (Vertecies[i].Y == MaxY && Vertecies[i].X > MaxX)) {
 				MaxX = Vertecies[i].X;
 				MaxY = Vertecies[i].Y;
 				CurIndex = i;
@@ -174,109 +155,101 @@ int BS_Polygon::FindLRVertexIndex() const
 	return -1;
 }
 
-// Testen auf Konvex/Konkav
+// Testing for Convex / Concave
 // ------------------------
 
-bool BS_Polygon::IsConvex() const
-{
+bool BS_Polygon::IsConvex() const {
 	return m_IsConvex;
 }
 
-bool BS_Polygon::IsConcave() const
-{
+bool BS_Polygon::IsConcave() const {
 	return !IsConvex();
 }
 
-bool BS_Polygon::ComputeIsConvex() const
-{
-	// Polygone mit 3 oder weniger Vertecies können nur Konvex sein.
+bool BS_Polygon::ComputeIsConvex() const {
+	// Polygons with three or less Vertecies can only be convex
 	if (VertexCount <= 3) return true;
 
-	// Alle Winkel im Polygon berechnen, wenn das Polygon Konvex ist, müssen alle Winkel das selbe Vorzeichen haben.
+	// All angles in the polygon computed will have the same direction sign if the polygon is convex
 	int Flag = 0;
-	for (int i = 0; i < VertexCount; i++)
-	{
-		// Die Indizies der beiden nächsten Vertecies nach i bestimmen.
+	for (int i = 0; i < VertexCount; i++) {
+		// Determine the next two vertecies to check
 		int j = (i + 1) % VertexCount;
 		int k = (i + 2) % VertexCount;
 
-		// Kreuzprodukt der drei Vertecies berechnen.
+		// Calculate the cross product of the three vertecies
 		int Cross = CrossProduct(Vertecies[i], Vertecies[j], Vertecies[k]);
 
-		// Die unteren beiden Bits von Flag haben folgende Bedeutung:
-		// 0 : negativer Winkel ist aufgetreten
-		// 1 : positiver Winkel ist aufgetreten
+		// The lower two bits of the flag represent the following:
+		// 0: negative angle occurred
+		// 1: positive angle occurred
 
-		// Vorzeichen des aktuellen Winkels in Flag vermerken.
+		// The sign of the current angle is recorded in Flag
 		if (Cross < 0)
 			Flag |= 1;
 		else if (Cross > 0)
 			Flag |= 2;
 
-		// Falls Flag 3 ist, sind sowohl positive als auch negative Winkel vorhanden -> Polygon ist Konkav.
+		// If flag is 3, there are both positive and negative angles; so the polygon is concave
 		if (Flag == 3) return false;
 	}
 
-	// Polygon ist Konvex.
+	// Polygon is convex
 	return true;
 }
 
-// Sicherstellen einer bestimmen Vertexordnung
-// -------------------------------------------
+// Make a determine vertex order
+// -----------------------------
 
-void BS_Polygon::EnsureCWOrder()
-{
+void BS_Polygon::EnsureCWOrder() {
 	if (!IsCW())
 		ReverseVertexOrder();
 }
 
-void BS_Polygon::EnsureCCWOrder()
-{
+void BS_Polygon::EnsureCCWOrder() {
 	if (!IsCCW())
 		ReverseVertexOrder();
 }
 
-// Umkehren der Reihenfolge der Vertecies
-// --------------------------------------
+// Reverse the order of vertecies
+// ------------------------------
 
-void BS_Polygon::ReverseVertexOrder()
-{
-	// Vertecies paarweise vertauschen, bis die Liste komplett umgekehrt wurde.
-	for (int i = 0; i < VertexCount / 2; i++)
-		std::swap(Vertecies[i], Vertecies[VertexCount - i - 1]);
+void BS_Polygon::ReverseVertexOrder() {
+	// Vertecies are exchanged in pairs, until the list has been completely reversed
+	for (int i = 0; i < VertexCount / 2; i++) {
+		BS_Vertex tempVertex = Vertecies[i];
+		Vertecies[i] = Vertecies[VertexCount - i - 1];
+		Vertecies[VertexCount - i - 1] = tempVertex;
+	}
 
 	// Vertexordnung neu berechnen.
 	m_IsCW = ComputeIsCW();
 }
 
-// Kreuzprodukt
-// ------------
+// Cross Product
+// -------------
 
-int BS_Polygon::CrossProduct(const BS_Vertex& V1, const BS_Vertex& V2, const BS_Vertex& V3) const
-{
+int BS_Polygon::CrossProduct(const BS_Vertex &V1, const BS_Vertex &V2, const BS_Vertex &V3) const {
 	return (V2.X - V1.X) * (V3.Y - V2.Y) -
 		   (V2.Y - V1.Y) * (V3.X - V2.X);
 }
 
-// Skalarproduct
-// -------------
+// Scalar Product
+// --------------
 
-int BS_Polygon::DotProduct(const BS_Vertex& V1, const BS_Vertex& V2, const BS_Vertex& V3) const
-{
+int BS_Polygon::DotProduct(const BS_Vertex &V1, const BS_Vertex &V2, const BS_Vertex &V3) const {
 	return (V1.X - V2.X) * (V3.X - V2.X) +
 		   (V1.Y - V2.Y) * (V3.X - V2.Y);
 }
 
-// Überprüfen auf Selbstüberschneidung
-// -----------------------------------
+// Check for self-intersections
+// ----------------------------
 
-bool BS_Polygon::CheckForSelfIntersection() const
-{
-	// TODO: Fertigstellen
+bool BS_Polygon::CheckForSelfIntersection() const {
+	// TODO: Finish this
 	/*
 	float AngleSum = 0.0f;
-	for (int i = 0; i < VertexCount; i++)
-	{
+	for (int i = 0; i < VertexCount; i++) {
 		int j = (i + 1) % VertexCount;
 		int k = (i + 2) % VertexCount;
 
@@ -289,8 +262,7 @@ bool BS_Polygon::CheckForSelfIntersection() const
 							 (Vertecies[k].Y - Vertecies[j].Y) * (Vertecies[k].Y - Vertecies[j].Y));
 		float Norm = Length1 * Length2;
 
-		if (Norm > 0.0f)
-		{
+		if (Norm > 0.0f) {
 			Dot /= Norm;
 			AngleSum += acos(Dot);
 		}
@@ -300,46 +272,43 @@ bool BS_Polygon::CheckForSelfIntersection() const
 	return false;
 }
 
-// Verschieben
-// -----------
+// Move
+// ----
 
-void BS_Polygon::operator+=(const BS_Vertex& Delta)
-{
-	// Alle Vetecies verschieben
+void BS_Polygon::operator+=(const BS_Vertex &Delta) {
+	// Move all vertecies
 	for (int i = 0; i < VertexCount; i++)
 		Vertecies[i] += Delta;
 
-	// Den Schwerpunkt verschieben.
+	// Shift the focus
 	m_Centroid += Delta;
 }
 
-// Sichtlinie
-// ----------
+// Line of Sight
+// -------------
 
-bool BS_Polygon::IsLineInterior(const BS_Vertex & a, const BS_Vertex & b) const
-{
-	// Beide Punkte müssen im Polygon sein
+bool BS_Polygon::IsLineInterior(const BS_Vertex &a, const BS_Vertex &b) const {
+	// Both points have to be in the polygon
 	if (!IsPointInPolygon(a, true) || !IsPointInPolygon(b, true)) return false;
 
-	// Falls die Punkte identisch sind, ist die Linie trivialerweise innerhalb des Polygons
+	// If the points are identical, the line is trivially within the polygon
 	if (a == b) return true;
 
-	// Testen, ob die Linie ein Liniensegment strikt schneidet (proper intersection)
-	for (int i = 0; i < VertexCount; i++)
-	{
+	// Test whether the line intersects a line segment strictly (proper intersection)
+	for (int i = 0; i < VertexCount; i++) {
 		int j = (i + 1) % VertexCount;
-		const BS_Vertex & VS = Vertecies[i];
-		const BS_Vertex & VE = Vertecies[j];
+		const BS_Vertex &VS = Vertecies[i];
+		const BS_Vertex &VE = Vertecies[j];
 	
-		// Falls die Linie ein Liniensegment strikt schneidet (proper intersection) ist die Linie nicht innerhalb des Polygons
+		// If the line intersects a line segment strictly (proper cross section) the line is not in the polygon
 		if (BS_Line::DoesIntersectProperly(a, b, VS, VE)) return false;
 
-		// Falls einer der beiden Linienpunkte auf der Kante liegt und der andere rechts der Kante liegt, befindet sich die Linie nicht
-		// vollständig innerhalb des Polygons.
+		// If one of the two line items is on the edge and the other is to the right of the edge,
+		// then the line is not completely within the polygon
 		if (BS_Line::IsOnLineStrict(VS, VE, a) && BS_Line::IsVertexRight(VS, VE, b)) return false;
 		if (BS_Line::IsOnLineStrict(VS, VE, b) && BS_Line::IsVertexRight(VS, VE, a)) return false;
 
-		// Falls einer der beiden Linienpunkte auf einem Vertex liegt muss die Linie in das Polygon hinein verlaufen
+		// If one of the two line items is on a vertex, the line traces into the polygon
 		if ((a == VS) && !IsLineInCone(i, b, true)) return false;
 		if ((b == VS) && !IsLineInCone(i, a, true)) return false;
 	}
@@ -347,37 +316,34 @@ bool BS_Polygon::IsLineInterior(const BS_Vertex & a, const BS_Vertex & b) const
 	return true;
 }
 
-bool BS_Polygon::IsLineExterior(const BS_Vertex & a, const BS_Vertex & b) const
-{
-	// Keiner der beiden Punkte darf strikt im Polygon sein (auf der Kante ist erlaubt)
+bool BS_Polygon::IsLineExterior(const BS_Vertex &a, const BS_Vertex &b) const {
+	// Neither of the two points must be strictly in the polygon (on the edge is allowed)
 	if (IsPointInPolygon(a, false) || IsPointInPolygon(b, false)) return false;
 
-	// Falls die Punkte identisch sind, ist die Linie trivialerweise ausserhalb des Polygons
+	// If the points are identical, the line is trivially outside of the polygon
 	if (a == b) return true;
 
-	// Testen, ob die Linie ein Liniensegment strikt schneidet (proper intersection)
-	for (int i = 0; i < VertexCount; i++)
-	{
+	// Test whether the line intersects a line segment strictly (proper intersection)
+	for (int i = 0; i < VertexCount; i++) {
 		int j = (i + 1) % VertexCount;
-		const BS_Vertex & VS = Vertecies[i];
-		const BS_Vertex & VE = Vertecies[j];
+		const BS_Vertex &VS = Vertecies[i];
+		const BS_Vertex &VE = Vertecies[j];
 
-		// Falls die Linie ein Liniensegment strikt schneidet (proper intersection) ist die Linie teilweise innerhalb des Polygons
+		// If the line intersects a line segment strictly (proper intersection), then
+		// the line is partially inside the polygon
 		if (BS_Line::DoesIntersectProperly(a, b, VS, VE)) return false;
 
-		// Falls einer der beiden Linienpunkte auf der Kante liegt und der andere rechts der Kante liegt, befindet sich die Linie nicht vollständig
-		// ausserhalb des Polygons.
+		// If one of the two line items is on the edge and the other is to the right of the edge,
+		// the line is not completely outside the polygon
 		if (BS_Line::IsOnLineStrict(VS, VE, a) && BS_Line::IsVertexLeft(VS, VE, b)) return false;
 		if (BS_Line::IsOnLineStrict(VS, VE, b) && BS_Line::IsVertexLeft(VS, VE, a)) return false;
 
-		// Falls einer der beiden Linienpunkte auf einem Vertex liegt, darf die Linie nicht in das Polygon hinein verlaufen
+		// If one of the lwo line items is on a vertex, the line must not run into the polygon
 		if ((a == VS) && IsLineInCone(i, b, false)) return false;
 		if ((b == VS) && IsLineInCone(i, a, false)) return false;
 
-		// Falls das Vertex mit Start- und Zielpunkt kollinear ist, dürfen die beiden Liniensegmente (a, VS) und (b, VS) nicht in das Polygon hinein
-		// verlaufen
-		if (BS_Line::IsOnLine(a, b, VS))
-		{
+		// If the vertex with start and end point is collinear, (a VS) and (b, VS) is not in the polygon
+		if (BS_Line::IsOnLine(a, b, VS)) {
 			if (IsLineInCone(i, a, false)) return false;
 			if (IsLineInCone(i, b, false)) return false;
 		}
@@ -386,23 +352,19 @@ bool BS_Polygon::IsLineExterior(const BS_Vertex & a, const BS_Vertex & b) const
 	return true;
 }
 
-bool BS_Polygon::IsLineInCone(int StartVertexIndex, const BS_Vertex & EndVertex, bool IncludeEdges) const
-{
-	const BS_Vertex & StartVertex = Vertecies[StartVertexIndex];
-	const BS_Vertex & NextVertex = Vertecies[(StartVertexIndex + 1) % VertexCount];
-	const BS_Vertex & PrevVertex = Vertecies[(StartVertexIndex + VertexCount - 1) % VertexCount];
+bool BS_Polygon::IsLineInCone(int StartVertexIndex, const BS_Vertex &EndVertex, bool IncludeEdges) const {
+	const BS_Vertex &StartVertex = Vertecies[StartVertexIndex];
+	const BS_Vertex &NextVertex = Vertecies[(StartVertexIndex + 1) % VertexCount];
+	const BS_Vertex &PrevVertex = Vertecies[(StartVertexIndex + VertexCount - 1) % VertexCount];
 
-	if (BS_Line::IsVertexLeftOn(PrevVertex, StartVertex, NextVertex))
-	{
+	if (BS_Line::IsVertexLeftOn(PrevVertex, StartVertex, NextVertex)) {
 		if (IncludeEdges)
 			return BS_Line::IsVertexLeftOn(EndVertex, StartVertex, NextVertex) &&
 			BS_Line::IsVertexLeftOn(StartVertex, EndVertex, PrevVertex);
 		else
 			return BS_Line::IsVertexLeft(EndVertex, StartVertex, NextVertex) &&
 			BS_Line::IsVertexLeft(StartVertex, EndVertex, PrevVertex);
-	}
-	else
-	{
+	} else {
 		if (IncludeEdges)
 			return !(BS_Line::IsVertexLeft(EndVertex, StartVertex, PrevVertex) &&
 			BS_Line::IsVertexLeft(StartVertex, EndVertex, NextVertex));
@@ -412,56 +374,49 @@ bool BS_Polygon::IsLineInCone(int StartVertexIndex, const BS_Vertex & EndVertex,
 	}
 }
 
-// Punkt-Polygon Tests
+// Point-Polygon Tests
 // -------------------
 
-bool BS_Polygon::IsPointInPolygon(int X, int Y, bool BorderBelongsToPolygon) const
-{
+bool BS_Polygon::IsPointInPolygon(int X, int Y, bool BorderBelongsToPolygon) const {
 	return IsPointInPolygon(BS_Vertex(X, Y), BorderBelongsToPolygon);
 }
 
-bool BS_Polygon::IsPointInPolygon(const BS_Vertex & Point, bool EdgesBelongToPolygon) const
-{
-	int Rcross = 0; // Anzahl der rechtsseitigen Überschneidungen
-	int Lcross = 0; // Anzahl der linksseitigen Überschneidungen
+bool BS_Polygon::IsPointInPolygon(const BS_Vertex &Point, bool EdgesBelongToPolygon) const {
+	int Rcross = 0; // Number of right-side overlaps
+	int Lcross = 0; // Number of left-side overlaps
 
-	// Jede Kante wird überprüft ob sie den vom Punkt ausgehenden Strahl schneidet
-	for (int i = 0; i < VertexCount; i++)
-	{
-		const BS_Vertex & EdgeStart = Vertecies[i];
-		const BS_Vertex & EdgeEnd = Vertecies[(i + 1) % VertexCount];
+	// Each edge is checked whether it cuts the outgoing stream from the point
+	for (int i = 0; i < VertexCount; i++) {
+		const BS_Vertex &EdgeStart = Vertecies[i];
+		const BS_Vertex &EdgeEnd = Vertecies[(i + 1) % VertexCount];
 
-		// Ist der Punkt ein Vertex? Dann liegt er auf einer Kante des Polygons
+		// A vertex is a point? Then it lies on one edge of the polygon
 		if (Point == EdgeStart) return EdgesBelongToPolygon;
 
-		if ((EdgeStart.Y > Point.Y) != (EdgeEnd.Y > Point.Y))
-		{
+		if ((EdgeStart.Y > Point.Y) != (EdgeEnd.Y > Point.Y)) {
 			int Term1 = (EdgeStart.X - Point.X) * (EdgeEnd.Y - Point.Y) - (EdgeEnd.X - Point.X) * (EdgeStart.Y - Point.Y);
 			int Term2 = (EdgeEnd.Y - Point.Y) - (EdgeStart.Y - EdgeEnd.Y);
 			if ((Term1 > 0) == (Term2 >= 0)) Rcross++;
 		}
 
-		if ((EdgeStart.Y < Point.Y) != (EdgeEnd.Y < Point.Y))
-		{ 
+		if ((EdgeStart.Y < Point.Y) != (EdgeEnd.Y < Point.Y)) { 
 			int Term1 = (EdgeStart.X - Point.X) * (EdgeEnd.Y - Point.Y) - (EdgeEnd.X - Point.X) * (EdgeStart.Y - Point.Y);
 			int Term2 = (EdgeEnd.Y - Point.Y) - (EdgeStart.Y - EdgeEnd.Y);
 			if ((Term1 < 0) == (Term2 <= 0)) Lcross++;
 		}
 	}	
 
-	// Der Punkt befindet sich auf einer Kante, wenn die Anzahl der linken und rechten Überschneidungen nicht die gleiche Geradzahligkeit haben
+	// The point is on an adge, if the number of left and right intersections have the same even numbers
 	if ((Rcross % 2 ) != (Lcross % 2 )) return EdgesBelongToPolygon;
 
-	// Der Punkt befindet sich genau dann strikt innerhalb des Polygons, wenn die Anzahl der Überschneidungen ungerade ist
+	// The point is strictly inside the polygon if and only if the number of overlaps is odd
 	if ((Rcross % 2) == 1) return true;
 	else return false;
 }
 
-bool BS_Polygon::Persist(BS_OutputPersistenceBlock & Writer)
-{
+bool BS_Polygon::Persist(BS_OutputPersistenceBlock &Writer) {
 	Writer.Write(VertexCount);
-	for (int i = 0; i < VertexCount; ++i)
-	{
+	for (int i = 0; i < VertexCount; ++i) {
 		Writer.Write(Vertecies[i].X);
 		Writer.Write(Vertecies[i].Y);
 	}
@@ -469,16 +424,16 @@ bool BS_Polygon::Persist(BS_OutputPersistenceBlock & Writer)
 	return true;
 }
 
-bool BS_Polygon::Unpersist(BS_InputPersistenceBlock & Reader)
-{
+bool BS_Polygon::Unpersist(BS_InputPersistenceBlock &Reader) {
 	int StoredVertexCount;
 	Reader.Read(StoredVertexCount);
 
-	std::vector<BS_Vertex> StoredVertecies(StoredVertexCount);
-	for (int i = 0; i < StoredVertexCount; ++i)
-	{
-		Reader.Read(StoredVertecies[i].X);
-		Reader.Read(StoredVertecies[i].Y);
+	Common::Array<BS_Vertex> StoredVertecies;
+	for (int i = 0; i < StoredVertexCount; ++i) {
+		int x, y;
+		Reader.Read(x);
+		Reader.Read(y);
+		StoredVertecies.push_back(BS_Vertex(x, y));
 	}
 
 	Init(StoredVertexCount, &StoredVertecies[0]);
@@ -486,30 +441,26 @@ bool BS_Polygon::Unpersist(BS_InputPersistenceBlock & Reader)
 	return Reader.IsGood();
 }
 
-// Schwerpunkt
-// -----------
+// Main Focus
+// ----------
 
-BS_Vertex BS_Polygon::GetCentroid() const
-{
+BS_Vertex BS_Polygon::GetCentroid() const {
 	return m_Centroid;
 }
 
-BS_Vertex BS_Polygon::ComputeCentroid() const
-{
-	// Flächeninhalt des Polygons berechnen.
+BS_Vertex BS_Polygon::ComputeCentroid() const {
+	// Area of the polygon is calculated
 	int DoubleArea = 0;
-	for (int i = 0; i < VertexCount; ++i)
-	{
+	for (int i = 0; i < VertexCount; ++i) {
 		DoubleArea += Vertecies[i].X * Vertecies[i + 1].Y - Vertecies[i + 1].X * Vertecies[i].Y;
 	}
 
-	// Division durch 0 beim nächsten Schritt vermeiden.
+	// Avoid division by zero in the next step
 	if (DoubleArea == 0) return BS_Vertex();
 
-	// Schwerpunkt berechnen.
+	// Calculate centroid
 	BS_Vertex Centroid;
-	for (int i = 0; i < VertexCount; ++i)
-	{
+	for (int i = 0; i < VertexCount; ++i) {
 		int Area = Vertecies[i].X * Vertecies[i + 1].Y - Vertecies[i + 1].X * Vertecies[i].Y;
 		Centroid.X += (Vertecies[i].X + Vertecies[i + 1].X) * Area;
 		Centroid.Y += (Vertecies[i].Y + Vertecies[i + 1].Y) * Area;
@@ -519,3 +470,5 @@ BS_Vertex BS_Polygon::ComputeCentroid() const
 
 	return Centroid;
 }
+
+} // End of namespace Sword25
diff --git a/engines/sword25/math/polygon.h b/engines/sword25/math/polygon.h
index 73de386917..d435c9746b 100644
--- a/engines/sword25/math/polygon.h
+++ b/engines/sword25/math/polygon.h
@@ -40,6 +40,8 @@
 #include "sword25/kernel/persistable.h"
 #include "sword25/math/vertex.h"
 
+namespace Sword25 {
+
 // -----------------------------------------------------------------------------
 // Forward Declarations
 // -----------------------------------------------------------------------------
@@ -49,158 +51,151 @@ class BS_Vertex;
 /**
 	@brief Eine Polygonklasse.
 */
-class BS_Polygon : public BS_Persistable
-{
+class BS_Polygon : public BS_Persistable {
 public:
 	/**
-		@brief Erzeugt ein Objekt vom Typ #BS_Polygon, das 0 Vertecies enthält.
-
-		Mit der Methode Init() können dem Polygon später Vertecies hinzugefügt werden.
-	*/
+	 * Creates an object of type #BS_Polygon, containing 0 Vertecies.
+	 *
+	 * With the method Init(), Vertices can be added in later
+	 */
 	BS_Polygon();
 
 	/**
-		@brief Copy-Constructor
-	*/
-	BS_Polygon(const BS_Polygon& Other);
+	 * Copy constructor
+	 */
+	BS_Polygon(const BS_Polygon &Other);
 
 	/**
-		@brief Erstellt ein Polygon anhand persistierter Daten.
-	*/
-	BS_Polygon(BS_InputPersistenceBlock & Reader);
+	 * Creates a polygon using persisted data
+	 */
+	BS_Polygon(BS_InputPersistenceBlock &Reader);
 
 	/**
-		@brief Erzeugt ein Objekt vom Typ #BS_Polygon und ordnet ihm Vertecies zu.
-		@param VertexCount die Anzahl der Vertecies im Vertex Array.
-		@param Vertecies ein Array, das Objekte vom Typ BS_Vertex enthält, die die Vertecies des Polygons darstellen.
-		@remark Die Vertecies müssen ein nicht selbstüberschneidendes Polygon definieren.
-				Falls das Polygon selbstüberschneidend sein sollte wird ein leeres BS_Polygon Objekt erzeugt.
-	*/
-	BS_Polygon(int VertexCount, const BS_Vertex* Vertecies);
+	 * Creaes an object of type #BS_Polygon, and assigns Vertices to it
+	 * @param VertexCount		The number of vertices being passed
+	 * @param Vertecies			An array of BS_Vertex objects representing the vertices in the polygon.
+	 * @remark					The Vertecies that define a polygon must not have any self-intersections.
+	 * If the polygon does have self-intersections, then an empty polygon object is created.
+	 */
+	BS_Polygon(int VertexCount, const BS_Vertex *Vertecies);
 
 	/**
-		@brief Löscht das BS_Polygon Objekt.
-	*/
+	 * Deletes the BS_Polygon object
+	 */
 	virtual ~BS_Polygon();
 
 	/**
-		@brief Initialisiert das BS_Polygon mit einer Liste von Vertecies.
-
-		Die Vertecies müssen ein nicht selbstüberschneidendes Polygon definieren.
-		Es kann auch einem Polygon, welches bereits Vertecies enthält, mit einer neue Vertexliste initialisiert werden, dabei gehen die
-		alten Vertecies verloren.
-
-		@param VertexCount die Anzahl der Vertecies im Vertecies Array.
-		@param Vertecies ein Array, das Objekte vom Typ BS_Vertex enthält, die die Vertecies des Polygons darstellen.
-		@return Gibt false zurück, falls die Vertecies ein selbstüberschneidendes Polygon definiert haben.
-				In diesem Fall wird das Objekt nicht initialisiert.
-	*/
-	bool Init(int VertexCount, const BS_Vertex* Vertecies);
-
-	//@{
-	/** @name Sondierende Methoden */
+	 * Initialises the BS_Polygon with a list of Vertecies.
+	 *
+	 * The Vertices need to define a polygon must not have self-intersections.
+	 * If a polygon already has verticies, this will re-initialise it with the new list.
+	 *
+	 * @param VertexCount		The number of vertices being passed
+	 * @param Vertecies			An array of BS_Vertex objects representing the vertices in the polygon.
+	 * @return					Returns false if the Vertecies have self-intersections. In this case,
+	 * the object is not initialised.
+	 */
+	bool Init(int VertexCount, const BS_Vertex *Vertecies);
+
+	//
+	// ** Exploratory methods **
+	//
 	
 	/**
-		@brief Überprüft, ob die Vertecies des Polygons im Uhrzeigersinn angeordnet sind.
-		@return Gibt true zurück, wenn die Vertecies des Polygons im Uhrzeigersinn angeordnet sind oder Koplanar sind.<br>
-				Gibt false zurück, wenn die Vertecies des Polygons entgegen dem Uhrzeigersinn angeordnet sind.
-		@remark Diese Methode gibt nur ein sinnvolles Ergebnis zurück, wenn das Polygon mindestens 3 Vertecies hat.
-	*/
+	 * Checks whether the Vertecies of the polygon are arranged in a clockwise direction.
+	 * @return					Returns true if the Vertecies of the polygon are arranged clockwise or co-planar.
+	 * Returns false if the Vertecies of the polygon are arrange counter-clockwise.
+	 * @remark					This method only returns a meaningful result if the polygon has at least three Vertecies.
+	 */
 	bool IsCW() const;
 
 	/**
-		@brief Überprüft, ob die Vertecies des Polygons entgegen dem Uhrzeigersinn angeordnet sind.
-		@return Gibt true zurück, wenn die Vertecies des Polygons entgegen dem Uhrzeigersinn angeordnet sind.<br>
-				Gibt false zurück, wenn die Vertecies des Polygons im Uhrzeigersinn angeordnet sind oder Koplanar sind.
-		@remark Diese Methode gibt nur ein sinnvolles Ergebnis zurück, wenn das Polygon mindestens 3 Vertecies hat.
-				
-	*/
+	 * Checks whether the Vertices of the polygon are arranged in a counter-clockwise direction.
+	 * @return					Returns true if the Vertecies of the polygon are arranged counter-clockwise.
+	 * Returns false if the Vertecies of the polygon are arranged clockwise or co-planar.
+	 * @remark					This method only returns a meaningful result if the polygon has at least three Vertecies.
+	 */
 	bool IsCCW() const;
 
 	/**
-		@brief Überprüft, ob das Polygon konvex ist.
-		@return Gibt true zurück, wenn das Polygon konvex ist.<br>
-				Gibt false zurück, wenn das Polygon konkav ist.
-		@remark Diese Methode gibt nur ein sinnvolles Ergebnis zurück, wenn das Polygon mindestens 3 Vertecies hat.
-	*/
+	 * Checks whether the polygon is convex.
+	 * @return					Returns true if the polygon is convex. Returns false if the polygon is concave.
+	 * @remark					This method only returns a meaningful result if the polygon has at least three Vertecies.
+	 */
 	bool IsConvex() const;
 
 	/** 
-		@brief Überprüft, ob das Polygon konkav ist.
-		@return Gibt true zurück, wenn das Polygon konkav ist.<br>
-				Gibt false zurück, wenn das Polygon konvex ist.
-		@remark Diese Methode gibt nur ein sinnvolles Ergebnis zurück, wenn das Polygon mindestens 3 Vertecies hat.
-	*/
+	 * Checks whether the polygon is concave.
+ 	 * @return					Returns true if the polygon is concave. Returns false if the polygon is convex.
+	 * @remark					This method only returns a meaningful result if the polygon has at least three Vertecies.
+	 */
 	bool IsConcave() const;
 
 	/**
-		@brief Überprüft, ob sich ein Punkt innerhalb des Polygons befindet.
-		@param Vertex ein Vertex, mit den Koordinaten des zu testenden Punktes.
-		@param BorderBelongsToPolygon gibt an, ob der Rand des Polygons als Teil des Polygons betrachtet werden soll.<br>
-									  Der Standardwert ist true.
-		@return Gibt true zurück, wenn sich der Punkt innerhalb des Polygons befindet.<br>
-				Gibt false zurück, wenn sich der Punkt außerhalb des Polygons befindet.
-	*/
-	bool IsPointInPolygon(const BS_Vertex& Vertex, bool BorderBelongsToPolygon = true) const;
+	 * Checks whether a point is inside the polygon
+	 * @param Vertex			A Vertex with the co-ordinates of the point to be tested.
+	 * @param BorderBelongsToPolygon	Specifies whether the edge of the polygon should be considered
+	 * @return					Returns true if the point is inside the polygon, false if it is outside.
+	 */
+	bool IsPointInPolygon(const BS_Vertex &Vertex, bool BorderBelongsToPolygon = true) const;
 
 	/**
-		@brief Überprüft, ob sich ein Punkt innerhalb des Polygons befindet.
-		@param X die Position des Punktes auf der X-Achse.
-		@param Y die Position des Punktes auf der Y-Achse.
-		@param BorderBelongsToPolygon gibt an, ob der Rand des Polygons als Teil des Polygons betrachtet werden soll.<br>
-									  Der Standardwert ist true.
-		@return Gibt true zurück, wenn sich der Punkt innerhalb des Polygons befindet.<br>
-				Gibt false zurück, wenn sich der Punkt außerhalb des Polygons befindet.
-	*/
+	 * Checks whether a point is inside the polygon
+	 * @param X					The X position of the point
+	 * @param Y					The Y position of the point
+	 * @param BorderBelongsToPolygon	Specifies whether the edge of the polygon should be considered
+	 * @return					Returns true if the point is inside the polygon, false if it is outside.
+	 */
 	bool IsPointInPolygon(int X, int Y, bool BorderBelongsToPolygon = true) const;
 
 	/**
-		@brief Gibt den Schwerpunkt des Polygons zurück.
-	*/
+	 * Returns the focus/centroid of the polygon
+	 */
 	BS_Vertex GetCentroid() const;
 
-	// Rand gehört zum Polygon
-	// Polygon muss CW sein
-	bool IsLineInterior(const BS_Vertex & a, const BS_Vertex & b) const;
-	// Rand gehört nicht zum Polygon
-	// Polygon muss CW sein
-	bool IsLineExterior(const BS_Vertex & a, const BS_Vertex & b) const;
-
-	//@}
+	// Edge belongs to the polygon
+	// Polygon must be CW
+	bool IsLineInterior(const BS_Vertex &a, const BS_Vertex &b) const;
+	// Edge does not belong to the polygon
+	// Polygon must be CW
+	bool IsLineExterior(const BS_Vertex &a, const BS_Vertex &b) const;
 
-	//@{
-	/** @name Manipulierende Methoden */
+	//
+	// Manipulation methods
+	//
 
 	/**
-		@brief Stellt sicher, dass die Vertecies des Polygons im Uhrzeigersinn angeordnet sind.
-	*/
+	 * Ensures that the Vertecies of the polygon are arranged in a clockwise direction
+	 */
 	void EnsureCWOrder();
 
 	/**
-		@brief Stellt sicher, dass die Vertecies des Polygons entgegen dem Uhrzeigersinn angeordnet sind.
-	*/
+	 * Ensures that the Vertecies of the polygon are arranged in a counter-clockwise direction
+	 */
 	void EnsureCCWOrder();
 
 	/**
-		@brief Kehrt die Reihenfolge der Vertecies um.
-	*/
+	 * Reverses the Vertecies order.
+	 */
 	void ReverseVertexOrder();
 
 	/**
-		@brief Verschiebt das Polygon.
-		@param Delta das Vertex um das das Polygon verschoben werden soll.
-	*/
-	void operator+=(const BS_Vertex& Delta);
+	 * Moves the polygon.
+	 * @param Delta				The vertex around the polygon to be moved.
+	 */
+	void operator+=(const BS_Vertex &Delta);
 
-	//@}
+	//
+	//------------------
+	//
 
-	/// Gibt die Anzahl an Vertecies im Vertecies-Array an.
+	/// Specifies the number of Vertecies in the Vertecies array.
 	int VertexCount;
-	/// Enthält die Vertecies des Polygons.
-	BS_Vertex* Vertecies;
+	/// COntains the Vertecies of the polygon
+	BS_Vertex *Vertecies;
 
-	virtual bool Persist(BS_OutputPersistenceBlock & Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
+	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
 
 private:
 	bool m_IsCW;
@@ -208,60 +203,64 @@ private:
 	BS_Vertex m_Centroid;
 	
 	/**
-		@brief Berechnet den Schwerpunkt des Polygons.
-	*/
+	 * Computes the centroid of the polygon.
+	 */
 	BS_Vertex ComputeCentroid() const;
 
 	/**
-		@brief Bestimmt wie die Vertecies des Polygon angeordnet sind.
-		@return Gibt true zurück, wenn die Vertecies im Uhrzeigersinn angeordnet sind, ansonsten false.
-	*/
+	 * Determines how the Vertecies of the polygon are arranged.
+	 * @return					Returns true if the Vertecies are arranged in a clockwise
+	 * direction, otherwise false.
+	 */
 	bool ComputeIsCW() const;
 
 	/**
-		@brief Bestimmt ob das Polygon Konvex oder Konkav ist.
-		@return Gibt true zurück, wenn das Polygon Konvex ist, ansonsten false.
-	*/
+	 * Determines whether the polygon is convex or concave.
+	 * @return					Returns true if the polygon is convex, otherwise false.
+	 */
 	bool ComputeIsConvex() const;
 
 	/**
-		@brief Berechnet das Kreuzprodukt dreier Vertecies.
-		@param V1 das erste Vertex
-		@param V2 des zweite Vertex
-		@param V3 das dritte Vertex
-		@return Gibt das Kreuzprodukt der drei Vertecies zurück.
-		@todo Diese Methode sollte an geeigneter Stelle in die BS_Vertex Klasse integriert werden.
-	*/
-	int CrossProduct(const BS_Vertex& V1, const BS_Vertex& V2, const BS_Vertex& V3) const;
+	 * Calculates the cross product of three Vertecies
+	 * @param V1				The first Vertex
+	 * @param V2				The second Vertex
+	 * @param V3				The third Vertex
+	 * @return					Returns the cross-product of the three vertecies
+	 * @todo					This method would be better as a method of the BS_Vertex class
+	 */
+	int CrossProduct(const BS_Vertex &V1, const BS_Vertex &V2, const BS_Vertex &V3) const;
 
 	/**
-		@brief Berechnet des Skalarprodukt der beiden von drei Vertecies aufgespannten Vektoren.
-
-		Die Vektoren werden von V2 -> V1 und V2 -> V3 aufgespannt.
-		
-		@param V1 das erste Vertex
-		@param V2 des zweite Vertex
-		@param V3 das dritte Vertex
-		@return Gibt das Skalarprodukt der drei Vertecies zurück.
-		@todo Diese Methode sollte an geeigneter Stelle in die BS_Vertex Klasse integriert werden.
-	*/
-	int DotProduct(const BS_Vertex& V1, const BS_Vertex& V2, const BS_Vertex& V3) const;
+	 * Computes the scalar product of two vectors spanning three vertecies
+	 *
+	 * The vectors are spanned by V2->V1 and V2->V3
+	 *
+	 * @param V1				The first Vertex
+	 * @param V2				The second Vertex
+	 * @param V3				The third Vertex
+	 * @return					Returns the dot product of the three Vertecies.
+	 * @todo					This method would be better as a method of the BS_Vertex class
+	 */
+	int DotProduct(const BS_Vertex &V1, const BS_Vertex &V2, const BS_Vertex &V3) const;
 
 	/**
-		@brief Überprüft ob das Polygon selbstüberschneidend ist.
-		@return Gibt true zurück, wenn das Polygon selbstüberschneidend ist.<br>
-				Gibt false zurück, wenn das Polygon nicht selbstüberschneidend ist.
-	*/
+	 * Checks whether the polygon is self-intersecting
+	 * @return					Returns true if the polygon is self-intersecting.
+	 * Returns false if the polygon is not self-intersecting.
+	 */
 	bool CheckForSelfIntersection() const;
 
 	/**
-		@brief Findet das Vertex des Polygons das am weitesten rechts unten liegt und gibt dessen Index im Vertex-Array zurück.
-		@return Gibt den Index des Vertex zurück das am weiteesten rechts unten liegt.<br>
-				Gibt -1 zurück, wenn die Vertexliste leer ist.
-	*/
+	 * Find the vertex of the polygon that is located below the right-most point,
+	 * and returns it's index in the vertex array.
+	 * @return					Returns the index of the vertex at the bottom-right of the polygon.
+	 * Returns -1 if the vertex list is empty.
+	 */
 	int FindLRVertexIndex() const;
 
-	bool IsLineInCone(int StartVertexIndex, const BS_Vertex & EndVertex, bool IncludeEdges) const;
+	bool IsLineInCone(int StartVertexIndex, const BS_Vertex &EndVertex, bool IncludeEdges) const;
 };
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/math/rect.h b/engines/sword25/math/rect.h
index a39c4de25f..849839aeec 100644
--- a/engines/sword25/math/rect.h
+++ b/engines/sword25/math/rect.h
@@ -36,278 +36,57 @@
 #define SWORD25_RECT_H
 
 // Includes
+#include "common/rect.h"
 #include "sword25/kernel/common.h"
 #include "sword25/math/vertex.h"
 
-// Klassendefinition
+namespace Sword25 {
+
+// Class definitions
+
 /**
-	@brief Diese Klasse beschreibt ein Rechteck und einige nützliche Operationen auf Rechtecken.
+ * Rect class. Currently this encapsultes the ScummVM Rect class. Eventually all usage of this
+ * class should be replaced with Common::Rect directly.
 */
-class BS_Rect
-{
+class BS_Rect: public Common::Rect {
 public:
-	/// Das linke Extrem des Rechteckes.
-	int	left;
-	/// Das obere Extrem des Rechteckes.
-	int top;
-	/// Das rechte Extrem des Rechteckes + 1.
-	int right;
-	/// Das untere Extrem des Rechteckes + 1.
-	int bottom;
+	BS_Rect() : Common::Rect() {}
+	BS_Rect(int16 w, int16 h) : Common::Rect(w, h) {}
+	BS_Rect(int16 x1, int16 y1, int16 x2, int16 y2) : Common::Rect(x1, y1, x2, y2) {}
 
-	/**
-		@brief Konstruktor, der alle Werte des Rechteckes mit 0 initialisiert.
-	*/
-	BS_Rect()
-	{
-		left = 0;
-		top = 0;
-		right = 0;
-		bottom = 0;
-	}
-	/**
-		@brief Konstruktor, der das Rechteck mit den übergebenen Werten initialisiert.
-		@param left das linke Extrem des Rechteckes
-		@param top das obere Extrem des Rechteckes
-		@param right das rechte Extrem des Rechteckes + 1
-		@param bottom des untere Extrem des Rechteckes + 1
-	*/
-	BS_Rect(int left_, int top_, int right_, int bottom_)
-	{
-		this->left = left_;
-		this->top = top_;
-		this->right = right_;
-		this->bottom = bottom_;
-	}
-	/**
-		@brief Verschiebt das Rechteck.
-		@param DeltaX der Wert um den das Rechteck auf der X-Achse verschoben werden soll.
-		@param DeltaY der Wert um den das Rechteck auf der Y-Achse verschoben werden soll.
-	*/
-	void Move(int DeltaX, int DeltaY)
-	{
-		left += DeltaX;
-		right += DeltaX;
-		top += DeltaY;
-		bottom += DeltaY;
-	}
-	/**
-		@brief Testet ob sich zwei Rechtecke schneiden.
-		@return Gibt true zurück, wenn sich die Rechtecke schneiden.
-	*/
-	bool DoesIntersect(const BS_Rect& Rect) const
-	{
-		int Dist;
-		
-		// Intersektion auf der X-Achse
-		Dist = left - Rect.left;
-		if (Dist < 0)
-		{
-			Dist = abs(Dist);
-			
-			// Schneiden sich die Rechtecke nicht auf der X-Achse, so schneiden sie sich gar nicht
-			if (Dist >= GetWidth())
-				return false;
-		}
-		else
-		{
-			// Schneiden sich die Rechtecke nicht auf der X-Achse, so schneiden sie sich gar nicht
-			if (Dist >= Rect.right - Rect.left)
-				return false;
-		}
-		
-		// Intersektion auf der Y-Achse
-		Dist = top - Rect.top;
-		if (Dist < 0)
-		{
-			Dist = abs(Dist);
-			
-			// Schneiden sich die Rechtecke nicht auf der Y-Achse, so schneiden sie sich gar nicht
-			if (Dist >= GetHeight())
-				return false;
-		}
-		else
-		{
-			// Schneiden sich die Rechtecke nicht auf der Y-Achse, so schneiden sie sich gar nicht
-			if (Dist >= Rect.bottom - Rect.top)
-				return false;
-		}
-		
-		return true;
-	}
+	void Move(int DeltaX, int DeltaY) { translate(DeltaX, DeltaY); }
 
-	/**
-		@brief Bildet den Durchschnitt zweier Rechtecke
-		@param Rect das Rechteck, dass mit dem Objekt geschnitter werden soll.
-		@param Result das Rechteck, dass das Ergebnisrechteck enthalten soll.
-		@return Gibt false zurück, falls Result undefiniert ist.<br>
-				Dies ist der Fall, wenn sich die Rechtecke nicht schneiden.
-	*/
-	bool Intersect(const BS_Rect& Rect, BS_Rect& Result) const
-	{
-		int Dist;
-		
-		// Intersektion auf der X-Achse
-		Dist = left - Rect.left;
-		if (Dist < 0)
-		{
-			Dist = abs(Dist);
-			
-			// Schneiden sich die Rechtecke nicht auf der X-Achse, so schneiden sie sich gar nicht
-			if (Dist >= GetWidth())
-			{
-				Result = BS_Rect(0, 0, 0, 0);
-				return false;
-			}
-			
-			// Die Abmessungen des Rect auf der X-Achse berechnen
-			Result.left = Rect.left;
-		}
-		else
-		{
-			// Schneiden sich die Rechtecke nicht auf der X-Achse, so schneiden sie sich gar nicht
-			if (Dist >= Rect.right - Rect.left)
-			{
-				Result = BS_Rect(0, 0, 0, 0);
-				return false;
-			}
-			
-			// Die Abmessungen des Rect auf der X-Achse berechnen
-			Result.left = left;
-		}
-		Result.right = right < Rect.right ? right : Rect.right;
-		
-		// Intersektion auf der Y-Achse
-		Dist = top - Rect.top;
-		if (Dist < 0)
-		{
-			Dist = abs(Dist);
-			
-			// Schneiden sich die Rechtecke nicht auf der Y-Achse, so schneiden sie sich gar nicht
-			if (Dist >= GetHeight())
-			{
-				Result = BS_Rect(0, 0, 0, 0);
-				return false;
-			}
-			
-			// Die Abmessungen des Rect auf der Y-Achse berechnen
-			Result.top = Rect.top;
-		}
-		else
-		{
-			// Schneiden sich die Rechtecke nicht auf der Y-Achse, so schneiden sie sich gar nicht
-			if (Dist >= Rect.bottom - Rect.top)
-			{
-				Result = BS_Rect(0, 0, 0, 0);
-				return false;
-			}
-			
-			// Die Abmessungen des Rect auf der Y-Achse berechnen
-			Result.top = top;
-		}
-		Result.bottom = bottom < Rect.bottom ? bottom : Rect.bottom;
-		
-		return true;
-	}
-	/**
-		@brief Bildet die Bounding-Box zweier Rechtecke.
-		@param Rect das Rechteck, dass mit dem Objekt verbunden werden soll.
-		@remark Das Ergebnis ist nicht ein Join in eigentlichen Sinne, sondern vielmehr die Bounding-Box um die Beiden
-				Rechtecke.
-	*/
-	void Join(const BS_Rect& Rect, BS_Rect& Result) const
-	{
-		Result.left = left < Rect.left ? left : Rect.left;
-		Result.top = top < Rect.top ? top : Rect.top;
-		Result.right = right > Rect.right ? right : Rect.right;
-		Result.bottom = bottom > Rect.bottom ? bottom : Rect.bottom;
-		return;
-	}
-	/**
-		@brief Gibt die Breite des Rechteckes zurück.
-		@return Die Breite des Rechteckes.
-	*/
-	int GetWidth() const
-	{
-		return right - left;
-	}
-	/**
-		@brief Gibt die Höhe des Rechteckes zurück.
-		@return Die Höhe des Rechteckes.
-	*/
-	int GetHeight() const
-	{
-		return bottom - top;
-	}
-	/** @brief Gibt den Flächeninhalt des Rechteckes zurück.
-		@return Der Flächeninhalt des Rechteckes.
-	*/
-	int GetArea() const
-	{
-		return GetWidth() * GetHeight();
-	}
-	/**
-		@brief Vergleichsoperator zum Überprüfen der Gleichheit zweier BS_Rect Objekte.
-		@return Gibt true zurück, wenn die Objekte die gleichen Werte haben, ansonsten false.
-	*/
-	bool operator== (const BS_Rect& rhs)
-	{
-		return (left == rhs.left) &&
-			   (top == rhs.top) &&
-			   (right == rhs.right) &&
-			   (bottom == rhs.bottom);
-	}
-	/**
-		@brief Vergleichsoperator zum Überprüfen der Ungleichheit zweier BS_Rect Objekte.
-		@return Gibt true zurück, wenn die Objekte ungleiche Werte haben, ansonsten false.
-	*/
-	bool operator!= (const BS_Rect& rhs)
-	{
-		return !(*this == rhs);
-	}
-	/**
-		@brief Überprüft, ob das Objekt einen gültigen Zustand hat.
-		@return Gibt false zurück, wenn das Objekt einen ungültigen Zustand hat.
-	*/
-	bool IsValid() const
-	{
-		if (left < right && top < bottom) return true;
-		return false;
-	}
-	/**
-		@brief Testet, ob sich ein Vertex innerhalb des Rechteckes befindet.
-		@param Vertex das Vertex, dass mit dem Rechteckes getestet werden soll
-		@return Gibt true zurück, wenn sich das Vertex innerhalb des Rechteckes befindet.<br>
-				Gibt false zurück, wenn sich das Vertex außerhalb des Rechteckes befindet.
-	*/
-	bool IsPointInRect(const BS_Vertex& Vertex) const
-	{
-		if (Vertex.X >= left && Vertex.X < right &&
-			Vertex.Y >= top && Vertex.Y < bottom)
-			return true;
-		return false;
-	}
-	/**
-		@brief Testet, ob sich ein Punkt innerhalb des Rechteckes befindet.
-		@param X die Position des Punktes auf der X-Achse.
-		@param Y die Position des Punktes auf der Y-Achse.
-		@return Gibt true zurück, wenn sich der Punkt innerhalb des Rechteckes befindet.<br>
-				Gibt false zurück, wenn sich der Punkt außerhalb des Rechteckes befindet.
-	*/
-	bool IsPointInRect(int X, int Y) const
-	{
-		return IsPointInRect(BS_Vertex(X, Y));
+	bool DoesIntersect(const BS_Rect &Rect) const { return intersects(Rect); }
+
+	bool Intersect(const BS_Rect &Rect, BS_Rect &Result) const {
+		Result = Rect;
+		Result.clip(*this);
 	}
-	/**
-		@brief Testet, ob ein andere Rechteck komplett in den Rechteck enthalten ist.
-		@param OtherRect das zu testende Rechteck
-		@brief Gibt true zurück, wenn sich das andere Rechteck komplett im Rechteck enthalten ist, ansonsten false.
-	*/
-	bool ContainsRect(const BS_Rect & OtherRect) const
-	{
-		return	IsPointInRect(OtherRect.left, OtherRect.top) &&
-				IsPointInRect(OtherRect.right - 1, OtherRect.bottom - 1);
+
+	void Join(const BS_Rect &Rect, BS_Rect &Result) const {
+		Result = Rect;
+		Result.extend(*this);
 	}
+
+	int GetWidth() const { return width(); }
+
+	int GetHeight() const { return height(); }
+
+	int GetArea() const { return width() * height(); }
+
+	bool operator==(const BS_Rect &rhs) const { return equals(rhs); }
+
+	bool operator!= (const BS_Rect &rhs) const { return !equals(rhs); }
+
+	bool IsValid() const { return isValidRect(); }
+
+	bool IsPointInRect(const BS_Vertex &Vertex) const { return contains(Vertex.X, Vertex.Y); }
+
+	bool IsPointInRect(int X, int Y) const { return contains(X, Y); }
+
+	bool ContainsRect(const BS_Rect &OtherRect) const { return contains(OtherRect); }
 };
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/math/region.cpp b/engines/sword25/math/region.cpp
index 323164435f..4999a4340e 100644
--- a/engines/sword25/math/region.cpp
+++ b/engines/sword25/math/region.cpp
@@ -41,29 +41,27 @@
 
 #define BS_LOG_PREFIX "REGION"
 
-// Konstruktion/Destruktion
+namespace Sword25 {
+
+// Constructor / Destructor
 // ------------------------
 
-BS_Region::BS_Region() : m_Valid(false), m_Type(RT_REGION)
-{
+BS_Region::BS_Region() : m_Valid(false), m_Type(RT_REGION) {
 	BS_RegionRegistry::GetInstance().RegisterObject(this);
 }
 
 // -----------------------------------------------------------------------------
 
-BS_Region::BS_Region(BS_InputPersistenceBlock & Reader, unsigned int Handle) : m_Valid(false), m_Type(RT_REGION)
-{
+BS_Region::BS_Region(BS_InputPersistenceBlock &Reader, unsigned int Handle) : m_Valid(false), m_Type(RT_REGION) {
 	BS_RegionRegistry::GetInstance().RegisterObject(this, Handle);
 	Unpersist(Reader);
 }
 
 // -----------------------------------------------------------------------------
 
-unsigned int BS_Region::Create(REGION_TYPE Type)
-{
+unsigned int BS_Region::Create(REGION_TYPE Type) {
 	BS_Region * RegionPtr;
-	switch (Type)
-	{
+	switch (Type) {
 		case RT_REGION:
 			RegionPtr = new BS_Region();
 			break;
@@ -81,24 +79,18 @@ unsigned int BS_Region::Create(REGION_TYPE Type)
 
 // -----------------------------------------------------------------------------
 
-unsigned int BS_Region::Create(BS_InputPersistenceBlock & Reader, unsigned int Handle)
-{
-	// Typ einlesen.
+unsigned int BS_Region::Create(BS_InputPersistenceBlock & Reader, unsigned int Handle) {
+	// Read type
 	unsigned int Type;
 	Reader.Read(Type);
 
-	// Je nach Typ ein neues BS_Region oder BS_WalkRegion Objekt erstellen.
+	// Depending on the type, create a new BS_Region or BS_WalkRegion object
 	BS_Region * RegionPtr;
-	if (Type == RT_REGION)
-	{
+	if (Type == RT_REGION) {
 		RegionPtr = new BS_Region(Reader, Handle);
-	}
-	else if (Type == RT_WALKREGION)
-	{
+	} else if (Type == RT_WALKREGION) {
 		RegionPtr = new BS_WalkRegion(Reader, Handle);
-	}
-	else
-	{
+	} else {
 		BS_ASSERT(false);
 	}
 
@@ -107,37 +99,33 @@ unsigned int BS_Region::Create(BS_InputPersistenceBlock & Reader, unsigned int H
 
 // -----------------------------------------------------------------------------
 
-BS_Region::~BS_Region()
-{
+BS_Region::~BS_Region() {
 	BS_RegionRegistry::GetInstance().DeregisterObject(this);
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_Region::Init(const BS_Polygon& Contour, const std::vector<BS_Polygon>* pHoles)
-{
-	// Objektzustand zurücksetzen.
+bool BS_Region::Init(const BS_Polygon& Contour, const Common::Array<BS_Polygon> *pHoles) {
+	// Reset object state
 	m_Valid = false;
 	m_Position = BS_Vertex(0, 0);
 	m_Polygons.clear();
 
-	// Genügend Platz für Kontur und Löcher im Polygon-Vektor reservieren
+	// Reserve sufficient  space for countour and holes in the polygon list
 	if (pHoles)
 		m_Polygons.reserve(1 + pHoles->size());
 	else
 		m_Polygons.reserve(1);
 
-	// Kontur an die erste Position im Polygon-Vektor kopieren
+	// The first polygon will be the contour
 	m_Polygons.push_back(BS_Polygon());
 	m_Polygons[0].Init(Contour.VertexCount, Contour.Vertecies);
-	// Sicherstellen, dass die Vertecies der Contour im Uhrzeigersinn angeordnet sind.
+	// Make sure that the Vertecies in the Contour are arranged in a clockwise direction
 	m_Polygons[0].EnsureCWOrder();
 
-	// Übergebene Lochpolygone an die folgenden Positionen im Polygon-Vektor kopieren
-	if (pHoles)
-	{
-		for (unsigned int i = 0; i< pHoles->size(); ++i)
-		{
+	// Place the hole polygons in the following positions
+	if (pHoles) {
+		for (unsigned int i = 0; i< pHoles->size(); ++i) {
 			m_Polygons.push_back(BS_Polygon());
 			m_Polygons[i + 1].Init((*pHoles)[i].VertexCount, (*pHoles)[i].Vertecies);
 			m_Polygons[i + 1].EnsureCWOrder();
@@ -145,7 +133,7 @@ bool BS_Region::Init(const BS_Polygon& Contour, const std::vector<BS_Polygon>* p
 	}
 
 
-	// Bounding-Box initialisieren.
+	// Initialise bounding box
 	UpdateBoundingBox();
 
 	m_Valid = true;
@@ -154,17 +142,14 @@ bool BS_Region::Init(const BS_Polygon& Contour, const std::vector<BS_Polygon>* p
 
 // -----------------------------------------------------------------------------
 
-void BS_Region::UpdateBoundingBox()
-{
-	if (m_Polygons[0].VertexCount)
-	{
+void BS_Region::UpdateBoundingBox() {
+	if (m_Polygons[0].VertexCount) {
 		int MinX = m_Polygons[0].Vertecies[0].X;
 		int MaxX = m_Polygons[0].Vertecies[0].X;
 		int MinY = m_Polygons[0].Vertecies[0].Y;
 		int MaxY = m_Polygons[0].Vertecies[0].Y;
 
-		for (int i = 1; i < m_Polygons[0].VertexCount; i++)
-		{
+		for (int i = 1; i < m_Polygons[0].VertexCount; i++) {
 			if (m_Polygons[0].Vertecies[i].X < MinX) MinX = m_Polygons[0].Vertecies[i].X;
 			else if (m_Polygons[0].Vertecies[i].X > MaxX) MaxX = m_Polygons[0].Vertecies[i].X;
 			if (m_Polygons[0].Vertecies[i].Y < MinY) MinY = m_Polygons[0].Vertecies[i].Y;
@@ -175,55 +160,47 @@ void BS_Region::UpdateBoundingBox()
 	}
 }
 
-// Positionsänderungen
-// -------------------
+// Position Changes
+// ----------------
 
-void BS_Region::SetPos(int X, int Y)
-{
-	// Unterschied zwischen alter und neuer Position berechnen.
+void BS_Region::SetPos(int X, int Y) {
+	// Calculate the difference between the old and new position
 	BS_Vertex Delta(X - m_Position.X, Y - m_Position.Y);
 
-	// Neue Position im internen Zustand merken.
+	// Save the new position
 	m_Position = BS_Vertex(X, Y);
 
-	// Alle Vertecies verschieben.
-	for (unsigned int i = 0; i < m_Polygons.size(); ++i)
-	{
+	// Move all the vertecies
+	for (unsigned int i = 0; i < m_Polygons.size(); ++i) {
 		m_Polygons[i] += Delta;
 	}
 
-	// Bounding-Box aktualisieren
+	// Update the bounding box
 	UpdateBoundingBox();
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_Region::SetPosX(int X)
-{
+void BS_Region::SetPosX(int X) {
 	SetPos(X, m_Position.Y);
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_Region::SetPosY(int Y)
-{
+void BS_Region::SetPosY(int Y) {
 	SetPos(m_Position.X, Y);
 }
 
-// Punkt-Region Tests
+// Point-Region Tests
 // ------------------
 
-bool BS_Region::IsPointInRegion(int X, int Y) const
-{
-	// Testen, ob der Punkt in der Bounding-Box ist.
-	if (m_BoundingBox.IsPointInRect(X, Y))
-	{
-		// Testen, ob der Punkt in der Contour ist.
-		if (m_Polygons[0].IsPointInPolygon(X, Y, true))
-		{
-			// Testen, ob der Punkt in einem Loch ist.
-			for (unsigned int i = 1; i < m_Polygons.size(); i++)
-			{
+bool BS_Region::IsPointInRegion(int X, int Y) const {
+	// Test whether the point is in the bounding box
+	if (m_BoundingBox.IsPointInRect(X, Y)) {
+		// Test whether the point is in the contour
+		if (m_Polygons[0].IsPointInPolygon(X, Y, true)) {
+			// Test whether the point is in a hole
+			for (unsigned int i = 1; i < m_Polygons.size(); i++) {
 				if (m_Polygons[i].IsPointInPolygon(X,Y, false))
 					return false;
 			}
@@ -237,22 +214,19 @@ bool BS_Region::IsPointInRegion(int X, int Y) const
 
 // -----------------------------------------------------------------------------
 
-bool BS_Region::IsPointInRegion(const BS_Vertex& Vertex) const
-{
+bool BS_Region::IsPointInRegion(const BS_Vertex &Vertex) const {
 	return IsPointInRegion(Vertex.X, Vertex.Y);
 }
 
 // -----------------------------------------------------------------------------
 
-BS_Vertex BS_Region::FindClosestRegionPoint(const BS_Vertex& Point) const
-{
-	// Feststellen, ob sich der Punkt innerhalb eines Loches befindet, falls dies der Fall ist wird der dichteste Punkt am Rand des Loches gesucht
+BS_Vertex BS_Region::FindClosestRegionPoint(const BS_Vertex &Point) const {
+	// Determine whether the point is inside a hole. If that is the case, the closest
+	// point on the edge of the hole is determined
 	int PolygonIdx = 0;
 	{
-		for (unsigned int i = 1; i < m_Polygons.size(); ++i)
-		{
-			if (m_Polygons[i].IsPointInPolygon(Point))
-			{
+		for (unsigned int i = 1; i < m_Polygons.size(); ++i) {
+			if (m_Polygons[i].IsPointInPolygon(Point)) {
 				PolygonIdx = i;
 				break;
 			}
@@ -263,30 +237,27 @@ BS_Vertex BS_Region::FindClosestRegionPoint(const BS_Vertex& Point) const
 
 	BS_ASSERT(Polygon.VertexCount > 1);
 
-	// Für jede Linie des Polygons wird der Punkt berechnet, der dem übergebenen am nächsten ist.
-	// Der Punkt dieser Menge mit dem gerigsten Abstand zum übergebenen Punkt ist das Ergebnis.
+	// For each line of the polygon, calculate the point that is cloest to the given point
+	// The point of this set with the smallest distance to the given point is the result.
 	BS_Vertex ClosestVertex = FindClosestPointOnLine(Polygon.Vertecies[0], Polygon.Vertecies[1], Point);
 	int ClosestVertexDistance2 = ClosestVertex.Distance(Point);
-	for (int i = 1; i < Polygon.VertexCount; ++i)
-	{
+	for (int i = 1; i < Polygon.VertexCount; ++i) {
 		int j = (i + 1) % Polygon.VertexCount;
 
 		BS_Vertex CurVertex = FindClosestPointOnLine(Polygon.Vertecies[i], Polygon.Vertecies[j], Point);
-		if (CurVertex.Distance(Point) < ClosestVertexDistance2)
-		{
+		if (CurVertex.Distance(Point) < ClosestVertexDistance2) {
 			ClosestVertex = CurVertex;
 			ClosestVertexDistance2 = CurVertex.Distance(Point);
 		}
 	}
 
-	// Feststellen, ob der konstruierte Punkt wirklich von der Methode IsPointInRegion als innerhalb der Region liegend erkannt wird.
-	// Dies muss nicht so sein, da aufgrund von Rundungsfehlern am Rand der Polygone Ungenauigkeiten auftreten.
+	// Determine whether the point is really within the region. This must not be so, as a result of rounding
+	// errors can occur at the edge of polygons
 	if (IsPointInRegion(ClosestVertex))
 		return ClosestVertex;
-	else
-	{
-		// Es wird versucht einen Punkt innerhalb der Region zu konstruieren indem 8 Punkte getestet werden, die in unmittelbarer Umgebung des
-		// berechneten Punktes liegen
+	else {
+		// Try to construct a point within the region - 8 points are tested in the immediate vacinity
+		// of the point
 		if (IsPointInRegion(ClosestVertex + BS_Vertex(-2, -2)))
 			return ClosestVertex + BS_Vertex(-2, -2);
 		else if (IsPointInRegion(ClosestVertex + BS_Vertex(0, -2)))
@@ -304,30 +275,27 @@ BS_Vertex BS_Region::FindClosestRegionPoint(const BS_Vertex& Point) const
 		else if (IsPointInRegion(ClosestVertex + BS_Vertex(2, 2)))
 			return ClosestVertex + BS_Vertex(2, 2);
 
-		// Falls auch auf diese Weise kein Punkt gefunden werden konnte, der innerhalb der Region liegt wird das Vertex genommen, welches am
-		// nächst an dem Punkt liegt.
+		// If no point could be found that way that lies within the region, find the next point
 		ClosestVertex = Polygon.Vertecies[0];
 		int ShortestVertexDistance2 = Polygon.Vertecies[0].Distance2(Point);
 		{
-			for (int i = 1; i < Polygon.VertexCount; i++)
-			{
+			for (int i = 1; i < Polygon.VertexCount; i++) {
 				int CurDistance2 = Polygon.Vertecies[i].Distance2(Point);
-				if (CurDistance2 < ShortestVertexDistance2)
-				{
+				if (CurDistance2 < ShortestVertexDistance2) {
 					ClosestVertex = Polygon.Vertecies[i];
 					ShortestVertexDistance2 = CurDistance2;
 				}
 			}
 		}
-			BS_LOG_WARNINGLN("Clostest vertex forced because edgepoint was outside region.");
-			return ClosestVertex;
+
+		BS_LOG_WARNINGLN("Clostest vertex forced because edgepoint was outside region.");
+		return ClosestVertex;
 	}
 }
 
 // -----------------------------------------------------------------------------
 
-BS_Vertex BS_Region::FindClosestPointOnLine(const BS_Vertex & LineStart, const BS_Vertex & LineEnd, const BS_Vertex Point) const
-{
+BS_Vertex BS_Region::FindClosestPointOnLine(const BS_Vertex &LineStart, const BS_Vertex &LineEnd, const BS_Vertex Point) const {
 	float Vector1X = static_cast<float>(Point.X - LineStart.X);
 	float Vector1Y = static_cast<float>(Point.Y - LineStart.Y);
 	float Vector2X = static_cast<float>(LineEnd.X - LineStart.X);
@@ -347,15 +315,14 @@ BS_Vertex BS_Region::FindClosestPointOnLine(const BS_Vertex & LineStart, const B
 }
 
 // -----------------------------------------------------------------------------
-// Sichtlinie
+// Line of Sight
 // -----------------------------------------------------------------------------
 
-bool BS_Region::IsLineOfSight(const BS_Vertex & a, const BS_Vertex & b) const
-{
+bool BS_Region::IsLineOfSight(const BS_Vertex &a, const BS_Vertex &b) const {
 	BS_ASSERT(m_Polygons.size());
 
-	// Die Linie muss innerhalb des Kontur-Polygons und ausserhalb aller Loch-Polygone sein
-	std::vector<BS_Polygon>::const_iterator iter = m_Polygons.begin();
+	// The line must be within the contour polygon, and outside of any hole polygons
+	Common::Array<BS_Polygon>::const_iterator iter = m_Polygons.begin();
 	if (!(*iter).IsLineInterior(a, b)) return false;
 	for (iter++; iter != m_Polygons.end(); iter++)
 		if (!(*iter).IsLineExterior(a, b)) return false;
@@ -364,11 +331,10 @@ bool BS_Region::IsLineOfSight(const BS_Vertex & a, const BS_Vertex & b) const
 }
 
 // -----------------------------------------------------------------------------
-// Persistenz
+// Persistence
 // -----------------------------------------------------------------------------
 
-bool BS_Region::Persist(BS_OutputPersistenceBlock & Writer)
-{
+bool BS_Region::Persist(BS_OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
 	Writer.Write(static_cast<unsigned int>(m_Type));
@@ -377,9 +343,8 @@ bool BS_Region::Persist(BS_OutputPersistenceBlock & Writer)
 	Writer.Write(m_Position.Y);
 	
 	Writer.Write(m_Polygons.size());
-	std::vector<BS_Polygon>::iterator It = m_Polygons.begin();
-	while (It != m_Polygons.end())
-	{
+	Common::Array<BS_Polygon>::iterator It = m_Polygons.begin();
+	while (It != m_Polygons.end()) {
 		Result &= It->Persist(Writer);
 		++It;
 	}
@@ -394,8 +359,7 @@ bool BS_Region::Persist(BS_OutputPersistenceBlock & Writer)
 
 // -----------------------------------------------------------------------------
 
-bool BS_Region::Unpersist(BS_InputPersistenceBlock & Reader)
-{
+bool BS_Region::Unpersist(BS_InputPersistenceBlock &Reader) {
 	Reader.Read(m_Valid);
 	Reader.Read(m_Position.X);
 	Reader.Read(m_Position.Y);
@@ -403,8 +367,7 @@ bool BS_Region::Unpersist(BS_InputPersistenceBlock & Reader)
 	m_Polygons.clear();
 	unsigned int PolygonCount;
 	Reader.Read(PolygonCount);
-	for (unsigned int i = 0; i < PolygonCount; ++i)
-	{
+	for (unsigned int i = 0; i < PolygonCount; ++i) {
 		m_Polygons.push_back(BS_Polygon(Reader));
 	}
 
@@ -418,10 +381,11 @@ bool BS_Region::Unpersist(BS_InputPersistenceBlock & Reader)
 
 // -----------------------------------------------------------------------------
 
-BS_Vertex BS_Region::GetCentroid() const
-{
+BS_Vertex BS_Region::GetCentroid() const {
 	if (m_Polygons.size() > 0)
 		return m_Polygons[0].GetCentroid();
 	return
 		BS_Vertex();
 }
+
+} // End of namespace Sword25
diff --git a/engines/sword25/math/region.h b/engines/sword25/math/region.h
index 90d6613aca..577da94fac 100644
--- a/engines/sword25/math/region.h
+++ b/engines/sword25/math/region.h
@@ -35,192 +35,188 @@
 #ifndef SWORD25_REGION_H
 #define SWORD25_REGION_H
 
-#include "sword25/kernel/memlog_off.h"
-#include <vector>
-#include "sword25/kernel/memlog_on.h"
-
 #include "sword25/kernel/common.h"
 #include "sword25/kernel/persistable.h"
 #include "sword25/math/vertex.h"
 #include "sword25/math/polygon.h"
 #include "sword25/math/rect.h"
 
+namespace Sword25 {
+
 /**
-	@brief Diese Klasse ist die Basisklasse aller Regionen.
-
-	Mit der Methode IsValid() lässt sich abfragen, ob sich das Objekt in einem gültigen Zustand befindet.<br>
-	Sollte dies nicht der Fall sein, ist die Methode Init() die einzige Methode die aufgerufen werden darf.
-	Diese Klasse garantiert, dass die Vertecies der die Umriss- und die Lochpolygone im Uhrzeigersinn angeordnet sind, so dass auf den Polygonen
-	arbeitende Algorithmen nur für diese Anordnung implementiert werden müssen.
-*/
-class BS_Region : public BS_Persistable
-{
+ * This class is the base class of all regions.
+ *
+ * The IsValid() method can be queried to see whether the object is in a valid state.
+ * If this is not the case, the method Init() is the only method that may be invoked.
+ * This class guarantees that the Vertecies outline of the hole, and the polygons are
+ * arranged in a clockwise direction, so that the polygon working algorithms will
+ * work properly.
+ */
+class BS_Region : public BS_Persistable {
 protected:
 	/**
-		@brief Erzeugt ein uninitialisiertes #BS_Region Objekt.
-
-		Nach dem Erzeugen ist das Objekt noch ungültig (IsValid() gibt false zurück), allerdings kann das Objekt nachträglich über
-		einen Aufruf von Init() in einen gültigen Zustand versetzt werden.
-	*/
+	 * Creates a new BS_Region object
+	 *
+	 * After creation the object is invaild (IsValid() return false), but a call can
+	 * be made later on to Init() to set up the region into a valid state.
+	 */
 	BS_Region();
 
-	BS_Region(BS_InputPersistenceBlock & Reader, unsigned int Handle);
+	BS_Region(BS_InputPersistenceBlock &Reader, unsigned int Handle);
 
 public:
-	enum REGION_TYPE
-	{
+	enum REGION_TYPE {
 		RT_REGION,
 		RT_WALKREGION
 	};
 
 	static unsigned int Create(REGION_TYPE Type);
-	static unsigned int Create(BS_InputPersistenceBlock & Reader, unsigned int Handle = 0);
+	static unsigned int Create(BS_InputPersistenceBlock &Reader, unsigned int Handle = 0);
 
 	virtual ~BS_Region();
 
 	/**
-		@brief Initialisiert ein BS_Region Objekt.
-		@param Contour ein Polygon das den Umriss der Region angibt.
-		@param pHoles ein Pointer auf einen Vector von Polygonen, die Löcher in der Region angeben.<br>
-					  Falls die Region keine Löcher hat, muss NULL übergeben werden.<br>
-					  Der Standardwert ist NULL.
-		@return Gibt true zurück, wenn die Initialisierung erfolgreich war.<br>
-				Gibt false zurück, wenn die Intialisierung fehlgeschlagen ist.
-		@remark Falls die Region bereits initialisiert war, wird der alte Zustand gelöscht.
-	*/
-	virtual bool Init(const BS_Polygon& Contour, const std::vector<BS_Polygon>* pHoles = NULL);
-	
-	//@{
-	/** @name Sondierende Methoden */
-
-	/**
-		@brief Gibt an, ob das Objekt in einem gültigen Zustand ist.
-		@return Gibt true zurück, wenn sich das Objekt in einem gültigen Zustand befindet.
-				Gibt false zurück, wenn sich das Objekt in einem ungültigen Zustand befindet.
-		@remark Ungültige Objekte können durch einen Aufruf von Init() in einen gültigen Zustand versetzt werden.
-	*/
+	 * Initialises a BS_Region object
+	 * @param Contour		A polygon indicating the outline of the region
+	 * @param pHoles		A pointer to an array of polygons representing the hole state in the region.
+	 * If the region has no holes, it must be passed as NULL. The default value is NULL.
+	 * @return				Returns true if the initialisation was successful, otherwise false.
+	 * @remark				If the region was already initialised, the old state will be deleted.
+	 */
+	virtual bool Init(const BS_Polygon &Contour, const Common::Array<BS_Polygon> *pHoles = NULL);
+
+	//
+	// Exploratory Methods
+	//
+
+	/**
+	 * Specifies whether the object is in a valid state
+	 * @return				Returns true if the object is in a valid state, otherwise false.
+	 * @remark				Invalid objects can be made valid by calling Init with a valid state.
+	 */
 	bool IsValid() const { return m_Valid; }
 
 	/**
-		@brief Gibt die Position der Region zurück.
-	*/
-	const BS_Vertex& GetPosition() const { return m_Position; }
+	 * Returns the position of the region
+	 */
+	const BS_Vertex &GetPosition() const { return m_Position; }
 
 	/**
-		@brief Gibt die Position des Region auf der X-Achse zurück.
-	*/
+	 * Returns the X position of the region
+	 */
 	int GetPosX() const { return m_Position.X; }
 
 	/**
-		@brief Gibt die Position des Region auf der Y-Achse zurück.
-	*/
+	 * Returns the Y position of the region
+	 */
 	int GetPosY() const { return m_Position.Y; }
 
 	/**
-		@brief Gibt an, ob sich ein Punkt innerhalb der Region befindet.
-		@param Vertex ein Vertex, mit den Koordinaten des zu testenden Punktes.
-		@return Gibt true zurück, wenn sich der Punkt innerhalb der Region befindet.<br>
-				Gibt false zurück, wenn sich der Punkt außerhalb der Region befindet.
-	*/
-	bool IsPointInRegion(const BS_Vertex& Vertex) const;
+	 * Indicates whether a point is inside the region
+	 * @param Vertex		A verex with the co-ordinates of the test point
+	 * @return				Returns true if the point is within the region, otherwise false.
+	 */
+	bool IsPointInRegion(const BS_Vertex &Vertex) const;
 
 	/**
-		@brief Gibt an, ob sich ein Punkt innerhalb der Region befindet.
-		@param X die Position des Punktes auf der X-Achse.
-		@param Y die Position des Punktes auf der Y-Achse.
-		@return Gibt true zurück, wenn sich der Punkt innerhalb der Region befindet.<br>
-				Gibt false zurück, wenn sich der Punkt außerhalb der Region befindet.
-	*/
+	 * Indicates whether a point is inside the region
+	 * @param X				The X position
+	 * @param Y				The Y position
+	 * @return				Returns true if the point is within the region, otherwise false.
+	 */
 	bool IsPointInRegion(int X, int Y) const;
 
 	/**
-		@brief Gibt das Umrisspolygon der Region zurück.
-	*/
-	const BS_Polygon& GetContour() const { return m_Polygons[0]; }
+	 * Returns the countour of the region
+	 */
+	const BS_Polygon &GetContour() const { return m_Polygons[0]; }
 
 	/**
-		@brief Gibt die Anzahl der Lochpolygone in der Region zurück.
-	*/
+	 * Returns the number of polygons in the hole region
+	 */
 	int GetHoleCount() const { return static_cast<int>(m_Polygons.size() - 1); }
 
 	/**
-		@brief Gibt ein bestimmtes Lochpolygon in der Region zurück.
-		@param i die Nummer des zurückzugebenen Loches.<br>
-				 Dieser Wert muss zwischen 0 und GetHoleCount() - 1 liegen.
-		@return Gibt das gewünschte Lochpolygon zurück.
-	*/
-	inline const BS_Polygon& GetHole(unsigned int i) const;
+	 * Returns a specific hole polygon in the region
+	 * @param i				The number of the hole to return.
+	 * The index must be between 0 and GetHoleCount() - 1.
+	 * @return				Returns the desired hole polygon
+	 */
+	inline const BS_Polygon &GetHole(unsigned int i) const;
 
 	/**
-		@brief Findet für einen Punkt ausserhalb der Region den nächsten Punkt, der sich innerhalb der Region befindet.
-		@param Point der Punkt, der sich ausserhalb der Region befindet
-		@return Gibt den Punkt innerhalb der Region zurück, der den geringsten Abstand zum übergebenen Punkt hat.
-		@remark Diese Methode arbeitet nicht immer Pixelgenau. Man sollte sich also nicht darauf verlassen, dass es wirklich keine Punkt innerhalb der
-				Region gibt, der dichter am übergebenen Punkt liegt.
-	*/
-	BS_Vertex FindClosestRegionPoint(const BS_Vertex& Point) const;
+	 * For a point outside the region, finds the closest point inside the region
+	 * @param Point			The point that is outside the region
+	 * @return				Returns the point within the region which is closest
+	 * @remark				This method does not always work with pixel accuracy.
+	 * One should not therefore rely on the fact that there is really no point in 
+	 * the region which is closer to the given point.
+	 */
+	BS_Vertex FindClosestRegionPoint(const BS_Vertex &Point) const;
 
 	/**
-		@brief Gibt den Schwerpunkt des Umrisspolygons zurück.
-	*/
+	 * Returns the centroid for the region
+	 */
 	BS_Vertex GetCentroid() const;
 
-	bool IsLineOfSight(const BS_Vertex & a, const BS_Vertex & b) const;
+	bool IsLineOfSight(const BS_Vertex &a, const BS_Vertex &b) const;
 
-	//@}
-
-	//@{
-	/** @name Manipulierende Methoden */
+	//
+	// Manipulation Methods
+	//
 
 	/**
-		@brief Setzt die Position der Region.
-		@param X die neue Position der Region auf der X-Achse.
-		@param Y die neue Position der Region auf der Y-Achse.
-	*/
+	 * Sets the position of the region
+	 * @param X				The new X psoition of the region
+	 * @param Y				The new Y psoition of the region
+	 */
 	virtual void SetPos(int X, int Y);
 
 	/**
-		@brief Setzt die Position der Region auf der X-Achse.
-		@param X die neue Position der Region auf der X-Achse.
-	*/
+	 * Sets the X position of the region
+	 * @param X				The new X position of the region
+	 */
 	void SetPosX(int X);
 
 	/**
-		@brief Setzt die Position der Region auf der Y-Achse.
-		@param Y die neue Position der Region auf der Y-Achse.
-	*/
+	 * Sets the Y position of the region
+	 * @param Y				The new Y position of the region
+	 */
 	void SetPosY(int Y);
 
-	//@}
+	//
+	// Manipulation Methods
+	//
 
-	virtual bool Persist(BS_OutputPersistenceBlock & Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
+	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
 
 protected:
-	/// Diese Variable gibt den Typ des Objektes an.
+	/// This specifies the type of object
 	REGION_TYPE m_Type;
-	/// Diese Variable gibt an, ob der aktuelle Objektzustand gültig ist.
+	/// This variable indicates whether the current object state is valid
 	bool m_Valid;
-	/// Dieses Vertex gibt die Position der Region an.
+	/// This vertex is the position of the region
 	BS_Vertex m_Position;
-	/// Dieser Vector enthält alle Polygone die die Region definieren. Das erste Element des Vectors ist die Kontur, alle weiteren sind die Löcher.
-	std::vector<BS_Polygon> m_Polygons;
-	/// Die Bounding-Box der Region.
+	/// This array contains all the polygons that define the region. The first element of
+	// the array is the contour, all others are the holes
+	Common::Array<BS_Polygon> m_Polygons;
+	/// The bounding box for the region
 	BS_Rect m_BoundingBox;
 
 	/**
-		@brief Aktualisiert die Bounding-Box der Region.
-	*/
+	 * Updates the bounding box of the region.
+	 */
 	void UpdateBoundingBox();
 
 	/**
-		@brief Findet den Punkt auf einer Linie, der einem anderen Punkt am nächsten ist.
-		@param LineStart der Startpunkt der Linie
-		@param LineEnd der Endpunkt der Linie
-		@param Point der Punkt, zu dem der nächste Punkt auf der Linie konstruiert werden soll.
-		@return Gibt den Punkt auf der Linie zurück, der dem übergebenen Punkt am nächsten ist.
-	*/
-	BS_Vertex FindClosestPointOnLine(const BS_Vertex & LineStart, const BS_Vertex & LineEnd, const BS_Vertex Point) const;
+	 * Find the point on a line which is closest to another point
+	 * @param LineStart		The start of the line
+	 * @param LineEnd		The end of the line
+	 * @param Point			The point to be compared against
+	 * @return				Returns the point on the line which is cloest to the passed point.
+	 */
+	BS_Vertex FindClosestPointOnLine(const BS_Vertex &LineStart, const BS_Vertex &LineEnd, const BS_Vertex Point) const;
 };
 
 
@@ -228,10 +224,11 @@ protected:
 // Inlines
 // -----------------------------------------------------------------------------
 
-inline const BS_Polygon& BS_Region::GetHole(unsigned int i) const
-{
+inline const BS_Polygon &BS_Region::GetHole(unsigned int i) const {
 	BS_ASSERT(i < m_Polygons.size() - 1);
 	return m_Polygons[i + 1];
 }
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/math/regionregistry.cpp b/engines/sword25/math/regionregistry.cpp
index 3af871b1e7..1611f228ea 100644
--- a/engines/sword25/math/regionregistry.cpp
+++ b/engines/sword25/math/regionregistry.cpp
@@ -47,46 +47,44 @@
 #include "sword25/math/regionregistry.h"
 #include "sword25/math/region.h"
 
+namespace Sword25 {
+
 // -----------------------------------------------------------------------------
 // Implementation
 // -----------------------------------------------------------------------------
 
-std::auto_ptr<BS_RegionRegistry> BS_RegionRegistry::m_InstancePtr;
+Common::SharedPtr<BS_RegionRegistry> BS_RegionRegistry::m_InstancePtr;
 
 // -----------------------------------------------------------------------------
 
-void BS_RegionRegistry::LogErrorLn(const char * Message) const
-{
+void BS_RegionRegistry::LogErrorLn(const char *Message) const {
 	BS_LOG_ERRORLN(Message);
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_RegionRegistry::LogWarningLn(const char * Message) const
-{
+void BS_RegionRegistry::LogWarningLn(const char *Message) const {
 	BS_LOG_WARNINGLN(Message);
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_RegionRegistry::Persist(BS_OutputPersistenceBlock & Writer)
-{
+bool BS_RegionRegistry::Persist(BS_OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
-	// Das nächste zu vergebene Handle schreiben.
+	// Write out the next handle
 	Writer.Write(m_NextHandle);
 
-	// Anzahl an BS_Regions schreiben.
+	// Number of regions to write
 	Writer.Write(m_Handle2PtrMap.size());
 
-	// Alle BS_Regions persistieren.
+	// Persist all the BS_Regions
 	HANDLE2PTR_MAP::const_iterator Iter = m_Handle2PtrMap.begin();
-	while (Iter != m_Handle2PtrMap.end())
-	{
-		// Handle persistieren.
+	while (Iter != m_Handle2PtrMap.end()) {
+		// Handle persistence
 		Writer.Write(Iter->first);
 
-		// Objekt persistieren.
+		// Persist object
 		Result &= Iter->second->Persist(Writer);
 
 		++Iter;
@@ -97,30 +95,30 @@ bool BS_RegionRegistry::Persist(BS_OutputPersistenceBlock & Writer)
 
 // -----------------------------------------------------------------------------
 
-bool BS_RegionRegistry::Unpersist(BS_InputPersistenceBlock & Reader)
-{
+bool BS_RegionRegistry::Unpersist(BS_InputPersistenceBlock &Reader) {
 	bool Result = true;
 
-	// Das nächste zu vergebene Handle wieder herstellen.
+	// Read in the next handle
 	Reader.Read(m_NextHandle);
 
-	// Alle vorhandenen BS_Regions zerstören.
+	// Destroy all existing BS_Regions
 	while (!m_Handle2PtrMap.empty()) delete m_Handle2PtrMap.begin()->second;
 
-	// Anzahl an BS_Regions einlesen.
+	// Read in the number of BS_Regions
 	unsigned int RegionCount;
 	Reader.Read(RegionCount);
 
-	// Alle gespeicherten BS_Regions wieder herstellen.
-	for (unsigned int i = 0; i < RegionCount; ++i)
-	{
-		// Handle lesen.
+	// Restore all the BS_Regions objects
+	for (unsigned int i = 0; i < RegionCount; ++i) 	{
+		// Handle read
 		unsigned int Handle;
 		Reader.Read(Handle);
 
-		// BS_Region wieder herstellen.
+		// BS_Region restore
 		Result &= BS_Region::Create(Reader, Handle) != 0;
 	}
 
 	return Reader.IsGood() && Result;
 }
+
+} // End of namespace Sword25
diff --git a/engines/sword25/math/regionregistry.h b/engines/sword25/math/regionregistry.h
index f1af5dc1b7..3c4771df5f 100644
--- a/engines/sword25/math/regionregistry.h
+++ b/engines/sword25/math/regionregistry.h
@@ -39,41 +39,40 @@
 // Includes
 // -----------------------------------------------------------------------------
 
+#include "common/ptr.h"
 #include "sword25/kernel/common.h"
 #include "sword25/kernel/persistable.h"
 #include "sword25/kernel/objectregistry.h"
 
-#include "sword25/kernel/memlog_off.h"
-#include <memory>
-#include "sword25/kernel/memlog_on.h"
+namespace Sword25 {
 
 // -----------------------------------------------------------------------------
-// Forward Deklarationen
+// Forward Declarations
 // -----------------------------------------------------------------------------
 
 class BS_Region;
 
 // -----------------------------------------------------------------------------
-// Klassendeklaration
+// Class definitions
 // -----------------------------------------------------------------------------
 
-class BS_RegionRegistry : public BS_ObjectRegistry<BS_Region>, public BS_Persistable
-{
+class BS_RegionRegistry : public BS_ObjectRegistry<BS_Region>, public BS_Persistable {
 public:
-	static BS_RegionRegistry & GetInstance()
-	{
-		if (!m_InstancePtr.get()) m_InstancePtr.reset(new BS_RegionRegistry);
+	static BS_RegionRegistry & GetInstance() {
+		if (!m_InstancePtr.get()) m_InstancePtr = Common::SharedPtr<BS_RegionRegistry>(new BS_RegionRegistry());
 		return *m_InstancePtr.get();
 	}
 
-	virtual bool Persist(BS_OutputPersistenceBlock & Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
+	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
 
 private:
-	virtual void LogErrorLn(const char * Message) const;
-	virtual void LogWarningLn(const char * Message) const;
+	virtual void LogErrorLn(const char *Message) const;
+	virtual void LogWarningLn(const char *Message) const;
 
-	static std::auto_ptr<BS_RegionRegistry> m_InstancePtr;
+	static Common::SharedPtr<BS_RegionRegistry> m_InstancePtr;
 };
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/math/vertex.cpp b/engines/sword25/math/vertex.cpp
index 5dbf99402e..61d21b58d8 100644
--- a/engines/sword25/math/vertex.cpp
+++ b/engines/sword25/math/vertex.cpp
@@ -34,31 +34,36 @@
 
 #include "sword25/math/vertex.h"
 
+namespace {
+
 extern "C"
 {
 	#include "sword25/util/lua/lua.h"
 	#include "sword25/util/lua/lauxlib.h"
 }
 
+}
+
 // -----------------------------------------------------------------------------
 
-BS_Vertex & BS_Vertex::LuaVertexToVertex(lua_State * L, int StackIndex, BS_Vertex & Vertex)
-{
+namespace Sword25 {
+
+BS_Vertex &BS_Vertex::LuaVertexToVertex(lua_State *L, int StackIndex, BS_Vertex &Vertex) {
 #ifdef DEBUG
 	int __startStackDepth = lua_gettop(L);
 #endif
 
-	// Sicherstellen, dass wir wirklich eine Tabelle betrachten
+	// Ensure that we actually consider a table
 	luaL_checktype(L, StackIndex, LUA_TTABLE);
 
-	// X Komponente auslesen
+	// Read X Component
 	lua_pushstring(L, "X");
 	lua_gettable(L, StackIndex);
 	if (!lua_isnumber(L, -1)) luaL_argcheck(L, 0, StackIndex, "the X component has to be a number");
 	Vertex.X = static_cast<int>(lua_tonumber(L, -1));
 	lua_pop(L, 1);
 
-	// Y Komponente auslesen
+	// Read Y Component
 	lua_pushstring(L, "Y");
 	lua_gettable(L, StackIndex);
 	if (!lua_isnumber(L, -1)) luaL_argcheck(L, 0, StackIndex, "the Y component has to be a number");
@@ -74,18 +79,19 @@ BS_Vertex & BS_Vertex::LuaVertexToVertex(lua_State * L, int StackIndex, BS_Verte
 
 // -----------------------------------------------------------------------------
 
-void BS_Vertex::VertexToLuaVertex(lua_State * L, const BS_Vertex & Vertex)
-{
-	// Neue Tabelle erstellen
+void BS_Vertex::VertexToLuaVertex(lua_State * L, const BS_Vertex &Vertex) {
+	// Create New Table
 	lua_newtable(L);
 
-	// X-Wert in die Tabelle schreiben
+	// X value is written to table
 	lua_pushstring(L, "X");
 	lua_pushnumber(L, Vertex.X);
 	lua_settable(L, -3);
 
-	// Y-Wert in die Tabelle schreiben
+	// Y value is written to table
 	lua_pushstring(L, "Y");
 	lua_pushnumber(L, Vertex.Y);
 	lua_settable(L, -3);
 }
+
+} // End of namespace Sword25
diff --git a/engines/sword25/math/vertex.h b/engines/sword25/math/vertex.h
index bb7a84abb9..5b4e6da0f8 100644
--- a/engines/sword25/math/vertex.h
+++ b/engines/sword25/math/vertex.h
@@ -46,14 +46,19 @@
 #include <math.h>
 #include "sword25/kernel/common.h"
 
-// Forward-Declarations
+namespace {
+
+// Forward declarations
 struct lua_State;
 
+}
+
+namespace Sword25 {
+
 /**
-	@brief Ein 2D-Vertex.
-*/
-class BS_Vertex
-{
+ * Defines a 2-D Vertex
+ */
+class BS_Vertex {
 public:
 	BS_Vertex() : X(0), Y(0) {};
 	BS_Vertex(int X_, int Y_) { this->X = X_; this->Y = Y_; }
@@ -62,91 +67,87 @@ public:
 	int Y;
 
 	/**
-		@brief Vergleicht zwei Vertecies.
-	*/
+	 * Compares two Vertecies.
+	 */
 	inline bool operator==(const BS_Vertex& rhs) const { if (X == rhs.X && Y == rhs.Y) return true; return false; }
 	/**
-	@brief Vergleicht zwei Vertecies.
-	*/
+	 * Compares two Vertecies.
+	 */
 	inline bool operator!=(const BS_Vertex& rhs) const { if (X != rhs.X || Y != rhs.Y) return true; return false; }
 	/**
-		@brief Addiert ein Vertex zum Vertex.
-	*/
+	 * Adds a vertex to vertex
+	 */
 	inline void operator+=(const BS_Vertex& Delta) { X += Delta.X; Y += Delta.Y; }
 
 	/**
-		@brief Subtrahiert ein Vertex vom Vertex.
-	*/
+	 * Subtracts a vertex from a vertex
+	 */
 	inline void operator-=(const BS_Vertex& Delta) { X -= Delta.X; Y -= Delta.Y; }
 
 	/**
-		@brief Addiert zwei Vertecies
-	*/
+	 * Adds two vertecies
+	 */
 	inline BS_Vertex operator+(const BS_Vertex& Delta) const { return BS_Vertex(X + Delta.X, Y + Delta.Y); }
 
 	/**
-		@brief Subtrahiert zwei Vertecies
-	*/
+	 * Subtracts two vertecies
+	 */
 	inline BS_Vertex operator-(const BS_Vertex& Delta) const { return BS_Vertex(X - Delta.X, Y - Delta.Y); }
 
 	/**
-		@brief Berechnet das Quadrat des Abstandes zweier Vertecies.
-		@param Vertex das Vertex zu dem der Abstand berechnet werden soll.
-		@return Gibt das Quadrat des Abstandes zwischen diesem Objekt und Vertex zurück.
-		@remark Falls nur Abstände verglichen werden sollen, sollte diese Methode benutzt werden, da sie schneller ist, als Distance().
-	*/
-	inline int Distance2(const BS_Vertex& Vertex) const
-	{
+	 * Calculates the square of the distance between two Vertecies.
+	 * @param Vertex		The vertex for which the distance is to be calculated
+	 * @return				Returns the square of the distance between itself and the passed vertex
+	 * @remark				If only distances should be compared, this method should be used because
+	 * it is faster than Distance()
+	 */
+	inline int Distance2(const BS_Vertex& Vertex) const	{
 		return (X - Vertex.X) * (X - Vertex.X) + (Y - Vertex.Y) * (Y - Vertex.Y);
 	}
 
 	/**
-		@brief Berechnet den Abstand zweier Vertecies.
-		@param Vertex das Vertex zu dem der Abstand berechnet werden soll.
-		@return Gibt den Abstand zwischen diesem Objekt und Vertex zurück.
-		@remark Falls nur Abstände verglichen werden sollen, sollte diese Methode Distance2(), die das Quadrat des Abstandes berechnet.
-				Sie ist schneller.
-	*/
-	inline int Distance(const BS_Vertex& Vertex) const
-	{
+	 * Calculates the square of the distance between two Vertecies.
+	 * @param Vertex		The vertex for which the distance is to be calculated
+	 * @return				Returns the square of the distance between itself and the passed vertex
+	 * @remark				If only distances should be compared, Distance2() should be used, since it is faster.
+	 */
+	inline int Distance(const BS_Vertex& Vertex) const {
 		return (int)(sqrtf(static_cast<float>(Distance2(Vertex))) + 0.5);
 	}
 
 	/**
-		@brief Berechnet das Kreuzprodukt dieses Vertex mit einem weiteren Vertex. Hierbei werden die Vertecies als Vektoren aufgefasst.
-		@param Vertex das zweite Vertex
-		@return Gibt das Kreuzprodukt von diesem Vertex und dem Parameter Vertex zurück.
-	*/
-	inline int ComputeCrossProduct(const BS_Vertex& Vertex) const
-	{
+	 * Calculates the cross product of the vertex with another vertex. Here the Vertecies will be
+	 * interpreted as vectors.
+	 * @param Vertex		The second vertex
+	 * @return				Returns the cross product of this vertex and the passed vertex.
+	 */
+	inline int ComputeCrossProduct(const BS_Vertex& Vertex) const {
 		return X * Vertex.Y - Vertex.X * Y;
 	}
 
 	/**
-		@brief Berechnet das Skalarprodukt dieses Vertex mit einem weiteren Vertex. Hierbei werden die Vertecies als Vektoren aufgefasst.
-		@param Vertex das zweite Vertex
-		@return Gibt das Skalarprodukt von diesem Vertex und dem Parameter Vertex zurück.
-	*/
+	 * Returns the dot product of this vertex with another vertex. Here the Vertecies are interpreted as vectors.
+	 * @param Vertex		The second vertex
+	 * @return				Returns the dot product of this vertex and the passed vertex.
+	 */
 	inline int ComputeDotProduct(const BS_Vertex& Vertex) const
 	{
 		return X * Vertex.X + Y * Vertex.Y;
 	}
 
 	/**
-		@brief Berechnet den Winkel zwischen diesem Vertex und einem weiteren Vertex.  Hierbei werden die Vertecies als Vektoren aufgefasst.
-		@param Vertex das zweite Vertex
-		@return Gibt den Winkel zwischen diesem Vertex und dem Parameter Vertex im Bogenmaß zurück.
-	*/
-	inline float ComputeAngle(const BS_Vertex& Vertex) const
-	{
+	 * Calculates the angle between this vertex and another vertex. Here the Vertecies are interpreted as vectors.
+	 * @param Vertex		The second vertex
+	 * @return				Returns the angle between this vertex and the passed vertex in radians.
+	 */
+	inline float ComputeAngle(const BS_Vertex& Vertex) const {
 		return atan2f(static_cast<float>(ComputeCrossProduct(Vertex)), static_cast<float>(ComputeDotProduct(Vertex)));
 	}
 
 	/**
-		@brief Berechnet die Länge des Vektors
-	*/
-	inline float ComputeLength() const
-	{
+	 * Calculates the length of the vector
+	 */
+	inline float ComputeLength() const {
 		return sqrtf(static_cast<float>(X * X + Y * Y));
 	}
 
@@ -154,4 +155,6 @@ public:
 	static void VertexToLuaVertex(lua_State * L, const BS_Vertex & Vertex);
 };
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/math/walkregion.cpp b/engines/sword25/math/walkregion.cpp
index 58d5bc45ba..70b84da3b9 100644
--- a/engines/sword25/math/walkregion.cpp
+++ b/engines/sword25/math/walkregion.cpp
@@ -32,8 +32,7 @@
  *
  */
 
-#include <list>
-#include <algorithm>
+#include "sword25/kernel/kernel.h"
 #include "sword25/kernel/inputpersistenceblock.h"
 #include "sword25/kernel/outputpersistenceblock.h"
 #include "sword25/math/walkregion.h"
@@ -41,65 +40,62 @@
 
 #define BS_LOG_PREFIX "WALKREGION"
 
+namespace Sword25 {
+
 // -----------------------------------------------------------------------------
-// Konstanten
+// Constants
 // -----------------------------------------------------------------------------
 
 static const int infinity = INT_MAX;
 
 // -----------------------------------------------------------------------------
-// Konstruktion / Destruktion
+// Constructor / Destructor
 // -----------------------------------------------------------------------------
 
-BS_WalkRegion::BS_WalkRegion()
-{
+BS_WalkRegion::BS_WalkRegion() {
 	m_Type = RT_WALKREGION;
 }
 
 // -----------------------------------------------------------------------------
 
 BS_WalkRegion::BS_WalkRegion(BS_InputPersistenceBlock &Reader, unsigned int Handle) :
-	BS_Region(Reader, Handle)
-{
+		BS_Region(Reader, Handle) {
 	m_Type = RT_WALKREGION;
 	Unpersist(Reader);
 }
 
 // -----------------------------------------------------------------------------
 
-BS_WalkRegion::~BS_WalkRegion()
-{
+BS_WalkRegion::~BS_WalkRegion() {
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_WalkRegion::Init(const BS_Polygon & Contour, const std::vector<BS_Polygon> * pHoles)
-{
-	// Standard-Initialisierungen der Region vornehmen.
+bool BS_WalkRegion::Init(const BS_Polygon &Contour, const Common::Array<BS_Polygon> *pHoles) {
+	// Default initialisation of the region
 	if (!BS_Region::Init(Contour, pHoles)) return false;
 
-	// Datenstrukturen fürs Pathfinding vorbereiten
+	// Prepare structures for pathfinding
 	InitNodeVector();
 	ComputeVisibilityMatrix();
 
-	// Erfolg signalisieren.
+	// Signal success
 	return true;
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_WalkRegion::QueryPath(BS_Vertex StartPoint, BS_Vertex EndPoint, BS_Path & Path)
-{
+bool BS_WalkRegion::QueryPath(BS_Vertex StartPoint, BS_Vertex EndPoint, BS_Path &Path) {
 	BS_ASSERT(Path.empty());
 
-	// Falls Start und Ziel identisch sind, muss trivialerweise kein Pfad gefunden werden.
+	// If the start and finish are identical, no path can be found trivially
 	if (StartPoint == EndPoint) return true;
 
-	// Sicherstellen, dass Start und Ziel gültig sind und neuen Start- und Zielpunkt finden, falls sie ausserhalb des Polygons liegen.
+	// Ensure that the start and finish are valid and find new start points if either 
+	// are outside the polygon
 	if (!CheckAndPrepareStartAndEnd(StartPoint, EndPoint)) return false;
 
-	// Wenn zwischen Start- und Endpunkt eine Sichtlinie besteht, muss kein Pathfindung durchgeführt werden und als Ergebnis wird die
-	// direkte Verbindungslinie zwischen Start- und Endpunkt zurückgegeben.
+	// If between the start and point a line of sight exists, then it can be returned.
 	if (IsLineOfSight(StartPoint, EndPoint))
 	{
 		Path.push_back(StartPoint);
@@ -112,9 +108,8 @@ bool BS_WalkRegion::QueryPath(BS_Vertex StartPoint, BS_Vertex EndPoint, BS_Path
 
 // -----------------------------------------------------------------------------
 
-struct DijkstraNode
-{
-	typedef std::vector<DijkstraNode> Container;
+struct DijkstraNode {
+	typedef Common::Array<DijkstraNode> Container;
 	typedef Container::iterator Iter;
 	typedef Container::const_iterator ConstIter;
 
@@ -124,30 +119,27 @@ struct DijkstraNode
 	bool		Chosen;
 };
 
-static void InitDijkstraNodes(DijkstraNode::Container & DijkstraNodes, const BS_Region & Region, const BS_Vertex & Start, const std::vector<BS_Vertex> & Nodes)
-{
-	// Ausreichend Platz im Vector reservieren
+static void InitDijkstraNodes(DijkstraNode::Container &DijkstraNodes, const BS_Region &Region, 
+							  const BS_Vertex &Start, const Common::Array<BS_Vertex> &Nodes) {
+	// Allocate sufficient space in the array
 	DijkstraNodes.resize(Nodes.size());
 
-	// Alle Randknoten initialisieren, die vom Startknoten sichtbar sind
+	// Initialise all the nodes which are visible from the starting node
 	DijkstraNode::Iter DijkstraIter = DijkstraNodes.begin();
-	for (std::vector<BS_Vertex>::const_iterator NodesIter = Nodes.begin(); NodesIter != Nodes.end(); NodesIter++, DijkstraIter++)
-	{
+	for (Common::Array<BS_Vertex>::const_iterator NodesIter = Nodes.begin(); 
+			NodesIter != Nodes.end(); NodesIter++, DijkstraIter++) {
 		(*DijkstraIter).ParentIter = DijkstraNodes.end();
 		if (Region.IsLineOfSight(*NodesIter, Start)) (*DijkstraIter).Cost = (*NodesIter).Distance(Start);
 	}
 	BS_ASSERT(DijkstraIter == DijkstraNodes.end());
 }
 
-static DijkstraNode::Iter ChooseClosestNode(DijkstraNode::Container & Nodes)
-{
+static DijkstraNode::Iter ChooseClosestNode(DijkstraNode::Container & Nodes) {
 	DijkstraNode::Iter ClosestNodeInter = Nodes.end();
 	int MinCost = infinity;
 
-	for (DijkstraNode::Iter iter = Nodes.begin(); iter != Nodes.end(); iter++)
-	{
-		if (!(*iter).Chosen && (*iter).Cost < MinCost)
-		{
+	for (DijkstraNode::Iter iter = Nodes.begin(); iter != Nodes.end(); iter++) {
+		if (!(*iter).Chosen && (*iter).Cost < MinCost) {
 			MinCost = (*iter).Cost;
 			ClosestNodeInter = iter;
 		}
@@ -156,22 +148,19 @@ static DijkstraNode::Iter ChooseClosestNode(DijkstraNode::Container & Nodes)
 	return ClosestNodeInter;
 }
 
-static void RelaxNodes(DijkstraNode::Container & Nodes,
-					   const std::vector< std::vector<int> > & VisibilityMatrix, 
-					   const DijkstraNode::ConstIter & CurNodeIter)
-{
-	// Alle Nachfolger vom aktuellen Knoten, die noch nicht gewählt wurden, werden in die Randknotenliste eingefügt und die Kosten werden
-	// aktualisiert, wenn ein kürzerer Pfad zu ihnen gefunden wurde.
+static void RelaxNodes(DijkstraNode::Container &Nodes,
+					   const Common::Array< Common::Array<int> > &VisibilityMatrix, 
+					   const DijkstraNode::ConstIter &CurNodeIter) {
+	// All the successors of the current node that have not been chosen will be
+	// inserted into the boundary node list, and the cost will be updated if
+	// a shorter path has been found to them.
 
 	int CurNodeIndex = CurNodeIter - Nodes.begin();
-	for (unsigned int i = 0; i < Nodes.size(); i++)
-	{
+	for (unsigned int i = 0; i < Nodes.size(); i++) {
 		int Cost = VisibilityMatrix[CurNodeIndex][i];
-		if (!Nodes[i].Chosen && Cost != infinity)
-		{
+		if (!Nodes[i].Chosen && Cost != infinity) {
 			int TotalCost = (*CurNodeIter).Cost + Cost;
-			if (TotalCost < Nodes[i].Cost)
-			{
+			if (TotalCost < Nodes[i].Cost) {
 				Nodes[i].ParentIter = CurNodeIter;
 				Nodes[i].Cost = TotalCost;
 			}
@@ -179,90 +168,82 @@ static void RelaxNodes(DijkstraNode::Container & Nodes,
 	}
 }
 
-static void RelaxEndPoint(const BS_Vertex & CurNodePos,
-						  const DijkstraNode::ConstIter & CurNodeIter,
-						  const BS_Vertex & EndPointPos,
-						  DijkstraNode & EndPoint,
-						  const BS_Region & Region)
-{
-	if (Region.IsLineOfSight(CurNodePos, EndPointPos))
-	{
+static void RelaxEndPoint(const BS_Vertex &CurNodePos,
+						  const DijkstraNode::ConstIter &CurNodeIter,
+						  const BS_Vertex &EndPointPos,
+						  DijkstraNode &EndPoint,
+						  const BS_Region &Region) {
+	if (Region.IsLineOfSight(CurNodePos, EndPointPos)) {
 		int TotalCost = (*CurNodeIter).Cost + CurNodePos.Distance(EndPointPos);
-		if (TotalCost < EndPoint.Cost)
-		{
+		if (TotalCost < EndPoint.Cost) {
 			EndPoint.ParentIter = CurNodeIter;
 			EndPoint.Cost = TotalCost;
 		}
 	}
 }
 
-bool BS_WalkRegion::FindPath(const BS_Vertex & Start, const BS_Vertex & End, BS_Path & Path) const
-{
-	// Dies ist eine Implementation des Dijkstra-Algorithmus
+bool BS_WalkRegion::FindPath(const BS_Vertex &Start, const BS_Vertex &End, BS_Path &Path) const {
+	// This is an implementation of Dijkstra's algorithm
 
-	// Randknotenliste initialisieren
+	// Initialise edge node list
 	DijkstraNode::Container DijkstraNodes;
 	InitDijkstraNodes(DijkstraNodes, *this, Start, m_Nodes);
 
-	// Der Endpunkt wird gesondert behandelt, da er im Sichtbarkeitsgraphen nicht vorhanden ist
+	// The end point is treated separately, since it does not exist in the visibility graph
 	DijkstraNode EndPoint;
 
-	// Da in jedem Durchgang ein Knoten aus der Knotenliste gewählt wird, und danach nie wieder gewählt werden kann, ist die maximale Anzahl der
-	// Schleifendurchläufe durch die Anzahl der Knoten begrenzt.
-	for (unsigned int i = 0; i < m_Nodes.size(); i++)
-	{
-		// Bestimme nächstgelegenen Knoten in der Randknotenliste
+	// Since a node is selected each round from the node list, and can never be selected again
+	// after that, the maximum number of loop iterations is limited by the number of nodes
+	for (unsigned int i = 0; i < m_Nodes.size(); i++) {
+		// Determine the nearest edge node in the node list
 		DijkstraNode::Iter NodeInter = ChooseClosestNode(DijkstraNodes);
 		(*NodeInter).Chosen = true;
 
-		// Falls kein freier Knoten mehr in der Randknotenliste vorhanden ist, gibt es keinen Weg vom Start- zum Endknoten.
-		// Dieser Fall sollte nie auftreten, da die Anzahl der Schleifendurchgänge begrenzt ist, aber sicher ist sicher.
+		// If no free nodes are absent from the edge node list, there is no path from start
+		// to end node. This case should never occur, since the number of loop passes is
+		// limited, but etter safe than sorry
 		if (NodeInter == DijkstraNodes.end()) return false;
 
-		// Wenn der Zielpunkt noch näher liegt als der nächte Punkt, ist die Suche beendet
-		if (EndPoint.Cost <= (*NodeInter).Cost)
-		{
-			// Ergebnispfad extrahieren
-
-			// Den Endpunkt in den Ergebnispfad einfügen
+		// If the destination point is closer than the point cost, scan can stop
+		if (EndPoint.Cost <= (*NodeInter).Cost) {
+			// Insert the end point in the list
 			Path.push_back(End);
 
-			// Die Wegknoten in umgekehrter Reihenfolge ablaufen und in den Ergebnispfad einfügen
+			// The list is done in reverse order and inserted into the path
 			DijkstraNode::ConstIter CurNode = EndPoint.ParentIter;
-			while (CurNode != DijkstraNodes.end())
-			{
+			while (CurNode != DijkstraNodes.end()) {
 				BS_ASSERT((*CurNode).Chosen);
 				Path.push_back(m_Nodes[CurNode - DijkstraNodes.begin()]);
 				CurNode = (*CurNode).ParentIter;
 			}
 
-			// Den Startpunkt in den Ergebnispfad einfügen
+			// The starting point is inserted into the path
 			Path.push_back(Start);
 
-			// Die Knoten des Pfades müssen ungedreht werden, da sie in umgekehrter Reihenfolge extrahiert wurden.
-			// Diesen Schritt könnte man sich sparen, wenn man den Pfad vom Ende zum Anfang sucht.
-			std::reverse(Path.begin(), Path.end());
+			// The nodes of the path must be untwisted, as they were extracted in reverse order.
+			// This step could be saved if the path from end to the beginning was desired
+			ReverseArray<BS_Vertex>(Path);
 
 			return true;
 		}
 
-		// Relaxation-Schritt für die Knoten des Graphen und für den Endknoten durchführen
+		// Relaxation step for nodes of the graph, and perform the end nodes
 		RelaxNodes(DijkstraNodes, m_VisibilityMatrix, NodeInter);
 		RelaxEndPoint(m_Nodes[NodeInter - DijkstraNodes.begin()], NodeInter, End, EndPoint, *this);
 	}
 
-	// Falls die Schleife komplett durchlaufen wurde, wurden alle Knoten gewählt und es wurde trotzdem kein Pfad gefunden. Es existiert also keiner.
+	// If the loop has been completely run through, all the nodes have been chosen, and still
+	// no path was found. There is therefore no path available
 	return false;
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_WalkRegion::InitNodeVector()
-{
-	// Knoten-Vector leeren.
+void BS_WalkRegion::InitNodeVector() {
+	// Empty the Node list
 	m_Nodes.clear();
 
-	// Anzahl der Knoten bestimmen.
+	// Determine the number of nodes
 	int NodeCount = 0;
 	{
 		for (unsigned int i = 0; i < m_Polygons.size(); i++)
@@ -280,26 +261,27 @@ void BS_WalkRegion::InitNodeVector()
 
 // -----------------------------------------------------------------------------
 
-void BS_WalkRegion::ComputeVisibilityMatrix()
-{
-	// Sichtbarkeitsmatrix initialisieren
-	m_VisibilityMatrix = std::vector< std::vector <int> >(m_Nodes.size(), std::vector<int>(m_Nodes.size(), infinity));
+void BS_WalkRegion::ComputeVisibilityMatrix() {
+	// Initialise visibility matrix 
+	m_VisibilityMatrix = Common::Array< Common::Array <int> >();
+	for (uint idx = 0; idx < m_Nodes.size(); ++idx) {
+		Common::Array<int> arr;
+		for (uint idx2 = 0; idx2 < m_Nodes.size(); ++idx2)
+			arr.push_back(infinity);
 
-	// Sichtbarkeiten zwischen Vertecies berechnen und in die Sichbarkeitsmatrix eintragen.
-	for (unsigned int j = 0; j < m_Nodes.size(); ++j)
-	{
-		for (unsigned int i = j; i < m_Nodes.size(); ++i)
-		{
-			if (IsLineOfSight(m_Nodes[i], m_Nodes[j]))
-			{
-				// Wenn eine Sichtlinie besteht wird die Entfernung der Knoten eingetragen
+		m_VisibilityMatrix.push_back(arr);
+	}
+		
+	// Calculate visibility been vertecies
+	for (unsigned int j = 0; j < m_Nodes.size(); ++j) {
+		for (unsigned int i = j; i < m_Nodes.size(); ++i) 	{
+			if (IsLineOfSight(m_Nodes[i], m_Nodes[j])) {
+				// There is a line of sight, so save the distance between the two
 				int Distance = m_Nodes[i].Distance(m_Nodes[j]);
 				m_VisibilityMatrix[i][j] = Distance;
 				m_VisibilityMatrix[j][i] = Distance;
-			}
-			else
-			{
-				// Wenn keine Sichtlinie besteht wird die Entfernung "unendlich" eingetragen
+			} else {
+				// There is no line of sight, so save infinity as the distance
 				m_VisibilityMatrix[i][j] = infinity;
 				m_VisibilityMatrix[j][i] = infinity;
 			}
@@ -309,15 +291,12 @@ void BS_WalkRegion::ComputeVisibilityMatrix()
 
 // -----------------------------------------------------------------------------
 
-bool BS_WalkRegion::CheckAndPrepareStartAndEnd(BS_Vertex & Start, BS_Vertex & End) const
-{
-	if (!IsPointInRegion(Start))
-	{
+bool BS_WalkRegion::CheckAndPrepareStartAndEnd(BS_Vertex &Start, BS_Vertex &End) const {
+	if (!IsPointInRegion(Start)) {
 		BS_Vertex NewStart = FindClosestRegionPoint(Start);
 
-		// Sicherstellen, dass der ermittelte Punkt wirklich innerhalb der Region liegt und Notfalls abbrechen.
-		if (!IsPointInRegion(NewStart))
-		{
+		// Check to make sure the point is really in the region. If not, stop with an error
+		if (!IsPointInRegion(NewStart)) {
 			BS_LOG_ERRORLN("Constructed startpoint ((%d,%d) from (%d,%d)) is not inside the region.",
 				NewStart.X, NewStart.Y,
 				Start.X, Start.Y);
@@ -327,14 +306,13 @@ bool BS_WalkRegion::CheckAndPrepareStartAndEnd(BS_Vertex & Start, BS_Vertex & En
 		Start = NewStart;
 	}
 
-	// Falls der Zielpunkt außerhalb der Region liegt, wird der nächste Punkt innerhalb der Region bestimmt und als Endpunkt benutzt.
-	if (!IsPointInRegion(End))
-	{
+	// If the destination is outside the region, a point is determined that is within the region,
+	// and that is used as an endpoint instead
+	if (!IsPointInRegion(End)) {
 		BS_Vertex NewEnd = FindClosestRegionPoint(End);
 
-		// Sicherstellen, dass der ermittelte Punkt wirklich innerhalb der Region liegt und Notfalls abbrechen.
-		if (!IsPointInRegion(NewEnd))
-		{
+		// Make sure that the determined point is really within the region
+		if (!IsPointInRegion(NewEnd)) {
 			BS_LOG_ERRORLN("Constructed endpoint ((%d,%d) from (%d,%d)) is not inside the region.",
 				NewEnd.X, NewEnd.Y,
 				End.X, End.Y);
@@ -344,52 +322,47 @@ bool BS_WalkRegion::CheckAndPrepareStartAndEnd(BS_Vertex & Start, BS_Vertex & En
 		End = NewEnd;
 	}
 
-	// Erfolg signalisieren
+	// Signal success
 	return true;
 }
 
 // -----------------------------------------------------------------------------
 
-void BS_WalkRegion::SetPos(int X, int Y)
-{
-	// Unterschied zwischen alter und neuer Position berechnen.
+void BS_WalkRegion::SetPos(int X, int Y) {
+	// Calculate the difference between old and new position
 	BS_Vertex Delta(X - m_Position.X, Y - m_Position.Y);
 
-	// Alle Nodes verschieben.
+	// Move all the nodes
 	for (unsigned int i = 0; i < m_Nodes.size(); i++) m_Nodes[i] += Delta;
 
-	// Region verschieben
+	// Move regions
 	BS_Region::SetPos(X, Y);
 }
 
 // -----------------------------------------------------------------------------
 
-bool BS_WalkRegion::Persist(BS_OutputPersistenceBlock & Writer)
-{
+bool BS_WalkRegion::Persist(BS_OutputPersistenceBlock &Writer) {
 	bool Result = true;
 
-	// Elternobjekt persistieren.
+	// Persist the parent region
 	Result &= BS_Region::Persist(Writer);
 
-	// Knoten persistieren.
+	// Persist the nodes
 	Writer.Write(m_Nodes.size());
-	std::vector<BS_Vertex>::const_iterator It = m_Nodes.begin();
-	while (It != m_Nodes.end())
-	{
+	Common::Array<BS_Vertex>::const_iterator It = m_Nodes.begin();
+	while (It != m_Nodes.end()) {
 		Writer.Write(It->X);
 		Writer.Write(It->Y);
 		++It;
 	}
 
-	// Sichtbarkeitsmatrix persistieren.
+	// Persist the visibility matrix
 	Writer.Write(m_VisibilityMatrix.size());
-	std::vector< std::vector<int> >::const_iterator RowIter = m_VisibilityMatrix.begin();
-	while (RowIter != m_VisibilityMatrix.end())
-	{
+	Common::Array< Common::Array<int> >::const_iterator RowIter = m_VisibilityMatrix.begin();
+	while (RowIter != m_VisibilityMatrix.end()) {
 		Writer.Write(RowIter->size());
-		std::vector<int>::const_iterator ColIter = RowIter->begin();
-		while (ColIter != RowIter->end())
-		{
+		Common::Array<int>::const_iterator ColIter = RowIter->begin();
+		while (ColIter != RowIter->end()) {
 			Writer.Write(*ColIter);
 			++ColIter;
 		}
@@ -402,40 +375,36 @@ bool BS_WalkRegion::Persist(BS_OutputPersistenceBlock & Writer)
 
 // -----------------------------------------------------------------------------
 
-bool BS_WalkRegion::Unpersist(BS_InputPersistenceBlock & Reader)
-{
+bool BS_WalkRegion::Unpersist(BS_InputPersistenceBlock &Reader) {
 	bool Result = true;
 
-	// Das Elternobjekt wurde schon über den Konstruktor von BS_Region geladen, daher müssen an dieser Stelle nur noch die zusätzlichen Daten von
-	// BS_WalkRegion geladen werden.
+	// The parent object was already loaded in the constructor of BS_Region, so at
+	// this point only the additional data from BS_WalkRegion needs to be loaded
 
-	// Knoten laden.
+	// Node load
 	unsigned int NodeCount;
 	Reader.Read(NodeCount);
 	m_Nodes.clear();
 	m_Nodes.resize(NodeCount);
-	std::vector<BS_Vertex>::iterator It = m_Nodes.begin();
-	while (It != m_Nodes.end())
-	{
+	Common::Array<BS_Vertex>::iterator It = m_Nodes.begin();
+	while (It != m_Nodes.end()) {
 		Reader.Read(It->X);
 		Reader.Read(It->Y);
 		++It;
 	}
 
-	// Sichtbarkeitsmatrix laden.
+	// Visibility matrix load
 	unsigned int RowCount;
 	Reader.Read(RowCount);
 	m_VisibilityMatrix.clear();
 	m_VisibilityMatrix.resize(RowCount);
-	std::vector< std::vector<int> >::iterator RowIter = m_VisibilityMatrix.begin();
-	while (RowIter != m_VisibilityMatrix.end())
-	{
+	Common::Array< Common::Array<int> >::iterator RowIter = m_VisibilityMatrix.begin();
+	while (RowIter != m_VisibilityMatrix.end()) {
 		unsigned int ColCount;
 		Reader.Read(ColCount);
 		RowIter->resize(ColCount);
-		std::vector<int>::iterator ColIter = RowIter->begin();
-		while (ColIter != RowIter->end())
-		{
+		Common::Array<int>::iterator ColIter = RowIter->begin();
+		while (ColIter != RowIter->end()) {
 			Reader.Read(*ColIter);
 			++ColIter;
 		}
@@ -445,3 +414,5 @@ bool BS_WalkRegion::Unpersist(BS_InputPersistenceBlock & Reader)
 
 	return Result && Reader.IsGood();
 }
+
+} // End of namespace Sword25
diff --git a/engines/sword25/math/walkregion.h b/engines/sword25/math/walkregion.h
index 8c61720a12..6b06c8ed30 100644
--- a/engines/sword25/math/walkregion.h
+++ b/engines/sword25/math/walkregion.h
@@ -35,83 +35,83 @@
 #ifndef SWORD25_WALKREGION_H
 #define SWORD25_WALKREGION_H
 
-#include "sword25/kernel/memlog_off.h"
-#include <vector>
-#include "sword25/kernel/memlog_on.h"
-
+#include "common/array.h"
 #include "sword25/kernel/common.h"
 #include "sword25/math/region.h"
 
+namespace Sword25 {
+
 // -----------------------------------------------------------------------------
-// Typdefinitionen
+// Type definitions
 // -----------------------------------------------------------------------------
 
-typedef std::vector<BS_Vertex> BS_Path;
+typedef Common::Array<BS_Vertex> BS_Path;
 
 // -----------------------------------------------------------------------------
-// Klassendefinition
+// Class definitions
 // -----------------------------------------------------------------------------
 
 /**
-	@brief Diese Klasse stellt die Region dar, in der sich der Hauptcharakter bewegen kann.
-*/
-class BS_WalkRegion : public BS_Region
-{
+ * This class represents the region in which the main character can move
+ */
+class BS_WalkRegion : public BS_Region {
 	friend class BS_Region;
 
 protected:
 	BS_WalkRegion();
-	BS_WalkRegion(BS_InputPersistenceBlock & Reader, unsigned int Handle);
+	BS_WalkRegion(BS_InputPersistenceBlock &Reader, unsigned int Handle);
 
 public:
 	virtual ~BS_WalkRegion();
 
-	virtual bool Init(const BS_Polygon & Contour, const std::vector<BS_Polygon> * pHoles = 0);
+	virtual bool Init(const BS_Polygon &Contour, const Common::Array<BS_Polygon> *pHoles = 0);
 
 	/**
-		@brief Ermittelt den kürzesten Weg zwischen zwei Punkten in der Region.
-
-		Diese Methode verlangt, dass der Startpunkt innerhalb der Region liegt. Der Endpunkt darf außerhalb der Region liegen. In diesem
-		Fall wählt die Methode als Endpunkt den Punkt innerhalb der Region, der am dichtesten am Endpunkt liegt.
-
-		@param X1 X-Koordinate des Startpunktes
-		@param Y1 Y-Koordinate des Startpunktes
-		@param X2 X-Koordinate des Zielpunktes
-		@param Y2 Y-Koordinate des Zielpunktes
-		@param Path ein leerer BS_Path, der den Ergebnispfad aufnehmen soll
-		@return Gibt false zurück, fall die Eingaben ungültig waren, ansonsten wird true zurückgegeben.
+	 * Get the shortest path between two points in the region
+	 *
+	 * This method requires that the starting point lies within the region. The end point
+	 * may lie outside the region. Int his case, the end is chosen as the cloest point to it
+	 * that lies within the region.
+	 *
+	 * @param X1			X Co-ordinate of the start point
+	 * @param Y1			Y Co-ordinate of the start point
+	 * @param X2			X Co-ordinate of the end point
+	 * @param Y2			Y Co-ordinate of the end point
+	 * @param Path			An empty BS_Path that will be set to the resulting path
+	 * @return				Returns false if the result is invalid, otherwise returns true.
 	 */
-	bool QueryPath(int X1, int Y1, int X2, int Y2, BS_Path & Path) { return QueryPath(BS_Vertex(X1, Y1), BS_Vertex(X2, Y2), Path); }
+	bool QueryPath(int X1, int Y1, int X2, int Y2, BS_Path &Path) { 
+		return QueryPath(BS_Vertex(X1, Y1), BS_Vertex(X2, Y2), Path);
+	}
 
 	/**
-		@brief Ermittelt den kürzesten Weg zwischen zwei Punkten in der Region.
-
-		Diese Methode verlangt, dass der Startpunkt innerhalb der Region liegt. Der Endpunkt darf außerhalb der Region liegen. In diesem
-		Fall wählt die Methode als Endpunkt den Punkt innerhalb der Region, der am dichtesten am Endpunkt liegt.
-		
-		@param StartPoint der Startpunkt
-		@param EndPoint der Endpunkt
-		@param Path ein leerer BS_Path, der den Ergebnispfad aufnehmen soll
-		@return Gibt false zurück, fall die Eingaben ungültig waren, ansonsten wird true zurückgegeben.
+	 * Get the shortest path between two points in the region.
+	 *
+	 * @param StartPoint	The start point
+	 * @param EndPoint		The end point
+	 * @param Path			An empty BS_Path that will be set to the resulting path
+	 * @return				Returns false if the result is invalid, otherwise returns true.
 	*/
 	bool QueryPath(BS_Vertex StartPoint, BS_Vertex EndPoint, BS_Path & Path);
 
 	virtual void SetPos(int X, int Y);
 
-	const std::vector<BS_Vertex> & GetNodes() const { return m_Nodes; }
-	const std::vector< std::vector<int> > & GetVisibilityMatrix() const { return m_VisibilityMatrix; }
+	const Common::Array<BS_Vertex> &GetNodes() const { return m_Nodes; }
+	const Common::Array< Common::Array<int> > &GetVisibilityMatrix() const { return m_VisibilityMatrix; }
 
-	virtual bool Persist(BS_OutputPersistenceBlock & Writer);
-	virtual bool Unpersist(BS_InputPersistenceBlock & Reader);
+	virtual bool Persist(BS_OutputPersistenceBlock &Writer);
+	virtual bool Unpersist(BS_InputPersistenceBlock &Reader);
 
 private:
-	std::vector<BS_Vertex> m_Nodes;
-	std::vector< std::vector<int> > m_VisibilityMatrix;
+	Common::Array<BS_Vertex> m_Nodes;
+	Common::Array< Common::Array<int> > m_VisibilityMatrix;
 
 	void InitNodeVector();
 	void ComputeVisibilityMatrix();
-	bool CheckAndPrepareStartAndEnd(BS_Vertex & Start, BS_Vertex & End) const;
-	bool FindPath(const BS_Vertex & Start, const BS_Vertex & End, BS_Path & Path) const;
+	bool CheckAndPrepareStartAndEnd(BS_Vertex &Start, BS_Vertex &End) const;
+	bool FindPath(const BS_Vertex &Start, const BS_Vertex &End, BS_Path &Path) const;
 };
 
+} // End of namespace Sword25
+
 #endif
diff --git a/engines/sword25/script/luascript.cpp b/engines/sword25/script/luascript.cpp
index 22d2a28072..8af0128c72 100644
--- a/engines/sword25/script/luascript.cpp
+++ b/engines/sword25/script/luascript.cpp
@@ -540,7 +540,7 @@ bool BS_LuaScriptEngine::Unpersist(BS_InputPersistenceBlock &Reader) {
 	ClearGlobalTable(m_State, ClearExceptionsSecondPass);
 
 	// Persisted Lua data
-	vector<unsigned char> chunkData;
+	Common::Array<unsigned char> chunkData;
 	Reader.Read(chunkData);
 
 	// Chunk-Reader initialisation. It is used with pluto_unpersist to restore read data