From 4720a00f98b19f792a4e377dde44acfebfaccfac Mon Sep 17 00:00:00 2001
From: Ykkrosh <philip@wildfiregames.com>
Date: Wed, 12 Jan 2005 14:31:47 +0000
Subject: [PATCH] Made ScEd output entities into an XML file.

Added CStrW::utf8() (used by XMLWriter).

This was SVN commit r1716.
---
 binaries/data/mods/official/maps/scenario.dtd |  19 +++
 source/graphics/MapIO.h                       |   2 +-
 source/graphics/MapReader.cpp                 | 152 +++++++++++++++---
 source/graphics/MapReader.h                   |   3 +
 source/graphics/MapWriter.cpp                 | 103 +++++++++++-
 source/graphics/MapWriter.h                   |   3 +
 source/graphics/ObjectEntry.cpp               |  18 ++-
 source/graphics/ObjectManager.cpp             |   2 +-
 source/main.cpp                               |   2 +
 source/ps/CStr.cpp                            |  42 ++++-
 source/ps/CStr.h                              |  12 +-
 source/ps/FileUnpacker.h                      |   2 +-
 source/ps/XMLWriter.cpp                       |  10 +-
 source/ps/XMLWriter.h                         |   2 +
 source/simulation/Entity.cpp                  |   5 +
 source/simulation/EntityManager.cpp           |   1 -
 source/tests/Tests.cpp                        |  60 +++++++
 source/tools/sced/EditorData.cpp              |  38 +----
 source/tools/sced/PaintObjectCommand.cpp      |   2 +-
 source/tools/sced/PaintObjectTool.cpp         |   1 +
 source/tools/sced/ui/MainFrm.cpp              |   4 +
 21 files changed, 407 insertions(+), 76 deletions(-)
 create mode 100644 binaries/data/mods/official/maps/scenario.dtd

diff --git a/binaries/data/mods/official/maps/scenario.dtd b/binaries/data/mods/official/maps/scenario.dtd
new file mode 100644
index 0000000000..8c826f9696
--- /dev/null
+++ b/binaries/data/mods/official/maps/scenario.dtd
@@ -0,0 +1,19 @@
+<!ELEMENT Scenario (Entities)>
+
+	<!ELEMENT Entities (Entity*)>
+
+		<!ELEMENT Entity (Template,Position,Orientation)>
+
+			<!ELEMENT Template (#PCDATA)>
+
+			<!ELEMENT Position EMPTY>
+			<!ATTLIST Position
+				x CDATA #REQUIRED
+				y CDATA #REQUIRED
+				z CDATA #REQUIRED
+			>
+
+			<!ELEMENT Orientation EMPTY>
+			<!ATTLIST Orientation
+				angle CDATA #REQUIRED
+			>
diff --git a/source/graphics/MapIO.h b/source/graphics/MapIO.h
index 57d6e2e6cc..bd6305623f 100755
--- a/source/graphics/MapIO.h
+++ b/source/graphics/MapIO.h
@@ -5,7 +5,7 @@ class CMapIO
 {
 public:
 	// current file version given to saved maps 
-	enum { FILE_VERSION = 2 };
+	enum { FILE_VERSION = 3 };
 	// supported file read version - file with version less than this will be reject
 	enum { FILE_READ_VERSION = 1 };
 
diff --git a/source/graphics/MapReader.cpp b/source/graphics/MapReader.cpp
index d73a1363d0..f80c447b28 100755
--- a/source/graphics/MapReader.cpp
+++ b/source/graphics/MapReader.cpp
@@ -32,8 +32,15 @@ void CMapReader::LoadMap(const char* filename, CTerrain *pTerrain, CUnitManager
 	// unpack the data
 	UnpackMap(unpacker);
 
-	// finally, apply data to the world
+	// apply data to the world
 	ApplyData(unpacker, pTerrain, pUnitMan, pLightEnv);
+
+	if (unpacker.GetVersion()>=3) {
+		// read the corresponding XML file
+		CStr filename_xml (filename);
+		filename_xml = filename_xml.Left(filename_xml.Length()-4) + ".xml";
+		ReadXML(filename_xml);
+	}
 }
 
 // UnpackMap: unpack the given data from the raw data stream into local variables
@@ -148,29 +155,33 @@ void CMapReader::ApplyData(CFileUnpacker& unpacker, CTerrain *pTerrain, CUnitMan
 	for (u32 i=0;i<m_Objects.size();i++) {
 		CObjectEntry* objentry=m_ObjectTypes[m_Objects[i].m_ObjectIndex];
 		if (objentry && objentry->m_Model) {
-			// Hijack the standard actor instantiation for actors that correspond to entities.
-			// Not an ideal solution; we'll have to figure out a map format that can define entities separately or somesuch.
 
-			CBaseEntity* templateObject = g_EntityTemplateCollection.getTemplateByActor( objentry );
-			
-			if( templateObject )
-			{
-				CVector3D orient = ((CMatrix3D*)m_Objects[i].m_Transform)->GetIn();
-				CVector3D position = ((CMatrix3D*)m_Objects[i].m_Transform)->GetTranslation();
-
-				g_EntityManager.create( templateObject, position, atan2( -orient.X, -orient.Z ) );
-			}
-			else
-			{
-				CUnit* unit=new CUnit(objentry,objentry->m_Model->Clone());
-			
-				CMatrix3D transform;
-				memcpy(&transform._11,m_Objects[i].m_Transform,sizeof(float)*16);
-				unit->GetModel()->SetTransform(transform);
+			if (unpacker.GetVersion() < 3) {
 				
-				// add this unit to list of units stored in unit manager
-				pUnitMan->AddUnit(unit);
+				// Hijack the standard actor instantiation for actors that correspond to entities.
+				// Not an ideal solution; we'll have to figure out a map format that can define entities separately or somesuch.
+
+				CBaseEntity* templateObject = g_EntityTemplateCollection.getTemplateByActor(objentry);
+			
+				if (templateObject)
+				{
+					CVector3D orient = ((CMatrix3D*)m_Objects[i].m_Transform)->GetIn();
+					CVector3D position = ((CMatrix3D*)m_Objects[i].m_Transform)->GetTranslation();
+
+					g_EntityManager.create(templateObject, position, atan2(-orient.X, -orient.Z));
+
+					continue;
+				}
 			}
+
+			CUnit* unit=new CUnit(objentry,objentry->m_Model->Clone());
+			
+			CMatrix3D transform;
+			memcpy(&transform._11,m_Objects[i].m_Transform,sizeof(float)*16);
+			unit->GetModel()->SetTransform(transform);
+			
+			// add this unit to list of units stored in unit manager
+			pUnitMan->AddUnit(unit);
 		}
 	}
 
@@ -179,3 +190,102 @@ void CMapReader::ApplyData(CFileUnpacker& unpacker, CTerrain *pTerrain, CUnitMan
 		*pLightEnv=m_LightEnv;
 	}
 }
+
+
+void CMapReader::ReadXML(const char* filename)
+{
+#ifdef SCED
+	// HACK: ScEd uses absolute filenames, not VFS paths. I can't be bothered
+	// to make Xeromyces work with non-VFS, so just cheat:
+	CStr filename_vfs (filename);
+	filename_vfs = filename_vfs.substr(filename_vfs.ReverseFind("\\mods\\official\\") + 15);
+	filename_vfs.Replace("\\", "/");
+	filename = filename_vfs;
+#endif
+
+	CXeromyces XeroFile;
+	if (XeroFile.Load(filename) != PSRETURN_OK)
+		throw CFileUnpacker::CFileReadError();
+
+	// Define all the elements and attributes used in the XML file
+#define EL(x) int el_##x = XeroFile.getElementID(#x)
+#define AT(x) int at_##x = XeroFile.getAttributeID(#x)
+	EL(scenario);
+	EL(entities);
+	EL(entity);
+	EL(template);
+	EL(position);
+	EL(orientation);
+	AT(x);
+	AT(y);
+	AT(z);
+	AT(angle);
+#undef AT
+#undef EL
+
+	XMBElement root = XeroFile.getRoot();
+	assert(root.getNodeName() == el_scenario);
+
+	// <scenario>
+
+	XMBElementList children = root.getChildNodes();
+	for (int i = 0; i < children.Count; ++i)
+	{
+		XMBElement child = children.item(i);
+		if (child.getNodeName() == el_entities)
+		{
+			// <entities>
+
+			XMBElementList children = child.getChildNodes();
+			for (int i = 0; i < children.Count; ++i)
+			{
+				XMBElement child = children.item(i);
+				assert(child.getNodeName() == el_entity);
+
+				// <entity>
+
+				CStrW TemplateName;
+				CVector3D Position;
+				float Orientation;
+
+				XMBElementList children = child.getChildNodes();
+				for (int i = 0; i < children.Count; ++i)
+				{
+					XMBElement child = children.item(i);
+					int element_name = child.getNodeName();
+
+					if (element_name == el_template)
+					{
+						// <template>
+						TemplateName = child.getText();
+					}
+					else if (element_name == el_position)
+					{
+						// <position>
+						XMBAttributeList attrs = child.getAttributes();
+						Position = CVector3D(
+							CStr(attrs.getNamedItem(at_x)).ToFloat(),
+							CStr(attrs.getNamedItem(at_y)).ToFloat(),
+							CStr(attrs.getNamedItem(at_z)).ToFloat()
+						);
+					}
+					else if (element_name == el_orientation)
+					{
+						// <orientation>
+						XMBAttributeList attrs = child.getAttributes();
+						Orientation = CStr(attrs.getNamedItem(at_angle)).ToFloat();
+					}
+					else
+						debug_warn("Invalid XML data - DTD shouldn't allow this");
+				}
+
+				g_EntityManager.create(g_EntityTemplateCollection.getTemplate(TemplateName), Position, Orientation);
+			}
+		}
+		else
+		{
+			debug_warn("Invalid XML data - DTD shouldn't allow this");
+		}
+	}
+
+}
diff --git a/source/graphics/MapReader.h b/source/graphics/MapReader.h
index 09eb8d346c..83233b029d 100755
--- a/source/graphics/MapReader.h
+++ b/source/graphics/MapReader.h
@@ -33,6 +33,9 @@ private:
 	// ApplyData: take all the input data, and rebuild the scene from it
 	void ApplyData(CFileUnpacker& unpacker, CTerrain *pTerrain, CUnitManager *pUnitMan, CLightEnv *pLightEnv);
 
+	// ReadXML: read some other data (entities, etc) in XML format
+	void ReadXML(const char* filename);
+
 	// size of map 
 	u32 m_MapSize;
 	// heightmap for map
diff --git a/source/graphics/MapWriter.cpp b/source/graphics/MapWriter.cpp
index bee1d9fde5..e682c42e6c 100755
--- a/source/graphics/MapWriter.cpp
+++ b/source/graphics/MapWriter.cpp
@@ -10,6 +10,12 @@
 #include "LightEnv.h"
 #include "TextureManager.h"
 
+#include "ps/XMLWriter.h"
+#include "lib/res/vfs.h"
+#include "simulation/Entity.h"
+#include "simulation/BaseEntity.h"
+#include "simulation/BaseEntityCollection.h"
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // CMapWriter constructor: nothing to do at the minute
 CMapWriter::CMapWriter()
@@ -27,6 +33,10 @@ void CMapWriter::SaveMap(const char* filename, CTerrain *pTerrain, CLightEnv *pL
 
 	// write it out
 	packer.Write(filename);
+
+	CStr filename_xml (filename);
+	filename_xml = filename_xml.Left(filename_xml.Length()-4) + ".xml";
+	WriteXML(filename_xml, pUnitMan);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -118,22 +128,29 @@ void CMapWriter::EnumObjects(CUnitManager *pUnitMan,
 	
 	// resize object array to required size
 	const std::vector<CUnit*>& units=pUnitMan->GetUnits();
-	objects.resize(units.size());
-	SObjectDesc* objptr=&objects[0];
+	objects.clear();
+	objects.reserve(units.size()); // slightly larger than necessary (if there are some entities)
 
 	// now iterate through all the units
-	for (u32 j=0;j<(u32)units.size();j++) {
+	for (size_t j=0;j<units.size();j++) {
+
 		CUnit* unit=units[j];
 
+		// Ignore entities, since they're outputted to XML instead
+		if (unit->GetEntity())
+			continue;
+
 		u16 index=u16(GetObjectIndex(unit->GetObject(),objectsInUse));
 		if (index==0xffff) {
 			index=(u16)objectsInUse.size();
 			objectsInUse.push_back(unit->GetObject());
 		}
 
-		objptr->m_ObjectIndex=index;
-		memcpy(objptr->m_Transform,&unit->GetModel()->GetTransform()._11,sizeof(float)*16);
-		objptr++;
+		SObjectDesc obj;
+		obj.m_ObjectIndex=index;
+		memcpy(obj.m_Transform,&unit->GetModel()->GetTransform()._11,sizeof(float)*16);
+
+		objects.push_back(obj);
 	}
 
 	// now build outgoing objectTypes array
@@ -220,3 +237,77 @@ void CMapWriter::PackTerrain(CFilePacker& packer, CTerrain *pTerrain)
 	packer.PackRaw(&tiles[0],(u32)(sizeof(STileDesc)*tiles.size()));	
 }
 
+
+
+void CMapWriter::WriteXML(const char* filename, CUnitManager* pUnitMan)
+{
+	// HACK: ScEd uses non-VFS filenames, so just use fopen instead of vfs_open
+#ifdef SCED
+	FILE* f = fopen(filename, "wb");
+	if (! f)
+	{
+		debug_warn("Failed to open map XML file");
+		return;
+	}
+#else
+	Handle h = vfs_open(filename, FILE_WRITE|FILE_NO_AIO);
+	if (h <= 0)
+	{
+		debug_warn("Failed to open map XML file");
+		return;
+	}
+#endif
+
+	XML_Start("utf-8");
+	XML_Doctype("Scenario", "/maps/scenario.dtd");
+
+	{
+		XML_Element("Scenario");
+		{
+			XML_Element("Entities");
+
+			const std::vector<CUnit*>& units = pUnitMan->GetUnits();
+			for (std::vector<CUnit*>::const_iterator unit = units.begin(); unit != units.end(); ++unit) {
+
+				CEntity* entity = (*unit)->GetEntity();
+
+				// Ignore objects that aren't entities
+				if (! entity)
+					continue;
+
+				XML_Element("Entity");
+
+				XML_Setting("Template", entity->m_base->m_Tag);
+
+				{
+					CVector3D position = entity->m_position;
+
+					XML_Element("Position");
+					XML_Attribute("x", position.X);
+					XML_Attribute("y", position.Y);
+					XML_Attribute("z", position.Z);
+				}
+
+				{
+					float angle = entity->m_orientation;
+
+					XML_Element("Orientation");
+					XML_Attribute("angle", angle);
+				}
+			}
+		}
+	}
+
+	// HACK: continued from above
+#ifdef SCED
+	CStr d = xml_file_.HACK_GetData();
+	fwrite(d.data(), d.length(), 1, f);
+	fclose(f);
+#else
+	if (! XML_StoreVFS(h))
+	{
+		debug_warn("Failed to write map XML file");
+	}
+	vfs_close(h);
+#endif
+}
\ No newline at end of file
diff --git a/source/graphics/MapWriter.h b/source/graphics/MapWriter.h
index 042d6bc3db..7214b03437 100755
--- a/source/graphics/MapWriter.h
+++ b/source/graphics/MapWriter.h
@@ -37,6 +37,9 @@ private:
 	// each object in the world
 	void EnumObjects(CUnitManager *pUnitMan, std::vector<CStr>& objectTypes,
 		std::vector<SObjectDesc>& objects);
+
+	// WriteXML: output some other data (entities, etc) in XML format
+	void WriteXML(const char* filename, CUnitManager* pUnitMan);
 };
 
 #endif
diff --git a/source/graphics/ObjectEntry.cpp b/source/graphics/ObjectEntry.cpp
index aa926d60a1..af9f8987a0 100755
--- a/source/graphics/ObjectEntry.cpp
+++ b/source/graphics/ObjectEntry.cpp
@@ -80,16 +80,24 @@ bool CObjectEntry::BuildModel()
 			const char* animfilename = m_Animations[t].m_FileName.c_str();
 			m_Animations[t].m_AnimData = m_Model->BuildAnimation(animfilename,m_Animations[t].m_Speed);
 
-			if( m_Animations[t].m_AnimName.LowerCase() == "idle" )
+			CStr AnimNameLC = m_Animations[t].m_AnimName.LowerCase();
+
+			if( AnimNameLC == "idle" )
 				m_IdleAnim = m_Animations[t].m_AnimData;
-			if( m_Animations[t].m_AnimName.LowerCase() == "walk" )
+			else
+			if( AnimNameLC == "walk" )
 				m_WalkAnim = m_Animations[t].m_AnimData;
-			if( m_Animations[t].m_AnimName.LowerCase() == "attack" )
+			else
+			if( AnimNameLC == "attack" )
 				m_MeleeAnim = m_Animations[t].m_AnimData;
-			if( m_Animations[t].m_AnimName.LowerCase() == "death" )
+			else
+			if( AnimNameLC == "death" )
 				m_DeathAnim = m_Animations[t].m_AnimData;
-			if( m_Animations[t].m_AnimName.LowerCase() == "decay" )
+			else
+			if( AnimNameLC == "decay" )
 				m_CorpseAnim = m_Animations[t].m_AnimData;
+			//else
+			//	debug_out("Invalid animation name '%s'\n", (const char*)AnimNameLC);
 		}
 		else
 		{
diff --git a/source/graphics/ObjectManager.cpp b/source/graphics/ObjectManager.cpp
index 9aedd761a0..214b392e2c 100755
--- a/source/graphics/ObjectManager.cpp
+++ b/source/graphics/ObjectManager.cpp
@@ -142,7 +142,7 @@ void CObjectManager::LoadObjects(int type)
 	pathname += m_ObjectTypes[type].m_Name;
 	pathname += "/";
 
-	Handle dir=vfs_open_dir(pathname.c_str());
+	Handle dir=vfs_open_dir(pathname);
 	vfsDirEnt dent;
 	
 	if (dir > 0)
diff --git a/source/main.cpp b/source/main.cpp
index 0c7f4b0e99..e7bb54eccb 100755
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -1345,6 +1345,8 @@ void ScEd_Init()
 	char path[512];
 	::GetModuleFileName(0,path,512);
 
+	g_Quickstart = true;
+
 	char* argv[1];
 	argv[0] = path;
 	Init(1, argv, false);
diff --git a/source/ps/CStr.cpp b/source/ps/CStr.cpp
index 022003d145..b2fefab9a0 100755
--- a/source/ps/CStr.cpp
+++ b/source/ps/CStr.cpp
@@ -13,6 +13,40 @@
 CStrW::CStrW(const CStr8 &asciStr) : std::wstring(asciStr.begin(), asciStr.end()) {}
 CStr8::CStr8(const CStrW &wideStr) : std:: string(wideStr.begin(), wideStr.end()) {}
 
+static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+CStr8 CStrW::utf8() const
+{
+	// Adapted from http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+
+	CStr8 result;
+
+	const wchar_t* source = &*begin();
+	for (size_t i = 0; i < Length(); ++i)
+	{
+		unsigned short bytesToWrite;
+		wchar_t ch = (*this)[i];
+
+		if (ch < 0x80) bytesToWrite = 1;
+		else if (ch < 0x800) bytesToWrite = 2;
+		else if (ch < 0x10000) bytesToWrite = 3;
+		else if (ch <= 0x7FFFFFFF) bytesToWrite = 4;
+		else bytesToWrite = 3, ch = 0x0000FFFD; // replacement character
+
+		char buf[4];
+		char* target = &buf[bytesToWrite];
+		switch (bytesToWrite)
+		{
+			case 4: *--target = ((ch | 0x80) & 0xBF); ch >>= 6;
+			case 3: *--target = ((ch | 0x80) & 0xBF); ch >>= 6;
+			case 2: *--target = ((ch | 0x80) & 0xBF); ch >>= 6;
+			case 1: *--target = (ch | firstByteMark[bytesToWrite]);
+		}
+		result += CStr(buf, bytesToWrite);
+	}
+	return result;
+}
+
+
 #else
 
 #include "CStr.h"
@@ -175,18 +209,18 @@ CStr CStr::UCase() const
 }
 
 // Retrieve the substring of the first n characters 
-CStr CStr::Left(long len) const
+CStr CStr::Left(size_t len) const
 {
 	assert(len >= 0);
-	assert(len <= (long)length());
+	assert(len <= length());
 	return substr(0, len);
 }
 
 // Retrieve the substring of the last n characters
-CStr CStr::Right(long len) const
+CStr CStr::Right(size_t len) const
 {
 	assert(len >= 0);
-	assert(len <= (long)length());
+	assert(len <= length());
 	return substr(length()-len, len);
 }
 
diff --git a/source/ps/CStr.h b/source/ps/CStr.h
index e0585d2d18..6f07a00a8f 100755
--- a/source/ps/CStr.h
+++ b/source/ps/CStr.h
@@ -119,7 +119,8 @@ public:
 		CStr(utf16string String) : std::tstring(String.begin(), String.end()) {}
 	#endif
 
-	// Transparent CStrW/8 conversion.
+	// Transparent CStrW/8 conversion. Non-ASCII characters are not
+	// handled correctly.
 	#ifndef _UNICODE
 		CStr8(const CStrW &wideStr);
 	#else
@@ -170,10 +171,10 @@ public:
 	CStr UCase() const;
 
 	// Retrieve the substring of the first n characters 
-	CStr Left(long len) const;
+	CStr Left(size_t len) const;
 
 	// Retrieve the substring of the last n characters
-	CStr Right(long len) const;
+	CStr Right(size_t len) const;
 	
 	// Remove all occurrences of some character or substring 
 	void Remove(const CStr& Str);
@@ -213,6 +214,11 @@ public:
 	// Conversion to utf16string
 	inline utf16string utf16() const
 	{	return utf16string(begin(), end()); }
+
+	// Conversion to UTF-8, encoded in a CStr8
+#ifdef _UNICODE
+	CStr8 utf8() const;
+#endif
 	
 	// Calculates a hash of the string's contents
 	size_t GetHashCode() const;
diff --git a/source/ps/FileUnpacker.h b/source/ps/FileUnpacker.h
index 477178d3c8..dc83615f71 100755
--- a/source/ps/FileUnpacker.h
+++ b/source/ps/FileUnpacker.h
@@ -15,7 +15,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // CFileUnpacker: class to assist in reading of binary files
-class CFileUnpacker 
+class CFileUnpacker
 {
 public:
 	// exceptions thrown by class
diff --git a/source/ps/XMLWriter.cpp b/source/ps/XMLWriter.cpp
index 2d5654a69c..3fbeff121b 100644
--- a/source/ps/XMLWriter.cpp
+++ b/source/ps/XMLWriter.cpp
@@ -5,6 +5,9 @@
 #include "ps/CLogger.h"
 #include "lib/res/vfs.h"
 
+// TODO: Write to the VFS handle all the time frequently, instead of buffering
+// the entire file, so that large files get written faster.
+
 enum { EL_ATTR, EL_TEXT, EL_SUBEL };
 
 XMLWriter_File::XMLWriter_File(const char* encoding)
@@ -152,4 +155,9 @@ template <> void XMLWriter_File::ElementAttribute<T>(const char* name, T& value,
 TYPE(int)
 TYPE(float)
 TYPE(double)
-TYPE(const char*)
\ No newline at end of file
+TYPE(const char*)
+
+template <> void XMLWriter_File::ElementAttribute<CStrW>(const char* name, CStrW& value, bool newelement)
+{
+	ElementAttribute(name, value.utf8(), newelement);
+}
diff --git a/source/ps/XMLWriter.h b/source/ps/XMLWriter.h
index 9c7a27fb68..7c187aa0d8 100644
--- a/source/ps/XMLWriter.h
+++ b/source/ps/XMLWriter.h
@@ -92,6 +92,8 @@ public:
 
 	bool StoreVFS(Handle h);
 
+	CStr HACK_GetData() { return m_Data; }
+
 private:
 
 	friend class XMLWriter_Element;
diff --git a/source/simulation/Entity.cpp b/source/simulation/Entity.cpp
index 5b50fff177..3eddb5c5f1 100755
--- a/source/simulation/Entity.cpp
+++ b/source/simulation/Entity.cpp
@@ -149,7 +149,12 @@ void CEntity::snapToGround()
 {
 	CTerrain *pTerrain = g_Game->GetWorld()->GetTerrain();
 	
+#ifdef SCED
+	extern CTerrain g_Terrain;
+	m_graphics_position.Y = g_Terrain.getExactGroundLevel( m_graphics_position.X, m_graphics_position.Z );
+#else
 	m_graphics_position.Y = pTerrain->getExactGroundLevel( m_graphics_position.X, m_graphics_position.Z );
+#endif
 }
 
 void CEntity::update( size_t timestep )
diff --git a/source/simulation/EntityManager.cpp b/source/simulation/EntityManager.cpp
index c531fa6bf9..b2caf1f9f8 100755
--- a/source/simulation/EntityManager.cpp
+++ b/source/simulation/EntityManager.cpp
@@ -134,7 +134,6 @@ void CEntityManager::destroy( u16 handle )
 {
 	m_reaper.push_back( m_entities[handle].m_entity );
 	m_entities[handle].m_entity->me.m_handle = INVALID_HANDLE;
-	//delete( m_entities[handle].m_entity ); // PT: Don't delete here, because the reaper will kill it later
 }
 
 bool CEntityManager::m_extant = false;
diff --git a/source/tests/Tests.cpp b/source/tests/Tests.cpp
index 3e62be7c4d..2982d22fb7 100755
--- a/source/tests/Tests.cpp
+++ b/source/tests/Tests.cpp
@@ -2,6 +2,7 @@
 
 #include "ps/CLogger.h"
 #include "ps/Parser.h"
+#include "ps/XMLWriter.h"
 
 #define ensure(x) if (!(x)) { ++err_count; LOG(ERROR, "", "%s:%d - test failed! (%s)", __FILE__, __LINE__, #x); }
 
@@ -96,4 +97,63 @@ void PerformTests()
 		LOG(ERROR, "", "%d test failures!", err_count);
 		debug_warn("Test failures!");
 	}
+
+
+
+	{
+		XML_Start("utf-8");
+		XML_Doctype("Scenario", "/maps/scenario.dtd");
+
+		{
+			XML_Element("Scenario");
+			{
+				XML_Comment("Comment test.");
+				XML_Comment("Comment test again.");
+				{
+					XML_Element("a");
+					XML_Attribute("one", 1);
+					XML_Attribute("two", "TWO");
+					XML_Text("b");
+					XML_Text(" (etc)");
+				}
+				{
+					XML_Element("c");
+					XML_Text("d");
+				}
+				XML_Setting("c2", "d2");
+				{
+					XML_Element("e");
+					{
+						{
+							XML_Element("f");
+							XML_Text("g");
+						}
+						{
+							XML_Element("h");
+						}
+						{
+							XML_Element("i");
+							XML_Attribute("j", 1.23);
+							{
+								XML_Element("k");
+								XML_Attribute("l", 2.34);
+								XML_Text("m");
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// For this test to be useful, it should actually test something.
+	}
+
+	{
+ 		const wchar_t chr_utf16[] = { 0x12, 0xff, 0x1234, 0x3456, 0x5678, 0x7890, 0x9abc, 0xbcde, 0xfffe };
+		const unsigned char chr_utf8[] = { 0x12, 0xc3, 0xbf, 0xe1, 0x88, 0xb4, 0xe3, 0x91, 0x96, 0xe5, 0x99, 0xb8, 0xe7, 0xa2, 0x90, 0xe9, 0xaa, 0xbc, 0xeb, 0xb3, 0x9e, 0xef, 0xbf, 0xbe };
+		CStrW str_utf16 (chr_utf16, sizeof(chr_utf16)/sizeof(wchar_t));
+		CStr8 str_utf8 = str_utf16.utf8();
+		ensure(str_utf8.length() == sizeof(chr_utf8));
+		ensure(memcmp(str_utf8.data(), chr_utf8, sizeof(chr_utf8)) == 0);
+	}
 }
\ No newline at end of file
diff --git a/source/tools/sced/EditorData.cpp b/source/tools/sced/EditorData.cpp
index c87842f733..8f640b67eb 100755
--- a/source/tools/sced/EditorData.cpp
+++ b/source/tools/sced/EditorData.cpp
@@ -187,29 +187,15 @@ void CEditorData::InitResources()
 // InitSingletons: create and initialise required singletons
 void CEditorData::InitSingletons()
 {
-//	// create terrain related stuff
-//	new CTextureManager;
-//
-//	// create actor related stuff
-//	new CSkeletonAnimManager;
-//	new CObjectManager;
-//	new CUnitManager;
-//
-//	// create entity related stuff 
-//	new CBaseEntityCollection;
-//	new CEntityManager;
-//	g_EntityTemplateCollection.loadTemplates();
+	new CEntityManager;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Init: perform one time initialisation of the editor
 bool CEditorData::Init()
 {
-//	// start up Xerces
-//	XMLPlatformUtils::Initialize();
-//
-//	// create and initialise singletons
-//	InitSingletons();
+	// create and initialise singletons
+	InitSingletons();
 
 	// load default textures
 	InitResources();
@@ -223,6 +209,8 @@ bool CEditorData::Init()
 	// set up the info box
 	m_InfoBox.Initialise();
 
+	g_EntityTemplateCollection.loadTemplates();
+
 	return true;
 }
 
@@ -230,20 +218,7 @@ bool CEditorData::Init()
 // Terminate: close down the editor (destroy singletons in reverse order to construction)
 void CEditorData::Terminate()
 {
-//	// destroy entity related stuff 
-//	delete CEntityManager::GetSingletonPtr();
-//	delete CBaseEntityCollection::GetSingletonPtr();
-//
-//	// destroy actor related stuff
-//	delete CUnitManager::GetSingletonPtr();
-//	delete CObjectManager::GetSingletonPtr();
-//	delete CSkeletonAnimManager::GetSingletonPtr();
-//
-//	// destroy terrain related stuff
-//	delete CTextureManager::GetSingletonPtr();
-
-	// close down Xerces
-//	XMLPlatformUtils::Terminate();
+	delete &g_EntityManager;
 }
 
 void CEditorData::InitCamera() 
@@ -636,6 +611,7 @@ bool CEditorData::LoadTerrain(const char* filename)
 void CEditorData::UpdateWorld(float time)
 {
 	if (m_Mode==SCENARIO_EDIT || m_Mode==TEST_MODE) {
+		g_EntityManager.interpolateAll(0.f);
 		const std::vector<CUnit*>& units=g_UnitMan.GetUnits();
 		for (uint i=0;i<units.size();++i) {
 			units[i]->GetModel()->Update(time);
diff --git a/source/tools/sced/PaintObjectCommand.cpp b/source/tools/sced/PaintObjectCommand.cpp
index de6e04786d..195e8f098d 100755
--- a/source/tools/sced/PaintObjectCommand.cpp
+++ b/source/tools/sced/PaintObjectCommand.cpp
@@ -41,7 +41,7 @@ void CPaintObjectCommand::Finalize()
 		CVector3D orient = m_Unit->GetModel()->GetTransform().GetIn();
 		CVector3D position = m_Unit->GetModel()->GetTransform().GetTranslation();
 		g_UnitMan.RemoveUnit(m_Unit);
-		g_EntityManager.create( templateObject, position, atan2( orient.X, orient.Z ) );
+		g_EntityManager.create( templateObject, position, atan2( -orient.X, -orient.Z ) );
 	}
 }
 
diff --git a/source/tools/sced/PaintObjectTool.cpp b/source/tools/sced/PaintObjectTool.cpp
index f803fcaf29..3f26446822 100755
--- a/source/tools/sced/PaintObjectTool.cpp
+++ b/source/tools/sced/PaintObjectTool.cpp
@@ -62,6 +62,7 @@ void CPaintObjectTool::OnLButtonUp(unsigned int flags,int px,int py)
 	// terminate current command, if we've got one
 	if (m_PaintCmd) {
 		m_PaintCmd->Finalize();
+		if (! m_PaintCmd->IsUndoable()) delete m_PaintCmd;
 		m_PaintCmd=0;
 		m_Rotation=0;
 	}
diff --git a/source/tools/sced/ui/MainFrm.cpp b/source/tools/sced/ui/MainFrm.cpp
index f694ed1a7b..0115bffb2a 100755
--- a/source/tools/sced/ui/MainFrm.cpp
+++ b/source/tools/sced/ui/MainFrm.cpp
@@ -580,10 +580,12 @@ void CMainFrame::OnFileSaveMap()
 			char buf[256];
 			sprintf(buf,"Error trying to write to \"%s\"",savename);
 			MessageBox(buf,"Error",MB_OK);
+#ifdef NDEBUG
 		} catch (...) {
 			char buf[256];
 			sprintf(buf,"Error saving file \"%s\"",savename);
 			MessageBox(buf,"Error",MB_OK);
+#endif
 		}
 	}
 }
@@ -645,10 +647,12 @@ void CMainFrame::OnFileLoadMap()
 			char buf[256];
 			sprintf(buf,"Error reading \"%s\" - doesn't seem to a PMP file",loadname);
 			MessageBox(buf,"Error",MB_OK);
+#ifdef NDEBUG
 		} catch (...) {
 			char buf[256];
 			sprintf(buf,"Error loading file \"%s\"",loadname);
 			MessageBox(buf,"Error",MB_OK);
+#endif
 		}
 	}	
 }