Index: ps/trunk/source/graphics/MapReader.cpp
===================================================================
--- ps/trunk/source/graphics/MapReader.cpp	(revision 4647)
+++ ps/trunk/source/graphics/MapReader.cpp	(revision 4648)
@@ -1,885 +1,1050 @@
 #include "precompiled.h"
 
 #include "MapReader.h"
 
 #include "graphics/Camera.h"
 #include "graphics/GameView.h"
 #include "graphics/Model.h"
 #include "graphics/ObjectManager.h"
 #include "graphics/Patch.h"
 #include "graphics/Terrain.h"
 #include "graphics/TextureEntry.h"
 #include "graphics/TextureManager.h"
 #include "graphics/Unit.h"
 #include "graphics/UnitManager.h"
 #include "lib/timer.h"
 #include "lib/types.h"
 #include "maths/MathUtil.h"
 #include "ps/CLogger.h"
 #include "ps/Game.h"
 #include "ps/Loader.h"
 #include "ps/LoaderThunks.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/SkyManager.h"
 #include "renderer/WaterManager.h"
 #include "simulation/Entity.h"
 #include "simulation/EntityManager.h"
+#include "simulation/TriggerManager.h"
 #include "simulation/EntityTemplate.h"
 #include "simulation/EntityTemplateCollection.h"
 
 #define LOG_CATEGORY "graphics"
 
 CMapReader::CMapReader()
 	: xml_reader(0)
 {
 	cur_terrain_tex = 0;	// important - resets generator state
 }
 
 
 // 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_, WaterManager* pWaterMan_, SkyManager* pSkyMan_,
 						 CLightEnv *pLightEnv_, CCamera *pCamera_, CCinemaManager* pCinema_)
 {
 	// latch parameters (held until DelayedLoadFinished)
 	pTerrain = pTerrain_;
 	pUnitMan = pUnitMan_;
 	pLightEnv = pLightEnv_;
 	pCamera = pCamera_;
 	pWaterMan = pWaterMan_;
 	pSkyMan = pSkyMan_;
 	pCinema = pCinema_;
 
 	// [25ms]
 	unpacker.Read(filename, "PSMP");
 
 	// check version
 	if (unpacker.GetVersion() < FILE_READ_VERSION) {
 		throw PSERROR_File_InvalidVersion();
 	}
 
 	// delete all existing entities
 	g_EntityManager.deleteAll();
 	// delete all remaining non-entity units
 	pUnitMan->DeleteAll();
 	g_UnitMan.SetNextID(0);
 
 	// unpack the data
 	RegMemFun(this, &CMapReader::UnpackMap, L"CMapReader::UnpackMap", 1200);
 
 	if (unpacker.GetVersion() >= 3) {
 		// read the corresponding XML file
 		filename_xml = filename;
 		filename_xml = filename_xml.Left(filename_xml.Length()-4) + ".xml";
 		RegMemFun(this, &CMapReader::ReadXML, L"CMapReader::ReadXML", 5800);
 	}
 
 	// apply data to the world
 	RegMemFun(this, &CMapReader::ApplyData, L"CMapReader::ApplyData", 5);
 
 	RegMemFun(this, &CMapReader::DelayLoadFinished, L"CMapReader::DelayLoadFinished", 5);
 }
 
 // UnpackMap: unpack the given data from the raw data stream into local variables
 int CMapReader::UnpackMap()
 {
 	// now unpack everything into local data
 	int ret = UnpackTerrain();
 	if(ret != 0)	// failed or timed out
 		return ret;
 
 	if (unpacker.GetVersion() < 4)
 		UnpackObjects();
 
 	if (unpacker.GetVersion() >= 2 && unpacker.GetVersion() < 4)
 		UnpackLightEnv();
 
 	return 0;
 }
 
 // UnpackLightEnv: unpack lighting parameters from input stream
 void CMapReader::UnpackLightEnv()
 {
 	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()
 {
 	// unpack object types
 	u32 numObjTypes;
 	unpacker.UnpackRaw(&numObjTypes, sizeof(numObjTypes));
 	m_ObjectTypes.resize(numObjTypes);
 	for (u32 i=0; i<numObjTypes; i++) {
 		unpacker.UnpackString(m_ObjectTypes[i]);
 	}
 
 	// unpack object data
 	u32 numObjects;
 	unpacker.UnpackRaw(&numObjects, sizeof(numObjects));
 	m_Objects.resize(numObjects);
 	if (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
 int CMapReader::UnpackTerrain()
 {
 	// yield after this time is reached. balances increased progress bar
 	// smoothness vs. slowing down loading.
 	const double end_time = get_time() + 200e-3;
 
 	// first call to generator (this is skipped after first call,
 	// i.e. when the loop below was interrupted)
 	if (cur_terrain_tex == 0)
 	{
 		// unpack map size
 		unpacker.UnpackRaw(&m_MapSize, sizeof(m_MapSize));
 
 		// unpack heightmap [600us]
 		u32 verticesPerSide = m_MapSize*PATCH_SIZE+1;
 		m_Heightmap.resize(SQR(verticesPerSide));
 		unpacker.UnpackRaw(&m_Heightmap[0], SQR(verticesPerSide)*sizeof(u16));
 
 		// unpack # textures
 		unpacker.UnpackRaw(&num_terrain_tex, sizeof(num_terrain_tex));
 		m_TerrainTextures.reserve(num_terrain_tex);
 	}
 
 	// unpack texture names; find handle for each texture.
 	// interruptible.
 	while (cur_terrain_tex < num_terrain_tex)
 	{
 		CStr texturename;
 		unpacker.UnpackString(texturename);
 
 		Handle handle;
 		CTextureEntry* texentry = g_TexMan.FindTexture(texturename);
 		// mismatch between texture datasets?
 		if (!texentry)
 			handle = 0;
 		else
 			handle = texentry->GetHandle();
 		m_TerrainTextures.push_back(handle);
 
 		cur_terrain_tex++;
 		LDR_CHECK_TIMEOUT(cur_terrain_tex, num_terrain_tex);
 	}
 
 	// unpack tile data [3ms]
 	u32 tilesPerSide = m_MapSize*PATCH_SIZE;
 	m_Tiles.resize(SQR(tilesPerSide));
 	unpacker.UnpackRaw(&m_Tiles[0], (u32)(sizeof(STileDesc)*m_Tiles.size()));
 
 	// reset generator state.
 	cur_terrain_tex = 0;
 
 	return 0;
 }
 int CMapReader::UnpackCinema()
 {
 	size_t numTracks;
 	unpacker.UnpackRaw(&numTracks, (u32)sizeof(size_t));
 	
 	for ( size_t track=0; track < numTracks; ++track )
 	{
 		CCinemaTrack trackObj;
 		std::vector<CCinemaPath> paths;
 		CStr name;
 		size_t numPaths;
 		CVector3D startRotation;
 		float timescale;
 
 		unpacker.UnpackString(name);
 		unpacker.UnpackRaw(&timescale, sizeof(float));
 		unpacker.UnpackRaw(&numPaths, sizeof(size_t));
 		unpacker.UnpackRaw(&startRotation, sizeof(CVector3D));
 
 		trackObj.SetStartRotation(startRotation);
 		trackObj.SetTimescale(timescale);
 
 		for ( size_t i=0; i<numPaths; ++i )
 		{
 			TNSpline spline;
 			size_t numNodes;
 			CCinemaData data;
 			
 			if ( i != 0 )
 				unpacker.UnpackRaw(&data.m_TotalRotation, sizeof(CVector3D));
 			unpacker.UnpackRaw(&data.m_Mode, sizeof(data.m_Mode));
 			unpacker.UnpackRaw(&data.m_Style, sizeof(data.m_Style));
 			unpacker.UnpackRaw(&data.m_Growth, sizeof(data.m_Growth));
 			unpacker.UnpackRaw(&data.m_Switch, sizeof(data.m_Switch));
 			unpacker.UnpackRaw(&numNodes, sizeof(size_t));
 			data.m_GrowthCount = data.m_Growth;
 
 			for ( size_t j=0; j < numNodes; ++j )
 			{
 				CVector3D position;
 				float distance;
 				unpacker.UnpackRaw(&position, sizeof(position));
 				unpacker.UnpackRaw(&distance, sizeof(distance));
 				spline.AddNode(position, distance);
 			}
 			trackObj.AddPath(data, spline);
 		}
 		m_Tracks[CStrW(name)] = trackObj;
 	}
 	return 0;
 }
 
 // ApplyData: take all the input data, and rebuild the scene from it
 int CMapReader::ApplyData()
 {
 	// 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<(u32)PATCH_SIZE; m++) {
 				for (u32 k=0; k<(u32)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++;
 				}
 			}
 		}
 	}
 
 	// add new objects
 	for (size_t i = 0; i < m_Objects.size(); ++i)
 	{
 
 		if (unpacker.GetVersion() < 3)
 		{
 			debug_warn("Old unsupported map version - objects will be missing");
 			// (getTemplateByActor doesn't work, since entity templates are now
 			// loaded on demand)
 		}
 
 		std::set<CStr8> selections; // TODO: read from file
 		CUnit* unit = g_UnitMan.CreateUnit(m_ObjectTypes.at(m_Objects[i].m_ObjectIndex), NULL, selections);
 
 		if (unit)
 		{
 			CMatrix3D transform;
 			memcpy2(&transform._11, m_Objects[i].m_Transform, sizeof(float)*16);
 			unit->GetModel()->SetTransform(transform);
 		}
 	}
 	//Make units start out conforming correctly
 	g_EntityManager.conformAll();
 
 	if (unpacker.GetVersion() >= 2)
 	{
 		// copy over the lighting parameters
 		*pLightEnv = m_LightEnv;
 	}
 	return 0;
 }
 
 
 
 // Holds various state data while reading maps, so that loading can be
 // interrupted (e.g. to update the progress display) then later resumed.
 class CXMLReader
 {
 public:
 	CXMLReader(const CStr& xml_filename, CMapReader& mapReader)
 		: m_MapReader(mapReader)
 	{
 		Init(xml_filename);
 	}
 
 	// return semantics: see Loader.cpp!LoadFunc.
 	int ProgressiveRead();
 
 private:
 	CXeromyces xmb_file;
 
 	CMapReader& m_MapReader;
 
 	int el_entity;
 	int el_tracks;
 	int el_template, el_player;
 	int el_position, el_orientation;
 	int el_nonentity;
 	int el_actor;
 	int at_x, at_y, at_z;
 	int at_angle;
 
 	XMBElementList nodes; // children of root
 
 	// loop counters
 	int node_idx;
 	int entity_idx, nonentity_idx;
 
 	// # entities+nonentities processed and total (for progress calc)
 	int completed_jobs, total_jobs;
 
 
 	void Init(const CStr& xml_filename);
 
 	void ReadEnvironment(XMBElement parent);
 	void ReadCamera(XMBElement parent);
 	void ReadCinema(XMBElement parent);
+	void ReadTriggers(XMBElement parent);
+	void ReadTriggerGroup(XMBElement parent, MapTriggerGroup& group);
 	int ReadEntities(XMBElement parent, double end_time);
 	int ReadNonEntities(XMBElement parent, double end_time);
 
 	NO_COPY_CTOR(CXMLReader);
 };
 
 
 void CXMLReader::Init(const CStr& xml_filename)
 {
 	// must only assign once, so do it here
 	node_idx = entity_idx = nonentity_idx = 0;
 
 	if (xmb_file.Load(xml_filename) != PSRETURN_OK)
 		throw PSERROR_File_ReadFailed();
 
 	// define the elements and attributes that are frequently used in the XML file,
 	// so we don't need to do lots of string construction and comparison when
 	// reading the data.
 	// (Needs to be synchronised with the list in CXMLReader - ugh)
 #define EL(x) el_##x = xmb_file.getElementID(#x)
 #define AT(x) at_##x = xmb_file.getAttributeID(#x)
 	EL(entity);
 	EL(tracks);
 	EL(template);
 	EL(player);
 	EL(position);
 	EL(orientation);
 	EL(nonentity);
 	EL(actor);
 	AT(x); AT(y); AT(z);
 	AT(angle);
 #undef AT
 #undef EL
 
 	XMBElement root = xmb_file.getRoot();
 	debug_assert(xmb_file.getElementString(root.getNodeName()) == "Scenario");
 	nodes = root.getChildNodes();
 
 	// find out total number of entities+nonentities
 	// (used when calculating progress)
 	completed_jobs = 0;
 	total_jobs = 0;
 	for (int i = 0; i < nodes.Count; i++)
 		total_jobs += nodes.item(i).getChildNodes().Count;
 }
 
 
 void CXMLReader::ReadEnvironment(XMBElement parent)
 {
 #define EL(x) int el_##x = xmb_file.getElementID(#x)
 #define AT(x) int at_##x = xmb_file.getAttributeID(#x)
 	EL(skyset);
 	EL(suncolour);
 	EL(sunelevation);
 	EL(sunrotation);
 	EL(terrainambientcolour);
 	EL(unitsambientcolour);
 	EL(terrainshadowtransparency);
 	EL(water);
 	EL(waterbody);
 	EL(type);
 	EL(colour);
 	EL(height);
 	EL(shininess);
 	EL(waviness);
 	EL(murkiness);
 	EL(tint);
 	EL(reflectiontint);
 	EL(reflectiontintstrength);
 	AT(r); AT(g); AT(b);
 #undef AT
 #undef EL
 
 	XERO_ITER_EL(parent, element)
 	{
 		int element_name = element.getNodeName();
 
 		XMBAttributeList attrs = element.getAttributes();
 
 		if (element_name == el_skyset)
 		{
 			m_MapReader.pSkyMan->SetSkySet(element.getText());
 		}
 		else if (element_name == el_suncolour)
 		{
 			m_MapReader.m_LightEnv.m_SunColor = RGBColor(
 				CStr(attrs.getNamedItem(at_r)).ToFloat(),
 				CStr(attrs.getNamedItem(at_g)).ToFloat(),
 				CStr(attrs.getNamedItem(at_b)).ToFloat());
 		}
 		else if (element_name == el_sunelevation)
 		{
 			m_MapReader.m_LightEnv.m_Elevation = CStr(attrs.getNamedItem(at_angle)).ToFloat();
 		}
 		else if (element_name == el_sunrotation)
 		{
 			m_MapReader.m_LightEnv.m_Rotation = CStr(attrs.getNamedItem(at_angle)).ToFloat();
 		}
 		else if (element_name == el_terrainambientcolour)
 		{
 			m_MapReader.m_LightEnv.m_TerrainAmbientColor = RGBColor(
 				CStr(attrs.getNamedItem(at_r)).ToFloat(),
 				CStr(attrs.getNamedItem(at_g)).ToFloat(),
 				CStr(attrs.getNamedItem(at_b)).ToFloat());
 		}
 		else if (element_name == el_unitsambientcolour)
 		{
 			m_MapReader.m_LightEnv.m_UnitsAmbientColor = RGBColor(
 				CStr(attrs.getNamedItem(at_r)).ToFloat(),
 				CStr(attrs.getNamedItem(at_g)).ToFloat(),
 				CStr(attrs.getNamedItem(at_b)).ToFloat());
 		}
 		else if (element_name == el_terrainshadowtransparency)
 		{
 			m_MapReader.m_LightEnv.SetTerrainShadowTransparency(CStr(element.getText()).ToFloat());
 		}
 		else if (element_name == el_water)
 		{
 			XERO_ITER_EL(element, waterbody)
 			{
 				debug_assert(waterbody.getNodeName() == el_waterbody);
 				XERO_ITER_EL(waterbody, waterelement)
 				{
 					int element_name = waterelement.getNodeName();
 					if (element_name == el_type)
 					{
 						// TODO: implement this, when WaterManager supports it
 					}
 
 #define READ_COLOUR(el, out) \
 					else if (element_name == el) \
 					{ \
 						XMBAttributeList attrs = waterelement.getAttributes(); \
 						out = CColor( \
 							CStr(attrs.getNamedItem(at_r)).ToFloat(), \
 							CStr(attrs.getNamedItem(at_g)).ToFloat(), \
 							CStr(attrs.getNamedItem(at_b)).ToFloat(), \
 							1.f); \
 					}
 
 #define READ_FLOAT(el, out) \
 					else if (element_name == el) \
 					{ \
 						out = CStr(waterelement.getText()).ToFloat(); \
 					} \
 
 					READ_COLOUR(el_colour, m_MapReader.pWaterMan->m_WaterColor)
 					READ_FLOAT(el_height, m_MapReader.pWaterMan->m_WaterHeight)
 					READ_FLOAT(el_shininess, m_MapReader.pWaterMan->m_Shininess)
 					READ_FLOAT(el_waviness, m_MapReader.pWaterMan->m_Waviness)
 					READ_FLOAT(el_murkiness, m_MapReader.pWaterMan->m_Murkiness)
 					READ_COLOUR(el_tint, m_MapReader.pWaterMan->m_WaterTint)
 					READ_COLOUR(el_reflectiontint, m_MapReader.pWaterMan->m_ReflectionTint)
 					READ_FLOAT(el_reflectiontintstrength, m_MapReader.pWaterMan->m_ReflectionTintStrength)
 
 #undef READ_FLOAT
 #undef READ_COLOUR
 
 					else
 						debug_warn("Invalid map XML data");
 				}
 
 			}
 		}
 		else
 			debug_warn("Invalid map XML data");
 	}
 
 	m_MapReader.m_LightEnv.CalculateSunDirection();
 }
 
 void CXMLReader::ReadCamera(XMBElement parent)
 {
 #define EL(x) int el_##x = xmb_file.getElementID(#x)
 #define AT(x) int at_##x = xmb_file.getAttributeID(#x)
 	EL(declination);
 	EL(rotation);
 	EL(position);
 	AT(angle);
 	AT(x); AT(y); AT(z);
 #undef AT
 #undef EL
 
 	float declination = DEGTORAD(30.f), rotation = DEGTORAD(-45.f);
 	CVector3D translation = CVector3D(100, 150, -100);
 
 	XERO_ITER_EL(parent, element)
 	{
 		int element_name = element.getNodeName();
 
 		XMBAttributeList attrs = element.getAttributes();
 		if (element_name == el_declination)
 		{
 			declination = CStr(attrs.getNamedItem(at_angle)).ToFloat();
 		}
 		else if (element_name == el_rotation)
 		{
 			rotation = CStr(attrs.getNamedItem(at_angle)).ToFloat();
 		}
 		else if (element_name == el_position)
 		{
 			translation = CVector3D(
 				CStr(attrs.getNamedItem(at_x)).ToFloat(),
 				CStr(attrs.getNamedItem(at_y)).ToFloat(),
 				CStr(attrs.getNamedItem(at_z)).ToFloat());
 		}
 		else
 			debug_warn("Invalid map XML data");
 	}
 
 	m_MapReader.pCamera->m_Orientation.SetXRotation(declination);
 	m_MapReader.pCamera->m_Orientation.RotateY(rotation);
 	m_MapReader.pCamera->m_Orientation.Translate(translation);
 	m_MapReader.pCamera->UpdateFrustum();
 }
 
 void CXMLReader::ReadCinema(XMBElement parent)
 {
 	#define EL(x) int el_##x = xmb_file.getElementID(#x)
 	#define AT(x) int at_##x = xmb_file.getAttributeID(#x)
 
 	EL(track);
 	EL(startrotation);
 	EL(path);
 	EL(rotation);
 	EL(distortion);
 	EL(node);
 	AT(name);
 	AT(timescale);
 	AT(mode);
 	AT(style);
 	AT(growth);
 	AT(switch);
 	AT(x);
 	AT(y);
 	AT(z);
 	AT(t);
 
 #undef EL
 #undef AT
 	
 	std::map<CStrW, CCinemaTrack> trackList;
 	XERO_ITER_EL(parent, element)
 	{
 		int elementName = element.getNodeName();
 			
 		if ( elementName == el_track )
 		{
 			CCinemaTrack track;
 			XMBAttributeList attrs = element.getAttributes();
 			CStrW name( CStr(attrs.getNamedItem(at_name)) );
 			float timescale = CStr(attrs.getNamedItem(at_timescale)).ToFloat();
 			track.SetTimescale(timescale);
 
 			XERO_ITER_EL(element, trackChild)
 			{
 				elementName = trackChild.getNodeName();
 
 				if ( elementName == el_startrotation )
 				{
 					attrs = trackChild.getAttributes();
 					float x = CStr(attrs.getNamedItem(at_x)).ToFloat();
 					float y = CStr(attrs.getNamedItem(at_y)).ToFloat();
 					float z = CStr(attrs.getNamedItem(at_z)).ToFloat();
 					track.SetStartRotation(CVector3D(x, y, z));
 				}
 				else if ( elementName == el_path )
 				{
 					CCinemaData pathData;
 					TNSpline spline, backwardSpline;
 
 					XERO_ITER_EL(trackChild, pathChild)
 					{
 						elementName = pathChild.getNodeName();
 						attrs = pathChild.getAttributes();
 
 						if ( elementName == el_rotation )
 						{
 							float x = CStr(attrs.getNamedItem(at_x)).ToFloat();
 							float y = CStr(attrs.getNamedItem(at_y)).ToFloat();
 							float z = CStr(attrs.getNamedItem(at_z)).ToFloat();
 							pathData.m_TotalRotation = CVector3D(x, y, z);
 						}
 						else if ( elementName == el_distortion )
 						{
 							pathData.m_Mode = CStr(attrs.getNamedItem(at_mode)).ToInt();
 							pathData.m_Style = CStr(attrs.getNamedItem(at_style)).ToInt();
 							pathData.m_Growth = CStr(attrs.getNamedItem(at_growth)).ToInt();
 							pathData.m_Switch = CStr(attrs.getNamedItem(at_switch)).ToInt();
 						}
 						else if ( elementName == el_node )
 						{
 							SplineData data;
 							data.Position.X = CStr(attrs.getNamedItem(at_x)).ToFloat();
 							data.Position.Y = CStr(attrs.getNamedItem(at_y)).ToFloat();
 							data.Position.Z = CStr(attrs.getNamedItem(at_z)).ToFloat();
 							data.Distance = CStr(attrs.getNamedItem(at_t)).ToFloat();
 							backwardSpline.AddNode(data.Position, data.Distance);
 						}
 						else
 							debug_warn("Invalid cinematic element for path child");
 					}	//node loop
 					CCinemaPath temp(pathData, backwardSpline);
 					const std::vector<SplineData>& nodes = temp.GetAllNodes();
 					if ( nodes.empty() )
 					{
 						debug_warn("Failure loading cinematics");
 						return;
 					}
 					
 					for ( std::vector<SplineData>::const_reverse_iterator 
 						it=nodes.rbegin(); it != nodes.rend(); ++it )
 					{
 						spline.AddNode(it->Position, it->Distance);
 					}
 					track.AddPath(pathData, spline);
 
 				}	// == el_path
 				else
 					debug_warn("Invalid cinematic element for track child");
 			}
 			trackList[name] = track;
 		}
 		else 
 			debug_warn("Invalid cinematic element for root track child");
 	}
 	g_Game->GetView()->GetCinema()->SetAllTracks(trackList);
 }
 
+void CXMLReader::ReadTriggers(XMBElement parent)
+{
+	MapTriggerGroup rootGroup( CStrW(L"Triggers"), CStrW(L"") );
+	g_TriggerManager.DestroyEngineTriggers();
+	ReadTriggerGroup(parent, rootGroup);
+}
+
+void CXMLReader::ReadTriggerGroup(XMBElement parent, MapTriggerGroup& group)
+{
+	#define EL(x) int el_##x = xmb_file.getElementID(#x)
+	#define AT(x) int at_##x = xmb_file.getAttributeID(#x)
+	
+	EL(group);
+	EL(trigger);
+	EL(active);
+	EL(delay);
+	EL(maxruncount);
+	EL(conditions);
+	EL(logicblock);
+	EL(logicblockend);
+	EL(condition);
+	EL(parameter);
+	EL(linklogic);
+	EL(effects);
+	EL(effect);
+
+	AT(name);
+	AT(function);
+	AT(display);
+	AT(not);
+	
+	#undef EL
+	#undef AT
+	
+	CStrW name = parent.getAttributes().getNamedItem(at_name), parentName = group.parentName;
+	if ( group.name == L"Triggers" )
+		name = group.name;
+	
+	MapTriggerGroup mapGroup(name, parentName);
+
+	XERO_ITER_EL(parent, groupChild)
+	{
+		int elementName = groupChild.getNodeName();
+		if ( elementName == el_group )
+			ReadTriggerGroup(groupChild, mapGroup);
+		
+		else if ( elementName == el_trigger )
+		{
+			MapTrigger mapTrigger;
+			mapTrigger.name = CStrW( groupChild.getAttributes().getNamedItem(at_name) );
+
+			//Read everything in this trigger
+			XERO_ITER_EL(groupChild, triggerChild)
+			{
+				elementName = triggerChild.getNodeName();
+				if ( elementName == el_active )
+				{
+					if ( CStr("false") == CStr( triggerChild.getText() ) )
+						mapTrigger.active = false;
+					else
+						mapTrigger.active = true;
+				}
+			
+				else if ( elementName == el_maxruncount )
+					mapTrigger.maxRunCount = CStr( triggerChild.getText() ).ToInt();
+				else if ( elementName == el_delay )
+					mapTrigger.timeValue = CStr( triggerChild.getText() ).ToFloat();
+			
+				else if ( elementName == el_conditions )
+				{
+					//Read in all conditions for this trigger
+					XERO_ITER_EL(triggerChild, condition)
+					{
+						elementName = condition.getNodeName();
+						if ( elementName == el_condition )
+						{
+							MapTriggerCondition mapCondition;
+							mapCondition.name = condition.getAttributes().getNamedItem(at_name);
+							mapCondition.functionName = condition.getAttributes().getNamedItem(at_function);
+							mapCondition.displayName = condition.getAttributes().getNamedItem(at_display);
+							
+							CStr notAtt(condition.getAttributes().getNamedItem(at_not));
+							if ( notAtt == CStr("true") )
+								mapCondition.not = true;
+
+							//Read in each condition child
+							XERO_ITER_EL(condition, conditionChild)
+							{
+								elementName = conditionChild.getNodeName();
+						
+								if ( elementName == el_parameter )
+									mapCondition.parameters.push_back( conditionChild.getText() );
+								else if ( elementName == el_linklogic )
+								{
+									CStr logic = conditionChild.getText();
+									if ( logic == CStr("AND") )
+										mapCondition.linkLogic = 1;
+									else
+										mapCondition.linkLogic = 2;
+								}
+							}
+							mapTrigger.conditions.push_back(mapCondition);
+						}	//Read all conditions
+
+						else if ( elementName == el_logicblock)
+						{
+							if ( CStr(condition.getAttributes().getNamedItem(at_not)) == CStr("true") )	
+								mapTrigger.AddLogicBlock(true);
+							else
+								mapTrigger.AddLogicBlock(false);
+						}
+						else if ( elementName == el_logicblockend)
+							mapTrigger.AddLogicBlockEnd();
+
+					}	//Read all conditions
+				}	
+
+				else if ( elementName == el_effects )
+				{
+					//Read all effects
+					XERO_ITER_EL(triggerChild, effect)
+					{
+						if ( effect.getNodeName() != el_effect )
+						{
+							debug_warn("Invalid effect tag in trigger XML file");
+							return;
+						}
+						MapTriggerEffect mapEffect;
+						mapEffect.name = effect.getAttributes().getNamedItem(at_name);
+						mapEffect.functionName = effect.getAttributes().getNamedItem(at_function);
+						mapEffect.displayName = effect.getAttributes().getNamedItem(at_display);
+						
+						//Read parameters
+						XERO_ITER_EL(effect, effectChild)
+						{
+							if ( effectChild.getNodeName() != el_parameter )
+							{
+								debug_warn("Invalid parameter tag in trigger XML file");
+								return;
+							}
+							mapEffect.parameters.push_back( effectChild.getText() );
+						}
+						mapTrigger.effects.push_back(mapEffect);
+					}
+				}
+				else
+					debug_warn("Invalid trigger node child in trigger XML file");
+
+			}	//Read trigger children
+			g_TriggerManager.AddTrigger(mapGroup, mapTrigger);
+		}	
+		else
+			debug_warn("Invalid group node child in XML file");
+	}	//Read group children
+
+	g_TriggerManager.AddGroup(mapGroup);
+}
+
 int CXMLReader::ReadEntities(XMBElement parent, double end_time)
 {
 	XMBElementList entities = parent.getChildNodes();
 	while (entity_idx < entities.Count)
 	{
 		// all new state at this scope and below doesn't need to be
 		// wrapped, since we only yield after a complete iteration.
 
 		XMBElement entity = entities.item(entity_idx++);
 		debug_assert(entity.getNodeName() == el_entity);
 
 		CStrW TemplateName;
 		int PlayerID = 0;
 		CVector3D Position;
 		float Orientation = 0.f;
 
 		XERO_ITER_EL(entity, setting)
 		{
 			int element_name = setting.getNodeName();
 
 			// <template>
 			if (element_name == el_template)
 			{
 				TemplateName = setting.getText();
 			}
 			// <player>
 			else if (element_name == el_player)
 			{
 				PlayerID = CStr(setting.getText()).ToInt();
 			}
 			// <position>
 			else if (element_name == el_position)
 			{
 				XMBAttributeList attrs = setting.getAttributes();
 				Position = CVector3D(
 					CStr(attrs.getNamedItem(at_x)).ToFloat(),
 					CStr(attrs.getNamedItem(at_y)).ToFloat(),
 					CStr(attrs.getNamedItem(at_z)).ToFloat());
 			}
 			// <orientation>
 			else if (element_name == el_orientation)
 			{
 				XMBAttributeList attrs = setting.getAttributes();
 				Orientation = CStr(attrs.getNamedItem(at_angle)).ToFloat();
 			}
 			else
 				debug_warn("Invalid map XML data");
 		}
 
 		CEntityTemplate* base = g_EntityTemplateCollection.getTemplate( TemplateName, g_Game->GetPlayer(PlayerID) );
 		if (! base)
 			LOG(ERROR, LOG_CATEGORY, "Failed to load entity template '%ls'", TemplateName.c_str());
 		else
 		{
 			std::set<CStr8> selections; // TODO: read from file
 
 			HEntity ent = g_EntityManager.create(base, Position, Orientation, selections);
 
 			if (! ent)
 				LOG(ERROR, LOG_CATEGORY, "Failed to create entity of type '%ls'", TemplateName.c_str());
 			else
 			{
 				ent->m_actor->SetPlayerID(PlayerID);
 
 				// TODO: save object IDs in the map file, and load them again,
 				// so that triggers have a persistent identifier for objects
 				ent->m_actor->SetID(g_UnitMan.GetNewID());
 			}
 		}
 
 		completed_jobs++;
 		LDR_CHECK_TIMEOUT(completed_jobs, total_jobs);
 	}
 
 	return 0;
 }
 
 
 int CXMLReader::ReadNonEntities(XMBElement parent, double end_time)
 {
 	XMBElementList nonentities = parent.getChildNodes();
 	while (nonentity_idx < nonentities.Count)
 	{
 		// all new state at this scope and below doesn't need to be
 		// wrapped, since we only yield after a complete iteration.
 
 		XMBElement nonentity = nonentities.item(nonentity_idx++);
 		debug_assert(nonentity.getNodeName() == el_nonentity);
 
 		CStr ActorName;
 		CVector3D Position;
 		float Orientation = 0.f;
 
 		XERO_ITER_EL(nonentity, setting)
 		{
 			int element_name = setting.getNodeName();
 
 			// <actor>
 			if (element_name == el_actor)
 			{
 				ActorName = setting.getText();
 			}
 			// <position>
 			else if (element_name == el_position)
 			{
 				XMBAttributeList attrs = setting.getAttributes();
 				Position = CVector3D(CStr(attrs.getNamedItem(at_x)).ToFloat(),
 					CStr(attrs.getNamedItem(at_y)).ToFloat(),
 					CStr(attrs.getNamedItem(at_z)).ToFloat());
 			}
 			// <orientation>
 			else if (element_name == el_orientation)
 			{
 				XMBAttributeList attrs = setting.getAttributes();
 				Orientation = CStr(attrs.getNamedItem(at_angle)).ToFloat();
 			}
 			else
 				debug_warn("Invalid map XML data");
 		}
 
 		std::set<CStr8> selections; // TODO: read from file
 
 		CUnit* unit = g_UnitMan.CreateUnit(ActorName, NULL, selections);
 
 		if (unit)
 		{
 			// Copied from CEntity::updateActorTransforms():
 			float s = sin(Orientation);
 			float c = cos(Orientation);
 			CMatrix3D m;
 			m._11 = -c;     m._12 = 0.0f;   m._13 = -s;     m._14 = Position.X;
 			m._21 = 0.0f;   m._22 = 1.0f;   m._23 = 0.0f;   m._24 = Position.Y;
 			m._31 = s;      m._32 = 0.0f;   m._33 = -c;     m._34 = Position.Z;
 			m._41 = 0.0f;   m._42 = 0.0f;   m._43 = 0.0f;   m._44 = 1.0f;
 			unit->GetModel()->SetTransform(m);
 
 			// TODO: save object IDs in the map file, and load them again,
 			// so that triggers have a persistent identifier for objects
 			unit->SetID(g_UnitMan.GetNewID());
 		}
 
 		completed_jobs++;
 		LDR_CHECK_TIMEOUT(completed_jobs, total_jobs);
 	}
 
 	return 0;
 }
 
 
 int CXMLReader::ProgressiveRead()
 {
 	// yield after this time is reached. balances increased progress bar
 	// smoothness vs. slowing down loading.
 	const double end_time = get_time() + 200e-3;
 
 	int ret;
 
 	while (node_idx < nodes.Count)
 	{
 		XMBElement node = nodes.item(node_idx);
 		CStr name = xmb_file.getElementString(node.getNodeName());
 		if (name == "Environment")
 		{
 			ReadEnvironment(node);
 		}
 		else if (name == "Camera")
 		{
 			ReadCamera(node);
 		}
 		else if (name == "Entities")
 		{
 			ret = ReadEntities(node, end_time);
 			if (ret != 0)	// error or timed out
 				return ret;
 		}
 		else if (name == "Nonentities")
 		{
 			ret = ReadNonEntities(node, end_time);
 			if (ret != 0)	// error or timed out
 				return ret;
 		}
 		else if (name == "Tracks")
 		{
 			ReadCinema(node);
 		}
+		else if (name == "Triggers")
+		{
+			ReadTriggers(node);
+		}
 		else
 			debug_warn("Invalid map XML data");
 
 		node_idx++;
 	}
 
 	return 0;
 }
 
 
 // progressive
 int CMapReader::ReadXML()
 {
 	if (!xml_reader)
 		xml_reader = new CXMLReader(filename_xml, *this);
 
 	int ret = xml_reader->ProgressiveRead();
 	// finished or failed
 	if (ret <= 0)
 	{
 		delete xml_reader;
 		xml_reader = 0;
 	}
 
 	return ret;
 }
 
 
 int CMapReader::DelayLoadFinished()
 {
 	// we were dynamically allocated by CWorld::Initialize
 	delete this;
 
 	return 0;
 }
Index: ps/trunk/source/graphics/CinemaTrack.h
===================================================================
--- ps/trunk/source/graphics/CinemaTrack.h	(revision 4647)
+++ ps/trunk/source/graphics/CinemaTrack.h	(revision 4648)
@@ -1,163 +1,163 @@
 
 #ifndef H_CinemaTracks_H
 #define H_CinemaTracks_H
 
 #include <list>
 #include <map>
 #include "ps/CStr.h"
 #include "maths/NUSpline.h"
 
 /*
-	Andrew (aka pyrolink)
+	Andrew Decker (aka pyrolink)
 	Contact: ajdecker1022@msn.com
 	desc: contains various functions used for cinematic camera tracks
 	See also: CinemaHandler.cpp, Cinematic.h/.cpp
 */
 
 class CVector3D;
 class CVector4D;
 class CCamera;
 
 //For loading data
 class CCinemaData
 {
 public:
 	CCinemaData() : m_GrowthCount(0), m_Growth(0), m_Switch(0), 
 					m_Mode(0), m_Style(0) {}
 	virtual ~CCinemaData() {}
 	
 	const CCinemaData* GetData() const { return this; }
 	
 	CVector3D m_TotalRotation;
 	
 	//Distortion variables
 	mutable float m_GrowthCount;
 	float m_Growth;
 	float m_Switch;
 	int m_Mode;
 	int m_Style;
 
 };
 
 //Once the data is part of the path, it shouldn't be changeable
 class CCinemaPath : private CCinemaData, public TNSpline
 {
 	//friend class CCinemaTrack;
 public:
 	CCinemaPath(const CCinemaData& data, const TNSpline& spline);
 	~CCinemaPath() { DistStylePtr = NULL;  DistModePtr = NULL; }
 	
 	enum { EM_IN, EM_OUT, EM_INOUT, EM_OUTIN };
 	enum { ES_DEFAULT, ES_GROWTH, ES_EXPO, ES_CIRCLE, ES_SINE };
 	
 	//sets camera position to calculated point on spline
 	void MoveToPointAt(float t, const CVector3D &startRotation);
 	
 	//Distortion mode functions-change how ratio is passed to distortion style functions
 	float EaseIn(float t) const;
 	float EaseOut(float t) const;
 	float EaseInOut(float t) const;
 	float EaseOutIn(float t) const;
 
 	//Distortion style functions
 	float EaseDefault(float t) const;
 	float EaseGrowth(float t) const;
 	float EaseExpo(float t) const;
 	float EaseCircle(float t) const;
 	float EaseSine(float t) const;
 	
 	float (CCinemaPath::*DistStylePtr)(float ratio) const;
 	float (CCinemaPath::*DistModePtr)(float ratio) const;
 
 	const CCinemaData* GetData() const { return CCinemaData::GetData(); }
 
 public:
 
 	void DrawSpline(const CVector4D& RGBA, int smoothness, bool lines) const;
 
 	inline CVector3D GetNodePosition(const int index) const { return Node[index].Position; }
 	inline float GetNodeDuration(const int index) const { return Node[index].Distance; }
 	inline float GetDuration() const { return MaxDistance; }
 	inline float GetElapsedTime() const { return m_TimeElapsed; }
 	const std::vector<SplineData>& GetAllNodes() const { return Node; } 
 	
 	float m_TimeElapsed;
 };
 
 class CCinemaTrack
 {
 	friend class CCinemaManager;
 public: 
 	CCinemaTrack();
 	~CCinemaTrack() {}
 	
 	void AddPath(const CCinemaData& data, const TNSpline& spline);
 	void AddPath(const CCinemaPath& path);
 	inline void SetTimescale(float scale) { m_Timescale = scale; }
 	inline void SetStartRotation(CVector3D rotation) { m_StartRotation = rotation; }
 	void UpdateDuration();
 
 	//Returns false if finished
 	bool Play(float DeltaTime);
 	bool Validate();
 
 	inline const CVector3D& GetRotation() const { return m_StartRotation; }
 	inline float GetTimescale() const { return m_Timescale; }
 	inline float GetTotalDuration() const { return m_TotalDuration; }
 	inline const std::vector<CCinemaPath>& GetAllPaths() const { return m_Paths; }
 	
 	
 private:
 	std::vector<CCinemaPath> m_Paths;
 	std::vector<CCinemaPath>::iterator m_CPA;	//current path
 	CVector3D m_StartRotation;
 	float m_Timescale;	//a negative timescale results in backwards play
 	float m_AbsoluteTime;	//Current time of track, in absolute terms (not path)
 	float m_TotalDuration;
 
 	bool ValidateForward();
 	bool ValidateRewind();
 	CVector3D CalculateRotation();
 };
 
 //Class for in game playing of cinematics. Should only be instantiated
 //in CGameView. 
 class CCinemaManager
 {
 public:
 	CCinemaManager();
 	~CCinemaManager() {}
 
 	void AddTrack(CCinemaTrack track, const CStrW& name);
 
 	//Adds track to list of being played. 
 	void QueueTrack(const CStrW& name, bool queue);
 	void OverrideTrack(const CStrW& name);	//clears track queue and replaces with 'name'
 	bool Update(float DeltaTime);
 	
 	//These stop track play, and accept time, not ratio of time
 	void MoveToPointAt(float time);
 	void MoveToPointAbsolute(float time);	//Time in terms of track
 
 	inline void StopPlaying() { m_TrackQueue.clear(); }
 	void DrawAllSplines() const;
 	
 	inline bool IsPlaying() const { return !m_TrackQueue.empty(); }
 	bool HasTrack(const CStrW& name) const; 
 	inline bool IsActive() const { return m_Active; }
 	inline void SetActive(bool active) { m_Active=active; }
 
 	inline const std::map<CStrW, CCinemaTrack>& GetAllTracks() { return m_Tracks; }
 	void SetAllTracks( const std::map<CStrW, CCinemaTrack>& tracks);
 	void SetCurrentTrack(const CStrW& name, bool all, bool current, bool lines);
 	void SetCurrentPath(int path);
 
 private:
 	bool m_Active, m_DrawCurrentSpline, m_DrawAllSplines, m_DrawLines;
 	int m_CurrentPath;
 	CCinemaTrack* m_CurrentTrack;
 	std::map<CStrW, CCinemaTrack> m_Tracks;
 	std::list<CCinemaTrack> m_TrackQueue;
 };
 
 #endif
Index: ps/trunk/source/graphics/MapReader.h
===================================================================
--- ps/trunk/source/graphics/MapReader.h	(revision 4647)
+++ ps/trunk/source/graphics/MapReader.h	(revision 4648)
@@ -1,90 +1,93 @@
 #ifndef _MAPREADER_H
 #define _MAPREADER_H
 
 #include "MapIO.h"
 #include "lib/res/handle.h"
 #include "ps/CStr.h"
 #include "LightEnv.h"
 #include "CinemaTrack.h"
 #include "ps/FileUnpacker.h"
 
 class CObjectEntry;
 class CTerrain;
 class CUnitManager;
 class WaterManager;
 class SkyManager;
 class CLightEnv;
 class CCamera;
 class CCinemaManager;
+class CTriggerManager;
 
 class CXMLReader;
 
 class CMapReader : public CMapIO
 {
 	friend class CXMLReader;
 
 public:
 	// constructor
 	CMapReader();
 	// LoadMap: try to load the map from given file; reinitialise the scene to new data if successful
 	void LoadMap(const char* filename, CTerrain *pTerrain, CUnitManager *pUnitMan,
-		WaterManager* pWaterMan, SkyManager* pSkyMan, CLightEnv *pLightEnv, CCamera *pCamera, CCinemaManager* pCinema);
+		WaterManager* pWaterMan, SkyManager* pSkyMan, CLightEnv *pLightEnv, CCamera *pCamera, 
+																CCinemaManager* pCinema);
 
 private:
 	// UnpackTerrain: unpack the terrain from the input stream
 	int UnpackTerrain();
 	//UnpackCinema: unpack the cinematic tracks from the input stream
 	int UnpackCinema();
 	// UnpackObjects: unpack world objects from the input stream
 	void UnpackObjects();
 	// UnpackObjects: unpack lighting parameters from the input stream
 	void UnpackLightEnv();
 
 	// UnpackMap: unpack the given data from the raw data stream into local variables
 	int UnpackMap();
 
 	// ApplyData: take all the input data, and rebuild the scene from it
 	int ApplyData();
 
 	// ReadXML: read some other data (entities, etc) in XML format
 	int ReadXML();
 
 	// clean up everything used during delayed load
 	int DelayLoadFinished();
 
 	// size of map 
 	u32 m_MapSize;
 	// heightmap for map
 	std::vector<u16> m_Heightmap;
 	// list of terrain textures used by map
 	std::vector<Handle> m_TerrainTextures;
 	// tile descriptions for each tile
 	std::vector<STileDesc> m_Tiles;
 	// cinematic tracks used by cinema manager
 	std::map<CStrW, CCinemaTrack> m_Tracks;
 	// list of object types used by map
 	std::vector<CStr> m_ObjectTypes;
 	// descriptions for each objects
 	std::vector<SObjectDesc> m_Objects;
 	// lightenv stored in file
 	CLightEnv m_LightEnv;
 
 	// state latched by LoadMap and held until DelayedLoadFinished
 	CFileUnpacker unpacker;
 	CTerrain* pTerrain;
 	CUnitManager* pUnitMan;
 	WaterManager* pWaterMan;
 	SkyManager* pSkyMan;
 	CLightEnv* pLightEnv;
 	CCamera* pCamera;
 	CCinemaManager* pCinema;
+	CTriggerManager* pTrigMan;
 	CStr filename_xml;
 
 	// UnpackTerrain generator state
 	u32 cur_terrain_tex;
 	u32 num_terrain_tex;
 
 	CXMLReader* xml_reader;
 };
 
 #endif
Index: ps/trunk/source/graphics/MapWriter.cpp
===================================================================
--- ps/trunk/source/graphics/MapWriter.cpp	(revision 4647)
+++ ps/trunk/source/graphics/MapWriter.cpp	(revision 4648)
@@ -1,430 +1,559 @@
 #include "precompiled.h"
 
 #include "lib/types.h"
 #include "lib/res/file/vfs.h"
 
 #include "Camera.h"
 #include "CinemaTrack.h"
 #include "LightEnv.h"
 #include "MapReader.h"
 #include "MapWriter.h"
 #include "Model.h"
 #include "ObjectBase.h"
 #include "ObjectManager.h"
 #include "Patch.h"
 #include "Terrain.h"
 #include "TextureEntry.h"
 #include "TextureManager.h"
 #include "Unit.h"
 #include "UnitManager.h"
 
 #include "maths/MathUtil.h"
 #include "maths/NUSpline.h"
 #include "ps/Loader.h"
 #include "ps/Player.h"
 #include "ps/VFSUtil.h"
 #include "ps/XML/XMLWriter.h"
 #include "renderer/SkyManager.h"
 #include "renderer/WaterManager.h"
 #include "simulation/EntityTemplate.h"
 #include "simulation/EntityTemplateCollection.h"
+#include "simulation/TriggerManager.h"
 #include "simulation/Entity.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,
 						 CUnitManager* pUnitMan, WaterManager* pWaterMan, SkyManager* pSkyMan,
 						 CLightEnv* pLightEnv, CCamera* pCamera, CCinemaManager* pCinema)
 {
 	CFilePacker packer(FILE_VERSION, "PSMP");
 
 	// build necessary data
 	PackMap(packer, pTerrain);
 
 	// write it out
 	packer.Write(filename);
 
 	CStr filename_xml (filename);
 	filename_xml = filename_xml.Left(filename_xml.Length()-4) + ".xml";
 	WriteXML(filename_xml, pUnitMan, pWaterMan, pSkyMan, pLightEnv, pCamera, pCinema);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // 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)
 {
 	const uint limit = MIN((uint)handles.size(), 0xFFFE);	// paranoia
 	for (uint i=0;i<limit;i++) {
 		if (handles[i]==handle) {
 			return (u16)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<(u32)PATCH_SIZE;m++) {
 				for (u32 k=0;k<(u32)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->GetTag();
 		}
 		textures.push_back(texturename);
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PackMap: pack the current world into a raw data stream
 void CMapWriter::PackMap(CFilePacker& packer, CTerrain* pTerrain)
 {
 	// now pack everything up
 	PackTerrain(packer, pTerrain);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // 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, WaterManager* pWaterMan, SkyManager* pSkyMan,
 						  CLightEnv* pLightEnv, CCamera* pCamera, CCinemaManager* pCinema)
 {
 	Handle h = vfs_open(filename, FILE_WRITE_TO_TARGET|FILE_NO_AIO);
 	if (h <= 0)
 	{
 		debug_warn("Failed to open map XML file");
 		return;
 	}
 
 	XML_Start("utf-8");
 
 	{
 		XML_Element("Scenario");
 
 		{
 			XML_Element("Environment");
 
 			XML_Setting("SkySet", pSkyMan->GetSkySet());
 			{
 				XML_Element("SunColour");
 				XML_Attribute("r", pLightEnv->m_SunColor.X); // yes, it's X/Y/Z...
 				XML_Attribute("g", pLightEnv->m_SunColor.Y);
 				XML_Attribute("b", pLightEnv->m_SunColor.Z);
 			}
 			{
 				XML_Element("SunElevation");
 				XML_Attribute("angle", pLightEnv->m_Elevation);
 			}
 			{
 				XML_Element("SunRotation");
 				XML_Attribute("angle", pLightEnv->m_Rotation);
 			}
 			{
 				XML_Element("TerrainAmbientColour");
 				XML_Attribute("r", pLightEnv->m_TerrainAmbientColor.X);
 				XML_Attribute("g", pLightEnv->m_TerrainAmbientColor.Y);
 				XML_Attribute("b", pLightEnv->m_TerrainAmbientColor.Z);
 			}
 			{
 				XML_Element("UnitsAmbientColour");
 				XML_Attribute("r", pLightEnv->m_UnitsAmbientColor.X);
 				XML_Attribute("g", pLightEnv->m_UnitsAmbientColor.Y);
 				XML_Attribute("b", pLightEnv->m_UnitsAmbientColor.Z);
 			}
 
 			{
 				XML_Element("Water");
 				{
 					XML_Element("WaterBody");
 					XML_Setting("Type", "default");
 					{
 						XML_Element("Colour");
 						XML_Attribute("r", pWaterMan->m_WaterColor.r);
 						XML_Attribute("g", pWaterMan->m_WaterColor.g);
 						XML_Attribute("b", pWaterMan->m_WaterColor.b);
 					}
 					XML_Setting("Height", pWaterMan->m_WaterHeight);
 					XML_Setting("Shininess", pWaterMan->m_Shininess);
 					XML_Setting("Waviness", pWaterMan->m_Waviness);
 					XML_Setting("Murkiness", pWaterMan->m_Murkiness);
 					{
 						XML_Element("Tint");
 						XML_Attribute("r", pWaterMan->m_WaterTint.r);
 						XML_Attribute("g", pWaterMan->m_WaterTint.g);
 						XML_Attribute("b", pWaterMan->m_WaterTint.b);
 					}
 					{
 						XML_Element("ReflectionTint");
 						XML_Attribute("r", pWaterMan->m_ReflectionTint.r);
 						XML_Attribute("g", pWaterMan->m_ReflectionTint.g);
 						XML_Attribute("b", pWaterMan->m_ReflectionTint.b);
 					}
 					XML_Setting("ReflectionTintStrength", pWaterMan->m_ReflectionTintStrength);
 				}
 			}
 		}
 
 		{
 			XML_Element("Camera");
 
 			{
 				XML_Element("Position");
 				CVector3D pos = pCamera->m_Orientation.GetTranslation();
 				XML_Attribute("x", pos.X);
 				XML_Attribute("y", pos.Y);
 				XML_Attribute("z", pos.Z);
 			}
 
 			CVector3D in = pCamera->m_Orientation.GetIn();
 			// Convert to spherical coordinates
 			float rotation = atan2(in.X, in.Z);
 			float declination = atan2(sqrt(in.X*in.X + in.Z*in.Z), in.Y) - PI/2;
 
 			{
 				XML_Element("Rotation");
 				XML_Attribute("angle", rotation);
 			}
 			{
 				XML_Element("Declination");
 				XML_Attribute("angle", declination);
 			}
 		}
 
 		{
 			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()->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.Y;
 
 					XML_Element("Orientation");
 					XML_Attribute("angle", angle);
 				}
 			}
 		}
 		{
 			XML_Element("Nonentities");
 
 			const std::vector<CUnit*>& units = pUnitMan->GetUnits();
 			for (std::vector<CUnit*>::const_iterator unit = units.begin(); unit != units.end(); ++unit) {
 
 				// Ignore objects that are entities
 				if ((*unit)->GetEntity())
 					continue;
 
 				XML_Element("Nonentity");
 
 				XML_Setting("Actor", (*unit)->GetObject()->m_Base->m_Name);
 
 				{
 					CVector3D position = (*unit)->GetModel()->GetTransform().GetTranslation();
 
 					XML_Element("Position");
 					XML_Attribute("x", position.X);
 					XML_Attribute("y", position.Y);
 					XML_Attribute("z", position.Z);
 				}
 
 				{
 					CVector3D orient = (*unit)->GetModel()->GetTransform().GetIn();
 					float angle = atan2(-orient.X, -orient.Z);
 
 					XML_Element("Orientation");
 					XML_Attribute("angle", angle);
 				}
 			}
 		}
 		const std::map<CStrW, CCinemaTrack>& tracks = pCinema->GetAllTracks();
 		std::map<CStrW, CCinemaTrack>::const_iterator it = tracks.begin();
 		
 		{
 			XML_Element("Tracks");
 
 			for ( ; it != tracks.end(); it++ )
 			{
 				const std::vector<CCinemaPath>& paths = it->second.GetAllPaths();
 				CStrW name = it->first;
 				size_t numPaths = paths.size();
 				CVector3D startRotation = it->second.GetRotation();
 				float timescale = it->second.GetTimescale();
 	
 				{
 					XML_Element("Track");
 					XML_Attribute("name", name);
 					XML_Attribute("timescale", timescale);
 					
 					{
 						XML_Element("StartRotation");
 						XML_Attribute("x", startRotation.X);
 						XML_Attribute("y", startRotation.Y);
 						XML_Attribute("z", startRotation.Z);
 					}
 						
 					for ( size_t i=0; i<numPaths; ++i )
 					{
 						const std::vector<SplineData>& nodes = 
 									paths[i].GetAllNodes();
 						const CCinemaData* data = paths[i].GetData();
 						{
 							XML_Element("Path");
 					
 							{	
 									CVector3D rot = data->m_TotalRotation;
 									XML_Element("Rotation");
 									XML_Attribute("x", rot.X);
 									XML_Attribute("y", rot.Y);
 									XML_Attribute("z", rot.Z);
 							}
 						
 							{
 								XML_Element("Distortion");
 								XML_Attribute("mode", data->m_Mode);
 								XML_Attribute("style", data->m_Style);
 								XML_Attribute("growth", data->m_Growth);
 								XML_Attribute("switch", data->m_Switch);
 							}
 		
 							for ( int j=(int)nodes.size()-1; j >= 0; --j )
 							{
 								{
 									XML_Element("Node");
 									XML_Attribute("x", nodes[j].Position.X);
 									XML_Attribute("y", nodes[j].Position.Y);
 									XML_Attribute("z", nodes[j].Position.Z);
 									XML_Attribute("t", nodes[j].Distance);
 								}
 							}	 
 						}   //path data
 					} 
 				}	//track data
 			}
-		}	//(Did this really happen) - I blame XML 
+		}	//(Did this really happen) - I blame XML :p
+		
+		const std::list<MapTriggerGroup>& groups = g_TriggerManager.GetAllTriggerGroups();
+		std::list<MapTriggerGroup> rootChildren;
+		std::list<MapTriggerGroup>::const_iterator root = std::find( groups.begin(), groups.end(),
+																			CStrW(L"Triggers") );
+		std::for_each(rootChildren.begin(), rootChildren.end(), copyIfRootChild(rootChildren));
+		
+		{
+			XML_Element("Triggers");
+			for ( std::list<MapTriggerGroup>::const_iterator it = rootChildren.begin(); 
+															it != rootChildren.end(); ++it )
+			{
+				WriteTriggerGroup(xml_file_, *it, groups);
+			}
+			for ( std::list<MapTrigger>::const_iterator it = root->triggers.begin();
+														it != root->triggers.end(); ++it )
+			{
+				WriteTrigger(xml_file_, *it);
+			}
+		}
 	}
 
 	if (! XML_StoreVFS(h))
 	{
 		debug_warn("Failed to write map XML file");
 	}
 	(void)vfs_close(h);
 }
 
+void CMapWriter::WriteTriggerGroup(XMLWriter_File& xml_file_, const MapTriggerGroup& group, const std::list<MapTriggerGroup>& groupList)
+{
+	XML_Element("Group");
+	XML_Attribute("name", group.name);
+
+	for ( std::list<CStrW>::const_iterator it = group.childGroups.begin(); 
+									it != group.childGroups.end(); ++it )
+	{
+		//Not very efficient...
+		std::list<MapTriggerGroup>::const_iterator it2 = std::find(groupList.begin(), groupList.end(), *it);
+		if ( it2 != groupList.end() )
+			WriteTriggerGroup(xml_file_, *it2, groupList);
+		else
+			debug_warn("Invalid trigger group ID while writing map");
+	}
+
+	for ( std::list<MapTrigger>::const_iterator it = group.triggers.begin(); it != group.triggers.end(); ++it )
+	{
+		WriteTrigger(xml_file_, *it);
+	}	
+}
+
+void CMapWriter::WriteTrigger(XMLWriter_File& xml_file_, const MapTrigger& trigger)
+{
+	XML_Element("Trigger");
+	XML_Attribute("name", trigger.name);
+
+	{
+		if ( trigger.active )
+			XML_Setting("Active", "true");
+		else
+			XML_Setting("Active", "false");
+		XML_Setting("MaxRunCount", trigger.maxRunCount);
+		XML_Setting("Delay", trigger.timeValue);
+	}
+		
+	{
+		XML_Element("Conditions");
+		for ( std::list<MapTriggerCondition>::const_iterator it2 = trigger.conditions.begin();
+													it2 != trigger.conditions.end(); ++it2 )
+		{
+			size_t distance = std::distance( trigger.conditions.begin(), it2 );
+			std::set<MapTriggerLogicBlock>::const_iterator logicIter;
+			
+			if ( ( logicIter = trigger.logicBlocks.find(MapTriggerLogicBlock(distance)) ) 
+														!= trigger.logicBlocks.end() )
+			{
+				XML_Element("LogicBlock");
+				if ( logicIter->not )
+					XML_Attribute("not", "true");
+				else
+					XML_Attribute("not", "false");
+			}
+			
+			{
+				XML_Element("Condition");
+				XML_Attribute("name", it2->name);
+				XML_Attribute("function", it2->functionName);
+				XML_Attribute("display", it2->displayName);
+
+				if ( it2->not )
+					XML_Attribute("not", "true");
+				else
+					XML_Attribute("not", "false");
+			
+				for ( std::list<CStrW>::const_iterator paramIter = it2->parameters.begin(); 
+											paramIter != it2->parameters.end(); ++paramIter )
+				{
+					XML_Setting("Parameter", *paramIter);
+				}
+	
+				if ( it2->linkLogic == 1 )
+				{
+					XML_Setting("LinkLogic", "AND");
+				}
+				else if ( it2->linkLogic == 2 )
+				{
+					XML_Setting("LinkLogic", "OR");
+				}
+					
+				if ( trigger.logicBlockEnds.find(distance) != trigger.logicBlockEnds.end() )
+				{
+					XML_Element("LogicBlockEnd");
+				}
+			}
+		}	//Read all conditions		
+	}	//Conditions' scope
+		
+	{
+		XML_Element("Effects");
+		for ( std::list<MapTriggerEffect>::const_iterator it2 = trigger.effects.begin(); 
+												it2 != trigger.effects.end(); ++it2 )
+		{
+			XML_Element("Effect");
+			XML_Attribute("name", it2->name);
+			XML_Attribute("function", it2->functionName);	
+			XML_Attribute("display", it2->displayName);
+
+			for ( std::list<CStrW>::const_iterator paramIter = it2->parameters.begin();
+											paramIter != it2->parameters.end(); ++paramIter )
+			{
+				XML_Setting("parameter", *paramIter);
+			}
+		}
+	}	//Effects' scope	
+}
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // RewriteAllMaps
 void CMapWriter::RewriteAllMaps(CTerrain* pTerrain, CUnitManager* pUnitMan,
 								WaterManager* pWaterMan, SkyManager* pSkyMan,
 								CLightEnv* pLightEnv, CCamera* pCamera, CCinemaManager* pCinema)
 {
 	VFSUtil::FileList files;
 	VFSUtil::FindFiles("maps/scenarios", "*.pmp", files);
 
 	for (VFSUtil::FileList::iterator it = files.begin(); it != files.end(); ++it)
 	{
 		CMapReader* reader = new CMapReader;
 		LDR_BeginRegistering();
 		reader->LoadMap(*it, pTerrain, pUnitMan, pWaterMan, pSkyMan, pLightEnv, pCamera, pCinema);
 		LDR_EndRegistering();
 		LDR_NonprogressiveLoad();
 
 		CStr n (*it);
 		n.Replace("scenarios/", "scenarios/new/");
 		CMapWriter writer;
 		writer.SaveMap(n, pTerrain, pUnitMan, pWaterMan, pSkyMan, pLightEnv, pCamera, pCinema);
 	}
 }
+
+		
\ No newline at end of file
Index: ps/trunk/source/graphics/MapWriter.h
===================================================================
--- ps/trunk/source/graphics/MapWriter.h	(revision 4647)
+++ ps/trunk/source/graphics/MapWriter.h	(revision 4648)
@@ -1,44 +1,59 @@
 #ifndef _MAPWRITER_H
 #define _MAPWRITER_H
 
 #include <vector>
 #include "MapIO.h"
 #include "ps/CStr.h"
 #include "ps/FilePacker.h"
 
+
 class CLightEnv;
 class CTerrain;
 class CUnitManager;
 class CCamera;
 class CCinemaManager;
+class CTriggerManager;
 class WaterManager;
 class SkyManager;
+struct MapTrigger;
+struct MapTriggerGroup;
+class XMLWriter_File;
 
 class CMapWriter : public CMapIO
 {
 public:
 	// constructor
 	CMapWriter();
 	// SaveMap: try to save the current map to the given file
-	void SaveMap(const char* filename, CTerrain* pTerr, CUnitManager* pUnitMan, WaterManager* pWaterMan, SkyManager* pSkyMan, CLightEnv* pLightEnv, CCamera* pCamera, CCinemaManager* pCinema);
+	void SaveMap(const char* filename, CTerrain* pTerr, CUnitManager* pUnitMan, 
+									WaterManager* pWaterMan, SkyManager* pSkyMan, 
+									CLightEnv* pLightEnv, CCamera* pCamera, 
+									CCinemaManager* pCinema);
 
 	// RewriteAllMaps: for use during development: load/save all maps, to
 	// update them to the newest format.
-	static void RewriteAllMaps(CTerrain* pTerrain, CUnitManager* pUnitMan, WaterManager* pWaterMan, SkyManager* pSkyMan, CLightEnv* pLightEnv, CCamera* pCamera, CCinemaManager* pCinema);
+	static void RewriteAllMaps(CTerrain* pTerrain, CUnitManager* pUnitMan, WaterManager* pWaterMan, 
+								SkyManager* pSkyMan, CLightEnv* pLightEnv, CCamera* pCamera, 
+								CCinemaManager* pCinema);
 
 private:
 	// PackMap: pack the current world into a raw data stream
 	void PackMap(CFilePacker& packer, CTerrain* pTerrain);
 	// PackTerrain: pack the terrain onto the end of the data stream
 	void PackTerrain(CFilePacker& packer, CTerrain* pTerrain);
 
 	// EnumTerrainTextures: build lists of textures used by map, and indices into this list 
 	// for each tile on the terrain
 	void EnumTerrainTextures(CTerrain* pTerrain, std::vector<CStr>& textures,
 		std::vector<STileDesc>& tileIndices);
 
 	// WriteXML: output some other data (entities, etc) in XML format
-	void WriteXML(const char* filename, CUnitManager* pUnitMan, WaterManager* pWaterMan, SkyManager* pSkyMan, CLightEnv* pLightEnv, CCamera* pCamera, CCinemaManager* pCinema);
+	void WriteXML(const char* filename, CUnitManager* pUnitMan, WaterManager* pWaterMan, 
+								SkyManager* pSkyMan, CLightEnv* pLightEnv, CCamera* pCamera, 
+								CCinemaManager* pCinema);
+	void WriteTriggerGroup(XMLWriter_File& xml_file_, const MapTriggerGroup& group, 
+											const std::list<MapTriggerGroup>& groupList);
+	void WriteTrigger(XMLWriter_File& xml_file_, const MapTrigger& trigger);
 };
 
 #endif
Index: ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.xml
===================================================================
--- ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.xml	(nonexistent)
+++ ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.xml	(revision 4648)
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+
+<Scenario>
+	<Environment>
+		<SkySet>default</SkySet>
+		<SunColour r="1" g="1" b="1"/>
+		<SunElevation angle="0.785398"/>
+		<SunRotation angle="5.49779"/>
+		<TerrainAmbientColour r="0.643137" g="0.643137" b="0.643137"/>
+		<UnitsAmbientColour r="0.643137" g="0.643137" b="0.643137"/>
+		<Water>
+			<WaterBody>
+				<Type>default</Type>
+				<Colour r="0.3" g="0.35" b="0.7"/>
+				<Height>5</Height>
+				<Shininess>150</Shininess>
+				<Waviness>8</Waviness>
+				<Murkiness>0.45</Murkiness>
+				<Tint r="0.28" g="0.3" b="0.59"/>
+				<ReflectionTint r="0.28" g="0.3" b="0.59"/>
+				<ReflectionTintStrength>0</ReflectionTintStrength>
+			</WaterBody>
+		</Water>
+	</Environment>
+	<Camera>
+		<Position x="100" y="150" z="-100"/>
+		<Rotation angle="0"/>
+		<Declination angle="0.523599"/>
+	</Camera>
+	<Entities/>
+	<Nonentities/>
+	<Tracks/>
+	<Triggers>
+		<Trigger name="Trigger 0">
+			<Active>true</Active>
+			<MaxRunCount>0</MaxRunCount>
+			<Delay>0</Delay>
+			<Conditions>
+				<Condition name="Condition 0" function="getAlwaysTrue" display="Always" not="false">
+					<LinkLogic>AND</LinkLogic>
+				</Condition>
+			</Conditions>
+			<Effects>
+				<Effect name="Effect 0" function="console.write" display="Text">
+					<parameter>"Disturbers of the human race, your bells are always ringing.  I wish the rope were 'round your neck and you upon it swinging."</parameter>
+				</Effect>
+			</Effects>
+		</Trigger>
+	</Triggers>
+</Scenario>
\ No newline at end of file
Index: ps/trunk/binaries/data/mods/official/scripts/TriggerSpecs.xml
===================================================================
--- ps/trunk/binaries/data/mods/official/scripts/TriggerSpecs.xml	(nonexistent)
+++ ps/trunk/binaries/data/mods/official/scripts/TriggerSpecs.xml	(revision 4648)
@@ -0,0 +1,35 @@
+<Definitions>
+
+	<Condition name ="DisplayName" function = "something">
+		<WindowRow>
+			<Parameter name = "Random">
+				<Window type="text" position = "0,0" size = "80,20"/>
+				<InputType>int</InputType>
+				<ParameterOrder>0</ParameterOrder>
+			</Parameter>
+			<Parameter name ="something">
+				<Window type="choice" position ="0,0" size="80, 20"/>
+				<Choices>ATLAS_CINEMA_LIST</Choices>
+				<ParameterOrder>0</ParameterOrder>
+			</Parameter>
+			<Parameter name ="awesome">
+				<Window type="choice" position ="0,0" size="80, 20"/>
+				<Choices>holy, crap, comma, seperated, choices</Choices>
+				<ParameterOrder>0</ParameterOrder>
+			</Parameter>
+		</WindowRow>
+	</Condition>
+	
+	<Condition name = "Always" function = "getAlwaysTrue"/>
+	
+	<Effect name ="Text" function = "console.write">
+		<WindowRow>
+			<Parameter name = "Text to display">
+				<Window type="text" position = "0,0" size = "80,20"/>
+				<InputType>string</InputType>
+				<ParameterOrder>0</ParameterOrder>
+			</Parameter>
+		</WindowRow>
+	</Effect>
+
+</Definitions>
\ No newline at end of file
Index: ps/trunk/source/tools/atlas/DatafileIO/Util.h
===================================================================
--- ps/trunk/source/tools/atlas/DatafileIO/Util.h	(revision 4647)
+++ ps/trunk/source/tools/atlas/DatafileIO/Util.h	(revision 4648)
@@ -1,45 +1,46 @@
 #include <string>
 #include <cassert>
+
 #if OS_UNIX
 #include "ps/utf16string.h"
 #include <sys/types.h>
 #endif
 
 #ifndef C_ASSERT
 #define C_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1]
 #endif
 
 namespace DatafileIO
 {
-#if OS_WIN
+#ifdef _WIN32
 	// TODO: proper portability
 	typedef int int32_t;
 	typedef unsigned int uint32_t;
 	typedef unsigned short uint16_t;
 	typedef std::wstring utf16string;
 	typedef wchar_t utf16_t;
 #else
 	typedef uint16_t utf16_t;
 	typedef std::basic_string<utf16_t> utf16string;
 #endif
 
 	C_ASSERT(sizeof(int32_t) == 4);
 	C_ASSERT(sizeof(uint32_t) == 4);
 	C_ASSERT(sizeof(uint16_t) == 2);
 	C_ASSERT(sizeof(utf16_t) == 2);
 
 	class InputStream;
 	class OutputStream;
 
 	// Read/write 4-byte length + UCS-2 string
 	utf16string ReadUString(InputStream& stream);
 	void WriteUString(OutputStream& stream, const utf16string& string);
 
 #if OS_WIN
 # define utf16tow(_str) _str
 # define wtoutf16(_str) _str
 #else
 	std::wstring utf16tow(const utf16string &str);
 	utf16string wtoutf16(const std::wstring &str);
 #endif
 }
Index: ps/trunk/source/tools/atlas/AtlasUI/ArchiveViewer/ArchiveViewer.cpp
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ArchiveViewer/ArchiveViewer.cpp	(revision 4647)
+++ ps/trunk/source/tools/atlas/AtlasUI/ArchiveViewer/ArchiveViewer.cpp	(revision 4648)
@@ -1,635 +1,635 @@
 #include "stdafx.h"
 
 #include "ArchiveViewer.h"
 
 #include "Misc/Version.h"
 
 #include <set>
 #include <algorithm>
 
 #include "DatafileIO/BAR/BAR.h"
 #include "DatafileIO/Stream/Stream.h"
 #include "DatafileIO/Stream/wx.h"
 using namespace DatafileIO;
 
 #include "wx/dnd.h"
 #include "wx/confbase.h"
 #include "wx/wfstream.h"
 #include "wx/tooltip.h"
 #ifdef _WIN32
 #include "wx/msw/registry.h"
 #endif
 #include "wx/progdlg.h"
 #include "wx/regex.h"
 
 // Possible TODO: Remove duplication of AtlasWindow code
 
 enum {
 	ID_ExtractSelected,
 	ID_ExtractAll,
 	ID_EnablePreview,
 	ID_About
 };
 
 BEGIN_EVENT_TABLE(ArchiveViewer, wxFrame)
 	EVT_MENU(wxID_OPEN, ArchiveViewer::OnOpen)
 	EVT_MENU_RANGE(wxID_FILE1, wxID_FILE9, ArchiveViewer::OnMRUFile)
 	EVT_MENU(wxID_EXIT, ArchiveViewer::OnQuit)
 	EVT_MENU(ID_ExtractSelected, ArchiveViewer::OnExtractSelected)
 	EVT_MENU(ID_ExtractAll, ArchiveViewer::OnExtractAll)
 	EVT_MENU(ID_EnablePreview, ArchiveViewer::OnEnablePreview)
 	EVT_MENU(ID_About, ArchiveViewer::OnAbout)
 	EVT_CLOSE(ArchiveViewer::OnClose)
 END_EVENT_TABLE()
 
 //////////////////////////////////////////////////////////////////////////
 
 
 class FilterTextCtrl : public wxTextCtrl
 {
 public:
 	FilterTextCtrl(wxWindow* parent, ArchiveViewer* archViewWin, const wxSize& size)
 		: wxTextCtrl(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, size),
 		m_archViewWin(archViewWin) {}
 private:
 	void OnChange(wxCommandEvent& WXUNUSED(event))
 	{
 		m_archViewWin->SetFilter(GetValue());
 	}
 	ArchiveViewer* m_archViewWin;
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(FilterTextCtrl, wxTextCtrl)
 	EVT_TEXT(wxID_ANY, FilterTextCtrl::OnChange)
 END_EVENT_TABLE()
 
 class FileListCtrl : public wxListCtrl
 {
 public:
 	FileListCtrl(wxWindow* parent, ArchiveViewer* archViewWin)
 		: wxListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT),
 		m_archViewWin(archViewWin) {}
 	void OnSelect(wxListEvent& event)
 	{
 		m_archViewWin->UpdatePreview(event.GetIndex());
 	}
 private:
 	ArchiveViewer* m_archViewWin;
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(FileListCtrl, wxListCtrl)
 	EVT_LIST_ITEM_SELECTED(wxID_ANY, FileListCtrl::OnSelect)
 END_EVENT_TABLE()
 
 //////////////////////////////////////////////////////////////////////////
 
 // Allow drag-and-drop of files onto the window, as a convenient way of opening them
 //class DropTarget : public wxFileDropTarget
 //{
 //public:
 //	DropTarget(ColourTesterImageCtrl* imgctrl)
 //		: m_ImageCtrl(imgctrl)
 //	{}
 //
 //	bool OnDropFiles(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), const wxArrayString& filenames)
 //	{
 //		if (filenames.GetCount() >= 1)
 //			m_ImageCtrl->SetImageFile(filenames[0]);
 //		return true;
 //	}
 //private:
 //	ColourTesterImageCtrl* m_ImageCtrl;
 //};
 
 
 ArchiveViewer::ArchiveViewer(wxWindow* parent)
 : wxFrame(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(600, 371))
 , m_FileHistory(_T("Archive Viewer"))
 , m_WindowTitle(wxString::Format(_("%s - Archive Viewer"), g_ProgramNameVersion.c_str()))
 , m_BARStream(NULL), m_BARReader(NULL), m_PreviewEnabled(false)
 {
 	SetIcon(wxIcon(_T("ICON_ArchiveViewer")));
 
 	wxToolTip::Enable(true);
 
 	wxMenuBar* menuBar = new wxMenuBar;
 	SetMenuBar(menuBar);
 
 	wxMenu *menuFile = new wxMenu;
 	menuBar->Append(menuFile, _("&File"));
 	{
 		menuFile->Append(wxID_OPEN, _("&Open..."));
 		menuFile->AppendSeparator();//-----------
 		menuFile->Append(wxID_EXIT,   _("E&xit"));
 		m_FileHistory.UseMenu(menuFile);//-------
 		m_FileHistory.AddFilesToMenu();
 	}
 
 	wxMenu *menuView = new wxMenu;
 	menuBar->Append(menuView, _("&View"));
 	{
 		menuView->AppendCheckItem(ID_EnablePreview, _("&Preview"));
 	}
 
 	wxMenu *menuExtract = new wxMenu;
 	menuBar->Append(menuExtract, _("&Extract"));
 	{
 		menuExtract->Append(ID_ExtractAll, _("&All files..."));
 		menuExtract->Append(ID_ExtractSelected, _("&Selected..."));
 	}
 
 	wxMenu *menuHelp = new wxMenu;
 	menuBar->Append(menuHelp, _("&Help"));
 	{
 		menuHelp->Append(ID_About, _("&About"));
 	}
 
 
 	m_FileHistory.Load(*wxConfigBase::Get());
 
 
 
 	m_Splitter = new SnapSplitterWindow(this, wxSP_NOBORDER | wxSP_3DSASH);
 
 	wxPanel* leftPanel = new wxPanel(m_Splitter);
 
 	//////////////////////////////////////////////////////////////////////////
 	// Set up sizers:
 
 	wxBoxSizer* vertSizer = new wxBoxSizer(wxVERTICAL);
 	leftPanel->SetSizer(vertSizer);
 
 	wxBoxSizer* filterSizer = new wxBoxSizer(wxHORIZONTAL);
 
 	//////////////////////////////////////////////////////////////////////////
 	// Add things to sizers:
 
 	m_FileListCtrl = new FileListCtrl(leftPanel, this);
 	m_FileListCtrl->InsertColumn(0, _("Filename"), wxLIST_FORMAT_LEFT, 300);
 	m_FileListCtrl->InsertColumn(1, _("File size (bytes)"), wxLIST_FORMAT_RIGHT, 100);
 	m_FileListCtrl->InsertColumn(2, _("Last modified date"), wxLIST_FORMAT_LEFT, 150);
 	vertSizer->Add(m_FileListCtrl, wxSizerFlags().Expand().Proportion(1).Border(wxALL, 5));
 
 	vertSizer->Add(filterSizer,
 		wxSizerFlags().Expand().Border(wxLEFT|wxRIGHT|wxBOTTOM, 5));
 
 
 	m_PreviewWindow = new FilePreviewer(m_Splitter);
 	m_PreviewWindow->Hide();
 
 	m_Splitter->Initialize(leftPanel);
 
 	filterSizer->Add(new wxStaticText(leftPanel, wxID_ANY, _("&Search for file:")),
 		wxSizerFlags().Centre().Border(wxALL, 5));
 
 	FilterTextCtrl* filterTextCtrl = new FilterTextCtrl(leftPanel, this, wxSize(150, -1));
 	filterTextCtrl->SetToolTip(_("You may use * to match any sequence characters, and ? to match a single character"));
 	filterSizer->Add(filterTextCtrl, wxSizerFlags().Border(wxALL, 5));
 
 	//////////////////////////////////////////////////////////////////////////
 
 	SetCurrentFilename();
 }
 
 void ArchiveViewer::OnAbout(wxCommandEvent& WXUNUSED(event))
 {
 	wxMessageBox(wxString::Format(_("%s - created by Philip Taylor (philip@wildfiregames.com / philip@zaynar.demon.co.uk)"), g_ProgramNameVersion.c_str()),
 		_("About"), wxOK|wxCENTRE|wxICON_INFORMATION);
 }
 
 ArchiveViewer::~ArchiveViewer()
 {
 	delete m_BARStream;
 	delete m_BARReader;
 }
 
 void ArchiveViewer::OnClose(wxCloseEvent& event)
 {
 	event.Skip();
 	m_FileHistory.Save(*wxConfigBase::Get());
 }
 
 //struct compare_bar {
 //	bool operator()(const BAREntry& x, const BAREntry& y) { return (x.filename < y.filename); }
 //};
 
 void ArchiveViewer::RedrawFileList(bool keepSelection)
 {
 	if (!m_BARReader || !m_BARStream)
 		// No BAR file loaded
 		return;
 
 	std::vector<bool> filesSelected;
 	filesSelected.resize(m_CachedFileData.size(), false);
 
 	// If desired, remember a list of selected and focussed items
 	int focussed = -1;
 	if (keepSelection)
 	{
 		// Iterate through selected items
 		long item = m_FileListCtrl->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
 		while (item != -1)
 		{
 			filesSelected[ m_FileListCtrl->GetItemData(item) ] = true;
 			item = m_FileListCtrl->GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
 		}
 
 		// Remember single focussed item
 		item = m_FileListCtrl->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_FOCUSED);
 		if (item != -1)
 			focussed = m_FileListCtrl->GetItemData(item);
 	}
 
 	wxString filter;
 	enum { NONE, SUBSTRING, WILDCARD } filterType = NONE; // attempt to use most efficient matching system
 	if (m_Filter.Len())
 	{
 		if (m_Filter.Contains(_T("*")) || m_Filter.Contains(_T("?")))
 		{
 			filterType = WILDCARD;
 			filter = _T("*") + m_Filter.Lower() + _T("*"); // match any substring, and case insensitive
 		}
 		else
 		{
 			filterType = SUBSTRING;
 			filter = m_Filter.Lower();
 		}
 	}
 
 	m_FileListCtrl->Freeze();
 	m_FileListCtrl->DeleteAllItems();
 
 	for (size_t i = 0; i < m_CachedFileData.size(); ++i)
 	{
 		if (   (filterType == SUBSTRING && !m_CachedFileData[i].NameLower.Contains(filter))
 			|| (filterType == WILDCARD && !m_CachedFileData[i].NameLower.Matches(filter)))
 			continue;
 
 		wxListItem info;
 		info.SetText(m_CachedFileData[i].Name);
 		info.SetData((long)i);
 		info.SetId((long)i);
 		if (keepSelection)
 		{
 			int state = (filesSelected[i] ? wxLIST_STATE_SELECTED : 0) | (focussed == (int)i ? wxLIST_STATE_FOCUSED : 0);
 			if (state)
 			{
 				info.SetState(state);
 				info.SetStateMask(wxLIST_STATE_SELECTED|wxLIST_STATE_FOCUSED);
 			}
 		}
 		long idx = m_FileListCtrl->InsertItem(info);
 		wxASSERT(idx != -1);
 		m_FileListCtrl->SetItem(idx, 1, m_CachedFileData[i].Size);
 		m_FileListCtrl->SetItem(idx, 2, m_CachedFileData[i].Date);
 	}
 
 	m_FileListCtrl->Thaw();
 }
 
 
 void ArchiveViewer::UpdateFileList()
 {
 	if (!m_BARReader || !m_BARStream)
 		// No BAR file loaded
 		return;
 
 	wxRegEx commas (_T("(\\d+)(\\d{3})"), wxRE_ADVANCED); // for comma-ising filesizes
 
 	// Get list of all files
 	//	std::vector<BAREntry> files = m_BARReader->GetFileList(); // non-constref copy, so we can sort it
 	//	std::sort(files.begin(), files.end(), compare_bar());
 	const std::vector<BAREntry>& files = m_BARReader->GetFileList();
 
 	m_CachedFileData.clear();
 	m_CachedFileData.resize(files.size());
 
 	for (size_t i = 0; i < files.size(); ++i)
 	{
-		m_CachedFileData[i].Name = utf16tow(files[i].filename);
+		m_CachedFileData[i].Name = wxString( utf16tow(files[i].filename).c_str() );
 		m_CachedFileData[i].NameLower = m_CachedFileData[i].Name.Lower();
 
 		m_CachedFileData[i].Size = wxString::Format(_T("%d"), files[i].filesize);
 		while (commas.Replace(&m_CachedFileData[i].Size, _T("\\1,\\2"))) ;
 
 		if (files[i].modified.year == 0)
 			m_CachedFileData[i].Date = _("Unknown");
 		else
 		{
 			wxDateTime date (files[i].modified.day, (wxDateTime::Month)(wxDateTime::Jan + files[i].modified.month-1), files[i].modified.year,
 				files[i].modified.hour, files[i].modified.minute, files[i].modified.second, files[i].modified.msecond);
 			m_CachedFileData[i].Date = wxString::Format(
 				_T("%s %s.%03d"),
 				date.FormatISODate().c_str(),
 				date.FormatISOTime().c_str(),
 				date.GetMillisecond());
 		}
 	}
 }
 
 void ArchiveViewer::OpenFile(const wxString& filename)
 {
 	wxFFileInputStream* fileStream = new wxFFileInputStream(filename);
 	if (! fileStream->Ok())
 	{
 		wxLogError(_("Failed to open file"));
 		delete fileStream;
 		return;
 	}
 
 	SeekableInputStream* stream = new SeekableInputStreamFromWx(fileStream);
 	BARReader* reader = new BARReader(*stream);
 	if (! reader->Initialise())
 	{
 		wxLogError(_("Failed to read BAR file"));
 		delete reader;
 		delete stream;
 		return;
 	}
 
 	// Delete old data, replace with new data
 	delete m_BARStream;
 	delete m_BARReader;
 	m_BARStream = stream;
 	m_BARReader = reader;
 
 	UpdateFileList();
 	RedrawFileList(false);
 
 	m_FileHistory.AddFileToHistory(filename);
 	SetCurrentFilename(filename);
 }
 
 
 
 
 
 void ArchiveViewer::OnExtractSelected(wxCommandEvent& WXUNUSED(event))
 {
 	ExtractFiles(true);
 }
 
 void ArchiveViewer::OnExtractAll(wxCommandEvent& WXUNUSED(event))
 {
 	ExtractFiles(false);
 }
 
 void ArchiveViewer::ExtractFiles(bool onlySelected)
 {
 	long item = -1;
 	
 	if (onlySelected)
 	{
 		// Find the first selected item, and make sure there is actually a selection
 		item = m_FileListCtrl->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
 
 		if (item == -1)
 		{
 			wxMessageBox(_("Please select one or more files to extract."), _("No files selected"), wxICON_INFORMATION);
 			return;
 		}
 	}
 
 	// Work out where to extract the files to:
 
 	// Assume same as last place, else default (from registry), else cwd
 	wxString dir = m_LastExtractDir;
 	if (! dir.Len())
 	{
 		dir = GetDefaultOpenDirectory();
 		if (! dir.Len())
 			dir = wxFileName::GetCwd();
 	}
 
 	// Let user choose final location
 	wxDirDialog dlg(this, wxDirSelectorPromptStr, dir);
 	if (dlg.ShowModal() != wxID_OK)
 		return;
 
 	// Remember the selection
 	dir = dlg.GetPath();
 	dir += wxFileName::GetPathSeparator();
 	m_LastExtractDir = dir;
 	wxFileName rootDir (dir);
 
 
 	// Construct a list of items to extract:
 	const std::vector<BAREntry>& files = m_BARReader->GetFileList();
 	std::vector<int> selection;
 	if (onlySelected)
 	{
 		while (item != -1)
 		{
 			selection.push_back(m_FileListCtrl->GetItemData(item)); // item was set at top of function
 			item = m_FileListCtrl->GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
 		}
 	}
 	else
 	{
 		// Extract all files
 		for (int i = 0; i < (int)files.size(); ++i)
 			selection.push_back(i);
 	}
 
 	bool aborted = false;
 
 	{
 		// Create the required directory structure:
 
 		// Extract the list of all directories:
 		std::set<std::wstring> dirs;
 		for (size_t sel = 0; sel < selection.size(); ++sel)
 		{
 			const BAREntry& file = files[selection[sel]];
-			wxString filename = utf16tow(file.filename);
+			wxString filename = wxString( utf16tow(file.filename).c_str() );
 			int lastSlash = filename.Find(_T('\\'), true);
 			if (lastSlash != -1)
 				dirs.insert(filename.Mid(0, lastSlash+1).c_str());
 		}
 
 		// Construct the directory tree:
 		for (std::set<std::wstring>::iterator it = dirs.begin(); it != dirs.end(); ++it)
 		{
 			// Append name-in-archive to target root directory, one dir
 			// at a time, calling mkdir at each step if necessary
 			wxFileName fullFilePath (rootDir);
 			wxFileName filePath (it->c_str(), wxPATH_WIN);
 			const wxArrayString& filePathDirs = filePath.GetDirs();
 			for (size_t i = 0; i < filePathDirs.Count(); ++i)
 			{
 				fullFilePath.AppendDir(filePathDirs[i]);
 				if (! wxDirExists(fullFilePath.GetPath()))
 					wxMkdir(fullFilePath.GetPath());
 			}
 		}
 
 		// Create progress display
 		wxProgressDialog progress (_("Extracting files"), _("Please wait"), (int)selection.size(), this,
 			wxPD_APP_MODAL | wxPD_CAN_ABORT | wxPD_ELAPSED_TIME | wxPD_REMAINING_TIME | wxPD_SMOOTH);
 
 		// Repeat for each selection file
 		for (size_t sel = 0; sel < selection.size(); ++sel)
 		{
 			const BAREntry& file = files[selection[sel]];
 
 			if (! progress.Update((int)sel, wxString::Format(_("Extracting %s"), file.filename.c_str())))
 			{
 				aborted = true;
 				break;
 			}
 
 			// Append name-in-archive to target root directory, one dir
 			// at a time, calling mkdir at each step if necessary
-			wxFileName filePath (utf16tow(file.filename), wxPATH_WIN);
+			wxFileName filePath (wxString( utf16tow(file.filename).c_str() ), wxPATH_WIN);
 			filePath.MakeAbsolute(rootDir.GetPath());
 
 			// Output to disk
 			wxFFileOutputStream outStream(filePath.GetFullPath());
 			if (! outStream.Ok())
 				wxLogError(wxString::Format(_("Error opening output file %s"), filePath.GetFullPath().c_str()));
 			else
 			{
 				SeekableOutputStreamFromWx str (outStream);
 				m_BARReader->TransferFile(file, str);
 				outStream.Close();
 
 				// Set the file's timestamps to match the one specified in the archive
 				if (file.modified.year != 0)
 				{
 					wxDateTime date (file.modified.day, (wxDateTime::Month)(wxDateTime::Jan + file.modified.month-1), file.modified.year,
 						file.modified.hour, file.modified.minute, file.modified.second, file.modified.msecond);
 					filePath.SetTimes(NULL, &date, &date);
 				}
 			}
 		}
 	}
 
 	if (aborted)
 		wxMessageBox(_("Extraction aborted."), _("Stopped"));
 	else
 		wxMessageBox(_("Extraction complete."), _("Finished"));
 }
 
 
 void ArchiveViewer::OnEnablePreview(wxCommandEvent& event)
 {
 	m_PreviewEnabled = event.IsChecked();
 	
 	if (m_PreviewEnabled)
 	{
 		// Make sure the window's not far too small
 		if (GetSize().GetWidth() < 700)
 			SetSize(-1, -1, 900, -1); // nobody is still using 800x600, are they?
 
 		m_Splitter->SetDefaultSashPosition(600);
 		m_Splitter->SplitVertically(m_Splitter->GetWindow1(), m_PreviewWindow);
 	}
 	else
 		m_Splitter->Unsplit();
 
 	UpdatePreview();
 }
 
 void ArchiveViewer::UpdatePreview(long item)
 {
 	if (! m_PreviewEnabled)
 		return;
 
 	// If the user opens a large archive file, enables the preview, selects the
 	// bottom file, and presses shift+home, it attempts to redraw the preview
 	// for every single file in sequence. That takes forever; so provide a way
 	// to abort the preview update.
 	if (wxGetKeyState(WXK_ESCAPE))
 		return;
 
 	// If none is specified, preview the first selected item
 	if (item == -1)
 		item = m_FileListCtrl->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
 
 	if (item == -1) // none selected
 		return;
 
 	const BAREntry& file = m_BARReader->GetFileList()[ m_FileListCtrl->GetItemData(item) ];
 	SeekableInputStream* str = m_BARReader->GetFile(file);
-	m_PreviewWindow->PreviewFile(utf16tow(file.filename), *str);
+	m_PreviewWindow->PreviewFile(wxString(utf16tow(file.filename).c_str()), *str);
 	delete str;
 }
 
 
 
 void ArchiveViewer::OnOpen(wxCommandEvent& WXUNUSED(event))
 {
 	wxString path, name;
 	if (GetCurrentFilename().IsOk())
 	{
 		path = GetCurrentFilename().GetPath();
 		name = GetCurrentFilename().GetFullName();
 	}
 	else
 	{
 		path = GetDefaultOpenDirectory();
 	}
 
 	wxFileDialog dlg (this, _("Select archive file to open"), path, name, _("BAR files (*.bar)|*.bar|All files (*.*)|*.*"), wxOPEN);
 
 	if (dlg.ShowModal() != wxID_OK)
 		return;
 
 	OpenFile(dlg.GetPath());
 }
 
 void ArchiveViewer::OnMRUFile(wxCommandEvent& event)
 {
 	wxString file (m_FileHistory.GetHistoryFile(event.GetId() - wxID_FILE1));
 	if (file.Len())
 		OpenFile(file);
 }
 
 void ArchiveViewer::OnQuit(wxCommandEvent& WXUNUSED(event))
 {
 	Close();
 }
 
 void ArchiveViewer::SetCurrentFilename(wxFileName filename)
 {
 	m_CurrentFilename = filename;
 
 	if (filename.IsOk())
 		SetTitle(m_WindowTitle + _T(" - ") + filename.GetFullName());
 	else
 		SetTitle(m_WindowTitle);
 }
 
 wxString ArchiveViewer::GetDefaultOpenDirectory()
 {
 // TODO
 /*
 	wxRegKey key (_T("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft Games\\Age of Empires 3\\1.0"));
 	if (key.Exists())
 	{
 		wxString dir;
 
 		// The path might be the default value under the AppPath key, or it
 		// might be the AppPath value; so check both.
 		wxRegKey subkey (key, _T("AppPath"));
 		if (subkey.Exists())
 		{
 			if (subkey.QueryValue(_T(""), dir)) // default value
 				return dir;
 		}
 		else
 		{
 			if (key.HasValue(_T("AppPath")) && key.QueryValue(_T("AppPath"), dir))
 				return dir;
 		}
 	}
 */
 
 	return _T("");
 }
 
 void ArchiveViewer::SetFilter(const wxString& filter)
 {
 	m_Filter = filter;
 	RedrawFileList(true);
 }
Index: ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/SectionLayout.cpp
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/SectionLayout.cpp	(revision 4647)
+++ ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/SectionLayout.cpp	(revision 4648)
@@ -1,289 +1,291 @@
 #include "stdafx.h"
 
 #include "wx/filename.h"
 #include "wx/wfstream.h"
 
 #include "SectionLayout.h"
 
 #include "SnapSplitterWindow/SnapSplitterWindow.h"
 
 #include "Sections/Map/Map.h"
 #include "Sections/Terrain/Terrain.h"
 #include "Sections/Object/Object.h"
 #include "Sections/Environment/Environment.h"
 #include "Sections/Cinematic/Cinematic.h"
+#include "Sections/Trigger/Trigger.h"
 
 #include "General/Datafile.h"
 
 //////////////////////////////////////////////////////////////////////////
 
 class SidebarButton : public wxBitmapButton
 {
 public:
 	SidebarButton(wxWindow* parent, const wxBitmap& bitmap, SidebarBook* book, size_t id)
 		: wxBitmapButton(parent, wxID_ANY, bitmap, wxDefaultPosition, wxSize(28, 28))
 		, m_Book(book), m_Id(id)
 	{
 		SetSelectedAppearance(false);
 	}
 
 	void OnClick(wxCommandEvent& event);
 
 	void SetSelectedAppearance(bool selected)
 	{
 		if (selected)
 			SetBackgroundColour(wxColour(0xee, 0xcc, 0x55));
 		else
 			SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
 	}
 
 private:
 	SidebarBook* m_Book;
 	size_t m_Id;
 
 	DECLARE_EVENT_TABLE();
 };
 
 BEGIN_EVENT_TABLE(SidebarButton, wxButton)
 	EVT_BUTTON(wxID_ANY, SidebarButton::OnClick)
 END_EVENT_TABLE();
 
 
 class SidebarBook : public wxPanel
 {
 private:
 	struct SidebarPage
 	{
 		SidebarPage() : button(NULL), bar(NULL) {}
 		SidebarPage(SidebarButton* button, Sidebar* bar) : button(button), bar(bar) {}
 		SidebarButton* button;
 		Sidebar* bar;
 	};
 
 public:
 	SidebarBook(wxWindow *parent, SnapSplitterWindow* splitter)
 		: wxPanel(parent), m_Splitter(splitter), m_SelectedPage(-1)
 	{
 		m_ButtonsSizer = new wxGridSizer(6, 5, 5);
 
 		wxSizer* mainSizer = new wxBoxSizer(wxVERTICAL);
 
 		mainSizer->Add(m_ButtonsSizer);
 
 		m_ContentWindow = new wxPanel(this);
 		mainSizer->Add(m_ContentWindow, wxSizerFlags().Expand().Proportion(1).Border(wxALL, 4));
 
 		SetSizer(mainSizer);
 	}
 
 	// Only allow Sidebar objects to be added
 	bool AddPage(Sidebar* sidebar, const wxString& iconPNGFilename, const wxString& tooltip)
 	{
 		wxImage img (1, 1, true);
 
 		// Load the icon
 		wxFileName iconPath (_T("tools/atlas/toolbar/"));
 		iconPath.MakeAbsolute(Datafile::GetDataDirectory());
 		iconPath.SetFullName(iconPNGFilename);
 		wxFileInputStream fstr (iconPath.GetFullPath());
 		if (! fstr.Ok())
 		{
 			wxLogError(_("Failed to open toolbar icon file '%s'"), iconPath.GetFullPath().c_str());
 		}
 		else
 		{
 			img = wxImage(fstr, wxBITMAP_TYPE_PNG);
 			if (! img.Ok())
 			{
 				wxLogError(_("Failed to load toolbar icon image '%s'"), iconPath.GetFullPath().c_str());
 				img = wxImage (1, 1, true);
 			}
 		}
 
 		// Create the button for the sidebar toolbar
 		SidebarButton* button = new SidebarButton(this, img, this, m_Pages.size());
 		button->SetToolTip(tooltip);
 
 		m_ButtonsSizer->Add(button);
 
 		m_Pages.push_back(SidebarPage(button, sidebar));
 
 		sidebar->Show(false);
 
 		// If this is the first page, make it selected by default
 		if (m_Pages.size() == 1)
 			SetSelection(0);
 
 		return true;
 	}
 
 	size_t GetPageCount()
 	{
 		return m_Pages.size();
 	}
 
 	wxWindow* GetContentWindow()
 	{
 		return m_ContentWindow;
 	}
 
 	void RepositionSelectedPage()
 	{
 		if (m_SelectedPage != -1 && m_Pages[m_SelectedPage].bar)
 		{
 			m_Pages[m_SelectedPage].bar->SetSize(m_ContentWindow->GetSize());
 		}
 	}
 
 	void OnSize(wxSizeEvent& event)
 	{
 		Layout();
 		RepositionSelectedPage();
 		event.Skip();
 	}
 
 	void SetSelection(size_t page)
 	{
 		if (page < m_Pages.size())
 		{
 			// If selecting the same one twice, don't do anything
 			if ((ssize_t)page == m_SelectedPage)
 				return;
 
 			SidebarPage oldPage;
 			if (m_SelectedPage != -1)
 				oldPage = m_Pages[m_SelectedPage];
 
 			if (oldPage.bar)
 				oldPage.bar->Show(false);
 
 			m_SelectedPage = (ssize_t)page;
 			RepositionSelectedPage();
 			m_Pages[m_SelectedPage].bar->Show(true);
 
 			OnPageChanged(oldPage, m_Pages[m_SelectedPage]);
 		}
 	}
 
 protected:
 
 	void OnPageChanged(SidebarPage oldPage, SidebarPage newPage)
 	{
 		if (oldPage.bar)
 		{
 			oldPage.bar->OnSwitchAway();
 			oldPage.button->SetSelectedAppearance(false);
 		}
 
 		if (newPage.bar)
 		{
 			newPage.bar->OnSwitchTo();
 			newPage.button->SetSelectedAppearance(true);
 		}
 
 		if (m_Splitter->IsSplit())
 		{
 			wxWindow* bottom;
 			if (newPage.bar && NULL != (bottom = newPage.bar->GetBottomBar()))
 			{
 				m_Splitter->ReplaceWindow(m_Splitter->GetWindow2(), bottom);
 			}
 			else
 			{
 				m_Splitter->Unsplit();
 			}
 		}
 		else
 		{
 			wxWindow* bottom;
 			if (newPage.bar && NULL != (bottom = newPage.bar->GetBottomBar()))
 			{
 				m_Splitter->SplitHorizontally(m_Splitter->GetWindow1(), bottom);
 			}
 		}
 	}
 
 private:
 	wxSizer* m_ButtonsSizer;
 	wxWindow* m_ContentWindow;
 	SnapSplitterWindow* m_Splitter;
 
 	std::vector<SidebarPage> m_Pages;
 	ssize_t m_SelectedPage;
 
 	DECLARE_EVENT_TABLE();
 };
 
 BEGIN_EVENT_TABLE(SidebarBook, wxPanel)
 	EVT_SIZE(SidebarBook::OnSize)
 END_EVENT_TABLE();
 
 void SidebarButton::OnClick(wxCommandEvent& WXUNUSED(event))
 {
 	m_Book->SetSelection(m_Id);
 }
 
 //////////////////////////////////////////////////////////////////////////
 
 
 
 SectionLayout::SectionLayout()
 {
 }
 
 SectionLayout::~SectionLayout()
 {
 }
 
 void SectionLayout::SetWindow(wxWindow* window)
 {
 	m_HorizSplitter = new SnapSplitterWindow(window, wxSP_NOBORDER);
 	m_VertSplitter = new SnapSplitterWindow(m_HorizSplitter, wxSP_3D);
 }
 
 wxWindow* SectionLayout::GetCanvasParent()
 {
 	return m_VertSplitter;
 }
 
 void SectionLayout::SetCanvas(wxWindow* canvas)
 {
 	m_Canvas = canvas;
 }
 
 void SectionLayout::Build()
 {
 	// TODO: wxWidgets bug (http://sourceforge.net/tracker/index.php?func=detail&aid=1298803&group_id=9863&atid=109863)
 	// - pressing menu keys (e.g. alt+f) with notebook tab focussed causes application to freeze
 
 	m_SidebarBook = new SidebarBook(m_HorizSplitter, m_VertSplitter);
 	Sidebar* sidebar;
 
 	#define ADD_SIDEBAR(classname, icon, tooltip) \
 		sidebar = new classname(m_SidebarBook->GetContentWindow(), m_VertSplitter); \
 		if (sidebar->GetBottomBar()) \
 			sidebar->GetBottomBar()->Show(false); \
 		m_SidebarBook->AddPage(sidebar, icon, tooltip); \
 		m_PageMappings.insert(std::make_pair(L###classname, (int)m_SidebarBook->GetPageCount()-1));
 	
 	ADD_SIDEBAR(MapSidebar,         _T("map.png"),         _("Map"));
 	ADD_SIDEBAR(TerrainSidebar,     _T("terrain.png"),     _("Terrain"));
 	ADD_SIDEBAR(ObjectSidebar,      _T("object.png"),      _("Object"));
 	ADD_SIDEBAR(EnvironmentSidebar, _T("environment.png"), _("Environment"));
-	ADD_SIDEBAR(CinematicSidebar,   _T("cinematic.png"),   _("Cinematics"));
+	ADD_SIDEBAR(CinematicSidebar,   _T("cinematic.png"),   _("Cinema"));
+	ADD_SIDEBAR(TriggerSidebar,		_T("trigger.png"),	   _("Trigger"));
 
 	#undef ADD_SIDEBAR
 
 	m_VertSplitter->SetDefaultSashPosition(-165);
 	m_VertSplitter->Initialize(m_Canvas);
 
 	m_HorizSplitter->SetDefaultSashPosition(200);
 	m_HorizSplitter->SplitVertically(m_SidebarBook, m_VertSplitter);
 }
 
 void SectionLayout::SelectPage(const wxString& classname)
 {
 	std::map<std::wstring, int>::iterator it = m_PageMappings.find(classname.c_str());
 	if (it != m_PageMappings.end())
 		m_SidebarBook->SetSelection(it->second);
 }
Index: ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Trigger/Trigger.cpp
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Trigger/Trigger.cpp	(nonexistent)
+++ ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Trigger/Trigger.cpp	(revision 4648)
@@ -0,0 +1,1426 @@
+#include "stdafx.h"
+
+#include "Trigger.h"
+#include "GameInterface/Messages.h"
+#include "CustomControls/Buttons/ActionButton.h"
+#include "ScenarioEditor/Tools/Common/Tools.h"
+#include <sstream>
+
+using namespace AtlasMessage;
+
+BEGIN_EVENT_TABLE(TriggerSidebar, Sidebar)
+EVT_TREE_BEGIN_DRAG(wxID_ANY, TriggerSidebar::onTreeDrag)
+EVT_TREE_END_LABEL_EDIT(wxID_ANY, TriggerSidebar::onTreeNameChange)
+EVT_TREE_SEL_CHANGED(wxID_ANY, TriggerSidebar::onTreeSelChange)
+EVT_LIST_ITEM_SELECTED(TriggerSidebar::ID_CondList, TriggerSidebar::onCondSelect)
+EVT_LIST_ITEM_SELECTED(TriggerSidebar::ID_EffectList, TriggerSidebar::onEffectSelect)
+EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, TriggerSidebar::onPageChange)
+END_EVENT_TABLE()
+
+
+class TriggerTreeCtrl : public wxTreeCtrl
+{
+public:
+	TriggerTreeCtrl(TriggerSidebar* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, 
+						const wxSize& size = wxDefaultSize, long style = wxTR_HAS_BUTTONS )
+						: wxTreeCtrl(parent, id, pos, size, style), m_Sidebar(parent) { }
+	
+	void onClick(wxMouseEvent& evt);
+
+private:
+	TriggerSidebar* m_Sidebar;
+	DECLARE_EVENT_TABLE();
+};
+
+BEGIN_EVENT_TABLE(TriggerTreeCtrl, wxTreeCtrl)
+EVT_LEFT_DOWN(TriggerTreeCtrl::onClick)
+END_EVENT_TABLE()
+
+
+struct LogicBlockHelper
+{
+	LogicBlockHelper() { index = -1; end = false; }
+	LogicBlockHelper(int _index, bool _end) : index(_index), end(_end) {}
+	int index;
+	bool end;
+
+	bool operator< ( const LogicBlockHelper& rhs ) const
+	{
+		return index < rhs.index;
+	}
+	bool operator== ( const LogicBlockHelper& rhs ) const
+	{
+		return index == rhs.index;
+	}
+};
+class TriggerSpecText : public wxTextCtrl
+{
+	typedef void (*callback)(void* data, std::wstring input, int parameter);
+
+public:
+	TriggerSpecText(wxWindow* parent, std::wstring label, const wxPoint& pos, const wxSize& size, 
+						int parameter, std::wstring dataType, callback func, void* data)
+		: wxTextCtrl(parent, wxID_ANY, wxString( label.c_str() ), pos, size, wxTE_PROCESS_ENTER), 
+			m_DataType(dataType), m_Parameter(parameter), m_Data(data), m_Callback(func)
+	{
+	}
+	void onTextEnter(wxCommandEvent& WXUNUSED(evt));
+
+	//Disallow invalid input
+	bool VerifyInput(std::wstring& input)
+	{
+		std::wstringstream stream(input);
+		if ( m_DataType == L"int" )
+		{
+			int test;
+			stream >> test;
+			return !stream.fail();
+		}
+		else if ( m_DataType == L"real" )
+		{
+			float test;
+			stream >> test;
+			return !stream.fail();
+		}
+		else if ( m_DataType == L"bool" )
+		{
+			bool test;
+			stream >> test;
+			return !stream.fail();
+		}
+		else if ( m_DataType == L"string" )
+		{
+			//Make strings appear as strings to javascript
+			std::wstring quote(L"\"");
+			input.insert(0, quote);
+			input.append(quote);
+			return true;
+		}
+		else
+		{
+			wxFAIL_MSG(L"Invalid input type for trigger specification");
+			return false;
+		}
+	}
+private:
+	void* m_Data;
+	int m_Parameter;
+	std::wstring m_DataType;
+	callback m_Callback;
+
+	DECLARE_EVENT_TABLE();
+	
+};
+BEGIN_EVENT_TABLE(TriggerSpecText, wxTextCtrl)
+EVT_TEXT_ENTER(wxID_ANY, TriggerSpecText::onTextEnter)
+END_EVENT_TABLE()
+
+class TriggerSpecChoice : public wxChoice
+{
+	typedef void (*callback)(void* data, std::wstring input, int parameter);
+
+public:
+	TriggerSpecChoice(wxWindow* parent, std::wstring label, const wxPoint& pos, 
+		const wxSize& size, const wxArrayString& strings, int parameter, callback func, void* data) 
+		: wxChoice(parent, wxID_ANY, pos, size, strings), m_Callback(func), m_Data(data), m_Parameter(parameter)
+	{ 
+	}
+
+	void onChoice(wxCommandEvent& evt)
+	{
+		(*m_Callback)(m_Data, std::wstring( evt.GetString().wc_str() ), m_Parameter);
+	}
+	
+private:
+	callback m_Callback;
+	int m_Parameter;
+	void* m_Data;
+
+	DECLARE_EVENT_TABLE();
+};
+
+BEGIN_EVENT_TABLE(TriggerSpecChoice, wxChoice)
+EVT_CHOICE(wxID_ANY, TriggerSpecChoice::onChoice)
+END_EVENT_TABLE()
+
+class TriggerListCtrl : public wxListCtrl
+{
+public:
+	TriggerListCtrl(wxWindow* parent, TriggerSidebar* sidebar, bool condition, wxWindowID id, const wxPoint& pos = wxDefaultPosition, 
+						const wxSize& size = wxDefaultSize, long style = wxLC_ICON)
+		: wxListCtrl(parent, id, pos, size, style), m_Sidebar(sidebar), m_Condition(condition)
+	{
+	}
+	void onClick(wxMouseEvent& evt);
+
+	TriggerSidebar* m_Sidebar;
+	bool m_Condition;
+private:
+	DECLARE_EVENT_TABLE();
+};
+BEGIN_EVENT_TABLE(TriggerListCtrl, wxListCtrl)
+EVT_LEFT_DOWN(TriggerListCtrl::onClick)
+END_EVENT_TABLE()
+
+
+class TriggerPage : public wxPanel
+{
+public:
+	TriggerPage(wxWindow* parent, TriggerSidebar* sidebar, long ID, wxString title, bool condition) 
+		: wxPanel(parent), m_Sidebar(sidebar), m_Condition(condition)
+	
+	{
+		wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
+
+		m_List = new TriggerListCtrl(this, sidebar, condition, ID, wxDefaultPosition,
+					wxSize(132, 210), wxLC_REPORT | wxLC_SINGLE_SEL);
+		m_List->InsertColumn(0, title, wxLIST_FORMAT_LEFT, 100);
+
+		sizer->Add(m_List);
+		SetSizer(sizer);
+	}
+
+	wxListCtrl* m_List;
+	TriggerSidebar* m_Sidebar;
+	bool m_Condition;
+};
+
+
+
+class TriggerItemData : public wxTreeItemData, public sTrigger
+{
+public:
+	TriggerItemData(TriggerSidebar* sidebar, const std::wstring& name, bool group)
+		: m_Sidebar(sidebar), sTrigger(name), m_Group(group), m_CondCount(0), m_EffectCount(0) {}
+	TriggerItemData(TriggerSidebar* sidebar, const sTrigger& trigger, bool group)
+		: m_Sidebar(sidebar), sTrigger(trigger), m_Group(group), m_CondCount(0), m_EffectCount(0) {}
+
+	TriggerSidebar* m_Sidebar;
+	size_t m_CondCount, m_EffectCount;
+	bool m_Group;
+	std::list<int> m_BlockIndices, m_BlockEndIndices;
+
+	void AddBlock(const int block, const int index)
+	{
+		std::vector<int> copy = *logicBlocks;
+		copy.push_back(block);
+		logicBlocks = copy;
+		m_BlockIndices.push_back(index);
+	}
+	void AddBlockEnd(const int block, const int index)
+	{
+		std::vector<int> copy = *logicBlockEnds;
+		copy.push_back(block);
+		logicBlockEnds = copy;
+		m_BlockEndIndices.push_back(index);
+	}
+
+	void ResetBlockIndices()
+	{
+		std::vector<int> newLogicBlocks, newLogicBlockEnds;
+		m_BlockIndices.clear();
+		m_BlockEndIndices.clear();
+		int conditionCount = 0;
+
+		for (int i=0; i<m_Sidebar->m_ConditionPage->m_List->GetItemCount(); ++i)
+		{
+			if ( m_Sidebar->m_ConditionPage->m_List->GetItemText(i) == m_Sidebar->m_LogicBlockString )
+			{
+				newLogicBlocks.push_back(conditionCount);
+				m_BlockIndices.push_back(i);
+			}
+
+			//Block ends belong to current condition, hence conditionCount-1
+			else if ( m_Sidebar->m_ConditionPage->m_List->GetItemText(i) == m_Sidebar->m_LogicBlockEndString )
+			{
+				if ( conditionCount == 0 )
+					newLogicBlockEnds.push_back(0);
+				else
+					newLogicBlockEnds.push_back(conditionCount-1);
+				m_BlockEndIndices.push_back(i);
+			}
+			else
+				++conditionCount;
+		}
+		logicBlocks = newLogicBlocks;
+		logicBlockEnds = newLogicBlockEnds;
+	}
+};
+
+
+void onTriggerParameter(void* data, std::wstring paramString, int parameter);
+
+
+class TriggerBottomBar : public wxPanel
+{
+	enum {  ID_TimeEdit, ID_CondNameEdit, ID_EffectNameEdit, ID_TriggerNameEdit, ID_RunsEdit,
+			ID_EffectChoice, ID_CondChoice, 
+			ID_TimeRadio, ID_LogicRadio, 
+			ID_NotCheck, ID_ActiveCheck };
+	
+public:
+	enum { NO_VIEW, TRIGGER_VIEW, CONDITION_VIEW, EFFECT_VIEW };
+
+	TriggerBottomBar(TriggerSidebar* sidebar, wxWindow* parent)
+		: wxPanel(parent), m_Sidebar(sidebar)
+	{
+		 m_Sizer = new wxBoxSizer(wxHORIZONTAL);
+		 SetSizer(m_Sizer);
+		 m_DependentStatus = NO_VIEW;
+	}
+	
+	int GetDependentStatus()
+	{
+		return m_DependentStatus;
+	}
+	void SetSpecs(std::vector<sTriggerSpec> conditions, std::vector<sTriggerSpec> effects)
+	{
+		m_ConditionSpecs = conditions;
+		m_EffectSpecs = effects;
+	}
+	
+	wxArrayString GetConditionNames()
+	{
+		wxArrayString ret;
+		for ( size_t i = 0; i < m_ConditionSpecs.size(); ++i )
+			ret.Add( wxString(m_ConditionSpecs[i].displayName.c_str()) );
+		return ret;
+	}
+	wxArrayString GetEffectNames()
+	{
+		wxArrayString ret;
+		for ( size_t i = 0; i < m_EffectSpecs.size(); ++i )
+			ret.Add( wxString(m_EffectSpecs[i].displayName.c_str()) );
+		return ret;
+	}
+	
+	void onEffectChoice(wxCommandEvent& evt)
+	{
+		//Retrieve specification corresponding to selection
+		if ( m_Sidebar->m_SelectedEffect != -1 )
+		{
+			std::vector<sTriggerSpec>::iterator it = std::find( m_EffectSpecs.begin(), 
+				m_EffectSpecs.end(), std::wstring(evt.GetString()) );
+			DisplayTriggerSpec(*it);
+		}
+	}
+
+	void onCondChoice(wxCommandEvent& evt)
+	{
+		if ( m_Sidebar->m_SelectedCond != -1 )
+		{	
+			std::vector<sTriggerSpec>::iterator it = std::find( m_ConditionSpecs.begin(), 
+				m_ConditionSpecs.end(), std::wstring(evt.GetString()) );
+			DisplayTriggerSpec(*it);
+		}
+	}
+	
+	void onTimeEnter(wxCommandEvent& WXUNUSED(evt))
+	{
+		float fValue;
+		std::wstringstream stream( std::wstring(m_TimeEdit->GetValue()) );
+		stream >> fValue;
+		
+		if ( stream.fail() )
+		{
+			wxBell();
+			return;
+		}
+		
+		m_Sidebar->GetSelectedItemData()->timeValue = fValue;
+		wxString value = wxString::Format(L"%.2f", fValue);
+		m_TimeEdit->SetValue(value);
+		m_Sidebar->UpdateEngineData();
+	}
+
+	void onConditionEnter(wxCommandEvent& WXUNUSED(evt))
+	{
+		if ( m_Sidebar->m_SelectedCond == -1 )
+			return;
+
+		std::vector<sTriggerCondition> conditions = *m_Sidebar->GetSelectedItemData()->conditions;
+		int condition = m_Sidebar->GetConditionCount(m_Sidebar->m_SelectedCond);
+		
+		if ( condition == 0 )
+			conditions[0].name = std::wstring( m_ConditionEdit->GetValue() );
+		else
+			conditions[condition-1] = std::wstring( m_ConditionEdit->GetValue() );
+		
+		m_Sidebar->GetSelectedItemData()->conditions = conditions;
+		m_Sidebar->UpdateLists();
+		m_Sidebar->UpdateEngineData();
+	}
+	void onEffectEnter(wxCommandEvent& WXUNUSED(evt))
+	{
+		if ( m_Sidebar->m_SelectedEffect== -1 )
+			return;
+
+		std::vector<sTriggerEffect> effects = *m_Sidebar->GetSelectedItemData()->effects;
+		effects[m_Sidebar->m_SelectedEffect].name = std::wstring( m_EffectEdit->GetValue() );
+		m_Sidebar->GetSelectedItemData()->effects = effects;
+		m_Sidebar->UpdateLists();
+		m_Sidebar->UpdateEngineData();
+	}
+	void onTriggerEnter(wxCommandEvent& WXUNUSED(evt))
+	{
+		TriggerItemData* data = m_Sidebar->GetSelectedItemData();
+		if ( data == NULL || m_Sidebar->m_TriggerTree->GetSelection() == m_Sidebar->m_TriggerTree->GetRootItem() )
+			return;
+		
+		wxString name = m_TriggerEdit->GetValue();
+		data->name = std::wstring(name);
+		m_Sidebar->m_TriggerTree->SetItemText(m_Sidebar->m_TriggerTree->GetSelection(), name);
+		m_Sidebar->UpdateEngineData();
+	}
+
+	void onRunsEnter(wxCommandEvent& WXUNUSED(evt))
+	{
+		int iValue;
+		std::wstringstream stream( std::wstring(m_RunsEdit->GetValue()) );
+		stream >> iValue;
+		
+		if ( stream.fail() )
+		{
+			wxBell();
+			return;
+		}
+		
+		m_Sidebar->GetSelectedItemData()->maxRuns = iValue;
+		m_Sidebar->UpdateEngineData();
+	}
+	void onLogicRadio(wxCommandEvent& evt)
+	{
+		if ( m_Sidebar->m_SelectedCond == -1 )
+			return;
+		std::vector<sTriggerCondition> conditions = *m_Sidebar->GetSelectedItemData()->conditions;
+		int condition = m_Sidebar->GetConditionCount(m_Sidebar->m_SelectedCond);
+		conditions[condition-1].linkLogic = evt.GetInt() + 1;
+		
+		m_Sidebar->GetSelectedItemData()->conditions = conditions;
+		m_Sidebar->UpdateLists();
+		m_Sidebar->UpdateEngineData();
+	}
+	void onActiveCheck(wxCommandEvent& evt)
+	{
+		m_Sidebar->GetSelectedItemData()->active = (evt.GetInt() == 1);
+		m_Sidebar->UpdateEngineData();
+	}
+	void onNotCheck(wxCommandEvent& evt)
+	{
+		if ( m_Sidebar->m_SelectedCond == -1 )
+			return;
+		std::vector<sTriggerCondition> conditions = *m_Sidebar->GetSelectedItemData()->conditions;
+		int condition = m_Sidebar->GetConditionCount(m_Sidebar->m_SelectedCond);
+		bool value = (evt.GetInt() == 1);
+		conditions[condition-1].not = value;
+		
+		m_Sidebar->GetSelectedItemData()->conditions = conditions;
+		m_Sidebar->UpdateLists();
+		m_Sidebar->UpdateEngineData();
+	}
+
+	void DisplayTriggerSpec(const sTriggerSpec& spec)
+	{
+		if ( m_Sizer->Detach(m_ParameterSizer) )
+		{
+			delete m_ParameterSizer;
+			m_Sizer->Layout();
+			Layout();
+		}
+		
+		//m_ParameterSizer = new wxStaticBoxSizer(wxVERTICAL, this, L"Parameters");
+		m_ParameterSizer = new wxBoxSizer(wxVERTICAL);
+		wxBoxSizer* hRow = NULL;
+		std::vector<sTriggerParameter> parameters = *spec.parameters;
+		std::vector<std::wstring> stringParameters;
+		int row = -1;
+		
+		//Set parameter data to new data if change is needed
+		if ( m_Sidebar->m_Notebook->GetCurrentPage() == m_Sidebar->m_ConditionPage )
+		{
+			std::vector<sTriggerCondition> conditions = *m_Sidebar->GetSelectedItemData()->conditions;
+			int condition = m_Sidebar->GetConditionCount(m_Sidebar->m_SelectedCond) - 1 ;
+			if ( *conditions[condition].displayName != *spec.displayName )
+			{
+				std::vector<std::wstring> newParameters(parameters.size());
+				conditions[condition].parameters = newParameters;
+				conditions[condition].displayName = *spec.displayName;
+				conditions[condition].functionName = *spec.functionName;
+				m_Sidebar->GetSelectedItemData()->conditions = conditions;
+				m_Sidebar->UpdateEngineData();
+			}
+			stringParameters = *(*m_Sidebar->GetSelectedItemData()->conditions)
+													[m_Sidebar->m_SelectedCond].parameters;
+		}
+		else
+		{
+			std::vector<sTriggerEffect> effects = *m_Sidebar->GetSelectedItemData()->effects;
+			if ( *effects[m_Sidebar->m_SelectedEffect].displayName != *spec.displayName )
+			{
+				std::vector<std::wstring> newParameters(parameters.size());
+				effects[m_Sidebar->m_SelectedEffect].parameters = newParameters;
+				effects[m_Sidebar->m_SelectedEffect].displayName = *spec.displayName;
+				effects[m_Sidebar->m_SelectedEffect].functionName = *spec.functionName;
+				m_Sidebar->GetSelectedItemData()->effects = effects;
+				m_Sidebar->UpdateEngineData();
+			}
+			stringParameters = *(*m_Sidebar->GetSelectedItemData()->effects)
+											[m_Sidebar->m_SelectedEffect].parameters;
+		}
+		
+		//Add all parameters to sizer
+		for ( std::vector<sTriggerParameter>::iterator it=parameters.begin(); it!=parameters.end(); ++it )
+		{
+			if ( it->row != row )
+			{
+				row = it->row;
+				hRow = new wxBoxSizer(wxHORIZONTAL);
+				m_ParameterSizer->Add(hRow);
+			}
+
+			if ( *it->windowType == std::wstring(L"text") )
+			{
+				hRow->Add( new wxStaticText(this, wxID_ANY, wxString( (*it->name).c_str() ), 
+															wxPoint(it->xPos, it->yPos)) );
+				wxTextCtrl* text = new TriggerSpecText(this, L"", wxDefaultPosition, wxSize(it->xSize, it->ySize), 
+									it->parameterOrder, *it->inputType, &onTriggerParameter, this);
+				
+				hRow->Add( text, 0, wxLEFT, 5 );
+				wxString fill( stringParameters[it->parameterOrder].c_str() );
+				
+				//Trim quotes
+				if ( *it->inputType == L"string" && fill.size() > 0 )
+				{
+					fill.erase(0, 1);
+					fill.erase(fill.size()-1, 1);
+				}
+				text->SetValue(fill);
+			}
+
+			else if ( *it->windowType == std::wstring(L"choice") )
+			{
+				qGetTriggerChoices qChoices(*spec.functionName + *it->name);
+				qChoices.Post();
+				std::vector<std::wstring> choices = *qChoices.choices;
+				wxArrayString strings;
+
+				for ( size_t i = 0; i < choices.size(); ++i )
+					strings.Add( wxString(choices[i].c_str()) );
+
+				hRow->Add( new wxStaticText(this, wxID_ANY, wxString( (*it->name).c_str() ), 
+															wxPoint(it->xPos, it->yPos)) );
+				wxChoice* choice = new TriggerSpecChoice( this, L"", wxDefaultPosition, wxSize(it->xSize, it->ySize), 
+									strings, it->parameterOrder, &onTriggerParameter, this );
+
+				hRow->Add(choice);
+				choice->SetStringSelection( wxString(stringParameters[it->parameterOrder].c_str()) );
+			}
+			else
+			{
+				wxFAIL_MSG(L"Invalid window type for trigger specification");
+				//do something else...
+			}
+		}
+	
+		
+		//(If nothing was added, it won't be automatically delted)
+		if ( row < 0 )
+		{
+			delete hRow;
+			delete m_ParameterSizer;
+		}
+		else
+			m_Sizer->Add(m_ParameterSizer, 0, wxLEFT, 5);
+
+		m_Sizer->Layout();
+		Layout();
+	}
+	
+	void FillConditionData()
+	{
+		if ( m_Sidebar->m_SelectedCond== -1 )
+			return;
+
+		TriggerItemData* itemData = m_Sidebar->GetSelectedItemData();		
+		int iCondition = m_Sidebar->GetConditionCount(m_Sidebar->m_SelectedCond);
+		sTriggerCondition condition = (*itemData->conditions)[iCondition-1];
+		wxString display( (*condition.displayName).c_str() );
+		m_ConditionEdit->SetValue( wxString(condition.name.c_str()) );
+
+		if ( display != L"" )
+		{
+			std::vector<sTriggerSpec>::iterator it = std::find( m_ConditionSpecs.begin(), 
+										m_ConditionSpecs.end(), std::wstring(display) );
+			if ( it != m_ConditionSpecs.end() )
+			{
+				m_ConditionChoice->SetStringSelection(display);
+				DisplayTriggerSpec(*it);
+			}
+		}
+		else
+			m_ConditionChoice->SetStringSelection(display);
+
+		if ( condition.linkLogic == 0 || condition.linkLogic == 1 )
+			m_LogicRadio->SetSelection(0);
+		else
+			m_LogicRadio->SetSelection(1);
+
+		m_NotCheck->SetValue(condition.not);
+	}
+
+	void FillEffectData()
+	{
+		TriggerItemData* itemData = m_Sidebar->GetSelectedItemData();
+		sTriggerEffect effect = (*itemData->effects)[m_Sidebar->m_SelectedEffect];
+		wxString display( (*effect.displayName).c_str() );
+
+		m_EffectEdit->SetValue( wxString(effect.name.c_str()) );
+		if ( display != L"" )
+		{
+			std::vector<sTriggerSpec>::iterator it = std::find( m_EffectSpecs.begin(), 
+											m_EffectSpecs.end(), std::wstring(display) );
+			if ( it != m_EffectSpecs.end() )
+			{
+				m_EffectChoice->SetStringSelection(display);
+				DisplayTriggerSpec(*it);
+			}
+		}
+		//m_TimeRadio->SetSelection(effect.loop);
+		
+		float timeVal = itemData->timeValue;
+		wxString value = wxString::Format(L"%.2f", timeVal);
+		m_TimeEdit->SetValue(value);
+	}
+
+	void FillTriggerData()
+	{
+		if ( m_DependentStatus != TRIGGER_VIEW )
+			return;
+		TriggerItemData* itemData = m_Sidebar->GetSelectedItemData();
+		m_TriggerEdit->SetValue( wxString( (*itemData->name).c_str()) );
+		m_ActiveCheck->SetValue(itemData->active);
+		int runs = itemData->maxRuns;
+		m_RunsEdit->SetValue( wxString( wxString::Format(L"%d", runs)) );
+
+	}
+
+	void ToEffectView()
+	{
+		DestroyChildren();
+		m_Sizer = new wxBoxSizer(wxHORIZONTAL);
+		m_DependentSizer = new wxStaticBoxSizer(wxVERTICAL, this, wxString(L"Trigger Editor"));
+		SetSizer(m_Sizer, true);
+		
+		m_DependentSizer = new wxStaticBoxSizer(wxVERTICAL, this, wxString(L"Trigger Editor"));
+		wxStaticText* name = new wxStaticText(this, wxID_ANY, wxString(L"Name:"));
+		wxStaticText* effect = new wxStaticText(this, wxID_ANY, wxString(L"Effect:"));
+		m_EffectEdit = new wxTextCtrl(this, ID_EffectNameEdit, _T(""), wxDefaultPosition,
+						wxSize(100, 18), wxTE_PROCESS_ENTER);
+
+		wxArrayString effectNames = GetEffectNames();
+		wxString radioChoice[] = { wxString(L"Delay"), wxString(L"Loop") };
+		m_EffectChoice = new wxChoice(this, ID_EffectChoice, wxDefaultPosition, wxSize(100, 13), effectNames);
+
+		m_TimeRadio = new wxRadioBox(this, ID_TimeRadio, _T("Execution type"),
+			wxDefaultPosition, wxDefaultSize, 2, radioChoice, 2, wxRA_SPECIFY_COLS);
+
+		wxStaticText* time = new wxStaticText(this, wxID_ANY, wxString(L"Time:"));
+		m_TimeEdit = new wxTextCtrl(this, ID_TimeEdit, _T(""), wxDefaultPosition,
+						wxSize(100, 18), wxTE_PROCESS_ENTER);
+
+		wxBoxSizer* hNameHolder = new wxBoxSizer(wxHORIZONTAL);
+		wxBoxSizer* hEffectHolder = new wxBoxSizer(wxHORIZONTAL);
+		wxBoxSizer* hTimeHolder = new wxBoxSizer(wxHORIZONTAL);
+
+		hNameHolder->Add(name);
+		hNameHolder->Add(m_EffectEdit, 0, wxLEFT, 5);
+		hEffectHolder->Add(effect);
+		hEffectHolder->Add(m_EffectChoice, 0, wxLEFT, 5);
+		hTimeHolder->Add(time);
+		hTimeHolder->Add(m_TimeEdit, 0, wxLEFT, 5);
+
+		m_DependentSizer->Add(hNameHolder, 0, wxTOP, 5);
+		m_DependentSizer->Add(hEffectHolder, 0, wxTOP, 5);
+		m_DependentSizer->Add(m_TimeRadio, 0, wxTOP | wxALIGN_CENTER, 10);
+		m_DependentSizer->Add(hTimeHolder, 0, wxTOP | wxALIGN_CENTER, 5);
+
+		m_Sizer->Add(m_DependentSizer);
+		m_Sizer->Layout();
+		Layout();
+		m_DependentStatus = EFFECT_VIEW;
+	}
+
+	void ToConditionView()
+	{
+		DestroyChildren();
+		m_Sizer = new wxBoxSizer(wxHORIZONTAL);
+		m_DependentSizer = new wxStaticBoxSizer(wxVERTICAL, this, wxString(L"Trigger Editor"));
+		SetSizer(m_Sizer, true);
+		
+		wxStaticText* name = new wxStaticText(this, wxID_ANY, wxString(L"Name:"));
+		wxStaticText* condition = new wxStaticText(this, wxID_ANY, wxString(L"Condition:"));
+		m_ConditionEdit = new wxTextCtrl(this, ID_CondNameEdit, _T(""), wxDefaultPosition,
+						wxSize(100, 18), wxTE_PROCESS_ENTER);
+
+		wxArrayString conditionNames = GetConditionNames();
+		wxString radioChoice[] = { wxString(L"And"), wxString(L"Or") };
+		m_ConditionChoice = new wxChoice(this, ID_CondChoice, wxDefaultPosition,
+											wxSize(100, 13), conditionNames);
+
+		m_LogicRadio = new wxRadioBox(this, ID_LogicRadio, _T("Link logic:"),
+			wxDefaultPosition, wxDefaultSize, 2, radioChoice, 2, wxRA_SPECIFY_COLS);
+
+		m_NotCheck = new wxCheckBox(this, ID_NotCheck, wxString(L"Not: "));
+
+		wxBoxSizer* hNameHolder = new wxBoxSizer(wxHORIZONTAL);
+		wxBoxSizer* hConditionHolder = new wxBoxSizer(wxHORIZONTAL);
+		wxBoxSizer* hLogicHolder = new wxBoxSizer(wxHORIZONTAL);
+
+		hNameHolder->Add(name);
+		hNameHolder->Add(m_ConditionEdit, 0, wxLEFT | wxALIGN_CENTER, 5);
+		hConditionHolder->Add(condition);
+		hConditionHolder->Add(m_ConditionChoice, 0, wxLEFT | wxALIGN_CENTER, 5);
+		hLogicHolder->Add(m_LogicRadio, 0, 0, 5);
+		hLogicHolder->Add(m_NotCheck, 0, wxLEFT | wxALIGN_CENTER, 5);
+
+		m_DependentSizer->Add(hNameHolder, 0, wxTOP, 5);
+		m_DependentSizer->Add(hConditionHolder, 0, wxTOP, 5);
+		m_DependentSizer->Add(hLogicHolder, 0, wxALIGN_CENTER | wxTOP, 10); 
+		
+		m_Sizer->Add(m_DependentSizer);
+		m_Sizer->Layout();
+		Layout();
+		m_DependentStatus = CONDITION_VIEW;
+	}
+
+	void ToTriggerView()
+	{
+		DestroyChildren();
+		m_Sizer = new wxBoxSizer(wxHORIZONTAL);
+		m_DependentSizer = new wxStaticBoxSizer(wxVERTICAL, this, wxString(L"Trigger Editor"));
+		SetSizer(m_Sizer, true);
+		
+		wxStaticText* name = new wxStaticText(this, wxID_ANY, wxString(L"Name:"));
+		m_TriggerEdit = new wxTextCtrl(this, ID_TriggerNameEdit, _T(""), wxDefaultPosition,
+						wxSize(100, 18), wxTE_PROCESS_ENTER);
+		
+		wxStaticText* runs = new wxStaticText(this, wxID_ANY, wxString(L"Maximum runs:"));
+		m_RunsEdit = new wxTextCtrl(this, ID_RunsEdit, wxString(L"-1"), wxDefaultPosition, wxSize(100, 18));
+		m_ActiveCheck = new wxCheckBox(this, ID_ActiveCheck, wxString(L"Active: "));
+
+		wxBoxSizer* nameHolder = new wxBoxSizer(wxHORIZONTAL), *runsHolder = new wxBoxSizer(wxHORIZONTAL);
+		
+		nameHolder->Add(name);
+		nameHolder->Add(m_TriggerEdit, 0, wxLEFT, 5);
+		runsHolder->Add(runs);
+		runsHolder->Add(m_RunsEdit, 0, wxLEFT, 5);
+
+		m_DependentSizer->Add(nameHolder);
+		m_DependentSizer->Add(runsHolder, 0, wxTOP, 5);
+		m_DependentSizer->Add(m_ActiveCheck, 0, wxTOP, 5);
+
+		m_Sizer->Add(m_DependentSizer);
+		m_Sizer->Layout();
+		Layout();
+		m_DependentStatus = TRIGGER_VIEW;
+	}
+	void ToNoView()
+	{
+		if ( m_DependentStatus == NO_VIEW )
+			return;
+		DestroyChildren();
+		m_DependentStatus = NO_VIEW;
+	}
+	TriggerSidebar* m_Sidebar;
+
+private:
+
+	wxBoxSizer* m_Sizer, *m_ParameterSizer;	
+	wxStaticBoxSizer* m_DependentSizer; //dependent = effect/condition
+	
+	wxTextCtrl* m_TimeEdit, *m_ConditionEdit, *m_EffectEdit, *m_TriggerEdit, *m_RunsEdit;
+	wxCheckBox* m_ActiveCheck, *m_NotCheck;
+	wxChoice* m_ConditionChoice, *m_EffectChoice;
+	wxRadioBox* m_LogicRadio, *m_TimeRadio;
+
+	std::vector<sTriggerSpec> m_ConditionSpecs, m_EffectSpecs;
+	int m_DependentStatus;
+
+	DECLARE_EVENT_TABLE();
+};
+
+
+BEGIN_EVENT_TABLE(TriggerBottomBar, wxPanel)
+EVT_TEXT_ENTER(TriggerBottomBar::ID_TimeEdit, TriggerBottomBar::onTimeEnter)
+EVT_TEXT_ENTER(TriggerBottomBar::ID_CondNameEdit, TriggerBottomBar::onConditionEnter)
+EVT_TEXT_ENTER(TriggerBottomBar::ID_EffectNameEdit, TriggerBottomBar::onEffectEnter)
+EVT_TEXT_ENTER(TriggerBottomBar::ID_TriggerNameEdit, TriggerBottomBar::onTriggerEnter)
+EVT_TEXT_ENTER(TriggerBottomBar::ID_RunsEdit, TriggerBottomBar::onRunsEnter)
+EVT_CHOICE(TriggerBottomBar::ID_EffectChoice, TriggerBottomBar::onEffectChoice)
+EVT_CHOICE(TriggerBottomBar::ID_CondChoice, TriggerBottomBar::onCondChoice)
+
+EVT_RADIOBOX(TriggerBottomBar::ID_LogicRadio, TriggerBottomBar::onLogicRadio)
+EVT_CHECKBOX(TriggerBottomBar::ID_ActiveCheck, TriggerBottomBar::onActiveCheck)
+EVT_CHECKBOX(TriggerBottomBar::ID_NotCheck, TriggerBottomBar::onNotCheck)
+//EVT_RADIOBOX(TriggerBotomBar::ID_TimeRadio, TriggerBottomBar::onTimeRadio)
+END_EVENT_TABLE()
+
+
+void TriggerTreeCtrl::onClick(wxMouseEvent& evt)
+{
+	if ( m_Sidebar->m_TriggerTree->GetSelection() == m_Sidebar->m_TriggerTree->GetRootItem() ||
+											!m_Sidebar->m_TriggerTree->GetSelection() )
+	{
+		m_Sidebar->m_TriggerBottom->ToNoView();
+	}
+	else
+	{
+		m_Sidebar->m_TriggerBottom->ToTriggerView();
+		m_Sidebar->m_TriggerBottom->FillTriggerData();
+	}
+	evt.Skip();
+}
+
+void TriggerListCtrl::onClick(wxMouseEvent& evt)
+{
+	if ( m_Condition )
+	{
+		//if ( m_Sidebar->m_TriggerBottom->GetDependentStatus() != TriggerBottomBar::CONDITION_VIEW )
+			m_Sidebar->m_TriggerBottom->ToConditionView();
+		if ( m_Sidebar->m_SelectedCond != -1 )
+			m_Sidebar->m_TriggerBottom->FillConditionData();
+	}
+	else
+	{
+		//if ( m_Sidebar->m_TriggerBottom->GetDependentStatus() != TriggerBottomBar::EFFECT_VIEW )
+			m_Sidebar->m_TriggerBottom->ToEffectView();
+		if ( m_Sidebar->m_SelectedEffect != -1 )
+			m_Sidebar->m_TriggerBottom->FillEffectData();
+	}
+	evt.Skip();
+}
+
+void TriggerSpecText::onTextEnter(wxCommandEvent& WXUNUSED(evt))
+{
+	std::wstring text( GetValue().wc_str() );
+		
+	if ( VerifyInput(text) )
+		(*m_Callback)(m_Data, text, m_Parameter );
+	else
+		wxBell();
+}
+
+
+void onTriggerParameter(void* data, std::wstring paramString, int parameter)
+{
+	TriggerBottomBar* bottomBar = static_cast<TriggerBottomBar*>(data);
+	
+	if ( bottomBar->m_Sidebar->m_Notebook->GetSelection() == 0 )
+	{
+		if ( bottomBar->m_Sidebar->m_SelectedCond == -1 )
+			return;
+		std::vector<sTriggerCondition> conditions = *bottomBar->m_Sidebar->GetSelectedItemData()->conditions;
+		std::vector<std::wstring> parameters = *conditions[bottomBar->m_Sidebar->m_SelectedCond].parameters;
+	
+		parameters[parameter] = paramString;
+		conditions[bottomBar->m_Sidebar->m_SelectedCond].parameters = parameters;
+		bottomBar->m_Sidebar->GetSelectedItemData()->conditions = conditions;
+	}
+	else
+	{
+		if ( bottomBar->m_Sidebar->m_SelectedEffect == -1 )
+			return;
+		std::vector<sTriggerEffect> effects = *bottomBar->m_Sidebar->GetSelectedItemData()->effects;
+		std::vector<std::wstring> parameters = *effects[bottomBar->m_Sidebar->m_SelectedEffect].parameters;
+	
+		parameters[parameter] = paramString;
+		effects[bottomBar->m_Sidebar->m_SelectedEffect].parameters = parameters;
+		bottomBar->m_Sidebar->GetSelectedItemData()->effects = effects;
+	}
+	bottomBar->m_Sidebar->UpdateEngineData();
+}
+
+void onGroupPush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	if ( !sidebar->m_TriggerTree->GetSelection())
+		return;
+	if ( !sidebar->IsGroupSelected() )
+		return;
+
+	wxString name = wxString::Format(L"Group %d", sidebar->m_GroupCount);
+	wxTreeItemId ID = sidebar->m_TriggerTree->AppendItem( sidebar->m_TriggerTree->GetSelection(),
+					name, -1, -1, new TriggerItemData(sidebar, std::wstring(name), true) );
+	sidebar->m_TriggerTree->EnsureVisible(ID);
+	++sidebar->m_GroupCount;
+
+	sidebar->UpdateEngineData();
+}
+
+void onTriggerPush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	wxTreeItemId ID = sidebar->m_TriggerTree->GetSelection();
+
+	if ( !sidebar->IsGroupSelected() )
+		ID = sidebar->m_TriggerTree->GetItemParent(ID);
+	
+	wxString name = wxString::Format(L"Trigger %d", sidebar->m_TriggerCount);
+	TriggerItemData* itemData = new TriggerItemData(sidebar, std::wstring(name), false);
+	itemData->group = std::wstring( sidebar->m_TriggerTree->GetItemText(ID) );
+	
+	ID = sidebar->m_TriggerTree->AppendItem(ID, name, -1, -1, itemData);
+	sidebar->m_TriggerTree->Expand( sidebar->m_TriggerTree->GetRootItem() );
+	
+	++sidebar->m_TriggerCount;
+	sidebar->m_TriggerTree->SelectItem(ID);
+	sidebar->UpdateEngineData();
+}
+
+void onDeleteTreePush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	if ( sidebar->m_TriggerTree->GetSelection() == sidebar->m_TriggerTree->GetRootItem() )
+		return;
+
+	if ( wxMessageBox( wxString(L"Are you sure you want to delete this item?"),
+					wxString(L"Caution"), wxYES_NO ) == wxYES )
+	{
+		sidebar->m_TriggerTree->Delete(sidebar->m_TriggerTree->GetSelection());
+		sidebar->m_TriggerTree->EnsureVisible( sidebar->m_TriggerTree->GetRootItem() );
+		sidebar->m_TriggerBottom->FillTriggerData();
+	}
+
+	sidebar->UpdateEngineData();
+}
+
+void onConditionPush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	if ( sidebar->IsGroupSelected() )
+		return;
+
+	sidebar->m_Notebook->SetSelection(0);
+	TriggerItemData* itemData = sidebar->GetSelectedItemData();
+	std::wstring name = std::wstring( wxString::Format(L"Condition %d", itemData->m_CondCount).wc_str() );
+	
+	if ( itemData->m_CondCount == 0 )
+		sidebar->m_SelectedCond = 0;
+	
+	++itemData->m_CondCount;
+
+	std::vector<sTriggerCondition> conditions = *itemData->conditions;
+	conditions.push_back( sTriggerCondition(name) );
+	itemData->conditions = conditions;
+	
+	long count = sidebar->m_ConditionPage->m_List->GetItemCount();
+
+	sidebar->m_ConditionPage->m_List->InsertItem(count, wxString(name.c_str()) );
+	sidebar->m_ConditionPage->m_List->EnsureVisible(count);
+	sidebar->m_ConditionPage->m_List->SetItemState(count, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+	
+	sidebar->m_TriggerBottom->ToConditionView();	//Some data is not valid, so reset
+	sidebar->m_TriggerBottom->FillConditionData();
+
+	sidebar->UpdateEngineData();
+}
+
+void onEffectPush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	if ( sidebar->IsGroupSelected() )
+		return;
+
+	sidebar->m_Notebook->SetSelection(1);
+	TriggerItemData* itemData = sidebar->GetSelectedItemData();
+	std::wstring name = std::wstring( wxString::Format(L"Effect %d", itemData->m_EffectCount).wc_str() );
+	
+	if ( itemData->m_EffectCount == 0 )
+		sidebar->m_SelectedEffect = 0;
+	++itemData->m_EffectCount;
+
+	std::vector<sTriggerEffect> effects = *itemData->effects;
+	effects.push_back( sTriggerEffect(name) );
+	itemData->effects = effects;
+	
+	long count = sidebar->m_EffectPage->m_List->GetItemCount();
+	sidebar->m_EffectPage->m_List->InsertItem(count, wxString(name.c_str()) );
+	sidebar->m_EffectPage->m_List->EnsureVisible(count);
+	sidebar->m_EffectPage->m_List->SetItemState(count, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+	
+	sidebar->m_TriggerBottom->ToEffectView();
+	sidebar->m_TriggerBottom->FillEffectData();
+
+	sidebar->UpdateEngineData();
+}
+
+void onDeleteBookPush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	wxListCtrl* list = static_cast<TriggerPage*>(sidebar->m_Notebook->GetCurrentPage())->m_List;
+	if ( !list )
+		return;
+
+	TriggerItemData* itemData = sidebar->GetSelectedItemData();
+	//Is condition? -- valid selection?
+	if ( list == sidebar->m_ConditionPage->m_List && sidebar->m_SelectedCond != -1 )
+	{
+		std::wstring text(sidebar->m_ConditionPage->m_List->GetItemText(sidebar->m_SelectedCond) ); 
+		int conditionCount = sidebar->GetConditionCount(sidebar->m_SelectedCond); 
+
+		if ( text == std::wstring(sidebar->m_LogicBlockString.wc_str()) )
+		{
+			std::vector<int> blocks = *itemData->logicBlocks;
+			if ( conditionCount == 0 )
+			{
+				blocks.erase( std::find(blocks.begin(), blocks.end(), 0) );
+				itemData->m_BlockIndices.erase( std::find( itemData->m_BlockIndices.begin(), 
+												itemData->m_BlockIndices.end(), sidebar->m_SelectedCond ) );
+			}
+			else
+			{
+				blocks.erase( std::find(blocks.begin(), blocks.end(), conditionCount) );
+				itemData->m_BlockIndices.erase( std::find( itemData->m_BlockIndices.begin(), 
+								itemData->m_BlockIndices.end(), sidebar->m_SelectedCond ) );
+			}
+			itemData->logicBlocks = blocks;
+		}
+		
+		else if ( text == std::wstring(sidebar->m_LogicBlockEndString.wc_str()) )
+		{
+			std::vector<int> blockEnds = *itemData->logicBlockEnds;
+			if ( conditionCount == 0 )
+			{
+				blockEnds.erase( std::find(blockEnds.begin(), blockEnds.end(), 0) );
+				itemData->m_BlockEndIndices.erase( std::find( itemData->m_BlockEndIndices.begin(), 
+										itemData->m_BlockEndIndices.end(), sidebar->m_SelectedCond ) );
+			}
+			else
+			{
+				blockEnds.erase( std::find(blockEnds.begin(), blockEnds.end(), conditionCount-1) );
+				itemData->m_BlockEndIndices.erase( std::find( itemData->m_BlockEndIndices.begin(), 
+							itemData->m_BlockEndIndices.end(), sidebar->m_SelectedCond ) );
+			}
+			itemData->logicBlockEnds = blockEnds;
+		}
+
+		else
+		{
+			std::vector<sTriggerCondition> conditions = *itemData->conditions;
+			conditions.erase( std::find(conditions.begin(), conditions.end(), text) );
+			itemData->conditions = conditions;
+		}
+
+		list->DeleteItem( sidebar->m_SelectedCond );
+		itemData->ResetBlockIndices();
+		
+		if ( sidebar->m_SelectedCond == list->GetItemCount() )
+			sidebar->m_SelectedCond = -1;
+		else
+			sidebar->m_TriggerBottom->FillConditionData();
+	}
+	
+	else if ( list == sidebar->m_EffectPage->m_List && sidebar->m_SelectedEffect != -1)
+	{
+		std::vector<sTriggerEffect> effects = *itemData->effects;
+		effects.erase( std::find( effects.begin(), effects.end(), std::wstring(
+							list->GetItemText(sidebar->m_SelectedEffect)) ) );
+		itemData->effects = effects;
+
+		list->DeleteItem( sidebar->m_SelectedEffect );
+		
+		if ( itemData->effects.GetSize() == 0 || sidebar->m_SelectedEffect == list->GetItemCount() )
+			sidebar->m_SelectedEffect = -1;
+		else
+			sidebar->m_TriggerBottom->FillEffectData();
+	}
+	sidebar->UpdateLists();
+	sidebar->UpdateEngineData();
+}
+
+void onLogicBlockPush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	sidebar->m_Notebook->SetSelection(0);
+
+	if ( sidebar->IsGroupSelected() )
+		return;
+	
+	int limit = sidebar->m_SelectedCond;
+	if ( sidebar->m_SelectedCond == -1 )
+		limit = sidebar->m_ConditionPage->m_List->GetItemCount()-1;
+	
+	int conditionCount = sidebar->GetConditionCount(limit);
+	if ( conditionCount == 0 )
+	{
+		sidebar->GetSelectedItemData()->AddBlock(0, 0);
+		sidebar->UpdateLists();
+		return;
+	}
+
+	sidebar->GetSelectedItemData()->AddBlock(conditionCount, limit);
+	sidebar->UpdateLists();
+	sidebar->UpdateEngineData();
+}
+
+void onBlockEndPush(void* data)
+{
+	TriggerSidebar* sidebar = static_cast<TriggerSidebar*>(data);
+	sidebar->m_Notebook->SetSelection(0);
+
+	if ( sidebar->IsGroupSelected() )
+		return;
+	
+	int limit = sidebar->m_SelectedCond;
+	if ( sidebar->m_SelectedCond == -1 )
+		limit = sidebar->m_ConditionPage->m_List->GetItemCount()-1;
+	
+	int conditionCount = sidebar->GetConditionCount(limit);
+	if ( conditionCount == 0 )
+	{
+		sidebar->GetSelectedItemData()->AddBlockEnd(0, 0);
+		sidebar->UpdateLists();
+		return;
+	}
+
+	sidebar->GetSelectedItemData()->AddBlockEnd(conditionCount-1, limit);
+	sidebar->UpdateLists();
+}
+
+
+
+TriggerSidebar::TriggerSidebar(wxWindow* sidebarContainer, wxWindow* bottomBarContainer)
+: Sidebar(sidebarContainer, bottomBarContainer), m_GroupCount(0), m_TriggerCount(0),
+									m_SelectedCond(-1), m_SelectedEffect(-1)
+{
+	m_TriggerBottom = new TriggerBottomBar(this, bottomBarContainer);
+	m_BottomBar = m_TriggerBottom;
+
+	m_TriggerTree = new TriggerTreeCtrl(this, wxID_ANY, wxDefaultPosition,
+						wxSize(140, 220), wxTR_HAS_BUTTONS | wxTR_EDIT_LABELS);
+	m_TriggerTree->AddRoot(L"Triggers", -1, -1, new TriggerItemData(this, L"Triggers", true));
+	m_TriggerTree->SelectItem( m_TriggerTree->GetRootItem() );
+	m_TriggerTree->Expand( m_TriggerTree->GetRootItem() );
+
+	
+	wxBoxSizer* hHolder = new wxBoxSizer(wxHORIZONTAL);
+	wxBoxSizer* vHolder = new wxBoxSizer(wxVERTICAL);
+	wxBoxSizer* vButtons = new wxBoxSizer(wxVERTICAL);
+
+	ActionButton* trigButton = new ActionButton( this, L"Trigger", &onTriggerPush,
+									this, wxSize(50, 20) );
+	ActionButton* groupButton = new ActionButton( this, L"Group", &onGroupPush,
+											this, wxSize(50, 20) );
+	ActionButton* deleteButton = new ActionButton( this, L"Delete", &onDeleteTreePush,
+											this, wxSize(50, 20) );
+
+	ActionButton* conditionButton = new ActionButton( this, L"Condition",
+								&onConditionPush, this, wxSize(54, 20) );
+	ActionButton* effectButton = new ActionButton( this, L"Effect",
+								&onEffectPush, this, wxSize(50, 20) );
+	ActionButton* bookDelete = new ActionButton( this, L"Delete",
+								&onDeleteBookPush, this, wxSize(50, 20) );
+	ActionButton* logicBlock = new ActionButton( this, L"Block",
+								&onLogicBlockPush, this, wxSize(50, 20) );
+	ActionButton* logicBlockEnd = new ActionButton( this, L"Block End",
+								&onBlockEndPush, this, wxSize(50, 20) );
+
+
+	m_LogicBlockString = wxString(L"--------------------");
+	m_LogicBlockEndString = wxString(L"===========");
+	wxStaticText* bottomTitle = new wxStaticText( this, wxID_ANY, _T("Conditions and Effects") );
+	m_Notebook = new wxNotebook(this, wxID_ANY, wxDefaultPosition,
+							wxSize(132, 210), wxNB_TOP);
+
+	m_ConditionPage = new TriggerPage(m_Notebook, this, ID_CondList, wxString(L"Conditions"), true);
+	m_EffectPage = new TriggerPage(m_Notebook, this, ID_EffectList, wxString(L"Effects"), false);
+
+	m_Notebook->AddPage( m_ConditionPage, _T("Conditions") );
+	m_Notebook->AddPage( m_EffectPage, _T("Effects") );
+	m_Notebook->SetPageSize(wxSize(130, 240));
+
+	vButtons->Add(trigButton);
+	vButtons->Add(groupButton);
+	vButtons->Add(deleteButton);
+	vButtons->Add(conditionButton, 0, wxTOP, 190);
+	vButtons->Add(effectButton);
+	vButtons->Add(bookDelete);
+	vButtons->Add(logicBlock);
+	vButtons->Add(logicBlockEnd);
+
+	vHolder->Add(m_TriggerTree, 0, wxTOP, 15);
+	vHolder->Add(bottomTitle, 0, wxALIGN_CENTER | wxTOP, 5);
+	vHolder->Add(m_Notebook, 0, wxTOP, 5 );
+
+	hHolder->Add(vHolder);
+	hHolder->Add(vButtons, 0, wxALIGN_CENTER);
+	m_MainSizer->Add(hHolder);
+}
+
+int TriggerSidebar::GetConditionCount(int limit)
+{
+	int conditionCount = 0;
+	wxListCtrl* list = m_ConditionPage->m_List;
+	for ( int i = 0; i <= limit; ++i )
+	{
+		if ( list->GetItemText(i) != m_LogicBlockString && list->GetItemText(i) != m_LogicBlockEndString)
+		{
+			++conditionCount;
+		}
+	}
+	return conditionCount;
+}
+void TriggerSidebar::OnFirstDisplay()
+{
+	qGetTriggerData dataQuery;
+	dataQuery.Post();
+	m_TriggerBottom->SetSpecs(*dataQuery.conditions, *dataQuery.effects);
+	
+	//Add all loaded triggers to the tree
+	const std::vector<sTriggerGroup> triggerGroups = *dataQuery.groups;
+	std::vector<sTriggerGroup>::const_iterator it = std::find( triggerGroups.begin(), 
+								triggerGroups.end(), std::wstring(L"Triggers") );
+
+	if ( it != triggerGroups.end() )
+	{
+		wxTreeItemId invalid;	
+		AddGroupTree(*it, invalid);
+		m_TriggerTree->Expand( m_TriggerTree->GetRootItem() );
+	}
+}
+
+void TriggerSidebar::AddGroupTree(const sTriggerGroup& group, wxTreeItemId parent)
+{
+	wxTreeItemId newID;
+	wxString text( (*group.name).c_str() );
+
+	//Make sure root item doesn't already exist
+	if ( !parent && !m_TriggerTree->GetRootItem() )
+		newID = m_TriggerTree->AddRoot(text, -1, -1, new TriggerItemData(this, *group.name, true));
+	else if ( parent )
+		newID = m_TriggerTree->AppendItem(parent, text);
+	else
+		newID = m_TriggerTree->GetRootItem();
+	
+	const std::vector<sTrigger> triggerBuf = *group.triggers;
+	const std::vector<std::wstring> groupBuf = *group.children;
+	
+	for ( size_t i = 0; i < group.children.GetSize(); ++i )
+		AddGroupTree( *std::find(m_TriggerGroups.begin(), m_TriggerGroups.end(), groupBuf[i]), newID );
+	for ( size_t i = 0; i < group.triggers.GetSize(); ++i )
+	{
+		std::wstring trigName = *triggerBuf[i].name;
+		
+		//Make triggers start where user last left off
+		if ( trigName.find(L"Trigger ") == 0 )
+		{
+			trigName.erase(0, 8);	//remove "Trigger "
+			std::wstringstream toInt(trigName);
+			size_t convert;
+			toInt >> convert;
+			++convert;
+
+			if ( !toInt.fail() )
+			{
+				if ( convert > m_TriggerCount )
+					m_TriggerCount = convert;
+			}
+		}
+
+		m_TriggerTree->AppendItem( newID, wxString( triggerBuf[i].name.c_str() ), -1, -1, 
+										new TriggerItemData(this, triggerBuf[i], false) );
+	}
+}
+
+
+void TriggerSidebar::onPageChange(wxNotebookEvent& evt)
+{
+	if ( evt.GetSelection() == 0 )
+	{
+		m_TriggerBottom->ToConditionView();
+		if ( m_SelectedCond != -1 )
+			m_TriggerBottom->FillConditionData();
+		return;
+	}
+	m_TriggerBottom->ToEffectView();
+	if ( m_SelectedEffect != -1 )
+		m_TriggerBottom->FillEffectData();
+}
+		
+void TriggerSidebar::onTreeDrag(wxTreeEvent& evt)
+{
+	//evt.Allow();
+}
+
+void TriggerSidebar::onTreeNameChange(wxTreeEvent& evt)
+{
+	ToDerived( m_TriggerTree->GetItemData(evt.GetItem()) )->name = std::wstring(
+														evt.GetLabel().wc_str());
+	UpdateEngineData();
+}
+
+void TriggerSidebar::onTreeSelChange(wxTreeEvent& evt)
+{
+	//Prevent other triggers from trying to use previous data
+	m_SelectedCond = -1;
+	m_SelectedEffect = -1;
+
+	if ( evt.GetItem() == m_TriggerTree->GetRootItem() )
+	{
+		m_TriggerBottom->ToNoView();
+		return;
+	}
+	
+	if ( m_TriggerBottom->GetDependentStatus() != TriggerBottomBar::TRIGGER_VIEW )
+		m_TriggerBottom->ToTriggerView();
+	m_TriggerBottom->FillTriggerData();
+	
+	UpdateLists();
+}
+void TriggerSidebar::UpdateLists()
+{
+	TriggerItemData* data = GetSelectedItemData();
+	m_ConditionPage->m_List->Freeze();
+	m_ConditionPage->m_List->DeleteAllItems();
+	m_EffectPage->m_List->Freeze();
+	m_EffectPage->m_List->DeleteAllItems();
+	
+	const Shareable<sTriggerCondition>* conditions = data->conditions.GetBuffer();
+	for ( size_t i = 0; i < data->conditions.GetSize(); ++i )
+	{
+		m_ConditionPage->m_List->InsertItem( m_ConditionPage->m_List->
+						GetItemCount(), wxString(conditions[i]->name.c_str()) );
+	}
+	
+	const Shareable<sTriggerEffect>* effects = data->effects.GetBuffer();
+	for ( size_t i = 0; i < data->effects.GetSize(); ++i )
+	{
+		m_EffectPage->m_List->InsertItem(m_EffectPage->m_List->GetItemCount(),
+										wxString(effects[i]->name.c_str()) );
+	}
+	
+	//These must be merged and sorted because adding them out-of-order screws up the list 
+	std::list<LogicBlockHelper> sortedBlocks;
+	std::list<int> blocks = data->m_BlockIndices, blockEnds = data->m_BlockEndIndices;
+	
+	for ( std::list<int>::iterator it = blocks.begin(); it != blocks.end(); ++it )
+		sortedBlocks.push_back( LogicBlockHelper(*it, false) );
+	for ( std::list<int>::iterator it = blockEnds.begin(); it != blockEnds.end(); ++it )
+		sortedBlocks.push_back( LogicBlockHelper(*it, true) );
+
+	sortedBlocks.sort();
+	for ( std::list<LogicBlockHelper>::iterator it = sortedBlocks.begin(); it != sortedBlocks.end(); ++it )
+	{
+		if ( it->end )
+			m_ConditionPage->m_List->InsertItem(it->index, m_LogicBlockEndString);
+		else
+			m_ConditionPage->m_List->InsertItem(it->index, m_LogicBlockString);
+	}
+
+	m_ConditionPage->m_List->Thaw();
+	m_EffectPage->m_List->Thaw();
+}
+
+void TriggerSidebar::onCondSelect(wxListEvent& evt)
+{
+	m_SelectedCond = evt.GetIndex();
+	//if ( m_TriggerBottom->GetDependentStatus() != TriggerBottomBar::CONDITION_VIEW )
+		m_TriggerBottom->ToConditionView();
+	m_TriggerBottom->FillConditionData();
+}
+void TriggerSidebar::onEffectSelect(wxListEvent& evt)
+{
+	m_SelectedEffect = evt.GetIndex();
+	//if ( m_TriggerBottom->GetDependentStatus() != TriggerBottomBar::EFFECT_VIEW )
+		m_TriggerBottom->ToEffectView();
+	m_TriggerBottom->FillEffectData();
+}
+
+bool TriggerSidebar::IsGroupSelected()
+{
+	if ( ToDerived( m_TriggerTree->GetItemData(m_TriggerTree->GetSelection()) )->m_Group )
+		return true;
+	return false;
+}
+
+sTrigger TriggerSidebar::CreateTrigger(TriggerItemData* data)
+{
+	sTrigger trigger;
+	
+	trigger.active = data->active;
+	trigger.group = data->group;
+	trigger.maxRuns = data->maxRuns;
+	trigger.name = data->name;
+	trigger.timeValue = data->timeValue;
+	
+	trigger.logicBlockEnds = data->logicBlockEnds;
+	trigger.logicBlocks = data->logicBlocks;
+	trigger.conditions = data->conditions;
+	trigger.effects = data->effects;
+	trigger.logicNots = data->logicNots;
+
+	return trigger;
+}
+
+void TriggerSidebar::CreateGroup(std::vector<sTriggerGroup>& groupList, sTriggerGroup& parent, wxTreeItemId index)
+{
+	wxTreeItemIdValue cookie;
+	std::vector<sTrigger> triggers;
+	sTriggerGroup group( std::wstring(m_TriggerTree->GetItemText(index)) );
+	group.parentName = parent.name;
+	
+	//Add this group to parent's child group
+	std::vector<std::wstring> parentChildren = *parent.children;
+	parentChildren.push_back(*group.parentName);
+	parent.children = parentChildren;
+
+	for ( wxTreeItemId ID = m_TriggerTree->GetFirstChild(index, cookie); ID.IsOk(); 
+							ID = m_TriggerTree->GetNextChild(index, cookie) )
+	{
+		TriggerItemData* itemData = ToDerived( m_TriggerTree->GetItemData(ID) );
+		if ( itemData->m_Group )
+			CreateGroup(groupList, group, ID);
+		else
+			triggers.push_back( CreateTrigger(itemData) );
+	}
+
+	group.triggers = triggers;
+	groupList.push_back(group);
+}
+
+void TriggerSidebar::UpdateEngineData()
+{
+	wxTreeItemIdValue cookie;
+	wxTreeItemId root = m_TriggerTree->GetRootItem();
+	
+	//Find all root groups
+	std::vector<sTriggerGroup> groups;
+	std::vector<sTrigger> triggers;
+	sTriggerGroup rootGroup(L"Triggers");
+
+	for ( wxTreeItemId ID = m_TriggerTree->GetFirstChild(root, cookie); ID.IsOk(); 
+							ID = m_TriggerTree->GetNextChild(root, cookie) )
+	{
+		TriggerItemData* itemData = ToDerived( m_TriggerTree->GetItemData(ID) );
+		if ( itemData->m_Group )
+			CreateGroup(groups, rootGroup, ID);
+		else
+			triggers.push_back( CreateTrigger(itemData) );
+	}
+	
+	rootGroup.triggers = triggers;
+	groups.push_back(rootGroup);
+	POST_COMMAND( SetAllTriggers, (groups) );
+}
+TriggerItemData* TriggerSidebar::ToDerived(wxTreeItemData* data)
+{
+	return ( static_cast<TriggerItemData*>(data) );
+}
+TriggerItemData* TriggerSidebar::GetSelectedItemData()
+{
+	if ( !m_TriggerTree->GetSelection() )
+		m_TriggerTree->SelectItem(m_TriggerTree->GetRootItem());
+	return ToDerived( m_TriggerTree->GetItemData(m_TriggerTree->GetSelection()) );
+	
+}
+
Index: ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Trigger/Trigger.h
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Trigger/Trigger.h	(nonexistent)
+++ ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Trigger/Trigger.h	(revision 4648)
@@ -0,0 +1,80 @@
+/* Andrew Decker, a.k.a pyrolink
+   Contact ajdecker1022@msn.com
+   Desc: interface for creation and editing of triggers.  Interprets
+   XML specifications then uses this to construct layout.
+*/
+
+#include "../Common/Sidebar.h"
+#include "GameInterface/Messages.h"
+
+class TriggerItemData;
+class TriggerTreeCtrl;
+class TriggerBottomBar;
+class TriggerPage;
+class wxTreeItemId;
+
+class TriggerSidebar : public Sidebar
+{
+public:
+	enum { ID_CondList, ID_EffectList };
+
+	TriggerSidebar(wxWindow* sidebarContainer, wxWindow* bottomBarContainer);
+
+	void onTreeDrag(wxTreeEvent& evt);
+	void onTreeNameChange(wxTreeEvent& evt);
+	//void onTreeDelete(wxTreeEvent& evt);
+	void onTreeSelChange(wxTreeEvent& evt);
+	void onTreeCollapse(wxTreeEvent& evt);
+	void onListSelect(wxListEvent& evt);
+	void onEffectSelect(wxListEvent& evt);
+	void onCondSelect(wxListEvent& evt);
+	void onPageChange(wxNotebookEvent& evt);
+
+	bool IsGroupSelected();
+	TriggerItemData* ToDerived(wxTreeItemData* data);
+	TriggerItemData* GetSelectedItemData();
+	
+	//Finds condition number (index+1) of m_SelectedCond [needed because of logic blocks]
+	int GetConditionCount(int limit);
+	void UpdateLists();
+	void UpdateEngineData();
+
+	//AtlasMessage::sTriggerList m_TriggerList;
+
+	TriggerBottomBar* m_TriggerBottom;
+	TriggerTreeCtrl* m_TriggerTree;
+	TriggerPage* m_ConditionPage, *m_EffectPage;
+	wxNotebook* m_Notebook;
+
+	size_t m_TriggerCount, m_GroupCount;
+	long m_SelectedCond, m_SelectedEffect, m_SelectedCondIndex, m_SelectedEffectIndex;
+	wxString m_LogicBlockString, m_LogicBlockEndString;
+
+protected:
+	virtual void OnFirstDisplay();
+
+private:
+	struct copyIfRootChild
+	{
+		copyIfRootChild(std::vector<AtlasMessage::sTriggerGroup>& groupList) : m_groupList(groupList) {}
+		void operator() ( const AtlasMessage::sTriggerGroup& group )
+		{ 
+			if ( *group.parentName == std::wstring(L"Triggers") )
+				m_groupList.push_back(group);
+		}
+	private:
+		std::vector<AtlasMessage::sTriggerGroup>& m_groupList;
+	};
+	
+	void AddGroupTree(const AtlasMessage::sTriggerGroup& group, wxTreeItemId parent);
+	
+	void CreateGroup(std::vector<AtlasMessage::sTriggerGroup>& groupList, 
+					AtlasMessage::sTriggerGroup& parent, wxTreeItemId index);
+
+	AtlasMessage::sTrigger CreateTrigger(TriggerItemData* data);
+
+	std::vector<AtlasMessage::sTriggerGroup> m_TriggerGroups;
+
+	DECLARE_EVENT_TABLE();
+};
+
Index: ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Environment/LightControl.cpp
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Environment/LightControl.cpp	(revision 4647)
+++ ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Environment/LightControl.cpp	(revision 4648)
@@ -1,156 +1,156 @@
 #include "stdafx.h"
 
 #include <algorithm>
 
 #include "LightControl.h"
 
 using AtlasMessage::Shareable;
 
 class LightSphere : public wxControl
 {
 public:
 
 	LightSphere(wxWindow* parent, const wxSize& size, LightControl* lightControl)
 		: wxControl(parent, wxID_ANY, wxDefaultPosition, size),
 		m_LightControl(lightControl)
 	{
 	}
 
 	void OnPaint(wxPaintEvent& WXUNUSED(event))
 	{
 		// Draw a lit 3D sphere:
 
 		int w = GetClientSize().GetWidth();
 		int h = GetClientSize().GetHeight();
 
 		float lx = sin(-theta)*cos(phi);
 		float ly = cos(-theta)*cos(phi);
 		float lz = sin(phi);
 
 		wxImage img (w, h);
 		unsigned char* imgData = img.GetData();
 
 		for (int y = 0; y < h; ++y)
 		{
 			for (int x = 0; x < w; ++x)
 			{
 				// Calculate normal vector of sphere (radius 1)
 				float nx = 2*x / (float)(w-1) - 1; // [-1, 1]
 				float ny = 2*y / (float)(h-1) - 1;
 				float nz2 = 1 - nx*nx - ny*ny;
 				if (nz2 >= 0.f)
 				{
 					float nz = sqrt(nz2);
 
 					// Get reflection vector (r) of camera vector (c) in n
 					float cx = 0;
 					float cy = 0;
 					float cz = 1; // (camera is infinitely far upwards)
 					float ndotc = nz;
 					float rx = -cx + nx*(2*ndotc);
 					float ry = -cy + ny*(2*ndotc);
 					float rz = -cz + nz*(2*ndotc);
 
 					float ndotl = nx*lx + ny*ly + nz*lz;
 					float rdotl = rx*lx + ry*ly + rz*lz;
 
 					int diffuse = (int)std::max(0.f, ndotl*128.f);
-					int specular = (int)std::min(255., 64.f*pow(std::max(0.f, rdotl), 16.f));
+					int specular = (int)std::min(255.f, 64.f*pow(std::max(0.f, rdotl), 16.f));
 
 					imgData[0] = std::min(64+diffuse+specular, 255);
 					imgData[1] = std::min(48+diffuse+specular, 255);
 					imgData[2] = std::min(48+diffuse+specular, 255);
 				}
 				else
 				{
 					imgData[0] = 0;
 					imgData[1] = 0;
 					imgData[2] = 0;
 				}
 				imgData += 3;
 			}
 		}
 
 		wxPaintDC dc(this);
 		#if OS_WIN
 		dc.DrawBitmap(wxBitmap(img, dc), 0, 0);
 		#else
 		dc.DrawBitmap(wxBitmap(img), 0, 0);
 		#endif
 	}
 
 	void OnMouse(wxMouseEvent& event)
 	{
 		if (event.LeftIsDown())
 		{
 			int x = event.GetX();
 			int y = event.GetY();
 			int w = GetClientSize().GetWidth();
 			int h = GetClientSize().GetHeight();
 
 			float mx = 2*x / (float)(w-1) - 1; // [-1, 1]
 			float my = 2*y / (float)(h-1) - 1;
 			float mz2 = 1 - mx*mx - my*my;
 			if (mz2 >= 0.f)
 			{
  				//float mz = sqrt(mz2);
  				//phi = asin(mz);
 
 				// ^^ That's giving the height of the sphere at that point, so it's
 				// matching the point the user clicked on - but that's quite inconvenient
 				// when you want to move the sun near the horizon. So just make up
 				// some formula that gives a slightly nicer-feeling result:
 				phi = asin(mz2*mz2);
 
 				theta = -atan2(mx, my);
 			}
 			else
 			{
 				theta = -atan2(mx, my);
 				phi = 0;
 			}
 
 			Refresh(false);
 			m_LightControl->NotifyOtherObservers();
 		}
 	}
 
 	float theta, phi;
 	LightControl* m_LightControl;
 
 	DECLARE_EVENT_TABLE();
 };
 
 BEGIN_EVENT_TABLE(LightSphere, wxControl)
 	EVT_PAINT(LightSphere::OnPaint)
 	EVT_MOTION(LightSphere::OnMouse)
 	EVT_LEFT_DOWN(LightSphere::OnMouse)
 END_EVENT_TABLE()
 
 LightControl::LightControl(wxWindow* parent, const wxSize& size, Observable<AtlasMessage::sEnvironmentSettings>& environment)
 : wxPanel(parent), m_Environment(environment)
 {
 	wxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
 	sizer->SetMinSize(size);
 	m_Sphere = new LightSphere(this, size, this);
 	m_Sphere->theta = environment.sunrotation;
 	m_Sphere->phi = environment.sunelevation;
 	sizer->Add(m_Sphere, wxSizerFlags().Expand().Proportion(1));
 	SetSizer(sizer);
 
 	m_Conn = environment.RegisterObserver(0, &LightControl::OnSettingsChange, this);
 }
 
 void LightControl::OnSettingsChange(const AtlasMessage::sEnvironmentSettings& settings)
 {
 	m_Sphere->theta = settings.sunrotation;
 	m_Sphere->phi = settings.sunelevation;
 	m_Sphere->Refresh(false);
 }
 
 void LightControl::NotifyOtherObservers()
 {
 	m_Environment.sunrotation = m_Sphere->theta;
 	m_Environment.sunelevation = m_Sphere->phi;
 	m_Environment.NotifyObserversExcept(m_Conn);
 }
Index: ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Cinematic/Cinematic.cpp
===================================================================
--- ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Cinematic/Cinematic.cpp	(revision 4647)
+++ ps/trunk/source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Cinematic/Cinematic.cpp	(revision 4648)
@@ -1,1539 +1,1538 @@
 #include "stdafx.h"
 
 #include "Cinematic.h"
 
 #include "GameInterface/Messages.h"
 #include "CustomControls/Buttons/ActionButton.h"
 //#include "CustomControls/Buttons/FloatingSpinCtrl.h"
 #include "General/Datafile.h"
 #include "ScenarioEditor/Tools/Common/Tools.h"
 #include "HighResTimer/HighResTimer.h"
 
 #include "wx/spinctrl.h"
 #include "wx/filename.h"
 #include "wx/wfstream.h"
 
 #include <sstream>
 
 using namespace AtlasMessage;
 
 #define CINEMA_EPSILON .032f
 
 struct eCinemaButton 
 { 
 	enum { 
 		previous/*, rewind, reverse*/, stop, 
 		play, pause, /*forward,*/ next }; 
 };
 
 float CinemaTextFloat(wxTextCtrl&, size_t, float, float, float);
 
 class CinematicBottomBar : public wxPanel
 {
 	friend void TimescaleSpin(void*);
 public:
 	CinematicBottomBar(wxWindow* parent, CinematicSidebar* side);
 	void AddLists(CinematicSidebar* side, TrackListCtrl* tracks,
 				PathListCtrl* paths, NodeListCtrl* nodes);
 	void OnText(wxCommandEvent& WXUNUSED(event))
 	{
 		m_OldScale = CinemaTextFloat(*m_TimeText, 2, -5.f, 5.f, m_OldScale);
 		m_Sidebar->UpdateTrack(m_Name->GetLineText(0).wc_str(), m_OldScale);
 	}
 	void Update(std::wstring name, float scale)
 	{
 		m_Name->SetValue( wxString(name.c_str()) );
 		m_TimeText->SetValue( wxString::Format(L"%f", scale) );
 		if ( m_OldTrackIndex != m_Sidebar->GetSelectedTrack() )
 		{
 			m_OldTrackIndex = m_Sidebar->GetSelectedTrack();
 			m_OldScale = 0.f;
 		}
 		CinemaTextFloat(*m_TimeText, 2, -5.f, 5.f, 0.f);
 	}
 private:
 	wxStaticBoxSizer* m_Sizer;
 	CinematicSidebar* m_Sidebar;
 	wxTextCtrl* m_Name, *m_TimeText;
 	float m_OldScale;
 	ssize_t m_OldTrackIndex;
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(CinematicBottomBar, wxPanel)
 EVT_TEXT_ENTER(wxID_ANY, CinematicBottomBar::OnText)
 END_EVENT_TABLE()
 	
 /////////////////////////////////////////////////////////////////////
 class TrackListCtrl : public wxListCtrl
 {
 public:
 	TrackListCtrl(wxWindow* parent, CinematicSidebar* side)
 		: wxListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT|/*wxLC_EDIT_LABELS|*/wxLC_SINGLE_SEL),
 		m_Sidebar(side)
 	{
 		InsertColumn(0, _("Tracks"), wxLIST_FORMAT_LEFT, 180);
 	}
 
 	void OnSelect(wxListEvent& event)
 	{
 		m_Sidebar->SelectTrack(event.GetIndex());
 		m_Sidebar->UpdateTexts();
 	}
 	void AddTrack()
 	{
 		std::wstringstream message;
 		message << "Track " << GetItemCount();
 		std::wstring msgString = message.str();
 		wxString fmt( msgString.c_str(), msgString.length() );
 		InsertItem(GetItemCount(), fmt);
 		
 		qGetCameraInfo qry;
 		qry.Post();
 		sCameraInfo info = qry.info;
-		m_Sidebar->AddTrack(info.rX, info.rY, info.rZ, msgString, 
-													GetItemCount()-1);
+		m_Sidebar->AddTrack(info.rX, info.rY, info.rZ, msgString, GetItemCount()-1);
 	}
 	void DeleteTrack()
 	{
 		DeleteItem(m_Sidebar->GetSelectedTrack());
 		m_Sidebar->DeleteTrack();
 	}
 
 private:
 	CinematicSidebar* m_Sidebar;
 
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(TrackListCtrl, wxListCtrl)
 	EVT_LIST_ITEM_SELECTED(wxID_ANY, TrackListCtrl::OnSelect)
 END_EVENT_TABLE()
 
 class PathListCtrl : public wxListCtrl
 {
 public:
 	PathListCtrl(wxWindow* parent, CinematicSidebar* side)
 		: wxListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT|wxLC_SINGLE_SEL),
 		m_Sidebar(side)
 	{
 		InsertColumn(0, _("Paths"), wxLIST_FORMAT_LEFT, 180);
 	}
 
 	void OnSelect(wxListEvent& event)
 	{
 		m_Sidebar->SelectPath(event.GetIndex());
 		m_Sidebar->UpdateTexts();
 	}
 	void AddPath()
 	{
 		std::wstringstream message;
 		message << "Path " << GetItemCount();
 		std::wstring msgString = message.str();
 		wxString fmt( msgString.c_str(), msgString.length() );
 		InsertItem(GetItemCount(), fmt);
 
 		qGetCameraInfo qry;
 		qry.Post();
 		sCameraInfo info = qry.info;
 		m_Sidebar->AddPath(info.rX, info.rY, info.rZ, GetItemCount()-1);
 	}
 	void DeletePath()
 	{
 		DeleteItem(m_Sidebar->GetSelectedPath());
 		m_Sidebar->DeletePath();
 	}
 	void UpdatePath()
 	{
 		qGetCameraInfo qry;
 		qry.Post();
 		sCameraInfo info = qry.info;
 		m_Sidebar->UpdatePath(info.rX, info.rY, info.rZ);
 	}
 
 private:
 	CinematicSidebar* m_Sidebar;
 	
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(PathListCtrl, wxListCtrl)
 	EVT_LIST_ITEM_SELECTED(wxID_ANY, PathListCtrl::OnSelect)
 END_EVENT_TABLE()
 
 class NodeListCtrl : public wxListCtrl
 {
 public:
 	NodeListCtrl(wxWindow* parent, CinematicSidebar* side)
 		: wxListCtrl(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT|wxLC_SINGLE_SEL),
 		m_Sidebar(side)
 	{
 		InsertColumn(0, _("Nodes"), wxLIST_FORMAT_LEFT, 180);
 	}
 	void OnSelect(wxListEvent& event)
 	{
 		m_Sidebar->SelectSplineNode(event.GetIndex(), GetItemCount());
 		m_Sidebar->UpdateTexts();
 	}	
 	void AddNode()
 	{	
 		std::wstringstream message;
 		message << "Node " << GetItemCount();
 		std::wstring msgString = message.str();
 		wxString fmt( msgString.c_str(), msgString.length() );
 		InsertItem(GetItemCount(), fmt);
 
 		qGetCameraInfo qry;
 		qry.Post();
 		sCameraInfo info = qry.info;
 		m_Sidebar->AddNode(info.pX, info.pY, info.pZ, GetItemCount()-1);
 	}
 	void DeleteNode()
 	{
 		DeleteItem(m_Sidebar->GetSelectedNode());
 		m_Sidebar->DeleteNode();
 	}
 	void UpdateNode()
 	{
 		qGetCameraInfo qry;
 		qry.Post();
 		sCameraInfo info = qry.info;
 		m_Sidebar->UpdateNode(info.pX, info.pY, info.pZ);
 	}
 	void GotoNode()
 	{
 		m_Sidebar->GotoNode();
 	}
 private:
 	CinematicSidebar* m_Sidebar;
 	
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(NodeListCtrl, wxListCtrl)
 	EVT_LIST_ITEM_SELECTED(wxID_ANY, NodeListCtrl::OnSelect)
 END_EVENT_TABLE()
 
 /////////////////////////////////////////////////////////////////
 
 void CinemaTrackAdd(void* data)
 {
 	TrackListCtrl* list = reinterpret_cast<TrackListCtrl*>(data);
 	list->AddTrack();
 }
 void CinemaPathAdd(void* data)
 {
 	PathListCtrl* list = reinterpret_cast<PathListCtrl*>(data);
 	list->AddPath();
 }
 void CinemaNodeAdd(void* data)
 {
 	NodeListCtrl* list = reinterpret_cast<NodeListCtrl*>(data);
 	list->AddNode();
 }
 void CinemaTrackDel(void* data)
 {
 	TrackListCtrl* list = reinterpret_cast<TrackListCtrl*>(data);
 	list->DeleteTrack();
 }
 void CinemaPathDel(void* data)
 {
 	PathListCtrl* list = reinterpret_cast<PathListCtrl*>(data);
 	list->DeletePath();
 }
 void CinemaNodeDel(void* data)
 {
 	NodeListCtrl* list = reinterpret_cast<NodeListCtrl*>(data);
 	list->DeleteNode();
 }
 
 void CinemaPathUpdate(void* data)
 {
 	PathListCtrl* list = reinterpret_cast<PathListCtrl*>(data);
 	list->UpdatePath();
 }
 void CinemaNodeUpdate(void* data)
 {
 	NodeListCtrl* list = reinterpret_cast<NodeListCtrl*>(data);
 	list->UpdateNode();
 }
 void CinemaNodeGoto(void* data)
 {
 	NodeListCtrl* list = reinterpret_cast<NodeListCtrl*>(data);
 	list->GotoNode();
 }
 
 ///////////////////////////////////////////////////////////
 
 void CinemaStringToFloat(wxString& text, size_t decimals)
 {
 	size_t i, j;
 	if ( (i = text.find(L".")) == wxString::npos)
 	{
 		text.Append('.');
 		text.Append('0', decimals);
 	}
 	else
 	{
 		j = text.find_last_not_of(L"0");
 		text.Remove(j+1);
 		//Too many numbers
 		if ( j - i > decimals )
 			text.Remove(i+decimals+1);
 		else
 			text.Append('0', decimals - (j-i));
 	}
 }
 float CinemaTextFloat(wxTextCtrl& ctrl, size_t decimals, float min, 
 											float max, float oldval)
 {
 	wxString text = ctrl.GetLineText(0);
 	double val;
 	if ( !text.ToDouble(&val) )
 	{
 		wxBell();
 		val = oldval;
 		text = wxString::Format(L"%f", val);
 		CinemaStringToFloat(text, decimals);
 	}
 	
 	if ( val > max )
 		val = oldval;
 	else if ( val < min )
 		val = oldval;
 	text = wxString::Format(L"%f", val);
 	CinemaStringToFloat(text, decimals);
 	ctrl.SetValue(text);
 	return val;
 	
 }
 void WrapCinemaPath(sCinemaPath& path)
 {
 	if ( path.x > 360 )
 		path.x = 360;
 	else if ( path.x < -360 )
 		path.x = -360;
 	
 	if ( path.y > 360 )
 		path.y = 360;
 	else if ( path.y < -360 )
 		path.y = -360;
 	
 	if ( path.y > 360 )
 		path.z = 360;
 	else if ( path.x < -360 )
 		path.z = -360;
 }
 /////////////////////////////////////////////////////////////
 
 class CinemaSpinnerBox : public wxPanel
 {
 public:
 	enum {  TrackX_ID, TrackY_ID, TrackZ_ID,
 			PathX_ID, PathY_ID, PathZ_ID,
 			NodeX_ID, NodeY_ID, NodeZ_ID };
 	CinemaSpinnerBox(wxWindow* parent, CinematicSidebar* side) 
 		: wxPanel(parent), m_OldT(0), m_OldIndex(0)
 	{
 		m_MainSizer = new wxBoxSizer(wxHORIZONTAL);
 		SetSizer(m_MainSizer);
 		m_Sidebar = side;
 		
 		wxStaticBoxSizer* tracks = new wxStaticBoxSizer(wxHORIZONTAL,
 											this, _T("Start Rotation"));
 		wxStaticBoxSizer* paths = new wxStaticBoxSizer(wxHORIZONTAL,
 												this, _T("Rotation"));
 		wxStaticBoxSizer* nodes = new wxStaticBoxSizer(wxHORIZONTAL,
 												this, _T("Position")); 
 
 			m_TrackX = new wxSpinCtrl(this, TrackX_ID, _T("x"), 
 		wxDefaultPosition, wxSize(50, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 			m_TrackY = new wxSpinCtrl(this, TrackY_ID, _T("y"), 
 		wxDefaultPosition, wxSize(50, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 			m_TrackZ = new wxSpinCtrl(this, TrackZ_ID, _T("z"), 
 		wxDefaultPosition, wxSize(50, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 
 			m_PathX = new wxSpinCtrl(this, PathX_ID, _T("x"), 
 		wxDefaultPosition, wxSize(50, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 			m_PathY = new wxSpinCtrl(this, PathY_ID, _T("y"), 
 		wxDefaultPosition, wxSize(50, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 			m_PathZ = new wxSpinCtrl(this, PathZ_ID, _T("z"), 
 		wxDefaultPosition, wxSize(50, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 		
 			m_NodeX = new wxSpinCtrl(this, NodeX_ID, _T("x"), 
 		wxDefaultPosition, wxSize(55, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 			m_NodeY = new wxSpinCtrl(this, NodeY_ID, _T("y"), 
 		wxDefaultPosition, wxSize(55, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 			m_NodeZ = new wxSpinCtrl(this, NodeZ_ID, _T("z"), 
 		wxDefaultPosition, wxSize(55, 15), wxSP_ARROW_KEYS|wxSP_WRAP );
 			m_NodeT = new wxTextCtrl(this, wxID_ANY, _T("0.00"),
 		wxDefaultPosition, wxSize(55, 15), wxTE_PROCESS_ENTER );
 			
 		m_TrackX->SetRange(-360, 360);
 		m_TrackY->SetRange(-360, 360);
 		m_TrackZ->SetRange(-360, 360);
 		m_PathX->SetRange(-360, 360);
 		m_PathY->SetRange(-360, 360);
 		m_PathZ->SetRange(-360, 360);
 		m_NodeX->SetRange(-1000, 1000);	//TODO make these more exact
 		m_NodeY->SetRange(-200, 600);
 		m_NodeZ->SetRange(-1000, 1000);
 		
 		tracks->Add(m_TrackX);
 		tracks->Add(m_TrackY);
 		tracks->Add(m_TrackZ);
 		paths->Add(m_PathX);
 		paths->Add(m_PathY);
 		paths->Add(m_PathZ);
 		nodes->Add(m_NodeX);
 		nodes->Add(m_NodeY);
 		nodes->Add(m_NodeZ);
 		nodes->Add(m_NodeT);
 		
 		m_MainSizer->Add(tracks);
 		m_MainSizer->Add(paths);
 		m_MainSizer->Add(nodes);
 	}
 
 	void OnTrackPush(wxSpinEvent& WXUNUSED(event))
 	{
 		m_Sidebar->UpdateTrack( m_TrackX->GetValue(), 
 				m_TrackY->GetValue(), m_TrackZ->GetValue());
 	}
 	void OnPathPush(wxSpinEvent& WXUNUSED(event))
 	{
 		m_Sidebar->UpdatePath( m_PathX->GetValue(), 
 					m_PathY->GetValue(), m_PathZ->GetValue());
 	}
 	void OnNodePush(wxSpinEvent& WXUNUSED(event))
 	{
 		m_OldT = CinemaTextFloat(*m_NodeT, 2, 0.f, 100.f, m_OldT);
 		m_Sidebar->UpdateNode( m_NodeX->GetValue(), 
 				m_NodeY->GetValue(), m_NodeZ->GetValue(), m_OldT);
 	}
 	void OnText(wxCommandEvent& WXUNUSED(event))
 	{
 		m_OldT = CinemaTextFloat(*m_NodeT, 2, 0.f, 100.f, m_OldT);
 		m_Sidebar->UpdateNode( m_NodeX->GetValue(), 
 				m_NodeY->GetValue(), m_NodeZ->GetValue(), m_OldT);
 	}
 
 	void UpdateTrackSpinners(int x, int y, int z)
 	{
 		m_TrackX->SetValue(x);
 		m_TrackY->SetValue(y);
 		m_TrackZ->SetValue(z);
 	}
 	void UpdatePathSpinners(int x, int y, int z)
 	{
 		m_PathX->SetValue(x);
 		m_PathY->SetValue(y);
 		m_PathZ->SetValue(z);
 	}
 	void UpdateNodeSpinners(int x, int y, int z, float t, ssize_t index)
 	{
 		m_NodeX->SetValue(x);
 		m_NodeY->SetValue(y);
 		m_NodeZ->SetValue(z);
 		m_NodeT->SetValue(wxString::Format(L"%f", t));
 		if ( m_OldIndex != index )
 		{
 			m_OldT = 0.f;
 			m_OldIndex = index;
 		}
 		m_OldT = CinemaTextFloat(*m_NodeT, 2, 0.f, 100.f, m_OldT);
 	}
 private:
 	wxSpinCtrl* m_TrackX, *m_TrackY, *m_TrackZ, *m_PathX, *m_PathY, *m_PathZ, *m_NodeX, *m_NodeY, *m_NodeZ;
 	wxTextCtrl* m_NodeT;
 	float m_OldT;
 	int m_OldIndex;
 	wxBoxSizer* m_MainSizer;
 	CinematicSidebar* m_Sidebar;
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(CinemaSpinnerBox, wxPanel)
 EVT_SPINCTRL(CinemaSpinnerBox::TrackX_ID, CinemaSpinnerBox::OnTrackPush)
 EVT_SPINCTRL(CinemaSpinnerBox::TrackY_ID, CinemaSpinnerBox::OnTrackPush)
 EVT_SPINCTRL(CinemaSpinnerBox::TrackZ_ID, CinemaSpinnerBox::OnTrackPush)
 EVT_SPINCTRL(CinemaSpinnerBox::PathX_ID, CinemaSpinnerBox::OnPathPush)
 EVT_SPINCTRL(CinemaSpinnerBox::PathY_ID, CinemaSpinnerBox::OnPathPush)
 EVT_SPINCTRL(CinemaSpinnerBox::PathZ_ID, CinemaSpinnerBox::OnPathPush)
 EVT_SPINCTRL(CinemaSpinnerBox::NodeX_ID, CinemaSpinnerBox::OnNodePush)
 EVT_SPINCTRL(CinemaSpinnerBox::NodeY_ID, CinemaSpinnerBox::OnNodePush)
 EVT_SPINCTRL(CinemaSpinnerBox::NodeZ_ID, CinemaSpinnerBox::OnNodePush)
 EVT_TEXT_ENTER(wxID_ANY, CinemaSpinnerBox::OnText)
 END_EVENT_TABLE()
 
 /////////////////////////////////////////////////////////////
 CinematicBottomBar::CinematicBottomBar(wxWindow* parent, CinematicSidebar* side)
 : wxPanel(parent), m_Sidebar(side), m_OldScale(0), m_OldTrackIndex(-1)
 {
 	m_Sizer = new wxStaticBoxSizer(wxVERTICAL, this);
 	SetSizer(m_Sizer);
 }
 void CinematicBottomBar::AddLists(CinematicSidebar* side, 
 		TrackListCtrl* tracks, PathListCtrl* paths, NodeListCtrl* nodes)
 {
 	wxBoxSizer* top = new wxBoxSizer(wxHORIZONTAL);
 	CinemaSpinnerBox* spinners = new CinemaSpinnerBox(this, side);
 	side->SetSpinners(spinners);
 	wxBoxSizer* trackButtons = new wxBoxSizer(wxVERTICAL);
 	wxBoxSizer* pathButtons = new wxBoxSizer(wxVERTICAL);
 	wxBoxSizer* nodeButtons = new wxBoxSizer(wxVERTICAL);
 
 	ActionButton* TrackAdd = new ActionButton(this, _T("Add"), 
 							&CinemaTrackAdd, tracks, wxSize(40, 18));
 	ActionButton* PathAdd = new ActionButton(this, _T("Add"),
 							&CinemaPathAdd, paths, wxSize(40, 18));
 	ActionButton* NodeAdd = new ActionButton(this, _T("Add"),
 							&CinemaNodeAdd, nodes, wxSize(40, 18));
 	ActionButton* TrackDel = new ActionButton(this, _T("Del"),
 							&CinemaTrackDel, tracks, wxSize(40, 18));
 	ActionButton* PathDel = new ActionButton(this, _T("Del"),
 							&CinemaPathDel, paths, wxSize(40, 18));
 	ActionButton* NodeDel = new ActionButton(this, _T("Del"),
 							&CinemaNodeDel, nodes, wxSize(40, 18));	
 	ActionButton* PathUpdate =  new ActionButton(this, _T("Mod"),
 							&CinemaPathUpdate, paths, wxSize(40, 18));
 	ActionButton* NodeUpdate =  new ActionButton(this, _T("Mod"),
 							&CinemaNodeUpdate, nodes, wxSize(40, 18));
 	ActionButton* NodeGoto = new ActionButton(this, _T("Goto"),
 							&CinemaNodeGoto, nodes, wxSize(44, 18));
 	
 	wxBoxSizer* textBoxes = new wxBoxSizer(wxVERTICAL);
 	wxBoxSizer* timescale = new wxBoxSizer(wxHORIZONTAL);
 
 	timescale->Add( new wxStaticText(this, wxID_ANY, _T("Timescale:")) );
 	m_TimeText = new wxTextCtrl(this, wxID_ANY, _T("1.00"),
 						wxDefaultPosition, wxSize(55, 20));
 	timescale->Add( m_TimeText );
 
 	wxBoxSizer* nameBox = new wxBoxSizer(wxHORIZONTAL);
 	nameBox->Add( new wxStaticText(this, wxID_ANY, _T("Name:")), 0,
 						wxALIGN_CENTER | wxLEFT | wxRIGHT, 5);
 	m_Name = new wxTextCtrl(this, wxID_ANY, _T(""), wxDefaultPosition, 
 														wxSize(55, 20));
 	nameBox->Add( m_Name );
 	
 	textBoxes->Add(timescale);
 	textBoxes->Add(nameBox, 0, wxEXPAND);
 
 	trackButtons->Add(TrackAdd, 0);
 	trackButtons->Add(TrackDel, 0);
 	pathButtons->Add(PathAdd, 0);
 	pathButtons->Add(PathDel, 0);
 	pathButtons->Add(PathUpdate, 0);
 	nodeButtons->Add(NodeAdd, 0);
 	nodeButtons->Add(NodeDel, 0);
 	nodeButtons->Add(NodeUpdate, 0);
 	nodeButtons->Add(NodeGoto, 0);
 	
 	top->Add(tracks, 0);
 	top->Add(trackButtons, 0);
 	top->Add(textBoxes, 0);
 	top->Add(paths, 0);
 	top->Add(pathButtons, 0);
 	top->Add(nodes, 0);
 	top->Add(nodeButtons, 0);
 
 	m_Sizer->Add(top, 0);
 	m_Sizer->Add(spinners, 0);
 }
 
 class CinemaInfoBox : public wxPanel
 {
 public:
 	enum { Mode_ID, Style_ID, Rotation_ID, Spline_ID };
 
 	CinemaInfoBox(CinematicSidebar* side) : wxPanel(side), 
 	m_Sidebar(side), m_OldGrowth(0), m_OldSwitch(0), m_OldTrackIndex(-1)
 	{
 		m_Sizer = new wxBoxSizer(wxVERTICAL);
 		SetSizer(m_Sizer);
 		//Use individual static boxes for nicer looks
 		wxBoxSizer* radios = new wxBoxSizer(wxHORIZONTAL);
 		wxBoxSizer* spinners = new wxBoxSizer(wxHORIZONTAL);
 
 		wxString style[5] = {_T("Default"), _T("Growth"), _T("Expo"),
 			_T("Circle"), _T("Sine") };
 		m_StyleBox = new wxRadioBox(this, Style_ID, _T("Style"), wxDefaultPosition, 
 			wxDefaultSize, 5, style, 5, wxRA_SPECIFY_ROWS );
 		radios->Add(m_StyleBox, 0, wxALIGN_CENTER);
 		
 		//Mode radio box
 		wxString mode[4]= { _T("Ease in"), _T("Ease Out"),
 									_T("In-out"), _T("Out-in") };
 		m_ModeBox = new wxRadioBox(this, Mode_ID, _T("Mode"), wxDefaultPosition, 
 					wxDefaultSize, 4, mode, 4, wxRA_SPECIFY_ROWS );
 		radios->Add(m_ModeBox, 0, wxEXPAND | wxALIGN_CENTER);
 
 		wxStaticText* growth = new wxStaticText(this, wxID_ANY, _T("Growth"));
 		wxStaticText* change = new wxStaticText(this, wxID_ANY, _T("Switch"));
 		m_Growth = new wxTextCtrl(this, wxID_ANY, _T("0.00"), wxDefaultPosition, 
 						wxSize(50, 15), wxTE_PROCESS_ENTER);
 		m_Switch = new wxTextCtrl(this, wxID_ANY, _T("0.00"), wxDefaultPosition, 
 						wxSize(50, 15), wxTE_PROCESS_ENTER);
 
 		wxStaticBoxSizer* growthBox = new wxStaticBoxSizer(wxHORIZONTAL, this);
 		growthBox->Add(growth, 0, wxALIGN_CENTER);
 		growthBox->Add(m_Growth, 0, wxALIGN_CENTER);
 		wxStaticBoxSizer* switchBox = new wxStaticBoxSizer(wxHORIZONTAL, this);
 		switchBox->Add(change, 0, wxALIGN_CENTER);
 		switchBox->Add(m_Switch, 0, wxALIGN_CENTER);
 
 		spinners->Add(growthBox);
 		spinners->Add(switchBox);
 		m_Sizer->Add(radios, 0, wxALIGN_CENTER);
 		m_Sizer->Add(spinners, 0, wxALIGN_CENTER);
 		
 		//Put this here since there isn't any other place yet
 		wxBoxSizer* displayH = new wxBoxSizer(wxHORIZONTAL);
 		m_DrawAll = new wxCheckBox(this, wxID_ANY, _T("Draw all"));
 		m_DrawCurrent = new wxCheckBox(this, wxID_ANY, _T("Draw current"));
 		
 		wxString splineStrings[2] = { _T("Points"), _T("Lines") };
 		m_SplineDisplay = new wxRadioBox(this, Spline_ID, _T("Spline Display"), 
 			wxDefaultPosition, wxDefaultSize, 2, splineStrings, 2, wxRA_SPECIFY_ROWS);
 		wxString angle[2] = { _T("Relative"), _T("Absolute") };
 		m_RotationDisplay = new wxRadioBox(this, Rotation_ID, _T("Rotation Display"), 
 			wxDefaultPosition, wxDefaultSize, 2, angle, 2, wxRA_SPECIFY_ROWS );
 		
 		displayH->Add(m_SplineDisplay, 0);
 		displayH->Add(m_RotationDisplay, 0);
 		m_Sizer->Add(displayH, 0, wxTop | wxALIGN_CENTER, 10);
 		m_Sizer->Add(m_DrawAll, 0);
 		m_Sizer->Add(m_DrawCurrent, 0);
 		
 	}
 	void Update(const sCinemaPath& path)
 	{
 		m_ModeBox->SetSelection(path.mode);
 		m_StyleBox->SetSelection(path.style);
 		float growth = path.growth;	//wxFormat doesn't like to share(able)
 		float change = path.change;
 		m_Growth->SetValue( wxString::Format(L"%f", growth) );
 		m_Switch->SetValue( wxString::Format(L"%f", change) );
 		UpdateOldIndex();
 		CinemaTextFloat(*m_Growth, 2, 0.f, 10.f, m_OldGrowth);
 		CinemaTextFloat(*m_Switch, 2, 0.f, 10.f, m_OldSwitch);
 	}
 	void OnChange(wxCommandEvent& WXUNUSED(event))
 	{	
 		m_OldGrowth = CinemaTextFloat(*m_Growth, 2, 0.f, 10.f, m_OldGrowth);
 		m_OldSwitch = CinemaTextFloat(*m_Switch, 2, 0.f, 10.f, m_OldSwitch);
 		UpdateOldIndex();
 		m_Sidebar->UpdatePathInfo( m_ModeBox->GetSelection(),
 			m_StyleBox->GetSelection(), m_OldGrowth, m_OldSwitch,
 			m_DrawAll->IsChecked(), m_DrawCurrent->IsChecked(), 
 							m_SplineDisplay->GetSelection()!=0 );
 	}
 	void OnRotation(wxCommandEvent& WXUNUSED(event))
 	{
 		m_Sidebar->m_RotationAbsolute = m_RotationDisplay->GetSelection()!=0;
 		m_Sidebar->UpdateSpinners();
 	}
 	void UpdateOldIndex()
 	{
 		if ( m_Sidebar->GetSelectedTrack() != m_OldTrackIndex )
 		{
 			m_OldTrackIndex = m_Sidebar->GetSelectedTrack();
 			m_OldGrowth = m_OldSwitch = 0.f;
 		}
 	}
 	bool GetDrawAll() { return m_DrawAll->IsChecked(); }
 	bool GetDrawCurrent() { return m_DrawCurrent->IsChecked(); }
 	bool GetDrawLines() { return m_SplineDisplay->GetSelection()!=0; }
 
 private:
 	wxBoxSizer* m_Sizer;
 	CinematicSidebar* m_Sidebar;
 	wxRadioBox* m_ModeBox, *m_StyleBox, *m_RotationDisplay, *m_SplineDisplay;
 	wxTextCtrl* m_Growth, *m_Switch;
 	wxCheckBox* m_DrawAll, *m_DrawCurrent;
 
 	float m_OldGrowth, m_OldSwitch;
 	ssize_t m_OldTrackIndex;
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(CinemaInfoBox, wxPanel)
 EVT_RADIOBOX(CinemaInfoBox::Mode_ID, CinemaInfoBox::OnChange)
 EVT_RADIOBOX(CinemaInfoBox::Style_ID, CinemaInfoBox::OnChange)
 EVT_RADIOBOX(CinemaInfoBox::Spline_ID, CinemaInfoBox::OnChange)
 EVT_CHECKBOX(wxID_ANY, CinemaInfoBox::OnChange)
 EVT_RADIOBOX(CinemaInfoBox::Rotation_ID, CinemaInfoBox::OnRotation)
 EVT_TEXT_ENTER(wxID_ANY, CinemaInfoBox::OnChange)
 END_EVENT_TABLE()
 
 class PathSlider;
 class CinemaSliderBox;
 
 class TrackSlider : public wxSlider
 {
 	static const int range=1024;
 public:
 	TrackSlider(CinematicSidebar* side, CinemaSliderBox* parent) 
 		: wxSlider((wxWindow*)parent, wxID_ANY, 0, 0, range),
 		m_Sidebar(side), m_Parent(parent)
 	{
 	}
 	void OnScroll(wxScrollEvent& event);
 	void Update(float interval);
 	void SetPathSlider(PathSlider* slider)
 	{
 		m_Path = slider;
 	}
 	
 private:
 	PathSlider* m_Path;
 	CinematicSidebar* m_Sidebar;
 	CinemaSliderBox* m_Parent;
 
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(TrackSlider, wxSlider)
 	EVT_SCROLL(TrackSlider::OnScroll)
 END_EVENT_TABLE()
 
 class PathSlider : public wxSlider
 {
 	static const int range=1024;
 public:
 	PathSlider(CinematicSidebar* side, wxWindow* parent) 
 		: wxSlider(parent, wxID_ANY, 0, 0, range, wxDefaultPosition,
 		wxDefaultSize, wxSL_HORIZONTAL, wxDefaultValidator, _("Path")),
 		m_Sidebar(side)
 	{
 	}
 
 	void OnScroll(wxScrollEvent& WXUNUSED(event));
 
 	void SetTrackSlider(TrackSlider* slider)
 	{
 		m_Track = slider;
 	}
 private:
 	TrackSlider* m_Track;
 	CinematicSidebar* m_Sidebar;
 
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(PathSlider, wxSlider)
 	EVT_SCROLL(PathSlider::OnScroll)
 END_EVENT_TABLE()
 
 class CinemaSliderBox : public wxPanel
 {
 public:
 	CinemaSliderBox(CinematicSidebar* parent, const wxString& label) 
 		: wxPanel(parent), m_Sidebar(parent), m_OldTime(0), m_NewTime(0)
 	{
 		m_Sizer = new wxStaticBoxSizer(wxVERTICAL, this, label);
 		SetSizer(m_Sizer);
 		m_Path = new PathSlider(parent, this);
 		m_Track = new TrackSlider(parent, this);
 		m_Path->SetTrackSlider(m_Track);
 		m_Track->SetPathSlider(m_Path);
 
 		m_Sizer->Add(m_Track, 0);
 		m_Sizer->Add(m_Path, 0);
 
 		m_Timer.SetOwner(this);
 	}
 	void Update()
 	{
 		m_Track->Update(0);
 	}
 	void OnTick(wxTimerEvent& WXUNUSED(event))
 	{
 		m_NewTime = m_HighResTimer.GetTime();
 		m_Track->Update(m_NewTime - m_OldTime);
 		m_OldTime = m_NewTime;
 	}
 	void PrepareTimers()
 	{
 		m_OldTime = m_NewTime = m_HighResTimer.GetTime();
 		m_Timer.Start(10);
 	}
 	void Reset()
 	{
 		m_Track->SetValue(0);
 		m_Path->SetValue(0);
 	}
 	
 	float m_OldTime;
 	float m_NewTime;
 	wxTimer m_Timer;
 private:
 	TrackSlider* m_Track;
 	HighResTimer m_HighResTimer;
 	PathSlider* m_Path;
 	wxStaticBoxSizer* m_Sizer;
 	CinematicSidebar* m_Sidebar;
 
 	DECLARE_EVENT_TABLE();
 };
 BEGIN_EVENT_TABLE(CinemaSliderBox, wxPanel)
 	EVT_TIMER(wxID_ANY, CinemaSliderBox::OnTick)
 END_EVENT_TABLE()
 
 void TrackSlider::OnScroll(wxScrollEvent& WXUNUSED(event))
 {
 	//Move path and send movement message
 	m_Sidebar->m_SliderBox->m_Timer.Stop();
 	if ( m_Sidebar->m_SelectedTrack < 0 || m_Sidebar->m_SelectedPath < 0 )
 	{
 		SetValue(0);
 		return;		
 	}
 	float ratio = (float)GetValue() / (float)range;
 	float time = ratio * m_Sidebar->m_Tracks[m_Sidebar->m_SelectedTrack].duration;
 	
 	POST_MESSAGE(CinemaEvent,
 		( *m_Sidebar->m_Tracks[m_Sidebar->m_SelectedTrack].name, 
 		eCinemaEventMode::IMMEDIATE_TRACK, time, 
 		m_Sidebar->m_InfoBox->GetDrawAll(), m_Sidebar->m_InfoBox->GetDrawCurrent(), 
 		m_Sidebar->m_InfoBox->GetDrawLines() ) );
 	
 	m_Sidebar->m_AbsoluteTime = time;
 	m_Path->SetValue( (int)( m_Sidebar->UpdateSelectedPath() /
 		m_Sidebar->GetCurrentPath().duration * range ) );
 }
 void PathSlider::OnScroll(wxScrollEvent& WXUNUSED(event))
 {
 	m_Sidebar->m_SliderBox->m_Timer.Stop();
 	if ( m_Sidebar->m_SelectedTrack < 0 || m_Sidebar->m_SelectedPath < 0 )
 	{
 		SetValue(0);
 		return;		
 	}
 	//Move path and send movement message
 	float ratio = (float)GetValue() / (float)range;
 	float time = ratio * m_Sidebar->GetCurrentPath().duration;
 	float trackTime = m_Sidebar->m_AbsoluteTime / m_Sidebar->
 			m_Tracks[m_Sidebar->m_SelectedTrack].duration * range;
 	m_Sidebar->m_AbsoluteTime += time - m_Sidebar->m_TimeElapsed;
 	m_Sidebar->m_TimeElapsed = time;
 
 	m_Track->SetValue( trackTime );
 	POST_MESSAGE(CinemaEvent,
 		( *m_Sidebar->m_Tracks[m_Sidebar->m_SelectedTrack].name, 
 		eCinemaEventMode::IMMEDIATE_TRACK, trackTime,
 		m_Sidebar->m_InfoBox->GetDrawAll(), m_Sidebar->m_InfoBox->GetDrawCurrent(),
 		m_Sidebar->m_InfoBox->GetDrawLines()) );
 		
 }
 
 void TrackSlider::Update(float interval)
 {
 	if ( m_Sidebar->m_SelectedTrack < 0 || m_Sidebar->m_SelectedPath < 0 )
 	{
 		SetValue(0);
 		return;		
 	}
 	interval *= m_Sidebar->m_Tracks[m_Sidebar->m_SelectedTrack].timescale;
 	m_Sidebar->m_AbsoluteTime += interval; 
 	int move = m_Sidebar->m_AbsoluteTime / m_Sidebar->m_Tracks
 		[m_Sidebar->m_SelectedTrack].duration * (float)range;
 	if ( move > range )
 		move = range;
 	SetValue( move );
 	m_Path->SetValue( (int)( m_Sidebar->UpdateSelectedPath() /
 	m_Sidebar->GetCurrentPath().duration * range ) );
 	
 	if ( move == range && m_Sidebar->m_Playing )
 	{
 		m_Parent->m_Timer.Stop();
 		SetValue(0);
 		m_Path->SetValue(0);
 		m_Sidebar->GotoNode(0);
 		m_Sidebar->m_Playing = false;
 	}
 }
 //////////////////////////////////////////////////////////////////////////
 
 class CinemaButtonBox : public wxPanel
 {
 public:
 	CinemaButtonBox(CinematicSidebar* parent) :  wxPanel(parent), m_Parent(parent)
 	{
 		m_Sizer = new wxStaticBoxSizer(wxHORIZONTAL, this);
 		SetSizer(m_Sizer);
 	}
 	void Add(wxBitmapButton* button)
 	{
 		m_Sizer->Add(button);
 	}
 	void OnPrevious(wxCommandEvent& WXUNUSED(event))
 	{
 		if ( m_Parent->m_SelectedTrack < 0 )
 			return;
 		m_Parent->m_SliderBox->m_Timer.Stop();
 		m_Parent->m_Playing = false;
 		std::wstring name=*m_Parent->m_Tracks[m_Parent->m_SelectedTrack].name;
 
 		if ( m_Parent->m_SelectedPath > 0 && m_Parent->m_TimeElapsed 
 												< CINEMA_EPSILON)
 		{
 			m_Parent->SelectPath(m_Parent->m_SelectedPath-1);
 			float t = -m_Parent->GetCurrentPath().duration;
 			m_Parent->m_AbsoluteTime += t;
 			m_Parent->m_TimeElapsed = 0.f;
 		
 			POST_MESSAGE(CinemaEvent, 
 			( name, eCinemaEventMode::IMMEDIATE_PATH, t,
 			m_Parent->m_InfoBox->GetDrawAll(), m_Parent->m_InfoBox->GetDrawCurrent(),
 			m_Parent->m_InfoBox->GetDrawLines() ) );
 		}
 		else
 		{
 			m_Parent->m_AbsoluteTime -= m_Parent->m_TimeElapsed;
 			m_Parent->m_TimeElapsed = 0.0f;
 				POST_MESSAGE(CinemaEvent, 
 				( name, eCinemaEventMode::IMMEDIATE_PATH, 0.0f,
 				m_Parent->m_InfoBox->GetDrawAll(), m_Parent->m_InfoBox->GetDrawCurrent(),
 				m_Parent->m_InfoBox->GetDrawLines()) );
 		}
 		m_Parent->m_SliderBox->Update();
 	}
 	//void OnRewind(wxCommandEvent& event)
 	
 	//void OnReverse(wxCommandEvent& event)
 	void OnStop(wxCommandEvent& WXUNUSED(event))
 	{
 		if ( m_Parent->m_SelectedTrack < 0 || m_Parent->m_SelectedPath < 0)
 			return;
 		m_Parent->m_SliderBox->m_Timer.Stop();
 		m_Parent->m_Playing = false;
 		m_Parent->m_AbsoluteTime = m_Parent->m_TimeElapsed = 0.0f;
 		m_Parent->SelectPath(0);
 		m_Parent->m_SliderBox->Update();
 
 		POST_MESSAGE(CinemaEvent,
 			(*m_Parent->m_Tracks[m_Parent->m_SelectedTrack].name, 
 			eCinemaEventMode::IMMEDIATE_TRACK, 0.0f,
 			m_Parent->m_InfoBox->GetDrawAll(), m_Parent->m_InfoBox->GetDrawCurrent(),
 			m_Parent->m_InfoBox->GetDrawLines()) );
 	}
 	void OnPlay(wxCommandEvent& WXUNUSED(event))
 	{
 		if ( m_Parent->m_SelectedTrack < 0 )
 			return;
 		m_Parent->m_SliderBox->m_Timer.Stop();
 		m_Parent->m_SliderBox->PrepareTimers();
 
 		POST_MESSAGE(CinemaEvent,
 			(*m_Parent->m_Tracks[m_Parent->m_SelectedTrack].name, 
 			eCinemaEventMode::SMOOTH, 0.0f,
 			m_Parent->m_InfoBox->GetDrawAll(), m_Parent->m_InfoBox->GetDrawCurrent(),
 			m_Parent->m_InfoBox->GetDrawLines()) );
 			
 		m_Parent->m_Playing = true;
 	}
 	void OnPause(wxCommandEvent& WXUNUSED(event))
 	{
 		if ( m_Parent->m_SelectedTrack < 0 )
 			return;
 		m_Parent->m_SliderBox->m_Timer.Stop();
 		m_Parent->m_SliderBox->Reset();
 		//m_Parent->m_NodeList->Thaw();
 		m_Parent->m_Playing = false;
 
 		POST_MESSAGE(CinemaEvent,
 			(*m_Parent->m_Tracks[m_Parent->m_SelectedTrack].name, 
 			eCinemaEventMode::IMMEDIATE_PATH, m_Parent->m_TimeElapsed,
 			m_Parent->m_InfoBox->GetDrawAll(), m_Parent->m_InfoBox->GetDrawCurrent(),
 			m_Parent->m_InfoBox->GetDrawLines()) );
 	}
 	//void OnForward(wxCommandEvent& event)
 	void OnNext(wxCommandEvent& WXUNUSED(event))
 	{
 		m_Parent->m_SliderBox->m_Timer.Stop();
 		m_Parent->m_Playing = false;
 		std::wstring name=*m_Parent->m_Tracks[m_Parent->m_SelectedTrack].name;
 		sCinemaPath path = m_Parent->GetCurrentPath();
 		float t = path.duration - m_Parent->m_TimeElapsed;
 
 		if ( m_Parent->m_SelectedPath < (ssize_t)m_Parent->m_Tracks
 				[m_Parent->m_SelectedTrack].paths.GetSize()-1 )
 		{
 			m_Parent->SelectPath(m_Parent->m_SelectedPath+1);
 			m_Parent->m_TimeElapsed = 0.f;
 		}
 		else
 			m_Parent->m_TimeElapsed = path.duration;
 		m_Parent->m_AbsoluteTime += t;	
 		
 		POST_MESSAGE(CinemaEvent, 
 		( name, eCinemaEventMode::IMMEDIATE_PATH, path.duration+CINEMA_EPSILON,
 		m_Parent->m_InfoBox->GetDrawAll(), m_Parent->m_InfoBox->GetDrawCurrent(),
 		m_Parent->m_InfoBox->GetDrawLines()) );
 		
 		m_Parent->m_SliderBox->Update();
 	}
 	CinematicSidebar* m_Parent;
 	wxStaticBoxSizer* m_Sizer;
 	DECLARE_EVENT_TABLE();
 };
 
 BEGIN_EVENT_TABLE(CinemaButtonBox, wxPanel)
 	EVT_BUTTON(eCinemaButton::previous, CinemaButtonBox::OnPrevious)
 	//EVT_BUTTON(eCinemaButton::rewind, CinemaButtonBox::OnRewind)
 	//EVT_BUTTON(eCinemaButton::reverse, CinemaButtonBox::OnReverse)
 	EVT_BUTTON(eCinemaButton::stop, CinemaButtonBox::OnStop)
 	EVT_BUTTON(eCinemaButton::play, CinemaButtonBox::OnPlay)
 	EVT_BUTTON(eCinemaButton::pause, CinemaButtonBox::OnPause)
 //	EVT_BUTTON(eCinemaButton::forward, CinemaButtonBox::OnForward)
 	EVT_BUTTON(eCinemaButton::next, CinemaButtonBox::OnNext)
 END_EVENT_TABLE()
 //////////////////////////////////////////////////////////////////////////
 
 CinematicSidebar::CinematicSidebar(wxWindow* sidebarContainer, wxWindow* bottomBarContainer)
 : Sidebar(sidebarContainer, bottomBarContainer), m_SelectedTrack(-1),
 m_SelectedPath(-1), m_SelectedSplineNode(-1), m_TimeElapsed(0.f), 
 m_AbsoluteTime(0.f), m_RotationAbsolute(false), m_UpdatePathEcho(false),
 m_Playing(false)
 {
 	m_SliderBox = new CinemaSliderBox(this, _T("Timeline"));
 	m_MainSizer->Add(m_SliderBox, 0, wxALIGN_CENTER);
 	m_IconSizer = new CinemaButtonBox(this);
 	LoadIcons(); //do this here; buttons must be added before box is
 	m_MainSizer->Add(m_IconSizer, 0, wxALIGN_CENTER);
 	m_InfoBox = new CinemaInfoBox(this);
 	m_MainSizer->Add(m_InfoBox, 0, wxALIGN_CENTER);
 	
 	CinematicBottomBar* bottom = new CinematicBottomBar(bottomBarContainer, this);
 	m_BottomBar = bottom;
 	m_CinemaBottomBar = bottom;  //avoid casting later
 	m_TrackList = new TrackListCtrl(bottom, this);
 	m_PathList = new PathListCtrl(bottom, this);
 	m_NodeList = new NodeListCtrl(bottom, this);
 	bottom->AddLists(this, m_TrackList, m_PathList, m_NodeList);
 }
 
 void CinematicSidebar::OnFirstDisplay()
 {
 	qGetCinemaTracks qry;
 	qry.Post();
 	m_Tracks = *qry.tracks;
 
 	m_TrackList->Freeze();
 	for (size_t track = 0; track < m_Tracks.size(); ++track)
 	{
 		m_TrackList->InsertItem((long)track, wxString(m_Tracks[track].name.c_str()));
 	}
 	m_TrackList->Thaw();
 
 }		
 
 void CinematicSidebar::SelectTrack(ssize_t n)
 {
 	if (n == -1)
 	{
 		m_SelectedTrack = -1;
 		SelectPath(-1);
 		return;
 	}
 	else
 	{
 		wxCHECK_RET (n >= 0 && n < (ssize_t)m_Tracks.size(), _T("SelectTrack out of bounds"));
 		
 		m_SelectedTrack = n;
 		SelectPath(-1);
 		m_PathList->Freeze();
 		m_PathList->DeleteAllItems();
 
 		if (n != -1)
 		{
 			std::vector<sCinemaPath> paths = *m_Tracks[n].paths;
 			for (size_t path = 0; path < paths.size(); ++path)
 			{
 				m_PathList->InsertItem((long)path, wxString::Format(_("Path %d"), path));
 			}
 		}
 		m_PathList->Thaw();
 	}
 
 	UpdateSpinners();
 }
 
 void CinematicSidebar::SelectPath(ssize_t n)
 {
 	if (n == -1 || m_SelectedTrack == -1)
 	{
 		m_PathList->DeleteAllItems();
 		//Do this here to avoid thinking that there's still a path
 		m_SelectedPath = n;
 		SelectSplineNode(-1);
 		return;
 	}
 	else
 	{
 		std::vector<sCinemaPath> paths = *m_Tracks[m_SelectedTrack].paths;
 		ssize_t size = (ssize_t)paths.size();
 		wxCHECK_RET (n >= 0 && n < size, _T("SelectPath out of bounds"));
 		
 		m_SelectedPath = n;
 		SelectSplineNode(-1);
 		m_NodeList->Freeze();
 		m_NodeList->DeleteAllItems();
 
 		if (n != -1)
 		{
 			std::vector<sCinemaSplineNode> nodes = *paths[n].nodes;
 			for ( size_t i=0; i<nodes.size(); ++i )
 			{
 				m_NodeList->InsertItem((long)i, wxString::Format(_("Node %d"), i));
 			}
 		}
 
 		m_NodeList->Thaw();
 	}
 	POST_MESSAGE(CinemaEvent, ( *GetCurrentTrack()->name, 
 		eCinemaEventMode::SELECT, (int)m_SelectedPath, m_InfoBox->GetDrawAll(), 
 		m_InfoBox->GetDrawCurrent(), m_InfoBox->GetDrawLines() ));
 	
 	UpdateSpinners();
 }
 
 void CinematicSidebar::SelectSplineNode(ssize_t n, ssize_t size)
 {
 	if (n == -1 || m_SelectedPath == -1)
 	{
 		m_NodeList->DeleteAllItems();
 	}
 	else
 		wxCHECK_RET (n < size, _T("SelectNode out of bounds"));
 	m_SelectedSplineNode = n;
 	UpdateSpinners();
 }
 const sCinemaTrack* CinematicSidebar::GetCurrentTrack()
 {
 	return &m_Tracks[m_SelectedTrack];
 }
 sCinemaPath CinematicSidebar::GetCurrentPath()
 {
 	if ( m_SelectedPath < 0 )
 	{
 		wxFAIL_MSG(L"CurrentPath() request out of range.  The game will attempt to continue.");
 		return sCinemaPath();
 	}
 	return (*m_Tracks[m_SelectedTrack].paths)[m_SelectedPath];
 }
 sCinemaSplineNode CinematicSidebar::GetCurrentNode()
 {
 	return (* (*m_Tracks[m_SelectedTrack].paths)[m_SelectedPath].nodes )
 										[m_SelectedSplineNode];
 }
 //copied from sectionlayout's addpage()
 wxImage CinematicSidebar::LoadIcon(const wxString& filename)
 {
 	wxImage img (1, 1, true);
 
 	// Load the icon
 	wxFileName iconPath (_T("mods/official/art/textures/ui/session/icons/single/atlas/"));
 	iconPath.MakeAbsolute(Datafile::GetDataDirectory());
 	iconPath.SetFullName(filename);
 	wxFileInputStream fstr (iconPath.GetFullPath());
 	if (! fstr.Ok())
 	{
 		wxLogError(_("Failed to open cinematic icon file '%s'"), iconPath.GetFullPath().c_str());
 	}
 	else
 	{
 		img = wxImage(fstr, wxBITMAP_TYPE_BMP);
 		if (! img.Ok())
 		{
 			wxLogError(_("Failed to load cinematic icon image '%s'"), iconPath.GetFullPath().c_str());
 			img = wxImage (1, 1, true);
 		}
 	}
 	return img;
 }
 void CinematicSidebar::LoadIcons()
 {
 	wxBitmapButton* previous = new wxBitmapButton(m_IconSizer, 
 			eCinemaButton::previous, LoadIcon( _T("previous_s.bmp") ));
 	m_IconSizer->Add(previous);
 	wxBitmapButton* stop = new wxBitmapButton(m_IconSizer, 
 			eCinemaButton::stop, LoadIcon( _T("stop_s.bmp") ));
 	m_IconSizer->Add(stop);
 	wxBitmapButton* play = new wxBitmapButton(m_IconSizer, 
 			eCinemaButton::play, LoadIcon( _T("play_s.bmp") ));
 	m_IconSizer->Add(play);
 	wxBitmapButton* pause = new wxBitmapButton(m_IconSizer, 
 			eCinemaButton::pause, LoadIcon( _T("pause_s.bmp") ));
 	m_IconSizer->Add(pause);
 	wxBitmapButton* next = new wxBitmapButton(m_IconSizer, 
 			eCinemaButton::next, LoadIcon( _T("next_s.bmp") ));
 	m_IconSizer->Add(next);
 }
 void CinematicSidebar::AddTrack(float x, float y, float z, 
 								std::wstring& name, int count)
 {
 	m_Tracks.push_back(sCinemaTrack(x, y, z, name));
 	SelectPath(-1);
 	SelectTrack(count);
 	UpdateEngineData();
 }
 void CinematicSidebar::AddPath(int x, int y, int z, int count)  //rotation
 {
 	if ( m_SelectedTrack < 0 )
 		return;
 	std::vector<sCinemaPath> paths=*m_Tracks[m_SelectedTrack].paths;
 	
 	//x, y, and z should always be absolute, so adjust here
 	if ( count == 0 )
 	{
 		paths.push_back( sCinemaPath(x - m_Tracks[m_SelectedTrack].x,
 		y-m_Tracks[m_SelectedTrack].y, z-m_Tracks[m_SelectedTrack].z) );
 	}
 	else
 	{
 		int x2 = paths[count-1].x, y2 = paths[count-1].y, 
 									z2 = paths[count-1].z;
 		GetAbsoluteRotation(x2, y2, z2, count-1);
 		paths.push_back( sCinemaPath(x - x2, y - y2, z - z2) );
 	}
 	
 	m_Tracks[m_SelectedTrack].paths = paths;
 	SelectSplineNode(-1);
 	SelectPath(count);
 	UpdateEngineData();
 }
 void CinematicSidebar::AddNode(float x, float y, float z, int count)
 {
 	if ( m_SelectedTrack < 0 || m_SelectedPath < 0 )
 		return;
 
 	std::vector<sCinemaPath> paths=*m_Tracks[m_SelectedTrack].paths;
 	std::vector<sCinemaSplineNode> nodes=*(*m_Tracks[m_SelectedTrack].paths)
 										[m_SelectedPath].nodes;
 	nodes.push_back(sCinemaSplineNode(x, y, z));
 	paths[m_SelectedPath].nodes = nodes;
 	m_Tracks[m_SelectedTrack].paths = paths;
 	UpdateEngineData();
 	SelectSplineNode(count, count+1);
 }
 void CinematicSidebar::DeleteTrack()
 {
 	m_Tracks.erase( m_Tracks.begin() + m_SelectedTrack );
 	ssize_t size = (ssize_t)m_Tracks.size();
 	
 	m_SelectedPath = -1;
 	m_SelectedSplineNode = -1;
 	if ( size == 0 )
 		SelectTrack(-1);
 	else if ( m_SelectedTrack > size-1 )
 		SelectTrack(size-1);
 	else
 		SelectTrack(m_SelectedTrack);
 
 	UpdateEngineData();
 }
 void CinematicSidebar::DeletePath()
 {
 	if ( m_SelectedTrack < 0 || m_SelectedPath < 0 )
 		return;
 	std::vector<sCinemaPath> paths = *m_Tracks[m_SelectedTrack].paths;
 	paths.erase( paths.begin() + m_SelectedPath );
 	m_Tracks[m_SelectedTrack].paths = paths;
 	ssize_t size = (ssize_t)paths.size();
 	
 	m_SelectedSplineNode = -1;
 	if ( size == 0 )
 		SelectPath(-1);
 	else if ( m_SelectedPath > size-1 )
 		SelectPath(size-1);
 	else
 		SelectPath(m_SelectedPath);
 	
 	SelectTrack(m_SelectedTrack);
 	UpdateEngineData();
 }
 void CinematicSidebar::DeleteNode()
 {
 	if ( m_SelectedTrack < 0 || m_SelectedPath < 0 || 
 									m_SelectedSplineNode < 0 )
 	{
 		return;
 	}
 	std::vector<sCinemaPath> paths = *m_Tracks[m_SelectedTrack].paths;
 	std::vector<sCinemaSplineNode> nodes = *paths[m_SelectedPath].nodes;
  	m_Tracks[m_SelectedTrack].duration = m_Tracks[m_SelectedTrack].duration - 
 									nodes[m_SelectedSplineNode].t;
 	paths[m_SelectedPath].duration = paths[m_SelectedPath].duration - 
 									nodes[m_SelectedSplineNode].t;
 	
 	if ( m_AbsoluteTime > m_Tracks[m_SelectedTrack].duration )
 		m_AbsoluteTime = m_Tracks[m_SelectedTrack].duration;
 	if ( m_TimeElapsed > paths[m_SelectedPath].duration )
 		m_TimeElapsed = paths[m_SelectedPath].duration;
 
 	nodes.erase( nodes.begin() + m_SelectedSplineNode );
 	paths[m_SelectedPath].nodes = nodes;
 	m_Tracks[m_SelectedTrack].paths = paths;
 	ssize_t size = (ssize_t)nodes.size();
 	
 	if ( size == 0 )
 		SelectSplineNode(-1);
 	else if ( m_SelectedSplineNode > size-1 )
 		SelectSplineNode(size-1, size);
 	else
 		SelectSplineNode(m_SelectedSplineNode, size);
 	SelectPath(m_SelectedPath);	//Correct numbering
 	UpdateEngineData();
 	
 }	
 
 void CinematicSidebar::UpdateTrack(std::wstring name, float timescale)
 {
 	if ( m_SelectedTrack < 0 )
 		return;
 	m_Tracks[m_SelectedTrack].name = name;
 	m_Tracks[m_SelectedTrack].timescale = timescale;
 	m_TrackList->SetItemText(m_SelectedTrack, wxString(name.c_str()));
 	UpdateEngineData();
 }
 void CinematicSidebar::UpdateTrack(float x, float y, float z)
 {
 	if ( m_SelectedTrack < 0 )
 		return;
 
 	m_Tracks[m_SelectedTrack].x = x;
 	m_Tracks[m_SelectedTrack].y = y;
 	m_Tracks[m_SelectedTrack].z = z;
 	
 	if ( m_Tracks[m_SelectedTrack].paths.GetSize() > 0 )
 	{
 		//Recalculate relative rotation for path
 		int x, y, z;
 		bool marker = m_RotationAbsolute;
 		m_RotationAbsolute = false;
 		GetAbsoluteRotation(x, y, z, 0);
 		//(Track rotation is always absolute)
 		UpdatePath(x-m_Tracks[m_SelectedTrack].x, y-m_Tracks[m_SelectedTrack].y, 
 						z - m_Tracks[m_SelectedTrack].z, 0);
 		m_RotationAbsolute = marker;
 	}
 
 	UpdateEngineData();
 }
 void CinematicSidebar::UpdatePath(int x, int y, int z, ssize_t index)
 {
 	if ( m_SelectedTrack < 0 || m_SelectedPath < 0 )
 		return;
 	if ( index < 0 )
 		index = m_SelectedPath;
 
 	std::vector<sCinemaPath> paths=*m_Tracks[m_SelectedTrack].paths;
 	
 	//Convert to relative rotation
 	if ( m_RotationAbsolute )
 	{
 		if ( index == 0 )
 		{
 			paths[index].x = x - m_Tracks[m_SelectedTrack].x;
 			paths[index].y = y - m_Tracks[m_SelectedTrack].y;
 			paths[index].z = z - m_Tracks[m_SelectedTrack].z;
 		}
 		else
 		{
 			int x2, y2, z2;
 			GetAbsoluteRotation(x2, y2, z2);
 			paths[index].x = x - x2;
 			paths[index].y = y - y2;
 			paths[index].z = z - z2;
 		}
 	}
 	else
 	{
 		paths[index].x = x;
 		paths[index].y = y;
 		paths[index].z = z;
 	}
 	
 	if ( index != (ssize_t)paths.size()-1 && !m_UpdatePathEcho )
 	{
 		//Recalculate relative rotation for path
 		m_Tracks[m_SelectedTrack].paths = paths;
 		int x2, y2, z2;
 		bool marker = m_RotationAbsolute;
 		m_RotationAbsolute = false;
 		GetAbsoluteRotation(x, y, z, index);
 		GetAbsoluteRotation(x2, y2, z2, index+1);
 
 		m_UpdatePathEcho = true;
 		UpdatePath(x2 - x, y2 - y, z2 - z, m_SelectedPath+1);
 		m_RotationAbsolute = marker;
 	}
 	else if ( m_UpdatePathEcho )
 		m_UpdatePathEcho = false;
 
 
 	m_Tracks[m_SelectedTrack].paths = paths;
 	UpdateEngineData();
 }
 void CinematicSidebar::UpdateNode(float x, float y, float z, float t)
 {
 	if ( m_SelectedTrack < 0 || m_SelectedPath < 0 || 
 									m_SelectedSplineNode < 0 )
 	{
 		return;
 	}
 	else if ( m_SelectedSplineNode == 0 )
 	{
 		wxBell();	//Let them know: the first node has no meaning
 		return;
 	}
 	std::vector<sCinemaPath> paths=*m_Tracks[m_SelectedTrack].paths;
 	std::vector<sCinemaSplineNode> nodes=*(*m_Tracks[m_SelectedTrack].paths)
 										[m_SelectedPath].nodes;
 	if ( t < 0 )
 		t = nodes[m_SelectedSplineNode].t;
 	sCinemaSplineNode newNode(x, y, z);
 	newNode.SetTime(t);
 	float delta = newNode.t - nodes[m_SelectedSplineNode].t;
 	paths[m_SelectedPath].duration = paths[m_SelectedPath].duration 
 															+ delta;
 	m_Tracks[m_SelectedTrack].duration = m_Tracks[m_SelectedTrack]
 													.duration + delta;
 
 	nodes[m_SelectedSplineNode] = newNode;
 	paths[m_SelectedPath].nodes = nodes;
 	m_Tracks[m_SelectedTrack].paths = paths;
 	UpdateEngineData();
 }
 void CinematicSidebar::UpdateSpinners()
 {
 	if ( m_SelectedTrack < 0 ) 
 		return;
 	int x = m_Tracks[m_SelectedTrack].x, y = m_Tracks[m_SelectedTrack].y,
 									z = m_Tracks[m_SelectedTrack].z;
 	m_SpinnerBox->UpdateTrackSpinners(x, y, z);
 	
 	if ( m_SelectedPath < 0 )
 		return;
 	sCinemaPath path = GetCurrentPath();
 	x = path.x, y = path.y, z = path.z;
 	
 	if ( m_RotationAbsolute )
 		GetAbsoluteRotation(x, y, z);
 	m_SpinnerBox->UpdatePathSpinners(x, y, z);
 	
 	if ( m_SelectedSplineNode < 0 )
 		return;
 
 	sCinemaSplineNode node = (*path.nodes)[m_SelectedSplineNode];
 	x = node.x, y = node.y, z = node.z;
 	float t = node.t;
 	m_SpinnerBox->UpdateNodeSpinners(x, y, z, t, m_SelectedSplineNode);
 }
 void CinematicSidebar::UpdateTexts()
 {
 	if ( m_SelectedTrack < 0 )
 		return;
 
 	m_CinemaBottomBar->Update(* m_Tracks[m_SelectedTrack].name, 
 						m_Tracks[m_SelectedTrack].timescale );
 	if ( m_SelectedPath >= 0 )
 	{
 		sCinemaPath path = GetCurrentPath();
 		m_InfoBox->Update(path);
 	}
 }
 void CinematicSidebar::UpdatePathInfo(int mode, int style, float growth, 
 				float change, bool drawAll, bool drawCurrent, bool drawLine)
 {
 	if ( m_SelectedTrack < 0 || m_SelectedPath < 0 )
 		return;
 	std::vector<sCinemaPath> paths = *m_Tracks[m_SelectedTrack].paths;
 	paths[m_SelectedPath].mode = mode;
 	paths[m_SelectedPath].style = style;
 	paths[m_SelectedPath].growth = growth;
 	paths[m_SelectedPath].change = change;
 	m_Tracks[m_SelectedTrack].paths = paths;
 	UpdateEngineData();
 	POST_MESSAGE( CinemaEvent, (*m_Tracks[m_SelectedTrack].name, 
 		eCinemaEventMode::SELECT, (int)m_SelectedPath, drawAll, 
 							drawCurrent, drawLine) );
 }
 void CinematicSidebar::UpdateEngineData()
 {
 	POST_COMMAND(SetCinemaTracks, (m_Tracks) );
 	UpdateSpinners();
 }
 void CinematicSidebar::GotoNode(ssize_t index)
 {
 	if ( m_SelectedTrack < 0 || m_SelectedPath < 0 ||
 								m_SelectedSplineNode < 0 )
 	{
 		return;
 	}
 	if ( index < 0 )
 		index = m_SelectedSplineNode;
 
 	std::vector<sCinemaPath> paths=*m_Tracks[m_SelectedTrack].paths;
 	std::vector<sCinemaSplineNode> nodes=*(*m_Tracks[m_SelectedTrack].paths)
 										[m_SelectedPath].nodes;
 	float nodeTime=0;
 	float pathTime=0;
 	for ( ssize_t i=0; i<=index; ++i )
 		nodeTime += nodes[i].t;
 	for ( ssize_t i=0; i<m_SelectedPath; ++i )
 		pathTime += (*m_Tracks[m_SelectedTrack].paths)[m_SelectedPath].duration;
 	
 	m_TimeElapsed = nodeTime;
 	m_AbsoluteTime = pathTime + nodeTime;
 	POST_MESSAGE(CinemaEvent,
 		( *m_Tracks[m_SelectedTrack].name, 
 			eCinemaEventMode::IMMEDIATE_TRACK, m_AbsoluteTime, 
 			m_InfoBox->GetDrawAll(), m_InfoBox->GetDrawCurrent(),
 			m_InfoBox->GetDrawLines() ) );
 	//this is just an echo if false
 	if ( m_AbsoluteTime / m_Tracks[m_SelectedTrack].duration + 
 			CINEMA_EPSILON < 1.f || !m_Playing )
 	{
 		m_SliderBox->Update();
 	}
 }
 
 void CinematicSidebar::GetAbsoluteRotation(int& x, int& y, int& z, ssize_t index)
 {
 	if ( index < 0 )
 		index = m_SelectedPath;
 	if ( m_SelectedTrack < 0 || index < 0 )
 		return;
 
 	std::vector<sCinemaPath> paths=*m_Tracks[m_SelectedTrack].paths;
 	sCinemaPath path;
 	for (ssize_t i=0; i <= index; ++i)
 			path = path + paths[i];
 
 	path.x = path.x + m_Tracks[m_SelectedTrack].x;
 	path.y = path.y + m_Tracks[m_SelectedTrack].y;
 	path.z = path.z + m_Tracks[m_SelectedTrack].z;
 	WrapCinemaPath(path);
 	x = path.x;
 	y = path.y;
 	z = path.z;
 }
 
 float CinematicSidebar::UpdateSelectedPath()
 {
 	size_t i=0;
 	std::vector<sCinemaPath>paths = *m_Tracks[m_SelectedTrack].paths;
 	for ( float time=0.0f; i < paths.size(); ++i )
 	{
 		float duration = paths[i].duration;
 		time += duration;
 		if ( time > m_AbsoluteTime )
 		{
 			static size_t index=(size_t)-1;
 			if ( index != i )
 			{
 				SelectPath((ssize_t)i);
 				index = i;
 			}
 			m_TimeElapsed = m_AbsoluteTime-(time-duration);
 			return m_TimeElapsed;
 		}
 	}
 	return m_TimeElapsed;
 }
Index: ps/trunk/source/tools/atlas/GameInterface/SharedTypes.h
===================================================================
--- ps/trunk/source/tools/atlas/GameInterface/SharedTypes.h	(revision 4647)
+++ ps/trunk/source/tools/atlas/GameInterface/SharedTypes.h	(revision 4648)
@@ -1,126 +1,239 @@
 #ifndef SHAREDTYPES_H__
 #define SHAREDTYPES_H__
 
 #include "Shareable.h"
 
 class wxPoint;
 class CVector3D;
 
 namespace AtlasMessage
 {
 
 // Represents a position in the game world, with an interface usable from the
 // UI (which usually knows only about screen space). Typically constructed
 // by the UI, then passed to the game which uses GetWorldSpace.
 
 struct Position
 {
 	Position() : type(0) { type0.x = type0.y = type0.z = 0.f;  }
 
 	// Constructs a position with specified world-space coordinates
 	Position(float x, float y, float z) : type(0) { type0.x = x; type0.y = y; type0.z = z; }
 	
 	// Constructs a position on the terrain underneath the screen-space coordinates
 	Position(const wxPoint& pt); // (implementation in ScenarioEditor.cpp)
 
 	// Store all possible position representations in a union, instead of something
 	// like inheritance and virtual functions, so we don't have to care about
 	// dynamic memory allocation across DLLs.
 	int type;
 	union {
 		struct { float x, y, z; } type0; // world-space coordinates
 		struct { int x, y; } type1; // screen-space coordinates, to be projected onto terrain
 		// type2: "same as previous" (e.g. for elevation-editing when the mouse hasn't moved)
 	};
 
 	// Constructs a position with the meaning "same as previous", which is handled
 	// in unspecified (but usually obvious) ways by different message handlers.
 	static Position Unchanged() { Position p; p.type = 2; return p; }
 
 	// Only for use in the game, not the UI.
 	// Implementations in Misc.cpp.
 	CVector3D GetWorldSpace(bool floating = false) const;
 	CVector3D GetWorldSpace(float h, bool floating = false) const;
 	CVector3D GetWorldSpace(const CVector3D& prev, bool floating = false) const;
 	void GetScreenSpace(float& x, float& y) const;
 };
 SHAREABLE_STRUCT(Position);
 
 
 struct Colour
 {
 	Colour()
 		: r(255), g(0), b(255)
 	{
 	}
 
 	Colour(unsigned char r, unsigned char g, unsigned char b)
 		: r(r), g(g), b(b)
 	{
 	}
 
 	unsigned char r, g, b;
 };
 SHAREABLE_STRUCT(Colour);
 
 
 typedef int ObjectID;
 inline bool ObjectIDIsValid(ObjectID id) { return (id >= 0); }
 
 
 struct sCinemaSplineNode
 {
 	Shareable<float> x, y, z, t;
 public:
 	sCinemaSplineNode(float px, float py, float pz) : x(px), y(py), z(pz), t(0.0f) {}
 	sCinemaSplineNode() {}
 	void SetTime(float _t) { t = _t; }
 };
 SHAREABLE_STRUCT(sCinemaSplineNode);
 
 struct sCinemaPath
 {
 	Shareable<std::vector<AtlasMessage::sCinemaSplineNode> > nodes;
 	Shareable<float> duration, x, y, z;
 	Shareable<int> mode, growth, change, style;	// change == switch point
 
 	sCinemaPath(float rx, float ry, float rz) : x(rx), y(ry), z(rz),
 		mode(0), style(0), change(0), growth(0), duration(0) {}
 	sCinemaPath() : x(0), y(0), z(0), mode(0), style(0),
 		change(0), growth(0), duration(0) {}
 
 	AtlasMessage::sCinemaPath operator-(const AtlasMessage::sCinemaPath& path)
 	{
 		return AtlasMessage::sCinemaPath(x - path.x, y - path.y, z - path.z);
 	}
 	AtlasMessage::sCinemaPath operator+(const AtlasMessage::sCinemaPath& path)
 	{
 		return AtlasMessage::sCinemaPath(x + path.x, y + path.y, z + path.z);
 	}
 };
 SHAREABLE_STRUCT(sCinemaPath);
 
 struct sCinemaTrack
 {
 	Shareable<std::wstring> name;
 	Shareable<float> x, y, z, timescale, duration;
 	Shareable<std::vector<AtlasMessage::sCinemaPath> > paths;
 
 public:
 	sCinemaTrack(float rx, float ry, float rz, std::wstring track) 
 		: x(rx), y(ry), z(rz), timescale(1.f), duration(0), name(track) {}
 	sCinemaTrack() : x(0), y(0), z(0), timescale(1.f), duration(0) {} 
 };
 SHAREABLE_STRUCT(sCinemaTrack);
 
 struct eCinemaEventMode { enum { SMOOTH, SELECT, IMMEDIATE_PATH, IMMEDIATE_TRACK }; };
 struct sCameraInfo
 {
 	Shareable<float> pX, pY, pZ, rX, rY, rZ;	// position and rotation
 };
 SHAREABLE_STRUCT(sCameraInfo);
 
 
+//******Triggers*****
+
+
+struct sTriggerParameter
+{
+	Shareable<int> row, column, xPos, yPos, xSize, ySize, parameterOrder;
+	Shareable<std::wstring> name, inputType, windowType;
+};
+SHAREABLE_STRUCT(sTriggerParameter);
+
+struct sTriggerSpec
+{
+	Shareable<std::vector<AtlasMessage::sTriggerParameter> > parameters;
+	Shareable<std::wstring> displayName, functionName;
+
+	bool operator== ( const std::wstring& name) const
+	{
+		return ( *displayName == name );
+	}
+};
+SHAREABLE_STRUCT(sTriggerSpec);
+
+
+struct sTriggerCondition
+{
+	sTriggerCondition() : linkLogic(1), not(false) {}
+	sTriggerCondition(const std::wstring& _name) : linkLogic(1), not(false), name(_name) {}
+	
+	//displayName is used for selecting choice items in Atlas
+	Shareable<std::wstring> name, functionName, displayName;	
+	Shareable< std::vector<std::wstring> > parameters;
+	
+	//0 = none, 1 = and, 2 = or
+	Shareable<int> linkLogic;
+	Shareable<bool> not;
+
+	bool operator== ( const std::wstring& _name ) const
+	{
+		return (*name == _name);
+	}
+};
+
+SHAREABLE_STRUCT(sTriggerCondition);
+
+struct sTriggerEffect
+{
+	sTriggerEffect() {}
+	sTriggerEffect(const std::wstring& _name) : name(_name) {}
+
+	Shareable<std::wstring> name, functionName, displayName;
+	Shareable< std::vector<std::wstring> > parameters;
+	//Shareable<bool> loop;
+
+	bool operator== ( const std::wstring& _name )
+	{
+		return (*name == _name);
+	}
+};
+SHAREABLE_STRUCT(sTriggerEffect);
+
+struct sTrigger
+{
+	Shareable<std::wstring> name, group;
+	Shareable< std::vector<sTriggerCondition> > conditions;
+	Shareable< std::vector<sTriggerEffect> > effects;
+	
+	//For beginnings, the index of the term it comes before.  For ends, the index it comes after
+	Shareable< std::vector<int> > logicBlocks, logicBlockEnds;
+	Shareable< std::vector<bool> > logicNots;	//true if logicBlocks are not-ed
+	Shareable<float> timeValue;
+	Shareable<int> maxRuns;
+	Shareable<bool> active;
+
+	sTrigger() : timeValue(0), maxRuns(-1), active(0) {}
+	sTrigger(std::wstring _name) : name(_name), timeValue(0), maxRuns(0), active(0) {}
+	bool operator== (const sTrigger& trigger)
+	{
+		return (*name == *trigger.name);
+	}
+	bool operator!= (const sTrigger& trigger)
+	{
+		return (*name != *trigger.name);
+	}
+};
+SHAREABLE_STRUCT(sTrigger);
+
+
+struct sTriggerGroup
+{
+	Shareable<std::wstring> name, parentName;
+	Shareable< std::vector<std::wstring> > children;
+	Shareable< std::vector<sTrigger> > triggers;
+	
+	sTriggerGroup() { }
+	sTriggerGroup(std::wstring _name) : name(_name) { }
+
+	bool operator== (const sTriggerGroup& group) const
+	{
+		return (*name == *group.name);
+	}
+	bool operator== (const std::wstring& _name) const
+	{
+		return (*name == _name);
+	}
+	/*bool operator!= (const sTriggerGroup& group)
+	{
+		return (*name != *group.name);
+	}*/
+};
+
+SHAREABLE_STRUCT(sTriggerGroup);
+
+
 }
 
 #endif // SHAREDTYPES_H__
Index: ps/trunk/source/tools/atlas/GameInterface/Messages.h
===================================================================
--- ps/trunk/source/tools/atlas/GameInterface/Messages.h	(revision 4647)
+++ ps/trunk/source/tools/atlas/GameInterface/Messages.h	(revision 4648)
@@ -1,351 +1,377 @@
 #ifndef MESSAGES_H__
 #define MESSAGES_H__
 
 #ifndef MESSAGES_SKIP_SETUP
 #include "MessagesSetup.h"
 #endif
 
 #include <vector>
 #include <string>
 
 // TODO: organisation, documentation, etc
 
 //////////////////////////////////////////////////////////////////////////
 
 MESSAGE(Init,
 		((bool, initsimulation)) // whether to initialise simulation/game-specific objects
 		);
 
 MESSAGE(Shutdown, );
 
 struct eRenderView { enum renderViews { NONE, GAME, ACTOR }; };
 
 MESSAGE(RenderEnable,
 		((int, view)) // eRenderView
 		);
 
 // SetViewParam: used for hints to the renderer, e.g. to set wireframe mode;
 // unrecognised param names are ignored
 MESSAGE(SetViewParamB,
 		((int, view)) // eRenderView
 		((std::wstring, name))
 		((bool, value))
 		);
 MESSAGE(SetViewParamC,
 		((int, view)) // eRenderView
 		((std::wstring, name))
 		((Colour, value))
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 QUERY(Ping, , );
 
 //////////////////////////////////////////////////////////////////////////
 
 MESSAGE(SetContext,
 		((void*, context))
 		);
 
 MESSAGE(ResizeScreen,
 		((int, width))
 		((int, height))
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 MESSAGE(GenerateMap,
 		((int, size)) // size in number of patches
 		);
 
 MESSAGE(LoadMap,
 		((std::wstring, filename))
 		);
 
 MESSAGE(SaveMap,
 		((std::wstring, filename))
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 MESSAGE(RenderStyle,
 		((bool, wireframe))
 		);
 
 MESSAGE(MessageTrace,
 		((bool, enable))
 		);
 
 MESSAGE(Screenshot,
 		((int, tiles)) // the final image will be (640*tiles)x(480*tiles)
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 MESSAGE(Brush,
 		((int, width)) // number of vertices
 		((int, height))
 		((std::vector<float>, data)) // width*height array
 		);
 
 MESSAGE(BrushPreview,
 		((bool, enable))
 		((Position, pos)) // only used if enable==true
 		);
 
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
 QUERY(GetTerrainGroups,
 	  , // no inputs
 	  ((std::vector<std::wstring>, groupnames))
 	  );
 
 struct sTerrainGroupPreview
 {
 	Shareable<std::wstring> name;
 	Shareable<std::vector<unsigned char> > imagedata; // RGB*size*size
 };
 SHAREABLE_STRUCT(sTerrainGroupPreview);
 
 QUERY(GetTerrainGroupPreviews,
 	  ((std::wstring, groupname))
 	  ((int, imagewidth))
 	  ((int, imageheight))
 	  ,
 	  ((std::vector<sTerrainGroupPreview>, previews))
 	  );
 
 
 //////////////////////////////////////////////////////////////////////////
 
 struct sObjectsListItem
 {
 	Shareable<std::wstring> id;
 	Shareable<std::wstring> name;
 	Shareable<int> type; // 0 = entity, 1 = actor
 };
 SHAREABLE_STRUCT(sObjectsListItem);
 
 QUERY(GetObjectsList,
 	  , // no inputs
 	  ((std::vector<sObjectsListItem>, objects)) // sorted by .name
 	  );
 
 struct sObjectSettings
 {
 	Shareable<int> player;
 	Shareable<std::vector<std::wstring> > selections;
 
 	// Some settings are immutable and therefore are ignored (and should be left
 	// empty) when passed from the editor to the game:
 
 	Shareable<std::vector<std::vector<std::wstring> > > variantgroups;
 };
 SHAREABLE_STRUCT(sObjectSettings);
 
 // Preview object in the game world - creates a temporary unit at the given
 // position, and removes it when the preview is next changed
 MESSAGE(ObjectPreview,
 		((std::wstring, id)) // or empty string => disable
 		((sObjectSettings, settings))
 		((Position, pos))
 		((bool, usetarget)) // true => use 'target' for orientation; false => use 'angle'
 		((Position, target))
 		((float, angle))
 		);
 
 COMMAND(CreateObject, NOMERGE,
 		((std::wstring, id))
 		((sObjectSettings, settings))
 		((Position, pos))
 		((bool, usetarget)) // true => use 'target' for orientation; false => use 'angle'
 		((Position, target))
 		((float, angle))
 		);
 
 // Set an actor to be previewed on its own (i.e. without the game world).
 // (Use RenderEnable to make it visible.)
 MESSAGE(SetActorViewer,
 		((std::wstring, id))
 		((std::wstring, animation))
 		((float, speed))
 		((bool, flushcache)) // true => unload all actor files before starting the preview (because we don't have proper hotloading yet)
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 QUERY(Exit,,); // no inputs nor outputs
 
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
 struct eScrollConstantDir { enum { FORWARDS, BACKWARDS, LEFT, RIGHT }; };
 MESSAGE(ScrollConstant,
 		((int, view)) // eRenderView
 		((int, dir)) // eScrollConstantDir
 		((float, speed)) // set speed 0.0f to stop scrolling
 		);
 
 struct eScrollType { enum { FROM, TO }; };
 MESSAGE(Scroll, // for scrolling by dragging the mouse FROM somewhere TO elsewhere
 		((int, view)) // eRenderView
 		((int, type)) // eScrollType
 		((Position, pos))
 		);
 
 MESSAGE(SmoothZoom,
 		((int, view)) // eRenderView
 		((float, amount))
 		);
 
 struct eRotateAroundType { enum { FROM, TO }; };
 MESSAGE(RotateAround,
 		((int, view)) // eRenderView
 		((int, type)) // eRotateAroundType
 		((Position, pos))
 		);
 
 MESSAGE(LookAt,
 		((int, view)) // eRenderView
 		((Position, pos))
 		((Position, target))
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 struct sEnvironmentSettings
 {
 	Shareable<float> waterheight; // range 0..1 corresponds to min..max terrain height; out-of-bounds values allowed
 	Shareable<float> watershininess; // range ???
 	Shareable<float> waterwaviness; // range ???
 	Shareable<float> watermurkiness; // range ???
 	
 	Shareable<Colour> watercolour;
 	Shareable<Colour> watertint;
 	Shareable<Colour> waterreflectiontint;
 	Shareable<float> waterreflectiontintstrength; // range ???
 
 	Shareable<float> sunrotation; // range -pi..+pi
 	Shareable<float> sunelevation; // range -pi/2 .. +pi/2
 
 	Shareable<std::wstring> skyset;
 
 	Shareable<Colour> suncolour;
 	Shareable<Colour> terraincolour;
 	Shareable<Colour> unitcolour;
 };
 SHAREABLE_STRUCT(sEnvironmentSettings);
 
 QUERY(GetEnvironmentSettings,
 	  // no inputs
 	  ,
 	  ((sEnvironmentSettings, settings))
 	  );
 
 COMMAND(SetEnvironmentSettings, MERGE,
 		((sEnvironmentSettings, settings))
 		);
 
 QUERY(GetSkySets,
 	  // no inputs
 	  ,
 	  ((std::vector<std::wstring>, skysets))
 	  );
 
 
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
 COMMAND(AlterElevation, MERGE,
 		((Position, pos))
 		((float, amount))
 		);
 
 COMMAND(FlattenElevation, MERGE,
 		((Position, pos))
 		((float, amount))
 		);
 
 struct ePaintTerrainPriority { enum { HIGH, LOW }; };
 COMMAND(PaintTerrain, MERGE,
 		((Position, pos))
 		((std::wstring, texture))
 		((int, priority)) // ePaintTerrainPriority
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 QUERY(PickObject,
 	  ((Position, pos))
 	  ,
 	  ((ObjectID, id))
 	  ((int, offsetx))  // offset of object centre from input position
 	  ((int, offsety)) //
 	  );
 
 COMMAND(MoveObject, MERGE,
 		((ObjectID, id))
 		((Position, pos))
 		);
 
 COMMAND(RotateObject, MERGE,
 		((ObjectID, id))
 		((bool, usetarget)) // true => use 'target' for orientation; false => use 'angle'
 		((Position, target))
 		((float, angle))
 		);
 
 COMMAND(DeleteObject, NOMERGE,
 		((ObjectID, id))
 		);
 
 MESSAGE(SetSelectionPreview,
 		((std::vector<ObjectID>, ids))
 		);
 
 QUERY(GetObjectSettings,
 	  ((int, view)) // eRenderView
 	  ((ObjectID, id))
 	  ,
 	  ((sObjectSettings, settings))
 	  );
 
 COMMAND(SetObjectSettings, NOMERGE,
 		((int, view)) // eRenderView
 		((ObjectID, id))
 		((sObjectSettings, settings))
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
 QUERY(GetCinemaTracks,
 	  , // no inputs
 	  ((std::vector<AtlasMessage::sCinemaTrack> , tracks))
 	  );
 
 QUERY(GetCameraInfo,
 	  ,
 	  ((AtlasMessage::sCameraInfo, info))
 	  );
 
 COMMAND(SetCinemaTracks, NOMERGE,
 		((std::vector<AtlasMessage::sCinemaTrack>, tracks))
 		);
 
 MESSAGE(CinemaEvent,
 		((std::wstring, track))
 		((int, mode))
 		((float, t))
 		((bool, drawAll))
 		((bool, drawCurrent))
 		((bool, lines))
 		);
 
 //////////////////////////////////////////////////////////////////////////
 
+enum eTriggerListType
+{
+	CINEMA_LIST,
+	TRIGGER_LIST,
+	TRIG_GROUP_LIST	//list of trigger groups
+	// [Eventually include things like entities and areas as the editor progresses...]
+};
+
+
+QUERY(GetTriggerData,
+	  , //no inputs
+	  ((std::vector<AtlasMessage::sTriggerGroup>, groups))
+	  ((std::vector<AtlasMessage::sTriggerSpec>, conditions))
+	  ((std::vector<AtlasMessage::sTriggerSpec>, effects))
+	  );
+
+QUERY(GetTriggerChoices,
+	  ((std::wstring, name)),
+	  ((std::vector<std::wstring>, choices))
+	  );
+		
+COMMAND(SetAllTriggers, NOMERGE, 
+	  ((std::vector<AtlasMessage::sTriggerGroup>, groups))
+	  );
+
+
 #ifndef MESSAGES_SKIP_SETUP
 #include "MessagesSetup.h"
 #endif
 
 #endif // MESSAGES_H__
Index: ps/trunk/source/tools/atlas/GameInterface/Handlers/TriggerHandler.cpp
===================================================================
--- ps/trunk/source/tools/atlas/GameInterface/Handlers/TriggerHandler.cpp	(nonexistent)
+++ ps/trunk/source/tools/atlas/GameInterface/Handlers/TriggerHandler.cpp	(revision 4648)
@@ -0,0 +1,321 @@
+#include "precompiled.h"
+
+#include "MessageHandler.h"
+#include "../CommandProc.h"
+#include "../Shareable.h"
+
+#include "simulation/TriggerManager.h"
+#include "ps/Game.h"
+//#include "../CommandProc.h"
+
+
+namespace AtlasMessage {
+
+sTriggerSpec TriggerSpecToAtlas(const CTriggerSpec& spec)
+{
+	sTriggerSpec atlasSpec;
+	std::vector< sTriggerParameter > atlasParameters;
+	const std::set<TriggerParameter>& parameters = spec.GetParameters();
+	
+	for ( std::set<TriggerParameter>::const_iterator it=parameters.begin(); it!=parameters.end(); ++it )
+	{
+		sTriggerParameter atlasParam;
+		atlasParam.column = it->column;
+		atlasParam.inputType = it->inputType;
+		atlasParam.name = it->name;
+		atlasParam.parameterOrder = it->parameterOrder;
+		atlasParam.row = it->row;
+		
+		atlasParam.windowType = it->windowType;
+		atlasParam.xPos = it->xPos;
+		atlasParam.yPos = it->yPos;
+		atlasParam.xSize = it->xSize;
+		atlasParam.ySize = it->ySize;
+		atlasParameters.push_back(atlasParam);
+	}
+	atlasSpec.functionName = spec.functionName;
+	atlasSpec.displayName = spec.displayName;
+	atlasSpec.parameters = atlasParameters;
+	return atlasSpec;
+}
+
+sTrigger TriggerToAtlas(const MapTrigger& trigger)
+{
+	sTrigger atlasTrigger;
+	atlasTrigger.active = trigger.active;
+	atlasTrigger.timeValue = trigger.timeValue;
+	atlasTrigger.maxRuns = trigger.maxRunCount;
+	atlasTrigger.group = trigger.groupName;
+	atlasTrigger.name = trigger.name;
+	
+	std::vector<bool> atlasNots;
+	std::vector<int> atlasBlocks, atlasBlockEnds;
+	
+	for ( std::set<MapTriggerLogicBlock>::const_iterator it = trigger.logicBlocks.begin();
+												it != trigger.logicBlocks.end(); ++it )
+	{
+		atlasBlocks.push_back( (int)it->index );
+		atlasNots.push_back( it->not );
+	}
+	for ( std::set<size_t>::const_iterator it = trigger.logicBlockEnds.begin(); 
+										it != trigger.logicBlockEnds.end(); ++it )
+	{
+		atlasBlockEnds.push_back( (int)*it );
+	}
+	atlasTrigger.logicNots = atlasNots;
+	atlasTrigger.logicBlocks = atlasBlocks;
+	atlasTrigger.logicBlockEnds = atlasBlockEnds;
+	
+	std::vector<sTriggerCondition> atlasConditions;
+	std::vector<sTriggerEffect> atlasEffects;
+	
+	for ( std::list<MapTriggerCondition>::const_iterator it = trigger.conditions.begin();
+											it != trigger.conditions.end(); ++it )
+	{
+		sTriggerCondition atlasCondition;
+		atlasCondition.linkLogic = it->linkLogic;
+		atlasCondition.name = it->name;
+		atlasCondition.functionName = it->functionName;
+		atlasCondition.displayName = it->displayName;
+		atlasCondition.not = it->not;
+		std::vector<std::wstring> parameters;
+		
+		for ( std::list<CStrW>::const_iterator it2=it->parameters.begin(); 
+													it2 != it->parameters.end(); ++it2 )
+		{
+			parameters.push_back( std::wstring(it2->c_str()) );
+		}
+		
+		atlasCondition.parameters = parameters;
+		atlasConditions.push_back(atlasCondition);
+	}
+
+	for ( std::list<MapTriggerEffect>::const_iterator it = trigger.effects.begin();
+														it != trigger.effects.end(); ++it )
+	{
+		sTriggerEffect atlasEffect;
+		std::vector<std::wstring> parameters;
+		atlasEffect.name = it->name;
+		atlasEffect.functionName = it->functionName;
+		atlasEffect.displayName = it->displayName;
+
+		for ( std::list<CStrW>::const_iterator it2 = it->parameters.begin(); 
+													it2 != it->parameters.end(); ++it2 )
+		{
+			parameters.push_back( std::wstring(it2->c_str()) );
+		}
+		atlasEffect.parameters = parameters;
+		atlasEffects.push_back( atlasEffect );
+	}
+
+	atlasTrigger.conditions = atlasConditions;
+	atlasTrigger.effects = atlasEffects;
+	return atlasTrigger;
+}
+
+sTriggerGroup GroupToAtlas(const MapTriggerGroup& group)
+{
+	sTriggerGroup atlasGroup;
+	atlasGroup.parentName = group.parentName;
+	atlasGroup.name = group.name;
+	
+	std::vector<sTrigger> atlasTriggers;
+	std::vector<std::wstring> atlasChildren;
+	for ( std::list<MapTrigger>::const_iterator it = group.triggers.begin(); 
+											it != group.triggers.end(); ++it )
+	{
+		atlasTriggers.push_back( TriggerToAtlas(*it) );
+	}
+	for ( std::list<CStrW>::const_iterator it = group.childGroups.begin();
+											it != group.childGroups.end(); ++it )
+	{
+		atlasChildren.push_back( std::wstring(it->c_str()) );
+	}
+	
+	atlasGroup.triggers = atlasTriggers;
+	atlasGroup.children = atlasChildren;
+	return atlasGroup;
+}
+
+MapTrigger AtlasToTrigger(const sTrigger& trigger)
+{
+	MapTrigger engineTrigger;
+	
+	engineTrigger.active = trigger.active;
+	engineTrigger.groupName = *trigger.group;
+
+	std::vector<int> blockEnds = *trigger.logicBlockEnds, blocks = *trigger.logicBlocks;
+	std::copy( blockEnds.begin(), blockEnds.end(), engineTrigger.logicBlockEnds.begin() );
+	std::copy( blocks.begin(), blocks.end(), engineTrigger.logicBlocks.begin() );
+
+	engineTrigger.maxRunCount = trigger.maxRuns;
+	engineTrigger.name = *trigger.name;
+	engineTrigger.timeValue = trigger.timeValue;
+	
+	std::vector<sTriggerCondition> conditions = *trigger.conditions;
+	std::vector<sTriggerEffect> effects = *trigger.effects;
+
+	for ( std::vector<sTriggerCondition>::const_iterator it = conditions.begin(); it != conditions.end(); ++it )
+	{
+		engineTrigger.conditions.push_back( MapTriggerCondition() );
+		MapTriggerCondition* cond = &engineTrigger.conditions.back();
+		
+		cond->functionName = *it->functionName;
+		cond->displayName = *it->displayName;
+		cond->linkLogic = it->linkLogic;
+		cond->name = *it->name;
+		cond->not = it->not;
+		
+		std::vector<std::wstring> parameters = *it->parameters;
+		for ( std::vector<std::wstring>::const_iterator it2 = parameters.begin(); it2 != parameters.end(); ++it2 )
+		{
+			cond->parameters.push_back( CStrW(*it2) );
+		}
+	}
+
+	for ( std::vector<sTriggerEffect>::const_iterator it = effects.begin(); it != effects.end(); ++it )
+	{
+		engineTrigger.effects.push_back( MapTriggerEffect() );
+		MapTriggerEffect* effect = &engineTrigger.effects.back();
+
+		effect->functionName = *it->functionName;
+		effect->displayName = *it->displayName;
+		effect->name = *it->name;
+		std::vector<std::wstring> parameters = *it->parameters;
+
+		for ( std::vector<std::wstring>::const_iterator it2 = parameters.begin(); it2 != parameters.end(); ++it2 )
+		{
+			effect->parameters.push_back( CStrW(*it2) );
+		}
+	}
+
+	return engineTrigger;
+}
+
+
+MapTriggerGroup AtlasToGroup(const sTriggerGroup& group)
+{
+	MapTriggerGroup engineGroup;
+	engineGroup.parentName = *group.parentName;
+	engineGroup.name = *group.name;
+	
+	std::list<MapTrigger> engineTriggers;
+	std::vector<std::wstring> atlasChildren = *group.children;
+	std::vector<sTrigger> atlasTriggers = *group.triggers;
+	
+	for ( std::vector<sTrigger>::const_iterator it = atlasTriggers.begin(); 
+													it != atlasTriggers.end(); ++it )
+	{
+		engineTriggers.push_back( AtlasToTrigger(*it) );
+	}
+	for ( std::vector<std::wstring>::const_iterator it = atlasChildren.begin(); it != atlasChildren.end(); ++it )
+		engineGroup.childGroups.push_back(*it);
+	
+	engineGroup.triggers = engineTriggers;
+	return engineGroup;
+}
+
+std::vector<sTriggerGroup> GetCurrentTriggers()
+{
+	const std::list<MapTriggerGroup>& groups = g_TriggerManager.GetAllTriggerGroups();
+	std::vector<sTriggerGroup> atlasGroups;
+
+	for ( std::list<MapTriggerGroup>::const_iterator it = groups.begin(); it != groups.end(); ++it )
+		atlasGroups.push_back( GroupToAtlas(*it) );
+	return atlasGroups;
+}
+
+void SetCurrentTriggers(const std::vector<sTriggerGroup>& groups)
+{
+	std::list<MapTriggerGroup> engineGroups;
+	for ( std::vector<sTriggerGroup>::const_iterator it = groups.begin(); it != groups.end(); ++it )
+		engineGroups.push_back( AtlasToGroup(*it) );
+	g_TriggerManager.SetAllGroups(engineGroups);
+}
+
+QUERYHANDLER(GetTriggerData)
+{
+	const std::list<CTriggerCondition>& conditions = g_TriggerManager.GetAllConditions();
+	const std::list<CTriggerEffect>& effects = g_TriggerManager.GetAllEffects();
+	std::vector<sTriggerSpec> atlasConditions;
+	std::vector<sTriggerSpec> atlasEffects;
+
+	for ( std::list<CTriggerCondition>::const_iterator it=conditions.begin(); it!=conditions.end(); ++it )
+		atlasConditions.push_back( TriggerSpecToAtlas(*it) );
+	for ( std::list<CTriggerEffect>::const_iterator it=effects.begin(); it!=effects.end(); ++it )
+		atlasEffects.push_back( TriggerSpecToAtlas(*it) );
+	
+	msg->conditions = atlasConditions;
+	msg->effects = atlasEffects;
+	msg->groups = GetCurrentTriggers();
+}
+
+QUERYHANDLER(GetTriggerChoices)
+{
+	std::vector<std::wstring> choices = g_TriggerManager.GetTriggerChoices( CStrW(*msg->name) );
+	if ( choices.empty() )
+		return;
+	
+	//If a special list (i.e. uses engine data)
+	if ( choices.size() == 1 )
+	{
+		
+		if ( choices[0] == std::wstring(L"ATLAS_CINEMA_LIST") )
+		{
+			choices.clear();
+			const std::map<CStrW, CCinemaTrack>& tracks = g_Game->GetView()->GetCinema()->GetAllTracks();
+			for ( std::map<CStrW, CCinemaTrack>::const_iterator it = tracks.begin(); it != tracks.end(); ++it )
+				choices.push_back(it->first);
+		}
+		else if ( choices[0] == std::wstring(L"ATLAS_TRIGGER_LIST") )
+		{
+			choices.clear();
+			const std::list<MapTriggerGroup>& groups = g_TriggerManager.GetAllTriggerGroups();
+			for ( std::list<MapTriggerGroup>::const_iterator it = groups.begin(); 
+															it != groups.end(); ++it )
+			{
+				for ( std::list<MapTrigger>::const_iterator it2 = it->triggers.begin(); 
+													it2 != it->triggers.end(); ++it2 )
+				{
+					choices.push_back(it2->name);
+				}
+			}
+		}
+		else if ( choices[0] == std::wstring(L"ATLAS_TRIG_GROUP_LIST") )
+		{
+			choices.clear();
+			const std::list<MapTriggerGroup>& groups = g_TriggerManager.GetAllTriggerGroups();
+			for ( std::list<MapTriggerGroup>::const_iterator it = groups.begin(); 
+															it != groups.end(); ++it )
+			{
+				choices.push_back(it->name);
+			}
+		}
+		else
+			debug_warn("Invalid choice list for trigger specification parameter");
+	}
+	msg->choices = choices;
+}
+
+BEGIN_COMMAND(SetAllTriggers)
+{
+	std::vector<sTriggerGroup> m_oldGroups, m_newGroups;
+
+	void Do()
+	{
+		m_oldGroups = GetCurrentTriggers();
+		m_newGroups = *msg->groups;
+		Redo();
+	}
+	void Redo()
+	{
+		SetCurrentTriggers(m_newGroups);
+	}
+	void Undo()
+	{
+		SetCurrentTriggers(m_oldGroups);
+	}
+};
+END_COMMAND(SetAllTriggers);
+
+}
\ No newline at end of file
Index: ps/trunk/source/tools/atlas/GameInterface/Shareable.h
===================================================================
--- ps/trunk/source/tools/atlas/GameInterface/Shareable.h	(revision 4647)
+++ ps/trunk/source/tools/atlas/GameInterface/Shareable.h	(revision 4648)
@@ -1,281 +1,282 @@
 #ifndef SHAREABLE_H__
 #define SHAREABLE_H__
 
 /*
 
 The Atlas UI DLL needs to share information with the game EXE. It's most
 convenient if they can pass STL objects, like std::wstring and std::vector;
 but that causes problems if the DLL and EXE were not compiled in exactly
 the same way.
 
 So, the Shareable<T> class is used to make things a bit safer:
 Simple types (primitives, basic structs, etc) are passed as normal.
 std::string is converted to an array, using a shared (and thread-safe) memory
 allocation function so that it works when the DLL and EXE use different heaps. 
 std::vector is done the same, though its element type must be Shareable too.
 
 This ought to protect against:
 * Different heaps (msvcr71 vs msvcr80, debug vs release, etc).
 * Different STL class layout.
 It doesn't protect against:
 * Different data type sizes/ranges.
 * Different packing in our structs. (But they're very simple structs,
 only storing size_t and pointer values.)
 * Vtable layout - this code doesn't actually care, but the rest of Atlas does.
 
 Usage should be fairly transparent - conversions from T to Shareable<T> are
 automatic, and the opposite is automatic for primitive types.
 For basic structs, use operator-> to access members (e.g. "msg->sharedstruct->value").
 For more complex things (strings, vectors), use the unary operator* to get back
 an STL object (e.g. "std::string s = *msg->sharedstring").
 (That conversion to an STL object is potentially expensive, so
 Shareable<string>.c_str() and Shareable<vector>.GetBuffer/GetSize() can be used
 if that's all you need.)
 
 The supported list of primitive types is below (SHAREABLE_PRIMITIVE).
 Structs are made shareable by manually ensuring that all their members are
 shareable (i.e. primitives and Shareable<T>s) and writing
 	SHAREABLE_STRUCTS(StructName);
 after their definition.
 
 */
 
 #include "SharedMemory.h"
 
 #include <vector>
 
 // We want to use placement new, which breaks when compiling Debug configurations
 // in the game and in wx, and they both need different workarounds.
 // (Duplicated in SharedMemory.h)
 #ifdef new
 # define SHAREABLE_USED_NOMMGR
 # ifdef __WXWINDOWS__
 #  undef new
 # else
 #  include "nommgr.h"
 # endif
 #endif
 
 namespace AtlasMessage
 {
 
 // By default, things are not shareable
 template <typename T> class Shareable
 {
 public:
 	Shareable();
 	enum { TypeIsShareable = 0 };
 };
 
 // Primitive types just need a very simple wrapper
 #define SHAREABLE_PRIMITIVE(T) \
 	template<> class Shareable<T> \
 	{ \
 		T m; \
 	public: \
 		enum { TypeIsShareable = 1 }; \
 		Shareable() {} \
 		Shareable(T const& rhs) { m = rhs; } \
 		operator const T() const { return m; } \
 		const T _Unwrap() const { return m; } \
 	}
 
 SHAREABLE_PRIMITIVE(unsigned char);
 SHAREABLE_PRIMITIVE(int);
+SHAREABLE_PRIMITIVE(long);
 SHAREABLE_PRIMITIVE(bool);
 SHAREABLE_PRIMITIVE(float);
 SHAREABLE_PRIMITIVE(void*);
 
 #undef SHAREABLE_PRIMITIVE
 
 // Structs are similar to primitives, but with operator->
 #define SHAREABLE_STRUCT(T) \
 	template<> class Shareable<T> \
 	{ \
 		T m; \
 	public: \
 		enum { TypeIsShareable = 1 }; \
 		Shareable() {} \
 		Shareable(T const& rhs) { m = rhs; } \
 		const T* operator->() const { return &m; } \
 		operator const T() const { return m; } \
 		const T _Unwrap() const { return m; } \
 	}
 
 
 // Shareable containers must have shareable contents - but it's easy to forget
 // to declare them, so make sure the errors are almost readable, like:
 //   "use of undefined type 'REQUIRE_TYPE_TO_BE_SHAREABLE_FAILURE<T,__formal>
 //      with [ T=AtlasMessage::sTerrainGroupPreview, __formal=false ]"
 //
 // (Implementation based on boost/static_assert)
 template <typename T, bool> struct REQUIRE_TYPE_TO_BE_SHAREABLE_FAILURE;
 template <typename T> struct REQUIRE_TYPE_TO_BE_SHAREABLE_FAILURE<T, true>{};
 template<int x> struct static_assert_test{};
 #define ASSERT_TYPE_IS_SHAREABLE(T) typedef static_assert_test< \
 	sizeof(REQUIRE_TYPE_TO_BE_SHAREABLE_FAILURE< T, (bool)(Shareable<T>::TypeIsShareable) >)> \
 	static_assert_typedef_
 
 // Should be an empty string when cast to either char* or wchar_t*
 // (which requires length >= 4, since GCC's sizeof(wchar_t)==4)
 static const char empty_str[4] = { 0, 0, 0, 0 };
 
 // Shareable strings:
 template<typename C> class Shareable< std::basic_string<C> >
 {
 	typedef std::basic_string<C> wrapped_type;
 
 	C* buf; // null-terminated string (perhaps with embedded nulls)
 	size_t length; // size of buf (including null)
 public:
 	enum { TypeIsShareable = 1 };
 
 	Shareable() : buf(NULL), length(0) {}
 
 	Shareable(const wrapped_type& rhs)
 	{
 		length = rhs.length()+1;
 		buf = (C*)ShareableMallocFptr(sizeof(C)*length);
 		memcpy(buf, rhs.c_str(), sizeof(C)*length);
 	}
 
 	~Shareable()
 	{
 		ShareableFreeFptr(buf);
 	}
 
 	Shareable<wrapped_type>& operator=(const Shareable<wrapped_type>& rhs)
 	{
 		if (&rhs == this)
 			return *this;
 		ShareableFreeFptr(buf);
 		length = rhs.length;
 		buf = (C*)ShareableMallocFptr(sizeof(C)*length);
 		memcpy(buf, rhs.buf, sizeof(C)*length);
 		return *this;
 	}
 
 	Shareable(const Shareable<wrapped_type>& rhs)
 		: buf(NULL), length(0)
 	{
 		*this = rhs;
 	}
 
 	const wrapped_type _Unwrap() const
 	{
 		return (buf && length) ? wrapped_type(buf, buf+length-1) : wrapped_type();
 	}
 
 	const wrapped_type operator*() const
 	{
 		return _Unwrap();
 	}
 
 	// Minor optimisation for code that just wants to access the characters,
 	// without constructing a new std::basic_string then calling c_str on that
 	const C* c_str() const
 	{
 		return (buf && length) ? buf : (C*)empty_str;
 	}
 };
 
 // Shareable vectors:
 template<typename E> class Shareable<std::vector<E> >
 {
 	ASSERT_TYPE_IS_SHAREABLE(E);
 	typedef std::vector<E> wrapped_type;
 	typedef Shareable<E> element_type;
 	element_type* array;
 	size_t size;
 
 	// Since we're allocating with malloc (roughly), but storing non-trivial
 	// objects, we have to allocate with placement new and call destructors
 	// manually. (At least the objects are usually just other Shareables, so it's
 	// reasonably safe to assume there's no exceptions or other confusingness.)
 	void Unalloc()
 	{
 		if (array == NULL)
 			return;
 
 		for (size_t i = 0; i < size; ++i)
 			array[i].~element_type();
 		ShareableFreeFptr(array);
 
 		array = NULL;
 		size = 0;
 	}
 
 public:
 	enum { TypeIsShareable = 1 };
 
 	Shareable() : array(NULL), size(0) {}
 
 	Shareable(const wrapped_type& rhs)
 	{
 		size = rhs.size();
 		array = static_cast<element_type*> (ShareableMallocFptr( sizeof(element_type)*size ));
 		for (size_t i = 0; i < size; ++i)
 			new (&array[i]) element_type (rhs[i]);
 	}
 
 	~Shareable()
 	{
 		Unalloc();
 	}
 
 	Shareable<wrapped_type>& operator=(const Shareable<wrapped_type>& rhs)
 	{
 		if (&rhs == this)
 			return *this;
 		Unalloc();
 		size = rhs.size;
 		array = static_cast<element_type*> (ShareableMallocFptr( sizeof(element_type)*size ));
 		for (size_t i = 0; i < size; ++i)
 			new (&array[i]) element_type (rhs.array[i]);
 		return *this;
 	}
 
 	Shareable(const Shareable<wrapped_type>& rhs)
 		: array(NULL), size(0)
 	{
 		*this = rhs;
 	}
 
 	const wrapped_type _Unwrap() const
 	{
 		wrapped_type r;
 		r.reserve(size);
 		for (size_t i = 0; i < size; ++i)
 			r.push_back(array[i]._Unwrap());
 		return r;
 	}
 
 	const wrapped_type operator*() const
 	{
 		return _Unwrap();
 	}
 
 	// Minor optimisation for code that just wants to access the buffer,
 	// without constructing a new std::vector
 	const element_type* GetBuffer() const
 	{
 		return array;
 	}
 	size_t GetSize() const
 	{
 		return size;
 	}
 };
 
 }
 
 #ifdef SHAREABLE_USED_NOMMGR
 # ifdef __WXWINDOWS__ // TODO: portability to non-Windows wx
 #  define new  new( _NORMAL_BLOCK, __FILE__, __LINE__)
 # else
 #  include "mmgr.h"
 # endif
 # undef SHAREABLE_USED_NOMMGR
 #endif
 
 #endif // SHAREABLE_H__
Index: ps/trunk/source/ps/GameSetup/GameSetup.cpp
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 4647)
+++ ps/trunk/source/ps/GameSetup/GameSetup.cpp	(revision 4648)
@@ -1,1106 +1,1113 @@
 #include "precompiled.h"
 
 #include "lib/lib.h"
 #include "lib/sdl.h"
 #include "lib/ogl.h"
 #include "lib/timer.h"
 #include "lib/input.h"
 #include "lib/app_hooks.h"
 #include "lib/sysdep/cpu.h"
 #include "lib/sysdep/gfx.h"
 #include "lib/res/res.h"
 #include "lib/res/file/trace.h"
 #include "lib/res/sound/snd_mgr.h"
 #include "lib/res/graphics/tex.h"
 #include "lib/res/graphics/cursor.h"
 
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Font.h"
 #include "ps/Game.h"
 #include "ps/Globals.h"
 #include "ps/Hotkey.h"
 #include "ps/Interact.h"
 #include "ps/Loader.h"
 #include "ps/Overlay.h"
 #include "ps/Profile.h"
 #include "ps/ProfileViewer.h"
 #include "ps/StringConvert.h"
 #include "ps/Util.h"
 #include "ps/i18n.h"
 
 #include "graphics/GameView.h"
 #include "graphics/LightEnv.h"
 #include "graphics/MapReader.h"
 #include "graphics/MaterialManager.h"
 #include "graphics/MeshManager.h"
 #include "graphics/Model.h"
 #include "graphics/ObjectManager.h"
 #include "graphics/ParticleEngine.h"
 #include "graphics/SkeletonAnimManager.h"
 #include "graphics/Terrain.h"
 #include "graphics/TextureManager.h"
 #include "graphics/Unit.h"
 #include "graphics/UnitManager.h"
 
 #include "renderer/Renderer.h"
 #include "renderer/VertexBufferManager.h"
 
 #include "maths/MathUtil.h"
 
 #include "simulation/Entity.h"
 #include "simulation/EntityHandles.h"
 #include "simulation/EntityManager.h"
 #include "simulation/EntityTemplate.h"
 #include "simulation/EntityTemplateCollection.h"
 #include "simulation/EventHandlers.h"
 #include "simulation/FormationCollection.h"
 #include "simulation/FormationManager.h"
 #include "simulation/TerritoryManager.h"
+#include "simulation/TriggerManager.h"
 #include "simulation/PathfindEngine.h"
 #include "simulation/Projectile.h"
 #include "simulation/Scheduler.h"
 #include "simulation/TechnologyCollection.h"
 
 #include "scripting/ScriptableComplex.inl"
 #include "scripting/ScriptingHost.h"
 #include "scripting/GameEvents.h"
 #include "scripting/ScriptableComplex.h"
 #include "maths/scripting/JSInterface_Vector3D.h"
 #include "graphics/scripting/JSInterface_Camera.h"
 #include "ps/scripting/JSInterface_Selection.h"
 #include "ps/scripting/JSInterface_Console.h"
 #include "graphics/scripting/JSInterface_LightEnv.h"
 #include "ps/scripting/JSCollection.h"
 #include "scripting/DOMEvent.h"
 #ifndef NO_GUI
 # include "gui/scripting/JSInterface_IGUIObject.h"
 # include "gui/scripting/JSInterface_GUITypes.h"
 # include "gui/GUI.h"
 #endif
 
 #include "sound/CMusicPlayer.h"
 #include "sound/JSI_Sound.h"
 
 #include "network/SessionManager.h"
 #include "network/Server.h"
 #include "network/Client.h"
 
 #include "Atlas.h"
 #include "GameSetup.h"
 #include "Config.h"
 
 ERROR_GROUP(System);
 ERROR_TYPE(System, SDLInitFailed);
 ERROR_TYPE(System, VmodeFailed);
 ERROR_TYPE(System, RequiredExtensionsMissing);
 
 #define LOG_CATEGORY "gamesetup"
 
 
 
 
 
 static int SetVideoMode(int w, int h, int bpp, bool fullscreen)
 {
 	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
 	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 
 	ulong flags = SDL_OPENGL;
 	if(fullscreen)
 		flags |= SDL_FULLSCREEN;
 	if(!SDL_SetVideoMode(w, h, bpp, flags))
 		return -1;
 
 	// Work around a bug in the proprietary Linux ATI driver (at least versions 8.16.20 and 8.14.13).
 	// The driver appears to register its own atexit hook on context creation.
 	// If this atexit hook is called before SDL_Quit destroys the OpenGL context,
 	// some kind of double-free problem causes a crash and lockup in the driver.
 	// Calling SDL_Quit twice appears to be harmless, though, and avoids the problem
 	// by destroying the context *before* the driver's atexit hook is called.
 	// (Note that atexit hooks are guarantueed to be called in reverse order of their registration.)
 	atexit(SDL_Quit);
 	// End work around.
 
 	glViewport(0, 0, w, h);
 
 #ifndef NO_GUI
 	g_GUI.UpdateResolution();
 #endif
 
 	oglInit();	// required after each mode change
 
 	if(SDL_SetGamma(g_Gamma, g_Gamma, g_Gamma) < 0)
 		debug_warn("SDL_SetGamma failed");
 
 	return 0;
 }
 
 static const uint SANE_TEX_QUALITY_DEFAULT = 5;	// keep in sync with code
 
 static void SetTextureQuality(uint quality)
 {
 	uint q_flags;
 	GLint filter;
 
 retry:
 	// keep this in sync with SANE_TEX_QUALITY_DEFAULT
 	switch(quality)
 	{
 		// worst quality
 	case 0:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST;
 		break;
 		// [perf] add bilinear filtering
 	case 1:
 		q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] no longer reduce resolution
 	case 2:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR;
 		break;
 		// [vmem] add mipmaps
 	case 3:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_NEAREST_MIPMAP_LINEAR;
 		break;
 		// [perf] better filtering
 	case 4:
 		q_flags = OGL_TEX_HALF_BPP;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [vmem] no longer reduce bpp
 	case SANE_TEX_QUALITY_DEFAULT:
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// [perf] add anisotropy
 	case 6:
 		// TODO: add anisotropic filtering
 		q_flags = OGL_TEX_FULL_QUALITY;
 		filter = GL_LINEAR_MIPMAP_LINEAR;
 		break;
 		// invalid
 	default:
 		debug_warn("SetTextureQuality: invalid quality");
 		quality = SANE_TEX_QUALITY_DEFAULT;
 		// careful: recursion doesn't work and we don't want to duplicate
 		// the "sane" default values.
 		goto retry;
 	}
 
 	ogl_tex_set_defaults(q_flags, filter);
 }
 
 
 //----------------------------------------------------------------------------
 // GUI integration
 //----------------------------------------------------------------------------
 
 void GUI_Init()
 {
 #ifndef NO_GUI
 	{TIMER("ps_gui_init");
 	g_GUI.Initialize();}
 
 	{TIMER("ps_gui_setup_xml");
 	g_GUI.LoadXMLFile("gui/test/setup.xml");}
 	{TIMER("ps_gui_styles_xml");
 	g_GUI.LoadXMLFile("gui/test/styles.xml");}
 	{TIMER("ps_gui_sprite1_xml");
 	g_GUI.LoadXMLFile("gui/test/sprite1.xml");}
 
 	// Atlas is running, we won't need these GUI pages (for now!
 	// what if Atlas switches to in-game mode?!)
 	// TODO: temporary hack until revised GUI structure is completed.
 //	if(ATLAS_IsRunning())
 //		return;
 
 	{TIMER("ps_gui_1");
 	g_GUI.LoadXMLFile("gui/test/1_init.xml");}
 	{TIMER("ps_gui_2");
 	g_GUI.LoadXMLFile("gui/test/2_mainmenu.xml");}
 	{TIMER("ps_gui_3");
 	g_GUI.LoadXMLFile("gui/test/3_loading.xml");}
 	{TIMER("ps_gui_4");
 	g_GUI.LoadXMLFile("gui/test/4_session.xml");}
 	{TIMER("ps_gui_6");
 	g_GUI.LoadXMLFile("gui/test/6_subwindows.xml");}
 	{TIMER("ps_gui_6_1");
 	g_GUI.LoadXMLFile("gui/test/6_1_manual.xml");}
 	{TIMER("ps_gui_6_2");
 	g_GUI.LoadXMLFile("gui/test/6_2_jukebox.xml");}
 	{TIMER("ps_gui_7");
 	g_GUI.LoadXMLFile("gui/test/7_atlas.xml");}
 	{TIMER("ps_gui_9");
 	g_GUI.LoadXMLFile("gui/test/9_global.xml");}
 #endif
 }
 
 
 void GUI_Shutdown()
 {
 #ifndef NO_GUI
 	g_GUI.Destroy();
 	delete &g_GUI;
 #endif
 }
 
 
 void GUI_ShowMainMenu()
 {
 
 }
 
 
 // display progress / description in loading screen
 void GUI_DisplayLoadProgress(int percent, const wchar_t* pending_task)
 {
 #ifndef NO_GUI
 	CStrW i18n_description = I18n::translate(pending_task);
 	JSString* js_desc = StringConvert::wstring_to_jsstring(g_ScriptingHost.getContext(), i18n_description);
 	g_ScriptingHost.SetGlobal("g_Progress", INT_TO_JSVAL(percent));
 	g_ScriptingHost.SetGlobal("g_LoadDescription", STRING_TO_JSVAL(js_desc));
 	g_GUI.SendEventToAll("progress");
 #endif
 }
 
 
 
 void Render()
 {
 	MICROLOG(L"begin frame");
 
 	oglCheck();
 
 #ifndef NO_GUI // HACK: because colour-parsing requires the GUI
 	CStr skystring = "61 193 255";
 	CFG_GET_USER_VAL("skycolor", String, skystring);
 	CColor skycol;
 	GUI<CColor>::ParseString(skystring, skycol);
 	g_Renderer.SetClearColor(skycol.Int());
 #endif
 
 	// start new frame
 	g_Renderer.BeginFrame();
 
 	oglCheck();
 
 	if (g_Game && g_Game->IsGameStarted())
 	{
 		g_Game->GetView()->Render();
 
 		glPushAttrib( GL_ENABLE_BIT );
 		glDisable( GL_LIGHTING );
 		glDisable( GL_TEXTURE_2D );
 		glDisable( GL_DEPTH_TEST );
 
 		if( g_EntGraph )
 		{
 			PROFILE( "render entity overlays" );
 			glColor3f( 1.0f, 0.0f, 1.0f );
 			g_EntityManager.renderAll(); // <-- collision outlines, pathing routes
 		}
 
 		glEnable( GL_DEPTH_TEST );
 
 		PROFILE_START( "render entity outlines" );
 		g_Mouseover.renderSelectionOutlines();
 		g_Selection.renderSelectionOutlines();
 		PROFILE_END( "render entity outlines" );
 		
 		PROFILE_START( "render entity auras" );
 		g_Mouseover.renderAuras();
 		g_Selection.renderAuras();
 		PROFILE_END( "render entity auras" );
 
 		glDisable(GL_DEPTH_TEST);
 
 		PROFILE_START( "render entity bars" );
 		pglActiveTextureARB(GL_TEXTURE1_ARB);
 		glDisable(GL_TEXTURE_2D);
 		pglActiveTextureARB(GL_TEXTURE0_ARB);
 		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
 		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
 		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
 		glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
 		glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
 		glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
 		glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
 		glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, g_Renderer.m_Options.m_LodBias);
 		glMatrixMode(GL_TEXTURE);
 		glLoadIdentity();
 		/*glMatrixMode(GL_PROJECTION);
 		glPushMatrix();
 		glLoadIdentity();
 		glOrtho(0.f, (float)g_xres, 0.f, (float)g_yres, -1.0f, 1000.f);
 		glMatrixMode(GL_MODELVIEW);
 		glPushMatrix();
 		glLoadIdentity();*/
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 		g_Mouseover.renderBars();
 		g_Selection.renderBars();
 		
 		glDisable(GL_BLEND);
 		/*glPopMatrix();
 		glMatrixMode(GL_PROJECTION);
 		glPopMatrix();
 		glMatrixMode(GL_MODELVIEW);*/
 		PROFILE_END( "render entity bars" );
 
 		glPopAttrib();
 		glMatrixMode(GL_MODELVIEW);
 
 		// Depth test is now enabled
 		PROFILE_START( "render rally points" );
 		g_Selection.renderRallyPoints();
 		g_Mouseover.renderRallyPoints();
 		PROFILE_END( "render rally points" );
 		
 		PROFILE_START( "render cinematic splines" );
 		//Sets/resets renderering properties itself
 		g_Game->GetView()->GetCinema()->DrawAllSplines();
 		PROFILE_END( "render cinematic splines" );
 	}
 
 	oglCheck();
 
 	PROFILE_START( "render fonts" );
 	MICROLOG(L"render fonts");
 	// overlay mode
 	glPushAttrib(GL_ENABLE_BIT);
 	glEnable(GL_TEXTURE_2D);
 	glDisable(GL_CULL_FACE);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	glEnable(GL_BLEND);
 	glMatrixMode(GL_PROJECTION);
 	glPushMatrix();
 	glLoadIdentity();
 	glOrtho(0.f, (float)g_xres, 0.f, (float)g_yres, -1.f, 1000.f);
 
 
 	glMatrixMode(GL_MODELVIEW);
 	glPushMatrix();
 	glLoadIdentity();
 
 	PROFILE_END( "render fonts" );
 
 	oglCheck();
 
 #ifndef NO_GUI
 	// Temp GUI message GeeTODO
 	MICROLOG(L"render GUI");
 	PROFILE_START( "render gui" );
 	g_GUI.Draw();
 	PROFILE_END( "render gui" );
 #endif
 
 	oglCheck();
 
 	// Particle Engine Updating
 	CParticleEngine::GetInstance()->updateEmitters();
 
 	// Text:
 
 	// Use the GL_ALPHA texture as the alpha channel with a flat colouring
 	glDisable(GL_ALPHA_TEST);
 	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 	// Added --
 	glEnable(GL_TEXTURE_2D);
 	// -- GL
 
 	oglCheck();
 
 	{
 		PROFILE( "render console" );
 		glLoadIdentity();
 
 		MICROLOG(L"render console");
 		CFont font("console");
 		font.Bind();
 		g_Console->Render();
 	}
 
 	oglCheck();
 
 
 	// Profile information
 
 	PROFILE_START( "render profiling" );
 	g_ProfileViewer.RenderProfile();
 	PROFILE_END( "render profiling" );
 
 	oglCheck();
 
 	if (g_Game && g_Game->IsGameStarted())
 	{
 		PROFILE( "render selection overlays" );
 		g_Mouseover.renderOverlays();
 		g_Selection.renderOverlays();
 	}
 
 	oglCheck();
 
 	// Draw the cursor (or set the Windows cursor, on Windows)
 	CStr cursorName = g_BuildingPlacer.m_active ? "action-build" : g_CursorName;
 	cursor_draw(cursorName, g_mouse_x, g_mouse_y);
 
 	// restore
 	glMatrixMode(GL_PROJECTION);
 	glPopMatrix();
 	glMatrixMode(GL_MODELVIEW);
 	glPopMatrix();
 	glPopAttrib();
 
 	MICROLOG(L"end frame");
 	g_Renderer.EndFrame();
 
 	oglCheck();
 }
 
 
 
 static void InitScripting()
 {
 	TIMER("InitScripting");
 
 	// Create the scripting host.  This needs to be done before the GUI is created.
 	// [7ms]
 	new ScriptingHost;
 	
 	// It would be nice for onLoad code to be able to access the setTimeout() calls.
 	new CScheduler;
 
 	// Register the JavaScript interfaces with the runtime
 	SColour::ScriptingInit();
 	CEntity::ScriptingInit();
+	CTrigger::ScriptingInit();
 	CEntityTemplate::ScriptingInit();
+
 	JSI_Sound::ScriptingInit();
 	CProfileNode::ScriptingInit();
 
 #ifndef NO_GUI
 	JSI_IGUIObject::init();
 	JSI_GUITypes::init();
 #endif
 	JSI_Vector3D::init();
 	EntityCollection::Init( "EntityCollection" );
 	CPlayer::ScriptingInit();
 
 	PlayerCollection::Init( "PlayerCollection" );
 
 	// call CJSComplexPropertyAccessor's ScriptingInit. doesn't really
 	// matter which <T> we use, but we know CJSPropertyAccessor<T> is
 	// already being compiled for T = CEntity.
 	ScriptableComplex_InitComplexPropertyAccessor<CEntity>();
 
 	CScriptEvent::ScriptingInit();
 	CJSProgressTimer::ScriptingInit();
 	CProjectile::ScriptingInit();
 
 	g_ScriptingHost.DefineConstant( "FORMATION_ENTER", CFormationEvent::FORMATION_ENTER );
 	g_ScriptingHost.DefineConstant( "FORMATION_LEAVE", CFormationEvent::FORMATION_LEAVE );
 	g_ScriptingHost.DefineConstant( "FORMATION_DAMAGE", CFormationEvent::FORMATION_DAMAGE );
 	g_ScriptingHost.DefineConstant( "FORMATION_ATTACK", CFormationEvent::FORMATION_ATTACK );
 
 	g_ScriptingHost.DefineConstant( "NOTIFY_NONE", CEntityListener::NOTIFY_NONE );
 	g_ScriptingHost.DefineConstant( "NOTIFY_GOTO", CEntityListener::NOTIFY_GOTO );
 	g_ScriptingHost.DefineConstant( "NOTIFY_RUN", CEntityListener::NOTIFY_RUN );
 	g_ScriptingHost.DefineConstant( "NOTIFY_FOLLOW", CEntityListener::NOTIFY_FOLLOW );
 	g_ScriptingHost.DefineConstant( "NOTIFY_ATTACK", CEntityListener::NOTIFY_ATTACK );
 	g_ScriptingHost.DefineConstant( "NOTIFY_DAMAGE", CEntityListener::NOTIFY_DAMAGE );
 	g_ScriptingHost.DefineConstant( "NOTIFY_COMBAT", CEntityListener::NOTIFY_COMBAT );
 	g_ScriptingHost.DefineConstant( "NOTIFY_ESCORT", CEntityListener::NOTIFY_ESCORT );
 	g_ScriptingHost.DefineConstant( "NOTIFY_HEAL", CEntityListener::NOTIFY_HEAL );
 	g_ScriptingHost.DefineConstant( "NOTIFY_GATHER", CEntityListener::NOTIFY_GATHER );
 	g_ScriptingHost.DefineConstant( "NOTIFY_IDLE", CEntityListener::NOTIFY_IDLE );
 	g_ScriptingHost.DefineConstant( "NOTIFY_ORDER_CHANGE", CEntityListener::NOTIFY_ORDER_CHANGE );
 	g_ScriptingHost.DefineConstant( "NOTIFY_ALL", CEntityListener::NOTIFY_ALL );
 	
 	g_ScriptingHost.DefineConstant( "ORDER_NONE", -1 );
 	g_ScriptingHost.DefineConstant( "ORDER_GOTO", CEntityOrder::ORDER_GOTO );
 	g_ScriptingHost.DefineConstant( "ORDER_RUN", CEntityOrder::ORDER_RUN );
 	g_ScriptingHost.DefineConstant( "ORDER_PATROL", CEntityOrder::ORDER_PATROL );
 	g_ScriptingHost.DefineConstant( "ORDER_GENERIC", CEntityOrder::ORDER_GENERIC );
 	g_ScriptingHost.DefineConstant( "ORDER_PRODUCE", CEntityOrder::ORDER_PRODUCE );
 	g_ScriptingHost.DefineConstant( "ORDER_START_CONSTRUCTION", CEntityOrder::ORDER_START_CONSTRUCTION );
 
 #define REG_JS_CONSTANT(_name) g_ScriptingHost.DefineConstant(#_name, _name)
 	REG_JS_CONSTANT(SDL_BUTTON_LEFT);
 	REG_JS_CONSTANT(SDL_BUTTON_MIDDLE);
 	REG_JS_CONSTANT(SDL_BUTTON_RIGHT);
 	REG_JS_CONSTANT(SDL_BUTTON_WHEELUP);
 	REG_JS_CONSTANT(SDL_BUTTON_WHEELDOWN);
 #undef REG_JS_CONSTANT
 
 	CNetMessage::ScriptingInit();
 
 	JSI_Camera::init();
 	JSI_Console::init();
 	JSI_LightEnv::init();
 
 	new CGameEvents;
 }
 
 
 static void InitVfs(const char* argv0)
 {
 	TIMER("InitVfs");
 
 	(void)file_init();
 
 	// set root directory to "$game_dir/data". all relative file paths
 	// passed to file.cpp will be based from this dir.
 	// (we don't set current directory because other libraries may
 	// hijack it).
 	//
 	// "../data" is relative to the executable (in "$game_dir/system").
 	//
 	// rationale for data/ being root: untrusted scripts must not be
 	// allowed to overwrite critical game (or worse, OS) files.
 	// the VFS prevents any accesses to files above this directory.
 	(void)file_set_root_dir(argv0, "../data");
 
 	vfs_init();
 
 	vfs_mount("screenshots/", "screenshots");
 	vfs_mount("profiles/", "profiles", VFS_MOUNT_RECURSIVE);
 
 	// rationale:
 	// - this is in a separate real directory so that it can later be moved
 	//   to $APPDATA to allow running without Admin access.
 	// - we mount as archivable so that all files will be added to archive.
 	//   even though we write out XMBs here, they will eventually be read,
 	//   so putting them in an archive boosts performance.
 	//
 	// [hot: 16ms]
 	vfs_mount("cache/", "cache", VFS_MOUNT_RECURSIVE|VFS_MOUNT_ARCHIVES|VFS_MOUNT_ARCHIVABLE);
 
 	// --- this belongs in a LoadMod function
 	// [hot: 150ms]
 	vfs_mount("", "mods/official", VFS_MOUNT_RECURSIVE|VFS_MOUNT_ARCHIVES|VFS_MOUNT_WATCH|VFS_MOUNT_ARCHIVABLE);
 	// ---
 
 	// TODO: once people can load multiple mods, set the top one to be the write target
 	vfs_set_write_target("mods/official");
 
 	// don't try vfs_display yet: SDL_Init hasn't yet redirected stdout
 }
 
 
 static void InitPs(bool setup_gui)
 {
 	if (setup_gui)
 	{
 		// The things here aren't strictly GUI, but they're unnecessary when in Atlas
 		// because the game doesn't draw any text or handle keys of anything
 
 		{
 			// console
 			TIMER("ps_console");
 
 			g_Console->UpdateScreenSize(g_xres, g_yres);
 
 			// Calculate and store the line spacing
 			CFont font("console");
 			g_Console->m_iFontHeight = font.GetLineSpacing();
 			g_Console->m_iFontWidth = font.GetCharacterWidth(L'C');
 			g_Console->m_charsPerPage = (size_t)(g_xres / g_Console->m_iFontWidth);
 			// Offset by an arbitrary amount, to make it fit more nicely
 			g_Console->m_iFontOffset = 9;
 		}
 
 		// language and hotkeys
 		{
 			TIMER("ps_lang_hotkeys");
 
 			std::string lang = "english";
 			CFG_GET_SYS_VAL("language", String, lang);
 			I18n::LoadLanguage(lang.c_str());
 
 			loadHotkeys();
 		}
 
 		// GUI uses VFS, so this must come after VFS init.
 		GUI_Init();
 	}
 }
 
 
 static void InitInput()
 {
 	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
 
 	// register input handlers
 	// This stack is constructed so the first added, will be the last
 	//  one called. This is important, because each of the handlers
 	//  has the potential to block events to go further down
 	//  in the chain. I.e. the last one in the list added, is the
 	//  only handler that can block all messages before they are
 	//  processed.
 	in_add_handler(game_view_handler);
 
 	in_add_handler(interactInputHandler);
 
 	in_add_handler(conInputHandler);
 
 	in_add_handler(CProfileViewer::InputThunk);
 
 	in_add_handler(hotkeyInputHandler);
 
 	in_add_handler(GlobalsInputHandler);
 }
 
 
 static void ShutdownPs()
 {
 	GUI_Shutdown();
 
 	delete g_Console;
 	g_Console = 0;
 
 	// disable the special Windows cursor, or free textures for OGL cursors
 	cursor_draw(0, g_mouse_x, g_mouse_y);
 
 	// close down Xerces if it was loaded
 	CXeromyces::Terminate();
 
 	// Unload the real language (since it depends on the scripting engine,
 	// which is going to be killed later) and use the English fallback messages
 	I18n::LoadLanguage(NULL);
 }
 
 
 static void InitRenderer()
 {
 	TIMER("InitRenderer");
 	// create renderer
 	new CRenderer;
 
 	// set renderer options from command line options - NOVBO must be set before opening the renderer
 	g_Renderer.SetOptionBool(CRenderer::OPT_NOVBO,g_NoGLVBO);
 	g_Renderer.SetOptionBool(CRenderer::OPT_NOFRAMEBUFFEROBJECT,g_NoGLFramebufferObject);
 	g_Renderer.SetOptionBool(CRenderer::OPT_SHADOWS,g_Shadows);
 	g_Renderer.SetOptionBool(CRenderer::OPT_FANCYWATER,g_FancyWater);
 	g_Renderer.SetRenderPath(CRenderer::GetRenderPathByName(g_RenderPath));
 	g_Renderer.SetOptionFloat(CRenderer::OPT_LODBIAS, g_LodBias);
 
 	// create terrain related stuff
 	new CTextureManager;
 
 	// create the material manager
 	new CMaterialManager;
 	new CMeshManager;
 
 	// create actor related stuff
 	new CSkeletonAnimManager;
 	new CObjectManager;
 	new CUnitManager;
 
 	MICROLOG(L"init renderer");
 	g_Renderer.Open(g_xres,g_yres,g_bpp);
 
 	// Setup lighting environment. Since the Renderer accesses the
 	// lighting environment through a pointer, this has to be done before
 	// the first Frame.
 	g_Renderer.SetLightEnv(&g_LightEnv);
 
 	// I haven't seen the camera affecting GUI rendering and such, but the
 	// viewport has to be updated according to the video mode
 	SViewPort vp;
 	vp.m_X=0;
 	vp.m_Y=0;
 	vp.m_Width=g_xres;
 	vp.m_Height=g_yres;
 	g_Renderer.SetViewport(vp);
 
 	ColorActivateFastImpl();
 }
 
 static void InitSDL()
 {
 	MICROLOG(L"init sdl");
 	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) < 0)
 	{
 		LOG(ERROR, LOG_CATEGORY, "SDL library initialization failed: %s", SDL_GetError());
 		throw PSERROR_System_SDLInitFailed();
 	}
 	atexit(SDL_Quit);
 	SDL_EnableUNICODE(1);
 }
 
 
 void EndGame()
 {
 	if (g_NetServer)
 	{
 		delete g_NetServer;
 		g_NetServer=NULL;
 	}
 	else if (g_NetClient)
 	{
 		delete g_NetClient;
 		g_NetClient=NULL;
 	}
 
 	delete g_Game;
 	g_Game=NULL;
 }
 
 
 void Shutdown(uint flags)
 {
 	MICROLOG(L"Shutdown");
 
 	if (g_Game)
 		EndGame();
 
 	ShutdownPs(); // Must delete g_GUI before g_ScriptingHost
 
 	TIMER_BEGIN("shutdown Scheduler");
 	delete &g_Scheduler;
 	TIMER_END("shutdown Scheduler");
 
 	delete &g_JSGameEvents;
 
 	if (! (flags & INIT_NO_SIM))
 	{
 		TIMER_BEGIN("shutdown SessionManager");
 		delete &g_SessionManager;
 		TIMER_END("shutdown SessionManager");
 
 		TIMER_BEGIN("shutdown mouse stuff");
 		delete &g_Mouseover;
 		delete &g_Selection;
 		delete &g_BuildingPlacer;
 		TIMER_END("shutdown mouse stuff");
 
 		TIMER_BEGIN("shutdown Pathfinder");
 		delete &g_Pathfinder;
 		TIMER_END("shutdown Pathfinder");
 
 		// Managed by CWorld
 		// delete &g_EntityManager;
 
 		TIMER_BEGIN("shutdown game scripting stuff");
 		delete &g_GameAttributes;
-
+		
+		delete &g_TriggerManager;
 		delete &g_FormationManager;
 		delete &g_TechnologyCollection;
 		delete &g_EntityFormationCollection;
 		delete &g_EntityTemplateCollection;
 		TIMER_END("shutdown game scripting stuff");
 	}
 
 	// destroy actor related stuff
 	TIMER_BEGIN("shutdown actor stuff");
 	delete &g_UnitMan;
 	delete &g_ObjMan;
 	delete &g_SkelAnimMan;
 
 	delete &g_MaterialManager;
 	delete &g_MeshManager;
 	TIMER_END("shutdown actor stuff");
 
 	// destroy terrain related stuff
 	TIMER_BEGIN("shutdown TexMan");
 	delete &g_TexMan;
 	TIMER_END("shutdown TexMan");
 
 	// destroy renderer
 	TIMER_BEGIN("shutdown Renderer");
 	delete &g_Renderer;
 	g_VBMan.Shutdown();
 	TIMER_END("shutdown Renderer");
 
 	TIMER_BEGIN("shutdown ScriptingHost");
 	delete &g_ScriptingHost;
 	TIMER_END("shutdown ScriptingHost");
 
 	TIMER_BEGIN("shutdown ConfigDB");
 	delete &g_ConfigDB;
 	TIMER_END("shutdown ConfigDB");
 
 	// Shut down the network loop
 	TIMER_BEGIN("shutdown CSocketBase");
 	CSocketBase::Shutdown();
 	TIMER_END("shutdown CSocketBase");
 
 	// Really shut down the i18n system. Any future calls
 	// to translate() will crash.
 	TIMER_BEGIN("shutdown I18N");
 	I18n::Shutdown();
 	TIMER_END("shutdown I18N");
 
 	// resource
 	// first shut down all resource owners, and then the handle manager.
 	TIMER_BEGIN("resource modules");
 		snd_shutdown();
 
 		(void)trace_write_to_file("../logs/trace.txt");
 
 		vfs_shutdown();
 
 		// must come before h_mgr_shutdown - it frees IO buffers,
 		// which we don't want showing up as leaks.
 		file_shutdown();
 
 		// this forcibly frees all open handles (thus preventing real leaks),
 		// and makes further access to h_mgr impossible.
 		h_mgr_shutdown();
 
 		// must come after h_mgr_shutdown - it causes memory
 		// to be freed, which requires this module to still be active.
 		mem_shutdown();
 	TIMER_END("resource modules");
 
 	TIMER_BEGIN("shutdown misc");
 		timer_display_client_totals();
 
 		// should be last, since the above use them
 		debug_shutdown();
 		SAFE_DELETE(g_Logger);
 		delete &g_Profiler;
 		delete &g_ProfileViewer;
 	TIMER_END("shutdown misc");
 }
 
 
 void Init(int argc, char* argv[], uint flags)
 {
 	const bool setup_vmode = (flags & INIT_HAVE_VMODE) == 0;
 
 	MICROLOG(L"Init");
 
 	debug_set_thread_name("main");
 	// add all debug_printf "tags" that we are interested in:
 	debug_filter_add("TIMER");
 
 	// Query CPU capabilities, possibly set some CPU-dependent flags
 	cpu_init();
 
 	// Do this as soon as possible, because it chdirs
 	// and will mess up the error reporting if anything
 	// crashes before the working directory is set.
 	MICROLOG(L"init vfs");
 	const char* argv0 = argc? argv[0] : NULL;
 	// ScEd doesn't have a main(argc, argv), and so it has no argv. In that
 	// case, just pass NULL to InitVfs, which will work out the current
 	// directory for itself.
 	InitVfs(argv0);
 
 	// This must come after VFS init, which sets the current directory
 	// (required for finding our output log files).
 	g_Logger = new CLogger;
 
 	// Call LoadLanguage(NULL) to initialize the I18n system, but
 	// without loading an actual language file - translate() will
 	// just show the English key text, which is better than crashing
 	// from a null pointer when attempting to translate e.g. error messages.
 	// Real languages can only be loaded when the scripting system has
 	// been initialised.
 	//
 	// this uses LOG and must therefore come after CLogger init.
 	MICROLOG(L"init i18n");
 	I18n::LoadLanguage(NULL);
 
 	// override ah_translate with our i18n code.
 	AppHooks hooks = {0};
 	hooks.translate = psTranslate;
 	hooks.translate_free = psTranslateFree;
 	app_hooks_update(&hooks);
 
 	// Set up the console early, so that debugging
 	// messages can be logged to it. (The console's size
 	// and fonts are set later in InitPs())
 	g_Console = new CConsole();
 
 	if(setup_vmode)
 		InitSDL();
 
 	// preferred video mode = current desktop settings
 	// (command line params may override these)
 	gfx_get_video_mode(&g_xres, &g_yres, &g_bpp, &g_freq);
 
 	new CProfileViewer;
 	new CProfileManager;	// before any script code
 
 	MICROLOG(L"init scripting");
 	InitScripting();	// before GUI
 
 	// g_ConfigDB, command line args, globals
 	CONFIG_Init(argc, argv);
 
 	// setup_gui must be set after CONFIG_Init, so command-line parameters can disable it
 	const bool setup_gui = ((flags & INIT_NO_GUI) == 0 && g_AutostartMap.Length() == 0);
 
 	// GUI is notified in SetVideoMode, so this must come before that.
 #ifndef NO_GUI
 	new CGUI;
 #endif
 
 	bool windowed = false;
 	CFG_GET_SYS_VAL("windowed", Bool, windowed);
 
 	if(setup_vmode)
 	{
 		MICROLOG(L"SetVideoMode");
 		if(SetVideoMode(g_xres, g_yres, 32, !windowed) < 0)
 		{
 			LOG(ERROR, LOG_CATEGORY, "Could not set %dx%d graphics mode: %s", g_xres, g_yres, SDL_GetError());
 			throw PSERROR_System_VmodeFailed();
 		}
 
 		SDL_WM_SetCaption("0 A.D.", "0 A.D.");
 	}
 
 	tex_codec_register_all();
 
 	uint quality = SANE_TEX_QUALITY_DEFAULT;	// TODO: set value from config file
 	SetTextureQuality(quality);
 
 	// required by ogl_tex to detect broken gfx card/driver combos
 	gfx_detect();
 
 	oglCheck();
 
 	if(!g_Quickstart)
 	{
 		WriteSystemInfo();
 		// note: no longer vfs_display here. it's dog-slow due to unbuffered
 		// file output and very rarely needed.
 	}
 	else
 	{
 		// speed up startup by disabling all sound
 		// (OpenAL init will be skipped).
 		// must be called before first snd_open.
 		snd_disable(true);
 	}
 
 	// (must come after SetVideoMode, since it calls oglInit)
 	const char* missing = oglHaveExtensions(0,
 		"GL_ARB_multitexture",
 		"GL_EXT_draw_range_elements",
 		"GL_ARB_texture_env_combine",
 		"GL_ARB_texture_env_dot3",
 		0);
 	if(missing)
 	{
 		wchar_t buf[500];
 		const wchar_t* fmt =
 			L"The %hs extension doesn't appear to be available on your computer. "
 			L"The game may still work, though - you are welcome to try at your own risk. "
 			L"If not or it doesn't look right, upgrade your graphics card.";
 		swprintf(buf, ARRAY_SIZE(buf), fmt, missing);
 		DISPLAY_ERROR(buf);
 		// TODO: i18n
 	}
 
 	if (!oglHaveExtension("GL_ARB_texture_env_crossbar"))
 	{
 		DISPLAY_ERROR(
 			L"The GL_ARB_texture_env_crossbar extension doesn't appear to be available on your computer."
 			L"Shadows are not available and overall graphics quality might suffer."
 			L"You are advised to try installing newer drivers and/or upgrade your graphics card.");
 		g_Shadows = false;
 	}
 
 	// enable/disable VSync
 	// note: "GL_EXT_SWAP_CONTROL" is "historical" according to dox.
 #if OS_WIN
 	if(oglHaveExtension("WGL_EXT_swap_control"))
 		pwglSwapIntervalEXT(g_VSync? 1 : 0);
 #endif
 
 	MICROLOG(L"init ps");
 	InitPs(setup_gui);
 
 	oglCheck();
 	InitRenderer();
 
 	if (! (flags & INIT_NO_SIM))
 	{
 		{
 			TIMER("Init_entitiessection");
 			// This needs to be done after the renderer has loaded all its actors...
 			new CEntityTemplateCollection;
 			new CFormationCollection;
 			new CTechnologyCollection;
 			g_EntityFormationCollection.loadTemplates();
 			g_TechnologyCollection.loadTechnologies();
 			new CFormationManager;
+			new CTriggerManager;
+			g_TriggerManager.LoadXML(CStr("scripts/TriggerSpecs.xml"));
+			g_ScriptingHost.RunScript("scripts/trigger_functions.js");
 
 			// CEntityManager is managed by CWorld
 			//new CEntityManager;
 			new CSelectedEntities;
 			new CMouseoverEntities;
 		}
 
 		{
 			TIMER("Init_miscgamesection");
 			new CPathfindEngine;
 			new CBuildingPlacer;
 			new CSessionManager;
 			new CGameAttributes;
 		}
 
 		// Register a few Game/Network JS globals
 		g_ScriptingHost.SetGlobal("g_GameAttributes", OBJECT_TO_JSVAL(g_GameAttributes.GetScript()));
 	}
 	
 	
 	// Check for heap corruption after every allocation. Very, very slowly.
 	// (And it highlights the allocation just after the one you care about,
 	// so you need to run it again and tell it to break on the one before.)
 //	debug_heap_enable(DEBUG_HEAP_ALL);
 
 	InitInput();
 
 	oglCheck();
 
 #ifndef NO_GUI
 	{
 	TIMER("Init_guiload");
 	g_GUI.SendEventToAll("load");
 	}
 #endif
 
 	if (g_FixedFrameTiming) {
 		CCamera &camera = *g_Game->GetView()->GetCamera();
 #if 0		// TOPDOWN
 		camera.SetProjection(1.0f,10000.0f,DEGTORAD(90));
 		camera.m_Orientation.SetIdentity();
 		camera.m_Orientation.RotateX(DEGTORAD(90));
 		camera.m_Orientation.Translate(CELL_SIZE*250*0.5, 250, CELL_SIZE*250*0.5);
 #else		// std view
 		camera.SetProjection(1.0f,10000.0f,DEGTORAD(20));
 		camera.m_Orientation.SetXRotation(DEGTORAD(30));
 		camera.m_Orientation.RotateY(DEGTORAD(-45));
 		camera.m_Orientation.Translate(350, 350, -275);
 #endif
 		camera.UpdateFrustum();
 	}
 
 	if (g_AutostartMap.Length())
 	{
 		// Code copied mostly from atlas/GameInterface/Handlers/Map.cpp -
 		// maybe should be refactored to avoid duplication
 		g_GameAttributes.m_MapFile = g_AutostartMap+".pmp";
 		for (int i=1; i<8; ++i)
 			g_GameAttributes.GetSlot(i)->AssignLocal();
 		g_Game = new CGame();
 
 		PSRETURN ret = g_Game->StartGame(&g_GameAttributes);
 		debug_assert(ret == PSRETURN_OK);
 		LDR_NonprogressiveLoad();
 		ret = g_Game->ReallyStartGame();
 		debug_assert(ret == PSRETURN_OK);
 	}
 
 }
Index: ps/trunk/source/scripting/ScriptGlue.cpp
===================================================================
--- ps/trunk/source/scripting/ScriptGlue.cpp	(revision 4647)
+++ ps/trunk/source/scripting/ScriptGlue.cpp	(revision 4648)
@@ -1,1518 +1,1546 @@
 // This module defines the table of all functions callable from JS.
 // it's required by the interpreter; we make use of the opportunity to
 // document them all in one spot. we thus obviate having to dig through
 // all the other headers. most of the functions are implemented here;
 // as for the rest, we only link to their docs (duplication is bad).
 
 #include "precompiled.h"
 
 #include "ScriptGlue.h"
 #include "JSConversions.h"
 #include "GameEvents.h"
 #include "graphics/GameView.h"
 #include "graphics/LightEnv.h"
 #include "graphics/MapWriter.h"
 #include "graphics/scripting/JSInterface_Camera.h"
 #include "graphics/scripting/JSInterface_LightEnv.h"
 #include "gui/CGUI.h"
 #include "lib/timer.h"
 #include "maths/scripting/JSInterface_Vector3D.h"
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/Game.h"
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/Interact.h"
 #include "network/Client.h"
 #include "network/Server.h"
 #include "ps/i18n.h"
 #include "ps/Hotkey.h"
 #include "ps/scripting/JSCollection.h"
 #include "ps/scripting/JSInterface_Console.h"
 #include "ps/scripting/JSInterface_Selection.h"
 #include "ps/scripting/JSInterface_VFS.h"
 #include "renderer/Renderer.h"
 #include "renderer/SkyManager.h"
 #include "renderer/WaterManager.h"
 #include "simulation/EntityTemplateCollection.h"
 #include "simulation/TechnologyCollection.h"
 #include "simulation/Entity.h"
 #include "simulation/EntityFormation.h"
 #include "simulation/EntityHandles.h"
 #include "simulation/EntityManager.h"
 #include "simulation/EntityTemplate.h"
 #include "simulation/FormationManager.h"
+#include "simulation/TriggerManager.h"
 #include "simulation/LOSManager.h"
 #include "simulation/Scheduler.h"
 #include "simulation/Simulation.h"
 
 #ifndef NO_GUI
 # include "gui/scripting/JSInterface_IGUIObject.h"
 #endif
 
 extern CConsole* g_Console;
 extern bool g_TerrainModified;
 
 
 // rationale: the function table is now at the end of the source file to
 // avoid the need for forward declarations for every function.
 
 // all normal function wrappers have the following signature:
 //   JSBool func(JSContext* cx, JSObject* globalObject, uint argc, jsval* argv, jsval* rval);
 // all property accessors have the following signature:
 //   JSBool accessor(JSContext* cx, JSObject* globalObject, jsval id, jsval* vp);
 
 
 //-----------------------------------------------------------------------------
 // Output
 //-----------------------------------------------------------------------------
 
 // Write values to the log file.
 // params: any number of any type.
 // returns:
 // notes:
 // - Each argument is converted to a string and then written to the log.
 // - Output is in NORMAL style (see LOG).
 JSBool WriteLog(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_PARAMS(1);
 
 	CStr logMessage;
 
 	for (int i = 0; i < (int)argc; i++)
 	{
 		try
 		{
 			CStr arg = g_ScriptingHost.ValueToString( argv[i] );
 			logMessage += arg;
 		}
 		catch( PSERROR_Scripting_ConversionFailed )
 		{
 			// Do nothing.
 		}
 	}
 
 	// We should perhaps unicodify (?) the logger at some point.
 
 	LOG( NORMAL, "script", logMessage );
 
 	*rval = JSVAL_TRUE;
 	return JS_TRUE;
 }
 
 
 //-----------------------------------------------------------------------------
 // Entity
 //-----------------------------------------------------------------------------
 
 // Retrieve the entity currently occupying the specified handle.
 // params: handle [int]
 // returns: entity
 JSBool getEntityByHandle( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 	*rval = JSVAL_NULL;
 
 	i32 handle;
 	try
 	{
 		handle = ToPrimitive<int>( argv[0] );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid handle" );
 		return( JS_TRUE );
 	}
 	HEntity* v = g_EntityManager.getByHandle( (u16)handle );
 	if( !v )
 	{
 		JS_ReportError( cx, "No entity occupying handle: %d", handle );
 		return( JS_TRUE );
 	}
 	JSObject* entity = (*v)->GetScript();
 
 	*rval = OBJECT_TO_JSVAL( entity );
 	return( JS_TRUE );
 }
 
 
 // Look up an EntityTemplate by name.
 // params: template name [wstring]
 // returns: entity template object
 JSBool getEntityTemplate( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAM_RANGE(1, 2);
 	*rval = JSVAL_NULL;
 
 	CStrW templateName;
 	CPlayer* player = 0;
 
 	try
 	{
 		templateName = g_ScriptingHost.ValueToUCString( argv[0] );
 		if( argc == 2 )
 		{
 			player = ToNative<CPlayer>( argv[1] );
 		}
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid template identifier" );
 		return( JS_TRUE );
 	}
 
 	CEntityTemplate* v = g_EntityTemplateCollection.getTemplate( templateName, player );
 	if( !v )
 	{
 		JS_ReportError( cx, "No such template: %s", CStr8(templateName).c_str() );
 		return( JS_TRUE );
 	}
 
 	*rval = OBJECT_TO_JSVAL( v->GetScript() );
 	return( JS_TRUE );
 }
 //Used to create net messages for formations--msgList.front() is the original message. see issueCommand
 void CreateFormationMessage( std::vector<CNetMessage*>& msgList, CNetMessage* msg, CEntityList& formation )
 {
 	CNetMessage* retMsg;
 	const int type = msg->GetType();
 
 	if ( type == NMT_Goto )
 	{
 		//formationEnt->GetFormation()->BaseToMovement();
 		CGoto* tmp = static_cast<CGoto*>(msg);
 		retMsg = CNetMessage::CreatePositionMessage( formation, NMT_FormationGoto, 
 						CVector2D(tmp->m_TargetX, tmp->m_TargetY) );
 	}
 	else if( type == NMT_Run )
 	{
 		CGoto* tmp = static_cast<CGoto*>(msg);
 		retMsg = CNetMessage::CreatePositionMessage( formation, NMT_FormationGoto, 
 						CVector2D(tmp->m_TargetX, tmp->m_TargetY) );
 	}
 	else if ( type == NMT_Generic )
 	{
 		CGeneric* tmp = static_cast<CGeneric*>(msg);
 		retMsg = CNetMessage::CreateEntityIntMessage(formation, NMT_FormationGeneric, 
 					tmp->m_Target, tmp->m_Action);
 	}
 	else
 		return;
 	
 	msgList.push_back(retMsg); 
 }
 
 // Issue a command (network message) to an entity or collection.
 // params: either an entity- or entity collection object, message ID [int],
 //   any further params needed by CNetMessage::CommandFromJSArgs
 // returns: command in serialized form [string]
 JSBool issueCommand( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	// at least one for target object, one for isQueued, and then 1 or more for the CommandFromJSArgs
 	JSU_REQUIRE_MIN_PARAMS(3);
 
 	JSU_ASSERT(JSVAL_IS_OBJECT(argv[0]), "Argument 0 must be an entity collection.");
 	*rval = JSVAL_NULL;
 	
 	CEntityList entities, msgEntities;
 
 	if (JS_GetClass(JSVAL_TO_OBJECT(argv[0])) == &CEntity::JSI_class)
 		entities.push_back( (ToNative<CEntity>(argv[0])) ->me);
 	else
 		entities = *EntityCollection::RetrieveSet(cx, JSVAL_TO_OBJECT(argv[0]));
 	
 	std::map<int, CEntityList> entityStore;
 
 	bool isQueued = ToPrimitive<bool>(argv[1]);
 	
 	//Destroy old notifiers if we're explicitly being reassigned
 	for ( size_t i=0; i < entities.size(); i++)
 	{
 		if ( entities[i]->entf_get(ENTF_DESTROY_NOTIFIERS))
 			entities[i]->DestroyAllNotifiers();
 	}
 	std::vector<CNetMessage*> messages;
 	
 	//Generate messages for formations
 	for (size_t i=0; i < entities.size(); i++ )
 	{
 		if ( entities[i]->m_formation >= 0)
 		{
 			CEntityFormation* formation = entities[i]->GetFormation();
 			bool duplicate = formation->IsDuplication();
 			
 			if ( formation->IsLocked() && !duplicate)
 			{
 				formation->SelectAllUnits();
 				entityStore[entities[i]->m_formation] = formation->GetEntityList();
 				formation->SetDuplication(true);
 			}
 		}
 		else
 			msgEntities.push_back( entities[i] );
 	}
 	CNetMessage* msg = CNetMessage::CommandFromJSArgs(msgEntities, cx, argc-2, argv+2, isQueued);
 	if (!msg)
 	{
 		delete msg;
 		return JS_TRUE;
 	}
 	messages.push_back(msg);
 	
 	for ( std::map<int, CEntityList>::iterator it=entityStore.begin(); it!=entityStore.end(); it++)
 		CreateFormationMessage(messages, msg, it->second);
 	
 	for ( std::vector<CNetMessage*>::iterator it=messages.begin(); it != messages.end(); it++ )
 	{
 		//g_Console->InsertMessage(L"issueCommand: %hs", (*it)->GetString().c_str());
 		g_Game->GetSimulation()->QueueLocalCommand(*it);
 		*rval = g_ScriptingHost.UCStringToValue((*it)->GetString());
 	}
 
 	return JS_TRUE;
 }
 //Formation stuff
 JSBool createEntityFormation( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(2);
 	
 	CEntityList entities = *EntityCollection::RetrieveSet(cx, JSVAL_TO_OBJECT(argv[0]));
 	CStrW name = ToPrimitive<CStrW>( argv[1] );
 	g_FormationManager.CreateFormation( entities, name );
 	*rval = JSVAL_VOID;
 	return JS_TRUE;
 
 }
 JSBool removeFromFormation( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 	
 	CEntityList entities;
 	if (JS_GetClass(JSVAL_TO_OBJECT(argv[0])) == &CEntity::JSI_class)
 		entities.push_back( (ToNative<CEntity>(argv[0])) ->me);
 	else
 		entities = *EntityCollection::RetrieveSet(cx, JSVAL_TO_OBJECT(argv[0]));
 
 	*rval = g_FormationManager.RemoveUnitList(entities) ? JS_TRUE : JS_FALSE;
 	return JS_TRUE;
 }
 JSBool lockEntityFormation( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 
 	CEntity* entity = ToNative<CEntity>( argv[0] );
 	entity->GetFormation()->SetLock( ToPrimitive<bool>( argv[1] ) );
 	*rval = JSVAL_VOID;
 	return JS_TRUE;
 }
 JSBool isFormationLocked( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 
 	CEntity* entity = ToNative<CEntity>( argv[0] );
 	*rval = entity->GetFormation()->IsLocked() ? JS_TRUE : JS_FALSE;
 	return JS_TRUE;
 }
 
 // Get the state of a given hotkey (from the hotkeys file)
 JSBool isOrderQueued( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	*rval = ToJSVal(hotkeys[HOTKEY_ORDER_QUEUE]);
 	return JS_TRUE;
 }
 
 
 //-----------------------------------------------------------------------------
 // Techs
 //-----------------------------------------------------------------------------
 
 JSBool getTechnology( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(2);
 	
 	CStrW name;
 	CPlayer* player;
 	
 	try
 	{
 		name = g_ScriptingHost.ValueToUCString( argv[0] );
 		player = ToNative<CPlayer>( argv[1] );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid parameters for getTechnology (expected name and player)" );
 		return( JS_TRUE );
 	}
 
 	*rval = JSVAL_NULL;
 
 	CTechnology* tech = g_TechnologyCollection.getTechnology( name, player );	
 	if ( tech )
 		*rval = ToJSVal( tech );
 	else
 		g_Console->InsertMessage( L"Warning: Invalid tech template name \"%ls\" passed for getTechnology()", name.c_str() );
 
 	return JS_TRUE;
 }
 
 //-----------------------------------------------------------------------------
 // Events
 //-----------------------------------------------------------------------------
 
 // Register a global handler for the specified DOM event.
 // params: event type name [wstring], handler [fragment or function]
 // returns: whether it was actually newly registered [bool]
 JSBool AddGlobalHandler( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(2);
 
 	*rval = BOOLEAN_TO_JSVAL( g_JSGameEvents.AddHandlerJS( cx, argc, argv ) );
 	return( JS_TRUE );
 }
 
 
 // Remove a previously registered global handler for the specified DOM event.
 // params: event type name [wstring], handler [fragment or function]
 // returns: whether it was successfully removed [bool]
 JSBool RemoveGlobalHandler( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(2);
 
 	*rval = BOOLEAN_TO_JSVAL( g_JSGameEvents.RemoveHandlerJS( cx, argc, argv ) );
 	return( JS_TRUE );
 }
 
 
 //-----------------------------------------------------------------------------
 // Timer
 //-----------------------------------------------------------------------------
 
 // Request a callback be executed after the specified delay.
 // params: callback [fragment or function], delay in milliseconds [int]
 // returns:
 // notes:
 // - Scripts and functions registered this way are called on the first
 //   simulation frame after the specified period has elapsed. If this causes
 //   multiple segments of code to be executed in the same frame,
 //   relative timing is maintained. Delays of 0 milliseconds cause code to be
 //   executed on the following simulation frame. If more than one script or
 //   function is scheduled to execute in the same millisecond, the order of
 //   execution is undefined. Code is scheduled in simulation time, and is
 //   therefore suspended while the game is paused or frozen. Granularity of
 //   timing is also limited to 1/(Simulation frame rate); currently 100ms.
 //   The called function or script executes in the same scope as the
 //   code that called setTimeout (amongst other things, the
 //   'this' reference is usually maintained)
 JSBool setTimeout( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAM_RANGE(2, 3);
 
 	size_t delay;
 	try
 	{
 		delay = ToPrimitive<int>( argv[1] );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid timer parameters" );
 		return( JS_TRUE );
 	}
 
 	JSObject* scope;
 	if( argc == 3 )
 	{
 		if( !JSVAL_IS_OBJECT( argv[2] ) )
 		{
 			JS_ReportError( cx, "Invalid timer parameters" );
 			return( JS_TRUE );
 		}
 		scope = JSVAL_TO_OBJECT( argv[2] );
 	}
 	else
 	{
 		scope = JS_GetScopeChain( cx );
 	}
 
 	switch( JS_TypeOfValue( cx, argv[0] ) )
 	{
 	case JSTYPE_STRING:
 	{
 		CStrW fragment = g_ScriptingHost.ValueToUCString( argv[0] );
 		int id = g_Scheduler.pushTime( delay, fragment, scope );
 		*rval = INT_TO_JSVAL( id );
 		return( JS_TRUE );
 	}
 	case JSTYPE_FUNCTION:
 	{
 		JSFunction* fn = JS_ValueToFunction( cx, argv[0] );
 		int id = g_Scheduler.pushTime( delay, fn, scope );
 		*rval = INT_TO_JSVAL( id );
 		return( JS_TRUE );
 	}
 	default:
 		JS_ReportError( cx, "Invalid timer script" );
 		return( JS_TRUE );
 	}
 }
 
 // Request a callback be executed periodically.
 // params: callback [fragment or function], initial delay in ms [int], period in ms [int]
 //   OR callback [fragment or function], period in ms [int] (initial delay = period)
 // returns:
 // notes:
 // - setTimeout's notes apply here as well.
 JSBool setInterval( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAM_RANGE(2, 3);
 
 	size_t first, interval;
 	try
 	{
 		first = ToPrimitive<int>( argv[1] );
 		if( argc == 3 )
 		{
 			// toDo, first, interval
 			interval = ToPrimitive<int>( argv[2] );
 		}
 		else
 		{
 			// toDo, interval (first = interval)
 			interval = first;
 		}
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid timer parameters" );
 		return( JS_TRUE );
 	}
 
 	switch( JS_TypeOfValue( cx, argv[0] ) )
 	{
 	case JSTYPE_STRING:
 	{
 		CStrW fragment = g_ScriptingHost.ValueToUCString( argv[0] );
 		int id = g_Scheduler.pushInterval( first, interval, fragment, JS_GetScopeChain( cx ) );
 		*rval = INT_TO_JSVAL( id );
 		return( JS_TRUE );
 	}
 	case JSTYPE_FUNCTION:
 	{
 		JSFunction* fn = JS_ValueToFunction( cx, argv[0] );
 		int id = g_Scheduler.pushInterval( first, interval, fn, JS_GetScopeChain( cx ) );
 		*rval = INT_TO_JSVAL( id );
 		return( JS_TRUE );
 	}
 	default:
 		JS_ReportError( cx, "Invalid timer script" );
 		return( JS_TRUE );
 	}
 }
 
 // Cause all periodic functions registered via setInterval to
 //   no longer be called.
 // params:
 // returns:
 // notes:
 // - Execution continues until the end of the triggered function or
 //   script fragment, but is not triggered again.
 JSBool cancelInterval( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	g_Scheduler.m_abortInterval = true;
 	return( JS_TRUE );
 }
 
 // Cause the scheduled task (timeout or interval) with the given ID to
 //   no longer be called.
 // params:
 // returns:
 // notes:
 // - Execution continues until the end of the triggered function or
 //   script fragment, but is not triggered again.
 JSBool cancelTimer( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 
 	try
 	{
 		int id = ToPrimitive<int>( argv[0] );
 		g_Scheduler.cancelTask( id );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid ID parameter" );
 		return( JS_TRUE );
 	}
 
 	return( JS_TRUE );
 }
 
 //Set the simulation rate scalar-time becomes time * SimRate.
 //Params: rate [float] : sets SimRate
 JSBool setSimRate(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_PARAMS(1);
 
 	g_Game->SetSimRate( ToPrimitive<float>(argv[0]) );
 	return JS_TRUE;
 }
 
 //Generate a random float in [0, 1) using the simulation's random generator
 JSBool simRand(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	*rval = ToJSVal( g_Game->GetSimulation()->RandFloat() );
 	return JS_TRUE;
 }
 
 //Generate a random float int between 0 and the given number - 1 using the simulation's RNG
 JSBool simRandInt(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_PARAMS(1);
 	JSU_ASSERT(JSVAL_IS_INT(argv[0]), "simRandInt(): first parameter must be an int");
 
 	*rval = ToJSVal( g_Game->GetSimulation()->RandInt(ToPrimitive<int>(argv[0])) );
 	return JS_TRUE;
 }
 
 // Script profiling functions: Begin timing a piece of code with startXTimer(num)
 // and stop timing with stopXTimer(num). The results will be printed to stdout
 // when the game exits.
 
 static const uint MAX_XTIMERS = 20;
 typedef TimerRdtsc XTimerImpl;	// type must be kept in sync with timer.h TIMER_USE_RAW_TICKS
 static XTimerImpl xtimer_impl;
 static XTimerImpl::unit xstart_times[MAX_XTIMERS];
 static XTimerImpl::unit xoverhead;
 static TimerClient xclients[MAX_XTIMERS];
 static char xdescription_buf[MAX_XTIMERS * 11];
 
 static void initXTimers()
 {
 	char* pos = xdescription_buf;
 	for(uint i = 0; i < MAX_XTIMERS; i++)
 	{
 		const char* description = pos;
 		pos += sprintf(pos, "xtimer %d", i)+1;
 		timer_add_client(&xclients[i], description);
 	}
 
 	// call several times to get a good approximation of 'hot' performance.
 	// note: don't use a separate timer slot to warm up and then judge
 	// overhead from another: that causes worse results (probably some
 	// caching effects inside JS, but I don't entirely understand why).
 	static const char* calibration_script =
 		"startXTimer(0);\n"
 		"stopXTimer (0);\n"
 		"startXTimer(0);\n"
 		"stopXTimer (0);\n"
 		"startXTimer(0);\n"
 		"stopXTimer (0);\n"
 		"startXTimer(0);\n"
 		"stopXTimer (0);\n"
 		"\n";
 	g_ScriptingHost.RunMemScript(calibration_script, strlen(calibration_script));
 	xoverhead = xclients[0].sum/4;
 }
 
 JSBool startXTimer(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	ONCE(initXTimers());
 
 	JSU_REQUIRE_PARAMS(1);
 	uint slot = ToPrimitive<uint>(argv[0]);
 	if (slot >= MAX_XTIMERS)
 		return JS_FALSE;
 
 	debug_assert(xstart_times[slot] == 0);
 	xstart_times[slot] = xtimer_impl.get_timestamp();
 	return JS_TRUE;
 }
 
 
 JSBool stopXTimer(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_PARAMS(1);
 	uint slot = ToPrimitive<uint>(argv[0]);
 	if (slot >= MAX_XTIMERS)
 		return JS_FALSE;
 
 	debug_assert(xstart_times[slot] != 0);
 	XTimerImpl::unit dt = xtimer_impl.get_timestamp() - xstart_times[slot] - xoverhead;
 	xstart_times[slot] = 0;
 	timer_bill_client(&xclients[slot], dt);
 	return JS_TRUE;
 }
 
 
 //-----------------------------------------------------------------------------
 // Game Setup
 //-----------------------------------------------------------------------------
 
 // Create a new network server object.
 // params:
 // returns: net server object
 JSBool createServer(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	if( !g_Game )
 		g_Game = new CGame();
 	if( !g_NetServer )
 		g_NetServer = new CNetServer(g_Game, &g_GameAttributes);
 
 	*rval = OBJECT_TO_JSVAL(g_NetServer->GetScript());
 	return( JS_TRUE );
 }
 
 
 // Create a new network client object.
 // params:
 // returns: net client object
 JSBool createClient(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	if( !g_Game )
 		g_Game = new CGame();
 	if( !g_NetClient )
 		g_NetClient = new CNetClient(g_Game, &g_GameAttributes);
 
 	*rval = OBJECT_TO_JSVAL(g_NetClient->GetScript());
 	return( JS_TRUE );
 }
 
 
 // Begin the process of starting a game.
 // params:
 // returns: success [bool]
 // notes:
 // - Performs necessary initialization while calling back into the
 //   main loop, so the game remains responsive to display+user input.
 // - When complete, the engine calls the reallyStartGame JS function.
 // TODO: Replace startGame with create(Game|Server|Client)/game.start() -
 //   after merging CGame and CGameAttributes
 JSBool startGame(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	*rval = BOOLEAN_TO_JSVAL(JS_TRUE);
 
 	// Hosted MP Game
 	if (g_NetServer)
 		*rval = BOOLEAN_TO_JSVAL(g_NetServer->StartGame() == 0);
 	// Joined MP Game: startGame is invalid - do nothing
 	else if (g_NetClient)
 	{
 	}
 	// Start an SP Game Session
 	else if (!g_Game)
 	{
 		g_Game = new CGame();
 		PSRETURN ret = g_Game->StartGame(&g_GameAttributes);
 		if (ret != PSRETURN_OK)
 		{
 			// Failed to start the game - destroy it, and return false
 
 			delete g_Game;
 			g_Game = NULL;
 
 			*rval = BOOLEAN_TO_JSVAL(JS_FALSE);
 			return( JS_TRUE );
 		}
 	}
 
 	return( JS_TRUE );
 }
 
 
 // Immediately ends the current game (if any).
 // params:
 // returns:
 JSBool endGame(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	EndGame();
 	return JS_TRUE;
 }
 
 
 //-----------------------------------------------------------------------------
 // Internationalization
 //-----------------------------------------------------------------------------
 
 // these remain here instead of in the i18n tree because they are
 // really related to the engine's use of them, as opposed to i18n itself.
 // contrariwise, translate() cannot be moved here because that would
 // make i18n dependent on this code and therefore harder to reuse.
 
 // Replaces the current language (locale) with a new one.
 // params: language id [string] as in I18n::LoadLanguage
 // returns:
 JSBool loadLanguage(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_PARAMS(1);
 
 	CStr lang = g_ScriptingHost.ValueToString(argv[0]);
 	I18n::LoadLanguage(lang);
 
 	return JS_TRUE;
 }
 
 
 // Return identifier of the current language (locale) in use.
 // params:
 // returns: language id [string] as in I18n::LoadLanguage
 JSBool getLanguageID(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 	*rval = JSVAL_NULL;
 
 	JSString* s = JS_NewStringCopyZ(cx, I18n::CurrentLanguageName());
 	if (!s)
 	{
 		JS_ReportError(cx, "Error creating string");
 		return JS_FALSE;
 	}
 	*rval = STRING_TO_JSVAL(s);
 	return JS_TRUE;
 }
 
 
 //-----------------------------------------------------------------------------
 // Debug
 //-----------------------------------------------------------------------------
 
 
 // Deliberately cause the game to crash.
 // params:
 // returns:
 // notes:
 // - currently implemented via access violation (read of address 0)
 // - useful for testing the crashlog/stack trace code.
 JSBool crash(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	MICROLOG(L"Crashing at user's request.");
 	return *(JSBool*)0;
 }
 
 
 // Force a JS GC (garbage collection) cycle to take place immediately.
 // params:
 // returns: true [bool]
 // notes:
 // - writes an indication of how long this took to the console.
 JSBool forceGC(JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	double time = get_time();
 	JS_GC(cx);
 	time = get_time() - time;
 	g_Console->InsertMessage(L"Garbage collection completed in: %f", time);
 	*rval = JSVAL_TRUE;
 	return JS_TRUE ;
 }
 
 
 
 //-----------------------------------------------------------------------------
 // GUI
 //-----------------------------------------------------------------------------
 
 // Returns the sort-of-global object associated with the current GUI.
 // params:
 // returns: global object
 // notes:
 // - Useful for accessing an object from another scope.
 JSBool getGUIGlobal(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	*rval = OBJECT_TO_JSVAL(g_GUI.GetScriptObject());
 	return JS_TRUE;
 }
 
 // Resets the entire GUI state and reloads the XML files.
 // params:
 // returns:
 JSBool resetGUI(JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval)
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	// Slightly unpleasant code, because CGUI is a Singleton but we don't really
 	// want it to be
 	g_GUI.Destroy();
 	delete &g_GUI;
 	new CGUI;
 	GUI_Init();
 	g_GUI.SendEventToAll("load");
 
 	return JS_TRUE;
 }
 
 
 //-----------------------------------------------------------------------------
 // Misc. Engine Interface
 //-----------------------------------------------------------------------------
 
 // Return the global frames-per-second value.
 // params:
 // returns: FPS [int]
 // notes:
 // - This value is recalculated once a frame. We take special care to
 //   filter it, so it is both accurate and free of jitter.
 JSBool getFPS( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	*rval = INT_TO_JSVAL(fps);
 	return JS_TRUE;
 }
 
 
 // Cause the game to exit gracefully.
 // params:
 // returns:
 // notes:
 // - Exit happens after the current main loop iteration ends
 //   (since this only sets a flag telling it to end)
 JSBool exitProgram( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	kill_mainloop();
 	return JS_TRUE;
 }
 
 
 // Write an indication of total/available video RAM to console.
 // params:
 // returns:
 // notes:
 // - Not supported on all platforms.
 // - Only a rough approximation; do not base low-level decisions
 //   ("should I allocate one more texture?") on this.
 JSBool vmem( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 #if OS_WIN
 	int left, total;
 	if (GetVRAMInfo(left, total))
 		g_Console->InsertMessage(L"VRAM: used %d, total %d, free %d", total-left, total, left);
 	else
 		g_Console->InsertMessage(L"VRAM: failed to detect");
 #else
 	g_Console->InsertMessage(L"VRAM: [not available on non-Windows]");
 #endif
 	return JS_TRUE;
 }
 
 
 // Change the mouse cursor.
 // params: cursor name [string] (i.e. basename of definition file and texture)
 // returns:
 // notes:
 // - Cursors are stored in "art\textures\cursors"
 JSBool setCursor( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 	g_CursorName = g_ScriptingHost.ValueToString(argv[0]);
 	return JS_TRUE;
 }
 JSBool getCursorName( JSContext* UNUSED(cx), JSObject*, uint UNUSED(argc), jsval* UNUSED(argv), jsval* rval )
 {
 	*rval = ToJSVal(g_CursorName);
 	return JS_TRUE;
 }
 
 // Trigger a rewrite of all maps.
 // params:
 // returns:
 // notes:
 // - Usefulness is unclear. If you need it, consider renaming this and updating the docs.
 JSBool _rewriteMaps( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	g_Game->GetWorld()->RewriteMap();
 	return JS_TRUE;
 }
 
 
 // Change the LOD bias.
 // params: LOD bias [float]
 // returns:
 // notes:
 // - value is as required by GL_TEXTURE_LOD_BIAS.
 // - useful for adjusting image "sharpness" (since it affects which mipmap level is chosen)
 JSBool _lodbias( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 
 	g_Renderer.SetOptionFloat(CRenderer::OPT_LODBIAS, ToPrimitive<float>(argv[0]));
 	return JS_TRUE;
 }
 
 
 // Focus the game camera on a given position.
 // params: target position vector [CVector3D]
 // returns: success [bool]
 JSBool setCameraTarget( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(1);
 	*rval = JSVAL_NULL;
 
 	CVector3D* target = ToNative<CVector3D>( argv[0] );
 	if(!target)
 	{
 		JS_ReportError( cx, "Invalid camera target" );
 		return( JS_TRUE );
 	}
 	g_Game->GetView()->SetCameraTarget( *target );
 
 	*rval = JSVAL_TRUE;
 	return( JS_TRUE );
 }
 
 
 //-----------------------------------------------------------------------------
 // Miscellany
 //-----------------------------------------------------------------------------
 
 // Return the date/time at which the current executable was compiled.
 // params: none (-> "date time") OR
 //   what to display [int]: 0 (-> "date"); 1 (-> "time")
 // returns: date and/or time [string]
 // notes:
 // - Displayed on main menu screen; tells non-programmers which auto-build
 //   they are running. Could also be determined via .EXE file properties,
 //   but that's a bit more trouble.
 // - To be exact, the date/time returned is when scriptglue.cpp was
 //   last compiled; since the auto-build does full rebuilds, that is moot.
 JSBool buildTime( JSContext* cx, JSObject*, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAM_RANGE(0, 1);
 
 	// buildTime( ) = "date time"
 	// buildTime(0) = "date"
 	// buildTime(1) = "time"
 	JSString* s = JS_NewStringCopyZ(cx,
 		argc && argv[0]==JSVAL_ONE ? __TIME__
 		:	argc ? __DATE__
 		: __DATE__" "__TIME__
 		);
 	*rval = STRING_TO_JSVAL(s);
 	return JS_TRUE;
 }
 
 
 // Return distance between 2 points.
 // params: 2 position vectors [CVector3D]
 // returns: Euclidean distance [float]
 JSBool v3dist( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS(2);
 
 	CVector3D* a = ToNative<CVector3D>( argv[0] );
 	CVector3D* b = ToNative<CVector3D>( argv[1] );
 	float dist = ( *a - *b ).GetLength();
 	*rval = ToJSVal( dist );
 	return( JS_TRUE );
 }
 
 
 // Returns the global object.
 // params:
 // returns: global object
 // notes:
 // - Useful for accessing an object from another scope.
 JSBool getGlobal( JSContext* cx, JSObject* globalObject, uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	*rval = OBJECT_TO_JSVAL( globalObject );
 	return( JS_TRUE );
 }
 
 // Activates the building placement cursor for placing a building. The currently selected units
 // are then ordered to construct the building if it is placed.
 // params: templateName - the name of the entity to place.
 // returns: true if cursor was activated, false if cursor was already active.
 JSBool startPlacing( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	CStrW name;
 	if(argc == 0) {
 		name = L"hele_ho";			// save some typing during testing
 	}
 	else {
 		if(!ToPrimitive<CStrW>( g_ScriptingHost.GetContext(), argv[0], name ))
 		{
 			JS_ReportError( cx, "Invalid template name argument" );
 			*rval = JSVAL_NULL;
 			return( JS_FALSE );
 		}
 	}
 
 	*rval = g_BuildingPlacer.activate(name) ? JS_TRUE : JS_FALSE;
 
 	return( JS_TRUE );
 }
 
 // Toggles drawing the sky
 JSBool toggleSky( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 	g_Renderer.GetSkyManager()->m_RenderSky = !g_Renderer.GetSkyManager()->m_RenderSky;
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Toggles drawing the water plane
 JSBool toggleWater( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 	g_Renderer.GetWaterManager()->m_RenderWater = !g_Renderer.GetWaterManager()->m_RenderWater;
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Sets the water plane height
 JSBool setWaterHeight( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 1 );
 	float newHeight;
 	if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], newHeight ))
 	{
 		JS_ReportError( cx, "Invalid water height argument" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 	g_Renderer.GetWaterManager()->m_WaterHeight = newHeight;
 	g_TerrainModified = true;
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Gets the water plane height
 JSBool getWaterHeight( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 	*rval = ToJSVal(g_Renderer.GetWaterManager()->m_WaterHeight);
 	return( JS_TRUE );
 }
 
 // Sets the water color
 JSBool setWaterColor( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 3 );
 	float r,g,b;
 	if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], r )
 		|| !ToPrimitive( g_ScriptingHost.GetContext(), argv[1], g )
 		|| !ToPrimitive( g_ScriptingHost.GetContext(), argv[2], b ))
 	{
 		JS_ReportError( cx, "Invalid arguments" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 	g_Renderer.GetWaterManager()->m_WaterColor = CColor(r, g, b, 1.0f);
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Sets the water tint (used to tint reflections in fancy water)
 JSBool setWaterTint( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 3 );
 	float r,g,b;
 	if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], r )
 		|| !ToPrimitive( g_ScriptingHost.GetContext(), argv[1], g )
 		|| !ToPrimitive( g_ScriptingHost.GetContext(), argv[2], b ))
 	{
 		JS_ReportError( cx, "Invalid arguments" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 	g_Renderer.GetWaterManager()->m_WaterTint = CColor(r, g, b, 1.0f);
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Sets the water tint (used to tint reflections in fancy water)
 JSBool setReflectionTint( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 3 );
 	float r,g,b;
 	if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], r )
 		|| !ToPrimitive( g_ScriptingHost.GetContext(), argv[1], g )
 		|| !ToPrimitive( g_ScriptingHost.GetContext(), argv[2], b ))
 	{
 		JS_ReportError( cx, "Invalid arguments" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 	g_Renderer.GetWaterManager()->m_ReflectionTint = CColor(r, g, b, 1.0f);
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Sets the max water alpha (achieved when it is at WaterFullDepth or deeper)
 JSBool setWaterMaxAlpha( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 1 );
 	float val;
 	if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], val ))
 	{
 		JS_ReportError( cx, "Invalid argument" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 	g_Renderer.GetWaterManager()->m_WaterMaxAlpha = val;
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Sets the water full depth (when it is colored WaterMaxAlpha)
 JSBool setWaterFullDepth( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 1 );
 	float val;
 	if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], val ))
 	{
 		JS_ReportError( cx, "Invalid argument" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 	g_Renderer.GetWaterManager()->m_WaterFullDepth = val;
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Sets the water alpha offset (added to tweak water alpha near the shore)
 JSBool setWaterAlphaOffset( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 1 );
 	float val;
 	if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], val ))
 	{
 		JS_ReportError( cx, "Invalid argument" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 	g_Renderer.GetWaterManager()->m_WaterAlphaOffset = val;
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 // Is the game paused?
 JSBool isPaused( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	if( !g_Game )
 	{
 		JS_ReportError( cx, "Game is not started" );
 		return JS_FALSE;
 	}
 
 	*rval = g_Game->m_Paused ? JSVAL_TRUE : JSVAL_FALSE;
 	return JS_TRUE ;
 }
 
 // Pause/unpause the game
 JSBool setPaused( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAMS( 1 );
 
 	if( !g_Game )
 	{
 		JS_ReportError( cx, "Game is not started" );
 		return JS_FALSE;
 	}
 
 	try
 	{
 		g_Game->m_Paused = ToPrimitive<bool>( argv[0] );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid parameter to setPaused" );
 	}
 
 	return  JS_TRUE;
 }
 
 // Get game time
 JSBool getGameTime( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_NO_PARAMS();
 
 	if( !g_Game )
 	{
 		JS_ReportError( cx, "Game is not started" );
 		return JS_FALSE;
 	}
 
 	*rval = ToJSVal(g_Game->GetTime());
 	return JS_TRUE;
 }
 
+JSBool registerTrigger( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, 
+														jsval* argv, jsval* rval )
+{
+	JSU_REQUIRE_PARAMS_CPP(1);
+	CTrigger* trigger = ToNative<CTrigger>( argv[0] );
+	debug_assert( trigger );
+
+	g_TriggerManager.AddTrigger( trigger );
+	*rval = JSVAL_NULL;
+	return JS_TRUE;
+}
+JSBool getTrigger( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, 
+													jsval* argv, jsval* rval )
+{
+	JSU_REQUIRE_PARAMS_CPP(1);
+	CStrW name = ToPrimitive<CStrW>( argv[0] );
+	
+	if ( g_TriggerManager.m_TriggerMap.find(name) != g_TriggerManager.m_TriggerMap.end() )
+		*rval = ToJSVal( g_TriggerManager.m_TriggerMap[name] );
+	else
+	{
+		debug_printf("Invalid trigger name %ws", name);
+		*rval = JSVAL_NULL;
+	}
+	return JS_TRUE;
+}
+
 // Reveal map
 JSBool revealMap( JSContext* cx, JSObject* UNUSED(globalObject), uint argc, jsval* argv, jsval* rval )
 {
 	JSU_REQUIRE_PARAM_RANGE(0, 1);
 
 	uint newValue;
 	if(argc == 0)
 	{
 		newValue = 2;
 	}
 	else if(!ToPrimitive( g_ScriptingHost.GetContext(), argv[0], newValue ) || newValue > 2 || newValue < 0)
 	{
 		JS_ReportError( cx, "Invalid argument (should be 0, 1 or 2)" );
 		*rval = JSVAL_VOID;
 		return( JS_FALSE );
 	}
 
 	g_Game->GetWorld()->GetLOSManager()->m_LOSSetting = newValue;
 	*rval = JSVAL_VOID;
 	return( JS_TRUE );
 }
 
 //-----------------------------------------------------------------------------
 // function table
 //-----------------------------------------------------------------------------
 
 // the JS interpreter expects the table to contain 5-tuples as follows:
 // - name the function will be called as from script;
 // - function which will be called;
 // - number of arguments this function expects
 // - Flags (deprecated, always zero)
 // - Extra (reserved for future use, always zero)
 //
 // we simplify this a bit with a macro:
 #define JS_FUNC(script_name, cpp_function, min_params) { #script_name, cpp_function, min_params, 0, 0 },
 
 JSFunctionSpec ScriptFunctionTable[] =
 {
 	// Console
 	JS_FUNC(writeConsole, JSI_Console::writeConsole, 1)	// external
 
 	// Entity
 	JS_FUNC(getEntityByHandle, getEntityByHandle, 1)
 	JS_FUNC(getEntityTemplate, getEntityTemplate, 1)
 	JS_FUNC(issueCommand, issueCommand, 2)
 	JS_FUNC(startPlacing, startPlacing, 1)
 
 	JS_FUNC(createEntityFormation, createEntityFormation, 2)
 	JS_FUNC(removeFromFormation, removeFromFormation, 1)
 	JS_FUNC(lockEntityFormation, lockEntityFormation, 1)
 	JS_FUNC(isFormationLocked, isFormationLocked, 1)
 	
 	//Tech
 	JS_FUNC(getTechnology, getTechnology, 2)
 	// Camera
 	JS_FUNC(setCameraTarget, setCameraTarget, 1)
 
 	// Sky
 	JS_FUNC(toggleSky, toggleSky, 0)
 
 	// Water
 	JS_FUNC(toggleWater, toggleWater, 0)
 	JS_FUNC(setWaterHeight, setWaterHeight, 1)
 	JS_FUNC(getWaterHeight, getWaterHeight, 0)
 	JS_FUNC(setWaterColor, setWaterColor, 3)
 	JS_FUNC(setWaterTint, setWaterTint, 3)
 	JS_FUNC(setReflectionTint, setReflectionTint, 3)
 	JS_FUNC(setWaterMaxAlpha, setWaterMaxAlpha, 0)
 	JS_FUNC(setWaterFullDepth, setWaterFullDepth, 0)
 	JS_FUNC(setWaterAlphaOffset, setWaterAlphaOffset, 0)
 
 	// GUI
 #ifndef NO_GUI
 	JS_FUNC(getGUIObjectByName, JSI_IGUIObject::getByName, 1)	// external
 	JS_FUNC(getGUIGlobal, getGUIGlobal, 0)
 	JS_FUNC(resetGUI, resetGUI, 0)
 #endif
 
 	// Events
 	JS_FUNC(addGlobalHandler, AddGlobalHandler, 2)
 	JS_FUNC(removeGlobalHandler, RemoveGlobalHandler, 2)
 
 	// Timer
 	JS_FUNC(setTimeout, setTimeout, 2)
 	JS_FUNC(setInterval, setInterval, 2)
 	JS_FUNC(cancelInterval, cancelInterval, 0)
 	JS_FUNC(cancelTimer, cancelTimer, 0)
 	JS_FUNC(setSimRate, setSimRate, 1)
 
 	// Random number generator
 	JS_FUNC(simRand, simRand, 0)
 	JS_FUNC(simRandInt, simRandInt, 1)
 
 	// Profiling
 	JS_FUNC(startXTimer, startXTimer, 1)
 	JS_FUNC(stopXTimer, stopXTimer, 1)
 
 	// Game Setup
 	JS_FUNC(startGame, startGame, 0)
 	JS_FUNC(endGame, endGame, 0)
 	JS_FUNC(createClient, createClient, 0)
 	JS_FUNC(createServer, createServer, 0)
 
 	// VFS (external)
 	JS_FUNC(buildDirEntList, JSI_VFS::BuildDirEntList, 1)
 	JS_FUNC(getFileMTime, JSI_VFS::GetFileMTime, 1)
 	JS_FUNC(getFileSize, JSI_VFS::GetFileSize, 1)
 	JS_FUNC(readFile, JSI_VFS::ReadFile, 1)
 	JS_FUNC(readFileLines, JSI_VFS::ReadFileLines, 1)
 	JS_FUNC(archiveBuilderCancel, JSI_VFS::ArchiveBuilderCancel, 1)
 
 	// Internationalization
 	JS_FUNC(loadLanguage, loadLanguage, 1)
 	JS_FUNC(getLanguageID, getLanguageID, 0)
 	// note: i18n/ScriptInterface.cpp registers translate() itself.
 	// rationale: see implementation section above.
 
 	// Debug
 	JS_FUNC(crash, crash, 0)
 	JS_FUNC(forceGC, forceGC, 0)
 	JS_FUNC(revealMap, revealMap, 1)
 
 	// Misc. Engine Interface
 	JS_FUNC(writeLog, WriteLog, 1)
 	JS_FUNC(exit, exitProgram, 0)
 	JS_FUNC(isPaused, isPaused, 0)
 	JS_FUNC(setPaused, setPaused, 1)
 	JS_FUNC(getGameTime, getGameTime, 0)
 	JS_FUNC(vmem, vmem, 0)
 	JS_FUNC(_rewriteMaps, _rewriteMaps, 0)
 	JS_FUNC(_lodbias, _lodbias, 0)
 	JS_FUNC(setCursor, setCursor, 1)
 	JS_FUNC(getCursorName, getCursorName, 0)
 	JS_FUNC(getFPS, getFPS, 0)
 	JS_FUNC(isOrderQueued, isOrderQueued, 1)
 
 	// Miscellany
 	JS_FUNC(v3dist, v3dist, 2)
 	JS_FUNC(buildTime, buildTime, 0)
 	JS_FUNC(getGlobal, getGlobal, 0)
 
 	// end of table marker
 	{0, 0, 0, 0, 0}
 };
 #undef JS_FUNC
 
 
 //-----------------------------------------------------------------------------
 // property accessors
 //-----------------------------------------------------------------------------
 
 JSBool GetEntitySet( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(argv), jsval* vp )
 {
 	std::vector<HEntity>* extant = g_EntityManager.getExtant();
 
 	*vp = OBJECT_TO_JSVAL( EntityCollection::Create( *extant ) );
 	delete( extant );
 
 	return( JS_TRUE );
 }
 
 
 JSBool GetPlayerSet( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(id), jsval* vp )
 {
 	std::vector<CPlayer*>* players = g_Game->GetPlayers();
 
 	*vp = OBJECT_TO_JSVAL( PlayerCollection::Create( *players ) );
 
 	return( JS_TRUE );
 }
 
 
 JSBool GetLocalPlayer( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(id), jsval* vp )
 {
 	*vp = OBJECT_TO_JSVAL( g_Game->GetLocalPlayer()->GetScript() );
 	return( JS_TRUE );
 }
 
 
 JSBool GetGaiaPlayer( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(id), jsval* vp )
 {
 	*vp = OBJECT_TO_JSVAL( g_Game->GetPlayer( 0 )->GetScript() );
 	return( JS_TRUE );
 }
 
 
 JSBool SetLocalPlayer( JSContext* cx, JSObject* UNUSED(obj), jsval UNUSED(id), jsval* vp )
 {
 	CPlayer* newLocalPlayer = ToNative<CPlayer>( *vp );
 
 	if( !newLocalPlayer )
 	{
 		JS_ReportError( cx, "Not a valid Player." );
 		return( JS_TRUE );
 	}
 
 	g_Game->SetLocalPlayer( newLocalPlayer );
 	return( JS_TRUE );
 }
 
 
 JSBool GetGameView( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(id), jsval* vp )
 {
 	if (g_Game)
 		*vp = OBJECT_TO_JSVAL( g_Game->GetView()->GetScript() );
 	else
 		*vp = JSVAL_NULL;
 	return( JS_TRUE );
 }
 
 
 JSBool GetRenderer( JSContext* UNUSED(cx), JSObject* UNUSED(obj), jsval UNUSED(id), jsval* vp )
 {
 	if (CRenderer::IsInitialised())
 		*vp = OBJECT_TO_JSVAL( g_Renderer.GetScript() );
 	else
 		*vp = JSVAL_NULL;
 	return( JS_TRUE );
 }
 
 
 enum ScriptGlobalTinyIDs
 {
 	GLOBAL_SELECTION,
 	GLOBAL_GROUPSARRAY,
 	GLOBAL_CAMERA,
 	GLOBAL_CONSOLE,
 	GLOBAL_LIGHTENV
 };
 
 // shorthand
 #define PERM  JSPROP_PERMANENT
 #define CONST JSPROP_READONLY
 
 JSPropertySpec ScriptGlobalTable[] =
 {
 	{ "selection"  , GLOBAL_SELECTION,   PERM,         JSI_Selection::getSelection, JSI_Selection::setSelection },
 	{ "groups"     , GLOBAL_GROUPSARRAY, PERM,         JSI_Selection::getGroups,    JSI_Selection::setGroups },
 	{ "camera"     , GLOBAL_CAMERA,      PERM,         JSI_Camera::getCamera,       JSI_Camera::setCamera },
 	{ "console"    , GLOBAL_CONSOLE,     PERM | CONST, JSI_Console::getConsole,     0 },
 	{ "lightenv"   , GLOBAL_LIGHTENV,    PERM,         JSI_LightEnv::getLightEnv,   JSI_LightEnv::setLightEnv },
 	{ "entities"   , 0,                  PERM | CONST, GetEntitySet,                0 },
 	{ "players"    , 0,                  PERM | CONST, GetPlayerSet,                0 },
 	{ "localPlayer", 0,                  PERM        , GetLocalPlayer,              SetLocalPlayer },
 	{ "gaiaPlayer" , 0,                  PERM | CONST, GetGaiaPlayer,               0 },
 	{ "gameView"   , 0,                  PERM | CONST, GetGameView,                 0 },
 	{ "renderer"   , 0,                  PERM | CONST, GetRenderer,                 0 },
 
 	// end of table marker
 	{ 0, 0, 0, 0, 0 },
 };
Index: ps/trunk/source/simulation/TriggerManager.h
===================================================================
--- ps/trunk/source/simulation/TriggerManager.h	(nonexistent)
+++ ps/trunk/source/simulation/TriggerManager.h	(revision 4648)
@@ -0,0 +1,210 @@
+//========================================================
+//Andrew Decker aka pyrolink
+//ajdecker1022@msn.com
+//Description: Manages loading trigger specs (format in Atlas) and updating trigger objects
+//=======================================================
+
+#ifndef TRIGGERMANAGER_INCLUDED
+#define TRIGGERMANAGER_INCLUDED
+
+#include "ps/Singleton.h"
+#include "scripting/ScriptableObject.h"
+#include "simulation/ScriptObject.h"
+
+class CXeromyces;
+class XMBElement;
+
+//Trigger storage - used be Atlas to keep track of different triggers
+
+struct MapTriggerCondition
+{
+	MapTriggerCondition() : linkLogic(0), not(false) { }
+	CStrW name, functionName, displayName;
+	std::list<CStrW> parameters;
+	int linkLogic;	//0 = NONE, 1 = AND, 2 = OR
+	bool not;
+};
+
+struct MapTriggerEffect
+{
+	CStrW name, functionName, displayName;
+	std::list<CStrW> parameters;
+};
+
+struct MapTriggerLogicBlock
+{
+	MapTriggerLogicBlock(size_t i, bool _not=false) : index(i), not(_not) { }
+	size_t index;
+	bool not;
+
+	bool operator< (const MapTriggerLogicBlock& block) const { return (index < block.index); }
+	bool operator== (const MapTriggerLogicBlock& block) const { return (index == block.index); }
+};
+
+struct MapTrigger
+{
+	MapTrigger() : active(false), maxRunCount(0), timeValue(0) { }
+	bool active;
+	int maxRunCount;
+	float timeValue;
+	CStrW name, groupName;
+	
+	std::set<MapTriggerLogicBlock> logicBlocks;	//Indices of where "(" 's go before
+	std::set<size_t> logicBlockEnds;  //Indices of where ")" 's come after
+	std::list<MapTriggerCondition> conditions;
+	std::list<MapTriggerEffect> effects;
+
+	void AddLogicBlock(bool not) { logicBlocks.insert( MapTriggerLogicBlock(conditions.size(), not) ); }
+	void AddLogicBlockEnd() { logicBlockEnds.insert( effects.size() ); }
+};
+
+struct MapTriggerGroup
+{
+	MapTriggerGroup() { }
+	MapTriggerGroup(CStrW _name, CStrW _parentName) : name(_name), parentName(_parentName) {}
+
+	std::list<MapTrigger> triggers;
+	std::list<CStrW> childGroups;	//Indices of children
+	CStrW name, parentName;
+	
+	bool operator== (const CStrW& _name) const { return (name == _name); }
+	bool operator== (const MapTriggerGroup& group) const { return (name == group.name); }
+};
+
+
+struct copyIfRootChild
+{
+	copyIfRootChild(std::list<MapTriggerGroup>& groupList) : m_groupList(groupList) {}
+	void operator() ( const MapTriggerGroup& group )
+	{ 
+		if ( group.parentName == L"Triggers" )
+			m_groupList.push_back(group);
+	}
+private:
+	void operator= (const copyIfRootChild& UNUSED(group)) const {}
+	std::list<MapTriggerGroup>& m_groupList;
+};
+
+//Triggers used by engine
+
+class CTrigger : public CJSObject<CTrigger>
+{
+	int m_runCount;
+	CStrW m_conditionFuncString, m_effectFuncString, m_name, m_groupName;
+	CScriptObject m_effectFunction;
+	CScriptObject m_conditionFunction;
+
+public:
+	CTrigger();
+	CTrigger(const CStrW& name, bool active, float delay, int maxRuns, const CStrW& condFunc, 
+																	const CStrW& effectFunc);
+	CTrigger(const CStrW& name, bool active, float delay, int maxRuns,
+					CScriptObject& condFunc, CScriptObject& effectFunc);
+
+	CTrigger& operator= (const CTrigger& trigger);
+	~CTrigger();
+
+	void SetFunctionBody(const CStrW& body);
+	const CStrW& GetConditionString() { return m_conditionFuncString; }
+	const CStrW& GetEffectString() { return m_effectFuncString; }
+	const CStrW& GetName() { return m_name; }
+	const CStrW& GetGroupName() { return m_groupName; }
+	
+	bool ShouldFire();
+	//Returns false if trigger exceeds run count
+	bool Fire();
+
+	jsval Activate(JSContext* cx, uint argc, jsval* argv);
+	jsval Deactivate(JSContext* cx, uint argc, jsval* argv);
+
+	static JSBool Construct( JSContext* cx, JSObject* obj, uint argc, jsval* argv, jsval* rval );
+	static void ScriptingInit();
+
+	JSContext* m_cx;
+	
+	bool m_active;
+	//Changeable by Atlas or needed by manager, no additional affects required
+	int m_maxRunCount;
+	float m_timeLeft, m_timeDelay;
+	
+};
+
+
+//*****Holds information specifying how conditions and effects should look like in atlas******
+
+struct TriggerParameter
+{
+	TriggerParameter() {}
+	TriggerParameter(int _row, int _column) : row(_row), column(_column) {}
+	void SetWindowData(const CStrW& _windowType, CStrW& windowPosition, CStrW& windowSize);
+	//Sort parameters in the order they will be added to a sizer in atlas
+	bool operator< ( const TriggerParameter& rhs ) const;
+	
+	CStrW name, windowType, inputType;
+	int row, column, xPos, yPos, xSize, ySize, parameterOrder;
+};
+
+class CTriggerSpec
+{
+public:
+	CTriggerSpec() {}
+	~CTriggerSpec() {}
+	
+	void AddParameter(const TriggerParameter& param) { parameters.insert(param); }
+	const std::set<TriggerParameter>& GetParameters() const { return parameters; }
+	
+	CStrW displayName, functionName;
+
+private:
+	
+	//Sorted by parameter order to make things easy for Atlas
+	std::set<TriggerParameter> parameters;
+};
+typedef CTriggerSpec CTriggerEffect;
+typedef CTriggerSpec CTriggerCondition;
+
+
+/******************************Trigger manager******************************/
+
+class CTriggerManager : public Singleton<CTriggerManager>
+{
+public:
+	typedef std::map<CStrW, CTrigger*>::iterator TriggerIter ;
+
+	CTriggerManager();
+	~CTriggerManager();
+	
+	//Returns false on detection of error
+	bool LoadXML( const CStr& filename );
+	void Update(float delta);
+
+	//Add simulation trigger (probably only called from JS)
+	void AddTrigger(CTrigger* trigger);
+	void AddTrigger(MapTriggerGroup& group, const MapTrigger& trigger);
+	void AddGroup(const MapTriggerGroup& group);
+	void SetAllGroups(const std::list<MapTriggerGroup>& groups);
+	void DestroyEngineTriggers();
+
+	const std::list<CTriggerCondition>& GetAllConditions() const { return m_ConditionSpecs; }
+	const std::list<CTriggerEffect>& GetAllEffects() const { return m_EffectSpecs; }
+	const std::list<MapTriggerGroup>& GetAllTriggerGroups() const { return m_GroupList; }
+	std::vector<std::wstring> GetTriggerChoices(const std::wstring& name);
+
+	std::map<CStrW, CTrigger*> m_TriggerMap;	//Simulation triggers - used in engine
+	
+private:
+	bool loadTriggerSpec( XMBElement condition, CXeromyces& XeroFile, bool isCondition );
+	
+	//Contains choices for trigger choice box parameters, with key = spec.funcName+paramName
+	std::map<std::wstring, std::vector<std::wstring> > m_TriggerChoices;
+	
+	//Holds information which descibes trigger layout in atlas
+	std::list<MapTriggerGroup> m_GroupList;		
+	std::list<CTriggerCondition> m_ConditionSpecs;
+	std::list<CTriggerEffect> m_EffectSpecs;
+
+};
+
+#define g_TriggerManager CTriggerManager::GetSingleton()
+
+#endif	//ifndef TRIGGERMANAGER_INCLUDED
Index: ps/trunk/source/simulation/TriggerManager.cpp
===================================================================
--- ps/trunk/source/simulation/TriggerManager.cpp	(nonexistent)
+++ ps/trunk/source/simulation/TriggerManager.cpp	(revision 4648)
@@ -0,0 +1,406 @@
+#include "precompiled.h"
+
+#include "TriggerManager.h"
+#include "scripting/ScriptingHost.h"
+#include "ps/XML/Xeromyces.h"
+#include "ps/XML/XeroXMB.h"
+#include "ps/CLogger.h"
+
+#define LOG_CATEGORY "Triggers"
+
+
+CTrigger::CTrigger()
+{
+	m_timeLeft = m_timeDelay = m_maxRunCount = m_runCount = m_active = 0;
+}
+CTrigger::~CTrigger()
+{
+
+}
+CTrigger::CTrigger(const CStrW& name, bool active, float delay, int maxRuns, const CStrW& condFunc, 
+																const CStrW& effectFunc)
+{
+	m_name = name;
+	m_active = active;
+	m_timeLeft = m_timeDelay = delay;
+	m_runCount = 0;
+	m_maxRunCount = maxRuns;
+	
+	m_conditionFuncString = condFunc;
+	m_effectFuncString = effectFunc;
+	m_conditionFunction.Compile( L"TriggerCondition::" + m_name, condFunc );
+	m_effectFunction.Compile( L"TriggerEffect::" + m_name, effectFunc );
+
+}
+CTrigger::CTrigger(const CStrW& name, bool active, float delay, int maxRuns,
+					CScriptObject& condFunc, CScriptObject& effectFunc)
+{
+	m_name = name;
+	m_active = active;
+	m_timeLeft = m_timeDelay = delay;
+	m_runCount = 0;
+	m_maxRunCount = maxRuns;
+	m_conditionFunction = condFunc;
+	m_effectFunction = effectFunc;
+}
+
+JSBool CTrigger::Construct( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
+{
+	JSU_REQUIRE_PARAMS_CPP(6);
+
+	CScriptObject condFunc( JS_ValueToFunction(cx, argv[4]) );
+	CScriptObject effectFunc( JS_ValueToFunction(cx, argv[5]) );
+	CTrigger* newTrigger = new CTrigger( ToPrimitive<CStr>( argv[0] ),
+										 ToPrimitive<bool>( argv[1] ),
+										 ToPrimitive<int>( argv[2] ),
+										 ToPrimitive<float>( argv[3] ),
+										 condFunc, effectFunc );
+
+	g_TriggerManager.AddTrigger(newTrigger);
+	*rval = OBJECT_TO_JSVAL( newTrigger->GetScript() );
+	return JS_TRUE;
+}
+
+CTrigger& CTrigger::operator= (const CTrigger& trigger)
+{
+	m_name = trigger.m_name;
+	m_active = trigger.m_active;
+	m_timeLeft = trigger.m_timeLeft;
+	m_timeDelay = trigger.m_timeDelay;
+	m_maxRunCount = trigger.m_maxRunCount;
+	m_conditionFunction = trigger.m_conditionFunction;
+	m_effectFunction = trigger.m_effectFunction;
+
+	return *this;
+}
+
+void CTrigger::ScriptingInit()
+{
+	AddProperty<int>(L"runCount", &CTrigger::m_runCount, true);
+	AddProperty(L"name", &CTrigger::m_name, true);
+	AddProperty<int>(L"maxRunCount", &CTrigger::m_maxRunCount);
+	AddProperty<float>(L"timeDelay", &CTrigger::m_timeDelay);
+
+	AddMethod<jsval, &CTrigger::Activate>( "activate", 0 );
+	AddMethod<jsval, &CTrigger::Deactivate>( "deactivate", 0 );
+
+	CJSObject<CTrigger>::ScriptingInit("Trigger", CTrigger::Construct, 6);
+}
+
+bool CTrigger::ShouldFire()
+{
+	if ( !m_active )
+		return false;
+	return m_conditionFunction.Run( this->GetScript() );
+}
+bool CTrigger::Fire()
+{
+	m_effectFunction.Run( this->GetScript() );
+	++m_runCount;
+	m_timeLeft = m_timeDelay;
+	return (m_runCount < m_maxRunCount);
+}
+
+jsval CTrigger::Activate(JSContext* UNUSED(cx), uint UNUSED(argc), jsval* UNUSED(argv))
+{
+	m_active = true;
+	return JS_TRUE;
+}
+jsval CTrigger::Deactivate(JSContext* UNUSED(cx), uint UNUSED(argc), jsval* UNUSED(argv))
+{
+	m_active = false;
+	return JS_TRUE;
+}
+
+
+void TriggerParameter::SetWindowData(const CStrW& _windowType, CStrW& windowPosition, CStrW& windowSize)
+{
+	windowPosition.Remove( CStr(L" ") );
+	windowSize.Remove( CStr(L" ") );
+
+	xPos = windowPosition.BeforeFirst( CStrW(L",") ).ToInt();
+	yPos = windowPosition.AfterFirst( CStrW(L",") ).ToInt();
+	xSize = windowSize.BeforeFirst( CStrW(L",") ).ToInt();
+	ySize = windowSize.AfterFirst( CStrW(L",") ).ToInt();
+	windowType = _windowType;
+}
+
+bool TriggerParameter::operator< ( const TriggerParameter& rhs ) const
+{
+	if ( row < rhs.row )
+		return true;
+	else if ( row == rhs.row)
+		return ( column < rhs.column );
+
+	return false;
+}
+//===========Trigger Manager===========
+
+CTriggerManager::CTriggerManager()
+{
+}
+
+CTriggerManager::~CTriggerManager()
+{
+	DestroyEngineTriggers();
+}
+
+void CTriggerManager::DestroyEngineTriggers()
+{
+	for ( TriggerIter it = m_TriggerMap.begin(); it != m_TriggerMap.end(); ++it )
+	{
+		SAFE_DELETE(it->second);
+	}
+	m_TriggerMap.clear();
+}
+std::vector<std::wstring> CTriggerManager::GetTriggerChoices(const std::wstring& name)
+{
+	return m_TriggerChoices[name];
+}
+
+void CTriggerManager::Update(float delta)
+{
+	std::list<TriggerIter> expired;
+	for ( TriggerIter it = m_TriggerMap.begin(); it != m_TriggerMap.end(); ++it )
+	{
+		if ( it->second->ShouldFire() )
+		{
+			it->second->m_timeLeft -= delta;
+			if ( it->second->m_timeLeft < 0 )
+			{
+				if ( !it->second->Fire() )
+					expired.push_back(it);
+			}
+		}
+	}
+
+	//Remove all expired triggers
+	for ( std::list<TriggerIter>::iterator it = expired.begin(); it != expired.end(); ++it )
+	{
+		delete (*it)->second;;
+		m_TriggerMap.erase(*it);
+	}
+}
+
+void CTriggerManager::AddTrigger(CTrigger* trigger)
+{
+	m_TriggerMap[trigger->GetName()] = trigger;
+}
+void CTriggerManager::AddGroup(const MapTriggerGroup& group)
+{
+	m_GroupList.push_back(group);
+}
+void CTriggerManager::SetAllGroups(const std::list<MapTriggerGroup>& groups)
+{
+	m_GroupList = groups;
+}
+
+void CTriggerManager::AddTrigger(MapTriggerGroup& group, const MapTrigger& trigger)
+{
+	CStrW conditionBody(L"if ( ");
+	CStrW linkLogic[] = { CStrW(L""), CStrW(L" && "), CStrW(L" || ") };
+	size_t i=0;
+
+	for ( std::list<MapTriggerCondition>::const_iterator it = trigger.conditions.begin();
+												it != trigger.conditions.end(); ++it, ++i )
+	{
+		//Opening parenthesis here?
+		std::set<MapTriggerLogicBlock>::const_iterator blockIt;
+		if ( ( blockIt = trigger.logicBlocks.find(MapTriggerLogicBlock(i)) ) != trigger.logicBlocks.end() )
+		{
+			if ( blockIt->not )
+				conditionBody += CStrW(L"!");
+			conditionBody += CStrW(L" (");
+		}
+		
+		if ( it->not )
+			conditionBody += CStrW(L"!");
+		conditionBody += it->functionName;
+		conditionBody += CStrW(L"(");
+		for ( std::list<CStrW>::const_iterator it2 = it->parameters.begin(); it2 != 
+													it->parameters.end(); ++it2 )
+		{
+			conditionBody += *it2;
+			if ( std::distance(it2, it->parameters.end()) != 1 )
+				conditionBody += CStrW(L", ");
+		}
+		
+		conditionBody += CStrW(L")");
+		if ( trigger.logicBlockEnds.find(i) != trigger.logicBlockEnds.end() )
+			conditionBody += CStrW(L" )");
+
+		if ( std::distance(it, trigger.conditions.end()) != 1 )
+			conditionBody += linkLogic[it->linkLogic];
+	}
+	conditionBody += CStrW(L" )");	//closing if
+	conditionBody += CStrW(L" { return true; } ");
+	CStrW effectBody;
+	
+	for ( std::list<MapTriggerEffect>::const_iterator it = trigger.effects.begin();
+													it != trigger.effects.end(); ++it )
+	{
+		effectBody += it->functionName;
+		effectBody += CStrW(L"(");
+		for ( std::list<CStrW>::const_iterator it2 = it->parameters.begin(); it2 != 
+													it->parameters.end(); ++it2 )
+		{
+			effectBody += *it2;
+			std::list<CStrW>::const_iterator endIt = it->parameters.end();
+			if ( std::distance(it2, endIt) != 1 )
+				effectBody += CStrW(L", ");
+		}
+
+		effectBody += CStrW(L");");
+	}
+	group.triggers.push_back(trigger);
+	CTrigger* newTrigger = new CTrigger(trigger.name, trigger.active, trigger.timeValue,
+									trigger.maxRunCount, conditionBody, effectBody);
+	AddTrigger(newTrigger);
+}
+
+
+//XML stuff
+
+bool CTriggerManager::LoadXML( const CStr& filename )
+{
+	CXeromyces XeroFile;
+
+	if ( XeroFile.Load( filename.c_str() ) != PSRETURN_OK )
+		return false;
+
+	#define EL(x) int el_##x = XeroFile.getElementID(#x)
+	#define AT(x) int at_##x = XeroFile.getAttributeID(#x)
+
+	EL(condition);
+	EL(effect);
+	EL(definitions);
+
+	#undef EL
+	#undef AT
+	
+	//Return false on any error to be extra sure the point gets across (FIX IT)
+	XMBElement root = XeroFile.getRoot();
+	
+	if ( root.getNodeName() != el_definitions )
+		return false;
+
+	XERO_ITER_EL(root, rootChild)
+	{
+		int name = rootChild.getNodeName();
+		if ( name == el_condition )
+		{
+			if ( !loadTriggerSpec(rootChild, XeroFile, true) )
+			{
+				LOG(ERROR, LOG_CATEGORY, "Error detected in Trigger XML <condition> tag. File: %s", filename);
+				return false;
+			}
+		}
+		else if ( name == el_effect )
+		{
+			if ( !loadTriggerSpec(rootChild, XeroFile, false) )
+			{
+				LOG(ERROR, LOG_CATEGORY, "Error detected in Trigger XML <effect> tag. File: %s", filename);
+				return false;
+			}
+		}
+		else 
+		{
+			LOG(ERROR, LOG_CATEGORY, "Invalid tag in trigger XML. File: ws", filename);
+			return false;
+		}
+	}
+	return true;
+}
+
+bool CTriggerManager::loadTriggerSpec( XMBElement condition, CXeromyces& XeroFile, bool isCondition )
+{
+	#define EL(x) int el_##x = XeroFile.getElementID(#x)
+	#define AT(x) int at_##x = XeroFile.getAttributeID(#x)
+
+	EL(parameter);
+	EL(window);
+	EL(inputtype);
+	EL(parameterorder);
+	EL(windowrow);
+	EL(choices);
+
+	AT(type);
+	AT(position);
+	AT(name);
+	AT(size);
+	AT(function);
+
+	#undef EL
+	#undef AT
+	
+	CTriggerSpec specStore;
+	specStore.functionName = CStrW( condition.getAttributes().getNamedItem(at_function) );
+	specStore.displayName = CStrW( condition.getAttributes().getNamedItem(at_name) );
+	int row = -1, column = -1;
+
+	XERO_ITER_EL(condition, child)
+	{
+		int childID = child.getNodeName();
+		
+		if ( childID == el_windowrow )
+		{
+			++row;
+			column = -1;
+			
+			XERO_ITER_EL(child, windowChild)
+			{
+				++column;
+				TriggerParameter specParam(row, column);
+				specParam.name = windowChild.getAttributes().getNamedItem(at_name);
+				childID = windowChild.getNodeName();
+				
+				if ( childID != el_parameter)
+					return false;
+
+				XERO_ITER_EL(windowChild, parameterChild)
+				{
+					childID = parameterChild.getNodeName();
+					
+					if ( childID == el_window )
+					{
+						CStrW type( parameterChild.getAttributes().getNamedItem(at_type) );
+						CStrW pos( parameterChild.getAttributes().getNamedItem(at_position) );
+						CStrW size( parameterChild.getAttributes().getNamedItem(at_size) );
+						specParam.SetWindowData(type, pos, size);
+					}
+					
+					else if ( childID == el_inputtype )
+						specParam.inputType = CStrW( parameterChild.getText() );
+					else if ( childID == el_parameterorder )
+						specParam.parameterOrder = CStrW( parameterChild.getText() ).ToInt();
+					else if ( childID == el_choices )
+					{
+						std::vector<std::wstring> choices;
+						CStrW comma(L","), input(parameterChild.getText());
+						CStrW substr;
+						while ( (substr = input.BeforeFirst(comma)) != input )
+						{
+							choices.push_back(substr);
+							input = input.AfterFirst(comma);
+						}
+
+						choices.push_back(substr);	//Last element has no comma
+						m_TriggerChoices[specStore.functionName + specParam.name] = choices;
+					}
+					else
+						return false;
+				}
+				specStore.AddParameter(specParam);
+			}
+		}
+		else
+			return false;
+	}
+
+	if ( isCondition )
+		m_ConditionSpecs.push_back(specStore);
+	else
+		m_EffectSpecs.push_back(specStore);
+
+	return true;
+}
Index: ps/trunk/source/simulation/Entity.h
===================================================================
--- ps/trunk/source/simulation/Entity.h	(revision 4647)
+++ ps/trunk/source/simulation/Entity.h	(revision 4648)
@@ -1,489 +1,490 @@
 // Entity.h
 //
 // Mark Thompson mot20@cam.ac.uk / mark@wildfiregames.com
 //
 // Entity class.
 //
 // Usage: Do not attempt to instantiate this class directly. (See EntityManager.h)
 //		  Most of the members are trivially obvious; some highlights are:
 //
 //			HEntity me: is a reference to this entity. See EntityHandles.h
 //
 //			Destroying entities: An entity is destroyed when all references to it expire.
 //								 It is somewhat unfunny if this happens while a method from this
 //                               class is still executing. If you need to kill an entity,
 //								 use CEntity::kill(). If kill() releases the final handle,
 //								 the entity is placed in the reaper queue and is deleted immediately
 //								 prior to its next update cycle.
 //
 //			CUnit* m_actor: is the visible representation of this entity.
 //
 //			snapToGround(): Called every frame, this will ensure the entity never takes flight.
 //			updateActorTransforms(): Must be called every time the position of this entity changes.
 //			Also remember to update the collision object if you alter the position directly.
 //
 
 #ifndef ENTITY_INCLUDED
 #define ENTITY_INCLUDED
 
 #include <deque>
 #include "scripting/ScriptableComplex.h"
 #include "ps/Vector2D.h"
 #include "maths/Vector3D.h"
 #include "EntityOrders.h"
 #include "EntityHandles.h"
 #include "EntityMessage.h"
 #include "ScriptObject.h"
 #include "EntitySupport.h"
 #include "scripting/DOMEvent.h"
 #include "scripting/ScriptCustomTypes.h"
 
 class CAura;
 class CEntityTemplate;
 class CBoundingObject;
 class CPlayer;
 class CProductionQueue;
 class CSkeletonAnim;
 class CUnit;
 class CTerritory;
 class CEntityFormation;
 class CStance;
 
 // 
 enum EntityFlags
 {
 	// If this unit has been removed from the gameworld but has still
 	// has references.
 	ENTF_DESTROYED                  = 0x0001,
 
 	// State transition in the FSM (animations should be reset)
 	ENTF_TRANSITION                 = 0x0002,
 
 	ENTF_HAS_RALLY_POINT            = 0x0004,
 
 	ENTF_HEALTH_DECAY               = 0x0008,
 
 	// if set, we destroy them; otherwise, the script does.
 	ENTF_DESTROY_NOTIFIERS          = 0x0010,
 
 	// is it actually running
 	ENTF_IS_RUNNING                 = 0x0020,
 	// if run was issued, it will remain true until it is stopped
 	ENTF_SHOULD_RUN                 = 0x0040,
 	// used in SetRun, corrects 1 frame stamina imbalance
 	ENTF_TRIGGER_RUN                = 0x0080
 };
 
 // TODO MT: Put this is /some/ sort of order...
 
 class CEntity : public CJSComplex<CEntity>, public IEventTarget
 {
 	friend class CEntityManager;
 	friend class CUnit;
 
 	typedef STL_HASH_MAP<CStrW, CAura*, CStrW_hash_compare> AuraTable;
 	typedef STL_HASH_MAP<int, SEntityAction> ActionTable;
 	typedef std::set<CAura*> AuraSet;
 
 public:
 	// Intrinsic properties
 	CEntityTemplate* m_base;
 
 	// The class types this entity has
 	CClassSet m_classes;
 
 	// Production queue
 	CProductionQueue* m_productionQueue;
 
 	// Unit AI stance
 	CStance* m_stance;
 
 	// Movement properties
 	float m_speed;
 	float m_turningRadius;
 	float m_runSpeed;
 	float m_runRegenRate;
 	float m_runDecayRate;
 
 	float m_maxActorPitch;
 	float m_minActorPitch;
 
 	float m_healthRegenRate;
 	float m_healthRegenStart;
 	float m_healthDecayRate;
 
 	float m_runMaxRange;
 	float m_runMinRange;
 	
 	ActionTable m_actions;
 
 	bool m_selected;
 	i32 m_grouped;
 	int m_formation;	// Index of which formation we're in
 	int m_formationSlot;	// The slot of the above formation
 
 	uint ent_flags;
 	bool entf_get(uint desired_flag) const { return (ent_flags & desired_flag) != 0; }
 	void entf_set(uint desired_flag) { ent_flags |= desired_flag; }
 	void entf_clear(uint desired_flag) { ent_flags &= ~desired_flag; }
 	void entf_set_to(uint desired_flag, bool value)
 	{
 		ent_flags &= ~desired_flag;
 		const uint mask = value? ~0u : 0;
 		ent_flags |= desired_flag & mask;
 	}
 
 	// If this unit is still active in the gameworld - i.e. not a corpse.
 	bool m_extant;
 
 	// If this is false, the unit will not be drawn and cannot be interacted with using the mouse.
 	bool m_visible;
 
 	int m_frameCheck;	//counts the frame
 
 	float m_lastCombatTime;
 	float m_lastRunTime;
 
 	// Building to convert to if this is a foundation, or "" otherwise
 	CStrW m_building;
 
 	//SP properties
 	float m_staminaCurr;
 	float m_staminaMax;
 
 	// HP properties
 	float m_healthCurr;
 	float m_healthMax;
 
 	// Rank properties
 	CStr m_rankName;
 
 	// Stance name
 	CStr m_stanceName;
 
 	// LOS
 	int m_los;
 
 	// If the object is a territory centre, this points to its territory
 	CTerritory* m_associatedTerritory;
 
 	// Auras
 	AuraTable m_auras;
 	AuraSet m_aurasInfluencingMe;
 
 	//-- Interpolated property
 	CVector3D m_position;
 	CVector3D m_position_previous;
 	CVector3D m_graphics_position;
 
 	CBoundingObject* m_bounds;
 	float m_targetorientation;
 	CVector2D m_ahead;
 
 	//-- Interpolated property
 	CVector3D m_orientation;
 	CVector3D m_orientation_previous;
 	CVector3D m_graphics_orientation;
 	
 	CVector2D m_orientation_unclamped;
 
 	CVector3D m_rallyPoint;	// valid iff ENT_HAS_RALLY_POINT
 
 	// If the actor's current transform data is valid (i.e. the entity hasn't
 	// moved since it was last calculated, and the terrain hasn't been changed).
 	bool m_actor_transform_valid;
 
 	// Our current collision patch in CEntityManager
 	std::vector<CEntity*>* m_collisionPatch;
 
 	//-- Scripts
 
 	// Get script execution contexts - always run in the context of the entity that fired it.
 	JSObject* GetScriptExecContext( IEventTarget* target ) { return( ((CEntity*)target)->GetScript() ); }
 
 	CScriptObject m_EventHandlers[EVENT_LAST];
 
 	CUnit* m_actor;
 	std::set<CStr8> m_actorSelections;
 
 	int m_lastState;	// used in animation FSM
 
 	// Position in the current state's cycle
 	static const size_t NOT_IN_CYCLE = (size_t)-1;
 	size_t m_fsm_cyclepos; // -cycle_length....cycle_length
 	CSkeletonAnim* m_fsm_animation; // the animation we're about to play this cycle,
 	size_t m_fsm_anipos; // the time at which we should start playing it.
 	size_t m_fsm_anipos2; // for when there are two animation-related events we need to take care of.
 
 	std::deque<CEntityOrder> m_orderQueue;
 	std::deque<CEntityListener> m_listeners;
 
 	std::vector<CEntity*> m_notifiers;
 	int m_currentNotification;	//Current order in the form of a notification code
 	int m_currentRequest;	//Notification we our notifiers are sending
 
 	std::vector<bool> m_sectorValues;
 	//Slight optimization for aura rendering
 	std::vector< std::vector<CVector2D> > m_unsnappedPoints;
 
 private:
 	CEntity( CEntityTemplate* base, CVector3D position, float orientation, const std::set<CStr8>& actorSelections, const CStrW* building = 0 );
 
 	uint processGotoHelper( CEntityOrder* current, size_t timestep_milli, HEntity& collide );
 
 	bool processContactAction( CEntityOrder* current, size_t timestep_millis, CEntityOrder::EOrderType transition, SEntityAction* action );
 	bool processContactActionNoPathing( CEntityOrder* current, size_t timestep_millis, const CStr& animation, CScriptEvent* contactEvent, SEntityAction* action );
 
 	bool processGeneric( CEntityOrder* current, size_t timestep_milli );
 	bool processGenericNoPathing( CEntityOrder* current, size_t timestep_milli );
 
 	bool processProduce( CEntityOrder* order );
 
 	bool processGotoNoPathing( CEntityOrder* current, size_t timestep_milli );
 	bool processGoto( CEntityOrder* current, size_t timestep_milli );
 	bool processGotoWaypoint( CEntityOrder* current, size_t timestep_milli, bool contact );
 
 	bool processPatrol( CEntityOrder* current, size_t timestep_milli );
 
 	float chooseMovementSpeed( float distance );
 	
 	bool shouldRun( float distance );		// Given our distance to a target, can we be running?
 
 public:
 	~CEntity();
 
 	// Handle-to-self.
 	HEntity me;
 
 	// Updates gameplay information for the specified timestep
 	void update( size_t timestep_millis );
 	// Updates graphical information for a point between the last and current simulation frame; 0 < relativeoffset < 1.
 	void interpolate( float relativeoffset );
 
 	// Forces update of actor information during next call to 'interpolate'.
 	// (Necessary when terrain might move underneath the actor.)
 	void invalidateActor();
 
 	// Updates auras
 	void UpdateAuras( size_t timestep_millis );
 
 	// Removes entity from the gameworld and deallocates it, but not necessarily immediately.
 	void kill();
 
 	// Process initialization
 	bool Initialize();
 	void initAuraData();
 
 	// Process tick.
 	void Tick();
 
 	// Calculate distances along the terrain
 
 	float distance2D( float x, float z )
 	{
 		float dx = x - m_position.X;
 		float dz = z - m_position.Z;
 		return sqrt( dx*dx + dz*dz );
 	}
 
 	float distance2D( CEntity* other )
 	{
 		return distance2D( other->m_position.X, other->m_position.Z );
 	}
 
 	float distance2D( CVector2D p )
 	{
 		return distance2D( p.x, p.y );
 	}
 
 private:
 	// The player that owns this entity.
 	// (Player is set publicly via CUnit::SetPlayerID)
 	CPlayer* m_player;
 	void SetPlayer(CPlayer* player);
 public:
 	// Retrieve the player associated with this entity.
 	CPlayer* GetPlayer() { return m_player; }
 
 	// Update collision patch (move ourselves to a new one if necessary)
 	void updateCollisionPatch();
 
 	float getAnchorLevel( float x, float z );
 
 	void snapToGround();
 	void updateActorTransforms();
 	void updateXZOrientation();
 
 	// Getter and setter for the class sets
 	jsval getClassSet();
 	void setClassSet( jsval value );
 	void rebuildClassSet();
 
 	// Things like selection circles and debug info - possibly move to gui if/when it becomes responsible for (and capable of) it.
 	void render();
 	void renderSelectionOutline( float alpha = 1.0f );
 	void renderAuras();
 	void renderBars();
 	void renderBarBorders();
 	void renderHealthBar();
 	void renderStaminaBar();
 	void renderRank();
 	void renderRallyPoint();
 	
 	// Utility functions for rendering:
 
 	// Draw rectangle around the given centre, aligned with the given axes
 	void drawRect(CVector3D& centre, CVector3D& up, CVector3D& right, float x1, float y1, float x2, float y2);
 	void drawBar(CVector3D& centre, CVector3D& up, CVector3D& right, 
 		float x1, float y1, float x2, float y2,
 		SColour col1, SColour col2, float currVal, float maxVal);
 
 	CVector2D getScreenCoords( float height );
 
 	// After a collision, recalc the path to the next fixed waypoint.
 	void repath();
 
 	//Calculate stamina points
 	void CalculateRegen(float timestep);
 
 	// Reset properties after the entity-template we use changes.
 	void loadBase();
 	static void initAttributes(const CEntity* _this);
 
 	void reorient(); // Orientation
 	void teleport(); // Fixes things if the position is changed by something externally.
 	void stanceChanged(); // Sets m_stance to the right CStance object when our stance property is changed through scripts
 	void checkSelection(); // In case anyone tries to select/deselect this through JavaScript.
 	void checkGroup(); // Groups
 	void checkExtant(); // Existence
 
 	void clearOrders();
 	void popOrder();	//Use this if and order has finished instead of m_orderQueue.pop_front()
 	void pushOrder( CEntityOrder& order );
 
 	void DispatchNotification( CEntityOrder order, int type );
 	int DestroyNotifier( CEntity* target );	//Stop notifier from sending to us
 	void DestroyAllNotifiers();
 
 	int findSector( int divs, float angle, float maxAngle, bool negative=true );
+	jsval FlattenTerrain( JSContext* cx, uintN argc, jsval* argv );
 
 	CEntityFormation* GetFormation();
 	jsval GetFormationPenalty( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetFormationPenaltyBase( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetFormationPenaltyType( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetFormationPenaltyVal( JSContext* cx, uintN argc, jsval* argv );
 
 	jsval GetFormationBonus( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetFormationBonusBase( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetFormationBonusType( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetFormationBonusVal( JSContext* cx, uintN argc, jsval* argv );
 
 	void DispatchFormationEvent( int type );
 
 	jsval RegisterDamage( JSContext* cx, uintN argc, jsval* argv );
 	jsval RegisterOrderChange( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetAttackDirections( JSContext* cx, uintN argc, jsval* argv );
 
 	jsval FindSector( JSContext* cx, uintN argc, jsval* argv );
 	// Script constructor
 
 	static JSBool Construct( JSContext* cx, JSObject* obj, uint argc, jsval* argv, jsval* rval );
 
 	// Script-bound functions
 
 	jsval ToString( JSContext* cx, uintN argc, jsval* argv );
 
 	bool Kill( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetSpawnPoint( JSContext* cx, uintN argc, jsval* argv );
 
 	inline jsval HasRallyPoint( JSContext* cx, uintN argc, jsval* argv );
 	inline jsval GetRallyPoint( JSContext* cx, uintN argc, jsval* argv );
 	inline jsval SetRallyPoint( JSContext* cx, uintN argc, jsval* argv );
 
 	jsval AddAura( JSContext* cx, uintN argc, jsval* argv );
 	jsval RemoveAura( JSContext* cx, uintN argc, jsval* argv );
 
 	jsval SetActionParams( JSContext* cx, uintN argc, jsval* argv );
 	jsval TriggerRun( JSContext* cx, uintN argc, jsval* argv );
 	jsval SetRun( JSContext* cx, uintN argc, jsval* argv );
 	jsval IsRunning( JSContext* cx, uintN argc, jsval* argv );
 	jsval GetRunState( JSContext* cx, uintN argc, jsval* argv );
 	
 	jsval OnDamaged( JSContext* cx, uintN argc, jsval* argv );
 
 	jsval GetVisibleEntities( JSContext* cx, uintN argc, jsval* argv );
 
 	float GetDistance( JSContext* cx, uintN argc, jsval* argv );
 
 	bool RequestNotification( JSContext* cx, uintN argc, jsval* argv );
 	//Just in case we want to explicitly check the listeners without waiting for the order to be pushed
 	bool ForceCheckListeners( JSContext* cx, uintN argc, jsval* argv );
 	int GetCurrentRequest( JSContext* cx, uintN argc, jsval* argv );
 	void CheckListeners( int type, CEntity *target );
 	jsval DestroyAllNotifiers( JSContext* cx, uintN argc, jsval* argv );
 	jsval DestroyNotifier( JSContext* cx, uintN argc, jsval* argv );
 
 	jsval JSI_GetPlayer();
 	void JSI_SetPlayer(jsval val);
 
 	bool IsInFormation( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 	{
 		return ( m_formation != 0 ? true : false );
 	}
 
 	bool Order( JSContext* cx, uintN argc, jsval* argv, bool Queued );
 	inline bool OrderSingle( JSContext* cx, uintN argc, jsval* argv )
 	{
 		return( Order( cx, argc, argv, false ) );
 	}
 	inline bool OrderQueued( JSContext* cx, uintN argc, jsval* argv )
 	{
 		return( Order( cx, argc, argv, true ) );
 	}
 
 	bool IsIdle( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 	{
 		return( m_orderQueue.empty() );
 	}
 
 	bool HasClass( JSContext* cx, uintN argc, jsval* argv )
 	{
 		debug_assert( argc >= 1 );
 		return( m_classes.IsMember( ToPrimitive<CStrW>( cx, argv[0] ) ) );
 	}
 
 	jsval TerminateOrder( JSContext* UNUSED(cx), uintN argc, jsval* argv )
 	{
 		debug_assert( argc >= 1);
 		if ( ToPrimitive<bool>( argv[0] ) )
 			m_orderQueue.clear();
 		else
 			m_orderQueue.pop_front();
 		return JSVAL_VOID;
 	}
 
 	jsval GetHeight( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 	{
 		return ToJSVal(m_position.Y);
 	}
 
 	static void ScriptingInit();
 
 	// Functions that call script code
 	int GetAttackAction( HEntity target );
 
 	NO_COPY_CTOR(CEntity);
 };
 
 // General entity globals
 
 
 // In its current incarnation, inefficient but pretty
 #define SELECTION_TERRAIN_CONFORMANCE
 
 extern int SELECTION_CIRCLE_POINTS;
 extern int SELECTION_BOX_POINTS;
 extern int SELECTION_SMOOTHNESS_UNIFIED;
 extern int AURA_CIRCLE_POINTS;
 
 #endif
Index: ps/trunk/source/simulation/EntityScriptInterface.cpp
===================================================================
--- ps/trunk/source/simulation/EntityScriptInterface.cpp	(revision 4647)
+++ ps/trunk/source/simulation/EntityScriptInterface.cpp	(revision 4648)
@@ -1,924 +1,955 @@
 #include "precompiled.h"
 
 #include "graphics/GameView.h"
 #include "graphics/Model.h"
 #include "graphics/Sprite.h"
 #include "graphics/Terrain.h"
 #include "graphics/Unit.h"
 #include "graphics/UnitManager.h"
 #include "maths/MathUtil.h"
 #include "maths/scripting/JSInterface_Vector3D.h"
 #include "ps/Game.h"
 #include "ps/Interact.h"
 #include "ps/Profile.h"
 #include "renderer/Renderer.h"
 #include "renderer/WaterManager.h"
 #include "scripting/ScriptableComplex.inl"
 #include "ps/scripting/JSCollection.h"
 
 #include "Aura.h"
 #include "Collision.h"
 #include "Entity.h"
 #include "EntityFormation.h"
 #include "EntityManager.h"
 #include "EntityTemplate.h"
 #include "EntityTemplateCollection.h"
 #include "EventHandlers.h"
 #include "Formation.h"
 #include "FormationManager.h"
 #include "PathfindEngine.h"
 #include "ProductionQueue.h"
 #include "TechnologyCollection.h"
 #include "TerritoryManager.h"
 #include "Stance.h"
 
 #include <algorithm>
 
 extern int g_xres, g_yres;
 
 /*
 
  Scripting interface
 
 */
 
 // Scripting initialization
 
 void CEntity::ScriptingInit()
 {
 	AddMethod<jsval, &CEntity::ToString>( "toString", 0 );
 	AddMethod<bool, &CEntity::OrderSingle>( "order", 1 );
 	AddMethod<bool, &CEntity::OrderQueued>( "orderQueued", 1 );
 	AddMethod<jsval, &CEntity::TerminateOrder>( "terminateOrder", 1 );
 	AddMethod<bool, &CEntity::Kill>( "kill", 0 );
 	AddMethod<bool, &CEntity::IsIdle>( "isIdle", 0 );
 	AddMethod<bool, &CEntity::HasClass>( "hasClass", 1 );
 	AddMethod<jsval, &CEntity::GetSpawnPoint>( "getSpawnPoint", 1 );
 	AddMethod<jsval, &CEntity::AddAura>( "addAura", 3 );
 	AddMethod<jsval, &CEntity::RemoveAura>( "removeAura", 1 );
 	AddMethod<jsval, &CEntity::SetActionParams>( "setActionParams", 5 );
 	AddMethod<int, &CEntity::GetCurrentRequest>( "getCurrentRequest", 0 );
 	AddMethod<bool, &CEntity::ForceCheckListeners>( "forceCheckListeners", 2 );
 	AddMethod<bool, &CEntity::RequestNotification>( "requestNotification", 4 );
 	AddMethod<jsval, &CEntity::DestroyNotifier>( "destroyNotifier", 1 );
 	AddMethod<jsval, &CEntity::DestroyAllNotifiers>( "destroyAllNotifiers", 0 );
 	AddMethod<jsval, &CEntity::TriggerRun>( "triggerRun", 1 );
 	AddMethod<jsval, &CEntity::SetRun>( "setRun", 1 );
 	AddMethod<jsval, &CEntity::GetRunState>( "getRunState", 0 );
 	AddMethod<bool, &CEntity::IsInFormation>( "isInFormation", 0 );
 	AddMethod<jsval, &CEntity::GetFormationBonus>( "getFormationBonus", 0 );
 	AddMethod<jsval, &CEntity::GetFormationBonusType>( "getFormationBonusType", 0 );
 	AddMethod<jsval, &CEntity::GetFormationBonusVal>( "getFormationBonusVal", 0 );
 	AddMethod<jsval, &CEntity::GetFormationPenalty>( "getFormationPenalty", 0 );
 	AddMethod<jsval, &CEntity::GetFormationPenaltyType>( "getFormationPenaltyType", 0 );
 	AddMethod<jsval, &CEntity::GetFormationPenaltyVal>( "getFormationPenaltyVal", 0 );
 	AddMethod<jsval, &CEntity::RegisterDamage>( "registerDamage", 0 );
 	AddMethod<jsval, &CEntity::RegisterOrderChange>( "registerOrderChange", 0 );
 	AddMethod<jsval, &CEntity::GetAttackDirections>( "getAttackDirections", 0 );
 	AddMethod<jsval, &CEntity::FindSector>( "findSector", 4);
 	AddMethod<jsval, &CEntity::GetHeight>( "getHeight", 0 );
 	AddMethod<jsval, &CEntity::HasRallyPoint>( "hasRallyPoint", 0 );
 	AddMethod<jsval, &CEntity::SetRallyPoint>( "setRallyPoint", 0 );
 	AddMethod<jsval, &CEntity::GetRallyPoint>( "getRallyPoint", 0 );
 	AddMethod<jsval, &CEntity::OnDamaged>( "onDamaged", 1 );
 	AddMethod<jsval, &CEntity::GetVisibleEntities>( "getVisibleEntities", 0 );
 	AddMethod<float, &CEntity::GetDistance>( "getDistance", 1 );
+	AddMethod<jsval, &CEntity::FlattenTerrain>( "flattenTerrain", 0 );
 
 	AddClassProperty( L"traits.id.classes", (GetFn)&CEntity::getClassSet, (SetFn)&CEntity::setClassSet );
 	AddClassProperty( L"template", (CEntityTemplate* CEntity::*)&CEntity::m_base, false, (NotifyFn)&CEntity::loadBase );
 
 	/* Any inherited property MUST be added to EntityTemplate.cpp as well */
 
 	AddClassProperty( L"actions.move.speed", &CEntity::m_speed );
 	AddClassProperty( L"actions.move.run.speed", &CEntity::m_runSpeed );
 	AddClassProperty( L"actions.move.run.rangemin", &CEntity::m_runMinRange );
 	AddClassProperty( L"actions.move.run.range", &CEntity::m_runMaxRange );
 	AddClassProperty( L"actions.move.run.regenRate", &CEntity::m_runRegenRate );
 	AddClassProperty( L"actions.move.run.decayRate", &CEntity::m_runDecayRate );
 	AddClassProperty( L"selected", &CEntity::m_selected, false, (NotifyFn)&CEntity::checkSelection );
 	AddClassProperty( L"group", &CEntity::m_grouped, false, (NotifyFn)&CEntity::checkGroup );
 	AddClassProperty( L"traits.extant", &CEntity::m_extant );
 	AddClassProperty( L"actions.move.turningRadius", &CEntity::m_turningRadius );
 	AddClassProperty( L"position", &CEntity::m_graphics_position, false, (NotifyFn)&CEntity::teleport );
 	AddClassProperty( L"orientation", &CEntity::m_orientation, false, (NotifyFn)&CEntity::reorient );
 	AddClassProperty( L"player", (GetFn)&CEntity::JSI_GetPlayer, (SetFn)&CEntity::JSI_SetPlayer );
 	AddClassProperty( L"traits.health.curr", &CEntity::m_healthCurr );
 	AddClassProperty( L"traits.health.max", &CEntity::m_healthMax );
 	AddClassProperty( L"traits.health.regenRate", &CEntity::m_healthRegenRate );
 	AddClassProperty( L"traits.health.regenStart", &CEntity::m_healthRegenStart );
 	AddClassProperty( L"traits.health.decayRate", &CEntity::m_healthDecayRate );
 	AddClassProperty( L"traits.stamina.curr", &CEntity::m_staminaCurr );
 	AddClassProperty( L"traits.stamina.max", &CEntity::m_staminaMax );
 	AddClassProperty( L"traits.rank.name", &CEntity::m_rankName );
 	AddClassProperty( L"traits.vision.los", &CEntity::m_los );
 	AddClassProperty( L"traits.ai.stance.curr", &CEntity::m_stanceName, false, (NotifyFn)&CEntity::stanceChanged );
 	AddClassProperty( L"lastCombatTime", &CEntity::m_lastCombatTime );
 	AddClassProperty( L"lastRunTime", &CEntity::m_lastRunTime );
 	AddClassProperty( L"building", &CEntity::m_building );
 	AddClassProperty( L"visible", &CEntity::m_visible );
 	AddClassProperty( L"productionQueue", &CEntity::m_productionQueue );
 
 	CJSComplex<CEntity>::ScriptingInit( "Entity", Construct, 2 );
 }
 
 // Script constructor
 
 JSBool CEntity::Construct( JSContext* cx, JSObject* UNUSED(obj), uint argc, jsval* argv, jsval* rval )
 {
 	debug_assert( argc >= 2 );
 
 	CVector3D position;
 	float orientation = (float)( PI * ( (double)( rand() & 0x7fff ) / (double)0x4000 ) );
 
 	JSObject* jsEntityTemplate = JSVAL_TO_OBJECT( argv[0] );
 	CStrW templateName;
 
 	CPlayer* player = g_Game->GetPlayer( 0 );
 
 	CEntityTemplate* baseEntity = NULL;
 	if( JSVAL_IS_OBJECT( argv[0] ) ) // only set baseEntity if jsEntityTemplate is a valid object
 		baseEntity = ToNative<CEntityTemplate>( cx, jsEntityTemplate );
 
 	if( !baseEntity )
 	{
 		try
 		{
 			templateName = g_ScriptingHost.ValueToUCString( argv[0] );
 		}
 		catch( PSERROR_Scripting_ConversionFailed )
 		{
 			*rval = JSVAL_NULL;
 			JS_ReportError( cx, "Invalid template identifier" );
 			return( JS_TRUE );
 		}
 		baseEntity = g_EntityTemplateCollection.getTemplate( templateName );
 	}
 
 	if( !baseEntity )
 	{
 		*rval = JSVAL_NULL;
 		JS_ReportError( cx, "No such template: %s", CStr8(templateName).c_str() );
 		return( JS_TRUE );
 	}
 
 	JSI_Vector3D::Vector3D_Info* jsVector3D = NULL;
 	if( JSVAL_IS_OBJECT( argv[1] ) )
 		jsVector3D = (JSI_Vector3D::Vector3D_Info*)JS_GetInstancePrivate( cx, JSVAL_TO_OBJECT( argv[1] ), &JSI_Vector3D::JSI_class, NULL );
 
 	if( jsVector3D )
 	{
 		position = *( jsVector3D->vector );
 	}
 
 	if( argc >= 3 )
 	{
 		try
 		{
 			orientation = ToPrimitive<float>( argv[2] );
 		}
 		catch( PSERROR_Scripting_ConversionFailed )
 		{
 			// TODO: Net-safe random for this parameter.
 			orientation = 0.0f;
 		}
 	}
 
 	if( argc >= 4 )
 	{
 		try
 		{
 			player = ToPrimitive<CPlayer*>( argv[3] );
 		}
 		catch( PSERROR_Scripting_ConversionFailed )
 		{
 			player = g_Game->GetPlayer( 0 );
 		}
 	}
 
 	std::set<CStr8> selections; // TODO: let scripts specify selections?
 	HEntity handle = g_EntityManager.create( baseEntity, position, orientation, selections );
 	handle->m_actor->SetPlayerID( player->GetPlayerID() );
 	handle->Initialize();
 
 	*rval = ToJSVal<CEntity>( *handle );
 	return( JS_TRUE );
 }
 
 // Script-bound methods
 
 jsval CEntity::ToString( JSContext* cx, uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	wchar_t buffer[256];
 	swprintf( buffer, 256, L"[object Entity: %ls]", m_base->m_Tag.c_str() );
 	buffer[255] = 0;
 	utf16string str16(buffer, buffer+wcslen(buffer));
 	return( STRING_TO_JSVAL( JS_NewUCStringCopyZ( cx, str16.c_str() ) ) );
 }
 
 jsval CEntity::JSI_GetPlayer()
 {
 	return ToJSVal<CPlayer>( m_player );
 }
 
 void CEntity::JSI_SetPlayer( jsval val )
 {
 	CPlayer* newPlayer = 0;
 
 	try 
 	{
 		newPlayer = ToPrimitive<CPlayer*>( val );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( g_ScriptingHost.getContext(), "Invalid value given to entity.player - should be a Player object." );
 		return;
 	}
 
 	// Cancel all production to refund the old player
 	m_productionQueue->CancelAll();
 
 	// Exit all our auras so we can re-enter them as the new player
 	for( AuraSet::iterator it = m_aurasInfluencingMe.begin(); it != m_aurasInfluencingMe.end(); it++ )
 	{
 		(*it)->Remove( this );
 	}
 	
 	if( m_actor )
 		m_actor->SetPlayerID( newPlayer->GetPlayerID() ); // calls this->SetPlayer
 	else
 		SetPlayer(newPlayer);
 }
 
 bool CEntity::Order( JSContext* cx, uintN argc, jsval* argv, bool Queued )
 {
 	// This needs to be sorted (uses Scheduler rather than network messaging)
 
 	int orderCode;
 	debug_assert(argc >= 1);
 	try
 	{
 		orderCode = ToPrimitive<int>( argv[0] );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid order type" );
 		return( false );
 	}
 
 	CEntityOrder newOrder;
 	newOrder.m_source = CEntityOrder::SOURCE_PLAYER;
 	CEntity* target;
 
 	(int&)newOrder.m_type = orderCode;
 
 	switch( orderCode )
 	{
 		case CEntityOrder::ORDER_GOTO:
 		case CEntityOrder::ORDER_RUN:
 		case CEntityOrder::ORDER_PATROL:
 			JSU_REQUIRE_PARAMS_CPP(3);
 			try
 			{
 				newOrder.m_data[0].location.x = ToPrimitive<float>( argv[1] );
 				newOrder.m_data[0].location.y = ToPrimitive<float>( argv[2] );
 			}
 			catch( PSERROR_Scripting_ConversionFailed )
 			{
 				JS_ReportError( cx, "Invalid location" );
 				return( false );
 			}
 			if ( orderCode == CEntityOrder::ORDER_RUN )
 				entf_set(ENTF_TRIGGER_RUN);
 			//It's not a notification order
 			if ( argc == 3 )
 			{
 				if ( entf_get(ENTF_DESTROY_NOTIFIERS) )
 				{
 					m_currentRequest=0;
 					DestroyAllNotifiers();
 				}
 			}
 			break;
 		case CEntityOrder::ORDER_GENERIC:
 			JSU_REQUIRE_PARAMS_CPP(3);
 			target = ToNative<CEntity>( argv[1] );
 			if( !target )
 			{
 				JS_ReportError( cx, "Invalid target" );
 				return( false );
 			}
 			newOrder.m_data[0].entity = target->me;
 			try
 			{
 				newOrder.m_data[1].data = ToPrimitive<int>( argv[2] );
 			}
 			catch( PSERROR_Scripting_ConversionFailed )
 			{
 				JS_ReportError( cx, "Invalid generic order type" );
 				return( false );
 			}
 			//It's not a notification order
 			if ( argc == 3 )
 			{
 				if ( entf_get(ENTF_DESTROY_NOTIFIERS) )
 				{
 					m_currentRequest=0;
 					DestroyAllNotifiers();
 				}
 			}
 			break;
 		case CEntityOrder::ORDER_PRODUCE:
 			JSU_REQUIRE_PARAMS_CPP(3);
 			try {
 				newOrder.m_data[0].string = ToPrimitive<CStrW>(argv[2]);
 				newOrder.m_data[1].data = ToPrimitive<int>(argv[1]);
 			}
 			catch( PSERROR_Scripting_ConversionFailed )
 			{
 				JS_ReportError( cx, "Invalid parameter types" );
 				return( false );
 			}
 			break;
 		default:
 			JS_ReportError( cx, "Invalid order type" );
 			return( false );
 	}
 
 	if( !Queued )
 		clearOrders();
 	pushOrder( newOrder );
 
 	return( true );
 }
 
 bool CEntity::Kill( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	CEventDeath evt;
 	DispatchEvent( &evt );
 
 	for( AuraTable::iterator it = m_auras.begin(); it != m_auras.end(); it++ )
 	{
 		it->second->RemoveAll();
 		delete it->second;
 	}
 	m_auras.clear();
 
 	for( AuraSet::iterator it = m_aurasInfluencingMe.begin(); it != m_aurasInfluencingMe.end(); it++ )
 	{
 		(*it)->Remove( this );
 	}
 	m_aurasInfluencingMe.clear();
 
 	if( m_bounds )
 	{
 		delete( m_bounds );
 		m_bounds = NULL;
 	}
 
 	if( m_extant )
 	{
 		m_extant = false;
 	}
 
 	updateCollisionPatch();
 
 	g_Selection.removeAll( me );
 
 	clearOrders();
 
 	g_EntityManager.SetDeath(true);
 
 	if( m_actor && m_actor->GetRandomAnimation( "death" ) != m_actor->GetRandomAnimation( "idle" ) )
 	{
 		// Prevent "wiggling" as we try to interpolate between here and our death position (if we were moving)
 		m_graphics_position = m_position;
 		m_position_previous = m_position;
 		m_graphics_orientation = m_orientation;
 		m_orientation_previous = m_orientation;
 		updateActorTransforms();
 
 		// Play death animation and keep the actor in the game in a dead state 
 		// (TODO: remove the actor after some time through some kind of fading mechanism)
 		m_actor->SetEntitySelection( "death" );
 		m_actor->SetRandomAnimation( "death", true );
 	}
 	else
 	{
 		g_UnitMan.RemoveUnit( m_actor );
 		delete( m_actor );
 		m_actor = NULL;
 	}
 
 	return( true );
 }
 
 jsval CEntity::GetSpawnPoint( JSContext* UNUSED(cx), uintN argc, jsval* argv )
 {
 	float spawn_clearance = 2.0f;
 	if( argc >= 1 )
 	{
 		CEntityTemplate* be = ToNative<CEntityTemplate>( argv[0] );
 		if( be )
 		{
 			switch( be->m_bound_type )
 			{
 				case CBoundingObject::BOUND_CIRCLE:
 				spawn_clearance = be->m_bound_circle->m_radius;
 				break;
 				case CBoundingObject::BOUND_OABB:
 				spawn_clearance = be->m_bound_box->m_radius;
 				break;
 				default:
 				debug_warn("No bounding information for spawned object!" );
 			}
 		}
 		else
 			spawn_clearance = ToPrimitive<float>( argv[0] );
 	}
 	else
 		debug_warn("No arguments to Entity::GetSpawnPoint()" );
 
 	// TODO: Make netsafe.
 	CBoundingCircle spawn( 0.0f, 0.0f, spawn_clearance, 0.0f );
 
 	if( m_bounds->m_type == CBoundingObject::BOUND_OABB )
 	{
 		CBoundingBox* oabb = (CBoundingBox*)m_bounds;
 
 		// Pick a start point
 
 		int edge = rand() & 3;
 		int point;
 
 		double max_w = oabb->m_w + spawn_clearance + 1.0;
 		double max_d = oabb->m_d + spawn_clearance + 1.0;
 		int w_count = (int)( max_w * 2 );
 		int d_count = (int)( max_d * 2 );
 
 		CVector2D w_step = oabb->m_v * (float)( max_w / w_count );
 		CVector2D d_step = oabb->m_u * (float)( max_d / d_count );
 		CVector2D pos( m_position );
 		if( edge & 1 )
 		{
 			point = rand() % ( 2 * d_count ) - d_count;
 			pos += ( oabb->m_v * (float)max_w + d_step * (float)point ) * ( ( edge & 2 ) ? -1.0f : 1.0f );
 		}
 		else
 		{
 			point = rand() % ( 2 * w_count ) - w_count;
 			pos += ( oabb->m_u * (float)max_d + w_step * (float)point ) * ( ( edge & 2 ) ? -1.0f : 1.0f );
 		}
 
 		int start_edge = edge;
 		int start_point = point;
 
 		spawn.m_pos = pos;
 
 		// Then step around the edge (clockwise) until a free space is found, or
 		// we've gone all the way around.
 		while( getCollisionObject( &spawn ) )
 		{
 			switch( edge )
 			{
 				case 0:
 				point++;
 				pos += w_step;
 				if( point >= w_count )
 				{
 					edge = 1;
 					point = -d_count;
 				}
 				break;
 				case 1:
 				point++;
 				pos -= d_step;
 				if( point >= d_count )
 				{
 					edge = 2;
 					point = w_count;
 				}
 				break;
 				case 2:
 				point--;
 				pos -= w_step;
 				if( point <= -w_count )
 				{
 					edge = 3;
 					point = d_count;
 				}
 				break;
 				case 3:
 				point--;
 				pos += d_step;
 				if( point <= -d_count )
 				{
 					edge = 0;
 					point = -w_count;
 				}
 				break;
 			}
 			if( ( point == start_point ) && ( edge == start_edge ) )
 				return( JSVAL_NULL );
 			spawn.m_pos = pos;
 		}
 		CVector3D rval( pos.x, getAnchorLevel( pos.x, pos.y ), pos.y );
 		return( ToJSVal( rval ) );
 	}
 	else if( m_bounds->m_type == CBoundingObject::BOUND_CIRCLE )
 	{
 		float ang;
 		ang = (float)( rand() & 0x7fff ) / (float)0x4000; /* 0...2 */
 		ang *= PI;
 		float radius = m_bounds->m_radius + 1.0f + spawn_clearance;
 		float d_ang = spawn_clearance / ( 2.0f * radius );
 		float ang_end = ang + 2.0f * PI;
 		float x = 0.0f, y = 0.0f; // make sure they're initialized
 		for( ; ang < ang_end; ang += d_ang )
 		{
 			x = m_position.X + radius * cos( ang );
 			y = m_position.Z + radius * sin( ang );
 			spawn.setPosition( x, y );
 			if( !getCollisionObject( &spawn ) )
 				break;
 		}
 		if( ang < ang_end )
 		{
 			// Found a satisfactory position...
 			CVector3D pos( x, 0, y );
 			pos.Y = getAnchorLevel( x, y );
 			return( ToJSVal( pos ) );
 		}
 		else
 			return( JSVAL_NULL );
 	}
 	return( JSVAL_NULL );
 }
 
 jsval CEntity::AddAura( JSContext* cx, uintN argc, jsval* argv )
 {
 	debug_assert( argc >= 8 );
 	debug_assert( JSVAL_IS_OBJECT(argv[7]) );
 
 	CStrW name = ToPrimitive<CStrW>( argv[0] );
 	float radius = ToPrimitive<float>( argv[1] );
 	size_t tickRate = std::max( 0, ToPrimitive<int>( argv[2] ) );	// since it's a size_t we don't want it to be negative
 	float r = ToPrimitive<float>( argv[3] );
 	float g = ToPrimitive<float>( argv[4] );
 	float b = ToPrimitive<float>( argv[5] );
 	float a = ToPrimitive<float>( argv[6] );
 	CVector4D color(r, g, b, a);
 	JSObject* handler = JSVAL_TO_OBJECT( argv[7] );
 
 	if( m_auras[name] )
 	{
 		delete m_auras[name];
 	}
 	m_auras[name] = new CAura( cx, this, name, radius, tickRate, color, handler );
 
 	initAuraData();
 
 	return JSVAL_VOID;
 }
 
 jsval CEntity::RemoveAura( JSContext* UNUSED(cx), uintN argc, jsval* argv )
 {
 	debug_assert( argc >= 1 );
 	CStrW name = ToPrimitive<CStrW>( argv[0] );
 	if( m_auras[name] )
 	{
 		delete m_auras[name];
 		m_auras.erase(name);
 	}
 
 	initAuraData();
 
 	return JSVAL_VOID;
 }
 
 jsval CEntity::SetActionParams( JSContext* UNUSED(cx), uintN argc, jsval* argv )
 {
 	debug_assert( argc == 5 );
 
 	int id = ToPrimitive<int>( argv[0] );
 	float minRange = ToPrimitive<int>( argv[1] );
 	float maxRange = ToPrimitive<int>( argv[2] );
 	uint speed = ToPrimitive<uint>( argv[3] );
 	CStr8 animation = ToPrimitive<CStr8>( argv[4] );
 
 	m_actions[id] = SEntityAction( id, minRange, maxRange, speed, animation );
 
 	return JSVAL_VOID;
 }
 
 bool CEntity::RequestNotification( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(4);
 
 	CEntityListener notify;
 	CEntity *target = ToNative<CEntity>( argv[0] );
 	(int&)notify.m_type = ToPrimitive<int>( argv[1] );
 	bool tmpDestroyNotifiers = ToPrimitive<bool>( argv[2] );
 	entf_set_to(ENTF_DESTROY_NOTIFIERS, !ToPrimitive<bool>( argv[3] ));
 
 	if (target == this)
 		return false;
 
 	notify.m_sender = this;
 
 	//Clean up old requests
 	if ( tmpDestroyNotifiers )
 		DestroyAllNotifiers();
 	//If new request is not the same and we're destroy notifiers, reset
 	else if ( !(notify.m_type & m_currentRequest) && entf_get(ENTF_DESTROY_NOTIFIERS))
 		DestroyAllNotifiers();
 
 	m_currentRequest = notify.m_type;
 	m_notifiers.push_back( target );
 	int result = target->m_currentNotification & notify.m_type;
 
 	//If our target isn't stationary and it's doing something we want to follow, send notification
 	if ( result && !target->m_orderQueue.empty() )
 	{
 		CEntityOrder order = target->m_orderQueue.front();
 		switch( result )
 		{
 			 case CEntityListener::NOTIFY_GOTO:
 			 case CEntityListener::NOTIFY_RUN:
 				DispatchNotification( order, result );
 				break;
 
 			 case CEntityListener::NOTIFY_HEAL:
 			 case CEntityListener::NOTIFY_ATTACK:
 			 case CEntityListener::NOTIFY_GATHER:
 			 case CEntityListener::NOTIFY_DAMAGE:
 				 DispatchNotification( order, result );
 				 break;
 			 default:
 				 JS_ReportError( cx, "Invalid order type" );
 				 break;
 		}
 		target->m_listeners.push_back( notify );
 		return true;
 	}
 
 	target->m_listeners.push_back( notify );
 	return false;
 }
 int CEntity::GetCurrentRequest( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return m_currentRequest;
 }
 bool CEntity::ForceCheckListeners( JSContext *cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(2);
 	int type = ToPrimitive<int>( argv[0] );	   //notify code
 	m_currentNotification = type;
 
 	CEntity *target = ToNative<CEntity>( argv[1] );
 	if ( target->m_orderQueue.empty() )
 		return false;
 
 	CEntityOrder order = target->m_orderQueue.front();
 	for (size_t i=0; i<m_listeners.size(); i++)
 	{
 		int result = m_listeners[i].m_type & type;
 		if ( result )
 		{
 			 switch( result )
 			 {
 				 case CEntityListener::NOTIFY_GOTO:
 				 case CEntityListener::NOTIFY_RUN:
 				 case CEntityListener::NOTIFY_HEAL:
 				 case CEntityListener::NOTIFY_ATTACK:
 				 case CEntityListener::NOTIFY_GATHER:
 				 case CEntityListener::NOTIFY_DAMAGE:
 				 case CEntityListener::NOTIFY_IDLE:	//target should be 'this'
 					m_listeners[i].m_sender->DispatchNotification( order, result );
 					break;
 
 				default:
 					JS_ReportError( cx, "Invalid order type" );
 					break;
 			 }
 		 }
 	}
 	return true;
 }
 void CEntity::CheckListeners( int type, CEntity *target)
 {
 	m_currentNotification = type;
 
 	debug_assert(target);
 	if ( target->m_orderQueue.empty() )
 		return;
 
 	CEntityOrder order = target->m_orderQueue.front();
 	for (size_t i=0; i<m_listeners.size(); i++)
 	{
 		int result = m_listeners[i].m_type & type;
 		if ( result )
 		{
 			 switch( result )
 			 {
 				 case CEntityListener::NOTIFY_GOTO:
 				 case CEntityListener::NOTIFY_RUN:
 				 case CEntityListener::NOTIFY_HEAL:
 				 case CEntityListener::NOTIFY_ATTACK:
 				 case CEntityListener::NOTIFY_GATHER:
 				 case CEntityListener::NOTIFY_DAMAGE:
 					 m_listeners[i].m_sender->DispatchNotification( order, result );
 					 break;
 				 default:
 					debug_warn("Invalid notification: CheckListeners()");
 					continue;
 			 }
 		}
 	}
 }
 jsval CEntity::DestroyAllNotifiers( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	DestroyAllNotifiers();
 	return JS_TRUE;
 }
 jsval CEntity::DestroyNotifier( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(1);
 	DestroyNotifier( ToNative<CEntity>( argv[0] ) );
 	return JS_TRUE;
 }
 
 jsval CEntity::TriggerRun( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	entf_set(ENTF_TRIGGER_RUN);
 	return JSVAL_VOID;
 }
 
 jsval CEntity::SetRun( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(1);
 	bool should_run = ToPrimitive<bool> ( argv[0] );
 	entf_set_to(ENTF_SHOULD_RUN, should_run);
 	entf_set_to(ENTF_IS_RUNNING, should_run);
 	return JSVAL_VOID;
 }
 jsval CEntity::GetRunState( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return BOOLEAN_TO_JSVAL( entf_get(ENTF_SHOULD_RUN) );
 }
 jsval CEntity::GetFormationPenalty( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetPenalty() );
 }
 jsval CEntity::GetFormationPenaltyBase( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetPenaltyBase() );
 }
 jsval CEntity::GetFormationPenaltyType( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetPenaltyType() );
 }
 jsval CEntity::GetFormationPenaltyVal( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetPenaltyVal() );
 }
 jsval CEntity::GetFormationBonus( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetBonus() );
 }
 jsval CEntity::GetFormationBonusBase( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetBonusBase() );
 }
 jsval CEntity::GetFormationBonusType( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetBonusType() );
 }
 jsval CEntity::GetFormationBonusVal( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( GetFormation()->GetBase()->GetBonusVal() );
 }
 
 jsval CEntity::RegisterDamage( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(1);
 	CEntity* inflictor = ToNative<CEntity>( argv[0] );
 	CVector2D up(1.0f, 0.0f);
 	CVector2D pos = CVector2D( inflictor->m_position.X, inflictor->m_position.Z );
 	CVector2D posDelta = (pos - m_position).normalize();
 
 	float angle = acosf( up.dot(posDelta) );
 	//Find what section it is between and "activate" it
 	int sector = findSector(m_base->m_sectorDivs, angle, DEGTORAD(360.0f))-1;
 	m_sectorValues[sector]=true;
 	return JS_TRUE;
 }
 jsval CEntity::RegisterOrderChange( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(1);
 	CEntity* idleEntity = ToNative<CEntity>( argv[0] );
 
 	CVector2D up(1.0f, 0.0f);
 	CVector2D pos = CVector2D( idleEntity->m_position.X, idleEntity->m_position.Z );
 	CVector2D posDelta = (pos - m_position).normalize();
 
 	float angle = acosf( up.dot(posDelta) );
 	//Find what section it is between and "deactivate" it
 	int sector = std::max(0, findSector(m_base->m_sectorDivs, angle, DEGTORAD(360.0f)));
 	m_sectorValues[sector]=false;
 	return JS_TRUE;
 }
 jsval CEntity::GetAttackDirections( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	int directions=0;
 
 	for ( std::vector<bool>::iterator it=m_sectorValues.begin(); it != m_sectorValues.end(); it++ )
 	{
 		if ( *it )
 			++directions;
 	}
 	return ToJSVal( directions );
 }
 jsval CEntity::FindSector( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(4);
 
 	try
 	{
 		int divs = ToPrimitive<int>( argv[0] );
 		float angle = ToPrimitive<float>( argv[1] );
 		float maxAngle = ToPrimitive<float>( argv[2] );
 		bool negative = ToPrimitive<bool>( argv[3] );
 
 		return ToJSVal( findSector(divs, angle, maxAngle, negative) );
 	}
 	catch( PSERROR_Scripting_ConversionFailed )
 	{
 		JS_ReportError( cx, "Invalid parameters for findSector" );
 		return 0;
 	}
 }
 jsval CEntity::HasRallyPoint( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( entf_get(ENTF_HAS_RALLY_POINT) );
 }
 jsval CEntity::GetRallyPoint( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	return ToJSVal( m_rallyPoint );
 }
 jsval CEntity::SetRallyPoint( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	entf_set(ENTF_HAS_RALLY_POINT);
 	m_rallyPoint = g_Game->GetView()->GetCamera()->GetWorldCoordinates(true);
 	return JS_TRUE;
 }
 
 // Called by the script when the entity is damaged, to let it retaliate
 jsval CEntity::OnDamaged( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(1);
 	CEntity* damageSource = ToNative<CEntity>( argv[0] );
 	m_stance->onDamaged( damageSource );
 	return JSVAL_VOID;
 }
 
 jsval CEntity::GetVisibleEntities( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
 {
 	std::vector<CEntity*> pointers;
 	g_EntityManager.GetInLOS( this, pointers );
 	std::vector<HEntity> handles( pointers.size() );
 	for( size_t i=0; i<pointers.size(); i++ )
 		handles[i] = pointers[i]->me;
 	return OBJECT_TO_JSVAL( EntityCollection::Create( handles ) );
 }
 
 float CEntity::GetDistance( JSContext* cx, uintN argc, jsval* argv )
 {
 	JSU_REQUIRE_PARAMS_CPP(1);
 	CEntity* target = ToNative<CEntity>( argv[0] );
 	if( !target )
 		return -1.0f;
 	return this->distance2D( target );
 }
 
 /*
 
 Methods that provide an interface from C++ to JavaScript functions.
 
 */
 
 int CEntity::GetAttackAction( HEntity target )
 {
 	jsval attackFunc;
 	if( GetProperty( g_ScriptingHost.GetContext(), L"getAttackAction", &attackFunc ) )
 	{
 		jsval arg = ToJSVal( target );
 		jsval rval;
 		if( JS_CallFunctionValue( g_ScriptingHost.GetContext(), GetScript(), attackFunc, 1, &arg, &rval ) == JS_TRUE )
 		{
 			return ToPrimitive<int>( rval );
 		}
 	}
 
 	// Default return value is an invalid action ID
 	return 0;
 }
+
+jsval CEntity::FlattenTerrain( JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* UNUSED(argv) )
+{
+	float xDiff, yDiff;
+	CVector3D pos = m_position;
+	CVector2D pos2D(m_position.X, m_position.Z);
+
+	if ( m_bounds->m_type == CBoundingObject::BOUND_CIRCLE )
+		xDiff = yDiff = m_bounds->m_radius;
+	else
+	{
+		CBoundingBox* box = static_cast<CBoundingBox*>( m_bounds );
+		xDiff = box->m_w;
+		yDiff = box->m_d;
+	}
+	//If we ever need to take rotated bounding boxes into account...
+	//CVector2D points[4] = { CVector2D(xDiff, yDiff), CVector2D(-xDiff, -yDiff),
+		//CVector2D(-xDiff, yDiff), CVector2D(xDiff, yDiff) };
+	//CVector3D circle = points[0].FindCircumCircle(points[1], points[2]);
+	//float cos = cosf(m_graphics_orientation.Y), sin = sinf(m_graphics_orientation.Y);
+
+	//for ( size_t i = 0; i<4; ++i )
+	//{
+	//	points[i].x *= cos*circle.Z;
+	//	points[i].y *= sin*circle.Z;
+	//}
+	g_Game->GetWorld()->GetTerrain()->FlattenArea(pos.X-xDiff, pos.X+xDiff, pos.Z-yDiff, pos.Z+yDiff);
+	snapToGround();
+	return JS_TRUE;
+}
\ No newline at end of file
Index: ps/trunk/source/main.cpp
===================================================================
--- ps/trunk/source/main.cpp	(revision 4647)
+++ ps/trunk/source/main.cpp	(revision 4648)
@@ -1,393 +1,398 @@
 /*
 
 This module drives the game when running without Atlas (our integrated
 map editor). It receives input and OS messages via SDL and feeds them
 into the input dispatcher, where they are passed on to the game GUI and
 simulation.
 It also contains main(), which either runs the above controller or
 that of Atlas depending on commandline parameters.
 
 */
 
 // not for any PCH effort, but instead for the (common) definitions
 // included there.
 #include "lib/precompiled.h"
 
 #include "lib/input.h"
 #include "lib/sdl.h"
 #include "lib/timer.h"
 #include "lib/res/file/vfs.h"
 #include "lib/res/sound/snd_mgr.h"
 #include "lib/res/file/vfs_optimizer.h"
 
 #include "ps/GameSetup/GameSetup.h"
 #include "ps/GameSetup/Atlas.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/Loader.h"
 #include "ps/CConsole.h"
 #include "ps/Profile.h"
 #include "ps/Util.h"
 #include "ps/Game.h"
 #include "ps/Hotkey.h"
 #include "ps/Globals.h"
 #include "ps/Interact.h"
 #include "network/SessionManager.h"
+#include "simulation/TriggerManager.h"
 #include "graphics/GameView.h"
 #include "simulation/Scheduler.h"
 #include "sound/CMusicPlayer.h"
 #include "gui/GUI.h"
 
 #if OS_WIN
 # include "lib/sysdep/win/win.h"
 #endif
 
 #define LOG_CATEGORY "main"
 
 extern bool g_TerrainModified;
 extern bool g_GameRestarted;
 
 void kill_mainloop();
 
 
 // main app message handler
 static InReaction MainInputHandler(const SDL_Event_* ev)
 {
 	switch(ev->ev.type)
 	{
 	case SDL_QUIT:
 		kill_mainloop();
 		break;
 
 	case SDL_HOTKEYDOWN:
 		switch(ev->ev.user.code)
 		{
 		case HOTKEY_EXIT:
 			kill_mainloop();
 			return IN_HANDLED;
 
 		case HOTKEY_SCREENSHOT:
 			WriteScreenshot("png");
 			return IN_HANDLED;
 
 		case HOTKEY_BIGSCREENSHOT:
 			WriteBigScreenshot("bmp", 10);
 			return IN_HANDLED;
 
 		default:
 			break;
 		}
 		break;
 	}
 
 	return IN_PASS;
 }
 
 
 // dispatch all pending events to the various receivers.
 static void PumpEvents()
 {
 	in_dispatch_recorded_events();
 
 	SDL_Event_ ev;
 	while(SDL_PollEvent(&ev.ev))
 		in_dispatch_event(&ev);
 }
 
 
 // return indication of whether archive is currently being built; this is
 // used to prevent reloading during that time (see call site).
 static bool ProgressiveBuildArchive()
 {
 	int ret = vfs_opt_auto_build("../logs/trace.txt", "mods/official/official%02d.zip", "mods/official/mini%02d.zip");
 	if(ret == INFO::ALL_COMPLETE)
 	{
 		// nothing to do; will return false below
 	}
 	else if(ret < 0)
 		DISPLAY_ERROR(L"Archive build failed");
 	else if(ret == INFO::OK)
 		g_GUI.SendEventToAll("archivebuildercomplete");
 	// in progress
 	else
 	{
 		int percent = (int)ret;
 		g_ScriptingHost.SetGlobal("g_ArchiveBuilderProgress", INT_TO_JSVAL(percent));
 		g_GUI.SendEventToAll("archivebuilderprogress");
 		return true;
 	}
 
 	return false;
 }
 
 
 static int ProgressiveLoad()
 {
 	wchar_t description[100];
 	int progress_percent;
 	LibError ret = LDR_ProgressiveLoad(10e-3, description, ARRAY_SIZE(description), &progress_percent);
 	switch(ret)
 	{
 		// no load active => no-op (skip code below)
 	case INFO::OK:
 		return 0;
 		// current task didn't complete. we only care about this insofar as the
 		// load process is therefore not yet finished.
 	case ERR::TIMED_OUT:
 		break;
 		// just finished loading
 	case INFO::ALL_COMPLETE:
 		g_Game->ReallyStartGame();
 		wcscpy_s(description, ARRAY_SIZE(description), L"Game is starting..");
 		// LDR_ProgressiveLoad returns L""; set to valid text to
 		// avoid problems in converting to JSString
 		break;
 		// error!
 	default:
 		CHECK_ERR(ret);
 		// can't do this above due to legit ERR::TIMED_OUT
 		break;
 	}
 
 	GUI_DisplayLoadProgress(progress_percent, description);
 	return 0;
 }
 
 
 CMusicPlayer music_player;
 
 static void Frame()
 {
 	MICROLOG(L"Frame");
 	oglCheck();
 
 	// get elapsed time
 	calc_fps();
 	// .. old method - "exact" but contains jumps
 #if 0
 	static double last_time;
 	const double time = get_time();
 	const float TimeSinceLastFrame = (float)(time-last_time);
 	last_time = time;
 	ONCE(return);	// first call: set last_time and return
 
 	// .. new method - filtered and more smooth, but errors may accumulate
 #else
 	const float TimeSinceLastFrame = spf;
 #endif
 	debug_assert(TimeSinceLastFrame >= 0.0f);
 
 	// decide if update/render is necessary
 	bool need_render, need_update;
 	if( g_app_minimized )
 	{
 		// TODO: eventually update ought to be re-enabled so the server host
 		// can Alt+Tab out without the match hanging. however, game updates
 		// are currently really slow and disabling them makes debugging nicer.
 		need_update = false;
 		need_render = false;
 
 		// inactive; relinquish CPU for a little while
 		// don't use SDL_WaitEvent: don't want the main loop to freeze until app focus is restored
 		SDL_Delay(10);
 	}
 	else if( !g_app_has_focus )
 	{
 		need_update = false;	// see above
 		need_render = true;
 
 		SDL_Delay(5);	// see above
 	}
 	else	// active
 	{
 		need_update = true;
 		need_render = true;
 	}
 	// TODO: throttling: limit update and render frequency to the minimum.
 	// this is mostly relevant for "inactive" state, so that other windows
 	// get enough CPU time, but it's always nice for power+thermal management.
 
 
 	PROFILE_START( "update music" );
 	music_player.update();
 	PROFILE_END( "update music" );
 
 	bool is_building_archive;	// must come before PROFILE_START's {
 	PROFILE_START("build archive");
 	MICROLOG(L"build archive");
 	is_building_archive = ProgressiveBuildArchive();
 	PROFILE_END( "build archive");
 
 	// this scans for changed files/directories and reloads them, thus
 	// allowing hotloading (changes are immediately assimilated in-game).
 	// must not be done during archive building because it changes the
 	// archive file each iteration, but keeps it locked; reloading
 	// would trigger a warning because the file can't be opened.
 	if(!is_building_archive)
 	{
 		PROFILE_START("reload changed files");
 		MICROLOG(L"reload changed files");
 		vfs_reload_changed_files(); 
 		PROFILE_END( "reload changed files");
 	}
 
 	PROFILE_START("progressive load");
 	MICROLOG(L"progressive load");
 	ProgressiveLoad();
 	PROFILE_END( "progressive load");
 
 	PROFILE_START("input");
 	MICROLOG(L"input");
 	PumpEvents();
 	g_SessionManager.Poll();
 	PROFILE_END("input");
 
 	oglCheck();
 
 	PROFILE_START("gui tick");
 	MICROLOG(L"gui tick");
 #ifndef NO_GUI
 	g_GUI.TickObjects();
 #endif
 	PROFILE_END("gui tick");
 
 	oglCheck();
 
 	PROFILE_START( "game logic" );
 	if (g_Game && g_Game->IsGameStarted() && need_update)
 	{
 		PROFILE_START( "simulation update" );
 		g_Game->Update(TimeSinceLastFrame);
 		PROFILE_END( "simulation update" );
 
 		if (!g_FixedFrameTiming)
 		{
 			PROFILE( "camera update" );
 			g_Game->GetView()->Update(float(TimeSinceLastFrame));
 		}
+		
+		PROFILE_START("trigger update");
+		g_TriggerManager.Update( (float)TimeSinceLastFrame );
+		PROFILE_END("trigger udpate");
 
 		PROFILE_START( "selection and interaction ui" );
 		// TODO Where does GameView end and other things begin?
 		g_Mouseover.update( TimeSinceLastFrame );
 		g_Selection.update();
 		g_BuildingPlacer.update( TimeSinceLastFrame );
 		PROFILE_END( "selection and interaction ui" );
 
 		PROFILE_START( "sound update" );
 		CCamera* camera = g_Game->GetView()->GetCamera();
 		CMatrix3D& orientation = camera->m_Orientation;
 
 		float* pos = &orientation._data[12];
 		float* dir = &orientation._data[8];
 		float* up  = &orientation._data[4];
 		if(snd_update(pos, dir, up) < 0)
 			debug_printf("snd_update failed\n");
 		PROFILE_END( "sound update" );
 	}
 	else
 	{
 		// CSimulation would do this with the proper turn length if we were in
 		// a game. This is basically just to keep script timers running.
 		uint ms_elapsed = (uint)(TimeSinceLastFrame*1000);
 		g_Scheduler.update(ms_elapsed);
 		if(snd_update(0, 0, 0) < 0)
 			debug_printf("snd_update (pos=0 version) failed\n");
 	}
 	PROFILE_END( "game logic" );
 
 	PROFILE_START( "update console" );
 	g_Console->Update(TimeSinceLastFrame);
 	PROFILE_END( "update console" );
 
 	PROFILE_START("render");
 	oglCheck();
 	if(need_render)
 	{
 		MICROLOG(L"render");
 		Render();
 		MICROLOG(L"finished render");
 		PROFILE_START( "swap buffers" );
 		SDL_GL_SwapBuffers();
 		PROFILE_END( "swap buffers" );
 	}
 	oglCheck();
 	PROFILE_END("render");
 
 	g_Profiler.Frame();
 
 	if(g_FixedFrameTiming && frameCount==100)
 		kill_mainloop();
 
 	g_TerrainModified = false;
 	g_GameRestarted = false;
 }
 
 
 static void MainControllerInit()
 {
 	// add additional input handlers only needed by this controller:
 
 	// gui_handler needs to be registered after (i.e. called before!) the
 	// hotkey handler so that input boxes can be typed in without
 	// setting off hotkeys.
 #ifndef NO_GUI
 	in_add_handler(gui_handler);
 #endif
 
 	// must be registered after gui_handler. Should mayhap even be last.
 	in_add_handler(MainInputHandler);
 }
 
 
 
 static void MainControllerShutdown()
 {
 	music_player.release();
 }
 
 
 static bool quit = false;	// break out of main loop
 
 // stop the main loop and trigger orderly shutdown. called from several
 // places: the event handler (SDL_QUIT and hotkey) and JS exitProgram.
 void kill_mainloop()
 {
 	quit = true;
 }
 
 
 #include "lib/res/file/trace.h"
 
 int main(int argc, char* argv[])
 {
 	// If you ever want to catch a particular allocation:
 	//_CrtSetBreakAlloc(7864);
 
 	// see discussion at declaration of win_pre_main_init.
 #if OS_WIN
 	win_pre_main_init();
 #endif
 
 	ATLAS_RunIfOnCmdLine(argc, argv);
 
 	Init(argc, argv, 0);
 	MainControllerInit();
 
 debug_filter_add("LOADER");
 
 //trace_gen_random(5000);
 //trace_write_to_file("../logs/trace.txt");
 
 #if 0
 trace_run("../logs/trace.txt");
 #else
 	while(!quit)
 		Frame();
 #endif
 
 	Shutdown(0);
 	MainControllerShutdown();
 
 	debug_printf("Shutdown complete, calling exit() now\n");
 	
 	exit(0);
 }
Index: ps/trunk/binaries/system/AtlasUI.dll
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Index: ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.pmp
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Index: ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.pmp
===================================================================
--- ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.pmp	(nonexistent)
+++ ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.pmp	(revision 4648)

Property changes on: ps/trunk/binaries/data/mods/official/maps/scenarios/triggerTest.pmp
___________________________________________________________________
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/official/scripts/entity_functions.js
===================================================================
--- ps/trunk/binaries/data/mods/official/scripts/entity_functions.js	(revision 4647)
+++ ps/trunk/binaries/data/mods/official/scripts/entity_functions.js	(revision 4648)
@@ -1,2189 +1,2196 @@
 /*
 	DESCRIPTION	: Functions that define the scripted behaviour of properties, particularly the effects of entity events and their properties when initialised.
 	NOTES		: 
 */
 
 // ====================================================================
 
 // To add a new generic order, do the following all within template_entity_script.js:
 
 //    * Pick a number to be its ID (add this to the "const"s directly below). f
 
 //    * Add code in the entityInit() function below that will call setActionParams to set the action's range, speed and animation if the entity supports this action. For example this.setActionParams( ACTION_GATHER, 0.0, a.range, a.speed, "gather" ) tells the entity that the action with ID of ACTION_GATHER has min range 0, max range a.range, speed a.speed, and should play the animation called "gather" while active. 
 
 //    * Add code in entityEventTargetChanged() to tell the GUI whether the entity should use this action depending on what target the mouse is hovering over. This is also where you can set a cursor for the action. 
 
 //    * Add code in entityEventGeneric() to deal with new generic order events of your type. Note that if you want to have your action handler in a separate function (is preferable), you need to also add this function to the entity object in entityInit() (its initialize event), e.g. this.processGather = entityEventGather. 
 
 const ACTION_NONE	= 0;
 const ACTION_ATTACK	= 1;
 const ACTION_GATHER	= 2;
 const ACTION_HEAL	= 3;
 const ACTION_ATTACK_RANGED = 4;
 const ACTION_BUILD = 5;
 const ACTION_REPAIR = 6;
 
 const PRODUCTION_TRAIN = 1;
 const PRODUCTION_RESEARCH = 2;
 
 
 // ====================================================================
 
 function entityInit( evt )
 {
 	// Initialise an entity when it is first spawned (generate starting hitpoints, etc).
 	
 	// This function is called for all "full" entities - those inheriting from template_entity_full; there is a simpler version below
 	// called entityInitQuasi for quasi-entities (rocks, trees, etc) for which most of the things dealt with here don't apply.
 
     startXTimer(1);
 
 	// If the entity is a foundation, we must deduct resource costs here
 	if( this.building )
 	{
 		var template = getEntityTemplate( this.building, this.player );
 		var result = checkEntityReqs( this.player, template );	
 
 		if (result == true) // If the entry meets requirements to be added to the queue (eg sufficient resources) 
 		{
 			// Cycle through all costs of this entry.
 			var pool = template.traits.creation.resource;
 			for ( resource in pool )
 			{
 				switch ( resource.toString() )
 				{
 					case "population":
 					case "housing":
 					break;
 					default:
 						// Deduct the given quantity of resources.
 						this.player.resources[resource.toString()] -= parseInt(pool[resource]);
 
 						//console.write ("Spent " + pool[resource] + " " + resource + " to build " + 
 						//	template.traits.id.generic);
 					break;
 				}
 			}
 		}
 		else
 		{
 			// Might happen if the player clicks to place 2 buildings really fast
 			evt.preventDefault();
 			stopXTimer(1);
 			return;
 		}
 	}
 	
 	stopXTimer(1);
 	startXTimer(2);
 	
 	// Attach our functions to ourselves
 	this.getAttackAction = getAttackAction;		// Note: required by CEntity
 	this.performAttack = performAttack;
 	this.performAttackRanged = performAttackRanged;
 	this.performGather = performGather;
 	this.performHeal = performHeal;
 	this.performBuild = performBuild;
 	this.performRepair = performRepair;
 	this.damage = damage;
 	this.entityComplete = entityComplete;
 	this.GotoInRange = GotoInRange;
 	this.attachAuras = attachAuras;
 	this.setupRank = setupRank;
 	this.chooseGatherTarget = chooseGatherTarget;
 	
 	// Some temp variables to speed up property access
 	var id = this.traits.id;
 	var supply = this.traits.supply;
 	var health = this.traits.health;
 	var stamina = this.traits.stamina;
 	
 	// If this is a foundation, initialize traits from the building we're converting into
 	if( this.building && this.building != "" )
 	{
 		var building = getEntityTemplate( this.building, this.player );
 		id.generic = building.traits.id.generic;
 		id.specific = building.traits.id.specific;
 		id.civ = building.traits.id.civ;
 		id.icon_cell = building.traits.id.icon_cell;
 		this.traits.health.max = building.traits.health.max;
 		this.buildPoints = new Object();
 		this.buildPoints.curr = 0.0;
 		this.buildPoints.max = parseFloat( building.traits.creation.time );
 	}
 	
 	// Generate civ code (1st four characters of civ name, in lower case eg "Carthaginians" => "cart").
 	if( !id.civ_code && id.civ )
 	{
 		var civ_code = id.civ.toString().substring (0, 4);
 		civ_code = civ_code.toString().toLowerCase();
 
 		// Exception to make the Romans into rome and Hellenes into hele.
 		if (civ_code == "roma") civ_code = "rome";
 		else if (civ_code == "hell") civ_code = "hele";
 		
 		id.civ_code = civ_code;
 	}
 
 	// If entity can contain garrisoned units, empty it.
 	if ( this.traits.garrison && this.traits.garrison.max )
 		this.traits.garrison.curr = 0;
 
 	// If entity has health, set current to same, unless it's a foundation, in which case we set it to 0.
 	if ( health && health.max  )
 		health.curr = ( this.building!="" ? 0.0 : health.max );
 
 	// If entity has stamina, set current to same.
 	if ( stamina && stamina.max )
 		stamina.curr = stamina.max
 
     stopXTimer(2);
     startXTimer(3);
 
 	if( supply )
 	{
 		// If entity has supply, set current to same.
 		supply.curr = supply.max;
 
 		// If entity has type of supply and no subType, set subType to same
 		// (so we don't have to say type="wood", subType="wood"
 		if (supply.type && !supply.subType)
 			supply.subType = supply.type;
 			
 		// The "dropsiteCount" array holds the number of units with gather aura in range of the object;
 		// this is important so that if you have two mills near something and one of them is destroyed,
 		// you can still gather from the thing. Initialize it to 0 (ungatherable) for every player unless
 		// the entity is forageable (e.g. for huntable animals).
 		var dropsiteCount = new Array();
 		initialCount = supply.subType.meat ? 1 : 0;
 		for( i=0; i<=8; i++ )
 		{
 			dropsiteCount[i] = initialCount;
 		}
 		supply.dropsiteCount = dropsiteCount;
 	}
 
 	if (!this.traits.promotion)
 		this.traits.promotion = new Object();
 		
 	// If entity becomes another entity after it gains enough experience points, set up secondary attributes.
 	if (this.traits.promotion.req)
 	{
 		this.setupRank();
 			
 		// Give the entity an initial value of 0 earned XP at startup if a default value is not specified.
 		if (!this.traits.promotion.curr)
 			this.traits.promotion.curr = 0;	
 	}
 	else
 	{
 		this.traits.promotion.rank = "0";
 	}
 	
 	stopXTimer(3);
 	startXTimer(4);
 	
 	// Register our actions with the generic order system
 	if( this.actions )
 	{
 		if ( this.actions.move && this.actions.move.speed )
 			this.actions.move.speedCurr = this.actions.move.speed;
 			
 		if( this.actions.attack && this.actions.attack.melee )
 		{
 			a = this.actions.attack.melee;
 			minRange = ( a.minRange ? a.minRange : 0.0 );
 			this.setActionParams( ACTION_ATTACK, minRange, a.range, a.speed, "melee" );
 		}
 		if( this.actions.gather )
 		{
 			a = this.actions.gather;
 			this.setActionParams( ACTION_GATHER, 0.0, a.range, a.speed, "gather" );
 		}
 		if( this.actions.heal )
 		{
 			a = this.actions.heal;
 			this.setActionParams( ACTION_HEAL, 0.0, a.range, a.speed, "heal" );
 		}
 		if( this.actions.attack && this.actions.attack.ranged )
 		{
 			a = this.actions.attack.ranged;
 			minRange = ( a.minRange ? a.minRange : 0.0 );
 			// this animation should actually be "ranged" except the current actors still have it called "melee"
 			this.setActionParams( ACTION_ATTACK_RANGED, minRange, a.range, a.speed, "melee" );
 		}
 		if( this.actions.build )
 		{
 			this.setActionParams( ACTION_BUILD, 0.0, 2.0, this.actions.build.speed, "build" );
 		}
 		if( this.actions.repair )
 		{
 			this.setActionParams( ACTION_REPAIR, 0.0, 2.0, this.actions.repair.speed, "build" );
 		}
 	}
 
     stopXTimer(4);
     startXTimer(5);
 
 	this.attachAuras();
 	
 	// If the entity either costs population or adds to it,
 	if (this.traits.population)
 	{
 		// If the entity increases the population limit (provides Housing),
 		if (this.traits.population.add)
 			this.player.resources.housing += parseInt(this.traits.population.add);
 		// If the entity takes up Housing,
 		if (this.traits.population.rem)
 			this.player.resources.population += parseInt(this.traits.population.rem);
 	}
 	
 	// Build Unit Ai Stance list, and set default stance.  ---> Can eventually be done in C++, since stances will likely be implemented in C++.
 	if (this.actions && this.actions.move)
 	{
 		if ( !this.traits.ai.stance.list )
 			this.traits.ai.stance.list = new Object();
 		// Create standard stances that all units have.
 		this.traits.ai.stance.list.avoid = new Object();
 		this.traits.ai.stance.list.hold = new Object();	
 		if ( this.actions && this.actions.attack )
 		{
 			// Create stances that units only have if they can attack.
 			this.traits.ai.stance.list.aggress = new Object();	
 			this.traits.ai.stance.list.defend = new Object();
 			this.traits.ai.stance.list.stand = new Object();
 			// Set default stance for combat units.
 			this.traits.ai.stance.curr = "aggress";
 		}
 	}
 	
 	// Set up allure counter
 	if (this.actions && this.actions.gather && this.actions.gather.affectedByAllure)
 	{
 		this.allureCount = 0;
 	}
 	
 	stopXTimer(5);
 /*	
 	// Generate entity's personal name (if it needs one).
 	if (this.traits.id.personal)
 	{
 		// todo
 
 		// Look in the appropriate array for a random string.
 
 		switch (this.traits.id.classes[])
 		{
 			case "Male":
 				this.traits.id.personal.table1 = "Male"
 			break;
 			case "Female":
 				this.traits.id.personal.table1 = "Female"
 			break;
 			default:
 				this.traits.id.personal.table1 = "Gen"
 			break;	
 		}
 		
 		
 		this.traits.id.personal.name = getRandom (this.traits.id.civ_code + this.traits.id.personal.table1 + "1")
 		this.traits.id.personal.name = this.traits.id.personal.name + " " + getRandom (this.traits.id.civ_code + this.traits.id.personal.table1 + "2")
 	}
 	else
 		this.traits.id.personal.name = "";
 */
 	// Log creation of entity to console.
 	//if (this.traits.id.personal && this.traits.id.personal.name)
 	//	console.write ("A new " + this.traits.id.specific + " (" + this.traits.id.generic + ") called " + this.traits.id.personal.name + " has entered your dungeon.")
 	//else	
 	//	console.write ("A new " + this.traits.id.specific + " (" + this.traits.id.generic + ") has entered your dungeon.")
 }
 
 // ====================================================================
 
 function entityInitQuasi()
 {
 	// Initialization function for quasi-entities like trees, rocks, etc; only sets up resources
 
     startXTimer(6);
 
 	var supply = this.traits.supply;
 	if( supply )
 	{
 		// If entity has supply, set current to same.
 		supply.curr = supply.max;
 
 		// If entity has type of supply and no subType, set subType to same
 		// (so we don't have to say type="wood", subType="wood"
 		if (supply.type && !supply.subType)
 			supply.subType = supply.type;
 			
 		// The "dropsiteCount" array holds the number of units with gather aura in range of the object;
 		// this is important so that if you have two mills near something and one of them is destroyed,
 		// you can still gather from the thing. Initialize it to 0 (ungatherable) for every player unless
 		// the entity is forageable (e.g. for huntable animals).
 		var dropsiteCount = new Array();
 		initialCount = supply.subType.meat ? 1 : 0;
 		for( i=0; i<=8; i++ )
 		{
 			dropsiteCount[i] = initialCount;
 		}
 		supply.dropsiteCount = dropsiteCount;
 	}
 	
 	stopXTimer(6);
 	startXTimer(7);
 	
 	// Generate civ code (1st four characters of civ name, in lower case eg "Carthaginians" => "cart").
 	var id = this.traits.id;
 	if( !id.civ_code && id.civ )
 	{
 		var civ_code = id.civ.toString().substring (0, 4);
 		civ_code = civ_code.toString().toLowerCase();
 
 		// Exception to make the Romans into rome and Hellenes into hele.
 		if (civ_code == "roma") civ_code = "rome";
 		else if (civ_code == "hell") civ_code = "hele";
 		
 		id.civ_code = civ_code;
 	}
 	
 	/*
 	// Original unoptimized version of the above code (for reference)
 	if( this.traits.id && this.traits.id.civ )
 	{
 		var id = this.traits.id; 
 		id.civ_code = id.civ.toString().substring (0, 4);
 		id.civ_code = id.civ_code.toString().toLowerCase();
 
 		// Exception to make the Romans into rome.
 		if (id.civ_code == "roma") id.civ_code = "rome";
 		// Exception to make the Hellenes into hele.
 		if (id.civ_code == "hell") id.civ_code = "hele";
 	}
 	*/
 	
 	stopXTimer(7);
 	
 	/*
 	
 	// Profiling code for comparing performance of pure JavaScript objects vs. CJSComplex.
 	// This should be removed when we're done optimizing entity init.
 	
 	var ob = new Object();
 	ob.traits = new Object();
 	
 	for(var i=0; i<50; i++) {
 		ob["temp"+i] = "blah";
 	}
 	for(var i=0; i<50; i++) {
 		ob.traits["temp"+i] = "blah";
 	}
 	
 	ob.traits.id = new Object();
 	ob.traits.id.civ = "hellenes";
 	
 	startXTimer(9);
 	
 	// ~100 MS with ob = new Object() as above, ~400 MS with ob = this
 	if( ob.traits.id && ob.traits.id.civ )
 	{
 	    var id = ob.traits.id; 
 		id.civ_code = id.civ.toString().substring (0, 4);
 		id.civ_code = id.civ_code.toString().toLowerCase();
 
 		// Exception to make the Romans into rome.
 		if (id.civ_code == "roma") id.civ_code = "rome";
 		// Exception to make the Hellenes into hele.
 		if (id.civ_code == "hell") id.civ_code = "hele";
 	}
 	
 	stopXTimer(9);
 	
 	*/
 }
 
 // ====================================================================
 
 // Setup entity's next rank
 function setupRank()
 {
 	// Get the name of the entity. 
 	entityName = this.tag.toString();
 	
 	// For accessing the this.traits.promotion object quicker
 	var promotion = this.traits.promotion;
 
 	// Determine whether current is basic, advanced or elite, and set rank to suit.
 	switch (entityName.substring (entityName.length-2, entityName.length))
 	{
 		case "_b":
 			// Basic. Upgrades to Advanced.
 			promotion.rank = "1";
 			nextSuffix = "_a";
 			// Set rank image to put over entity's head.
 			this.traits.rank.name = "";
 		break;
 		case "_a":
 			// Advanced. Upgrades to Elite.
 			promotion.rank = "2";
 			nextSuffix = "_e";
 			// Set rank image to put over entity's head.
 			this.traits.rank.name = "advanced.dds";				
 		break;
 		case "_e":
 			// Elite. Maximum rank.
 			promotion.rank = "3";
 			nextSuffix = "";
 			// Set rank image to put over entity's head.
 			this.traits.rank.name = "elite.dds";				
 		break;
 		default:
 			// Does not gain promotions.
 			promotion.rank = "0"
 			nextSuffix = ""
 		break;
 	}
 
 	// If entity is an additional rank and the correct actor has not been specified
 	// (it's just inherited the Basic), point it to the correct suffix. (Saves us specifying it each time.)
 	actorStr = this.actor.toString();
 	if (promotion.rank > "1"
 		&& actorStr.substring (actorStr.length-5, actorStr.length) != nextSuffix + ".xml")
 		this.actor = actorStr.substring (1,actorStr.length-5) + nextSuffix + ".xml";
 		
 	// The entity it should become (unless specified otherwise) is the base entity plus promotion suffix.
 	if (!promotion.newentity && nextSuffix != "" && promotion.rank != "0")
 		promotion.newentity = entityName.substring (0, entityName.length-2) + nextSuffix;
 }
 
 // ====================================================================
 
 // Attach any auras the entity is entitled to. This was moved to a separate function so that buildings can have their auras 
 // attached to them only when they finish construction.
 function attachAuras() 
 {
 	// Add all auras defined in this.traits.auras
 	var t = this.traits.auras;
 	var a;
 	if( t )
 	{
 		if( t.courage )
 		{
 			a = t.courage;
 			this.addAura ( "courage", a.radius, 0, a.r, a.g, a.b, a.a, new DamageModifyAura( this, true, a.bonus ) );
 		}
 		if( t.fear )
 		{
 			a = t.fear;
 			this.addAura ( "fear", a.radius, 0, a.r, a.g, a.b, a.a, new DamageModifyAura( this, false, -a.bonus ) );
 		}
 		if( t.infidelity )
 		{
 			a = t.infidelity;
 			this.addAura ( "infidelity", a.radius, 0, a.r, a.g, a.b, a.a, new InfidelityAura( this, a.time ) );
 		}
 		if( t.dropsite )
 		{
 			a = t.dropsite;
 			this.addAura ( "dropsite", a.radius, 0, a.r, a.g, a.b, a.a, new DropsiteAura( this, a.types ) );
 		}
 		if( t.heal )
 		{
 			a = t.heal;
 			this.addAura ( "heal", a.radius, a.speed, a.r, a.g, a.b, a.a, new HealAura( this ) );
 		}
 		if( t.trample )
 		{
 			a = t.trample;
 			this.addAura ( "trample", a.radius, a.speed, a.r, a.g, a.b, a.a, new TrampleAura( this ) );
 		}
 		if( t.allure )
 		{
 			a = t.allure;
 			this.addAura ( "allure", a.radius, 0, a.r, a.g, a.b, a.a, new AllureAura( this ) );
 		}
 	}		
 	
 	// Settlements also get a special aura that will let them change player when a Civ Centre is built on top
 	if( this.hasClass("Settlement") )
 	{
 		this.addAura ( "settlement", 1.0, 0, 0.0, 0.0, 0.0, 0.0, new SettlementAura( this ) );
 	}
 }
 
 // ====================================================================
 
 function entityDestroyed( evt )
 {
 	// If the entity either costs population or adds to it,
 	if (this.traits.population)
 	{
 		// If the entity increases the population limit (provides Housing),
 		if (this.traits.population.add)
 			this.player.resources.housing -= parseInt(this.traits.population.add);
 		// If the entity occupies population slots (occupies Housing),
 		if (this.traits.population.rem)
 			this.player.resources.population -= parseInt(this.traits.population.rem);
 	}
 }
 
 // ====================================================================
 
 function foundationDestroyed( evt )
 {
 	if( this.building != "" )	// Check that we're *really* a foundation since the event handler is kept when we change templates (probably a bug)
 	{
 		//console.write( "Hari Seldon made a small calculation error." );
 		
 		var bp = this.buildPoints;
 		var fractionToReturn = (bp.max - bp.curr) / bp.max;
 		
 		var resources = getEntityTemplate( this.building, this.player ).traits.creation.resource;
 		for( r in resources )
 		{
 			amount = parseInt( fractionToReturn * parseInt(resources[r]) );
 			this.player.resources[r.toString()] += amount;
 		}
 	}
 }
 
 // ====================================================================
 
 function performAttack( evt )
 {
 	this.lastCombatTime = getGameTime();
 	
 	var curr_hit = getGUIGlobal().newRandomSound("voice", "hit", this.traits.audio.path);
 	curr_hit.play();
 
 	// Attack logic.
 	var dmg = new DamageType();
 	if ( this.getRunState() )
 	{
 		console.write("" + this + " doing a charge attack!");
 		var a = this.actions.attack.charge;
 		dmg.crush = a.damage * a.crush;
 		dmg.hack = a.damage * a.hack;
 		dmg.pierce = a.damage * a.pierce;
 		this.setRun( false );
 	}
 	else
 	{
 		var a = this.actions.attack.melee;
 		dmg.crush = a.damage * a.crush;
 		dmg.hack = a.damage * a.hack;
 		dmg.pierce = a.damage * a.pierce;
 	}
 	
 	// Add flank penalty
 	var bonus = 1.0;
 	if(evt.target.traits.flankPenalty)
 		bonus += (evt.target.getAttackDirections()-1) * evt.target.traits.flankPenalty.value;
 	bonus += getElevationBonus(this.getHeight() - evt.target.getHeight());
 	dmg.crush *= bonus;
 	dmg.hack *= bonus;
 	dmg.pierce *= bonus;
 
 	evt.target.damage( dmg, this );
 	
 }
 
 // ====================================================================
 
 function performAttackRanged( evt )
 {
 	this.lastCombatTime = getGameTime();
 
 	// Create a projectile from us, to the target, that will do some damage when it hits them.
 	dmg = new DamageType();
 	var a = this.actions.attack.ranged;
 	dmg.crush = a.damage * a.crush;
 	dmg.hack = a.damage * a.hack;
 	dmg.pierce = a.damage * a.pierce;
 	
 	// Add flank penalty and elevation bonus
 	var bonus = 1.0;
 	if(evt.target.traits.flankPenalty)
 		bonus += (evt.target.getAttackDirections()-1) * evt.target.traits.flankPenalty.value;
 	bonus += getElevationBonus(this.getHeight() - evt.target.getHeight());
 	dmg.crush *= bonus;
 	dmg.hack *= bonus;
 	dmg.pierce *= bonus;
 
 	// The parameters for Projectile are:	
 	// 1 - The actor to use as the projectile. There are two ways of specifying this:
 	//     the first is by giving an entity. The projectile's actor is found by looking
 	//     in the actor of that entity. This way is usual, and preferred - visual
 	//     information, like the projectile model, should be stored in the actor files.
 	//     The second way is to give a actor/file name string (e.g. "props/weapon/weap_
 	//     arrow_front.xml"). This is only meant to be used for 'Acts of Gaia' where
 	//     there is no originating entity. Right now, this entity is the one doing the
 	//     firing, so pass this.
 	// 2 - Where the projectile is coming from. This can be an entity or a Vector3D.
 	//     For now, that's also us.
 	// 3 - Where the projectile is going to. Again, either a vector (attack ground?) 
 	//     or an entity. Let's shoot at our target, lest we get people terribly confused.
 	// 4 - How fast the projectile should go. To keep things clear, we'll set it to 
 	//     just a bit faster than the average cavalry.
 	// 5 - Who fired it? Erm... yep, us again.
 	// 6 - The function you'd like to call when it hits an entity.
 	// There's also a seventh parameter, for a function to call when it misses (more
 	//  accurately, when it hits the floor). At the moment, however, the default
 	//  action (do nothing) is what we want.
 	// Parameters 5, 6, and 7 are all optional.
 	
 	projectile = new Projectile( this, this, evt.target, 
 		this.actions.attack.ranged.projectileSpeed, 
 		this, projectileEventImpact )
 	
 	// We'll attach the damage information to the projectile, just to show you can
 	// do that like you can with most other objects. Could also do this by making
 	// the function we pass a closure.
 	
 	projectile.damage = dmg;
 	
 	// Finally, tell the engine not to send this event to anywhere else - 
 	// in particular, this shouldn't get to the melee event handler, above.
 	
 	evt.stopPropagation();
 	
 	//console.write( "Fire!" );
 }
 
 // ====================================================================
 
 function projectileEventImpact( evt )
 {
 	//console.write( "Hit!" );
 	if(evt.impacted.damage)
 		evt.impacted.damage( this.damage, evt.originator );
 	
 	// Just so you know - there's no guarantee that evt.impacted is the thing you were
 	// aiming at. This function gets called when the projectile hits *anything*.
 	// For example:
 	
 	//if( evt.impacted.player == evt.originator.player )
 	//	console.write( "Friendly fire!" );
 		
 	// The three properties of the ProjectileImpact event are:
 	// - impacted, the thing it hit
 	// - originator, the thing that fired it (the fifth parameter of Projectile's
 	//   constructor) - may be null
 	// - position, the position the arrow was in the world when it hit.
 	
 	// The properties of the ProjectileMiss event (the one that gets sent to the
 	// handler that was the seventh parameter of the constructor) are similar,
 	// but it doesn't have 'impacted' - for obvious reasons.
 }
 
 // ====================================================================
 
 function performGather( evt )
 {
 	g = this.actions.gather;
 	s = evt.target.traits.supply;
 	
 	if( !s.dropsiteCount[this.player.id] )
 	{
 		// Entity has become ungatherable for us, probably meaning our mill near it was killed; cancel order
 		evt.preventDefault();
 		return;
 	}
 
 	var allureMod = 1;
 	if( g.affectedByAllure && this.allureCount > 0 )
 		allureMod = 1.2;
 	
 	if( g.resource[s.type][s.subType])
 		gather_amt = parseFloat( g.resource[s.type][s.subType] * allureMod );
 	else
 		gather_amt = parseFloat( g.resource[s.type] * allureMod );
 
 	if( s.max > 0 )
 	{
 		if( s.curr <= gather_amt )
 		{
 			gather_amt = s.curr.valueOf();
 		}
 		
 		// Remove amount from target.
 		s.curr -= gather_amt;
 		
 		// Add extracted resources to player's resource pool.
 		this.player.resources[s.type.toString()] += gather_amt;
 		
 		// Kill the target if it's now out of resources
 		if( s.curr == 0 )
 		{
 			evt.target.kill();
 		}
 	}
 }
 
 // ====================================================================
 
 function performHeal( evt )
 {
 	if ( this.player.getDiplomaticStance(evt.target.player) == DIPOLMACY_ENEMY )
 	{
 		//console.write( "You have a traitor!" );
 		return;
 	}
 
 	// Cycle through all resources.
 	pool = this.player.resources;
 	for( resource in pool )
 	{
 		switch( resource.toString() )
 		{
 			case "population" || "housing":
 			break;
 			default:
 				// Make sure we have enough resources.
 				if ( pool[resource] - evt.target.actions.heal.cost * evt.target.traits.creation.cost[resource] < 0 )
 				{
 					console.write( "Not enough " + resource.toString() + " for healing." );
 					return;
 				}
 			break;
 		}
 	}
 
 	evt.target.traits.health.curr += this.actions.heal.speed;
 	//console.write( this.traits.id.specific + " has performed a miracle!" );
 	
 	if (evt.target.traits.health.curr >= evt.target.traits.health.max)
 	{		
 		evt.target.traits.health.curr = evt.target.traits.health.max;
 	}
 
 	// Cycle through all resources.
 	pool = this.player.resources;
 	for( resource in pool )
 	{
 		switch( resource.toString() )
 		{
 			case "population":
 			case "housing":
 				break;
 			default:
 				// Deduct resources to pay for healing.
 				this.player.resources[resource.toString()] -= parseInt(evt.target.actions.heal.cost * evt.target.traits.creation.cost[resource]);
 				break;
 		}
 	}
 }
 
 // ====================================================================
 
 function performBuild( evt )
 {
 	if( !canBuild( this, evt.target ) )
 	{
 		evt.preventDefault();
 		return;
 	}
 	
 	var t = evt.target;
 	var b = this.actions.build;
 	var bp = t.buildPoints;
 	var hp = t.traits.health;
 	
 	var points = parseFloat( b.rate ) * parseFloat( b.speed ) / 1000.0;
+	if ( bp.curr == 0 )
+	{
+		t.flattenTerrain(); //make the terrain stable for the building
+		//t.placeBuildingFootprint(false);  //false means display regular footprint, not rubble
+	}
 	bp.curr += points;
 	hp.curr = Math.min( hp.max, hp.curr + (points/bp.max)*hp.max );
 	
+	
+
 	if( bp.curr >= bp.max )
 	{
 		// We've finished building this object; convert the foundation to a building
 		if( t.building != "" )	// Might be false if another unit finished building the thing during our last anim cycle
 		{
 			t.template = getEntityTemplate( t.building, t.player );
 			t.building = "";
 			
 			t.attachAuras();
 			
 			if (t.traits.population && t.traits.population.add)
 				this.player.resources.housing += parseInt(t.traits.population.add);
 		}
 		evt.preventDefault();	// Stop performing this action
 	}
 }
 
 // ====================================================================
 
 function performRepair( evt )
 {
 	if( !canRepair( this, evt.target ) )
 	{
 		evt.preventDefault();
 		return;
 	}
 	
 	var t = evt.target;
 	var b = this.actions.build;
 	var hp = t.traits.health;
 	var resources = t.traits.creation.resource;
 	
 	// Find the fraction of max health to repair by; this should be one build tick (i.e. longer for buildings with
 	// longer creation time) but also not so much that it causes the unit to have more than max HP
 	var fraction = Math.min(
 		parseFloat( b.rate ) / t.traits.creation.time,
 		( hp.max - hp.curr ) / hp.max 
 	);
 	//console.write("Repair fraction is " + fraction);
 	
 	// Check if we can afford to repair
 	for( r in resources )
 	{
 		var amount = parseInt( fraction * parseInt(resources[r]) );
 		if( this.player.resources[r.toString()] < amount )
 		{
 			console.write("Can't repair - not enough " + r.toString());
 			evt.preventDefault();
 			return;
 		}
 	}
 
 	// Heal the building
 	hp.curr = Math.min( hp.max, hp.curr + fraction * hp.max );
 	
 	// Deduct the resources
 	for( r in resources )
 	{
 		amount = parseInt( fraction * parseInt(resources[r]) );
 		this.player.resources[r.toString()] -= amount;
 	}
 }
 
 // ====================================================================
 
 function damage( dmg, inflictor )
 {	
 	var arm = this.traits.armour;
 	if(!arm) return;		// corpses have no armour, everything else should
 	
 	this.lastCombatTime = getGameTime();
 	
 	// Apply armour and work out how much damage we actually take
 	crushDamage = dmg.crush - arm.value * arm.crush;
 	if ( crushDamage < 0 ) crushDamage = 0;
 	pierceDamage = dmg.pierce - arm.value * arm.pierce;
 	if ( pierceDamage < 0 ) pierceDamage = 0;
 	hackDamage = dmg.hack - arm.value * arm.hack;
 	if ( hackDamage < 0 ) hackDamage = 0;
 
 	totalDamage = parseInt(dmg.typeless + crushDamage + pierceDamage + hackDamage);
 
 	// Minimum of 1 damage
 	if( totalDamage < 1 ) totalDamage = 1;
 
 	this.traits.health.curr -= totalDamage;
 
 	if( this.traits.health.curr <= 0 )
 	{
 		// If the fallen is worth any loot and the inflictor is capable of looting
 		if (this.traits.loot && inflictor.actions && inflictor.actions.loot)
 		{
 			// Cycle through all loot on this entry.
 			for( loot in this.traits.loot )
 			{
 				switch( loot.toString().toUpperCase() )
 				{
 						case "XP":
 						// If the inflictor gains promotions, and he's capable of earning more ranks,
 						if (inflictor.traits.promotion && inflictor.traits.promotion.curr && inflictor.traits.promotion.req
 								&& inflictor.traits.promotion.newentity && inflictor.traits.promotion.newentity != ""
 								&& this.traits.loot && this.traits.loot.xp && inflictor.actions.loot.xp)
 						{
 							// Give him the fallen's upgrade points (if he has any).
 							if (this.traits.loot.xp)
 								inflictor.traits.promotion.curr = parseInt(inflictor.traits.promotion.curr) + parseInt(this.traits.loot.xp);
 
 							// Notify player.
 							/*if (inflictor.traits.id.specific)
 								console.write(inflictor.traits.id.specific + " has earned " + this.traits.loot.xp + " upgrade points!");
 							else
 								console.write("One of your units has earned " + this.traits.loot.xp + " upgrade points!");
 							*/
 
 							// If he now has maximum upgrade points for his rank,
 							if (inflictor.traits.promotion.curr >= inflictor.traits.promotion.req)
 							{
 								// Notify the player.
 								/*if (inflictor.traits.id.specific)
 									console.write(inflictor.traits.id.specific + " has gained a promotion!");
 								else
 									console.write("One of your units has gained a promotion!");*/
 								
 								// Reset his upgrade points.
 								inflictor.traits.promotion.curr = 0; 
 
 								// Upgrade his portrait to the next level.
 								inflictor.traits.id.icon_cell++; 
 
 								// Transmogrify him into his next rank.
 								inflictor.template = getEntityTemplate( inflictor.traits.promotion.newentity, inflictor.player );
 								
 								inflictor.traits.promotion.newentity = null;		// So that setupRank() can set it properly
 								inflictor.setupRank();
 								//console.write("New promotion values: " + inflictor.traits.promotion.curr + " / " + inflictor.traits.promotion.req);
 							}
 						}
 						break;
 					default:
 						if ( inflictor.actions.loot.resources )
 						{
 							// Notify player.
 							//console.write ("Spoils of war! " + this.traits.loot[loot] + " " + loot.toString() + "!");
 							// Give the inflictor his resources.
 							this.player.resources[loot.toString()] -= parseInt(this.traits.loot[loot]);
 						}
 						break;
 				}
 			}
 		}
 
 		// Notify player.
 		if ( inflictor )
 			console.write( this.traits.id.generic + " got the point of " + inflictor.traits.id.generic + "'s weapon." );
 		else
 			console.write( this.traits.id.generic + " died in mysterious circumstances." );
 
 		// Make him cry out in pain.
 		if (this.traits.audio && this.traits.audio.path)
 		{
 			curr_pain = getGUIGlobal().newRandomSound("voice", "pain", this.traits.audio.path);
 			if (curr_pain) curr_pain.play();
 		}
 		else
 		{
 			console.write ("Sorry, no death sound for this unit; you'll just have to imagine it ...");
 		}
 
 		// We've taken what we need. Kill the swine.
 		//console.write("Kill!!");
 		this.kill();
 	}
 	/*else if( inflictor && this.actions && this.actions.attack )
 	{
 		// If we're not already doing something else, take a measured response - hit 'em back.
 		// You know, I think this is quite possibly the first Ai code the Ai divlead has written
 		// for 0 A.D....
 		//When the entity changes order, we can readjust flank penalty. We must destroy the notifiers ourselves later,however.
 		this.requestNotification( inflictor, NOTIFY_ORDER_CHANGE, false, true );			
 		this.registerDamage( inflictor );
 		if( this.isIdle() )
 			this.order( ORDER_GENERIC, inflictor, this.getAttackAction( inflictor ) );
 	}*/
 	
 	this.onDamaged( inflictor );
 }
 // ====================================================================
 
 function entityEventGeneric( evt )
 {
 	switch( evt.action )
 	{
 		case ACTION_ATTACK:
 			this.performAttack( evt ); break;
 		case ACTION_GATHER:
 			evt.notifyType = NOTIFY_GATHER;
 			this.performGather( evt );
 			break;
 		case ACTION_HEAL:
 			this.performHeal( evt ); break;
 		case ACTION_ATTACK_RANGED:
 			this.performAttackRanged( evt ); break;
 		case ACTION_BUILD:
 			this.performBuild( evt ); break;
 		case ACTION_REPAIR:
 			this.performRepair( evt ); break;
 
 		default:
 			console.write( "Unknown generic action: " + evt.action );
 	}
 }
 
 //======================================================================
 
 function entityEventNotification( evt )
 {
 	//This is used to adjust the flank penalty (we're no longer being attacked).
 	if ( this.getCurrentRequest() == NOTIFY_ORDER_CHANGE )
 	{
 		this.registerOrderChange( evt.target );
 		destroyNotifier( evt.target );
 		return;
 	}
 	//Add "true" to the end of order() to indicate that this is a notification order.
 	switch( evt.notifyType )
 	{
 		
 		case NOTIFY_GOTO:	
 			this.GotoInRange( evt.location.x, evt.location.z, false);
 			break;
 		case NOTIFY_RUN:
 			this.GotoInRange( evt.location.x, evt.location.z, true );
 			break;
 		case NOTIFY_ATTACK:
 		case NOTIFY_DAMAGE:
 			this.order( ORDER_GENERIC, evt.target, ACTION_ATTACK );
 			break;
 		case NOTIFY_HEAL:
 			this.order( ORDER_GENERIC, evt.target, ACTION_HEAL );
 			break;
 		case NOTIFY_GATHER:
 			this.order( ORDER_GENERIC, evt.target, ACTION_GATHER );
 			break;
 		case NOTIFY_IDLE:
 			//target is the unit that has become idle.  Eventually...do something here.
 			break;
 		default:
 			console.write( "Unknown notification request " + evt.notifyType );
 			return;
 	}
 	
 }		
 
 // ====================================================================
 
 function getAttackAction( target )
 {
 	if (!this.actions.attack)
 		return ACTION_NONE;
 	var attack = this.actions.attack;
 	if ( attack.melee )
 		return ACTION_ATTACK;
 	else if ( attack.ranged )
 		return ACTION_ATTACK_RANGED;
 	else
 		return ACTION_NONE;
 }
 
 // ====================================================================
 
 // TODO: Change this to an event so that it gets passed to our parent too, like other events
 function entityComplete()
 {
 	console.write( this + " is finished building." );
 }
 
 //=====================================================================
 
 function entityEventIdle( evt )
 {
 	//Use our own data for target; we aren't affecting anyone, so listeners want to know about us
 	this.forceCheckListeners( NOTIFY_IDLE, this );
 }
 
 // ====================================================================
 
 function entityEventTargetExhausted( evt )
 {
 	if( evt.action == ACTION_GATHER )
 	{
 		// Look for other resources of the same type to gather
 		this.chooseGatherTarget( evt.target.traits.supply.subType.toString() );
 	}
 	else if( evt.action == ACTION_BUILD )
 	{
 		// Look for other stuff to build
 		var visible = this.getVisibleEntities();
 		var bestDist = 1e20;
 		var bestTarget = null;
 		for( var i=0; i<visible.length; i++ )
 		{
 			var e = visible[i];
 			if( canBuild( this, e ) )
 			{
 				var dist = this.getDistance( e );
 				if( dist < bestDist )
 				{
 					bestDist = dist;
 					bestTarget = e;
 				}
 			}
 		}
 		if( bestTarget != null )
 		{
 			this.order( ORDER_GENERIC, bestTarget, ACTION_BUILD );
 		}
 		else if( evt.target.hasClass("Village") )
 		{
 			// Nothing to build, but try to gather any resource around us
 			this.chooseGatherTarget( null, evt.target.getVisibleEntities() );
 		}
 	}
 }
 
 function chooseGatherTarget( resourceSubType, targetList )
 {
 	if( !targetList )
 		targetList = this.getVisibleEntities();
 	var bestDist = 1e20;
 	var bestTarget = null;
 	for( var i=0; i<targetList.length; i++ )
 	{
 		var e = targetList[i];
 		if( canGather( this, e )
 			&& ( !resourceSubType || e.traits.supply.subType.toString() == resourceSubType ) )
 		{
 			var dist = this.getDistance( e );
 			if( dist < bestDist )
 			{
 				bestDist = dist;
 				bestTarget = e;
 			}
 		}
 	}
 	if( bestTarget != null )
 	{
 		this.order( ORDER_GENERIC, bestTarget, ACTION_GATHER );
 		return true;
 	}
 	return false;
 }
 
 // ====================================================================
 
 function entityEventTargetChanged( evt )
 {
 	// This event lets us know when the user moves his/her cursor to a different unit (provided this
 	// unit is selected) - use it to tell the engine what context cursor should be displayed, given
 	// the target.
 
 	// If we can gather, and the target supplies, gather. If it's our enemy, and we're armed, attack. 
 	// If all else fails, move (or run on a right-click).
 	
 	if ( getCursorName() == "cursor-rally" )
 	{
 		evt.defaultCursor = "cursor-rally";
 		evt.defaultOrder = -1;	
 		return;
 	}	
 
 	evt.defaultOrder = NMT_Goto;
 	evt.defaultCursor = "arrow-default";
 	evt.defaultAction = ACTION_NONE;
 	evt.secondaryAction = ACTION_NONE;
 	evt.secondaryCursor = "arrow-default";
 	if ( this.actions && this.actions.run && this.actions.run.speed > 0 )
 	{
 		evt.secondaryOrder = NMT_Run;
 	}
 
 	if( evt.target && this.actions )
 	{
 		if( this.actions.attack && 
 			this.player.getDiplomaticStance(evt.target.player) != DIPLOMACY_ALLIED &&
 			evt.target.traits.health &&
 			evt.target.traits.health.max != 0 )
 		{
 			evt.defaultOrder = NMT_Generic;
 			evt.defaultAction = this.getAttackAction( evt.target );
 			evt.defaultCursor = "action-attack";
 
 			evt.secondaryOrder = NMT_Generic;
 			evt.secondaryAction = this.getAttackAction( evt.target );
 			evt.secondaryCursor = "action-attack";
 		}
 		
 		if ( this.actions.escort &&
 			this != evt.target &&
 			evt.target.player == this.player &&
 			evt.target.actions )
 		{
 			if (evt.target.actions.move)
 			{ 
 				//Send an empty order
 				evt.defaultOrder = NMT_NotifyRequest;
 				evt.secondaryOrder = NMT_NotifyRequest;
 
 				evt.defaultAction = NOTIFY_ESCORT;
 				evt.secondaryAction = NOTIFY_ESCORT;
 			}
 		}
 
 		if ( canGather( this, evt.target ) )
 		{
 			evt.defaultOrder = NMT_Generic;
 			evt.defaultAction = ACTION_GATHER;
 		    // Set cursor (eg "action-gather-fruit").
 		    evt.defaultCursor = "action-gather-" + evt.target.traits.supply.subType;
 
 			evt.secondaryOrder = NMT_Generic;
 			evt.secondaryAction = ACTION_GATHER;
 		  	// Set cursor (eg "action-gather-fruit").
 		    evt.secondaryCursor = "action-gather-" + evt.target.traits.supply.subType;
 		}
 		
 		if ( canBuild( this, evt.target ) )
 		{
 			evt.defaultOrder = NMT_Generic;
 			evt.defaultAction = ACTION_BUILD;
 		    evt.defaultCursor = "action-build";
 
 			evt.secondaryOrder = NMT_Generic;
 			evt.secondaryAction = ACTION_BUILD;
 		    evt.secondaryCursor = "action-build";
 		}
 		
 		if ( canRepair( this, evt.target ) )
 		{
 			evt.defaultOrder = NMT_Generic;
 			evt.defaultAction = ACTION_REPAIR;
 		    evt.defaultCursor = "action-build";
 
 			evt.secondaryOrder = NMT_Generic;
 			evt.secondaryAction = ACTION_REPAIR;
 		    evt.secondaryCursor = "action-build";
 		}
 	}
 	//Rally point
 	else if ( this.building )
 	{
 		evt.defaultOrder = -1;
 		evt.defaultCursor = "cursor-rally";
 	}
 
 		
 }
 
 // ====================================================================
 
 function entityEventPrepareOrder( evt )
 {
 	// This event gives us a chance to veto any order we're given before we execute it.
 	// Not sure whether this really belongs here like this: the alternative is to override it in
 	// subTypes - then you wouldn't need to check tags, you could hardcode results.
 
 	if ( !this.actions )
 	{
 		evt.preventDefault();
 		return;
 	}
 	
 	//evt.notifySource is the entity order data will be obtained from, so if we're attacking and we 
 	//want our listeners to copy us, then we will use our own order as the source.
 	//registerOrderChange() is used to adjust the flank penalty
 
 	switch( evt.orderType )
 	{
 		case ORDER_GOTO:
 			if ( !this.actions.move )
 			{
 				evt.preventDefault();
 				return;
 			}
 			evt.notifyType = NOTIFY_GOTO;
 			evt.notifySource = this;
 			this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 			break;
 			
 		case ORDER_RUN:
 			if ( !this.actions.move.run )	
 			{
 				evt.preventDefault();
 				return;
 			}
 			evt.notifyType = NOTIFY_RUN;
 			evt.notifySource = this;
 			this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 			break;
 			
 		case ORDER_PATROL:
 			if ( !this.actions.patrol )
 			{
 				evt.preventDefault();
 				return;
 			}
 			this.registerOrderChange();
 			this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 			break;	
 			
 		case ORDER_GENERIC:
 			evt.notifySource = this;
 			switch ( evt.action )
 			{
 				case ACTION_ATTACK:
 				case ACTION_ATTACK_RANGED:
 					evt.action = this.getAttackAction( evt.target );
 					if ( evt.action == ACTION_NONE )
 					{
 						evt.preventDefault();
 						return;
 					}
 					evt.notifyType = NOTIFY_ATTACK;
 					this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 					break;
 
 				case ACTION_GATHER:
 					if ( !this.actions.gather )
 					{
 						evt.preventDefault();
 						return;
 					}
 					evt.notifyType = NOTIFY_GATHER;
 					this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 					
 					// Change our gather animation based on the type of target
 					var a = this.actions.gather;
 					this.setActionParams( ACTION_GATHER, 0.0, a.range, a.speed,
 						"gather_" + evt.target.traits.supply.subType );
 						
 					break;
 					
 				case ACTION_HEAL:
 					if ( !this.actions.heal )
 					{
 						evt.preventDefault();
 						return;
 					}
 					evt.notifyType = NOTIFY_HEAL;
 					this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 					break;	
 					
 				case ACTION_BUILD:
 					if ( !this.actions.build || !evt.target.building || evt.target.building=="" )
 					{
 						evt.preventDefault();
 						return;
 					}
 					evt.notifyType = NOTIFY_NONE;
 					this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 					break;	
 					
 				case ACTION_REPAIR:
 					if ( !this.actions.repair )
 					{
 						evt.preventDefault();
 						return;
 					}
 					evt.notifyType = NOTIFY_NONE;
 					this.forceCheckListeners( NOTIFY_ORDER_CHANGE, this );
 					break;	
 			}
 			break;
 		
 		case ORDER_PRODUCE:
 		case ORDER_START_CONSTRUCTION:
 			evt.notifyType = NOTIFY_NONE;
 			break;
 			
 		default:
 			console.write("Unknown order type " + evt.orderType + "; ignoring.");
 			evt.preventDefault();
 			break;
 	}
 }
 
 // ====================================================================
 
 function entityStartConstruction( evt )
 {
 	this.order( ORDER_GENERIC, evt.target, ACTION_BUILD );
 }
 
 // ====================================================================
 
 const TECH_RESOURCES = new Array("food", "wood", "stone", "metal");
 
 function entityStartProduction( evt )
 {
 	//console.write("StartProduction: " + evt.productionType + " " + evt.name);
 	
 	if( evt.productionType == PRODUCTION_TRAIN ) 
 	{
 		var template = getEntityTemplate( evt.name, this.player );
 		var result = checkEntityReqs( this.player, template );	
 
 		if (result == true) // If the entry meets requirements to be added to the queue (eg sufficient resources) 
 		{
 			// Cycle through all costs of this entry.
 			var pool = template.traits.creation.resource;
 			for ( resource in pool )
 			{
 				switch ( resource.toString() )
 				{
 					case "population":
 					case "housing":
 					break;
 					default:
 						// Deduct the given quantity of resources.
 						this.player.resources[resource.toString()] -= parseInt(pool[resource]);
 
 						/*console.write ("Spent " + pool[resource] + " " + resource + " to purchase " + 
 							template.traits.id.generic);*/
 					break;
 				}
 			}
 			
 			// Reserve population space for the unit
 			if( template.traits.population && template.traits.population.rem )
 			{
 				this.player.resources.population += parseInt(template.traits.population.rem);
 			}
 	
 			// Set the amount of time it will take to complete production of the production object.
 			evt.time = getEntityTemplate( evt.name, this.player ).traits.creation.time;
 		}
 		else
 		{	
 			// If not, output the error message.
 			console.write(result);
 			evt.preventDefault();
 			return;
 		}
 	}
 	else if( evt.productionType == PRODUCTION_RESEARCH ) 
 	{
 		var tech = getTechnology( evt.name, this.player );
 		
 		if( !tech )
 		{
 			console.write( "No such tech: " + evt.name );
 			evt.preventDefault();
 			return;
 		}
 		
 		// Check tech requirements other than resources
 		if( !tech.isValid() ) 
 		{
 			console.write( "Tech " + evt.name + " is currently unavailable" );
 			evt.preventDefault();
 			return;
 		}
 		
 		// Check for sufficient resources
 		for( i in TECH_RESOURCES )
 		{
 			var res = TECH_RESOURCES[i];
 			if( this.player.resources[res] < tech[res] )
 			{
 				console.write( "Cannot afford " + evt.name + ": need " + tech[res] + " " + res );
 				evt.preventDefault();
 				return;
 			}
 		}
 		
 		// Subtract resources
 		for( i in TECH_RESOURCES )
 		{
 			var res = TECH_RESOURCES[i];
 			this.player.resources[res] -= tech[res];
 		}
 		
 		// Mark it as in progress
 		tech.in_progress = true;
 		
 		// Set the amount of time it will take to complete production of the tech.
 		evt.time = tech.time;
 	}
 	else
 	{
 		evt.preventDefault();
 	}
 }
 
 function entityCancelProduction( evt )
 {
 	//console.write("CancelProduction: " + evt.productionType + " " + evt.name);
 	
 	if( evt.productionType == PRODUCTION_TRAIN )
 	{
 		// Give back all the resources spent on this entry.
 		var template = getEntityTemplate( evt.name, this.player );
 		var pool = template.traits.creation.resource;
 		for ( resource in pool )
 		{
 			switch ( resource.toString() )
 			{
 				case "population":
 				case "housing":
 				break;
 				default:
 					// Refund the given quantity of resources.
 					this.player.resources[resource.toString()] += parseInt(pool[resource]);
 
 					console.write ("Got back " + pool[resource] + " " + resource + " from cancelling " + 
 						template.traits.id.generic);
 				break;
 			}
 		}
 		
 		// Give back the reserved population space
 		if( template.traits.population && template.traits.population.rem )
 		{
 			this.player.resources.population -= parseInt(template.traits.population.rem);
 		}
 	}
 	else if( evt.productionType == PRODUCTION_RESEARCH )
 	{
 		var tech = getTechnology( evt.name, this.player );
 		
 		// Give back the player's resources
 		for( i in TECH_RESOURCES )
 		{
 			var res = TECH_RESOURCES[i];
 			this.player.resources[res] += tech[res];
 		}
 		
 		// Unmark tech as in progress
 		tech.in_progress = false;
 	}
 }
 
 function entityFinishProduction( evt )
 {
 	//console.write("FinishProduction: " + evt.productionType + " " + evt.name);
 	
 	if( evt.productionType == PRODUCTION_TRAIN ) 
 	{
 		var template =  getEntityTemplate( evt.name, this.player );
 	
 		// Give back reserved population space (the unit will take it up again in its initialize event, if we find space to place it)
 		if( template.traits.population && template.traits.population.rem )
 		{
 			this.player.resources.population -= parseInt(template.traits.population.rem);
 		}
 	
 		// Code to find a free space around an object is tedious and slow, so 
 		// I wrote it in C. Takes the template object so it can determine how
 		// much space it needs to leave.
 		var position = this.getSpawnPoint( template );
 		
 		// The above function returns null if it couldn't find a large enough space.
 		if( !position )
 		{
 			console.write( "Couldn't train unit - not enough space" );
 			// Oh well. The player's just lost all the resources and time they put into
 			// construction - serves them right for not paying attention to the land
 			// around their barracks, doesn't it?
 		}
 		else
 		{
 			var created = new Entity( template, position, 0, this.player );
 		
 			// Above shouldn't ever fail, but just in case...
 			if( created )
 			{
 				//console.write( "Created: ", template.tag );
 				var rally = this.getRallyPoint();
 				created.order( ORDER_GOTO, rally.x, rally.z );	
 			}
 		}		
 	}
 	else if( evt.productionType == PRODUCTION_RESEARCH ) 
 	{
 		// Apply the tech's effects
 		var tech = getTechnology( evt.name, this.player );
 		tech.applyEffects();
 	}
 }
 
 // Old training queue system
 
 // ====================================================================
 /*
 function entityAddCreateQueue( template, tab, list )
 {
 	// Make sure we have a queue to put things in...
 	if( !this.actions.create.queue )
 		this.actions.create.queue      = new Array();
 
 	// Construct template object.
 	comboTemplate = template;
 	comboTemplate.list = list;
 	comboTemplate.tab = tab;
 
 	// Append to the end of this queue
 
 	this.actions.create.queue.push( template );
 
 	// If we're not already building something...
 	if( !this.actions.create.progress )
 	{
 		console.write( "Starting work on (unqueued) ", template.tag );
 		 // Start the progress timer.
 		 // - First parameter is target value (in this case, base build time in seconds)
 		 // - Second parameter is increment per millisecond (use build rate modifier and correct for milliseconds)
 		 // - Third parameter is the function to call when the timer finishes.
 		 // - Fourth parameter is the scope under which to run that function (what the 'this' parameter should be)
 		 this.actions.create.progress = new ProgressTimer( template.traits.creation.time, 
 			this.actions.create.speed / 1000, entityCreateComplete, this )
 	}
 }
 
 // ====================================================================
 
 // This is the syntax to add a function (or a property) to absolutely every entity.
 
 Entity.prototype.add_create_queue = entityAddCreateQueue;
 
 // ====================================================================
 
 function entityCreateComplete()
 {
 	// Get the unit that was at the head of our queue, and remove it.
 	// (Oh, for information about all these nifty properties and functions
 	//  of the Array object that I use, see the ECMA-262 documentation
 	//  at http://www.mozilla.org/js/language/E262-3.pdf. Bit technical but
 	//  the sections on 'Native ECMAScript Objects' are quite useful)
 	
 	var template = this.actions.create.queue.shift();
 
 	// Code to find a free space around an object is tedious and slow, so 
 	// I wrote it in C. Takes the template object so it can determine how
 	// much space it needs to leave.
 	position = this.getSpawnPoint( template );
 	
 	// The above function returns null if it couldn't find a large enough space.
 	if( !position )
 	{
 		console.write( "Couldn't train unit - not enough space" );
 		// Oh well. The player's just lost all the resources and time they put into
 		// construction - serves them right for not paying attention to the land
 		// around their barracks, doesn't it?
 	}
 	else
 	{
 		created = new Entity( template, position );
 	
 		// Above shouldn't ever fail, but just in case...
 		if( created )
 		{
 			console.write( "Created: ", template.tag );
 	
 			// Entities start under Gaia control - make the controller
 			// the same as our controller
 			created.player = this.player;
 		}
 	}		
 	// If there's something else in the build queue...
 	if( this.actions.create.queue.length > 0 )
 	{
 		// Start on the next item.
 		template = this.actions.create.queue[0];
 		console.write( "Starting work on (queued) ", template.tag );
 		this.actions.create.progress = new ProgressTimer( template.traits.creation.time, 
 			this.actions.create.speed / 1000, entityCreateComplete, this )
 	}
 	else
 	{
 		// Otherwise, delete the timer.
 		this.actions.create.progress = null;
 	}
 }
 
 // ====================================================================
 
 function attemptAddToBuildQueue( entity, create_tag, tab, list )
 {
 	template = getEntityTemplate( create_tag, entity.player );
 	result = checkEntityReqs( entity, template );	
 
 	if (result == true) // If the entry meets requirements to be added to the queue (eg sufficient resources) 
 	{
 		// Cycle through all costs of this entry.
 		pool = template.traits.creation.resource;
 		for ( resource in pool )
 		{
 			switch ( resource.toString() )
 			{
 				case "population":
 				case "housing":
 				break;
 				default:
 					// Deduct the given quantity of resources.
 					this.player.resources[resource.toString()] -= parseInt(pool[resource]);
 
 					console.write ("Spent " + pool[resource] + " " + resource + " to purchase " + 
 						template.traits.id.generic);
 				break;
 			}
 		}
 
 		// Add entity to queue.
 		console.write( "Adding ", create_tag, " to build queue..." );
 		entity.addCreateQueue( template, tab, list );
 		
 		return true;
 	}
 	else
 	{	// If not, output the error message.
 		console.write(result);
 		return false;
 	}
 }
 */
 // ====================================================================
 
 function checkEntityReqs( player, template ) 
 { 
 	// Determines if the given entity meets requirements for production by the player, and returns an appropriate 
 	// error string.
 	// A return value of 0 equals success -- entry meets requirements for production. 
 	
 	// Cycle through all resources that this item costs, and check the player can afford the cost.
 	var resources = template.traits.creation.resource;
 	for( resource in resources )
 	{
 		switch( resource.toString() )
 		{
 			case "population":
 			case "housing": // Ignore housing. It's handled in combination with population.
 			break
 			default:
 				// If the item costs more of this resource type than we have,
 				var cur = player.resources[resource];
 				var req = parseInt(resources[resource]);
 				if (req > cur)
 				{
 					// Return an error.
 					return ("Insufficient " + resource + "; " + (req-cur) + " more required."); 
 				}
 				//else
 				//	console.write("Player has at least " + req + " " + resource + ".");
 			break;
 		}
 	}
 	
 	// Check if we have enough population space for the entity
 	
 	if(template.traits.population && template.traits.population.rem) 
 	{
 		var req = parseInt(template.traits.population.rem);
 		var space = player.resources.housing - player.resources.population;
 	
 		// If the item costs more of this resource type than we have,
 		if (req > space)
 		{
 			// Return an error.
 			return ("Insufficient Housing; " + (req - space) + " more required."); 
 		}
 	}
 
 	// Check if another entity must first exist. 
 
 	// Check if another tech must first be researched. 
 
 	// Check if the limit for this type of entity has been reached. 
 
 	// If we passed all checks, return success. Entity can be queued.
 	return true; 
 }
 
 // ====================================================================
 
 function canGather( source, target )
 {
 	// Checks whether we're allowed to gather from a target entity (this involves looking at both the type and subType).
 	if( !source.actions || !target.traits )
 		return false;
 	g = source.actions.gather;
 	s = target.traits.supply;
 	return ( g && s && g.resource && g.resource[s.type] &&
 		( s.subType==s.type || g.resource[s.type][s.subType] ) &&
 		( s.curr > 0 || s.max == 0 ) && 
 		s.dropsiteCount[source.player.id] );
 }
 
 // ====================================================================
 
 function canBuild( source, target )
 {
 	// Checks whether we're allowed to build a target entity
 	if( !source.actions )
 		return false;
 	b = source.actions.build;
 	return (b && target.building != "" && target.player.id == source.player.id
 		&& target.buildPoints.curr < target.buildPoints.max );
 }
 
 // ====================================================================
 
 function canRepair( source, target )
 {
 	// Checks whether we're allowed to gather from a target entity (this involves looking at both the type and subType).
 	if( !source.actions )
 		return false;
 	r = source.actions.repair;
 	return( r && target.traits.health.repairable && target.player.id == source.player.id
 			&& target.traits.health.curr < target.traits.health.max 
 			&& target.building == "" );
 }
 
 // ====================================================================
 
 // Get the elevation attack bonus if we are heightDif units higher than our target
 function getElevationBonus( heightDif )
 {
 	if ( heightDif > 2.0 )
 		return 0.3;	// we are significantly higher, get a positive bonus
 	else 
 		return 0.0;	// we are at roughly the same height, or below
 }
 
 // ====================================================================
 
 // DamageType class
 function DamageType()
 {
 	this.typeless = 0.0;
 	this.crush = 0.0;
 	this.pierce = 0.0;
 	this.hack = 0.0;
 }
 
 // ====================================================================
 
 function DamageModifyAura( source, ally, bonus )
 {
 	// Defines the effects of the DamageModify Aura. (Adjacent units have modified attack bonus.)
 	// The Courage Aura uses this function to give attack bonus to allies.	
 	// The Fear Aura uses this function to give attack penalties to enemies.
 
 	this.source = source;
 	this.bonus = bonus;
 	this.ally = ally;
 	
 	this.affects = function( e ) 
 	{
 		if( this.ally )
 		{
 			return ( e.player.id == this.source.player.id && e.actions && e.actions.attack );
 		}
 		else
 		{
 			return ( e.player.id != this.source.player.id && e.actions && e.actions.attack );
 		}
 	}
 	
 	this.onEnter = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			//console.write( "DamageModify aura: giving " + this.bonus + " damage to " + e );
 			e.actions.attack.damage += this.bonus;
 		}
 	};
 	
 	this.onExit = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			//console.write( "DamageModify aura: taking away " + this.bonus + " damage from " + e );
 			e.actions.attack.damage -= this.bonus;
 		}
 	};
 }
 
 // ====================================================================
 
 function DropsiteAura( source, types )
 {
 	// Defines the effects of the Gather aura. Enables resource gathering on entities
 	// near the source for it's owner.
 
 	this.source = source;
 	this.types = types;
 	
 	this.affects = function( e ) 
 	{
 		return( e.traits.supply && this.types[e.traits.supply.type] );
 	}
 	
 	this.onEnter = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			//console.write( "Dropsite aura: adding +1 for " + this.source.player.id + " on " + e );
 			e.traits.supply.dropsiteCount[this.source.player.id]++;
 		}
 	};
 	
 	this.onExit = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			//console.write( "Dropsite aura: adding -1 for " + this.source.player.id + " on " + e );
 			e.traits.supply.dropsiteCount[this.source.player.id]--;
 		}
 	};
 }
 
 // ====================================================================
 
 function InfidelityAura( source, time )
 {
 	// Defines the effects of the Infidelity Aura. Changes ownership of entity when only one player's units surrounds them.
 
 	this.source = source;
 	
 	this.time = time;
 	
 	this.count = new Array( 9 );
 	for( i = 0; i <= 8; i++ )
 	{
 		this.count[i] = 0;
 	}
 	
 	this.convertTimer = 0;
 		
 	this.affects = function( e ) 
 	{
 		return ( e.player.id != 0 && ( !e.traits.auras || !e.traits.auras.infidelity ) );
 	}
 	
 	this.onEnter = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			//console.write( "Infidelity aura: adding +1 count to " + e.player.id );
 			this.count[e.player.id]++;
 			this.changePlayerIfNeeded();
 		}
 	};
 	
 	this.onExit = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			//console.write( "Infidelity aura: adding -1 count to " + e.player.id );
 			this.count[e.player.id]--;
 			this.changePlayerIfNeeded();
 		}
 	};
 	
 	this.changePlayerIfNeeded = function()
 	{
 		if( this.count[this.source.player.id] == 0 )
 		{
 			// If our owner has nothing near us but someone else does, start a time to convert over if we haven't done so already
 			if( !this.convertTimer )
 			{
 				for( i = 1; i <= 8; i++ )
 				{
 					if( this.count[i] > 0 )
 					{
 						console.write( "Starting convert timer" );
 						this.convertTimer = setTimeout( this.convert, parseInt( this.time * 1000 ), this );
 						return;
 					}
 				}
 			}
 		}
 		
 		// If we had started a convert timer before, cancel it (either we have units from our owner in range, or there are no units from anyone in range)
 		if( this.convertTimer )
 		{
 			console.write( "Cancelling convert timer" );
 			cancelTimer( this.convertTimer );
 			this.convertTimer = 0;
 		}
 	}
 	
 	this.convert = function()
 	{
 		console.write( "Conversion time!" );
 		
 		// Switch ownership to whichever non-gaia player has the most units near us
 		bestPlayer = 0;
 		bestCount = 0;
 		for( i = 1; i <= 8; i++ )
 		{
 			if( this.count[i] > bestCount )
 			{
 				bestCount = this.count[i];
 				bestPlayer = i;
 			}
 		}
 		if( bestCount > 0 )
 		{
 			//console.write( "Infidelity aura: changing ownership to " + bestPlayer );
 			this.source.player = players[bestPlayer];
 		}
 		
 		this.convertTimer = 0;
 	}
 }
 
 // ====================================================================
 
 function HealAura( source )
 {
 	// Defines the effects of the Heal aura. Slowly heals nearby allies over time.
 
 	this.source = source;
 	
 	this.affects = function( e ) 
 	{
 		return ( e.player.id == this.source.player.id && e.traits.health 
 					&& e.traits.health.healable
 					&& e.traits.health.curr < e.traits.health.max );
 	}
 	
 	this.onTick = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			var hp = e.traits.health;
 			var rate = this.source.traits.auras.heal.rate;
 			hp.curr = Math.min( hp.max, hp.curr + rate );
 		}
 	};
 }
 
 // ====================================================================
 
 function TrampleAura( source )
 {
 	// Defines the effects of the Trample  aura. Damages nearby enemies over time if the unit is charging or has recently charged.
 	
 	this.source = source;
 	
 	this.affects = function( e )
 	{
 		// Check if the target is an enemy foot unit with health and if we were running in the last 3 seconds
 		var a = this.source.traits.auras.trample;
 		return ( e.player.id != this.source.player.id && e.traits.health && e.hasClass("Foot")
 			&& (getGameTime() - this.source.lastRunTime < a.duration) );
 	}
 	
 	this.onTick = function( e )
 	{
 		if( this.affects( e ) )
 		{
 			// Set up the damage object
 			var dmg = new DamageType();
 			var a = this.source.traits.auras.trample;
 			dmg.crush = parseInt(a.damage * a.crush);
 			dmg.hack = parseInt(a.damage * a.hack);
 			dmg.pierce = parseInt(a.damage * a.pierce);
 
 			// Add flank bonus
 			if(e.traits.flankPenalty)
 			{
 				var flank = (e.getAttackDirections()-1)*e.traits.flankPenalty.value;
 				dmg.crush += dmg.crush * flank;
 				dmg.hack += dmg.hack * flank;
 				dmg.pierce += dmg.pierce * flank;
 			}
 
 			// Perform the damage
 			e.damage( dmg, this.source );
 		}
 	};
 }
 
 // ====================================================================
 
 function SettlementAura( source )
 {
 	// Defines the effects of the Settlement Aura. Changes ownership of entity when a civil center is on it.
 
 	this.source = source;
 	
 	this.affects = function( e ) 
 	{
 		return ( e.hasClass("CivilCentre") );
 	}
 	
 	this.onEnter = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			// If a new Civ Centre has entered our radius, it must mean it's on us; switch player and become invisible
 			source.player = e.player;
 			source.visible = false;
 		}
 	};
 	
 	this.onExit = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			// If a Civ Centre has entered our radius, it must mean the one on us died; become visible again
 			source.visible = true;
 		}
 	}
 }
 
 // ====================================================================
 
 function AllureAura( source )
 {
 	// Defines the effects of the Allure Aura. (Adjacent male units owned by the same player gather faster.)
 
 	this.source = source;
 	
 	this.affects = function( e ) 
 	{
 		return ( e.player.id == this.source.player.id && e.actions && e.actions.gather
 			&& e.actions.gather.affectedByAllure );
 	}
 	
 	this.onEnter = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			e.allureCount++;
 		}
 	};
 	
 	this.onExit = function( e ) 
 	{
 		if( this.affects( e ) ) 
 		{
 			e.allureCount--;
 		}
 	};
 }
 
 // ====================================================================
 
 function GotoInRange( x, y, run )
 {	
 	if ( !this.actions || !this.actions.move )
 		return;
 	//Add "true" at the end to indicate that this is a notification order.
 	if (run && this.actions.move.run)
 		this.order( ORDER_RUN, x, y - this.actions.escort.distance, true);
 	else
 		this.order( ORDER_GOTO, x, y - this.actions.escort.distance, true);
 }
 
 //=====================================================================
 
 function entityEventFormation( evt )
 {
 	if ( evt.formationEvent == FORMATION_ENTER )
 	{
 		if ( this.getFormationBonus() && this.hasClass( this.getFormationBonusType() ) )
 		{
 			eval( this + this.getFormationBonus() ) += eval( this + this.getFormationBonusBase() ) *		
 				 this.getFormationBonusVal();
 		}
 		if ( this.getFormationPenalty() && this.hasInClass( this.getFormationPenaltyType() ) )
 		{
 			eval( this + this.getFormationPenalty() ) -= eval( this + this.getFormationPenaltyBase() ) *
 				this.getFormationPenaltyVal();
 		}
 	}
 	//Reverse the bonuses
 	else if ( evt.formationEvent == FORMATION_LEAVE )
 	{
 		if ( this.getFormationPenalty() && this.hasInClass( this.getFormationPenaltyType() ) )
 		{
 			eval( this + this.getFormationPenalty() ) += eval( this + this.getFormationPenaltyBase() ) *
 				this.getFormationPenaltyVal();
 		}
 		if ( this.getFormationBonus() && this.hasClass( this.getFormationBonusType() ) )
 		{
 			eval( this + this.getFormationBonus() ) -= eval( this + this.getFormationBonusBase() ) *						 this.getFormationBonusVal();
 		}
 		
 	}
 }
\ No newline at end of file
Index: ps/trunk/binaries/data/mods/official/scripts/trigger_functions.js
===================================================================
--- ps/trunk/binaries/data/mods/official/scripts/trigger_functions.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/official/scripts/trigger_functions.js	(revision 4648)
@@ -0,0 +1,4 @@
+function getAlwaysTrue()
+{
+return true;
+}