Index: ps/trunk/source/graphics/MapReader.cpp
===================================================================
--- ps/trunk/source/graphics/MapReader.cpp	(revision 1919)
+++ ps/trunk/source/graphics/MapReader.cpp	(revision 1920)
@@ -1,300 +1,303 @@
 #include "precompiled.h"
 
 #include "types.h"
 #include "MapReader.h"
 #include "UnitManager.h"
 #include "Unit.h"
 #include "Game.h"
 #include "ObjectManager.h"
 #include "BaseEntity.h"
 #include "BaseEntityCollection.h"
 #include "EntityManager.h"
 
 #include "Model.h"
 #include "Terrain.h"
 #include "TextureManager.h"
 
 // CMapReader constructor: nothing to do at the minute
 CMapReader::CMapReader()
 {
 }
 
 // LoadMap: try to load the map from given file; reinitialise the scene to new data if successful
 void CMapReader::LoadMap(const char* filename, CTerrain *pTerrain, CUnitManager *pUnitMan, CLightEnv *pLightEnv)
 {
 	CFileUnpacker unpacker;
 	unpacker.Read(filename,"PSMP");
 
 	// check version 
 	if (unpacker.GetVersion()<FILE_READ_VERSION) {
 		throw CFileUnpacker::CFileVersionError();
 	}
 
 	// unpack the data
 	UnpackMap(unpacker);
 
 	// 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
 void CMapReader::UnpackMap(CFileUnpacker& unpacker)
 {
 	// now unpack everything into local data
 	UnpackTerrain(unpacker);
 	UnpackObjects(unpacker);
 	if (unpacker.GetVersion()>=2) {
 		UnpackLightEnv(unpacker);
 	}
 }
 
 // UnpackLightEnv: unpack lighting parameters from input stream
 void CMapReader::UnpackLightEnv(CFileUnpacker& unpacker)
 {
 	unpacker.UnpackRaw(&m_LightEnv.m_SunColor,sizeof(m_LightEnv.m_SunColor));
 	unpacker.UnpackRaw(&m_LightEnv.m_Elevation,sizeof(m_LightEnv.m_Elevation));
 	unpacker.UnpackRaw(&m_LightEnv.m_Rotation,sizeof(m_LightEnv.m_Rotation));
 	unpacker.UnpackRaw(&m_LightEnv.m_TerrainAmbientColor,sizeof(m_LightEnv.m_TerrainAmbientColor));
 	unpacker.UnpackRaw(&m_LightEnv.m_UnitsAmbientColor,sizeof(m_LightEnv.m_UnitsAmbientColor));
     m_LightEnv.CalculateSunDirection();
 }
 
 // UnpackObjects: unpack world objects from input stream
 void CMapReader::UnpackObjects(CFileUnpacker& unpacker)
 {
 	// unpack object types
 	u32 numObjTypes;
 	unpacker.UnpackRaw(&numObjTypes,sizeof(numObjTypes));	
 	m_ObjectTypes.resize(numObjTypes);
 	for (uint i=0;i<numObjTypes;i++) {
 		CStr objname;
 		unpacker.UnpackString(objname);
 
 		CObjectEntry* object=g_ObjMan.FindObject((const char*) objname);
 		m_ObjectTypes[i]=object;
 	}
 	
 	// unpack object data
 	u32 numObjects;
 	unpacker.UnpackRaw(&numObjects,sizeof(numObjects));	
 	m_Objects.resize(numObjects);
 	unpacker.UnpackRaw(&m_Objects[0],sizeof(SObjectDesc)*numObjects);	
 }
 
 // UnpackTerrain: unpack the terrain from the end of the input data stream
 //		- data: map size, heightmap, list of textures used by map, texture tile assignments
 void CMapReader::UnpackTerrain(CFileUnpacker& unpacker)
 {
 	// unpack map size
 	unpacker.UnpackRaw(&m_MapSize,sizeof(m_MapSize));	
 	
 	// unpack heightmap
 	u32 verticesPerSide=m_MapSize*PATCH_SIZE+1;
 	m_Heightmap.resize(SQR(verticesPerSide));
 	unpacker.UnpackRaw(&m_Heightmap[0],SQR(verticesPerSide)*sizeof(u16));	
 	
 	// unpack texture names; find handle for each texture
 	u32 numTextures;
 	unpacker.UnpackRaw(&numTextures,sizeof(numTextures));	
 
 	m_TerrainTextures.reserve(numTextures);
 	for (uint i=0;i<numTextures;i++) {
 		CStr texturename;
 		unpacker.UnpackString(texturename);
 
 		Handle handle;
 		CTextureEntry* texentry=g_TexMan.FindTexture(texturename);
 		if (!texentry) {
 			// ack; mismatch between texture datasets?
 			handle=0;
 		} else {
 			handle=texentry->GetHandle();
 		}
 		m_TerrainTextures.push_back(handle);
 	}
 	
 	// unpack tile data
 	u32 tilesPerSide=m_MapSize*PATCH_SIZE;
 	m_Tiles.resize(SQR(tilesPerSide));
 	unpacker.UnpackRaw(&m_Tiles[0],(u32)(sizeof(STileDesc)*m_Tiles.size()));	
 }
 
 // ApplyData: take all the input data, and rebuild the scene from it
 void CMapReader::ApplyData(CFileUnpacker& unpacker, CTerrain *pTerrain, CUnitManager *pUnitMan, CLightEnv *pLightEnv)
 {
 	// initialise the terrain 
 	pTerrain->Initialize(m_MapSize,&m_Heightmap[0]);	
 
 	// setup the textures on the minipatches
 	STileDesc* tileptr=&m_Tiles[0];
 	for (u32 j=0;j<m_MapSize;j++) {
 		for (u32 i=0;i<m_MapSize;i++) {
 			for (u32 m=0;m<PATCH_SIZE;m++) {
 				for (u32 k=0;k<PATCH_SIZE;k++) {
 					CMiniPatch& mp=pTerrain->GetPatch(i,j)->m_MiniPatches[m][k];
 					
 					mp.Tex1=m_TerrainTextures[tileptr->m_Tex1Index];
 					mp.Tex1Priority=tileptr->m_Priority;
 
 					tileptr++;
 				}
 			}
 		}
 	}
 
-	// empty out existing units
+	// remove all existing entities (by recreating the entity manager)
+	delete &g_EntityManager;
+	new CEntityManager();
+	// delete all remaining non-entity units
 	pUnitMan->DeleteAll();
 	
 	// add new objects
 	for (u32 i=0;i<m_Objects.size();i++) {
 		CObjectEntry* objentry=m_ObjectTypes[m_Objects[i].m_ObjectIndex];
 		if (objentry && objentry->m_Model) {
 
 			if (unpacker.GetVersion() < 3) {
 				
 				// 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);
 		}
 	}
 
 	if (unpacker.GetVersion()>=2) {
 		// copy over the lighting parameters
 		*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(player);
 	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;
 				int PlayerID;
 				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_player)
 					{
 						// <player>
 						PlayerID = CStr(child.getText()).ToInt();
 					}
 					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");
 				}
 
 				HEntity ent = g_EntityManager.create(g_EntityTemplateCollection.getTemplate(TemplateName), Position, Orientation);
 
 				ent->SetPlayer(g_Game->GetPlayer(PlayerID));
 			}
 		}
 		else
 		{
 			debug_warn("Invalid XML data - DTD shouldn't allow this");
 		}
 	}
 }
Index: ps/trunk/source/graphics/MapWriter.cpp
===================================================================
--- ps/trunk/source/graphics/MapWriter.cpp	(revision 1919)
+++ ps/trunk/source/graphics/MapWriter.cpp	(revision 1920)
@@ -1,315 +1,315 @@
 #include "precompiled.h"
 
 #include "types.h"
 #include "MapWriter.h"
 #include "UnitManager.h"
 #include "Unit.h"
 #include "ObjectManager.h"
 #include "Model.h"
 #include "Terrain.h"
 #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()
 {
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // SaveMap: try to save the current map to the given file
 void CMapWriter::SaveMap(const char* filename, CTerrain *pTerrain, CLightEnv *pLightEnv, CUnitManager *pUnitMan)
 {
 	CFilePacker packer(FILE_VERSION, "PSMP");
 
 	// build necessary data
 	PackMap(packer, pTerrain, pLightEnv, pUnitMan);
 
 	// write it out
 	packer.Write(filename);
 
 	CStr filename_xml (filename);
 	filename_xml = filename_xml.Left(filename_xml.Length()-4) + ".xml";
 	WriteXML(filename_xml, pUnitMan);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // GetHandleIndex: return the index of the given handle in the given list; or 0xffff if
 // handle isn't in list
 static u16 GetHandleIndex(const Handle handle,const std::vector<Handle>& handles)
 {
 	for (uint i=0;i<(uint)handles.size();i++) {
 		if (handles[i]==handle) {
 			return i;
 		}
 	}
 
 	return 0xffff;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // GetObjectIndex: return the index of the given object in the given list; or 0xffff if
 // object isn't in list
 static u16 GetObjectIndex(const CObjectEntry* object,const std::vector<CObjectEntry*>& objects)
 {
 	for (uint i=0;i<(uint)objects.size();i++) {
 		if (objects[i]==object) {
 			return i;
 		}
 	}
 
 	return 0xffff;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // EnumTerrainTextures: build lists of textures used by map, and tile descriptions for 
 // each tile on the terrain
 void CMapWriter::EnumTerrainTextures(CTerrain *pTerrain,
 									 std::vector<CStr>& textures,
 									 std::vector<STileDesc>& tiles)
 {
 	// the list of all handles in use
 	std::vector<Handle> handles;
 	
 	// resize tile array to required size
 	tiles.resize(SQR(pTerrain->GetVerticesPerSide()-1));
 	STileDesc* tileptr=&tiles[0];
 
 	// now iterate through all the tiles
 	u32 mapsize=pTerrain->GetPatchesPerSide();
 	for (u32 j=0;j<mapsize;j++) {
 		for (u32 i=0;i<mapsize;i++) {
 			for (u32 m=0;m<PATCH_SIZE;m++) {
 				for (u32 k=0;k<PATCH_SIZE;k++) {
 					CMiniPatch& mp=pTerrain->GetPatch(i,j)->m_MiniPatches[m][k];
 					u16 index=u16(GetHandleIndex(mp.Tex1,handles));
 					if (index==0xffff) {
 						index=(u16)handles.size();
 						handles.push_back(mp.Tex1);
 					}
 
 					tileptr->m_Tex1Index=index;
 					tileptr->m_Tex2Index=0xffff;
 					tileptr->m_Priority=mp.Tex1Priority;
 					tileptr++;
 				}
 			}
 		}
 	}
 
 	// now find the texture names for each handle
 	for (uint i=0;i<(uint)handles.size();i++) {
 		CStr texturename;
 		CTextureEntry* texentry=g_TexMan.FindTexture(handles[i]);
 		if (!texentry) {
 			// uh-oh, this shouldn't happen; set texturename to empty string
 			texturename="";
 		} else {
 			texturename=texentry->GetName();
 		}
 		textures.push_back(texturename);
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // EnumObjects: build lists of object types used by map, and object descriptions for 
 // each object in the world
 void CMapWriter::EnumObjects(CUnitManager *pUnitMan,
 	std::vector<CStr>& objectTypes, std::vector<SObjectDesc>& objects)
 {
 	// the list of all object entries in use
 	std::vector<CObjectEntry*> objectsInUse;
 	
 	// resize object array to required size
 	const std::vector<CUnit*>& units=pUnitMan->GetUnits();
 	objects.clear();
 	objects.reserve(units.size()); // slightly larger than necessary (if there are some entities)
 
 	// now iterate through all the units
 	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());
 		}
 
 		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
 	for (uint i=0;i<(uint)objectsInUse.size();i++) {
 		objectTypes.push_back(objectsInUse[i]->m_Name);
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PackMap: pack the current world into a raw data stream
 void CMapWriter::PackMap(CFilePacker& packer, CTerrain *pTerrain, CLightEnv *pLightEnv, CUnitManager *pUnitMan)
 {
 	// now pack everything up
 	PackTerrain(packer, pTerrain);
 	PackObjects(packer, pUnitMan);
 	PackLightEnv(packer, pLightEnv);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PackLightEnv: pack lighting parameters onto the end of the output data stream
 void CMapWriter::PackLightEnv(CFilePacker& packer, CLightEnv *pLightEnv)
 {
 	packer.PackRaw(&pLightEnv->m_SunColor,sizeof(pLightEnv->m_SunColor));
 	packer.PackRaw(&pLightEnv->m_Elevation,sizeof(pLightEnv->m_Elevation));
 	packer.PackRaw(&pLightEnv->m_Rotation,sizeof(pLightEnv->m_Rotation));
 	packer.PackRaw(&pLightEnv->m_TerrainAmbientColor,sizeof(pLightEnv->m_TerrainAmbientColor));
 	packer.PackRaw(&pLightEnv->m_UnitsAmbientColor,sizeof(pLightEnv->m_UnitsAmbientColor));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PackObjects: pack world objects onto the end of the output data stream
 //		- data: list of objects types used by map, list of object descriptions
 void CMapWriter::PackObjects(CFilePacker& packer, CUnitManager *pUnitMan)
 {
 	// the list of object types used by map
 	std::vector<CStr> objectTypes;
 	// descriptions of each object
 	std::vector<SObjectDesc> objects;
 	
 	// build lists by scanning through the world
 	EnumObjects(pUnitMan, objectTypes, objects);
 
 	// pack object types
 	u32 numObjTypes=(u32)objectTypes.size();
 	packer.PackRaw(&numObjTypes,sizeof(numObjTypes));	
 	for (uint i=0;i<numObjTypes;i++) {
 		packer.PackString(objectTypes[i]);
 	}
 	
 	// pack object data
 	u32 numObjects=(u32)objects.size();
 	packer.PackRaw(&numObjects,sizeof(numObjects));	
 	packer.PackRaw(&objects[0],sizeof(SObjectDesc)*numObjects);	
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PackTerrain: pack the terrain onto the end of the output data stream
 //		- data: map size, heightmap, list of textures used by map, texture tile assignments
 void CMapWriter::PackTerrain(CFilePacker& packer, CTerrain *pTerrain)
 {
 	// pack map size
 	u32 mapsize=pTerrain->GetPatchesPerSide();
 	packer.PackRaw(&mapsize,sizeof(mapsize));	
 	
 	// pack heightmap
 	packer.PackRaw(pTerrain->GetHeightMap(),sizeof(u16)*SQR(pTerrain->GetVerticesPerSide()));	
 
 	// the list of textures used by map
 	std::vector<CStr> terrainTextures;
 	// descriptions of each tile
 	std::vector<STileDesc> tiles;
 	
 	// build lists by scanning through the terrain
 	EnumTerrainTextures(pTerrain, terrainTextures, tiles);
 	
 	// pack texture names
 	u32 numTextures=(u32)terrainTextures.size();
 	packer.PackRaw(&numTextures,sizeof(numTextures));	
 	for (uint i=0;i<numTextures;i++) {
 		packer.PackString(terrainTextures[i]);
 	}
 	
 	// pack tile data
 	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);
 
-				XML_Setting("Player", entity->GetPlayer());
+				XML_Setting("Player", entity->GetPlayer()->GetPlayerID());
 
 				{
 					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
 }
Index: ps/trunk/source/graphics/Model.cpp
===================================================================
--- ps/trunk/source/graphics/Model.cpp	(revision 1919)
+++ ps/trunk/source/graphics/Model.cpp	(revision 1920)
@@ -1,401 +1,411 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // Name:		Model.cpp
 // Author:		Rich Cross
 // Contact:		rich@wildfiregames.com
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "precompiled.h"
 
 #include "Model.h"
 #include "ModelDef.h"
 #include "Quaternion.h"
 #include "Bound.h"
 #include "SkeletonAnim.h"
 #include "SkeletonAnimDef.h"
 #include "SkeletonAnimManager.h"
 #include "MeshManager.h"
 #include "lib/res/ogl_tex.h"
 
+#include "ps/CLogger.h"
+#define LOG_CATEGORY "graphics"
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Constructor
 CModel::CModel() 
 	: m_Flags(0), m_PlayerID(0), m_Anim(0), m_AnimTime(0), 
 	m_BoneMatrices(0), m_InvBoneMatrices(0), m_BoneMatricesValid(false)
 {
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Destructor
 CModel::~CModel()
 {
 	ReleaseData();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // ReleaseData: delete anything allocated by the model
 void CModel::ReleaseData()
 {
 	delete[] m_BoneMatrices;
 	delete[] m_InvBoneMatrices;
 	for (size_t i=0;i<m_Props.size();i++) {
 		delete m_Props[i].m_Model;
 	}
 	m_Props.clear();
 	m_pModelDef = CModelDefPtr();
 
 	Handle h = m_Texture.GetHandle();
 	tex_free(h);
 	m_Texture.SetHandle(0);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // InitModel: setup model from given geometry
 bool CModel::InitModel(CModelDefPtr modeldef)
 {
 	// clean up any existing data first
 	ReleaseData();
 
 	m_pModelDef = modeldef;
 	
 	u32 numBones=modeldef->GetNumBones();
 	if (numBones>0) {
 		// allocate matrices for bone transformations
 		m_BoneMatrices=new CMatrix3D[numBones];
 		m_InvBoneMatrices=new CMatrix3D[numBones];
 		// store default pose until animation assigned
 		CBoneState* defpose=modeldef->GetBones();
 		for (uint i=0;i<numBones;i++) {
 			CMatrix3D& m=m_BoneMatrices[i];
 			m.SetIdentity();
 			m.Rotate(defpose[i].m_Rotation);
 			m.Translate(defpose[i].m_Translation);
 			m.GetInverse(m_InvBoneMatrices[i]);
 		}
 		m_BoneMatricesValid=true;
 	}
 
 	return true;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // SkinPoint: skin the given point using the given blend and bonestate data
 static CVector3D SkinPoint(const CVector3D& pos,const SVertexBlend& blend,
 						   const CBoneState* bonestates)
 {
 	CVector3D result(0,0,0);
 	for (int i=0;i<SVertexBlend::SIZE && blend.m_Bone[i]!=0xff;i++) {
 		CMatrix3D m;
 		m.SetIdentity();
 		m.Rotate(bonestates[blend.m_Bone[i]].m_Rotation);		
 		m.Translate(bonestates[blend.m_Bone[i]].m_Translation);		
 
 		CVector3D tmp=m.Transform(pos);
 		result+=tmp*blend.m_Weight[i];
 	}
 
 	return result;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // SkinPoint: skin the given point using the given blend and matrix data
 static CVector3D SkinPoint(const CVector3D& pos,const SVertexBlend& blend,
 						   const CMatrix3D* bonestates)
 {
 	CVector3D result,tmp;
 
 	// must have at least one valid bone if we're using SkinPoint
 	assert(blend.m_Bone[0]!=0xff);
 
 	const CMatrix3D& m=bonestates[blend.m_Bone[0]];
 	m.Transform(pos,result);
 	result*=blend.m_Weight[0];
 
 	for (int i=1;i<SVertexBlend::SIZE && blend.m_Bone[i]!=0xff;i++) {
 		const CMatrix3D& m=bonestates[blend.m_Bone[i]];
 		m.Transform(pos,tmp);
 		result+=tmp*blend.m_Weight[i];
 	}
 
 	return result;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // CalcBound: calculate the world space bounds of this model
 void CModel::CalcBounds()
 {
 	// Need to calculate the object bounds first, if that hasn't already been done
 	if (! m_Anim)
 		CalcObjectBounds();
 	else
 	{
 		if (m_Anim->m_ObjectBounds.IsEmpty())
 			CalcAnimatedObjectBound(m_Anim->m_AnimDef, m_Anim->m_ObjectBounds);
 		assert(! m_Anim->m_ObjectBounds.IsEmpty()); // (if this happens, it'll be recalculating the bounds every time)
 		m_ObjectBounds = m_Anim->m_ObjectBounds;
 	}
 
 	m_ObjectBounds.Transform(GetTransform(),m_Bounds);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // CalcObjectBounds: calculate object space bounds of this model, based solely on vertex positions
 void CModel::CalcObjectBounds()
 {
 	m_ObjectBounds.SetEmpty();
 
 	int numverts=m_pModelDef->GetNumVertices();
 	SModelVertex* verts=m_pModelDef->GetVertices();
 
 	for (int i=0;i<numverts;i++) {
 		m_ObjectBounds+=verts[i].m_Coords;
 	}		
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // CalcAnimatedObjectBound: calculate bounds encompassing all vertex positions for given animation 
 void CModel::CalcAnimatedObjectBound(CSkeletonAnimDef* anim,CBound& result)
 {
 	result.SetEmpty();
 
 	// Set the current animation on which to perform calculations (if it's necessary)
 	if (anim != m_Anim->m_AnimDef)
 	{
 		CSkeletonAnim dummyanim;
 		dummyanim.m_AnimDef=anim;
 		if (!SetAnimation(&dummyanim)) return;
 	}
 
 	int numverts=m_pModelDef->GetNumVertices();
 	SModelVertex* verts=m_pModelDef->GetVertices();
 
 	// Remove any transformations, so that we calculate the bounding box
 	// at the origin. The box is later re-transformed onto the object, without
 	// having to recalculate the size of the box.
 	CMatrix3D transform, oldtransform = GetTransform();
 	transform.SetIdentity();
 	SetTransform(transform);
 
 	// iterate through every frame of the animation
 	for (uint j=0;j<anim->GetNumFrames();j++) {		
 		// extend bounds by vertex positions at the frame
 		for (int i=0;i<numverts;i++) {
 			CVector3D tmp=SkinPoint(verts[i].m_Coords,verts[i].m_Blend,GetBoneMatrices());
 			result+=tmp;
 		}		
 		// advance to next frame
 		m_AnimTime+=anim->GetFrameTime();
 		m_BoneMatricesValid=false;
 	}
 
 	SetTransform(oldtransform);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // BuildAnimation: load raw animation frame animation from given file, and build a 
 // animation specific to this model
 CSkeletonAnim* CModel::BuildAnimation(const char* filename,float speed)
 {
 	CSkeletonAnimDef* def=g_SkelAnimMan.GetAnimation(filename);
 	if (!def) return 0;
 
 	CSkeletonAnim* anim=new CSkeletonAnim;
 	anim->m_AnimDef=def;
 	anim->m_Speed=speed;
 	anim->m_ObjectBounds.SetEmpty();
 	InvalidateBounds();
 
 	return anim;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Update: update this model by the given time, in seconds
 void CModel::Update(float time)
 {
 	if (m_Anim && m_BoneMatrices) {
 		// convert to ms and adjust for animation speed
 		float animtime=time*1000*m_Anim->m_Speed;
 
 		// update animation time, but don't calculate bone matrices - do that (lazily) when
 		// something requests them; that saves some calculation work for offscreen models,
 		// and also assures the world space, inverted bone matrices (required for normal
 		// skinning) are up to date with respect to m_Transform 
 		m_AnimTime+=animtime;
 		
 		float duration=m_Anim->m_AnimDef->GetDuration();
 		if (m_AnimTime>duration) {
 			if( m_Flags & MODELFLAG_NOLOOPANIMATION )
 				SetAnimation( NULL );
 			m_AnimTime=(float) fmod(m_AnimTime,duration);
 		}
 		
 		// mark vertices as dirty
 		SetDirty(RENDERDATA_UPDATE_VERTICES);
 		
 		// mark matrices as dirty
 		m_BoneMatricesValid=false;
 	}
 
 	// update props
 	for (uint i=0;i<m_Props.size();i++) {
 		m_Props[i].m_Model->Update(time);
 	}
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // GenerateBoneMatrices: calculate necessary bone transformation matrices for skinning
 void CModel::GenerateBoneMatrices()
 {
 	if (!m_Anim || !m_BoneMatrices) return;
 
+	assert(m_pModelDef->GetNumBones() == m_Anim->m_AnimDef->GetNumKeys());
+
 	m_Anim->m_AnimDef->BuildBoneMatrices(m_AnimTime,m_BoneMatrices);
 
 	const CMatrix3D& transform=GetTransform();
 	for (int i=0;i<m_pModelDef->GetNumBones();i++) {
 		m_BoneMatrices[i].Concatenate(transform);
 		m_BoneMatrices[i].GetInverse(m_InvBoneMatrices[i]);
 	}
 
 	// update transform of boned props 
 	// TODO, RC - ugh, we'll be doing this twice (for boned props, at least) - once here, 
 	// and once again in SetTransform; better to just do it in Update? 
 	for (size_t j=0;j<m_Props.size();j++) {
 		const Prop& prop=m_Props[j];
 
 		if (prop.m_Point->m_BoneIndex!=0xff) {
 			CMatrix3D proptransform=prop.m_Point->m_Transform;;
 			if (prop.m_Point->m_BoneIndex!=0xff) {
 				proptransform.Concatenate(m_BoneMatrices[prop.m_Point->m_BoneIndex]);
 			} else {			
 				proptransform.Concatenate(transform);
 			}
 			prop.m_Model->SetTransform(proptransform);
 		} 			
 	}
 
 	m_BoneMatricesValid=true;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // SetAnimation: set the given animation as the current animation on this model;
 // return false on error, else true
 bool CModel::SetAnimation(CSkeletonAnim* anim, bool once)
 {
-	m_Anim=anim;
-	if (m_Anim) {
+	m_Anim=NULL; // in case something fails
+
+	if (anim) {
 		m_Flags &= ~MODELFLAG_NOLOOPANIMATION;
 		if( once )
 			m_Flags |= MODELFLAG_NOLOOPANIMATION;
 
 		if (!m_BoneMatrices) {
 			// not boned, can't animate
 			return false;
 		}
 
-		if (m_Anim->m_AnimDef->GetNumKeys()!=m_pModelDef->GetNumBones()) {
+		if (anim->m_AnimDef->GetNumKeys()!=m_pModelDef->GetNumBones()) {
 			// mismatch between model's skeleton and animation's skeleton
+			LOG(ERROR, LOG_CATEGORY, "Mismatch between model's skeleton and animation's skeleton (%d model bones != %d animation keys)",
+										m_pModelDef->GetNumBones(), anim->m_AnimDef->GetNumKeys());
 			return false;
 		}
 
 		// reset the cached bounds when the animation is changed
 		m_ObjectBounds.SetEmpty();
 		InvalidateBounds();
 
 		// start anim from beginning 
 		m_AnimTime=0; 
 	} 
 
+	m_Anim=anim;
+
 	return true;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // AddProp: add a prop to the model on the given point
 void CModel::AddProp(SPropPoint* point,CModel* model)
 {
 	// position model according to prop point position
 	model->SetTransform(point->m_Transform);
 
 	// check if we're already using this point, and replace
 	// model on it if so
 	uint i;
 	for (i=0;i<m_Props.size();i++) {
 		if (m_Props[i].m_Point==point) {
 			delete m_Props[i].m_Model;
 			m_Props[i].m_Model=model;
 			return;
 		}
 	}
 
 	// not using point; add new prop
 	Prop prop;
 	prop.m_Point=point;
 	prop.m_Model=model;
 	m_Props.push_back(prop);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // RemoveProp: remove a prop from the given point
 void CModel::RemoveProp(SPropPoint* point)
 {
 	typedef std::vector<Prop>::iterator Iter;
 	for (Iter iter=m_Props.begin();iter!=m_Props.end();++iter) {
 		const Prop& prop=*iter;
 		if (prop.m_Point==point) {
 			m_Props.erase(iter);
 			return;
 		}
 	}
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Clone: return a clone of this model
 CModel* CModel::Clone() const
 {
 	CModel* clone=new CModel;
 	clone->m_ObjectBounds=m_ObjectBounds;
 	clone->InitModel(m_pModelDef);
 	clone->SetTexture(m_Texture);
     clone->SetMaterial(m_Material);
 	clone->SetAnimation(m_Anim);
 	clone->SetPlayerID(m_PlayerID);
 	clone->SetFlags(m_Flags);
 	for (uint i=0;i<m_Props.size();i++) {
 		// eek!  TODO, RC - need to investigate shallow clone here
 		clone->AddProp(m_Props[i].m_Point,m_Props[i].m_Model->Clone());
 	}
 	return clone;
 }
 
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // SetTransform: set the transform on this object, and reorientate props accordingly
 void CModel::SetTransform(const CMatrix3D& transform) 
 {
 	// call base class to set transform on this object
 	CRenderableObject::SetTransform(transform);
 	m_BoneMatricesValid=false;
 	InvalidateBounds();
 
 	// now set transforms on props
 	const CMatrix3D* bonematrices=GetBoneMatrices();
 	for (size_t i=0;i<m_Props.size();i++) {
 		const Prop& prop=m_Props[i];
 
 		CMatrix3D proptransform=prop.m_Point->m_Transform;;
 		if (prop.m_Point->m_BoneIndex!=0xff) {
 			proptransform.Concatenate(m_BoneMatrices[prop.m_Point->m_BoneIndex]);
 		} else {
 			proptransform.Concatenate(transform);
 		}
 		prop.m_Model->SetTransform(proptransform);
 	}
 }
 
 void CModel::SetMaterial(const CMaterial &material)
 {
     m_Material = material;
     if(m_Material.GetTexture().Trim(PS_TRIM_BOTH).Length() > 0)
     {
     }
 }
Index: ps/trunk/source/graphics/ModelDef.cpp
===================================================================
--- ps/trunk/source/graphics/ModelDef.cpp	(revision 1919)
+++ ps/trunk/source/graphics/ModelDef.cpp	(revision 1920)
@@ -1,134 +1,134 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Name:		ModelDef.cpp
 // Author:		Rich Cross
 // Contact:		rich@wildfiregames.com
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "precompiled.h"
 
 #include "ModelDef.h"
 #include "FilePacker.h"
 #include "FileUnpacker.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 // CModelDef Constructor
 CModelDef::CModelDef()	
 	: m_pVertices(0), m_NumVertices(0), m_pFaces(0), m_NumFaces(0), m_Bones(0), m_NumBones(0),
 	m_NumPropPoints(0), m_PropPoints(0)
 {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CModelDef Destructor
 CModelDef::~CModelDef()
 {
 	delete[] m_pVertices;
 	delete[] m_pFaces;
 	delete[] m_Bones;
 	delete[] m_PropPoints;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // FindPropPoint: find and return pointer to prop point matching given name; 
 // return null if no match (case insensitive search)
 SPropPoint* CModelDef::FindPropPoint(const char* name) const
 {
 	for (uint i=0;i<m_NumPropPoints;i++) {
 		if (stricmp(name,m_PropPoints[i].m_Name)==0) {
 			return &m_PropPoints[i];
 		}
 	}
 	return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Load: read and return a new CModelDef initialised with data from given file
 CModelDef* CModelDef::Load(const char* filename)
 {
 	CFileUnpacker unpacker;
 	
 	// read everything in from file
 	unpacker.Read(filename,"PSMD");
 			
 	// check version
 	if (unpacker.GetVersion()<FILE_READ_VERSION) {
 		throw CFileUnpacker::CFileVersionError();
 	}
 
 	CModelDef* mdef=new CModelDef;
 	try {
 		// now unpack everything 
 		unpacker.UnpackRaw(&mdef->m_NumVertices,sizeof(mdef->m_NumVertices));	
 		mdef->m_pVertices=new SModelVertex[mdef->m_NumVertices];
 		unpacker.UnpackRaw(mdef->m_pVertices,sizeof(SModelVertex)*mdef->m_NumVertices);
 		
 		unpacker.UnpackRaw(&mdef->m_NumFaces,sizeof(mdef->m_NumFaces));
 		mdef->m_pFaces=new SModelFace[mdef->m_NumFaces];
 		unpacker.UnpackRaw(mdef->m_pFaces,sizeof(SModelFace)*mdef->m_NumFaces);
 		
 		unpacker.UnpackRaw(&mdef->m_NumBones,sizeof(mdef->m_NumBones));
 		if (mdef->m_NumBones) {
 			mdef->m_Bones=new CBoneState[mdef->m_NumBones];
 			unpacker.UnpackRaw(mdef->m_Bones,mdef->m_NumBones*sizeof(CBoneState));
 		}
 
 		if (unpacker.GetVersion()>=2) {
 			// versions >=2 also have prop point data
 			unpacker.UnpackRaw(&mdef->m_NumPropPoints,sizeof(mdef->m_NumPropPoints));
 			if (mdef->m_NumPropPoints) {
 				mdef->m_PropPoints=new SPropPoint[mdef->m_NumPropPoints];
 				for (u32 i=0;i<mdef->m_NumPropPoints;i++) {
 					unpacker.UnpackString(mdef->m_PropPoints[i].m_Name);
 					unpacker.UnpackRaw(&mdef->m_PropPoints[i].m_Position.X,sizeof(mdef->m_PropPoints[i].m_Position));
 					unpacker.UnpackRaw(&mdef->m_PropPoints[i].m_Rotation.m_V.X,sizeof(mdef->m_PropPoints[i].m_Rotation));
 					unpacker.UnpackRaw(&mdef->m_PropPoints[i].m_BoneIndex,sizeof(mdef->m_PropPoints[i].m_BoneIndex));
 
 					// build prop point transform
 					mdef->m_PropPoints[i].m_Transform.SetIdentity();
 					mdef->m_PropPoints[i].m_Transform.Rotate(mdef->m_PropPoints[i].m_Rotation);
 					mdef->m_PropPoints[i].m_Transform.Translate(mdef->m_PropPoints[i].m_Position);
 				}
 			}
 		}
-	} catch (...) {
+	} catch (CFileUnpacker::CFileEOFError) {
 		delete mdef;
 		throw CFileUnpacker::CFileEOFError();
 	}
 
 	return mdef;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Save: write the given CModelDef to the given file
 void CModelDef::Save(const char* filename,const CModelDef* mdef)
 {
 	CFilePacker packer(FILE_VERSION, "PSMD");
 
 	// pack everything up
 	u32 numVertices=mdef->GetNumVertices();
 	packer.PackRaw(&numVertices,sizeof(numVertices));
 	packer.PackRaw(mdef->GetVertices(),sizeof(SModelVertex)*numVertices);
 	
 	u32 numFaces=mdef->GetNumFaces();
 	packer.PackRaw(&numFaces,sizeof(numFaces));
 	packer.PackRaw(mdef->GetFaces(),sizeof(SModelFace)*numFaces);
 	
 	packer.PackRaw(&mdef->m_NumBones,sizeof(mdef->m_NumBones));
 	if (mdef->m_NumBones) {
 		packer.PackRaw(mdef->m_Bones,sizeof(CBoneState)*mdef->m_NumBones);
 	}
 
 	packer.PackRaw(&mdef->m_NumPropPoints,sizeof(mdef->m_NumPropPoints));
 	for (u32 i=0;i<mdef->m_NumPropPoints;i++) {
 		packer.PackString(mdef->m_PropPoints[i].m_Name);
 		packer.PackRaw(&mdef->m_PropPoints[i].m_Position.X,sizeof(mdef->m_PropPoints[i].m_Position));
 		packer.PackRaw(&mdef->m_PropPoints[i].m_Rotation.m_V.X,sizeof(mdef->m_PropPoints[i].m_Rotation));
 		packer.PackRaw(&mdef->m_PropPoints[i].m_BoneIndex,sizeof(mdef->m_PropPoints[i].m_BoneIndex));
 	}
 	
 	// flush everything out to file
 	packer.Write(filename);
 }
 
Index: ps/trunk/source/graphics/ObjectEntry.cpp
===================================================================
--- ps/trunk/source/graphics/ObjectEntry.cpp	(revision 1919)
+++ ps/trunk/source/graphics/ObjectEntry.cpp	(revision 1920)
@@ -1,367 +1,368 @@
 #include "precompiled.h"
 
 #include "ObjectEntry.h"
 #include "ObjectManager.h"
 #include "Model.h"
 #include "ModelDef.h"
 #include "CLogger.h"
 #include "MaterialManager.h"
 #include "MeshManager.h"
 
 #include "UnitManager.h"
 #include "Unit.h"
 
 #include "ps/Xeromyces.h"
 #include "ps/XMLWriter.h"
 
 #include "lib/res/vfs.h"
 
 #define LOG_CATEGORY "graphics"
 
 CObjectEntry::CObjectEntry(int type) : m_Model(0), m_Type(type)
 {
 	m_IdleAnim=0;
 	m_WalkAnim=0;
 	m_DeathAnim=0;
 	m_CorpseAnim=0;
 	m_MeleeAnim=0;
 	m_RangedAnim=0;
 	m_Properties.m_CastShadows=true;
 	m_Properties.m_AutoFlatten=false;
 }
 
 CObjectEntry::~CObjectEntry()
 {
 	for (size_t i=0;i<m_Animations.size();i++) {
 		delete m_Animations[i].m_AnimData;
 	}
 
 	delete m_Model;
 }
 
 bool CObjectEntry::BuildModel()
 {
 	// check we've enough data to consider building the object
 	if (m_ModelName.Length()==0 || m_TextureName.Length()==0) {
 		return false;
 	}
 
 	// get the root directory of this object
 	CStr dirname=g_ObjMan.m_ObjectTypes[m_Type].m_Name;
 
 	// remember the old model so we can replace any models using it later on
 	CModelDefPtr oldmodeldef=m_Model ? m_Model->GetModelDef() : CModelDefPtr();
 
 	const char* modelfilename = m_ModelName.c_str();
 
 	// try and create a model
 	CModelDefPtr modeldef (g_MeshManager.GetMesh(modelfilename));
 	if (!modeldef)
 	{
 		LOG(ERROR, LOG_CATEGORY, "CObjectEntry::BuildModel(): Model %s failed to load", modelfilename);
 		return false;
 	}
 
 	// delete old model, create new 
 	delete m_Model;
 	m_Model=new CModel;
 	m_Model->SetTexture((const char*) m_TextureName);
     m_Model->SetMaterial(g_MaterialManager.LoadMaterial((const char *)m_Material));
 	m_Model->InitModel(modeldef);
 
 	// calculate initial object space bounds, based on vertex positions
 	m_Model->CalcObjectBounds();
 
 	// load animations
-	for( uint t = 0; t < m_Animations.size(); t++ )
+	for (uint t = 0; t < m_Animations.size(); t++)
 	{
-		if( m_Animations[t].m_FileName.Length() > 0 )
+		if (m_Animations[t].m_FileName.Length() > 0)
 		{
 			const char* animfilename = m_Animations[t].m_FileName.c_str();
 			m_Animations[t].m_AnimData = m_Model->BuildAnimation(animfilename,m_Animations[t].m_Speed);
 
 			CStr AnimNameLC = m_Animations[t].m_AnimName.LowerCase();
 
-			if( AnimNameLC == "idle" )
+			if (AnimNameLC == "idle")
 				m_IdleAnim = m_Animations[t].m_AnimData;
 			else
-			if( AnimNameLC == "walk" )
+			if (AnimNameLC == "walk")
 				m_WalkAnim = m_Animations[t].m_AnimData;
 			else
-			if( AnimNameLC == "attack" )
+			if (AnimNameLC == "attack")
 				m_MeleeAnim = m_Animations[t].m_AnimData;
 			else
-			if( AnimNameLC == "death" )
+			if (AnimNameLC == "death")
 				m_DeathAnim = m_Animations[t].m_AnimData;
 			else
-			if( AnimNameLC == "decay" )
+			if (AnimNameLC == "decay")
 				m_CorpseAnim = m_Animations[t].m_AnimData;
 			//else
 			//	debug_out("Invalid animation name '%s'\n", (const char*)AnimNameLC);
 		}
 		else
 		{
 			// FIXME, RC - don't store invalid animations (possible?)
 			m_Animations[t].m_AnimData=0;
 		}
 	}
 	// start up idling
-	m_Model->SetAnimation( m_IdleAnim );
+	if (! m_Model->SetAnimation(m_IdleAnim))
+		LOG(ERROR, LOG_CATEGORY, "Failed to set idle animation in model \"%s\"", modelfilename);
 
 	// build props - TODO, RC - need to fix up bounds here
 	for (uint p=0;p<m_Props.size();p++) {
 		const Prop& prop=m_Props[p];
 		SPropPoint* proppoint=modeldef->FindPropPoint((const char*) prop.m_PropPointName);
 		if (proppoint) {
 			CObjectEntry* oe=g_ObjMan.FindObject(prop.m_ModelName);
 			if (oe) {
 				// try and build model if we haven't already got it
 				if (!oe->m_Model) oe->BuildModel();
 				if (oe->m_Model) {
 					CModel* propmodel=oe->m_Model->Clone();
 					m_Model->AddProp(proppoint,propmodel);
 					if (oe->m_WalkAnim) propmodel->SetAnimation(oe->m_WalkAnim);
 				} else {
 					LOG(ERROR, LOG_CATEGORY, "Failed to build prop model \"%s\" on actor \"%s\"",(const char*) m_Name,(const char*) prop.m_ModelName);
 				}
 			}
 		} else {
 			LOG(ERROR, LOG_CATEGORY, "Failed to matching prop point called \"%s\" in model \"%s\"", (const char*)prop.m_PropPointName, modelfilename);
 		}
 	}
 
 	// setup flags
 	if (m_Properties.m_CastShadows) {
 		m_Model->SetFlags(m_Model->GetFlags()|MODELFLAG_CASTSHADOWS);
 	}
 
 	// replace any units using old model to now use new model; also reprop models, if necessary
 	// FIXME, RC - ugh, doesn't recurse correctly through props
 	const std::vector<CUnit*>& units=g_UnitMan.GetUnits();
 	for (uint i=0;i<units.size();++i) {
 		CModel* unitmodel=units[i]->GetModel();
 		if (unitmodel->GetModelDef()==oldmodeldef) {			
 			unitmodel->InitModel(m_Model->GetModelDef());
 			unitmodel->SetFlags(m_Model->GetFlags());
 
 			const std::vector<CModel::Prop>& newprops=m_Model->GetProps();
 			for (uint j=0;j<newprops.size();j++) {
 				unitmodel->AddProp(newprops[j].m_Point,newprops[j].m_Model->Clone());
 			}
 		}
 
 		std::vector<CModel::Prop>& mdlprops=unitmodel->GetProps();
 		for (uint j=0;j<mdlprops.size();j++) {
 			CModel::Prop& prop=mdlprops[j];
 			if (prop.m_Model) {
 				if (prop.m_Model->GetModelDef()==oldmodeldef) {
 					delete prop.m_Model;
 					prop.m_Model=m_Model->Clone();
 				}
 			}
 		}
 	}
 
 	return true;
 }
 
 CSkeletonAnim* CObjectEntry::GetNamedAnimation( CStr animationName )
 {
 	for( uint t = 0; t < m_Animations.size(); t++ )
 	{
 		if( m_Animations[t].m_AnimName == animationName )
 			return( m_Animations[t].m_AnimData );
 	}
 	return( NULL );
 }
 
 bool CObjectEntry::Load(const char* filename)
 {
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(filename) != PSRETURN_OK)
 		return false;
 
 	// 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(name);
 	EL(modelname);
 	EL(texturename);
     EL(material);
 	EL(animations);
 	EL(props);
 	EL(properties);
 	AT(attachpoint);
 	AT(model);
 	AT(name);
 	AT(file);
 	AT(speed);
 	AT(autoflatten);
 	AT(castshadows);
 	#undef AT
 	#undef EL
 
 	XMBElement root = XeroFile.getRoot();
 
 	XMBElementList children = root.getChildNodes();
 
 	for (int i = 0; i < children.Count; ++i) {
 
 		XMBElement child = children.item(i);
 
 		int element_name = child.getNodeName();
 		CStr element_value (child.getText());
 
 		if (element_name == el_name)
 			m_Name=element_value;
 
 		else if (element_name == el_modelname)
 			m_ModelName=element_value;
 
 		else if (element_name == el_texturename)
 			m_TextureName=element_value;
 
         else if(element_name == el_material)
             m_Material = element_value;
 
 		else if (element_name == el_properties) {
 
 			XMBAttributeList attributes=child.getAttributes();
 			for (int j = 0; j < attributes.Count; ++j) {
 				XMBAttribute attrib=attributes.item(j);
 
 				int attrib_name = attrib.Name;
 
 				if (attrib_name == at_autoflatten) {
 					CStr str (attrib.Value);
 					m_Properties.m_AutoFlatten=str.ToInt() ? true : false;
 
 				} else if (attrib_name == at_castshadows) {
 					CStr str = (attrib.Value);
 					m_Properties.m_CastShadows=str.ToInt() ? true : false;
 				} 
 			}
 		}
 
 		else if (element_name == el_animations)
 		{
 			XMBElementList animations=child.getChildNodes();
 
 			for (int j = 0; j < animations.Count; ++j) {
 				XMBElement anim_element = animations.item(j);
 				XMBAttributeList attributes=anim_element.getAttributes();
 				if (attributes.Count) {
 					Anim anim;
 
 					anim.m_AnimName = attributes.getNamedItem(at_name);
 					anim.m_FileName = attributes.getNamedItem(at_file);
 					CStr speedstr = attributes.getNamedItem(at_speed);
 
 					anim.m_Speed=float(speedstr.ToInt())/100.0f;
 					if (anim.m_Speed<=0.0) anim.m_Speed=1.0f;
 
 					m_Animations.push_back(anim);
 				}
 			}
 		}
 		else if (element_name == el_props)
 		{
 			XMBElementList props=child.getChildNodes();
 
 			for (int j = 0; j < props.Count; ++j) {
 				XMBElement prop_element = props.item(j);
 				XMBAttributeList attributes=prop_element.getAttributes();
 				if (attributes.Count) {
 					Prop prop;
 
 					prop.m_PropPointName = attributes.getNamedItem(at_attachpoint);
 					prop.m_ModelName = attributes.getNamedItem(at_model);
 
 					m_Props.push_back(prop);
 				}
 			}
 		}
 	}
 
 	return true;
 
 }
 
 bool CObjectEntry::Save(const char* filename)
 {
 	Handle h = vfs_open(filename, FILE_WRITE|FILE_NO_AIO);
 	if (h <= 0)
 	{
 		debug_warn("actor open failed");
 		return false;
 	}
 
 	XML_Start("iso-8859-1");
 	XML_Doctype("Object", "/art/actors/object.dtd");
 
 	XML_Comment("File automatically generated by ScEd");
 
 	{
 		XML_Element("Object");
 
 		XML_Setting("Name", m_Name);
 		XML_Setting("ModelName", m_ModelName);
 		XML_Setting("TextureName", m_TextureName);
 
 		if(m_Material.Trim(PS_TRIM_BOTH).Length())
 			XML_Setting("Material", m_Material);
 
 		{
 			XML_Element("Properties");
 			XML_Attribute("autoflatten", m_Properties.m_AutoFlatten ? 1 : 0);
 			XML_Attribute("castshadows", m_Properties.m_CastShadows ? 1 : 0);
 		}
 
 		if (m_Animations.size()>0)
 		{
 			XML_Element("Animations");
 
 			for (uint i=0;i<m_Animations.size();i++)
 			{
 				XML_Element("Animation");
 				XML_Attribute("name", m_Animations[i].m_AnimName);
 				XML_Attribute("file", m_Animations[i].m_FileName);
 				XML_Attribute("speed", int(m_Animations[i].m_Speed*100));
 			}
 		}
 
 		if (m_Props.size()>0)
 		{
 			XML_Element("Props");
 
 			for (uint i=0;i<m_Props.size();i++)
 			{
 				XML_Element("Prop");
 				XML_Attribute("attachpoint", m_Props[i].m_PropPointName);
 				XML_Attribute("model", m_Props[i].m_ModelName);
 			}
 		}
 	}
 
 	if (! XML_StoreVFS(h))
 	{
 		// Error occurred while saving data
 		debug_warn("actor save failed");
 		vfs_close(h);
 		return false;
 	}
 
 	vfs_close(h);
 	return true;
 }
 
 
 CObjectEntry::Prop* CObjectEntry::FindProp(const char* proppointname)
 {
 	for (size_t i=0;i<m_Props.size();i++) {
 		if (strcmp(proppointname,m_Props[i].m_PropPointName)==0) return &m_Props[i];
 	}
 
 	return 0;
 }
Index: ps/trunk/source/tools/sced/SelectObjectTool.cpp
===================================================================
--- ps/trunk/source/tools/sced/SelectObjectTool.cpp	(revision 1919)
+++ ps/trunk/source/tools/sced/SelectObjectTool.cpp	(revision 1920)
@@ -1,123 +1,117 @@
 #include "precompiled.h"
 
 #include "CommandManager.h"
 #include "Unit.h"
 #include "Model.h"
 #include "ObjectEntry.h"
 #include "Terrain.h"
 #include "Renderer.h"
 #include "UnitManager.h"
 #include "SelectObjectTool.h"
 #include <algorithm>
 
 // default tool instance
 CSelectObjectTool CSelectObjectTool::m_SelectObjectTool;
 
 CSelectObjectTool::CSelectObjectTool() 
 {
 	m_BrushSize=0;
 }
 
 void CSelectObjectTool::OnDraw()
 {
 	glColor3f(1,0,0);
 
 	for (uint i=0;i<m_SelectedUnits.size();i++) {
 		RenderUnitBounds(m_SelectedUnits[i]);
 	}
 }
 
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // SelectObject: try and select the object under the cursor
 // TODO, RC - add support for CTRL, SHIFT + ALT modifiers
 // TODO, RC - move selected objects to another tool? visual of selection
 // currently disappears when tool changes
 void CSelectObjectTool::SelectObject(unsigned int flags,int px,int py)
 {
 	// modifiers:
 	//	CTRL - add to selection
 	//	ALT - remove from selection
 
 	// build camera ray
 	CVector3D rayorigin,raydir;
 	BuildCameraRay(px,py,rayorigin,raydir);
 
 	// try and pick object with it
 	CUnit* hit=g_UnitMan.PickUnit(rayorigin,raydir);
 	if (hit) {
 		if (flags & TOOL_MOUSEFLAG_CTRLDOWN) {
 			// add unit to selection if not already there
 			if (std::find(m_SelectedUnits.begin(),m_SelectedUnits.end(),hit)==m_SelectedUnits.end()) {
 				m_SelectedUnits.push_back(hit);
 			}
 		} else if (flags & TOOL_MOUSEFLAG_ALTDOWN) {
 			// add unit to selection if not already there
 			typedef std::vector<CUnit*>::iterator Iter; 
 			Iter iter=std::find(m_SelectedUnits.begin(),m_SelectedUnits.end(),hit);
 			if (iter!=m_SelectedUnits.end()) {
 				m_SelectedUnits.erase(iter);
 			}
 		} else {
 			// just set hit as sole selection
 			m_SelectedUnits.clear();
 			m_SelectedUnits.push_back(hit);
 		}
 	} else {
 		// clear selection unless some modifier begin applied
 		if (!(flags & TOOL_MOUSEFLAG_CTRLDOWN) && !(flags & TOOL_MOUSEFLAG_ALTDOWN)) {
 			m_SelectedUnits.clear();
 		}
 	}
 }
 	
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // RenderUnitBounds: render a bounding box round given unit
 void CSelectObjectTool::RenderUnitBounds(CUnit* unit)
 {
-	glPushMatrix();
-	const CMatrix3D& transform=unit->GetModel()->GetTransform();
-	glMultMatrixf(&transform._11);	
-
-	const CBound& bounds=unit->GetModel()->GetObjectBounds();
+	const CBound& bounds=unit->GetModel()->GetBounds();
 
 	glBegin(GL_LINE_LOOP);
 	glVertex3f(bounds[0].X,bounds[0].Y,bounds[0].Z);
 	glVertex3f(bounds[0].X,bounds[0].Y,bounds[1].Z);
 	glVertex3f(bounds[0].X,bounds[1].Y,bounds[1].Z);
 	glVertex3f(bounds[0].X,bounds[1].Y,bounds[0].Z);
 	glEnd();
 
 	glBegin(GL_LINE_LOOP);
 	glVertex3f(bounds[1].X,bounds[0].Y,bounds[0].Z);
 	glVertex3f(bounds[1].X,bounds[0].Y,bounds[1].Z);
 	glVertex3f(bounds[1].X,bounds[1].Y,bounds[1].Z);
 	glVertex3f(bounds[1].X,bounds[1].Y,bounds[0].Z);
 	glEnd();
 
 	glBegin(GL_LINE_LOOP);
 	glVertex3f(bounds[0].X,bounds[0].Y,bounds[0].Z);
 	glVertex3f(bounds[0].X,bounds[0].Y,bounds[1].Z);
 	glVertex3f(bounds[1].X,bounds[0].Y,bounds[1].Z);
 	glVertex3f(bounds[1].X,bounds[0].Y,bounds[0].Z);
 	glEnd();
 
 	glBegin(GL_LINE_LOOP);
 	glVertex3f(bounds[0].X,bounds[1].Y,bounds[0].Z);
 	glVertex3f(bounds[0].X,bounds[1].Y,bounds[1].Z);
 	glVertex3f(bounds[1].X,bounds[1].Y,bounds[1].Z);
 	glVertex3f(bounds[1].X,bounds[1].Y,bounds[0].Z);
 	glEnd();
-
-	glPopMatrix();
 }
 
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // GetFirstEntity: return the entity of the first selected object
 CEntity* CSelectObjectTool::GetFirstEntity()
 {
 	if (m_SelectedUnits.size() == 0)
 		return NULL;
 	return m_SelectedUnits[0]->GetEntity();
 }
\ No newline at end of file
Index: ps/trunk/source/tools/sced/EditorData.cpp
===================================================================
--- ps/trunk/source/tools/sced/EditorData.cpp	(revision 1919)
+++ ps/trunk/source/tools/sced/EditorData.cpp	(revision 1920)
@@ -1,626 +1,629 @@
 #include "precompiled.h"
 
 #include "EditorData.h"
 #include "ui/UIGlobals.h"
 #include "ToolManager.h"
 #include "ObjectManager.h"
 #include "UnitManager.h"
 #include "TextureManager.h"
 #include "Model.h"
 #include "SkeletonAnimManager.h"
 #include "Unit.h"
 
 #include "ogl.h"
 #include "res/tex.h"
 #include "time.h"
 
 #include "BaseEntityCollection.h"
 #include "Entity.h"
 #include "EntityHandles.h"
 #include "EntityManager.h"
 #include "ConfigDB.h"
 #include "Scheduler.h"
 
 #include "XML.h"
 
 #include "Game.h"
 
 const int NUM_ALPHA_MAPS = 14;
 Handle AlphaMaps[NUM_ALPHA_MAPS];
 
 extern CLightEnv	g_LightEnv;
 CMiniMap			g_MiniMap;
 CEditorData			g_EditorData;
 
 CEditorData::CEditorData()
 {
 	m_ModelMatrix.SetIdentity();
 	m_ScenarioName="Scenario01";
 }
 
 void CEditorData::SetMode(EditMode mode)
 { 
 	if (m_Mode==TEST_MODE && mode!=TEST_MODE) StopTestMode();
 	m_Mode=mode; 
 	if (m_Mode==TEST_MODE) StartTestMode();
 }
 
 bool CEditorData::InitScene()
 {
 	// setup default lighting environment
 	g_LightEnv.m_SunColor=RGBColor(1,1,1);
 	g_LightEnv.m_Rotation=DEGTORAD(270);
 	g_LightEnv.m_Elevation=DEGTORAD(45);
 	g_LightEnv.m_TerrainAmbientColor=RGBColor(0,0,0);
 	g_LightEnv.m_UnitsAmbientColor=RGBColor(0.4f,0.4f,0.4f);
 	g_Renderer.SetLightEnv(&g_LightEnv);
 
 	// load the default
 	if (!LoadTerrain("temp/terrain.png")) return false;
 	
 	// get default texture to apply to terrain
 	CTextureEntry* texture=0;
 	for (uint i=0;i<g_TexMan.m_TerrainTextures.size();i++) {
 		if (g_TexMan.m_TerrainTextures[i].m_Textures.size()) {
 			texture=g_TexMan.m_TerrainTextures[i].m_Textures[0];
 			break;
 		}
 	}
 
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	// cover entire terrain with default texture
 	u32 patchesPerSide=terrain->GetPatchesPerSide();
 	for (uint pj=0; pj<patchesPerSide; pj++) {
 		for (uint pi=0; pi<patchesPerSide; pi++) {
 			
 			CPatch* patch=terrain->GetPatch(pi,pj);
 			
 			for (int j=0;j<PATCH_SIZE;j++) {
 				for (int i=0;i<PATCH_SIZE;i++) {
 					patch->m_MiniPatches[j][i].Tex1=texture ? texture->GetHandle() : 0;
 				}
 			}
 		}
 	}
 
 	// setup camera
 	InitCamera();
 
 	// build the terrain plane
 	float h=128*HEIGHT_SCALE;
 	u32 mapSize=terrain->GetVerticesPerSide();
 	CVector3D pt0(0,h,0),pt1(float(CELL_SIZE*mapSize),h,0),pt2(0,h,float(CELL_SIZE*mapSize));
 	m_TerrainPlane.Set(pt0,pt1,pt2);
 	m_TerrainPlane.Normalize();
 
 	return true;
 }
 
 
 struct TGAHeader {
 	// header stuff
 	unsigned char  iif_size;            
 	unsigned char  cmap_type;           
 	unsigned char  image_type;          
 	unsigned char  pad[5];
 
 	// origin : unused
 	unsigned short d_x_origin;
 	unsigned short d_y_origin;
 	
 	// dimensions
 	unsigned short width;
 	unsigned short height;
 
 	// bits per pixel : 16, 24 or 32
 	unsigned char  bpp;          
 
 	// image descriptor : Bits 3-0: size of alpha channel
 	//					  Bit 4: must be 0 (reserved)
 	//					  Bit 5: should be 0 (origin)
 	//					  Bits 6-7: should be 0 (interleaving)
    unsigned char image_descriptor;    
 };
 
 static bool saveTGA(const char* filename,int width,int height,unsigned char* data) 
 {
 	FILE* fp=fopen(filename,"wb");
 	if (!fp) return false;
 
 	// fill file header
 	TGAHeader header;
 	header.iif_size=0;
 	header.cmap_type=0;
 	header.image_type=2;
 	memset(header.pad,0,sizeof(header.pad));
 	header.d_x_origin=0;
 	header.d_y_origin=0;
 	header.width=width;
 	header.height=height;
 	header.bpp=24;
 	header.image_descriptor=0;
 
 	if (fwrite(&header,sizeof(TGAHeader),1,fp)!=1) {
 		fclose(fp);
 		return false;
 	}
 
 	// write data 
 	if (fwrite(data,width*height*3,1,fp)!=1) {
 		fclose(fp);
 		return false;
 	}
 
 	// return success ..
     fclose(fp);
 	return true;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Init: perform one time initialisation of the editor
 bool CEditorData::Init()
 {
+	// Set attributes for the game
+	g_GameAttributes.m_MapFile = L""; // start without a map
+
 	// Set up the actual game
 	g_Game = new CGame();
 	PSRETURN ret = g_Game->StartGame(&g_GameAttributes);
 	if (ret != PSRETURN_OK)
 	{
 		// Failed to start the game
 		delete g_Game;
 		g_Game = NULL;
 		return false;
 	}
 
 	// create the scene - terrain, camera, light environment etc
 	if (!InitScene()) return false;
 
 	// set up an empty minimap
 	g_MiniMap.Initialise();
 
 	// set up the info box
 	m_InfoBox.Initialise();
 
 	return true;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Terminate: close down the editor (destroy singletons in reverse order to construction)
 void CEditorData::Terminate()
 {
 }
 
 void CEditorData::InitCamera() 
 {
 	g_NaviCam.GetCamera().SetProjection(1.0f,10000.0f,DEGTORAD(90));
 	g_NaviCam.GetCamera().m_Orientation.SetIdentity();
 #ifdef TOPDOWNVIEW
 	g_NaviCam.GetCamera().m_Orientation.RotateX(DEGTORAD(90));
 	g_NaviCam.GetCamera().m_Orientation.Translate(CELL_SIZE*250*0.5, 80, CELL_SIZE*250*0.5);
 #else
 	g_NaviCam.GetCamera().m_Orientation.RotateX(DEGTORAD(40));
 	g_NaviCam.GetCamera().m_Orientation.RotateY(DEGTORAD(-45));
 	g_NaviCam.GetCamera().m_Orientation.Translate(600, 200, 125);
 #endif
 
 	OnCameraChanged();
 }
 
 void CEditorData::OnCameraChanged() 
 {
 	int width=g_Renderer.GetWidth();
 	int height=g_Renderer.GetHeight();
 
 	// resize viewport
 	SViewPort viewport;
 	viewport.m_X=0;
 	viewport.m_Y=0;
 	viewport.m_Width=width;
 	viewport.m_Height=height;
 	g_NaviCam.GetCamera().SetViewPort(&viewport);
 
 	// rebuild object camera
 	m_ObjectCamera.SetViewPort(&viewport);
 	m_ObjectCamera.SetProjection(1.0f,10000.0f,DEGTORAD(90));
 
 
 	// recalculate projection matrix
 	g_NaviCam.GetCamera().SetProjection(1.0f,10000.0f,DEGTORAD(20));
 
 	// update viewing frustum
 	g_NaviCam.GetCamera().UpdateFrustum();
 
 	// calculate intersection of camera stabbing lines with terrain plane
 
 	// get points of back plane of frustum in camera space
 	float aspect=height>0 ? float(width)/float(height) : 1.0f;
 	float zfar=g_NaviCam.GetCamera().GetFarPlane();
 	CVector3D cPts[4];
 	float x=zfar*float(tan(g_NaviCam.GetCamera().GetFOV()*aspect*0.5));
 	float y=zfar*float(tan(g_NaviCam.GetCamera().GetFOV()*0.5));
 	cPts[0].X=-x;
 	cPts[0].Y=-y;
 	cPts[0].Z=zfar;
 	cPts[1].X=x;
 	cPts[1].Y=-y;
 	cPts[1].Z=zfar;
 	cPts[2].X=x;
 	cPts[2].Y=y;
 	cPts[2].Z=zfar;
 	cPts[3].X=-x;
 	cPts[3].Y=y;
 	cPts[3].Z=zfar;
 
 	// transform to world space
 	CVector3D wPts[4];
 	for (int i=0;i<4;i++) {
 		wPts[i]=g_NaviCam.GetCamera().m_Orientation.Transform(cPts[i]);
 	}
 
 	// now intersect a ray from the camera through each point 
 	CVector3D rayOrigin=g_NaviCam.GetCamera().m_Orientation.GetTranslation();
 	CVector3D rayDir=g_NaviCam.GetCamera().m_Orientation.GetIn();
 
 	CVector3D hitPt[4];
 	for (i=0;i<4;i++) {
 		CVector3D rayDir=wPts[i]-rayOrigin;
 		rayDir.Normalize();
 
 		// get intersection point
 		m_TerrainPlane.FindRayIntersection(rayOrigin,rayDir,&hitPt[i]);
 	}
 
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	for (i=0;i<4;i++) {
 		// convert to minimap space
 		float px=hitPt[i].X;
 		float pz=hitPt[i].Z;
 		g_MiniMap.m_ViewRect[i][0]=(197*px/float(CELL_SIZE*terrain->GetVerticesPerSide()));
 		g_MiniMap.m_ViewRect[i][1]=197*pz/float(CELL_SIZE*terrain->GetVerticesPerSide());
 	}
 }
 
 void CEditorData::RenderTerrain()
 {
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	CFrustum frustum=g_NaviCam.GetCamera().GetFrustum();
 	u32 patchesPerSide=	g_Game->GetWorld()->GetTerrain()->GetPatchesPerSide();
 	for (uint j=0; j<patchesPerSide; j++) {
 		for (uint i=0; i<patchesPerSide; i++) {
 			CPatch* patch=terrain->GetPatch(i,j);
 			if (frustum.IsBoxVisible (CVector3D(0,0,0),patch->GetBounds())) {
 				g_Renderer.Submit(patch);
 			}
 		}
 	}
 }
 
 void CEditorData::OnScreenShot(const char* filename)
 {
 	g_Renderer.SetClearColor(0);
 	g_Renderer.BeginFrame();
 	g_Renderer.SetCamera(g_NaviCam.GetCamera());
 	
 	RenderWorld();
 
 	g_Renderer.EndFrame();
 
 	int width=g_Renderer.GetWidth();
 	int height=g_Renderer.GetHeight();
 	unsigned char* data=new unsigned char[width*height*3];
 
 	glReadBuffer(GL_BACK);
 	glReadPixels(0,0,width,height,GL_BGR_EXT,GL_UNSIGNED_BYTE,data);	
 
 	saveTGA(filename,width,height,data);
 	
 	delete[] data;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 // SubmitModelRecursive: recurse down given model, submitting it and all its descendants to the 
 // renderer
 void SubmitModelRecursive(CModel* model)
 {
 	g_Renderer.Submit(model);
 
 	const std::vector<CModel::Prop>& props=model->GetProps();
 	for (uint i=0;i<props.size();i++) {
 		SubmitModelRecursive(props[i].m_Model);
 	}
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 // RenderNoCull: render absolutely everything to a blank frame to force renderer
 // to load required assets 
 void CEditorData::RenderNoCull()
 {
 	g_Renderer.BeginFrame();
 	g_Renderer.SetCamera(g_NaviCam.GetCamera());
 
 	uint i,j;
 	const std::vector<CUnit*>& units=g_UnitMan.GetUnits();
 	for (i=0;i<units.size();++i) {
 		SubmitModelRecursive(units[i]->GetModel());
 	}
 	
 	CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
 	u32 patchesPerSide=terrain->GetPatchesPerSide();
 	for (j=0; j<patchesPerSide; j++) {
 		for (i=0; i<patchesPerSide; i++) {
 			CPatch* patch=terrain->GetPatch(i,j);
 			g_Renderer.Submit(patch);
 		}
 	}
 
 	g_Renderer.FlushFrame();
 	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 	g_Renderer.EndFrame();
 }
 
 void CEditorData::RenderModels()
 {
 	CFrustum frustum=g_NaviCam.GetCamera().GetFrustum();
 
 	const std::vector<CUnit*>& units=g_UnitMan.GetUnits();
 	uint i;
 	for (i=0;i<units.size();++i) {
 		if (frustum.IsBoxVisible (CVector3D(0,0,0),units[i]->GetModel()->GetBounds())) {
 			SubmitModelRecursive(units[i]->GetModel());
 		}
 	}
 }
 
 void CEditorData::RenderWorld()
 {
 	// render terrain
 	RenderTerrain();
 
 	// render all the units
 	RenderModels();
 	
 	// flush prior to rendering overlays etc
 	g_Renderer.FlushFrame();
 }
 
 void CEditorData::RenderObEdGrid()
 {
 	int i;
 	const int numSteps=32;
 	const CVector3D start(-numSteps*CELL_SIZE/2,0,-numSteps*CELL_SIZE/2);
 	const CVector3D end(numSteps*CELL_SIZE/2,0,numSteps*CELL_SIZE/2);
 
 	glDisable(GL_TEXTURE_2D);
 
 	glDepthMask(0);
 	glColor4f(0.5f,0.5f,0.5f,0.35f);
 	glLineWidth(1.0f);
 	
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 
 	glBegin(GL_LINES);
 	for (i=0;i<=numSteps;i++) {
 		if (i%8==0) continue;
 		CVector3D v0(start.X+(i*(end.X-start.X))/float(numSteps),start.Y,start.Z);
 		glVertex3fv(&v0.X);
 
 		CVector3D v1(v0.X,end.Y,end.Z);
 		glVertex3fv(&v1.X);
 	}
 
 	for (i=0;i<=numSteps;i++) {
 		if (i%8==0) continue;
 		CVector3D v0(start.X,start.Y,start.Z+(i*(end.Z-start.Z))/float(numSteps));
 		glVertex3fv(&v0.X);
 
 		CVector3D v1(end.X,end.Y,v0.Z);
 		glVertex3fv(&v1.X);
 	}
 	glEnd();
 
 	glDisable(GL_BLEND);
 
 	glColor3f(0,0,0.5);
 	glLineWidth(2.0f);
 
 	glBegin(GL_LINES);
 	for (i=0;i<=numSteps;i+=8) {
 		CVector3D v0(start.X+(i*(end.X-start.X))/float(numSteps),start.Y,start.Z);
 		glVertex3fv(&v0.X);
 
 		CVector3D v1(v0.X,end.Y,end.Z);
 		glVertex3fv(&v1.X);
 	}
 
 	for (i=0;i<=numSteps;i+=8) {
 		CVector3D v0(start.X,start.Y,start.Z+(i*(end.Z-start.Z))/float(numSteps));
 		glVertex3fv(&v0.X);
 
 		CVector3D v1(end.X,end.Y,v0.Z);
 		glVertex3fv(&v1.X);
 	}
 	glEnd();
 	glDepthMask(1);
 }
 
 void CEditorData::OnDraw()
 {	
 	if (m_Mode==SCENARIO_EDIT || m_Mode==TEST_MODE) {
 		g_Renderer.SetClearColor(0x00000000);
 		g_Renderer.BeginFrame();
 
 		// setup camera
 		g_Renderer.SetCamera(g_NaviCam.GetCamera());
 
 		// render base terrain plus models
 		RenderWorld();
 
 		if (m_Mode!=TEST_MODE) {
 			// render the active tool
 			g_ToolMan.OnDraw();
 		}
 
 		// flush prior to rendering overlays ..
 		g_Renderer.FlushFrame();
 		
 		// .. and here's the overlays
 		g_MiniMap.Render();
 		m_InfoBox.Render();
 
 		const std::vector<CUnit*>& units=g_UnitMan.GetUnits();
 		for (size_t i=0;i<units.size();++i)
 			if (units[i]->GetEntity())
 				units[i]->GetEntity()->renderSelectionOutline();
 
 	} else {
 		g_Renderer.SetClearColor(0x00453015);
 		g_Renderer.BeginFrame();
 		
 		CObjectEntry* selobject=g_ObjMan.GetSelectedObject();
 		if (selobject && selobject->m_Model) {
 			// setup camera such that object is in the centre of the viewport
 			m_ModelMatrix.SetIdentity();
 			selobject->m_Model->SetTransform(m_ModelMatrix);
 
 			const CBound& bound=selobject->m_Model->GetBounds();
 			CVector3D pt((bound[0].X+bound[1].X)*0.5f,(bound[0].Y+bound[1].Y)*0.5f,bound[0].Z);
 			
 			float hfov=tan(DEGTORAD(45));
 			float vfov=hfov/g_Renderer.GetAspect();
 			float zx=(bound[1].X-bound[0].X)*0.5f/hfov;
 			float zy=(bound[1].Y-bound[0].Y)*0.5f/vfov;
 			float z=zx>zy ? zx : zy;
 			z=(z+1)*2;
 
 			m_ObjectCamera.m_Orientation.SetIdentity();
 			m_ObjectCamera.m_Orientation.Translate(pt.X,pt.Y,-z);
 
 			g_Renderer.SetCamera(m_ObjectCamera);
 
 			RenderObEdGrid();
 
 			g_Renderer.Submit(selobject->m_Model);
 		}
 
 		// flush prior to rendering overlays ..
 		g_Renderer.FlushFrame();
 		
 		// .. and here's the overlays
 		m_InfoBox.Render();
 	}
 
 	g_Renderer.EndFrame();
 
 	// notify info box frame is complete; gives it chance to accumulate stats, check
 	// fps, etc
 	m_InfoBox.OnFrameComplete();
 }
 
 
 bool CEditorData::LoadTerrain(const char* filename)
 {		
 	Handle h = tex_load(filename);
 	if(h<=0) {
 		char buf[1024];
 		sprintf(buf,"Failed to load \"%s\"",filename);
 		ErrorBox(buf);
 		return false;
 	} else {
 
 		int width=0;
 		int height=0;
 		int bpp=0;
 		void *ptr=0;
 
 		int i=tex_info(h, &width, &height, NULL, &bpp, &ptr);
 		if (i)
 		{
 			printf("tex_info error: %d\n",i);
 			fflush(stdout);
 		}
 
 		// rescale the texture to fit to the nearest of the 4 possible map sizes
 		u32 mapsize=9;	// assume smallest map
 		if (width>11*PATCH_SIZE+1) mapsize=11;
 		if (width>13*PATCH_SIZE+1) mapsize=13;
 		if (width>17*PATCH_SIZE+1) mapsize=17;
 
 		u32 targetsize=mapsize*PATCH_SIZE+1;
 		unsigned char* data=new unsigned char[targetsize*targetsize*bpp/8];
 		u32 fmt=(bpp==8) ? GL_RED : ((bpp==24) ? GL_RGB : GL_RGBA);
 		gluScaleImage(fmt,width,height,GL_UNSIGNED_BYTE,ptr,
 			targetsize,targetsize,GL_UNSIGNED_BYTE,data);
 
 		// build 16 bit heightmap from red channel of texture
 		u16* heightmap=new u16[targetsize*targetsize];
 		int stride=bpp/8;
 		u16* hmptr=heightmap;
 
 		// get src of copy
 		const u8* dataptr = (bpp==8) ? data : ((bpp==24) ? data+2 : data+3);
 		
 		// build heightmap
 		for (uint j=0;j<targetsize;++j) {
 			for (uint i=0;i<targetsize;++i) {
 				*hmptr=(*dataptr) << 8;
 				hmptr++;
 				dataptr+=stride;
 			}
 		}
 
 		// rebuild terrain
 		g_Game->GetWorld()->GetTerrain()->Resize(mapsize);
 		g_Game->GetWorld()->GetTerrain()->SetHeightMap(heightmap);
 		
 		// clean up
 		delete[] data;
 		delete[] heightmap;
 
 		// re-initialise minimap - terrain size may have changed
 		g_MiniMap.Initialise();
 
 		return true;
 	}
 }
 
 // UpdateWorld: update time dependent data in the world to account for changes over 
 // the given time (in s)
 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);
 		}
 		if (m_Mode==TEST_MODE) {
 			g_EntityManager.updateAll( time );
 		}
 	} else {
 		CObjectEntry* selobject=g_ObjMan.GetSelectedObject();
 		if (selobject && selobject->m_Model) {
 			selobject->m_Model->Update(time);
 		}
 	}	
 }
 
 void CEditorData::StartTestMode()
 {	
 	// initialise entities
 	g_EntityManager.InitializeAll();
 }
 
 void CEditorData::StopTestMode()
 {	
 	// make all units idle again
 	const std::vector<CUnit*>& units=g_UnitMan.GetUnits();
 	for (uint i=0;i<units.size();++i) {
 		if (units[i]->GetObject()->m_IdleAnim) {
 			units[i]->GetModel()->SetAnimation(units[i]->GetObject()->m_IdleAnim);
 		}
 	}
 }
\ No newline at end of file
Index: ps/trunk/source/ps/World.cpp
===================================================================
--- ps/trunk/source/ps/World.cpp	(revision 1919)
+++ ps/trunk/source/ps/World.cpp	(revision 1920)
@@ -1,44 +1,48 @@
 #include "precompiled.h"
 
 #include "CStr.h"
 #include "CLogger.h"
 #include "ps/Errors.h"
 
 #include "World.h"
 #include "MapReader.h"
 #include "Game.h"
 #include "Terrain.h"
 #include "LightEnv.h"
 #include "BaseEntityCollection.h"
 #include "EntityManager.h"
 
 #define LOG_CATEGORY "world"
 
 CLightEnv g_LightEnv;
 
 void CWorld::Initialize(CGameAttributes *pAttribs)
 {
 	g_EntityTemplateCollection.loadTemplates();
 
-	CStr mapfilename("maps/scenarios/");
-
-	mapfilename += (CStr)pAttribs->m_MapFile;
-
-	try {
-		CMapReader reader;
-		reader.LoadMap(mapfilename, &m_Terrain, &m_UnitManager, &g_LightEnv);
-	} catch (...) {
-		LOG(ERROR, LOG_CATEGORY, "Failed to load map %s", mapfilename.c_str());
-		throw PSERROR_Game_World_MapLoadFailed();
+	// Load the map, if one was specified
+	if (pAttribs->m_MapFile.Length())
+	{
+		CStr mapfilename("maps/scenarios/");
+
+		mapfilename += (CStr)pAttribs->m_MapFile;
+
+		try {
+			CMapReader reader;
+			reader.LoadMap(mapfilename, &m_Terrain, &m_UnitManager, &g_LightEnv);
+		} catch (...) {
+			LOG(ERROR, LOG_CATEGORY, "Failed to load map %s", mapfilename.c_str());
+			throw PSERROR_Game_World_MapLoadFailed();
+		}
 	}
 }
 
 CWorld::~CWorld()
 {
 	// The Entity Manager should perhaps be converted into a CWorld member..
 	// But for now, we'll just create and delete the global singleton instance
 	// following the creation and deletion of CWorld.
 	// The reason for not keeping the instance around is that we require a
 	// clean slate for each game start.
 	delete &m_EntityManager;
 }
Index: ps/trunk/source/ps/XMLWriter.cpp
===================================================================
--- ps/trunk/source/ps/XMLWriter.cpp	(revision 1919)
+++ ps/trunk/source/ps/XMLWriter.cpp	(revision 1920)
@@ -1,174 +1,173 @@
 #include "precompiled.h"
 
 #include "XMLWriter.h"
 
-// TODO: (MT) Someone who knows what this is supposed to do, please take a look at CPlayer and make sure it's doing what it's supposed to.
-
-#include "Player.h"
 #include "ps/CLogger.h"
 #include "lib/res/vfs.h"
 
-// TODO: Write to the VFS handle all the time frequently, instead of buffering
+// TODO (maybe): Write to the VFS handle 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)
 	: m_LastElement(NULL), m_Indent(0)
 {
 	m_Data = "<?xml version=\"1.0\" encoding=\"";
 	m_Data += encoding;
 	m_Data += "\" standalone=\"no\"?>\n";
 }
 
 void XMLWriter_File::Doctype(const char* type, const char* dtd)
 {
 	m_Data += "<!DOCTYPE ";
 	m_Data += type;
 	m_Data += " SYSTEM \"";
 	m_Data += dtd;
 	m_Data += "\">\n";
 }
 
 bool XMLWriter_File::StoreVFS(Handle h)
 {
 	if (m_LastElement) debug_warn("ERROR: Saving XML while an element is still open");
 
 	void* data = (void*)m_Data.data();
 	int err = vfs_io(h, m_Data.Length(), &data);
 	if (err < 0)
 	{
 		LOG(ERROR, "xml", "Error saving XML data through VFS: %lld", h);
 		return false;
 	}
 	return true;
 }
 
 void XMLWriter_File::Comment(const char* text)
 {
 	ElementStart(NULL, "!-- ");
 	m_Data += text;
 	m_Data += " -->";
 	--m_Indent;
 }
 
 CStr XMLWriter_File::Indent()
 {
 	return std::string(m_Indent, '\t');
 }
 
 void XMLWriter_File::ElementStart(XMLWriter_Element* element, const char* name)
 {
 	if (m_LastElement) m_LastElement->Close(EL_SUBEL);
 	m_LastElement = element;
 	m_Data += "\n" + Indent() + "<" + name;
 
 	++m_Indent;
 }
 
 void XMLWriter_File::ElementClose()
 {
 	m_Data += ">";
 }
 
 void XMLWriter_File::ElementEnd(const char* name, int type)
 {
 	--m_Indent;
 	m_LastElement = NULL;
 
 	switch (type)
 	{
 	case EL_ATTR:
 		m_Data += " />";
 		break;
 	case EL_TEXT:
 		m_Data += "</";
 		m_Data += name;
 		m_Data += ">";
 		break;
 	case EL_SUBEL:
 		m_Data += "\n" + Indent() + "</" + name += ">";
 		break;
 	default:
 		assert(0);
 	}
 }
 
 void XMLWriter_File::ElementText(const char* text)
 {
 	m_Data += text;
 }
 
 
 XMLWriter_Element::XMLWriter_Element(XMLWriter_File& file, const char* name)
 	: m_File(&file), m_Name(name), m_Type(EL_ATTR)
 {
 	m_File->ElementStart(this, name);
 }
 
 
 XMLWriter_Element::~XMLWriter_Element()
 {
 	m_File->ElementEnd(m_Name, m_Type);
 }
 
 
 void XMLWriter_Element::Close(int type)
 {
 	m_File->ElementClose();
 	m_Type = type;
 }
 
 void XMLWriter_Element::Text(const char* text)
 {
 	Close(EL_TEXT);
 	m_File->ElementText(text);
 }
 
 
 
 template <> void XMLWriter_File::ElementAttribute<CStr>(const char* name, const CStr& value, bool newelement)
 {
 	if (newelement)
 	{
 		ElementStart(NULL, name);
 		m_Data += ">";
 		ElementText(value);
 		ElementEnd(name, EL_TEXT);
 	}
 	else
 	{
 		assert(m_LastElement && m_LastElement->m_Type == EL_ATTR);
 		m_Data += " ";
 		m_Data += name;
 		m_Data += "=\"" + value + "\"";
 	}
 }
 
-// Attribute/setting value-to-string template specialisations:
+// Attribute/setting value-to-string template specialisations.
+//
+// These only deal with basic types. Anything more complicated should
+// be converted into a basic type by whatever is making use of XMLWriter,
+// to keep game-related logic out of the not-directly-game-related code here.
 
 // Use CStr's conversion for most types:
 #define TYPE2(ID_T, ARG_T) \
 template <> void XMLWriter_File::ElementAttribute<ID_T>(const char* name, ARG_T value, bool newelement) \
 { \
 	ElementAttribute(name, CStr(value), newelement); \
 }
 #define TYPE(T) TYPE2(T, const T &)
 
 TYPE(int)
 TYPE(unsigned int)
 TYPE(float)
 TYPE(double)
 // This is the effect of doing const T& with T=const char* - char const* const&
 // Weird - I know ;-)
 TYPE2(const char *, char const* const&) 
 
+// Encode Unicode strings as UTF-8 (though that will only be correct if
+// the encoding was set to "utf-8"; it'll look a little odd if you store
+// Unicode strings in an iso-8859-1 file, so please don't do that)
 template <> void XMLWriter_File::ElementAttribute<CStrW>(const char* name, const CStrW& value, bool newelement)
 {
 	ElementAttribute(name, value.utf8(), newelement);
 }
-
-template <> void XMLWriter_File::ElementAttribute<CPlayer*>(const char* name, CPlayer*const & value, bool newelement)
-{
-	ElementAttribute(name, value->GetPlayerID(), newelement);
-}
Index: ps/trunk/source/ps/Network/Session.h
===================================================================
--- ps/trunk/source/ps/Network/Session.h	(revision 1919)
+++ ps/trunk/source/ps/Network/Session.h	(revision 1920)
@@ -1,74 +1,74 @@
 #ifndef _Network_NetSession_H
 #define _Network_NetSession_H
 
 #include <Network/Network.h>
 #include <Network/SessionManager.h>
 
 /*
 	CNetSession
 
 	DESCRIPTION:
 		The representation of a network session (on both the client and server
 		side)
 */
 class CNetSession: public CMessageSocket
 {
 protected:
 	/*
 		The MessageHandler callback follows the contract of HandleMessage, see
 		the documentation for that function for more information.
 	*/
 	typedef bool (MessageHandler)(CNetMessage *, CNetSession *);
 	MessageHandler *m_pMessageHandler;
 
 	CStrW m_Name;
 
 public:
 	/*
-		Note: This constructer takes over ownership of the passed pipe end. It
+		Note: This constructor takes over ownership of the passed pipe end. It
 		should not be freed by the caller, and should be heap-allocated.
 	 */
 	inline CNetSession(MessageHandler *pMsgHandler=NULL):
 		m_pMessageHandler(pMsgHandler)
 	{
 		g_SessionManager.Register(this);
 	}
 	inline CNetSession(CSocketInternal *pInt, MessageHandler *pMsgHandler=NULL):
 		CMessageSocket(pInt),
 		m_pMessageHandler(pMsgHandler)
 	{
 		g_SessionManager.Register(this);
 	}
 
 	virtual ~CNetSession();
 
 	/*
 		Handle an incoming message.
 
 		THREADS:
 			When used with the session manager, this method will only be
 			called from the main thread.
 
 		ARGUMENTS:
 			pMsg		The incoming message
 			pSocket		The socket the message came from
 
 		RETURNS:
 			TRUE if the message was handled by this class or another protocol
 			that this class knows of. FALSE if the message was not handled.
 	*/
 	inline bool HandleMessage(CNetMessage *pMsg)
 	{
 		if (m_pMessageHandler)
 			return (m_pMessageHandler)(pMsg, this);
 		else
 			return false;
 	}
 
 	inline CStrW GetName()
 	{
 		return m_Name;
 	}
 };
 
 #endif //_Network_NetSession_H