Merge branch 'reorganisation' of github.com:FacialTurd/The-Powder-Toy

1 files changed, 1151 insertions, 0 deletions

diff --git a/src/gui/game/GameModel.cpp b/src/gui/game/GameModel.cpp
new file mode 100644
index 0000000..37194a5
--- /dev/null
+++ b/src/gui/game/GameModel.cpp
@@ -0,0 +1,1151 @@
+#include "gui/interface/Engine.h"
+#include "GameModel.h"
+#include "GameView.h"
+#include "simulation/Simulation.h"
+#include "simulation/Air.h"
+#include "simulation/Tools.h"
+#include "graphics/Renderer.h"
+#include "gui/interface/Point.h"
+#include "Brush.h"
+#include "EllipseBrush.h"
+#include "TriangleBrush.h"
+#include "BitmapBrush.h"
+#include "client/Client.h"
+#include "client/GameSave.h"
+#include "gui/game/DecorationTool.h"
+#include "GameModelException.h"
+#include "QuickOptions.h"
+#include "Format.h"
+
+GameModel::GameModel():
+	sim(NULL),
+	ren(NULL),
+	currentBrush(0),
+	currentUser(0, ""),
+	currentSave(NULL),
+	currentFile(NULL),
+	colourSelector(false),
+	clipboard(NULL),
+	stamp(NULL),
+	placeSave(NULL),
+	colour(255, 0, 0, 255),
+	toolStrength(1.0f),
+	activeColourPreset(-1),
+	activeMenu(NULL),
+	edgeMode(0)
+{
+	sim = new Simulation();
+	ren = new Renderer(ui::Engine::Ref().g, sim);
+
+	activeTools = regularToolset;
+
+	std::fill(decoToolset, decoToolset+3, (Tool*)NULL);
+	std::fill(regularToolset, regularToolset+3, (Tool*)NULL);
+
+	//Default render prefs
+	std::vector<unsigned int> tempArray;
+	tempArray.push_back(RENDER_FIRE);
+	tempArray.push_back(RENDER_EFFE);
+	tempArray.push_back(RENDER_BASC);
+	ren->SetRenderMode(tempArray);
+	tempArray.clear();
+
+	ren->SetDisplayMode(tempArray);
+
+	ren->SetColourMode(0);
+
+	//Load config into renderer
+	try
+	{
+		ren->SetColourMode(Client::Ref().GetPrefUInteger("Renderer.ColourMode", 0));
+
+		vector<unsigned int> tempArray = Client::Ref().GetPrefUIntegerArray("Renderer.DisplayModes");
+		if(tempArray.size())
+		{
+			std::vector<unsigned int> displayModes(tempArray.begin(), tempArray.end());
+			ren->SetDisplayMode(displayModes);
+		}
+
+		tempArray = Client::Ref().GetPrefUIntegerArray("Renderer.RenderModes");
+		if(tempArray.size())
+		{
+			std::vector<unsigned int> renderModes(tempArray.begin(), tempArray.end());
+			ren->SetRenderMode(renderModes);
+		}
+
+		ren->gravityFieldEnabled = Client::Ref().GetPrefBool("Renderer.GravityField", false);
+		ren->decorations_enable = Client::Ref().GetPrefBool("Renderer.Decorations", true);
+	}
+	catch(json::Exception & e)
+	{
+	}
+
+	//Load config into simulation
+	edgeMode = Client::Ref().GetPrefInteger("Simulation.EdgeMode", 0);
+	sim->SetEdgeMode(edgeMode);
+
+	//Load last user
+	if(Client::Ref().GetAuthUser().ID)
+	{
+		currentUser = Client::Ref().GetAuthUser();
+	}
+
+	//Set stamp to first stamp in list
+	vector<string> stamps = Client::Ref().GetStamps(0, 1);
+	if(stamps.size()>0)
+	{
+		SaveFile * stampFile = Client::Ref().GetStamp(stamps[0]);
+		if(stampFile && stampFile->GetGameSave())
+			stamp = stampFile->GetGameSave();
+	}
+
+	BuildMenus();
+
+	//Set default brush palette
+	brushList.push_back(new EllipseBrush(ui::Point(4, 4)));
+	brushList.push_back(new Brush(ui::Point(4, 4)));
+	brushList.push_back(new TriangleBrush(ui::Point(4, 4)));
+
+	//Load more from brushes folder
+	std::vector<string> brushFiles = Client::Ref().DirectorySearch(BRUSH_DIR, "", ".ptb");
+	for(int i = 0; i < brushFiles.size(); i++)
+	{
+		std::vector<unsigned char> brushData = Client::Ref().ReadFile(brushFiles[i]);
+		if(!brushData.size())
+		{
+			std::cout << "Brushes: Skipping " << brushFiles[i] << ". Could not open" << std::endl;
+			continue;
+		}
+		int dimension = std::sqrt((float)brushData.size());
+		if(dimension * dimension != brushData.size())
+		{
+			std::cout << "Brushes: Skipping " << brushFiles[i] << ". Invalid bitmap size" << std::endl;
+			continue;
+		}
+		brushList.push_back(new BitmapBrush(brushData, ui::Point(dimension, dimension)));
+	}
+
+	//Set default decoration colour
+	unsigned char colourR = min(Client::Ref().GetPrefInteger("Decoration.Red", 200), 255);
+	unsigned char colourG = min(Client::Ref().GetPrefInteger("Decoration.Green", 100), 255);
+	unsigned char colourB = min(Client::Ref().GetPrefInteger("Decoration.Blue", 50), 255);
+	unsigned char colourA = min(Client::Ref().GetPrefInteger("Decoration.Alpha", 255), 255);
+
+	SetColourSelectorColour(ui::Colour(colourR, colourG, colourB, colourA));
+
+	colourPresets.push_back(ui::Colour(255, 255, 255));
+	colourPresets.push_back(ui::Colour(0, 255, 255));
+	colourPresets.push_back(ui::Colour(255, 0, 255));
+	colourPresets.push_back(ui::Colour(255, 255, 0));
+	colourPresets.push_back(ui::Colour(255, 0, 0));
+	colourPresets.push_back(ui::Colour(0, 255, 0));
+	colourPresets.push_back(ui::Colour(0, 0, 255));
+}
+
+GameModel::~GameModel()
+{
+	//Save to config:
+	Client::Ref().SetPref("Renderer.ColourMode", ren->GetColourMode());
+
+	std::vector<unsigned int> displayModes = ren->GetDisplayMode();
+	Client::Ref().SetPref("Renderer.DisplayModes", std::vector<unsigned int>(displayModes.begin(), displayModes.end()));
+
+	std::vector<unsigned int> renderModes = ren->GetRenderMode();
+	Client::Ref().SetPref("Renderer.RenderModes", std::vector<unsigned int>(renderModes.begin(), renderModes.end()));
+
+	Client::Ref().SetPref("Renderer.GravityField", (bool)ren->gravityFieldEnabled);
+	Client::Ref().SetPref("Renderer.Decorations", (bool)ren->decorations_enable);
+
+	Client::Ref().SetPref("Simulation.EdgeMode", sim->edgeMode);
+
+	Client::Ref().SetPref("Decoration.Red", (int)colour.Red);
+	Client::Ref().SetPref("Decoration.Green", (int)colour.Green);
+	Client::Ref().SetPref("Decoration.Blue", (int)colour.Blue);
+	Client::Ref().SetPref("Decoration.Alpha", (int)colour.Alpha);
+
+	for(int i = 0; i < menuList.size(); i++)
+	{
+		delete menuList[i];
+	}
+	for(std::vector<Tool*>::iterator iter = extraElementTools.begin(), end = extraElementTools.end(); iter != end; ++iter)
+	{
+		delete *iter;
+	}
+	for(int i = 0; i < brushList.size(); i++)
+	{
+		delete brushList[i];
+	}
+	delete sim;
+	delete ren;
+	if(placeSave)
+		delete placeSave;
+	if(clipboard)
+		delete clipboard;
+	if(stamp)
+		delete stamp;
+	if(currentSave)
+		delete currentSave;
+	if(currentFile)
+		delete currentFile;
+	//if(activeTools)
+	//	delete[] activeTools;
+}
+
+void GameModel::UpdateQuickOptions()
+{
+	for(std::vector<QuickOption*>::iterator iter = quickOptions.begin(), end = quickOptions.end(); iter != end; ++iter)
+	{
+		QuickOption * option = *iter;
+		option->Update();
+	}	
+}
+
+void GameModel::BuildQuickOptionMenu(GameController * controller)
+{
+	for(std::vector<QuickOption*>::iterator iter = quickOptions.begin(), end = quickOptions.end(); iter != end; ++iter)
+	{
+		delete *iter;
+	}
+	quickOptions.clear();
+
+	quickOptions.push_back(new SandEffectOption(this));
+	quickOptions.push_back(new DrawGravOption(this));
+	quickOptions.push_back(new DecorationsOption(this));
+	quickOptions.push_back(new NGravityOption(this));
+	quickOptions.push_back(new AHeatOption(this));
+	quickOptions.push_back(new ConsoleShowOption(this, controller));
+
+	notifyQuickOptionsChanged();
+	UpdateQuickOptions();
+}
+
+void GameModel::BuildMenus()
+{
+	char lastMenu = 0;
+	if(activeMenu)
+		lastMenu = activeMenu->GetIcon();
+
+	std::string activeToolIdentifiers[3];
+	if(regularToolset[0])
+		activeToolIdentifiers[0] = regularToolset[0]->GetIdentifier();
+	if(regularToolset[1])
+		activeToolIdentifiers[1] = regularToolset[1]->GetIdentifier();
+	if(regularToolset[2])
+		activeToolIdentifiers[2] = regularToolset[2]->GetIdentifier();
+
+	//Empty current menus
+	for(std::vector<Menu*>::iterator iter = menuList.begin(), end = menuList.end(); iter != end; ++iter)
+	{
+		delete *iter;
+	}
+	menuList.clear();
+	toolList.clear();
+
+	for(std::vector<Tool*>::iterator iter = extraElementTools.begin(), end = extraElementTools.end(); iter != end; ++iter)
+	{
+		delete *iter;
+	}
+	extraElementTools.clear();
+	elementTools.clear();
+
+	//Create menus
+	for(int i = 0; i < SC_TOTAL; i++)
+	{
+		menuList.push_back(new Menu((const char)sim->msections[i].icon[0], sim->msections[i].name));
+	}
+
+	//Build menus from Simulation elements
+	for(int i = 0; i < PT_NUM; i++)
+	{
+		if(sim->elements[i].Enabled)
+		{
+			Tool * tempTool;
+			if(i == PT_LIGH)
+			{
+				tempTool = new Element_LIGH_Tool(i, sim->elements[i].Name, sim->elements[i].Description, PIXR(sim->elements[i].Colour), PIXG(sim->elements[i].Colour), PIXB(sim->elements[i].Colour), sim->elements[i].Identifier, sim->elements[i].IconGenerator);
+			}
+			else if(i == PT_TESC)
+			{
+				tempTool = new Element_TESC_Tool(i, sim->elements[i].Name, sim->elements[i].Description, PIXR(sim->elements[i].Colour), PIXG(sim->elements[i].Colour), PIXB(sim->elements[i].Colour), sim->elements[i].Identifier, sim->elements[i].IconGenerator);
+			}
+			else if(i == PT_STKM || i == PT_FIGH || i == PT_STKM2)
+			{
+				tempTool = new PlopTool(i, sim->elements[i].Name, sim->elements[i].Description, PIXR(sim->elements[i].Colour), PIXG(sim->elements[i].Colour), PIXB(sim->elements[i].Colour), sim->elements[i].Identifier, sim->elements[i].IconGenerator);
+			}
+			else
+			{
+				tempTool = new ElementTool(i, sim->elements[i].Name, sim->elements[i].Description, PIXR(sim->elements[i].Colour), PIXG(sim->elements[i].Colour), PIXB(sim->elements[i].Colour), sim->elements[i].Identifier, sim->elements[i].IconGenerator);
+			}
+
+			if(sim->elements[i].MenuSection < SC_TOTAL && sim->elements[i].MenuVisible)
+			{
+				menuList[sim->elements[i].MenuSection]->AddTool(tempTool);
+			}
+			else
+			{
+				extraElementTools.push_back(tempTool);
+			}
+			elementTools.push_back(tempTool);
+		}
+	}
+
+	//Build menu for GOL types
+	for(int i = 0; i < NGOL; i++)
+	{
+		Tool * tempTool = new GolTool(i, sim->gmenu[i].name, std::string(sim->gmenu[i].description), PIXR(sim->gmenu[i].colour), PIXG(sim->gmenu[i].colour), PIXB(sim->gmenu[i].colour), "DEFAULT_PT_LIFE_"+std::string(sim->gmenu[i].name));
+		menuList[SC_LIFE]->AddTool(tempTool);
+	}
+
+	//Build other menus from wall data
+	for(int i = 0; i < UI_WALLCOUNT; i++)
+	{
+		Tool * tempTool = new WallTool(i, "", std::string(sim->wtypes[i].descs), PIXR(sim->wtypes[i].colour), PIXG(sim->wtypes[i].colour), PIXB(sim->wtypes[i].colour), "DEFAULT_WL_"+format::NumberToString<int>(i), sim->wtypes[i].textureGen);
+		menuList[SC_WALL]->AddTool(tempTool);
+		//sim->wtypes[i]
+	}
+	
+	//Add special sign and prop tools
+	menuList[SC_TOOL]->AddTool(new SampleTool(this));
+	menuList[SC_TOOL]->AddTool(new SignTool());
+	menuList[SC_TOOL]->AddTool(new PropertyTool());
+	menuList[SC_TOOL]->AddTool(new WindTool(0, "WIND", "Create air movement", 64, 64, 64, "DEFAULT_UI_WIND"));
+	
+	//Build menu for simtools
+	for(int i = 0; i < sim->tools.size(); i++)
+	{
+		Tool * tempTool;
+		tempTool = new Tool(i, sim->tools[i]->Name, sim->tools[i]->Description, PIXR(sim->tools[i]->Colour), PIXG(sim->tools[i]->Colour), PIXB(sim->tools[i]->Colour), sim->tools[i]->Identifier);
+		menuList[SC_TOOL]->AddTool(tempTool);
+	}
+
+	//Add decoration tools to menu
+	menuList[SC_DECO]->AddTool(new DecorationTool(DecorationTool::BlendAdd, "ADD", "Colour blending: Add", 0, 0, 0, "DEFAULT_DECOR_ADD"));
+	menuList[SC_DECO]->AddTool(new DecorationTool(DecorationTool::BlendRemove, "SUB", "Colour blending: Subtract", 0, 0, 0, "DEFAULT_DECOR_SUB"));
+	menuList[SC_DECO]->AddTool(new DecorationTool(DecorationTool::BlendMultiply, "MUL", "Colour blending: Multiply", 0, 0, 0, "DEFAULT_DECOR_MUL"));
+	menuList[SC_DECO]->AddTool(new DecorationTool(DecorationTool::BlendDivide, "DIV", "Colour blending: Divide" , 0, 0, 0, "DEFAULT_DECOR_DIV"));
+	menuList[SC_DECO]->AddTool(new DecorationTool(DecorationTool::BlendSmudge, "SMDG", "Smudge colour", 0, 0, 0, "DEFAULT_DECOR_SMDG"));
+	menuList[SC_DECO]->AddTool(new DecorationTool(DecorationTool::BlendSet, "SET", "Set colour (No blending)", 0, 0, 0, "DEFAULT_DECOR_SET"));
+	menuList[SC_DECO]->AddTool(new DecorationTool(DecorationTool::Remove, "CLR", "Clear any set decoration", 0, 0, 0, "DEFAULT_DECOR_CLR"));
+	decoToolset[0] = GetToolFromIdentifier("DEFAULT_DECOR_SET");
+	decoToolset[1] = GetToolFromIdentifier("DEFAULT_DECOR_CLR");
+	decoToolset[2] = GetToolFromIdentifier("DEFAULT_UI_SAMPLE");
+
+	//Set default tools
+	regularToolset[0] = GetToolFromIdentifier("DEFAULT_PT_DUST");
+	regularToolset[1] = GetToolFromIdentifier("DEFAULT_PT_NONE");
+	regularToolset[2] = GetToolFromIdentifier("DEFAULT_UI_SAMPLE");
+
+
+	if(activeToolIdentifiers[0].length())
+		regularToolset[0] = GetToolFromIdentifier(activeToolIdentifiers[0]);
+	if(activeToolIdentifiers[1].length())
+		regularToolset[1] = GetToolFromIdentifier(activeToolIdentifiers[1]);
+	if(activeToolIdentifiers[2].length())
+		regularToolset[2] = GetToolFromIdentifier(activeToolIdentifiers[2]);
+
+	lastTool = activeTools[0];
+
+	//Set default menu
+	activeMenu = menuList[SC_POWDERS];
+
+	if(lastMenu)
+	{
+		for(std::vector<Menu*>::iterator iter = menuList.begin(), end = menuList.end(); iter != end; ++iter)
+		{
+			if((*iter)->GetIcon() == lastMenu)
+				activeMenu = *iter;
+		}
+	}
+
+	if(activeMenu)
+		toolList = activeMenu->GetToolList();
+	else
+		toolList = std::vector<Tool*>();
+
+	notifyMenuListChanged();
+	notifyToolListChanged();
+	notifyActiveToolsChanged();
+	notifyLastToolChanged();
+}
+
+Tool * GameModel::GetToolFromIdentifier(std::string identifier)
+{
+	for(std::vector<Menu*>::iterator iter = menuList.begin(), end = menuList.end(); iter != end; ++iter)
+	{
+		std::vector<Tool*> menuTools = (*iter)->GetToolList();
+		for(std::vector<Tool*>::iterator titer = menuTools.begin(), tend = menuTools.end(); titer != tend; ++titer)
+		{
+			if(identifier == (*titer)->GetIdentifier())
+				return *titer;
+		}
+	}
+	return NULL;
+}
+
+void GameModel::SetEdgeMode(int edgeMode)
+{
+	this->edgeMode = edgeMode;
+	sim->SetEdgeMode(edgeMode);
+}
+
+int GameModel::GetEdgeMode()
+{
+	return this->edgeMode;
+}
+
+std::deque<Snapshot*> GameModel::GetHistory()
+{
+	return history;
+}
+void GameModel::SetHistory(std::deque<Snapshot*> newHistory)
+{
+	history = newHistory;
+}
+
+void GameModel::SetVote(int direction)
+{
+	if(currentSave)
+	{
+		RequestStatus status = Client::Ref().ExecVote(currentSave->GetID(), direction);
+		if(status == RequestOkay)
+		{
+			currentSave->vote = direction;
+			notifySaveChanged();
+		}
+		else
+		{
+			throw GameModelException("Could not vote: "+Client::Ref().GetLastError());
+		}
+	}
+}
+
+Brush * GameModel::GetBrush()
+{
+	return brushList[currentBrush];
+}
+
+int GameModel::GetBrushID()
+{
+	return currentBrush;
+}
+
+void GameModel::SetBrush(int i)
+{
+	currentBrush = i%brushList.size();
+	notifyBrushChanged();
+}
+
+void GameModel::AddObserver(GameView * observer){
+	observers.push_back(observer);
+
+	observer->NotifySimulationChanged(this);
+	observer->NotifyRendererChanged(this);
+	observer->NotifyPausedChanged(this);
+	observer->NotifySaveChanged(this);
+	observer->NotifyBrushChanged(this);
+	observer->NotifyMenuListChanged(this);
+	observer->NotifyToolListChanged(this);
+	observer->NotifyUserChanged(this);
+	observer->NotifyZoomChanged(this);
+	observer->NotifyColourSelectorVisibilityChanged(this);
+	observer->NotifyColourSelectorColourChanged(this);
+	observer->NotifyColourPresetsChanged(this);
+	observer->NotifyColourActivePresetChanged(this);
+	observer->NotifyQuickOptionsChanged(this);
+	observer->NotifyLastToolChanged(this);
+	UpdateQuickOptions();
+}
+
+void GameModel::SetToolStrength(float value)
+{
+	toolStrength = value;
+}
+
+float GameModel::GetToolStrength()
+{
+	return toolStrength;
+}
+
+void GameModel::SetActiveMenu(Menu * menu)
+{
+	for(int i = 0; i < menuList.size(); i++)
+	{
+		if(menuList[i]==menu)
+		{
+			activeMenu = menu;
+			toolList = menu->GetToolList();
+			notifyToolListChanged();
+
+			if(menu == menuList[SC_DECO])
+			{
+				if(activeTools != decoToolset)
+				{
+					activeTools = decoToolset;
+					notifyActiveToolsChanged();
+				}
+			}
+			else
+			{
+				if(activeTools != regularToolset)
+				{
+					activeTools = regularToolset;
+					notifyActiveToolsChanged();
+				}
+			}
+		}
+	}
+}
+
+vector<Tool*> GameModel::GetUnlistedTools()
+{
+	return extraElementTools;
+}
+
+vector<Tool*> GameModel::GetToolList()
+{
+	return toolList;
+}
+
+Menu * GameModel::GetActiveMenu()
+{
+	return activeMenu;
+}
+
+Tool * GameModel::GetElementTool(int elementID)
+{
+	std::cout << elementID << std::endl;
+	for(std::vector<Tool*>::iterator iter = elementTools.begin(), end = elementTools.end(); iter != end; ++iter)
+	{
+		if((*iter)->GetToolID() == elementID)
+			return *iter;
+	}
+	return NULL;
+}
+
+Tool * GameModel::GetActiveTool(int selection)
+{
+	return activeTools[selection];
+}
+
+void GameModel::SetActiveTool(int selection, Tool * tool)
+{
+	activeTools[selection] = tool;
+	notifyActiveToolsChanged();
+}
+
+vector<QuickOption*> GameModel::GetQuickOptions()
+{
+	return quickOptions;
+}
+
+vector<Menu*> GameModel::GetMenuList()
+{
+	return menuList;
+}
+
+SaveInfo * GameModel::GetSave()
+{
+	return currentSave;
+}
+
+void GameModel::SetSave(SaveInfo * newSave)
+{
+	if(currentSave != newSave)
+	{
+		if(currentSave)
+			delete currentSave;
+		if(newSave == NULL)
+			currentSave = NULL;
+		else
+			currentSave = new SaveInfo(*newSave);
+	}
+	if(currentFile)
+		delete currentFile;
+	currentFile = NULL;
+
+	if(currentSave && currentSave->GetGameSave())
+	{
+		GameSave * saveData = currentSave->GetGameSave();
+		SetPaused(saveData->paused | GetPaused());
+		sim->gravityMode = saveData->gravityMode;
+		sim->air->airMode = saveData->airMode;
+		sim->legacy_enable = saveData->legacyEnable;
+		sim->water_equal_test = saveData->waterEEnabled;
+		if(saveData->gravityEnable)
+			sim->grav->start_grav_async();
+		else
+			sim->grav->stop_grav_async();
+		sim->SetEdgeMode(0);
+		sim->clear_sim();
+		ren->ClearAccumulation();
+		sim->Load(saveData);
+	}
+	notifySaveChanged();
+	UpdateQuickOptions();
+}
+
+SaveFile * GameModel::GetSaveFile()
+{
+	return currentFile;
+}
+
+void GameModel::SetSaveFile(SaveFile * newSave)
+{
+	if(currentFile != newSave)
+	{
+		if(currentFile)
+			delete currentFile;
+		if(newSave == NULL)
+			currentFile = NULL;
+		else
+			currentFile = new SaveFile(*newSave);
+	}
+	if (currentSave)
+		delete currentSave;
+	currentSave = NULL;
+
+	if(newSave && newSave->GetGameSave())
+	{
+		GameSave * saveData = newSave->GetGameSave();
+		SetPaused(saveData->paused | GetPaused());
+		sim->gravityMode = saveData->gravityMode;
+		sim->air->airMode = saveData->airMode;
+		sim->legacy_enable = saveData->legacyEnable;
+		sim->water_equal_test = saveData->waterEEnabled;
+		if(saveData->gravityEnable && !sim->grav->ngrav_enable)
+		{
+			sim->grav->start_grav_async();
+		}
+		else if(!saveData->gravityEnable && sim->grav->ngrav_enable)
+		{
+			sim->grav->stop_grav_async();
+		}
+		sim->SetEdgeMode(0);
+		sim->clear_sim();
+		ren->ClearAccumulation();
+		sim->Load(saveData);
+	}
+	
+	notifySaveChanged();
+	UpdateQuickOptions();
+}
+
+Simulation * GameModel::GetSimulation()
+{
+	return sim;
+}
+
+Renderer * GameModel::GetRenderer()
+{
+	return ren;
+}
+
+User GameModel::GetUser()
+{
+	return currentUser;
+}
+
+Tool * GameModel::GetLastTool()
+{
+	return lastTool;
+}
+
+void GameModel::SetLastTool(Tool * newTool)
+{
+	if(lastTool != newTool)
+	{
+		lastTool = newTool;
+		notifyLastToolChanged();
+	}
+}
+
+void GameModel::SetZoomEnabled(bool enabled)
+{
+	ren->zoomEnabled = enabled;
+	notifyZoomChanged();
+}
+
+bool GameModel::GetZoomEnabled()
+{
+	return ren->zoomEnabled;
+}
+
+void GameModel::SetZoomPosition(ui::Point position)
+{
+	ren->zoomScopePosition = position;
+	notifyZoomChanged();
+}
+
+ui::Point GameModel::GetZoomPosition()
+{
+	return ren->zoomScopePosition;
+}
+
+void GameModel::SetZoomWindowPosition(ui::Point position)
+{
+	ren->zoomWindowPosition = position;
+	notifyZoomChanged();
+}
+
+ui::Point GameModel::GetZoomWindowPosition()
+{
+	return ren->zoomWindowPosition;
+}
+
+void GameModel::SetZoomSize(int size)
+{
+	ren->zoomScopeSize = size;
+	notifyZoomChanged();
+}
+
+int GameModel::GetZoomSize()
+{
+	return ren->zoomScopeSize;
+}
+
+void GameModel::SetZoomFactor(int factor)
+{
+	ren->ZFACTOR = factor;
+	notifyZoomChanged();
+}
+
+int GameModel::GetZoomFactor()
+{
+	return ren->ZFACTOR;
+}
+
+void GameModel::SetActiveColourPreset(int preset)
+{
+	activeColourPreset = preset;
+	notifyColourActivePresetChanged();
+}
+
+int GameModel::GetActiveColourPreset()
+{
+	return activeColourPreset;
+}
+
+void GameModel::SetPresetColour(ui::Colour colour)
+{
+	if(activeColourPreset >= 0 && activeColourPreset < colourPresets.size())
+	{
+		colourPresets[activeColourPreset] = colour;
+		notifyColourPresetsChanged();
+	}
+}
+
+std::vector<ui::Colour> GameModel::GetColourPresets()
+{
+	return colourPresets;
+}
+
+void GameModel::SetColourSelectorVisibility(bool visibility)
+{
+	if(colourSelector != visibility)
+	{
+		colourSelector = visibility;
+		notifyColourSelectorVisibilityChanged();
+	}
+}
+
+bool GameModel::GetColourSelectorVisibility()
+{
+	return colourSelector;
+}
+
+void GameModel::SetColourSelectorColour(ui::Colour colour_)
+{
+	colour = colour_;
+	notifyColourSelectorColourChanged();
+
+	vector<Tool*> tools = GetMenuList()[SC_DECO]->GetToolList();
+	for(int i = 0; i < tools.size(); i++)
+	{
+		((DecorationTool*)tools[i])->Red = colour.Red;
+		((DecorationTool*)tools[i])->Green = colour.Green;
+		((DecorationTool*)tools[i])->Blue = colour.Blue;
+		((DecorationTool*)tools[i])->Alpha = colour.Alpha;
+	}
+}
+
+ui::Colour GameModel::GetColourSelectorColour()
+{
+	return colour;
+}
+
+void GameModel::SetUser(User user)
+{
+	currentUser = user;
+	//Client::Ref().SetAuthUser(user);
+	notifyUserChanged();
+}
+
+void GameModel::SetPaused(bool pauseState)
+{
+	sim->sys_pause = pauseState?1:0;
+	notifyPausedChanged();
+}
+
+bool GameModel::GetPaused()
+{
+	return sim->sys_pause?true:false;
+}
+
+void GameModel::SetDecoration(bool decorationState)
+{
+	ren->decorations_enable = decorationState?1:0;
+	notifyDecorationChanged();
+	UpdateQuickOptions();
+	if (decorationState)
+		SetInfoTip("Decorations Layer: On");
+	else
+		SetInfoTip("Decorations Layer: Off");
+}
+
+bool GameModel::GetDecoration()
+{
+	return ren->decorations_enable?true:false;
+}
+
+void GameModel::SetAHeatEnable(bool aHeat)
+{
+	sim->aheat_enable = aHeat;
+	UpdateQuickOptions();
+	if (aHeat)
+		SetInfoTip("Ambient Heat: On");
+	else
+		SetInfoTip("Ambient Heat: Off");
+}
+
+bool GameModel::GetAHeatEnable()
+{
+	return sim->aheat_enable;
+}
+
+void GameModel::ShowGravityGrid(bool showGrid)
+{
+	ren->gravityFieldEnabled = showGrid;
+	if (showGrid)
+		SetInfoTip("Gravity Grid: On");
+	else
+		SetInfoTip("Gravity Grid: Off");
+}
+
+bool GameModel::GetGravityGrid()
+{
+	return ren->gravityFieldEnabled;
+}
+
+void GameModel::FrameStep(int frames)
+{
+	sim->framerender += frames;
+}
+
+void GameModel::ClearSimulation()
+{
+	//Load defaults
+	sim->gravityMode = 0;
+	sim->air->airMode = 0;
+	sim->legacy_enable = false;
+	sim->water_equal_test = false;
+	sim->SetEdgeMode(edgeMode);
+
+	sim->clear_sim();
+	ren->ClearAccumulation();
+
+	notifySaveChanged();
+	UpdateQuickOptions();
+}
+
+void GameModel::SetStamp(GameSave * save)
+{
+	if(stamp != save)
+	{
+		if(stamp)
+			delete stamp;
+		if(save)
+			stamp = new GameSave(*save);
+		else
+			stamp = NULL;
+	}
+}
+
+void GameModel::SetPlaceSave(GameSave * save)
+{
+	if(save != placeSave)
+	{
+		if(placeSave)
+			delete placeSave;
+		if(save)
+			placeSave = new GameSave(*save);
+		else
+			placeSave = NULL;
+	}
+	notifyPlaceSaveChanged();
+}
+
+void GameModel::AddStamp(GameSave * save)
+{
+	if(stamp)
+		delete stamp;
+	stamp = save;
+	Client::Ref().AddStamp(save);
+}
+
+void GameModel::SetClipboard(GameSave * save)
+{
+	if(clipboard)
+		delete clipboard;
+	clipboard = save;
+}
+
+GameSave * GameModel::GetClipboard()
+{
+	return clipboard;
+}
+
+GameSave * GameModel::GetPlaceSave()
+{
+	return placeSave;
+}
+
+GameSave * GameModel::GetStamp()
+{
+	return stamp;
+}
+
+void GameModel::Log(string message)
+{
+	consoleLog.push_front(message);
+	if(consoleLog.size()>100)
+		consoleLog.pop_back();
+	notifyLogChanged(message);
+}
+
+deque<string> GameModel::GetLog()
+{
+	return consoleLog;
+}
+
+std::vector<Notification*> GameModel::GetNotifications()
+{
+	return notifications;
+}
+
+void GameModel::AddNotification(Notification * notification)
+{
+	notifications.push_back(notification);
+	notifyNotificationsChanged();
+}
+
+void GameModel::RemoveNotification(Notification * notification)
+{
+	for(std::vector<Notification*>::iterator iter = notifications.begin(); iter != notifications.end(); ++iter)
+	{
+		if(*iter == notification)
+		{
+			delete *iter;
+			notifications.erase(iter);
+			break;
+		}
+	}
+	notifyNotificationsChanged();
+}
+
+void GameModel::SetToolTip(std::string text)
+{
+	toolTip = text;
+	notifyToolTipChanged();
+}
+
+void GameModel::SetInfoTip(std::string text)
+{
+	infoTip = text;
+	notifyInfoTipChanged();
+}
+
+std::string GameModel::GetToolTip()
+{
+	return toolTip;
+}
+
+std::string GameModel::GetInfoTip()
+{
+	return infoTip;
+}
+
+void GameModel::notifyNotificationsChanged()
+{
+	for(std::vector<GameView*>::iterator iter = observers.begin(); iter != observers.end(); ++iter)
+	{
+		(*iter)->NotifyNotificationsChanged(this);
+	}
+}
+
+void GameModel::notifyColourPresetsChanged()
+{
+	for(std::vector<GameView*>::iterator iter = observers.begin(); iter != observers.end(); ++iter)
+	{
+		(*iter)->NotifyColourPresetsChanged(this);
+	}
+}
+
+void GameModel::notifyColourActivePresetChanged()
+{
+	for(std::vector<GameView*>::iterator iter = observers.begin(); iter != observers.end(); ++iter)
+	{
+		(*iter)->NotifyColourActivePresetChanged(this);
+	}
+}
+
+void GameModel::notifyColourSelectorColourChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyColourSelectorColourChanged(this);
+	}
+}
+
+void GameModel::notifyColourSelectorVisibilityChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyColourSelectorVisibilityChanged(this);
+	}
+}
+
+void GameModel::notifyRendererChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyRendererChanged(this);
+	}
+}
+
+void GameModel::notifySaveChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifySaveChanged(this);
+	}
+}
+
+void GameModel::notifySimulationChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifySimulationChanged(this);
+	}
+}
+
+void GameModel::notifyPausedChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyPausedChanged(this);
+	}
+}
+
+void GameModel::notifyDecorationChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		//observers[i]->NotifyPausedChanged(this);
+	}
+}
+
+void GameModel::notifyBrushChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyBrushChanged(this);
+	}
+}
+
+void GameModel::notifyMenuListChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyMenuListChanged(this);
+	}
+}
+
+void GameModel::notifyToolListChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyToolListChanged(this);
+	}
+}
+
+void GameModel::notifyActiveToolsChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyActiveToolsChanged(this);
+	}
+}
+
+void GameModel::notifyUserChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyUserChanged(this);
+	}
+}
+
+void GameModel::notifyZoomChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyZoomChanged(this);
+	}
+}
+
+void GameModel::notifyPlaceSaveChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyPlaceSaveChanged(this);
+	}
+}
+
+void GameModel::notifyLogChanged(string entry)
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyLogChanged(this, entry);
+	}
+}
+
+void GameModel::notifyInfoTipChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyInfoTipChanged(this);
+	}
+}
+
+void GameModel::notifyToolTipChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyToolTipChanged(this);
+	}
+}
+
+void GameModel::notifyQuickOptionsChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyQuickOptionsChanged(this);
+	}
+}
+
+void GameModel::notifyLastToolChanged()
+{
+	for(int i = 0; i < observers.size(); i++)
+	{
+		observers[i]->NotifyLastToolChanged(this);
+	}
+}