No OneTemporary
Actions

Authored By

Unknown

Size

267 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/Commands.cpp b/src/Commands.cpp
	index 77b234c..617c9c7 100644
	--- a/src/Commands.cpp
	+++ b/src/Commands.cpp
	@@ -1,1007 +1,1011 @@
	/*
	* Copyright (C) 2018 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me And My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	// An undo/redo system based on <http://www.codeproject.com/Articles/2500/A-Basic-Undo-Redo-Framework-For-C>.
	// Originally written by squarecross <https://forum.freegamedev.net/viewtopic.php?f=48&t=5432>.

	#include "Commands.h"
	#include "GameObjects.h"
	#include "Block.h"
	#include "LevelEditor.h"
	#include "Globals.h"
	#include "Functions.h"

	#include <algorithm>
	#include <string>
	#include <vector>
	#include <map>

	#include <stdio.h>

	#include "libs/tinyformat/tinyformat.h"

	Command::~Command() {

	}

	//////////////////////////////MoveGameObjectCommand///////////////////////////////////
	MoveGameObjectCommand::MoveGameObjectCommand(LevelEditor* levelEditor, GameObject* gameObject, int x, int y, int w, int h)
	: editor(levelEditor), objects(1, gameObject)
	, resizeCommand(NULL)
	{
	SDL_Rect r = gameObject->getBox();
	r.x = x;
	r.y = y;
	if (w >= 0) r.w = w;
	if (h >= 0) r.h = h;

	newPosition.push_back(r);

	init();
	}

	MoveGameObjectCommand::MoveGameObjectCommand(LevelEditor* levelEditor, std::vector<GameObject*>& gameObjects, int dx, int dy)
	: editor(levelEditor), objects(gameObjects)
	, resizeCommand(NULL)
	{
	for (auto obj : objects) {
	SDL_Rect r = obj->getBox();
	r.x += dx;
	r.y += dy;
	newPosition.push_back(r);
	}

	init();
	}

	void MoveGameObjectCommand::init() {
	//Initialize old position.
	for (auto obj : objects) {
	SDL_Rect r = obj->getBox();
	oldPosition.push_back(r);
	}

	// Create resize command if necessary.
	resizeCommand = ResizeLevelCommand::createAndShiftIfNecessary(editor, newPosition);
	}

	MoveGameObjectCommand::~MoveGameObjectCommand(){
	if (resizeCommand) delete resizeCommand;
	}

	void MoveGameObjectCommand::execute(){
	// First resize the level if necessary.
	if (resizeCommand) resizeCommand->execute();

	// Set the obj at its new position.
	for (int i = 0; i < (int)objects.size(); i++) {
	const SDL_Rect &r = newPosition[i];
	GameObject *obj = objects[i];
	obj->setBaseLocation(r.x, r.y);
	obj->setBaseSize(r.w, r.h);
	}
	}

	void MoveGameObjectCommand::unexecute() {
	// First undo the resize if necessary.
	if (resizeCommand) resizeCommand->unexecute();

	// Set the obj at its old position.
	for (int i = 0; i < (int)objects.size(); i++) {
	const SDL_Rect &r = oldPosition[i];
	GameObject *obj = objects[i];
	obj->setBaseLocation(r.x, r.y);
	obj->setBaseSize(r.w, r.h);
	}
	}

	ResizeLevelCommand::ResizeLevelCommand(LevelEditor* levelEditor, int newWidth, int newHeight, int diffx, int diffy)
	: editor(levelEditor), newLevelWidth(newWidth), newLevelHeight(newHeight), diffx(diffx), diffy(diffy)
	{
	oldLevelWidth = LEVEL_WIDTH;
	oldLevelHeight = LEVEL_HEIGHT;
	}

	ResizeLevelCommand::~ResizeLevelCommand() {
	}

	void ResizeLevelCommand::execute() {
	resizeLevel(editor, newLevelWidth, newLevelHeight, diffx, diffy);
	}

	void ResizeLevelCommand::unexecute() {
	resizeLevel(editor, oldLevelWidth, oldLevelHeight, -diffx, -diffy);
	}

	void ResizeLevelCommand::resizeLevel(LevelEditor* levelEditor, int newWidth, int newHeight, int diffx, int diffy) {
	LEVEL_WIDTH = newWidth;
	LEVEL_HEIGHT = newHeight;

	if (diffx != 0 \|\| diffy != 0) {
	camera.x += diffx;
	camera.y += diffy;

	for (unsigned int o = 0; o < levelEditor->levelObjects.size(); o++){
	SDL_Rect r = levelEditor->levelObjects[o]->getBox();
	levelEditor->levelObjects[o]->setBaseLocation(r.x + diffx, r.y + diffy);
	}
	for (auto it = levelEditor->sceneryLayers.begin(); it != levelEditor->sceneryLayers.end(); ++it) {
	- for (unsigned int o = 0; o < it->second.size(); o++){
	- SDL_Rect r = it->second[o]->getBox();
	- it->second[o]->setBaseLocation(r.x + diffx, r.y + diffy);
	+ for (auto o : it->second->objects){
	+ SDL_Rect r = o->getBox();
	+ o->setBaseLocation(r.x + diffx, r.y + diffy);
	}
	}
	}
	}

	ResizeLevelCommand* ResizeLevelCommand::createAndShiftIfNecessary(LevelEditor* levelEditor, std::vector<SDL_Rect>& position) {
	// Calculate new level size, shift, etc.
	int newLevelWidth = LEVEL_WIDTH;
	int newLevelHeight = LEVEL_HEIGHT;
	int diffx = 0, diffy = 0;

	for (int i = 0; i < (int)position.size(); i++) {
	const SDL_Rect &r = position[i];
	if (r.x + r.w > newLevelWidth) {
	newLevelWidth = r.x + r.w;
	}
	if (r.y + r.h > newLevelHeight) {
	newLevelHeight = r.y + r.h;
	}
	if (r.x + diffx < 0) diffx = -r.x;
	if (r.y + diffy < 0) diffy = -r.y;
	}

	newLevelWidth += diffx;
	newLevelHeight += diffy;

	if (newLevelWidth != LEVEL_WIDTH \|\| newLevelHeight != LEVEL_HEIGHT \|\| diffx \|\| diffy) {
	if (diffx \|\| diffy) {
	for (int i = 0; i < (int)position.size(); i++) {
	SDL_Rect &r = position[i];
	r.x += diffx;
	r.y += diffy;
	}
	}
	return new ResizeLevelCommand(levelEditor, newLevelWidth, newLevelHeight, diffx, diffy);
	} else {
	return NULL;
	}
	}

	std::string ResizeLevelCommand::describe() {
	return _("Resize level");
	}

	//////////////////////////////AddRemoveGameObjectCommand///////////////////////////////////
	AddRemoveGameObjectCommand::AddRemoveGameObjectCommand(LevelEditor* levelEditor, GameObject* gameObject, bool isAdd_)
	: editor(levelEditor), objects(1, gameObject), isAdd(isAdd_), ownObject(isAdd_)
	, resizeCommand(NULL), removeStartCommand(NULL), oldTriggers(NULL)
	{
	init();
	}

	AddRemoveGameObjectCommand::AddRemoveGameObjectCommand(LevelEditor* levelEditor, std::vector<GameObject*>& gameObjects, bool isAdd_)
	: editor(levelEditor), objects(gameObjects), isAdd(isAdd_), ownObject(isAdd_)
	, resizeCommand(NULL), removeStartCommand(NULL), oldTriggers(NULL)
	{
	init();
	}

	void AddRemoveGameObjectCommand::init() {
	if (isAdd) {
	theLayer = editor->selectedLayer;

	// adjust the object position if necessary
	std::vector<SDL_Rect> position;
	for (auto obj : objects) {
	position.push_back(obj->getBox());
	}
	resizeCommand = ResizeLevelCommand::createAndShiftIfNecessary(editor, position);
	if (resizeCommand) {
	for (int i = 0; i < (int)objects.size(); i++) {
	const SDL_Rect &r = position[i];
	objects[i]->setBaseLocation(r.x, r.y);
	}
	}

	// remove the existing player/shadow start if necessary
	std::vector<bool> typesToBeRemoved((int)TYPE_MAX, false);
	bool removeSomething = false;
	for (auto obj : objects) {
	if (obj->type == TYPE_START_PLAYER \|\| obj->type == TYPE_START_SHADOW) {
	typesToBeRemoved[obj->type] = true;
	removeSomething = true;
	}
	}
	if (removeSomething) {
	std::vector<GameObject*> objectsToBeRemoved;
	for (auto obj : editor->levelObjects) {
	if (typesToBeRemoved[obj->type]) objectsToBeRemoved.push_back(obj);
	}
	if (!objectsToBeRemoved.empty()) {
	removeStartCommand = new AddRemoveGameObjectCommand(editor, objectsToBeRemoved, false);
	}
	}
	}
	}

	void AddRemoveGameObjectCommand::backupTriggers() {
	if (oldTriggers == NULL) oldTriggers = new LevelEditor::Triggers(editor->triggers);
	}

	AddRemoveGameObjectCommand::~AddRemoveGameObjectCommand(){
	//Remove the objects if we own them.
	if (ownObject) {
	for (auto obj : objects) {
	delete obj;
	}
	}

	//Delete internal commands.
	if (resizeCommand) delete resizeCommand;
	if (removeStartCommand) delete removeStartCommand;

	//Delete old triggers
	if (oldTriggers) delete oldTriggers;
	}

	void AddRemoveGameObjectCommand::addGameObject(){
	// some sanity check
	assert(ownObject);

	// Remove old start position if necessary.
	if (removeStartCommand) removeStartCommand->execute();

	// Resize the level if necessary.
	if (resizeCommand) resizeCommand->execute();

	// Add each object to level
	for (int index = 0; index < (int)objects.size(); index++) {
	GameObject *obj = objects[index];

	//Increase totalCollectables everytime we add a new collectable
	if (obj->type == TYPE_COLLECTABLE) {
	editor->totalCollectables++;
	}

	Block* block = dynamic_cast<Block*>(obj);
	Scenery* scenery = dynamic_cast<Scenery*>(obj);

	//Add it to the levelObjects.
	if (theLayer.empty()) {
	assert(block != NULL);
	editor->levelObjects.push_back(block);
	} else {
	assert(scenery != NULL);
	- editor->sceneryLayers[theLayer].push_back(scenery);
	+ auto it = editor->sceneryLayers.find(theLayer);
	+ assert(it != editor->sceneryLayers.end());
	+ it->second->objects.push_back(scenery);
	}

	//GameObject type specific stuff.
	switch (obj->type){
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	case TYPE_PORTAL:
	{
	//If block doesn't have an id (new object).
	if (block->getEditorProperty("id").empty()) {
	//Give it it's own id.
	char s[64];
	sprintf(s, "%u", editor->currentId);
	editor->currentId++;
	block->setEditorProperty("id", s);
	}

	break;
	}
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//Add the object to the moving blocks.
	vector<MovingPosition> positions;
	editor->movingBlocks[block] = positions;

	//Get the moving position.
	const vector<SDL_Rect> &movingPos = block->movingPos;

	//Add the object to the movingBlocks vector.
	editor->movingBlocks[block].clear();

	for (int i = 0, m = movingPos.size(); i < m; i++) {
	MovingPosition position(movingPos[i].x, movingPos[i].y, movingPos[i].w);
	editor->movingBlocks[block].push_back(position);
	}

	//If block doesn't have an id.
	if (block->getEditorProperty("id").empty()) {
	//Give it it's own id.
	char s[64];
	sprintf(s, "%u", editor->currentId);
	editor->currentId++;
	block->setEditorProperty("id", s);
	}

	break;
	}
	default:
	break;
	}
	}

	// now we doesn't own the object anymore.
	ownObject = false;
	}

	void AddRemoveGameObjectCommand::removeGameObject(){
	// some sanity check
	assert(!ownObject);

	//Make sure we don't access the removed object through
	//moving/linking.
	editor->movingBlock = nullptr;
	editor->linkingTrigger = nullptr;
	editor->moving = false;
	editor->linking = false;

	// Remove objects
	for (int index = 0; index < (int)objects.size(); index++) {
	GameObject *obj = objects[index];

	std::vector<GameObject*>::iterator it;
	std::map<Block, vector<GameObject> >::iterator mapIt;

	//Decrease totalCollectables everytime we remove a collectable
	if (obj->type == TYPE_COLLECTABLE){
	editor->totalCollectables--;
	}

	//Check if the object is in the selection.
	it = find(editor->selection.begin(), editor->selection.end(), obj);
	if (it != editor->selection.end()){
	//It is so we delete it.
	editor->selection.erase(it);
	}

	Block theBlock = dynamic_cast<Block>(obj);
	Scenery theScenery = dynamic_cast<Scenery>(obj);

	//Check if the object is in the triggers.
	if (theBlock) {
	mapIt = editor->triggers.find(theBlock);
	if (mapIt != editor->triggers.end()){
	//Back up triggers if it's remove mode.
	if (!isAdd) backupTriggers();

	//Remove the object from triggers.
	editor->triggers.erase(mapIt);
	}
	}

	//Boolean if it could be a target.
	if (obj->type == TYPE_MOVING_BLOCK \|\| obj->type == TYPE_MOVING_SHADOW_BLOCK \|\| obj->type == TYPE_MOVING_SPIKES
	\|\| obj->type == TYPE_CONVEYOR_BELT \|\| obj->type == TYPE_SHADOW_CONVEYOR_BELT \|\| obj->type == TYPE_PORTAL)
	{
	for (mapIt = editor->triggers.begin(); mapIt != editor->triggers.end(); ++mapIt){
	//Now loop the target vector.
	for (int o = mapIt->second.size() - 1; o >= 0; o--){
	//Check if the obj is in the target vector.
	if (mapIt->second[o] == obj){
	//Back up triggers if it's remove mode.
	if (!isAdd) backupTriggers();

	//Remove the object from triggers.
	mapIt->second.erase(mapIt->second.begin() + o);
	}
	}
	}
	}

	//Check if the object is in the movingObjects.
	if (theBlock) {
	std::map<Block*, vector<MovingPosition> >::iterator movIt;
	movIt = editor->movingBlocks.find(theBlock);
	if (movIt != editor->movingBlocks.end()){
	//It is so we remove it.
	editor->movingBlocks.erase(movIt);
	}
	}

	//Check if the block isn't being configured with a window one way or another.
	for (;;) {
	std::map<GUIObject, GameObject>::iterator confIt;
	for (confIt = editor->objectWindows.begin(); confIt != editor->objectWindows.end(); ++confIt){
	if (confIt->second == obj) break;
	}
	if (confIt == editor->objectWindows.end()) break;
	editor->destroyWindow(confIt->first);
	}

	//Now we remove the object from the levelObjects and/or scenery.
	if (theBlock){
	std::vector<Block*>::iterator it;
	it = find(editor->levelObjects.begin(), editor->levelObjects.end(), theBlock);
	if (it != editor->levelObjects.end()){
	editor->levelObjects.erase(it);
	theLayer.clear(); // record the layer of this object
	}
	} else if (theScenery) {
	for (auto it = editor->sceneryLayers.begin(); it != editor->sceneryLayers.end(); ++it){
	- auto it2 = find(it->second.begin(), it->second.end(), theScenery);
	- if (it2 != it->second.end()) {
	- it->second.erase(it2);
	+ auto it2 = find(it->second->objects.begin(), it->second->objects.end(), theScenery);
	+ if (it2 != it->second->objects.end()) {
	+ it->second->objects.erase(it2);
	theLayer = it->first; // record the layer of this object
	break;
	}
	}
	}
	}

	// Resize the level if necessary.
	if (resizeCommand) resizeCommand->unexecute();

	// Restore old start position if necessary.
	if (removeStartCommand) removeStartCommand->unexecute();

	// now we own this object
	ownObject = true;

	//Set dirty of selection popup
	editor->selectionDirty();
	}

	void AddRemoveGameObjectCommand::execute(){
	if (isAdd) {
	addGameObject();
	} else {
	removeGameObject();
	}
	}

	void AddRemoveGameObjectCommand::unexecute(){
	if (isAdd) {
	removeGameObject();
	} else {
	addGameObject();
	}

	// Restore old triggers if necessary
	if (oldTriggers) editor->triggers = *oldTriggers;
	}

	//////////////////////////////AddRemovePathCommand///////////////////////////////////
	AddRemovePathCommand::AddRemovePathCommand(LevelEditor* levelEditor, Block* movingBlock, MovingPosition movingPosition, bool isAdd_)
	:editor(levelEditor), target(movingBlock), movePos(movingPosition), isAdd(isAdd_)
	{
	if (!isAdd) {
	if (target->movingPos.empty()) {
	assert(!"movingBlock->movingPos is empty!");
	} else {
	const SDL_Rect& r = target->movingPos.back();
	movePos.x = r.x;
	movePos.y = r.y;
	movePos.time = r.w;
	}
	}
	}

	AddRemovePathCommand::~AddRemovePathCommand(){
	}

	void AddRemovePathCommand::execute(){
	if (isAdd) addPath();
	else removePath();
	}

	void AddRemovePathCommand::unexecute(){
	if (isAdd) removePath();
	else addPath();
	}

	void AddRemovePathCommand::addPath() {
	//Add movePos to the path.
	editor->movingBlocks[target].push_back(movePos);

	//Write the path to the moving block.
	setEditorData();
	}

	void AddRemovePathCommand::removePath() {
	//Remove the last point in the path.
	editor->movingBlocks[target].pop_back();

	//Write the path to the moving block.
	setEditorData();
	}

	void AddRemovePathCommand::setEditorData() {
	target->movingPos.clear();

	for (const MovingPosition& p : editor->movingBlocks[target]) {
	SDL_Rect r = { p.x, p.y, p.time };
	target->movingPos.push_back(r);
	}
	}

	//////////////////////////////RemovePathCommand///////////////////////////////////
	RemovePathCommand::RemovePathCommand(LevelEditor* levelEditor, Block* targetBlock)
	:editor(levelEditor), target(targetBlock){
	}

	RemovePathCommand::~RemovePathCommand(){
	}

	void RemovePathCommand::execute(){
	//Set the number of movingPositions to 0.
	target->setEditorProperty("MovingPosCount","0");

	std::map<Block*,vector<MovingPosition> >::iterator it;
	//Check if target is in movingBlocks.
	it = editor->movingBlocks.find(target);
	if(it!=editor->movingBlocks.end()){
	//Store the movingPositions for unexecute.
	movePositions = it->second;

	//Clear all its movingPositions
	it->second.clear();
	}
	}

	void RemovePathCommand::unexecute(){
	std::map<Block*,vector<MovingPosition> >::iterator it;
	//Find target in movingBlocks
	it = editor->movingBlocks.find(target);

	if(it!=editor->movingBlocks.end()){
	//Restore its movingPositions
	it->second = movePositions;

	//Write the path to the moving block.
	std::map<std::string,std::string> editorData;
	char s[64], s0[64];

	sprintf(s,"%d",int(editor->movingBlocks[target].size()));
	editorData["MovingPosCount"]=s;
	//Loop through the positions.
	for(unsigned int o=0; o<editor->movingBlocks[target].size(); o++) {
	sprintf(s0+1,"%u",o);
	sprintf(s,"%d",editor->movingBlocks[target][o].x);
	s0[0]='x';
	editorData[s0]=s;
	sprintf(s,"%d",editor->movingBlocks[target][o].y);
	s0[0]='y';
	editorData[s0]=s;
	sprintf(s,"%d",editor->movingBlocks[target][o].time);
	s0[0]='t';
	editorData[s0]=s;
	}
	target->setEditorData(editorData);
	}

	}

	//////////////////////////////AddLinkCommand///////////////////////////////////
	AddLinkCommand::AddLinkCommand(LevelEditor* levelEditor, Block* linkingTrigger, GameObject* clickedObject)
	:editor(levelEditor), target(linkingTrigger), clickedObj(clickedObject),oldPortalLink(NULL), destination(""), id(""){
	}

	AddLinkCommand::~AddLinkCommand(){
	}

	void AddLinkCommand::execute(){
	//Check if the target can handle multiple or only one link.
	switch(target->type) {
	case TYPE_PORTAL: {
	//Store the last portal link.
	if(!editor->triggers[target].empty()){
	oldPortalLink = editor->triggers[target].back();
	}

	//Portals can only link to one so remove all existing links.
	editor->triggers[target].clear();

	editor->triggers[target].push_back(clickedObj);
	break;
	}
	default: {
	//The others can handle multiple links.
	editor->triggers[target].push_back(clickedObj);
	break;
	}
	}

	//Check if it's a portal.
	if(target->type==TYPE_PORTAL) {
	//Store the previous destination.
	destination = target->getEditorProperty("destination");

	//Portals need to get the id of the other instead of give it's own id.
	char s[64];
	sprintf(s,"%d",atoi(clickedObj->getEditorProperty("id").c_str()));
	target->setEditorProperty("destination",s);
	} else{
	//Store the previous id.
	id = clickedObj->getEditorProperty("id");

	//Give the clickedObject the same id as the trigger.
	char s[64];
	sprintf(s,"%d",atoi(target->getEditorProperty("id").c_str()));
	clickedObj->setEditorProperty("id",s);
	}
	}

	void AddLinkCommand::unexecute(){
	//Check if the target can handle multiple or only one link.
	switch(target->type) {
	case TYPE_PORTAL: {
	//Portals can only link to one so remove all existing links.
	editor->triggers[target].clear();

	//Put the previous portal link back.
	if(oldPortalLink != NULL)
	editor->triggers[target].push_back(oldPortalLink);

	break;
	}
	default:{
	std::vector<GameObject*>::iterator it;
	//Find the clickedObj in the target's triggers.
	it = std::find(editor->triggers[target].begin(), editor->triggers[target].end(), clickedObj);
	if(it != editor->triggers[target].end()){
	//Remove it.
	editor->triggers[target].erase(it);
	}
	break;
	}
	}

	//Check if it's a portal.
	if(target->type==TYPE_PORTAL) {
	//Restore previous destination.
	target->setEditorProperty("destination",destination);
	} else{
	//Restore clickedObj's previous id.
	clickedObj->setEditorProperty("id",id);
	}
	}

	//////////////////////////////RemoveLinkCommand///////////////////////////////////
	RemoveLinkCommand::RemoveLinkCommand(LevelEditor* levelEditor, Block* targetBlock)
	: editor(levelEditor), target(targetBlock), destination(""), id(""){
	}

	RemoveLinkCommand::~RemoveLinkCommand(){
	}

	void RemoveLinkCommand::execute(){
	std::map<Block,vector<GameObject> >::iterator it;
	//Find target in triggers.
	it = editor->triggers.find(target);
	if(it!=editor->triggers.end()) {
	//Copy the objects the target was linked to.
	links = it->second;

	//Remove the links.
	it->second.clear();
	}

	//In case of a portal remove its destination field.
	if(target->type==TYPE_PORTAL) {
	//Copy its previous destination.
	destination = target->getEditorProperty("destination");

	//Erase its destination.
	target->setEditorProperty("destination","");
	} else{
	//Copy its previous id.
	id = target->getEditorProperty("id");

	//Give the trigger a new id to prevent activating unlinked targets.
	char s[64];
	sprintf(s,"%u",editor->currentId);
	editor->currentId++;
	target->setEditorProperty("id",s);
	}
	}

	void RemoveLinkCommand::unexecute(){
	std::map<Block,vector<GameObject> >::iterator it;
	//Find target in triggers.
	it = editor->triggers.find(target);
	if(it!=editor->triggers.end()) {
	//Restore objects it was linked to.
	it->second = links;
	}

	if(target->type== TYPE_PORTAL){
	//Restore old destination.
	target->setEditorProperty("destination", destination);
	} else{
	//Restore old id.
	target->setEditorProperty("id", id);
	}
	}

	SetEditorPropertyCommand::SetEditorPropertyCommand(LevelEditor* levelEditor, ImageManager& imageManager, SDL_Renderer& renderer, GameObject* targetBlock,
	const std::string& propertyName, const std::string& propertyValue, const std::string& propertyDescription)
	: editor(levelEditor), imageManager(imageManager), renderer(renderer)
	, target(targetBlock), prop(propertyName), newValue(propertyValue), desc(propertyDescription)
	{
	oldValue = target->getEditorProperty(prop);
	}

	SetEditorPropertyCommand::~SetEditorPropertyCommand() {
	}

	void SetEditorPropertyCommand::execute() {
	target->setEditorProperty(prop, newValue);
	updateCustomScenery();
	}

	void SetEditorPropertyCommand::unexecute() {
	target->setEditorProperty(prop, oldValue);
	updateCustomScenery();
	}

	void SetEditorPropertyCommand::updateCustomScenery() {
	Scenery scenery = dynamic_cast<Scenery>(target);
	if (target && prop == "customScenery") {
	scenery->updateCustomScenery(imageManager, renderer);
	}
	}

	SetLevelPropertyCommand::~SetLevelPropertyCommand() {
	}

	void SetLevelPropertyCommand::execute() {
	setLevelProperty(newProperty);
	}

	void SetLevelPropertyCommand::unexecute() {
	setLevelProperty(oldProperty);
	}

	std::string SetLevelPropertyCommand::describe() {
	return _("Modify level property");
	}

	SetScriptCommand::SetScriptCommand(LevelEditor* levelEditor, Block* targetBlock, const std::map<int, std::string>& script, const std::string& id)
	: editor(levelEditor), target(targetBlock), newScript(script), id(id)
	{
	if (target) {
	oldScript = target->scripts;
	oldId = target->id;
	} else {
	oldScript = editor->scripts;
	}
	}

	SetScriptCommand::~SetScriptCommand() {
	}

	void SetScriptCommand::execute() {
	setScript(newScript, id);
	}

	void SetScriptCommand::unexecute() {
	setScript(oldScript, oldId);
	}

	void SetScriptCommand::setScript(const std::map<int, std::string>& script, const std::string& id) {
	if (target) {
	target->scripts = script;

	//Set the new id for the target block.
	//TODO: Check for trigger links etc...
	target->id = id;
	} else {
	editor->scripts = script;
	}
	}

	AddRemoveLayerCommand::AddRemoveLayerCommand(LevelEditor* levelEditor, const std::string& layerName, bool isAdd_)
	- : editor(levelEditor), theLayer(layerName), isAdd(isAdd_), ownObject(isAdd_)
	+ : editor(levelEditor), layer(NULL), theLayer(layerName), isAdd(isAdd_), ownObject(isAdd_)
	{
	- if (!isAdd) {
	+ if (isAdd) {
	+ layer = new SceneryLayer;
	+ } else {
	auto it = editor->sceneryLayers.find(theLayer);
	if (it != editor->sceneryLayers.end()) {
	- objects = it->second;
	+ layer = it->second;
	}
	}
	}

	void AddRemoveLayerCommand::execute() {
	if (isAdd) {
	addLayer();
	} else {
	removeLayer();
	}
	}

	void AddRemoveLayerCommand::unexecute() {
	if (isAdd) {
	removeLayer();
	} else {
	addLayer();
	}
	}

	void AddRemoveLayerCommand::addLayer() {
	- assert(ownObject);
	+ assert(ownObject && layer);
	assert(editor->sceneryLayers.find(theLayer) == editor->sceneryLayers.end());

	// add this layer
	- editor->sceneryLayers[theLayer] = objects;
	+ editor->sceneryLayers[theLayer] = layer;

	// show and select the newly created layer
	editor->layerVisibility[theLayer] = true;
	editor->selectedLayer = theLayer;

	// deselect all
	editor->deselectAll();

	// change the ownership
	ownObject = false;
	}

	void AddRemoveLayerCommand::removeLayer() {
	assert(!ownObject);
	+ assert(editor->sceneryLayers.find(theLayer) != editor->sceneryLayers.end());
	+ assert(editor->sceneryLayers.find(theLayer)->second == layer);

	// deselect all
	editor->deselectAll();

	// select the Blocks layer
	editor->selectedLayer.clear();

	// remove this layer
	editor->layerVisibility.erase(theLayer);
	editor->sceneryLayers.erase(theLayer);

	// change the ownership
	ownObject = true;
	}

	AddRemoveLayerCommand::~AddRemoveLayerCommand() {
	if (ownObject) {
	- for (auto obj : objects) {
	- delete obj;
	- }
	+ delete layer;
	}
	}

	std::string AddRemoveLayerCommand::describe() {
	return tfm::format(isAdd ? _("Add scenery layer %s") : _("Delete scenery layer %s"), theLayer);
	}

	RenameLayerCommand::RenameLayerCommand(LevelEditor* levelEditor, const std::string& oldName, const std::string& newName)
	: editor(levelEditor), oldName(oldName), newName(newName)
	{
	}

	void RenameLayerCommand::execute() {
	rename(oldName, newName);
	}

	void RenameLayerCommand::unexecute() {
	rename(newName, oldName);
	}

	RenameLayerCommand::~RenameLayerCommand() {
	}

	std::string RenameLayerCommand::describe() {
	return tfm::format(_("Rename scenery layer %s to %s"), oldName, newName);
	}

	void RenameLayerCommand::rename(const std::string& oldName, const std::string& newName) {
	assert(editor->sceneryLayers.find(oldName) != editor->sceneryLayers.end() && editor->sceneryLayers.find(newName) == editor->sceneryLayers.end());

	// create a temp variable, save the old layer to it, remove the old layer
	- std::vector<Scenery*> tmp;
	- std::swap(editor->sceneryLayers[oldName], tmp);
	+ SceneryLayer *tmp;
	+ tmp = editor->sceneryLayers[oldName];
	+ assert(tmp != NULL);
	editor->sceneryLayers.erase(oldName);

	// then save the temp variable to the new layer
	- std::swap(editor->sceneryLayers[newName], tmp);
	-
	- // sanity check
	- assert(tmp.empty());
	+ editor->sceneryLayers[newName] = tmp;

	// show and select the newly created layer
	editor->layerVisibility[newName] = editor->layerVisibility[oldName];
	editor->layerVisibility.erase(oldName);
	editor->selectedLayer = newName;
	}

	MoveToLayerCommand::MoveToLayerCommand(LevelEditor* levelEditor, std::vector<GameObject*>& gameObjects, const std::string& oldName, const std::string& newName)
	- : editor(levelEditor), oldName(oldName), newName(newName), createNewLayer(false)
	+ : editor(levelEditor), oldName(oldName), newName(newName), createNewLayer(NULL)
	{
	- if (editor->sceneryLayers.find(newName) == editor->sceneryLayers.end()) createNewLayer = true;
	+ if (editor->sceneryLayers.find(newName) == editor->sceneryLayers.end()) {
	+ createNewLayer = new AddRemoveLayerCommand(levelEditor, newName, true);
	+ }
	for (auto obj : gameObjects) {
	Scenery scenery = dynamic_cast<Scenery>(obj);
	if (scenery) objects.push_back(scenery);
	}
	}

	void MoveToLayerCommand::execute() {
	+ if (createNewLayer) {
	+ createNewLayer->execute();
	+ }
	+
	removeGameObject();
	addGameObject(newName);

	// show and select the new layer
	editor->layerVisibility[newName] = true;
	editor->selectedLayer = newName;

	// deselect all
	editor->deselectAll();
	}

	void MoveToLayerCommand::unexecute() {
	removeGameObject();
	addGameObject(oldName);

	if (createNewLayer) {
	- auto it = editor->sceneryLayers.find(newName);
	- if (it != editor->sceneryLayers.end()) {
	- assert(it->second.empty());
	-
	- // remove this layer
	- editor->layerVisibility.erase(newName);
	- editor->sceneryLayers.erase(newName);
	- }
	+ createNewLayer->unexecute();
	}

	// show and select the old layer
	editor->layerVisibility[oldName] = true;
	editor->selectedLayer = oldName;

	// deselect all
	editor->deselectAll();
	}

	MoveToLayerCommand::~MoveToLayerCommand() {
	+ if (createNewLayer) {
	+ delete createNewLayer;
	+ }
	}

	std::string MoveToLayerCommand::describe() {
	return tfm::format(_("Move %d object(s) from layer %s to layer %s"), objects.size(), oldName, newName);
	}

	void MoveToLayerCommand::removeGameObject() {
	// Remove objects
	for (int index = 0; index < (int)objects.size(); index++) {
	Scenery *scenery = objects[index];

	//Now we remove the object from scenery.
	for (auto it = editor->sceneryLayers.begin(); it != editor->sceneryLayers.end(); ++it){
	- auto it2 = find(it->second.begin(), it->second.end(), scenery);
	- if (it2 != it->second.end()) {
	- it->second.erase(it2);
	+ auto it2 = find(it->second->objects.begin(), it->second->objects.end(), scenery);
	+ if (it2 != it->second->objects.end()) {
	+ it->second->objects.erase(it2);
	break;
	}
	}
	}
	}

	void MoveToLayerCommand::addGameObject(const std::string& layer) {
	// Add objects
	- std::vector<Scenery*> &target = editor->sceneryLayers[layer];
	+ const auto& target = editor->sceneryLayers[layer];
	for (int index = 0; index < (int)objects.size(); index++) {
	- target.push_back(objects[index]);
	+ target->objects.push_back(objects[index]);
	}
	}

	diff --git a/src/Commands.h b/src/Commands.h
	index 94e3843..785c080 100644
	--- a/src/Commands.h
	+++ b/src/Commands.h
	@@ -1,489 +1,489 @@
	/*
	* Copyright (C) 2018 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me And My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	// An undo/redo system based on <http://www.codeproject.com/Articles/2500/A-Basic-Undo-Redo-Framework-For-C>.
	// Originally written by squarecross <https://forum.freegamedev.net/viewtopic.php?f=48&t=5432>.

	#ifndef COMMANDS_H
	#define COMMANDS_H

	#include "LevelEditor.h"

	#include <vector>
	#include <string>
	#include <map>

	class Block;
	class GameObject;
	class LevelEditor;
	class MovingPosition;

	// Abstract class for commands.
	class Command {
	public:
	// Do the command.
	virtual void execute() = 0;

	// Undo the command.
	virtual void unexecute() = 0;

	// The short description to the command.
	virtual std::string describe() = 0;

	// Deconstructor for derived classes.
	virtual ~Command();
	};

	//Class for resize level.
	class ResizeLevelCommand : public Command {
	private:
	LevelEditor* editor;

	//New level size.
	int newLevelWidth, newLevelHeight;

	//Differences used for map dimension changes to shift position of other objects.
	int diffx, diffy;

	//Old level size.
	int oldLevelWidth, oldLevelHeight;

	public:
	ResizeLevelCommand(LevelEditor* levelEditor, int newWidth, int newHeight, int diffx, int diffy);
	virtual ~ResizeLevelCommand();

	virtual void execute();

	virtual void unexecute();

	static void resizeLevel(LevelEditor* levelEditor, int newWidth, int newHeight, int diffx, int diffy);

	// create a ResizeLevelCommand and shift the input position if any of them is outside the map area
	static ResizeLevelCommand* createAndShiftIfNecessary(LevelEditor* levelEditor, std::vector<SDL_Rect>& position);

	virtual std::string describe();
	};

	//Class for moving game objects.
	class MoveGameObjectCommand: public Command{
	private:
	LevelEditor* editor;

	//Object being moved.
	std::vector<GameObject*> objects;

	//New position.
	std::vector<SDL_Rect> newPosition;

	//Old position.
	std::vector<SDL_Rect> oldPosition;

	//Internal resize command. Can be NULL.
	ResizeLevelCommand* resizeCommand;

	public:
	// Move or resize one object.
	MoveGameObjectCommand(LevelEditor* levelEditor, GameObject* gameObject, int x, int y, int w, int h);

	// Move a bunch of objects
	MoveGameObjectCommand(LevelEditor* levelEditor, std::vector<GameObject*>& gameObjects, int dx, int dy);

	virtual ~MoveGameObjectCommand();

	//Moves the object to the specified position.
	virtual void execute();

	//Moves object back to its previous position.
	virtual void unexecute();

	virtual std::string describe();

	private:
	// initialize new/old positions, etc. of objects
	void init();
	};

	//Class for add/remove game objects.
	class AddRemoveGameObjectCommand: public Command {
	private:
	LevelEditor* editor;

	//Object being added or removed.
	std::vector<GameObject*> objects;

	//The layer of the object.
	std::string theLayer;

	//Internal resize command for object placement. Can be NULL.
	ResizeLevelCommand* resizeCommand;

	//Internal command used to remove player/shadow start if we are adding new start point. Can be NULL.
	AddRemoveGameObjectCommand* removeStartCommand;

	//The working mode.
	bool isAdd;

	//Boolean indicates if we own this object.
	bool ownObject;

	//A copy of the level editor's triggers. Can be NULL.
	LevelEditor::Triggers *oldTriggers;

	private:
	//Adds the gameObject.
	void addGameObject();

	//Removes the gameObject.
	void removeGameObject();

	public:
	AddRemoveGameObjectCommand(LevelEditor* levelEditor, GameObject* gameObject, bool isAdd_);
	AddRemoveGameObjectCommand(LevelEditor* levelEditor, std::vector<GameObject*>& gameObjects, bool isAdd_);

	virtual void execute();

	virtual void unexecute();

	virtual ~AddRemoveGameObjectCommand();

	virtual std::string describe();

	private:
	// initialize new positions, etc. of objects
	void init();

	// Back up old triggers. It can be only called once.
	void backupTriggers();
	};

	//Class that adds/removes a moving position to the target moving block.
	class AddRemovePathCommand : public Command{
	private:
	LevelEditor* editor;

	//Point on the path that is being added.
	MovingPosition movePos;

	//Block that the path is being added to.
	Block* target;

	//The working mode.
	bool isAdd;
	public:
	AddRemovePathCommand(LevelEditor* levelEditor, Block* movingBlock, MovingPosition movingPosition, bool isAdd_);

	virtual ~AddRemovePathCommand();

	//Add the MovingPosition.
	virtual void execute();

	//Remove the MovingPosition.
	virtual void unexecute();

	virtual std::string describe();

	private:
	void addPath();

	void removePath();

	void setEditorData();
	};

	//Class that clears the moving position of the target moving block.
	class RemovePathCommand : public Command{
	private:
	LevelEditor* editor;

	//Block that the path is being removed from.
	Block* target;

	//The MovingPositions of the target to be restored when unexecuting.
	std::vector<MovingPosition> movePositions;
	public:
	RemovePathCommand(LevelEditor* levelEditor, Block* targetBlock);

	virtual ~RemovePathCommand();

	//Remove the path.
	virtual void execute();

	//Re-add the path.
	virtual void unexecute();

	virtual std::string describe();
	};

	//Class that adds a link from the target object ot the selected object.
	class AddLinkCommand : public Command{
	private:
	LevelEditor* editor;

	//Object that was clicked upon when adding the link.
	GameObject* clickedObj;

	//Object that is linking to another.
	Block* target;

	//Previous link of the target block if it is a portal (portal has only 1 link).
	GameObject* oldPortalLink;

	//Previous destination of portal.
	std::string destination;

	//Previous id of target.
	std::string id;
	public:
	AddLinkCommand(LevelEditor* levelEditor, Block* linkingTrigger, GameObject* clickedObject);

	virtual ~AddLinkCommand();

	//Add the link, clicked object will get the same id as the target block.
	virtual void execute();

	//Remove the link.
	virtual void unexecute();

	virtual std::string describe();
	};

	//Class that clears the links from the target object.
	class RemoveLinkCommand : public Command{
	private:
	LevelEditor* editor;

	//Block whose links are being removed.
	Block* target;

	//Copy of the links being removed.
	std::vector<GameObject*> links;

	//Previous destination of portal.
	std::string destination;

	//Previous target id.
	std::string id;
	public:
	RemoveLinkCommand(LevelEditor* levelEditor, Block* targetBlock);

	virtual ~RemoveLinkCommand();

	//Remove all the links, changes the id of the object.
	virtual void execute();

	//Add all the links, restores the object's previous id.
	virtual void unexecute();

	virtual std::string describe();
	};

	//Class that modifies an editor property of an object.

	class SetEditorPropertyCommand :public Command {
	private:
	LevelEditor* editor;
	ImageManager& imageManager;
	SDL_Renderer& renderer;

	//Object being modified.
	GameObject* target;

	//The property being modified.
	std::string prop;

	//The new value of the property.
	std::string newValue;

	//The old value of the property.
	std::string oldValue;

	//The description of the property.
	std::string desc;

	public:
	SetEditorPropertyCommand(LevelEditor* levelEditor, ImageManager& imageManager, SDL_Renderer& renderer, GameObject* targetBlock,
	const std::string& propertyName, const std::string& propertyValue, const std::string& propertyDescription);

	virtual ~SetEditorPropertyCommand();

	virtual void execute();

	virtual void unexecute();

	virtual std::string describe();

	private:
	void updateCustomScenery();
	};

	//Class that modifies the level settings.

	class SetLevelPropertyCommand : public Command {
	public:
	struct LevelProperty {
	std::string levelName;
	std::string levelTheme;
	std::string levelMusic;
	int levelTime;
	int levelRecordings;
	};

	private:
	LevelEditor* editor;

	LevelProperty oldProperty;
	LevelProperty newProperty;

	public:
	SetLevelPropertyCommand(LevelEditor* levelEditor, const LevelProperty& levelProperty);

	virtual ~SetLevelPropertyCommand();

	virtual void execute();

	virtual void unexecute();

	virtual std::string describe();

	private:
	void setLevelProperty(const LevelProperty& levelProperty);
	};

	//Class that modifies the scripting for block or level
	// NOTE: currently the scripting for scenery block is unsupported.

	class SetScriptCommand : public Command {
	private:
	LevelEditor* editor;

	//Object being modified. Can be NULL.
	Block* target;

	std::map<int, std::string> newScript;
	std::map<int, std::string> oldScript;

	//the new id for the target block.
	std::string id;

	std::string oldId;

	public:
	SetScriptCommand(LevelEditor* levelEditor, Block* targetBlock, const std::map<int, std::string>& script, const std::string& id = std::string());

	virtual ~SetScriptCommand();

	virtual void execute();

	virtual void unexecute();

	virtual std::string describe();

	private:
	void setScript(const std::map<int, std::string>& script, const std::string& id);
	};

	//Class for add/remove scenery layer.
	class AddRemoveLayerCommand : public Command {
	private:
	LevelEditor* editor;

	- //Object being added or removed.
	- std::vector<Scenery*> objects;
	+ //Layer added or removed.
	+ SceneryLayer* layer;

	//The layer of the object.
	std::string theLayer;

	//The working mode.
	bool isAdd;

	//Boolean indicates if we own this object.
	bool ownObject;

	private:
	//Adds the layer.
	void addLayer();

	//Removes the layer.
	void removeLayer();

	public:
	AddRemoveLayerCommand(LevelEditor* levelEditor, const std::string& layerName, bool isAdd_);

	virtual void execute();

	virtual void unexecute();

	virtual ~AddRemoveLayerCommand();

	virtual std::string describe();
	};

	//Class for rename scenery layer.
	class RenameLayerCommand : public Command {
	private:
	LevelEditor* editor;

	std::string oldName;
	std::string newName;

	public:
	RenameLayerCommand(LevelEditor* levelEditor, const std::string& oldName, const std::string& newName);

	virtual void execute();

	virtual void unexecute();

	virtual ~RenameLayerCommand();

	virtual std::string describe();

	private:
	void rename(const std::string& oldName, const std::string& newName);
	};

	//Class for move object between layers.
	class MoveToLayerCommand : public Command {
	private:
	LevelEditor* editor;

	std::vector<Scenery*> objects;

	std::string oldName;
	std::string newName;

	- bool createNewLayer;
	+ AddRemoveLayerCommand* createNewLayer;

	public:
	MoveToLayerCommand(LevelEditor* levelEditor, std::vector<GameObject*>& gameObjects, const std::string& oldName, const std::string& newName);

	virtual void execute();

	virtual void unexecute();

	virtual ~MoveToLayerCommand();

	virtual std::string describe();

	private:
	void removeGameObject();

	void addGameObject(const std::string& layer);
	};

	#endif
	diff --git a/src/Game.cpp b/src/Game.cpp
	index e7a3542..310e9b3 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,1772 +1,1770 @@
	/*
	* Copyright (C) 2011-2013 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "Block.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "Game.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	#include "MusicManager.h"
	#include "Render.h"
	#include "StatisticsManager.h"
	#include "ScriptExecutor.h"
	#include <fstream>
	#include <iostream>
	#include <sstream>
	#include <vector>
	#include <map>
	#include <algorithm>
	#include <locale>
	#include <stdio.h>
	#include <SDL_ttf.h>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	const char* Game::blockName[TYPE_MAX]={"Block","PlayerStart","ShadowStart",
	"Exit","ShadowBlock","Spikes",
	"Checkpoint","Swap","Fragile",
	"MovingBlock","MovingShadowBlock","MovingSpikes",
	"Teleporter","Button","Switch",
	"ConveyorBelt","ShadowConveyorBelt","NotificationBlock", "Collectable", "Pushable"
	};

	map<string,int> Game::blockNameMap;
	map<int,string> Game::gameObjectEventTypeMap;
	map<string,int> Game::gameObjectEventNameMap;
	map<int,string> Game::levelEventTypeMap;
	map<string,int> Game::levelEventNameMap;
	string Game::recordFile;

	//An internal function.
	static void copyCompiledScripts(lua_State *state, const std::map<int, int>& src, std::map<int, int>& dest) {
	//Clear the existing scripts.
	for (auto it = dest.begin(); it != dest.end(); ++it) {
	luaL_unref(state, LUA_REGISTRYINDEX, it->second);
	}
	dest.clear();

	//Copy the source to the destination.
	for (auto it = src.begin(); it != src.end(); ++it) {
	lua_rawgeti(state, LUA_REGISTRYINDEX, it->second);
	dest[it->first] = luaL_ref(state, LUA_REGISTRYINDEX);
	}
	}

	Game::Game(SDL_Renderer &renderer, ImageManager &imageManager):isReset(false)
	, scriptExecutor(new ScriptExecutor())
	,currentLevelNode(NULL)
	,customTheme(NULL)
	,background(NULL)
	,won(false)
	,interlevel(false)
	,gameTipIndex(0)
	,time(0),timeSaved(0)
	,recordings(0),recordingsSaved(0)
	,cameraMode(CAMERA_PLAYER),cameraModeSaved(CAMERA_PLAYER)
	,player(this),shadow(this),objLastCheckPoint(NULL)
	,currentCollectables(0),totalCollectables(0),currentCollectablesSaved(0){

	saveStateNextTime=false;
	loadStateNextTime=false;

	recentSwap=recentSwapSaved=-10000;
	recentLoad=recentSave=0;

	action=imageManager.loadTexture(getDataPath()+"gfx/actions.png", renderer);
	medals=imageManager.loadTexture(getDataPath()+"gfx/medals.png", renderer);
	//Get the collectable image from the theme.
	//NOTE: Isn't there a better way to retrieve the image?
	objThemes.getBlock(TYPE_COLLECTABLE)->createInstance(&collectable);

	//Hide the cursor if not in the leveleditor.
	if(stateID!=STATE_LEVEL_EDITOR)
	SDL_ShowCursor(SDL_DISABLE);
	}

	Game::~Game(){
	//Simply call our destroy method.
	destroy();

	//Before we leave make sure the cursor is visible.
	SDL_ShowCursor(SDL_ENABLE);
	}

	void Game::destroy(){
	delete scriptExecutor;
	scriptExecutor = NULL;

	//Loop through the levelObjects and delete them.
	for(unsigned int i=0;i<levelObjects.size();i++)
	delete levelObjects[i];
	//Done now clear the levelObjects vector.
	levelObjects.clear();

	//Loop through the sceneryLayers and delete them.
	- std::map<std::string,std::vector<Scenery*> >::iterator it;
	- for(it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	- for(unsigned int i=0;i<it->second.size();i++)
	- delete it->second[i];
	+ for(auto it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	+ delete it->second;
	}
	sceneryLayers.clear();

	//Clear the name and the editor data.
	levelName.clear();
	levelFile.clear();
	editorData.clear();

	//Remove everything from the themeManager.
	background=NULL;
	if(customTheme)
	objThemes.removeTheme();
	customTheme=NULL;
	//If there's a (partial) theme bundled with the levelpack remove that as well.
	if(levels->customTheme)
	objThemes.removeTheme();

	//delete current level (if any)
	if(currentLevelNode){
	delete currentLevelNode;
	currentLevelNode=NULL;
	}

	//Reset the time.
	time=timeSaved=0;
	recordings=recordingsSaved=0;
	recentSwap=recentSwapSaved=-10000;

	//Set the music list back to the configured list.
	getMusicManager()->setMusicList(getSettings()->getValue("musiclist"));
	}

	void Game::reloadMusic() {
	//NOTE: level music is always enabled.

	//Check if the levelpack has a prefered music list.
	if (levels && !levels->levelpackMusicList.empty())
	getMusicManager()->setMusicList(levels->levelpackMusicList);

	//Check for the music to use.
	string &s = editorData["music"];
	if (!s.empty()) {
	getMusicManager()->playMusic(s);
	} else {
	getMusicManager()->pickMusic();
	}
	}

	void Game::loadLevelFromNode(ImageManager& imageManager,SDL_Renderer& renderer,TreeStorageNode* obj,const string& fileName){
	//Make sure there's nothing left from any previous levels.
	//Not needed since loadLevelFromNode is only called from the changeState method, meaning it's a new instance of Game.
	//destroy();

	//set current level to loaded one.
	currentLevelNode=obj;

	//Set the level dimensions to the default, it will probably be changed by the editorData,
	//but 800x600 is a fallback.
	LEVEL_WIDTH=800;
	LEVEL_HEIGHT=600;

	currentCollectables=0;
	totalCollectables=0;
	currentCollectablesSaved=0;

	//Load the additional data.
	for(map<string,vector<string> >::iterator i=obj->attributes.begin();i!=obj->attributes.end();++i){
	if(i->first=="size"){
	//We found the size attribute.
	if(i->second.size()>=2){
	//Set the dimensions of the level.
	LEVEL_WIDTH=atoi(i->second[0].c_str());
	LEVEL_HEIGHT=atoi(i->second[1].c_str());
	}
	}else if(i->second.size()>0){
	//Any other data will be put into the editorData.
	editorData[i->first]=i->second[0];
	}
	}

	//Get the theme.
	{
	//NOTE: level themes are always enabled.

	//Check for bundled (partial) themes for level pack.
	if (levels->customTheme){
	if (objThemes.appendThemeFromFile(levels->levelpackPath + "/theme/theme.mnmstheme", imageManager, renderer) == NULL){
	//The theme failed to load so set the customTheme boolean to false.
	levels->customTheme = false;
	}
	}

	//Check for the theme to use for this level. This has higher priority.
	//Examples: %DATA%/themes/classic or %USER%/themes/Orange
	string &s = editorData["theme"];
	if (!s.empty()){
	customTheme = objThemes.appendThemeFromFile(processFileName(s) + "/theme.mnmstheme", imageManager, renderer);
	}

	//Set the Appearance of the player and the shadow.
	objThemes.getCharacter(false)->createInstance(&player.appearance);
	objThemes.getCharacter(true)->createInstance(&shadow.appearance);
	}

	//Get the music.
	reloadMusic();

	//Load the data from the level node.
	for(unsigned int i=0;i<obj->subNodes.size();i++){
	TreeStorageNode* obj1=obj->subNodes[i];
	if(obj1==NULL) continue;
	if(obj1->name=="tile"){
	Block* block=new Block(this);
	if(!block->loadFromNode(imageManager,renderer,obj1)){
	delete block;
	continue;
	}

	//If the type is collectable, increase the number of totalCollectables
	if(block->type==TYPE_COLLECTABLE)
	totalCollectables++;

	//Add the block to the levelObjects vector.
	levelObjects.push_back(block);
	}else if(obj1->name=="scenerylayer" && obj1->value.size()==1){
	- //Loop through the sub nodes.
	- for(unsigned int j=0;j<obj1->subNodes.size();j++){
	- TreeStorageNode* obj2=obj1->subNodes[j];
	- if(obj2==NULL) continue;
	-
	- if(obj2->name=="object" \|\| obj2->name=="scenery"){
	- //Load the scenery from node.
	- Scenery* scenery=new Scenery(this);
	- if(!scenery->loadFromNode(imageManager,renderer,obj2)){
	- delete scenery;
	- continue;
	- }
	-
	- sceneryLayers[obj1->value[0]].push_back(scenery);
	- }
	+ //Check if the layer exists.
	+ if (sceneryLayers[obj1->value[0]] == NULL) {
	+ sceneryLayers[obj1->value[0]] = new SceneryLayer();
	}
	+
	+ //Load contents from node.
	+ sceneryLayers[obj1->value[0]]->loadFromNode(this, imageManager, renderer, obj1);
	}else if(obj1->name=="script" && !obj1->value.empty()){
	map<string,int>::iterator it=Game::levelEventNameMap.find(obj1->value[0]);
	if(it!=Game::levelEventNameMap.end()){
	int eventType=it->second;
	const std::string& script=obj1->attributes["script"][0];
	if(!script.empty()) scripts[eventType]=script;
	}
	}
	}

	//Set the levelName to the name of the current level.
	levelName=editorData["name"];
	levelFile=fileName;

	//Some extra stuff only needed when not in the levelEditor.
	if(stateID!=STATE_LEVEL_EDITOR){
	//We create a text with the text "Level <levelno> <levelName>".
	//It will be shown in the left bottom corner of the screen.
	string s;
	if(levels->getLevelCount()>1 && levels->type!=COLLECTION){
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,_CC(levels->getDictionaryManager(),editorData["name"]));
	} else {
	s = _CC(levels->getDictionaryManager(), editorData["name"]);
	}

	bmTips[0]=textureFromText(renderer, *fontText,s.c_str(),objThemes.getTextColor(true));
	}

	//Get the background
	background=objThemes.getBackground(false);

	//Now the loading is finished, we reset all objects to their initial states.
	reset(true, stateID == STATE_LEVEL_EDITOR);
	}

	void Game::loadLevel(ImageManager& imageManager,SDL_Renderer& renderer,std::string fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode *obj=new TreeStorageNode();
	{
	POASerializer objSerializer;
	string s=fileName;

	//Parse the file.
	if(!objSerializer.loadNodeFromFile(s.c_str(),obj,true)){
	cerr<<"ERROR: Can't load level file "<<s<<endl;
	delete obj;
	return;
	}
	}

	//Now call another function.
	loadLevelFromNode(imageManager,renderer,obj,fileName);
	}

	void Game::saveRecord(const char* fileName){
	//check if current level is NULL (which should be impossible)
	if(currentLevelNode==NULL) return;

	TreeStorageNode obj;
	POASerializer objSerializer;

	//put current level to the node.
	currentLevelNode->name="map";
	obj.subNodes.push_back(currentLevelNode);

	//serialize the game record using RLE compression.
	#define PUSH_BACK \
	if(j>0){ \
	if(j>1){ \
	sprintf(c,"%d*%d",last,j); \
	}else{ \
	sprintf(c,"%d",last); \
	} \
	v.push_back(c); \
	}
	vector<string> &v=obj.attributes["record"];
	vector<int> *record=player.getRecord();
	char c[64];
	int i,j=0,last;
	for(i=0;i<(int)record->size();i++){
	int currentKey=(*record)[i];
	if(j==0 \|\| currentKey!=last){
	PUSH_BACK;
	last=currentKey;
	j=1;
	}else{
	j++;
	}
	}
	PUSH_BACK;
	#undef PUSH_BACK

	#ifdef RECORD_FILE_DEBUG
	//add record file debug data.
	{
	obj.attributes["recordKeyPressLog"].push_back(player.keyPressLog());

	vector<SDL_Rect> &playerPosition=player.playerPosition();
	string s;
	char c[32];

	sprintf(c,"%d\n",int(playerPosition.size()));
	s=c;

	for(unsigned int i=0;i<playerPosition.size();i++){
	SDL_Rect& r=playerPosition[i];
	sprintf(c,"%d %d\n",r.x,r.y);
	s+=c;
	}

	obj.attributes["recordPlayerPosition"].push_back(s);
	}
	#endif

	//save it
	objSerializer.saveNodeToFile(fileName,&obj,true,true);

	//remove current level from node to prevent delete it.
	obj.subNodes.clear();
	}

	void Game::loadRecord(ImageManager& imageManager, SDL_Renderer& renderer, const char* fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	string s=fileName;

	//Parse the file.
	if(!objSerializer.loadNodeFromFile(s.c_str(),&obj,true)){
	cerr<<"ERROR: Can't load record file "<<s<<endl;
	return;
	}
	}

	//find the node named 'map'.
	bool loaded=false;
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	if(obj.subNodes[i]->name=="map"){
	//load the level. (fileName=???)
	loadLevelFromNode(imageManager,renderer,obj.subNodes[i],"???");
	//remove this node to prevent delete it.
	obj.subNodes[i]=NULL;
	//over
	loaded=true;
	break;
	}
	}

	if(!loaded){
	cerr<<"ERROR: Can't find subnode named 'map' from record file"<<endl;
	return;
	}

	//load the record.
	{
	vector<int> *record=player.getRecord();
	record->clear();
	vector<string> &v=obj.attributes["record"];
	for(unsigned int i=0;i<v.size();i++){
	string &s=v[i];
	string::size_type pos=s.find_first_of('*');
	if(pos==string::npos){
	//1 item only.
	int i=atoi(s.c_str());
	record->push_back(i);
	}else{
	//contains many items.
	int i=atoi(s.substr(0,pos).c_str());
	int j=atoi(s.substr(pos+1).c_str());
	for(;j>0;j--){
	record->push_back(i);
	}
	}
	}
	}

	#ifdef RECORD_FILE_DEBUG
	//load the debug data
	{
	vector<string> &v=obj.attributes["recordPlayerPosition"];
	vector<SDL_Rect> &playerPosition=player.playerPosition();
	playerPosition.clear();
	if(!v.empty()){
	if(!v[0].empty()){
	stringstream st(v[0]);
	int m;
	st>>m;
	for(int i=0;i<m;i++){
	SDL_Rect r;
	st>>r.x>>r.y;
	r.w=0;
	r.h=0;
	playerPosition.push_back(r);
	}
	}
	}
	}
	#endif

	//play the record.
	//TODO: tell the level manager don't save the level progress.
	player.playRecord();
	shadow.playRecord(); //???
	}

	/////////////EVENT///////////////
	void Game::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//First of all let the player handle input.
	player.handleInput(&shadow);

	//Check for an SDL_QUIT event.
	if(event.type==SDL_QUIT){
	//We need to quit so enter STATE_EXIT.
	setNextState(STATE_EXIT);
	}

	//Check for the escape key.
	if(stateID != STATE_LEVEL_EDITOR && inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	//Escape means we go one level up, to the level select state.
	setNextState(STATE_LEVEL_SELECT);
	//Save the progress.
	levels->saveLevelProgress();

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}

	//Check if 'R' is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_RESTART)){
	//Restart game only if we are not watching a replay.
	if (!player.isPlayFromRecord() \|\| interlevel) {
	//Reset the game at next frame.
	isReset = true;

	//Also delete any gui (most likely the interlevel gui). Only in game mode.
	if (GUIObjectRoot && stateID != STATE_LEVEL_EDITOR){
	delete GUIObjectRoot;
	GUIObjectRoot = NULL;
	}

	//And set interlevel to false.
	interlevel = false;
	}
	}

	//Check for the next level buttons when in the interlevel popup.
	if (inputMgr.isKeyDownEvent(INPUTMGR_SPACE) \|\| inputMgr.isKeyDownEvent(INPUTMGR_SELECT)){
	if(interlevel){
	//The interlevel popup is shown so we need to delete it.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Now goto the next level.
	gotoNextLevel(imageManager,renderer);
	}
	}

	//Check if tab is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	//Switch the camera mode.
	switch(cameraMode){
	case CAMERA_PLAYER:
	cameraMode=CAMERA_SHADOW;
	break;
	case CAMERA_SHADOW:
	case CAMERA_CUSTOM:
	cameraMode=CAMERA_PLAYER;
	break;
	}
	}
	}

	/////////////////LOGIC///////////////////
	void Game::logic(ImageManager& imageManager, SDL_Renderer& renderer){
	//Add one tick to the time.
	time++;

	//FIXME:Resetting dx/dy and xVel/yVel every loop interferes with movement logic of player and blocks.
	//First prepare each gameObject for the new frame.
	//This includes resetting dx/dy and xVel/yVel.
	//for(unsigned int o=0;o<levelObjects.size();o++)
	//levelObjects[o]->prepareFrame();

	//Process delay execution scripts.
	getScriptExecutor()->processDelayExecution();

	//Process any event in the queue.
	for(unsigned int idx=0;idx<eventQueue.size();idx++){
	//Get the event from the queue.
	typeGameObjectEvent &e=eventQueue[idx];

	//Check if the it has an id attached to it.
	if(e.target){
	//NOTE: Should we check if the target still exists???
	e.target->onEvent(e.eventType);
	}else if(e.flags&1){
	//Loop through the levelObjects and give them the event if they have the right id.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	if(levelObjects[i]->id==e.id){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}else{
	//Loop through the levelObjects and give them the event.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}
	//Done processing the events so clear the queue.
	eventQueue.clear();

	//Check if we should save/load state.
	//NOTE: This happens after event handling so no eventQueue has to be saved/restored.
	if(saveStateNextTime){
	saveState();
	}else if(loadStateNextTime){
	loadState();
	}
	saveStateNextTime=false;
	loadStateNextTime=false;

	//Loop through the gameobjects to update them.
	for(unsigned int i=0;i<levelObjects.size();i++){
	//Send GameObjectEvent_OnEnterFrame event to the script
	levelObjects[i]->onEvent(GameObjectEvent_OnEnterFrame);
	}
	for(unsigned int i=0;i<levelObjects.size();i++){
	//Let the gameobject handle movement.
	levelObjects[i]->move();
	}
	//Also update the scenery.
	- {
	- std::map<std::string,std::vector<Scenery*> >::iterator it;
	- for(it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	- for(unsigned int i=0;i<it->second.size();i++)
	- it->second[i]->move();
	- }
	+ for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it){
	+ it->second->updateAnimation();
	}

	//Let the player store his move, if recording.
	player.shadowSetState();
	//Let the player give his recording to the shadow, if configured.
	player.shadowGiveState(&shadow);

	//NOTE: to fix bugs regarding player/shadow swap, we should first process collision of player/shadow then move them

	SDL_Rect playerLastPosition = player.getBox();
	SDL_Rect shadowLastPosition = shadow.getBox();

	//Check collision for player.
	player.collision(levelObjects);
	//Now let the shadow decide his move, if he's playing a recording.
	shadow.moveLogic();
	//Check collision for shadow.
	shadow.collision(levelObjects);

	//Let the player move.
	player.move(levelObjects, playerLastPosition.x, playerLastPosition.y);
	//Let the shadow move.
	shadow.move(levelObjects, shadowLastPosition.x, shadowLastPosition.y);

	//Check collision and stuff for the shadow and player.
	player.otherCheck(&shadow);

	//Update the camera.
	switch(cameraMode){
	case CAMERA_PLAYER:
	player.setMyCamera();
	break;
	case CAMERA_SHADOW:
	shadow.setMyCamera();
	break;
	case CAMERA_CUSTOM:
	//NOTE: The target is (should be) screen size independent so calculate the real target x and y here.
	int targetX=cameraTarget.x-(SCREEN_WIDTH/2);
	int targetY=cameraTarget.y-(SCREEN_HEIGHT/2);
	//Move the camera to the cameraTarget.
	if(camera.x>targetX){
	camera.x-=(camera.x-targetX)>>4;
	//Make sure we don't go too far.
	if(camera.x<targetX)
	camera.x=targetX;
	}else if(camera.x<targetX){
	camera.x+=(targetX-camera.x)>>4;
	//Make sure we don't go too far.
	if(camera.x>targetX)
	camera.x=targetX;
	}
	if(camera.y>targetY){
	camera.y-=(camera.y-targetY)>>4;
	//Make sure we don't go too far.
	if(camera.y<targetY)
	camera.y=targetY;
	}else if(camera.y<targetY){
	camera.y+=(targetY-camera.y)>>4;
	//Make sure we don't go too far.
	if(camera.y>targetY)
	camera.y=targetY;
	}
	break;
	}

	//Check if we won.
	if(won){
	//Check if it's playing from record
	if(player.isPlayFromRecord() && !interlevel){
	recordingEnded(imageManager,renderer);
	}else{
	//the string to store auto-save record path.
	string bestTimeFilePath,bestRecordingFilePath;
	//and if we can't get test path.
	bool filePathError=false;

	//Get current level
	LevelPack::Level *level=levels->getLevel();

	//Now check if we should update statistics
	{
	//Get previous and current medal
	int oldMedal=level->won?1:0,newMedal=1;

	int bestTime=level->time;
	int targetTime=level->targetTime;
	int bestRecordings=level->recordings;
	int targetRecordings=level->targetRecordings;

	if(oldMedal){
	if(targetTime<0){
	oldMedal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	oldMedal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	oldMedal++;
	}
	}else{
	bestTime=time;
	bestRecordings=recordings;
	}

	if(bestTime==-1 \|\| bestTime>time) bestTime=time;
	if(bestRecordings==-1 \|\| bestRecordings>recordings) bestRecordings=recordings;

	if(targetTime<0){
	newMedal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	newMedal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	newMedal++;
	}

	//Check if we need to update statistics
	if(newMedal>oldMedal){
	switch(oldMedal){
	case 0:
	statsMgr.completedLevels++;
	break;
	case 2:
	statsMgr.silverLevels--;
	break;
	}

	switch(newMedal){
	case 2:
	statsMgr.silverLevels++;
	break;
	case 3:
	statsMgr.goldLevels++;
	break;
	}
	}
	}

	//Check the achievement "Complete a level with checkpoint, but without saving"
	if (objLastCheckPoint == NULL) {
	for (auto obj : levelObjects) {
	if (obj->type == TYPE_CHECKPOINT) {
	statsMgr.newAchievement("withoutsave");
	break;
	}
	}
	}

	//Set the current level won.
	level->won=true;
	if(level->time==-1 \|\| level->time>time){
	level->time=time;
	//save the best-time game record.
	if(bestTimeFilePath.empty()){
	getCurrentLevelAutoSaveRecordPath(bestTimeFilePath,bestRecordingFilePath,true);
	}
	if(bestTimeFilePath.empty()){
	cerr<<"ERROR: Couldn't get auto-save record file path"<<endl;
	filePathError=true;
	}else{
	saveRecord(bestTimeFilePath.c_str());
	}
	}
	if(level->recordings==-1 \|\| level->recordings>recordings){
	level->recordings=recordings;
	//save the best-recordings game record.
	if(bestRecordingFilePath.empty() && !filePathError){
	getCurrentLevelAutoSaveRecordPath(bestTimeFilePath,bestRecordingFilePath,true);
	}
	if(bestRecordingFilePath.empty()){
	cerr<<"ERROR: Couldn't get auto-save record file path"<<endl;
	filePathError=true;
	}else{
	saveRecord(bestRecordingFilePath.c_str());
	}
	}

	//Set the next level unlocked if it exists.
	if(levels->getCurrentLevel()+1<levels->getLevelCount()){
	levels->setLocked(levels->getCurrentLevel()+1);
	}
	//And save the progress.
	levels->saveLevelProgress();

	//Now go to the interlevel screen.
	replayPlay(imageManager,renderer);

	//Update achievements
	if(levels->levelpackName=="tutorial") statsMgr.updateTutorialAchievements();
	statsMgr.updateLevelAchievements();

	//NOTE: We set isReset false to prevent the user from getting a best time of 0.00s and 0 recordings.
	isReset = false;
	}
	}
	won=false;

	//Check if we should reset.
	if (isReset) {
	//NOTE: we don't need to reset save ??? it looks like that there are no bugs
	reset(false, false);
	}
	isReset=false;
	}

	/////////////////RENDER//////////////////
	void Game::render(ImageManager&,SDL_Renderer &renderer){
	//First of all render the background.
	{
	//Get a pointer to the background.
	ThemeBackground* bg=background;

	//Check if the background is null, but there are themes.
	if(bg==NULL && objThemes.themeCount()>0){
	//Get the background from the first theme in the stack.
	bg=objThemes[0]->getBackground(false);
	}

	//Check if the background isn't null.
	if(bg){
	//It isn't so draw it.
	bg->draw(renderer);

	//And if it's the loaded background then also update the animation.
	//FIXME: Updating the animation in the render method?
	if(bg==background)
	bg->updateAnimation();
	}else{
	//There's no background so fill the screen with white.
	SDL_SetRenderDrawColor(&renderer, 255,255,255,255);
	SDL_RenderClear(&renderer);
	}
	}

	//Now draw the blackground layers.
	- std::map<std::string,std::vector<Scenery*> >::iterator it;
	- for(it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	+ auto it = sceneryLayers.begin();
	+ for (; it != sceneryLayers.end(); ++it){
	if (it->first >= "f") break; // now we meet a foreground layer
	- for(unsigned int i=0;i<it->second.size();i++)
	- it->second[i]->show(renderer);
	+ it->second->show(renderer);
	}

	//Now we draw the levelObjects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	levelObjects[o]->show(renderer);
	}

	//Followed by the player and the shadow.
	//NOTE: We draw the shadow first, because he needs to be behind the player.
	shadow.show(renderer);
	player.show(renderer);

	//Now draw the foreground layers.
	for (; it != sceneryLayers.end(); ++it){
	- for (unsigned int i = 0; i<it->second.size(); i++)
	- it->second[i]->show(renderer);
	+ it->second->show(renderer);
	}

	//Show the levelName if it isn't the level editor.
	if(stateID!=STATE_LEVEL_EDITOR && bmTips[0]!=NULL && !interlevel){
	withTexture(*bmTips[0], [&](SDL_Rect r){
	drawGUIBox(-2,SCREEN_HEIGHT-r.h-4,r.w+8,r.h+6,renderer,0xFFFFFFFF);
	applyTexture(2,SCREEN_HEIGHT-r.h,*bmTips[0],renderer,NULL);
	});
	}

	//Check if there's a tooltip.
	//NOTE: gameTipIndex 0 is used for the levelName, 1 for shadow death, 2 for restart text, 3 for restart+checkpoint.
	if(gameTipIndex>3 && gameTipIndex<TYPE_MAX){
	//Check if there's a tooltip for the type.
	if(bmTips[gameTipIndex]==NULL){
	//There isn't thus make it.
	string s;
	string keyCode = InputManagerKeyCode::describeTwo(inputMgr.getKeyCode(INPUTMGR_ACTION, false), inputMgr.getKeyCode(INPUTMGR_ACTION, true));
	transform(keyCode.begin(),keyCode.end(),keyCode.begin(),::toupper);
	switch(gameTipIndex){
	case TYPE_CHECKPOINT:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to save the game."),keyCode);
	break;
	case TYPE_SWAP:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to swap the position of player and shadow."),keyCode);
	break;
	case TYPE_SWITCH:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to activate the switch."),keyCode);
	break;
	case TYPE_PORTAL:
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with current action key
	s=tfm::format(_("Press %s key to teleport."),keyCode);
	break;
	}

	//If we have a string then it's a supported GameObject type.
	if(!s.empty()){
	bmTips[gameTipIndex]=textureFromText(renderer, *fontText, s.c_str(), objThemes.getTextColor(true));
	}
	}

	//We already have a gameTip for this type so draw it.
	if(bmTips[gameTipIndex]!=NULL){
	withTexture(*bmTips[gameTipIndex], [&](SDL_Rect r){
	drawGUIBox(-2,-2,r.w+8,r.h+6,renderer,0xFFFFFFFF);
	applyTexture(2,2,*bmTips[gameTipIndex],renderer);
	});
	}
	}
	//Set the gameTip to 0.
	gameTipIndex=0;
	// Limit the scope of bm, as it's a borrowed pointer.
	{
	//Pointer to the sdl texture that will contain a message, if any.
	SDL_Texture* bm=NULL;

	//Check if the player is dead, meaning we draw a message.
	if(player.dead){
	//Get user configured restart key
	string keyCodeRestart = InputManagerKeyCode::describeTwo(inputMgr.getKeyCode(INPUTMGR_RESTART, false), inputMgr.getKeyCode(INPUTMGR_RESTART, true));
	transform(keyCodeRestart.begin(),keyCodeRestart.end(),keyCodeRestart.begin(),::toupper);
	//The player is dead, check if there's a state that can be loaded.
	if(player.canLoadState()){
	//Now check if the tip is already made, if not make it.
	if(bmTips[3]==NULL){
	//Get user defined key for loading checkpoint
	string keyCodeLoad = InputManagerKeyCode::describeTwo(inputMgr.getKeyCode(INPUTMGR_LOAD, false), inputMgr.getKeyCode(INPUTMGR_LOAD, true));
	transform(keyCodeLoad.begin(),keyCodeLoad.end(),keyCodeLoad.begin(),::toupper);
	//Draw string
	bmTips[3]=textureFromText(renderer, *fontText,//TTF_RenderUTF8_Blended(fontText,
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - first %s means currently configured key to restart game
	/// - Second %s means configured key to load from last save
	tfm::format(_("Press %s to restart current level or press %s to load the game."),
	keyCodeRestart,keyCodeLoad).c_str(),
	objThemes.getTextColor(true));
	}
	bm=bmTips[3].get();
	}else{
	//Now check if the tip is already made, if not make it.
	if(bmTips[2]==NULL){
	bmTips[2]=textureFromText(renderer, *fontText,
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with currently configured key to restart game
	tfm::format(_("Press %s to restart current level."),keyCodeRestart).c_str(),
	objThemes.getTextColor(true));
	}
	bm=bmTips[2].get();
	}
	}

	//Check if the shadow has died (and there's no other notification).
	//NOTE: We use the shadow's jumptime as countdown, this variable isn't used when the shadow is dead.
	if(shadow.dead && bm==NULL && shadow.jumpTime>0){
	//Now check if the tip is already made, if not make it.
	if(bmTips[1]==NULL){
	bmTips[1]=textureFromText(renderer, *fontText,
	_("Your shadow has died."),
	objThemes.getTextColor(true));
	}
	bm=bmTips[1].get();

	//NOTE: Logic in the render loop, we substract the shadow's jumptime by one.
	shadow.jumpTime--;

	//return view to player and keep it there
	cameraMode=CAMERA_PLAYER;
	}

	//Draw the tip.
	if(bm!=NULL){
	const SDL_Rect textureSize = rectFromTexture(*bm);
	int x=(SCREEN_WIDTH-textureSize.w)/2;
	int y=32;
	drawGUIBox(x-8,y-8,textureSize.w+16,textureSize.h+14,renderer,0xFFFFFFFF);
	applyTexture(x,y,*bm,renderer);
	}
	}

	//Show the number of collectables the user has collected if there are collectables in the level.
	//We hide this when interlevel.
	if(currentCollectables<=totalCollectables && totalCollectables!=0 && !interlevel && time>0){
	if(collectablesTexture.needsUpdate(currentCollectables)) {
	//Temp stringstream just to addup all the text nicely
	std::stringstream temp;
	temp << currentCollectables << "/" << totalCollectables;
	collectablesTexture.update(currentCollectables,
	textureFromText(renderer,
	*fontText,
	temp.str().c_str(),
	objThemes.getTextColor(true)));
	}
	SDL_Rect bmSize = rectFromTexture(*collectablesTexture.get());

	//Draw background
	drawGUIBox(SCREEN_WIDTH-bmSize.w-34,SCREEN_HEIGHT-bmSize.h-4,bmSize.w+34+2,bmSize.h+4+2,renderer,0xFFFFFFFF);

	//Draw the collectable icon
	collectable.draw(renderer,SCREEN_WIDTH-50+12,SCREEN_HEIGHT-50+10);

	//Draw text
	applyTexture(SCREEN_WIDTH-50-bmSize.w+22,SCREEN_HEIGHT-bmSize.h,collectablesTexture.getTexture(),renderer);
	}

	//show time and records used in level editor.
	if(stateID==STATE_LEVEL_EDITOR && time>0){
	const SDL_Color fg=objThemes.getTextColor(true),bg={255,255,255,255};
	const int alpha = 160;
	if (recordingsTexture.needsUpdate(recordings)) {
	recordingsTexture.update(recordings,
	textureFromTextShaded(
	renderer,
	*fontText,
	tfm::format(_("%d recordings"),recordings).c_str(),
	fg,
	bg
	));
	SDL_SetTextureAlphaMod(recordingsTexture.get(),alpha);
	}

	int y=SCREEN_HEIGHT - textureHeight(*recordingsTexture.get());

	applyTexture(0,y,*recordingsTexture.get(), renderer);

	if(timeTexture.needsUpdate(time)) {
	const size_t len = 32;
	char c[len];
	SDL_snprintf(c,len,"%-.2fs",time/40.0f);
	timeTexture.update(time,
	textureFromTextShaded(
	renderer,
	*fontText,
	c,
	fg,
	bg
	));
	y-=textureHeight(*timeTexture.get());
	}

	applyTexture(0,y,*timeTexture.get(), renderer);
	}

	//Draw the current action in the upper right corner.
	if(player.record){
	const SDL_Rect r = { 0, 0, 50, 50 };
	applyTexture(SCREEN_WIDTH - 50, 0, *action, renderer, &r);
	} else if (shadow.state != 0){
	const SDL_Rect r={50,0,50,50};
	applyTexture(SCREEN_WIDTH-50,0,*action,renderer,&r);
	}

	//if the game is play from record then draw something indicates it
	if(player.isPlayFromRecord()){
	//Dim the screen if interlevel is true.
	if( interlevel){
	dimScreen(renderer,191);
	}else if((time & 0x10)==0x10){
	// FIXME: replace this ugly ad-hoc animation by a better one
	const SDL_Rect r={50,0,50,50};
	applyTexture(0,0,*action,renderer,&r);
	applyTexture(0,SCREEN_HEIGHT-50,*action,renderer,&r);
	applyTexture(SCREEN_WIDTH-50,SCREEN_HEIGHT-50,*action,renderer,&r);
	}
	}else if(player.objNotificationBlock){
	//If the player is in front of a notification block show the message.
	//And it isn't a replay.
	//Check if we need to update the notification message texture.
	const auto& blockId = player.objNotificationBlock;
	int maxWidth = 0;
	int y = 20;
	//We check against blockId rather than the full message, as blockId is most likely shorter.
	if(notificationTexture.needsUpdate(blockId)) {
	const std::string &untranslated_message=player.objNotificationBlock->message;
	std::string message=_CC(levels->getDictionaryManager(),untranslated_message);

	std::vector<std::string> string_data;

	//Trim the message.
	{
	size_t lps = message.find_first_not_of("\n\r \t");
	if (lps == string::npos) {
	message.clear(); // it's completely empty
	} else {
	message = message.substr(lps, message.find_last_not_of("\n\r \t") - lps + 1);
	}
	}

	//Split the message into lines.
	for (int lps = 0;;) {
	// determine the end of line
	int lpe = lps;
	for (; message[lpe] != '\n' && message[lpe] != '\r' && message[lpe] != '\0'; lpe++);

	string_data.push_back(message.substr(lps, lpe - lps));

	// break if the string ends
	if (message[lpe] == '\0') break;

	// skip "\r\n" for Windows line ending
	if (message[lpe] == '\r' && message[lpe + 1] == '\n') lpe++;

	// point to the start of next line
	lps = lpe + 1;
	}

	vector<SurfacePtr> lines;

	//Create the image for each lines
	for (int i = 0; i < (int)string_data.size(); i++) {
	//Integer used to center the sentence horizontally.
	int x = 0;
	TTF_SizeUTF8(fontText, string_data[i].c_str(), &x, NULL);

	//Find out largest width
	if (x>maxWidth)
	maxWidth = x;

	lines.emplace_back(TTF_RenderUTF8_Blended(fontText, string_data[i].c_str(), objThemes.getTextColor(true)));

	//Increase y with 25, about the height of the text.
	y += 25;
	}

	maxWidth+=SCREEN_WIDTH*0.15;

	SurfacePtr surf = createSurface(maxWidth, y);
	int y1 = y;
	for(SurfacePtr &s : lines) {
	if(s) {
	applySurface((surf->w-s->w)/2,surf->h - y1,s.get(),surf.get(),NULL);
	}
	y1 -= 25;
	}
	notificationTexture.update(blockId, textureUniqueFromSurface(renderer,std::move(surf)));
	} else {
	auto texSize = rectFromTexture(*notificationTexture.get());
	maxWidth=texSize.w;
	y=texSize.h;
	}

	drawGUIBox((SCREEN_WIDTH-maxWidth)/2,SCREEN_HEIGHT-y-25,maxWidth,y+20,renderer,0xFFFFFFBF);
	applyTexture((SCREEN_WIDTH-maxWidth)/2,SCREEN_HEIGHT-y,notificationTexture.getTexture(),renderer);
	}
	}

	void Game::resize(ImageManager&, SDL_Renderer& /renderer/){
	//Check if the interlevel popup is shown.
	if(interlevel && GUIObjectRoot){
	GUIObjectRoot->left=(SCREEN_WIDTH-GUIObjectRoot->width)/2;
	}
	}

	void Game::replayPlay(ImageManager& imageManager,SDL_Renderer& renderer){
	//Set interlevel true.
	interlevel=true;

	//Make a copy of the playerButtons.
	vector<int> recordCopy=player.recordButton;

	//Reset the game.
	//NOTE: We don't reset the saves. I'll see that if it will introduce bugs.
	reset(false, false);

	//Make the cursor visible when the interlevel popup is up.
	SDL_ShowCursor(SDL_ENABLE);

	//Set the copy of playerButtons back.
	player.recordButton=recordCopy;

	//Now play the recording.
	player.playRecord();

	//Create the gui if it isn't already done.
	if(!GUIObjectRoot){
	//Create a new GUIObjectRoot the size of the screen.
	GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	//Make child widgets change color properly according to theme.
	GUIObjectRoot->inDialog=true;

	//Create a GUIFrame for the upper frame.
	GUIFrame* upperFrame=new GUIFrame(imageManager,renderer,0,4,0,68);
	GUIObjectRoot->addChild(upperFrame);

	//Render the You've finished: text and add it to a GUIImage.
	//NOTE: The texture is managed by the GUIImage so no need to free it ourselfs.
	auto bm = SharedTexture(textureFromText(renderer, *fontGUI,_("You've finished:"),objThemes.getTextColor(true)));
	const SDL_Rect textureSize = rectFromTexture(*bm);

	GUIImage* title=new GUIImage(imageManager,renderer,0,4-GUI_FONT_RAISE,textureSize.w,textureSize.h,bm);
	upperFrame->addChild(title);

	//Create the sub title.
	string s;
	if (levels->getLevelCount()>0){
	/// TRANSLATORS: Please do not remove %s or %d from your translation:
	/// - %d means the level number in a levelpack
	/// - %s means the name of current level
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,_CC(levels->getDictionaryManager(),levelName));
	}
	GUIObject* obj=new GUILabel(imageManager,renderer,0,40,0,28,s.c_str(),0,true,true,GUIGravityCenter);
	upperFrame->addChild(obj);
	obj->render(renderer,0,0,false);

	//Determine the width the upper frame should have.
	int width;
	if(textureSize.w>obj->width)
	width=textureSize.w+32;
	else
	width=obj->width+32;
	//Set the left of the title.
	title->left=(width-title->width)/2;
	//Set the width of the level label to the width of the frame for centering.
	obj->width=width;
	//Now set the position and width of the frame.
	upperFrame->width=width;
	upperFrame->left=(SCREEN_WIDTH-width)/2;

	//Now create a GUIFrame for the lower frame.
	GUIFrame* lowerFrame=new GUIFrame(imageManager,renderer,0,SCREEN_HEIGHT-140,570,135);
	GUIObjectRoot->addChild(lowerFrame);

	//The different values.
	int bestTime=levels->getLevel()->time;
	int targetTime=levels->getLevel()->targetTime;
	int bestRecordings=levels->getLevel()->recordings;
	int targetRecordings=levels->getLevel()->targetRecordings;

	int medal=1;
	if(targetTime<0){
	medal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	medal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	medal++;
	}

	int maxWidth=0;
	int x=20;

	//Is there a target time for this level?
	int timeY=0;
	bool isTargetTime=true;
	if(targetTime<=0){
	isTargetTime=false;
	timeY=12;
	}

	//Create the labels with the time and best time.
	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	obj=new GUILabel(imageManager,renderer,x,10+timeY,-1,36,tfm::format(_("Time: %-.2fs"),time/40.0f).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	obj=new GUILabel(imageManager,renderer,x,34+timeY,-1,36,tfm::format(_("Best time: %-.2fs"),bestTime/40.0f).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %-.2f from your translation:
	/// - %-.2f means time in seconds
	/// - s is shortened form of a second. Try to keep it so.
	if(isTargetTime){
	obj=new GUILabel(imageManager,renderer,x,58,-1,36,tfm::format(_("Target time: %-.2fs"),targetTime/40.0f).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;
	}

	x+=maxWidth+20;

	//Is there target recordings for this level?
	int recsY=0;
	bool isTargetRecs=true;
	if(targetRecordings<0){
	isTargetRecs=false;
	recsY=12;
	}

	//Now the ones for the recordings.
	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	obj=new GUILabel(imageManager,renderer,x,10+recsY,-1,36,tfm::format(_("Recordings: %d"),recordings).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	obj=new GUILabel(imageManager,renderer,x,34+recsY,-1,36,tfm::format(_("Best recordings: %d"),bestRecordings).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	if(isTargetRecs){
	obj=new GUILabel(imageManager,renderer,x,58,-1,36,tfm::format(_("Target recordings: %d"),targetRecordings).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;
	}

	x+=maxWidth;

	//The medal that is earned.
	/// TRANSLATORS: Please do not remove %s from your translation:
	/// - %s will be replaced with name of a prize medal (gold, silver or bronze)
	string s1=tfm::format(_("You earned the %s medal"),(medal>1)?(medal==3)?_("GOLD"):_("SILVER"):_("BRONZE"));
	obj=new GUILabel(imageManager,renderer,50,92,-1,36,s1.c_str(),0,true,true,GUIGravityCenter);
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->left+obj->width>x){
	x=obj->left+obj->width+30;
	}else{
	obj->left=20+(x-20-obj->width)/2;
	}

	//Create the rectangle for the earned medal.
	SDL_Rect r;
	r.x=(medal-1)*30;
	r.y=0;
	r.w=30;
	r.h=30;

	//Create the medal on the left side.
	obj=new GUIImage(imageManager,renderer,16,92,30,30,medals,r);
	lowerFrame->addChild(obj);
	//And the medal on the right side.
	obj=new GUIImage(imageManager,renderer,x-24,92,30,30,medals,r);
	lowerFrame->addChild(obj);

	//Create the three buttons, Menu, Restart, Next.
	/// TRANSLATORS: used as return to the level selector menu
	GUIObject* b1=new GUIButton(imageManager,renderer,x,10,-1,36,_("Menu"),0,true,true,GUIGravityCenter);
	b1->name="cmdMenu";
	b1->eventCallback=this;
	lowerFrame->addChild(b1);
	b1->render(renderer,0,0,true);

	/// TRANSLATORS: used as restart level
	GUIObject* b2=new GUIButton(imageManager,renderer,x,50,-1,36,_("Restart"),0,true,true,GUIGravityCenter);
	b2->name="cmdRestart";
	b2->eventCallback=this;
	lowerFrame->addChild(b2);
	b2->render(renderer,0,0,true);

	/// TRANSLATORS: used as next level
	GUIObject* b3=new GUIButton(imageManager,renderer,x,90,-1,36,_("Next"),0,true,true,GUIGravityCenter);
	b3->name="cmdNext";
	b3->eventCallback=this;
	lowerFrame->addChild(b3);
	b3->render(renderer,0,0,true);

	maxWidth=b1->width;
	if(b2->width>maxWidth)
	maxWidth=b2->width;
	if(b3->width>maxWidth)
	maxWidth=b3->width;

	b1->left=b2->left=b3->left=x+maxWidth/2;

	x+=maxWidth;
	lowerFrame->width=x;
	lowerFrame->left=(SCREEN_WIDTH-lowerFrame->width)/2;
	}
	}

	void Game::recordingEnded(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check if it's a normal replay, if so just stop.
	if(!interlevel){
	//Show the cursor so that the user can press the ok button.
	SDL_ShowCursor(SDL_ENABLE);
	//Now show the message box.
	msgBox(imageManager,renderer,_("Game replay is done."),MsgBoxOKOnly,_("Game Replay"));
	//Go to the level select menu.
	setNextState(STATE_LEVEL_SELECT);

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}else{
	//Instead of directly replaying we set won true to let the Game handle the replaying at the end of the update cycle.
	won=true;
	}
	}

	bool Game::canSaveState(){
	return (player.canSaveState() && shadow.canSaveState());
	}

	bool Game::saveState(){
	//Check if the player and shadow can save the current state.
	if(canSaveState()){
	//Let the player and the shadow save their state.
	player.saveState();
	shadow.saveState();

	//Save the stats.
	timeSaved=time;
	recordingsSaved=recordings;
	recentSwapSaved=recentSwap;

	//Save the camera mode and target.
	cameraModeSaved=cameraMode;
	cameraTargetSaved=cameraTarget;

	//Save the current collectables
	currentCollectablesSaved=currentCollectables;

	//Save scripts.
	copyCompiledScripts(getScriptExecutor()->getLuaState(), compiledScripts, savedCompiledScripts);

	//Save other state, for example moving blocks.
	for (auto block : levelObjects){
	block->saveState();
	copyCompiledScripts(getScriptExecutor()->getLuaState(), block->compiledScripts, block->savedCompiledScripts);
	}

	+ //Also save states of scenery layers.
	+ for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it) {
	+ it->second->saveAnimation();
	+ }
	+
	//Also save the background animation, if any.
	if(background)
	background->saveAnimation();

	if(!player.isPlayFromRecord() && !interlevel){
	//Update achievements
	Uint32 t=SDL_GetTicks()+5000; //Add a bias to prevent bugs
	if(recentSave+1000>t){
	statsMgr.newAchievement("panicSave");
	}
	recentSave=t;

	//Update statistics.
	statsMgr.saveTimes++;

	//Update achievements
	switch(statsMgr.saveTimes){
	case 1000:
	statsMgr.newAchievement("save1k");
	break;
	}
	}

	//Save the state for script executor.
	getScriptExecutor()->saveState();

	//Execute the onSave event.
	executeScript(LevelEvent_OnSave);

	//Return true.
	return true;
	}

	//We can't save the state so return false.
	return false;
	}

	bool Game::loadState(){
	//Check if there's a state that can be loaded.
	if(player.canLoadState() && shadow.canLoadState()){
	//Let the player and the shadow load their state.
	player.loadState();
	shadow.loadState();

	//Load the stats.
	time=timeSaved;
	recordings=recordingsSaved;
	recentSwap=recentSwapSaved;

	//Load the camera mode and target.
	cameraMode=cameraModeSaved;
	cameraTarget=cameraTargetSaved;

	//Load the current collactbles
	currentCollectables=currentCollectablesSaved;

	//Load scripts.
	copyCompiledScripts(getScriptExecutor()->getLuaState(), savedCompiledScripts, compiledScripts);

	//Load other state, for example moving blocks.
	for(auto block:levelObjects){
	block->loadState();
	copyCompiledScripts(getScriptExecutor()->getLuaState(), block->savedCompiledScripts, block->compiledScripts);
	}

	+ //Also load states of scenery layers.
	+ for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it) {
	+ it->second->loadAnimation();
	+ }
	+
	//Also load the background animation, if any.
	if(background)
	background->loadAnimation();

	if(!player.isPlayFromRecord() && !interlevel){
	//Update achievements.
	Uint32 t=SDL_GetTicks()+5000; //Add a bias to prevent bugs
	if(recentLoad+1000>t){
	statsMgr.newAchievement("panicLoad");
	}
	recentLoad=t;

	//Update statistics.
	statsMgr.loadTimes++;

	//Update achievements
	switch(statsMgr.loadTimes){
	case 1000:
	statsMgr.newAchievement("load1k");
	break;
	}
	}

	//Load the state for script executor.
	getScriptExecutor()->loadState();

	//Execute the onLoad event, if any.
	executeScript(LevelEvent_OnLoad);

	//Return true.
	return true;
	}

	//We can't load the state so return false.
	return false;
	}

	void Game::reset(bool save,bool noScript){
	//We need to reset the game so we also reset the player and the shadow.
	player.reset(save);
	shadow.reset(save);

	saveStateNextTime=false;
	loadStateNextTime=false;

	//Reset the stats if interlevel isn't true.
	if(!interlevel){
	time=0;
	recordings=0;
	}

	recentSwap=-10000;
	if(save) recentSwapSaved=-10000;

	//Reset the camera.
	cameraMode=CAMERA_PLAYER;
	if(save) cameraModeSaved=CAMERA_PLAYER;
	cameraTarget.x=cameraTarget.y=cameraTarget.w=cameraTarget.h=0;
	if(save) cameraTargetSaved.x=cameraTargetSaved.y=cameraTargetSaved.w=cameraTargetSaved.h=0;

	//Reset the number of collectables
	currentCollectables=0;
	if(save)
	currentCollectablesSaved=0;

	//There is no last checkpoint so set it to NULL.
	if(save)
	objLastCheckPoint=NULL;

	//Clear the event queue, since all the events are from before the reset.
	eventQueue.clear();

	//Reset other state, for example moving blocks.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->reset(save);
	}

	+ //Also reset states of scenery layers.
	+ for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it) {
	+ it->second->resetAnimation(save);
	+ }
	+
	//Also reset the background animation, if any.
	if(background)
	background->resetAnimation(save);

	//Reset the cached notification block
	notificationTexture.update(NULL, NULL);

	//Reset the script environment if necessary.
	if (noScript) {
	//Destroys the script environment completely.
	getScriptExecutor()->destroy();

	//Clear the level script.
	compiledScripts.clear();
	savedCompiledScripts.clear();
	initialCompiledScripts.clear();

	//Clear the block script.
	for (auto block : levelObjects){
	block->compiledScripts.clear();
	block->savedCompiledScripts.clear();
	block->initialCompiledScripts.clear();
	}
	} else {
	if (save \|\| getScriptExecutor()->getLuaState() == NULL) {
	//Create a new script environment.
	getScriptExecutor()->reset(true);

	//Recompile the level script.
	compiledScripts.clear();
	savedCompiledScripts.clear();
	initialCompiledScripts.clear();
	for (auto it = scripts.begin(); it != scripts.end(); ++it){
	int index = getScriptExecutor()->compileScript(it->second);
	compiledScripts[it->first] = index;
	lua_rawgeti(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX, index);
	initialCompiledScripts[it->first] = luaL_ref(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX);
	}

	//Recompile the block script.
	for (auto block : levelObjects) {
	block->compiledScripts.clear();
	block->savedCompiledScripts.clear();
	block->initialCompiledScripts.clear();
	for (auto it = block->scripts.begin(); it != block->scripts.end(); ++it){
	int index = getScriptExecutor()->compileScript(it->second);
	block->compiledScripts[it->first] = index;
	lua_rawgeti(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX, index);
	block->initialCompiledScripts[it->first] = luaL_ref(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX);
	}
	}
	} else {
	//Do a soft reset.
	getScriptExecutor()->reset(false);

	//Restore the level script to initial state.
	copyCompiledScripts(getScriptExecutor()->getLuaState(), initialCompiledScripts, compiledScripts);

	//Restore the block script to initial state.
	for (auto block : levelObjects) {
	copyCompiledScripts(getScriptExecutor()->getLuaState(), block->initialCompiledScripts, block->compiledScripts);
	}
	}
	}

	//Call the level's onCreate event.
	executeScript(LevelEvent_OnCreate);

	//Send GameObjectEvent_OnCreate event to the script
	for (auto block : levelObjects) {
	block->onEvent(GameObjectEvent_OnCreate);
	}

	//Close exit(s) if there are any collectables
	if (totalCollectables>0){
	for (auto block : levelObjects){
	if (block->type == TYPE_EXIT){
	block->onEvent(GameObjectEvent_OnSwitchOff);
	}
	}
	}

	//Hide the cursor (if not the leveleditor).
	if(stateID!=STATE_LEVEL_EDITOR)
	SDL_ShowCursor(SDL_DISABLE);
	}

	void Game::executeScript(int eventType){
	map<int,int>::iterator it;

	//Check if there's a script for the given event.
	it=compiledScripts.find(eventType);
	if(it!=compiledScripts.end()){
	//There is one so execute it.
	getScriptExecutor()->executeScript(it->second);
	}
	}

	void Game::broadcastObjectEvent(int eventType,int objectType,const char* id,GameObject* target){
	//Create a typeGameObjectEvent that can be put into the queue.
	typeGameObjectEvent e;
	//Set the event type.
	e.eventType=eventType;
	//Set the object type.
	e.objectType=objectType;
	//By default flags=0.
	e.flags=0;
	//Unless there's an id.
	if(id){
	//Set flags to 0x1 and set the id.
	e.flags\|=1;
	e.id=id;
	}
	//Or there's a target given.
	if(target)
	e.target=target;
	else
	e.target=NULL;

	//Add the event to the queue.
	eventQueue.push_back(e);
	}

	void Game::getCurrentLevelAutoSaveRecordPath(std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath){
	levels->getLevelAutoSaveRecordPath(-1,bestTimeFilePath,bestRecordingFilePath,createPath);
	}

	void Game::gotoNextLevel(ImageManager& imageManager, SDL_Renderer& renderer){
	//Goto the next level.
	levels->nextLevel();

	//Check if the level exists.
	if(levels->getCurrentLevel()<levels->getLevelCount()){
	setNextState(STATE_GAME);
	}else{
	if(!levels->congratulationText.empty()){
	msgBox(imageManager,renderer,_CC(levels->getDictionaryManager(),levels->congratulationText),MsgBoxOKOnly,_("Congratulations"));
	}else{
	msgBox(imageManager,renderer,_("You have finished the levelpack!"),MsgBoxOKOnly,_("Congratulations"));
	}
	//Now go back to the levelselect screen.
	setNextState(STATE_LEVEL_SELECT);
	//And set the music back to menu.
	getMusicManager()->playMusic("menu");
	}
	}

	void Game::GUIEventCallback_OnEvent(ImageManager& imageManager,SDL_Renderer& renderer, string name,GUIObject* obj,int eventType){
	if(name=="cmdMenu"){
	setNextState(STATE_LEVEL_SELECT);

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}else if(name=="cmdRestart"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	interlevel=false;

	//And reset the game.
	//NOTE: We don't need to clear the save game because in level replay the game won't be saved (??)
	//TODO: it seems work (??); I'll see if it introduce bugs
	reset(false, false);
	}else if(name=="cmdNext"){
	//No matter what, clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//And goto the next level.
	gotoNextLevel(imageManager,renderer);
	}
	}
	diff --git a/src/Game.h b/src/Game.h
	index 99c653d..ac3a48e 100644
	--- a/src/Game.h
	+++ b/src/Game.h
	@@ -1,305 +1,306 @@
	/*
	* Copyright (C) 2011-2013 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GAME_H
	#define GAME_H

	#include <SDL.h>
	#include <array>
	#include <vector>
	#include <map>
	#include <string>

	#include "CachedTexture.h"
	#include "GameState.h"
	#include "GUIObject.h"
	#include "GameObjects.h"
	#include "Scenery.h"
	+#include "SceneryLayer.h"
	#include "Player.h"
	#include "Render.h"
	#include "Shadow.h"

	//This structure contains variables that make a GameObjectEvent.
	struct typeGameObjectEvent{
	//The type of event.
	int eventType;
	//The type of object that should react to the event.
	int objectType;
	//Flags, 0x1 means use the id.
	int flags;
	//Blocks with this id should react to the event.
	std::string id;

	//Optional pointer to the block the event should be called on.
	GameObject* target;
	};

	class ThemeManager;
	class ThemeBackground;
	class TreeStorageNode;
	class ScriptExecutor;

	//The different level events.
	enum LevelEventType{
	//Event called when the level is created or the game is reset. This happens after all the blocks are created and their onCreate is called.
	LevelEvent_OnCreate=1,
	//Event called when the game is saved.
	LevelEvent_OnSave,
	//Event called when the game is loaded.
	LevelEvent_OnLoad,
	};

	class Game : public GameState,public GUIEventCallback{
	private:
	//Boolean if the game should reset. This happens when player press 'R' button.
	bool isReset;

	//The script executor.
	ScriptExecutor *scriptExecutor;

	protected:
	//contains currently played level.
	TreeStorageNode* currentLevelNode;

	//Array containing "tooltips" for certain block types.
	//It will be shown in the topleft corner of the screen.
	std::array<TexturePtr, TYPE_MAX> bmTips;

	//Texture containing the action images (record, play, etc..)
	SharedTexture action;
	//Texture containing the medal image.
	SharedTexture medals;

	//ThemeBlockInstance containing the collectable image.
	ThemeBlockInstance collectable;

	//The name of the current level.
	std::string levelName;
	//The path + file of the current level.
	std::string levelFile;

	//Editor data containing information like name, size, etc...
	std::map<std::string,std::string> editorData;

	//Vector used to queue the gameObjectEvents.
	std::vector<typeGameObjectEvent> eventQueue;

	//The themeManager.
	ThemeManager* customTheme;
	//The themeBackground.
	ThemeBackground* background;

	CachedTexture<int> collectablesTexture;
	CachedTexture<int> recordingsTexture;
	CachedTexture<int> timeTexture;
	CachedTexture<Block*> notificationTexture;

	//Load a level from node.
	//After calling this function the ownership of
	//node will transfer to Game class. So don't delete
	//the node after calling this function!
	virtual void loadLevelFromNode(ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode* obj, const std::string& fileName);

	//(internal function) Reload the music according to level music and level pack music.
	//This is mainly used in level editor.
	void reloadMusic();

	public:
	//Array used to convert GameObject type->string.
	static const char* blockName[TYPE_MAX];
	//Map used to convert GameObject string->type.
	static std::map<std::string,int> blockNameMap;

	//Map used to convert GameObjectEventType type->string.
	static std::map<int,std::string> gameObjectEventTypeMap;
	//Map used to convert GameObjectEventType string->type.
	static std::map<std::string,int> gameObjectEventNameMap;

	//Map used to convert LevelEventType type->string.
	static std::map<int,std::string> levelEventTypeMap;
	//Map used to convert LevelEventType string->type.
	static std::map<std::string,int> levelEventNameMap;

	//Boolean that is set to true when a game is won.
	bool won;

	//Boolean that is set to true when we should save game on next logic update.
	bool saveStateNextTime;

	//Boolean that is set to true when we should load game on next logic update.
	bool loadStateNextTime;

	//Boolean if the replaying currently done is for the interlevel screen.
	bool interlevel;

	//Integer containing the current tip index.
	int gameTipIndex;

	//Integer containing the number of ticks passed since the start of the level.
	int time;
	//Integer containing the stored value of time.
	int timeSaved;

	//Integer containing the number of recordings it took to finish.
	int recordings;
	//Integer containing the stored value of recordings.
	int recordingsSaved;

	//Integer keeping track of currently obtained collectables
	int currentCollectables;
	//Integer keeping track of total colletables in the level
	int totalCollectables;
	//Integer containing the stored value of current collectables
	int currentCollectablesSaved;

	//Time of recent swap, for achievements. (in game-ticks)
	int recentSwap,recentSwapSaved;

	//Store time of recent save/load for achievements (in millisecond)
	Uint32 recentLoad,recentSave;

	//Enumeration with the different camera modes.
	enum CameraMode{
	CAMERA_PLAYER,
	CAMERA_SHADOW,
	CAMERA_CUSTOM
	};
	//The current camera mode.
	CameraMode cameraMode;
	//Rectangle containing the target for the camera.
	SDL_Rect cameraTarget;

	//The saved cameraMode.
	CameraMode cameraModeSaved;
	SDL_Rect cameraTargetSaved;

	//Level scripts.
	std::map<int,std::string> scripts;

	//Compiled scripts. Use lua_rawgeti(L, LUA_REGISTRYINDEX, r) to get the function.
	std::map<int, int> compiledScripts, savedCompiledScripts, initialCompiledScripts;

	//Vector containing all the levelObjects in the current game.
	std::vector<Block*> levelObjects;

	//The layers for the scenery.
	// We utilize the fact that std::map is sorted, and we compare the layer name with "f",
	// If name<"f" then it's background layer, if name>="f" then it's foreground layer.
	// NOTE: the layer name is case sensitive, in particular if the name start with capital "F"
	// then it is still background layer.
	- std::map<std::string,std::vector<Scenery*> > sceneryLayers;
	+ std::map<std::string,SceneryLayer*> sceneryLayers;

	//The player...
	Player player;
	//... and his shadow.
	Shadow shadow;

	//warning: weak reference only, may point to invalid location
	Block* objLastCheckPoint;

	//Constructor.
	Game(SDL_Renderer& renderer, ImageManager& imageManager);
	//If this is not empty then when next Game class is created
	//it will play this record file.
	static std::string recordFile;
	//Destructor.
	//It will call destroy();
	~Game();

	//Method used to clean up the GameState.
	void destroy();

	//Inherited from GameState.
	void handleEvents(ImageManager&imageManager, SDL_Renderer&renderer) override;
	void logic(ImageManager& imageManager, SDL_Renderer& renderer) override;
	void render(ImageManager&,SDL_Renderer& renderer) override;
	void resize(ImageManager& imageManager, SDL_Renderer& renderer) override;

	//This method will load a level.
	//fileName: The fileName of the level.
	virtual void loadLevel(ImageManager& imageManager, SDL_Renderer& renderer, std::string fileName);

	//Method used to broadcast a GameObjectEvent.
	//eventType: The type of event.
	//objectType: The type of object that should react to the event.
	//id: The id of the blocks that should react.
	//target: Pointer to the object
	void broadcastObjectEvent(int eventType,int objectType=-1,const char* id=NULL,GameObject* target=NULL);

	//Compile all scripts and run onCreate script.
	//NOTE: Call this function only after script state reset, or there will be some memory leaks.
	void compileScript();

	//Method that will check if a script for a given levelEvent is present.
	//If that's the case the script will be executed.
	//eventType: The level event type to execute.
	void inline executeScript(int eventType);


	//Returns if the player and shadow can save the current state.
	bool canSaveState();

	//Method used to store the current state.
	//This is used for checkpoints.
	//Returns: True if it succeeds without problems.
	bool saveState();
	//Method used to load the stored state.
	//This is used for checkpoints.
	//Returns: True if it succeeds without problems.
	bool loadState();
	//Method that will reset the GameState to it's initial state.
	//save: Boolean if the saved state should also be deleted. This also means recreate the Lua context.
	//noScript: Boolean if we should not compile the script at all. This is used by level editor when exiting test play.
	void reset(bool save,bool noScript);

	//Save current game record to the file.
	//fileName: The filename of the destination file.
	void saveRecord(const char* fileName);
	//Load game record (and its level) from file and play it.
	//fileName: The filename of the recording file.
	void loadRecord(ImageManager& imageManager, SDL_Renderer& renderer, const char* fileName);

	//Method called by the player (or shadow) when he finished.
	void replayPlay(ImageManager& imageManager, SDL_Renderer &renderer);
	//Method that gets called when the recording has ended.
	void recordingEnded(ImageManager& imageManager, SDL_Renderer& renderer);

	//get current level's auto-save record path,
	//using current level's MD5, file name and other information.
	void getCurrentLevelAutoSaveRecordPath(std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath);

	//Method that will prepare the gamestate for the next level and start it.
	//If it's the last level it will show the congratulations text and return to the level select screen.
	void gotoNextLevel(ImageManager& imageManager, SDL_Renderer& renderer);

	//Get the name of the current level.
	const std::string& getLevelName(){
	return levelName;
	}

	//GUI event handling is done here.
	void GUIEventCallback_OnEvent(ImageManager&imageManager, SDL_Renderer&renderer, std::string name, GUIObject* obj, int eventType) override;

	//Get the script executor.
	ScriptExecutor* getScriptExecutor() {
	return scriptExecutor;
	}
	};

	#endif
	diff --git a/src/LevelEditor.cpp b/src/LevelEditor.cpp
	index 499fc22..ec201f0 100644
	--- a/src/LevelEditor.cpp
	+++ b/src/LevelEditor.cpp
	@@ -1,4609 +1,4556 @@
	/*
	* Copyright (C) 2011-2013 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "Block.h"
	#include "Commands.h"
	#include "CommandManager.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "LevelPack.h"
	#include "LevelEditor.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "GUIListBox.h"
	#include "GUITextArea.h"
	#include "GUIWindow.h"
	#include "GUISpinBox.h"
	#include "MusicManager.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include <fstream>
	#include <iostream>
	#include <vector>
	#include <algorithm>
	#include <string.h>
	#include <stdio.h>
	#include <sstream>

	#include <SDL_ttf.h>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	static int levelTime,levelRecordings;

	//Array containing translateble block names
	static const char* blockNames[TYPE_MAX]={
	__("Block"),__("Player Start"),__("Shadow Start"),
	__("Exit"),__("Shadow Block"),__("Spikes"),
	__("Checkpoint"),__("Swap"),__("Fragile"),
	__("Moving Block"),__("Moving Shadow Block"),__("Moving Spikes"),
	__("Teleporter"),__("Button"),__("Switch"),
	__("Conveyor Belt"),__("Shadow Conveyor Belt"),__("Notification Block"),__("Collectable"),__("Pushable")
	};

	static const std::array<const char*, static_cast<size_t>(ToolTips::TooltipMax)> tooltipNames = {
	__("Select"), __("Add"), __("Delete"), __("Play"), "", "", __("Level settings"), __("Save level"), __("Back to menu"), __("Configure")
	};


	//Array indicates if block is linkable
	static const bool isLinkable[TYPE_MAX]={
	false,false,false,
	false,false,false,
	false,false,false,
	true,true,true,
	true,true,true,
	false,false,false,false
	};

	static std::string describeSceneryName(const std::string& name) {
	//Check if the input is a valid block name.
	if (name.size() > 8 && name.substr(name.size() - 8) == "_Scenery") {
	auto it = Game::blockNameMap.find(name.substr(0, name.size() - 8));
	if (it != Game::blockNameMap.end()){
	return tfm::format(_("%s (Scenery)"), _(blockNames[it->second]));
	}
	}

	return name;
	}

	/////////////////LevelEditorActionsPopup/////////////////

	class LevelEditorActionsPopup:private GUIEventCallback{
	private:
	//The parent object.
	LevelEditor* parent;

	//The position and size of window.
	SDL_Rect rect;

	//Array containing the actions in this popup.
	GUIListBox* actions;

	//GUI image.
	SDL_Surface* bmGUI;

	//Pointer to the object the actions apply to.
	GameObject* target;

	//The behaviour names.
	vector<string> behaviour;
	//The fragile block states.
	vector<string> states;

	public:
	SDL_Rect getRect(){
	return rect;
	}
	void dismiss(){
	//Remove the actionsPopup from the parent.
	if(parent!=NULL && parent->actionsPopup==this){
	parent->actionsPopup=NULL;
	}

	//And delete ourself.
	delete this;
	}
	SharedTexture createItem(SDL_Renderer& renderer,const char* caption,int icon){
	//FIXME: Add some sort of caching?
	//We draw using surfaces and convert to a texture in the end for now.
	SurfacePtr tip(TTF_RenderUTF8_Blended(fontText,caption,objThemes.getTextColor(true)));
	SDL_SetSurfaceBlendMode(tip.get(), SDL_BLENDMODE_NONE);

	//Create the surface, we add 16px to the width for an icon,
	//plus 8px for the border to make it looks better.
	SurfacePtr item = createSurface(tip->w + 24 + (icon >= 0x100 ? 24 : 0), 24);

	//Draw the text on the item surface.
	applySurface(24 + (icon >= 0x100 ? 24 : 0), 0, tip.get(), item.get(), NULL);

	//Temporarily set the blend mode of bmGUI to none, which simply copies RGBA channels to destination.
	SDL_BlendMode oldBlendMode = SDL_BLENDMODE_BLEND;
	SDL_GetSurfaceBlendMode(bmGUI, &oldBlendMode);
	SDL_SetSurfaceBlendMode(bmGUI, SDL_BLENDMODE_NONE);

	//Check if we should draw an icon.
	if(icon>0){
	//Draw the check (or not).
	SDL_Rect r={0,0,16,16};
	r.x=((icon-1)%8)*16;
	r.y=(((icon-1)/8)%8)*16;
	applySurface(4,3,bmGUI,item.get(),&r);
	}

	//Check if we should draw a secondary icon.
	if (icon >= 0x100) {
	SDL_Rect r = { 0, 0, 16, 16 };
	r.x = ((icon / 0x100 - 1) % 8) * 16;
	r.y = (((icon / 0x100 - 1) / 8) % 8) * 16;
	applySurface(28, 3, bmGUI, item.get(), &r);
	}

	//Reset the blend mode of bmGUI.
	SDL_SetSurfaceBlendMode(bmGUI, oldBlendMode);

	//Check if we should update the width., 8px extra on the width is for four pixels spacing on either side.
	if(item->w+8>rect.w) {
	rect.w=item->w+8;
	}

	return textureFromSurface(renderer, std::move(item));
	}
	void updateListBoxSize() {
	//Update the size of the GUIListBox.
	actions->width = rect.w;
	actions->height = rect.h;

	int x = rect.x, y = rect.y;

	if (x>SCREEN_WIDTH - rect.w) x = SCREEN_WIDTH - rect.w;
	else if (x<0) x = 0;
	if (y>SCREEN_HEIGHT - rect.h) y = SCREEN_HEIGHT - rect.h;
	else if (y<0) y = 0;
	rect.x = x;
	rect.y = y;
	}
	void updateItem(SDL_Renderer& renderer,int index,const char* action,const char* caption,int icon=0){
	auto item=createItem(renderer,caption,icon);
	actions->updateItem(renderer, index,action,item);

	//Update the size of the GUIListBox.
	updateListBoxSize();
	}
	void addItem(SDL_Renderer& renderer,const char* action,const char* caption,int icon=0){
	auto item=createItem(renderer,caption,icon);
	actions->addItem(renderer,action,item);

	//Update the height.
	rect.h += 24;

	//Update the size of the GUIListBox.
	updateListBoxSize();
	}
	LevelEditorActionsPopup(ImageManager& imageManager,SDL_Renderer& renderer,LevelEditor* parent, GameObject* target, int x=0, int y=0){
	this->parent=parent;
	this->target=target;
	rect.x = x;
	rect.y = y;
	//NOTE: The size gets set in the addItem method, height is already four to prevent a scrollbar.
	rect.w=0;
	rect.h=4;

	//Load the gui images.
	bmGUI=imageManager.loadImage(getDataPath()+"gfx/gui.png");

	//Create the behaviour vector.
	behaviour.push_back(_("On"));
	behaviour.push_back(_("Off"));
	behaviour.push_back(_("Toggle"));

	//Create the states list.
	states.push_back(_("Complete"));
	states.push_back(_("One step"));
	states.push_back(_("Two steps"));
	states.push_back(_("Gone"));
	//TODO: The width should be based on the longest option.

	//Create default actions.
	//NOTE: Width and height are determined later on when the options are rendered.
	actions=new GUIListBox(imageManager,renderer,0,0,0,0);
	actions->eventCallback=this;

	//Check if it's a block or not.
	if(target!=NULL)
	addBlockItems(renderer);
	else
	addLevelItems(renderer);
	}

	static std::string getRepeatModeName(int mode) {
	switch (mode) {
	case Scenery::NEGATIVE_INFINITY:
	return _("Negative infinity");
	case Scenery::ZERO:
	return _("Zero");
	case Scenery::LEVEL_SIZE:
	return _("Level size");
	case Scenery::POSITIVE_INFINITY:
	return _("Positive infinity");
	default:
	return _("Default");
	}
	}

	void addBlockItems(SDL_Renderer& renderer){
	//Check if the block is selected or not.
	std::vector<GameObject*>::iterator it;
	it=find(parent->selection.begin(),parent->selection.end(),target);
	if(it!=parent->selection.end())
	addItem(renderer,"Deselect",_("Deselect"));
	else
	addItem(renderer,"Select",_("Select"));
	addItem(renderer,"Delete",_("Delete"),8);

	Scenery scenery = dynamic_cast<Scenery>(target);
	if (scenery) {
	// it is scenery block
	addItem(renderer, "RepeatMode0", tfm::format(_("Horizontal repeat start: %s"),
	getRepeatModeName(scenery->repeatMode & 0xFF)).c_str(), 8 * 2 + 3);
	addItem(renderer, "RepeatMode1", tfm::format(_("Horizontal repeat end: %s"),
	getRepeatModeName((scenery->repeatMode >> 8) & 0xFF)).c_str(), 8 * 2 + 4);
	addItem(renderer, "RepeatMode2", tfm::format(_("Vertical repeat start: %s"),
	getRepeatModeName((scenery->repeatMode >> 16) & 0xFF)).c_str(), 8 * 3 + 3);
	addItem(renderer, "RepeatMode3", tfm::format(_("Vertical repeat end: %s"),
	getRepeatModeName((scenery->repeatMode >> 24) & 0xFF)).c_str(), 8 * 3 + 4);

	if (scenery->sceneryName_.empty()) {
	addItem(renderer, "CustomScenery", _("Custom scenery"), 8 + 4);
	}

	return;
	}

	addItem(renderer, "Visible", _("Visible"), (target->getEditorProperty("visible") == "1") ? 2 : 1);

	//Get the type of the target.
	int type = target->type;

	//Determine what to do depending on the type.
	if(isLinkable[type]){
	//Check if it's a moving block type or trigger.
	if(type==TYPE_BUTTON \|\| type==TYPE_SWITCH \|\| type==TYPE_PORTAL){
	addItem(renderer,"Link",_("Link"),8*3);
	addItem(renderer,"Remove Links",_("Remove Links"));

	//Check if it's a portal, which contains a automatic option, and triggers a behaviour one.
	if(type==TYPE_PORTAL){
	addItem(renderer,"Automatic",_("Automatic"),(target->getEditorProperty("automatic")=="1")?2:1);
	}else{
	//Get the current behaviour.
	int currentBehaviour=2;
	if(target->getEditorProperty("behaviour")=="on"){
	currentBehaviour=0;
	}else if(target->getEditorProperty("behaviour")=="off"){
	currentBehaviour=1;
	}

	addItem(renderer,"Behaviour",behaviour[currentBehaviour].c_str());
	}
	}else{
	addItem(renderer,"Path",_("Path"),8+5);
	addItem(renderer,"Remove Path",_("Remove Path"));

	addItem(renderer,"Activated",_("Activated"),(target->getEditorProperty("activated")=="1")?2:1);
	addItem(renderer,"Looping",_("Looping"),(target->getEditorProperty("loop")=="1")?2:1);
	}
	}
	//Check for a conveyor belt.
	if(type==TYPE_CONVEYOR_BELT \|\| type==TYPE_SHADOW_CONVEYOR_BELT){
	addItem(renderer,"Activated",_("Activated"),(target->getEditorProperty("activated")=="1")?2:1);
	addItem(renderer,"Speed",_("Speed"));
	}
	//Check if it's a fragile block.
	if(type==TYPE_FRAGILE){
	//Get the current state.
	int currentState=atoi(target->getEditorProperty("state").c_str());
	addItem(renderer,"State",states[currentState].c_str());
	}
	//Check if it's a notification block.
	if(type==TYPE_NOTIFICATION_BLOCK)
	addItem(renderer,"Message",_("Message"));
	//Add the custom appearance menu item.
	addItem(renderer, "Appearance", _("Appearance"), 8 + 4);
	//Finally add scripting to the bottom.
	addItem(renderer,"Scripting",_("Scripting"),8*2+1);
	}

	void addLevelItems(SDL_Renderer& renderer){
	// add the layers
	{
	// background layers.
	- std::map<std::string, std::vector<Scenery*> >::iterator it;
	- for (it = parent->sceneryLayers.begin(); it != parent->sceneryLayers.end(); ++it){
	+ auto it = parent->sceneryLayers.begin();
	+ for (; it != parent->sceneryLayers.end(); ++it){
	if (it->first >= "f") break; // now we meet a foreground layer
	int icon = parent->layerVisibility[it->first] ? (8 * 3 + 1) : (8 * 3 + 2);
	icon \|= (parent->selectedLayer == it->first ? 2 : 1) << 8;
	std::string s = "_layer:" + it->first;
	addItem(renderer, s.c_str(), tfm::format(_("Background layer: %s"), it->first).c_str(), icon);
	}

	// the Blocks layer.
	{
	int icon = parent->layerVisibility[std::string()] ? (8 * 3 + 1) : (8 * 3 + 2);
	icon \|= (parent->selectedLayer.empty() ? 2 : 1) << 8;
	addItem(renderer, "_layer:", _("Blocks layer"), icon);
	}

	// foreground layers.
	for (; it != parent->sceneryLayers.end(); ++it){
	int icon = parent->layerVisibility[it->first] ? (8 * 3 + 1) : (8 * 3 + 2);
	icon \|= (parent->selectedLayer == it->first ? 2 : 1) << 8;
	std::string s = "_layer:" + it->first;
	addItem(renderer, s.c_str(), tfm::format(_("Foreground layer: %s"), it->first).c_str(), icon);
	}
	}

	addItem(renderer, "AddLayer", _("Add new layer"), 8 + 3);
	addItem(renderer, "DeleteLayer", _("Delete selected layer"), 8);
	addItem(renderer, "RenameLayer", _("Rename selected layer"));
	addItem(renderer, "MoveToLayer", _("Move selected object to layer"));

	addItem(renderer,"LevelSettings",_("Settings"),8*2);
	addItem(renderer,"LevelScripting",_("Scripting"),8*2+1);
	}

	virtual ~LevelEditorActionsPopup(){
	//bmGui is freed by imageManager.
	if(actions)
	delete actions;
	}

	void render(SDL_Renderer& renderer){
	//Draw the actions.
	actions->render(renderer,rect.x,rect.y);
	}
	void handleEvents(SDL_Renderer& renderer){
	//Check if a mouse is pressed outside the popup.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};
	if(event.type==SDL_MOUSEBUTTONDOWN && !checkCollision(mouse,rect)){
	dismiss();
	return;
	}
	//Let the listbox handle its events.
	actions->handleEvents(renderer,rect.x,rect.y);
	}
	static void addLayerNameNote(ImageManager& imageManager, SDL_Renderer& renderer, GUIWindow *root, int yy = 148) {
	std::string s = _("NOTE: the layers are sorted by name alphabetically.\nThe layer is background layer if its name is < 'f'\nby dictionary order, otherwise it's foreground layer.");
	for (int lps = 0;;) {
	size_t lpe = s.find_first_of('\n', lps);

	GUIObject *obj = new GUILabel(imageManager, renderer, 40, yy, 520, 36,
	lpe == string::npos ? (s.c_str() + lps) : s.substr(lps, lpe - lps).c_str());
	root->addChild(obj);

	if (lpe == string::npos) break;
	lps = lpe + 1;
	yy += 24;
	}
	}
	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//NOTE: There should only be one GUIObject, so we know what event is fired.
	//Get the selected entry.
	std::string action=actions->item[actions->value];
	if(action=="Select"){
	//Add the target to the selection.
	parent->selection.push_back(target);
	dismiss();
	return;
	}else if(action=="Deselect"){
	//Check if the block is in the selection.
	std::vector<GameObject*>::iterator it;
	it=find(parent->selection.begin(),parent->selection.end(),target);
	if(it!=parent->selection.end()){
	//Remove the object from the selection.
	parent->selection.erase(it);
	}

	dismiss();
	return;
	}else if(action=="Delete"){
	parent->commandManager->doCommand(new AddRemoveGameObjectCommand(parent, target, false));
	dismiss();
	return;
	}else if(action=="Link"){
	parent->linking=true;
	parent->linkingTrigger=dynamic_cast<Block*>(target);
	parent->tool=LevelEditor::SELECT;
	dismiss();
	return;
	}else if(action=="Remove Links"){
	//Remove all the links
	Block block = dynamic_cast<Block>(target);
	if (block) {
	RemoveLinkCommand* pCommand = new RemoveLinkCommand(parent, block);
	parent->commandManager->doCommand(pCommand);
	}

	dismiss();
	return;
	}else if(action=="Path"){
	parent->moving=true;
	parent->pauseMode = false;
	parent->pauseTime = 0;
	parent->movingBlock=dynamic_cast<Block*>(target);
	parent->tool=LevelEditor::SELECT;
	dismiss();
	return;
	}else if(action=="Remove Path"){
	//Remove all the paths
	Block block = dynamic_cast<Block>(target);
	if (block) {
	RemovePathCommand* pCommand = new RemovePathCommand(parent, block);
	parent->commandManager->doCommand(pCommand);
	}

	dismiss();
	return;
	}else if(action=="Message"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-250)/2,600,250,true,true,_("Notification block"));
	root->name="notificationBlockWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	obj=new GUILabel(imageManager,renderer,40,50,240,36,_("Enter message here:"));
	root->addChild(obj);
	GUITextArea* textarea=new GUITextArea(imageManager,renderer,50,90,500,100);
	//Set the name of the text area, which is used to identify the object later on.
	textarea->name="message";
	string tmp=target->getEditorProperty("message");
	//Change \n with the characters '\n'.
	while(tmp.find("\\n")!=string::npos){
	tmp=tmp.replace(tmp.find("\\n"),2,"\n");
	}
	textarea->setString(renderer, tmp);
	root->addChild(textarea);

	obj=new GUIButton(imageManager,renderer,root->width*0.3,250-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgNotificationBlockOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,250-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="Activated"){
	//Get the previous state.
	bool enabled=(target->getEditorProperty("activated")=="1");

	//Switch the state.
	enabled=!enabled;

	parent->commandManager->doCommand(new SetEditorPropertyCommand(parent, imageManager, renderer,
	target, "activated", enabled ? "1" : "0", _("Activated")));

	updateItem(renderer,actions->value,"Activated",_("Activated"),enabled?2:1);
	actions->value=-1;
	return;
	} else if (action == "Visible"){
	//Get the previous state.
	bool visible = (target->getEditorProperty("visible") == "1");

	//Switch the state.
	visible = !visible;

	parent->commandManager->doCommand(new SetEditorPropertyCommand(parent, imageManager, renderer,
	target, "visible", visible ? "1" : "0", _("Visible")));

	updateItem(renderer, actions->value, "Visible", _("Visible"), visible ? 2 : 1);
	actions->value = -1;
	return;
	} else if (action == "Looping"){
	//Get the previous state.
	bool loop=(target->getEditorProperty("loop")=="1");

	//Switch the state.
	loop=!loop;
	parent->commandManager->doCommand(new SetEditorPropertyCommand(parent, imageManager, renderer,
	target, "loop", loop ? "1" : "0", _("Looping")));

	updateItem(renderer,actions->value,"Looping",_("Looping"),loop?2:1);
	actions->value=-1;
	return;
	}else if(action=="Automatic"){
	//Get the previous state.
	bool automatic=(target->getEditorProperty("automatic")=="1");

	//Switch the state.
	automatic=!automatic;
	parent->commandManager->doCommand(new SetEditorPropertyCommand(parent, imageManager, renderer,
	target, "automatic", automatic ? "1" : "0", _("Automatic")));

	updateItem(renderer,actions->value,"Automatic",_("Automatic"),automatic?2:1);
	actions->value=-1;
	return;
	}else if(action=="Behaviour"){
	//Get the current behaviour.
	int currentBehaviour=2;
	string behave=target->getEditorProperty("behaviour");
	if(behave=="on"){
	currentBehaviour=0;
	}else if(behave=="off"){
	currentBehaviour=1;
	}

	//Increase the behaviour.
	currentBehaviour++;
	if(currentBehaviour>2)
	currentBehaviour=0;

	//Update the data of the block.
	parent->commandManager->doCommand(new SetEditorPropertyCommand(parent, imageManager, renderer,
	target, "behaviour", behaviour[currentBehaviour], _("Behaviour")));

	//And update the item.
	updateItem(renderer,actions->value,"Behaviour",behaviour[currentBehaviour].c_str());
	actions->value=-1;
	return;
	}else if(action=="State"){
	//Get the current state.
	int currentState=atoi(target->getEditorProperty("state").c_str());

	//Increase the state.
	currentState++;
	if(currentState>3)
	currentState=0;

	//Update the data of the block.
	char s[64];
	sprintf(s,"%d",currentState);
	parent->commandManager->doCommand(new SetEditorPropertyCommand(parent, imageManager, renderer,
	target, "state", s, _("State")));

	//And update the item.
	updateItem(renderer,actions->value,"State",states[currentState].c_str());
	actions->value=-1;
	return;
	}else if(action=="Speed"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-250)/2,600,250,true,true,_("Conveyor belt speed"));
	root->name="conveyorBlockWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	obj=new GUILabel(imageManager,renderer,40,100,240,36,_("Enter speed here:"));
	root->addChild(obj);
	GUISpinBox* obj2=new GUISpinBox(imageManager,renderer,240,100,320,36);
	//Set the name of the text area, which is used to identify the object later on.
	obj2->name="speed";
	obj2->caption=target->getEditorProperty("speed10");
	obj2->format = "%1.0f";
	obj2->update();
	root->addChild(obj2);

	obj = new GUILabel(imageManager, renderer, 40, 160, 520, 36, _("NOTE: 1 Speed = 0.08 block/s"));
	root->addChild(obj);

	obj=new GUIButton(imageManager,renderer,root->width*0.3,250-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgConveyorBlockOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,250-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="Scripting"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-500)/2,600,500,true,true,_("Scripting"));
	root->name="scriptingWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	obj=new GUILabel(imageManager,renderer,50,60,240,36,_("Id:"));
	root->addChild(obj);

	obj=new GUITextBox(imageManager,renderer,100,60,240,36,dynamic_cast<Block*>(target)->id.c_str());
	obj->name="id";
	root->addChild(obj);

	GUISingleLineListBox* list=new GUISingleLineListBox(imageManager,renderer,50,100,500,36);
	std::map<std::string,int>::iterator it;
	for(it=Game::gameObjectEventNameMap.begin();it!=Game::gameObjectEventNameMap.end();++it)
	list->addItem(it->first);
	list->name="cfgScriptingEventType";
	list->value=0;
	list->eventCallback=root;
	root->addChild(list);

	//Add a text area for each event type.
	Block* block=dynamic_cast<Block*>(target);
	for(unsigned int i=0;i<list->item.size();i++){
	GUITextArea* text=new GUITextArea(imageManager,renderer,50,140,500,300);
	text->name=list->item[i].first;
	text->setFont(fontMono);
	//Only set the first one visible and enabled.
	text->visible=(i==0);
	text->enabled=(i==0);

	map<int,string>::iterator it=block->scripts.find(Game::gameObjectEventNameMap[list->item[i].first]);
	if(it!=block->scripts.end())
	text->setString(renderer, it->second);

	root->addChild(text);
	}


	obj=new GUIButton(imageManager,renderer,root->width*0.3,500-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgScriptingOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,500-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="LevelSettings"){
	//Open the levelSettings window.
	parent->levelSettings(imageManager,renderer);

	//And dismiss this popup.
	dismiss();
	return;
	}else if(action=="LevelScripting"){
	//Create the GUI.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-500)/2,600,500,true,true,_("Level Scripting"));
	root->name="levelScriptingWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	GUISingleLineListBox* list=new GUISingleLineListBox(imageManager,renderer,50,60,500,36);
	std::map<std::string,int>::iterator it;
	for(it=Game::levelEventNameMap.begin();it!=Game::levelEventNameMap.end();++it)
	list->addItem(it->first);
	list->name="cfgLevelScriptingEventType";
	list->value=0;
	list->eventCallback=root;
	root->addChild(list);

	//Add a text area for each event type.
	for(unsigned int i=0;i<list->item.size();i++){
	GUITextArea* text=new GUITextArea(imageManager,renderer,50,100,500,340);
	text->name=list->item[i].first;
	text->setFont(fontMono);
	//Only set the first one visible and enabled.
	text->visible=(i==0);
	text->enabled=(i==0);

	map<int,string>::iterator it=parent->scripts.find(Game::levelEventNameMap[list->item[i].first]);
	if(it!=parent->scripts.end())
	text->setString(renderer, it->second);

	root->addChild(text);
	}


	obj=new GUIButton(imageManager,renderer,root->width*0.3,500-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgLevelScriptingOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,500-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root]=target;

	//And dismiss this popup.
	dismiss();
	return;
	} else if (action.size() >= 7 && action.substr(0, 7) == "_layer:") {
	std::string s0 = action.substr(7);
	auto it = parent->layerVisibility.find(s0);
	if (it != parent->layerVisibility.end()) {
	int x;
	SDL_GetMouseState(&x, NULL);
	if (x < rect.x + 24) {
	// toggle the visibility
	it->second = !it->second;

	if (parent->selectedLayer == it->first) {
	// deselect all blocks if the visibility of current layer is changed
	parent->deselectAll();
	}
	} else if (parent->selectedLayer != it->first) {
	// deselect all blocks if the selected layer is changed
	parent->deselectAll();

	// uncheck the previously selected layer
	std::string oldSelected = "_layer:" + parent->selectedLayer;
	for (unsigned int idx = 0; idx < actions->item.size(); idx++) {
	if (actions->item[idx] == oldSelected) {
	int icon = parent->layerVisibility[parent->selectedLayer] ? (8 * 3 + 1) : (8 * 3 + 2);
	icon \|= 1 << 8;
	updateItem(renderer, idx, oldSelected.c_str(),
	parent->selectedLayer.empty() ? _("Blocks layer") :
	tfm::format((parent->selectedLayer < "f") ? _("Background layer: %s") : _("Foreground layer: %s"), parent->selectedLayer).c_str(),
	icon);
	break;
	}
	}

	// change the selected layer
	parent->selectedLayer = it->first;
	} else {
	actions->value = -1;
	return;
	}

	int icon = it->second ? (8 * 3 + 1) : (8 * 3 + 2);
	icon \|= (parent->selectedLayer == it->first ? 2 : 1) << 8;
	std::string s = "_layer:" + it->first;
	updateItem(renderer, actions->value, s.c_str(),
	it->first.empty() ? _("Blocks layer") :
	tfm::format((it->first < "f") ? _("Background layer: %s") : _("Foreground layer: %s"), it->first).c_str(),
	icon);
	}
	actions->value = -1;
	return;
	} else if (action == "AddLayer") {
	//Create the add layer GUI.
	GUIWindow* root = new GUIWindow(imageManager, renderer, (SCREEN_WIDTH - 600) / 2, (SCREEN_HEIGHT - 300) / 2, 600, 300, true, true, _("Add layer"));
	root->name = "addLayerWindow";
	root->eventCallback = parent;
	GUIObject* obj;

	obj = new GUILabel(imageManager, renderer, 40, 64, 520, 36, _("Enter the layer name:"));
	root->addChild(obj);
	GUITextBox* obj2 = new GUITextBox(imageManager, renderer, 40, 100, 520, 36);
	//Set the name of the text area, which is used to identify the object later on.
	obj2->name = "layerName";
	root->addChild(obj2);

	addLayerNameNote(imageManager, renderer, root);

	obj = new GUIButton(imageManager, renderer, root->width*0.3, 300 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgAddLayerOK";
	obj->eventCallback = root;
	root->addChild(obj);
	obj = new GUIButton(imageManager, renderer, root->width*0.7, 300 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgCancel";
	obj->eventCallback = root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root] = target;

	//And dismiss this popup.
	dismiss();
	return;
	} else if (action == "DeleteLayer") {
	// delete selected layer
	if (parent->selectedLayer.empty()) {
	// can't delete Blocks layer
	actions->value = -1;
	return;
	}

	if (parent->sceneryLayers.find(parent->selectedLayer) == parent->sceneryLayers.end()) {
	// can't find the layer with given name
	actions->value = -1;
	return;
	}

	if (msgBox(imageManager, renderer,
	tfm::format(_("Are you sure you want to delete layer '%s'?"), parent->selectedLayer).c_str(),
	MsgBoxYesNo, _("Delete layer")) == MsgBoxYes)
	{
	// do the actual operation
	parent->commandManager->doCommand(new AddRemoveLayerCommand(parent, parent->selectedLayer, false));
	}

	dismiss();
	return;
	} else if (action == "RenameLayer") {
	// rename selected layer
	if (parent->selectedLayer.empty()) {
	// can't rename Blocks layer
	actions->value = -1;
	return;
	}

	auto it = parent->sceneryLayers.find(parent->selectedLayer);
	if (it == parent->sceneryLayers.end()) {
	// can't find the layer with given name
	actions->value = -1;
	return;
	}

	//Create the rename layer GUI.
	GUIWindow* root = new GUIWindow(imageManager, renderer, (SCREEN_WIDTH - 600) / 2, (SCREEN_HEIGHT - 300) / 2, 600, 300, true, true, _("Rename layer"));
	root->name = "renameLayerWindow";
	root->eventCallback = parent;
	GUIObject* obj;

	obj = new GUILabel(imageManager, renderer, 40, 64, 520, 36, tfm::format(_("Enter the new name for layer '%s':"), it->first).c_str());
	root->addChild(obj);
	GUITextBox* obj2 = new GUITextBox(imageManager, renderer, 40, 100, 520, 36, it->first.c_str());
	//Set the name of the text area, which is used to identify the object later on.
	obj2->name = "layerName";
	root->addChild(obj2);

	// A stupid code to save the old name
	obj = new GUIObject(imageManager, renderer, 0, 0, 0, 0, it->first.c_str(), 0, false, false);
	obj->name = "oldName";
	root->addChild(obj);

	addLayerNameNote(imageManager, renderer, root);

	obj = new GUIButton(imageManager, renderer, root->width*0.3, 300 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgRenameLayerOK";
	obj->eventCallback = root;
	root->addChild(obj);
	obj = new GUIButton(imageManager, renderer, root->width*0.7, 300 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgCancel";
	obj->eventCallback = root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root] = target;

	//And dismiss this popup.
	dismiss();
	return;
	} else if (action == "MoveToLayer") {
	// move the selected object to another layer
	if (parent->selection.empty() \|\| parent->selectedLayer.empty()) {
	// either nothing selected, or can't move objects in Blocks layer
	actions->value = -1;
	return;
	}

	//Create the rename layer GUI.
	GUIWindow* root = new GUIWindow(imageManager, renderer, (SCREEN_WIDTH - 600) / 2, (SCREEN_HEIGHT - 300) / 2, 600, 300, true, true, _("Move to layer"));
	root->name = "moveToLayerWindow";
	root->eventCallback = parent;
	GUIObject* obj;

	obj = new GUILabel(imageManager, renderer, 40, 64, 520, 36, _("Enter the layer name (create new layer if necessary):"));
	root->addChild(obj);
	GUITextBox* obj2 = new GUITextBox(imageManager, renderer, 40, 100, 520, 36, parent->selectedLayer.c_str());
	//Set the name of the text area, which is used to identify the object later on.
	obj2->name = "layerName";
	root->addChild(obj2);

	// A stupid code to save the old name
	obj = new GUIObject(imageManager, renderer, 0, 0, 0, 0, parent->selectedLayer.c_str(), 0, false, false);
	obj->name = "oldName";
	root->addChild(obj);

	addLayerNameNote(imageManager, renderer, root);

	obj = new GUIButton(imageManager, renderer, root->width*0.3, 300 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgMoveToLayerOK";
	obj->eventCallback = root;
	root->addChild(obj);
	obj = new GUIButton(imageManager, renderer, root->width*0.7, 300 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgCancel";
	obj->eventCallback = root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root] = target;

	//And dismiss this popup.
	dismiss();
	return;
	} else if (action.size() > 10 && action.substr(0, 10) == "RepeatMode") {
	Scenery scenery = dynamic_cast<Scenery>(target);
	if (scenery) {
	int index = atoi(action.c_str() + 10);
	assert(index >= 0 && index < 4);

	//Get the current repeat mode.
	unsigned int repeatMode = scenery->repeatMode;

	//Extract the value we want to modify.
	unsigned int i = (repeatMode >> (index * 8)) & 0xFF;
	repeatMode &= ~(0xFFu << (index * 8));

	//Increase the value.
	for (;;) {
	i++;
	if (i >= Scenery::REPEAT_MODE_MAX) i = 0;

	// skip invalid values (POSITIVE_INFINITY for start, NEGATIVE_INFINITY for end)
	if ((index & 1) == 0 && i == Scenery::POSITIVE_INFINITY) continue;
	if ((index & 1) == 1 && i == Scenery::NEGATIVE_INFINITY) continue;

	break;
	}

	//Update the repeat mode of the block.
	char s[64];
	sprintf(s, "%u", repeatMode \| (i << (index * 8)));
	parent->commandManager->doCommand(new SetEditorPropertyCommand(parent, imageManager, renderer,
	target, "repeatMode", s, _("Repeat mode")));

	//And update the item.
	const char* ss[4] = {
	__("Horizontal repeat start: %s"),
	__("Horizontal repeat end: %s"),
	__("Vertical repeat start: %s"),
	__("Vertical repeat end: %s"),
	};
	const int icons[4] = {
	8 * 2 + 3, 8 * 2 + 4, 8 * 3 + 3, 8 * 3 + 4,
	};
	updateItem(renderer, actions->value, action.c_str(), tfm::format(_(ss[index]), getRepeatModeName(i)).c_str(), icons[index]);
	}
	actions->value = -1;
	return;
	} else if (action == "CustomScenery") {
	//Create the GUI.
	GUIWindow* root = new GUIWindow(imageManager, renderer, (SCREEN_WIDTH - 600) / 2, (SCREEN_HEIGHT - 400) / 2, 600, 400, true, true, _("Custom scenery"));
	root->name = "customSceneryWindow";
	root->eventCallback = parent;
	GUIObject* obj;

	obj = new GUILabel(imageManager, renderer, 50, 60, 240, 36, _("Custom scenery:"));
	root->addChild(obj);

	//Add a text area.
	Scenery* scenery = dynamic_cast<Scenery*>(target);
	GUITextArea* text = new GUITextArea(imageManager, renderer, 50, 100, 500, 240);
	text->name = "cfgCustomScenery";
	text->setFont(fontMono);
	//Only set the first one visible and enabled.
	text->visible = true;
	text->enabled = true;

	// FIXME: an ad-hoc code
	std::string s;
	for (char c : scenery->customScenery_) {
	if (c == '\t')
	s.append(" ");
	else
	s.push_back(c);
	}
	text->setString(renderer, s);
	root->addChild(text);

	obj = new GUIButton(imageManager, renderer, root->width*0.3, 400 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgCustomSceneryOK";
	obj->eventCallback = root;
	root->addChild(obj);
	obj = new GUIButton(imageManager, renderer, root->width*0.7, 400 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgCancel";
	obj->eventCallback = root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root] = target;

	//And dismiss this popup.
	dismiss();
	return;
	} else if (action == "Appearance"){
	//Create the GUI.
	GUIWindow* root = new GUIWindow(imageManager, renderer, (SCREEN_WIDTH - 600) / 2, (SCREEN_HEIGHT - 400) / 2, 600, 400, true, true, _("Appearance"));
	root->name = "appearanceWindow";
	root->eventCallback = parent;
	GUIObject* obj;

	Block* block = dynamic_cast<Block*>(target);

	//Create a list box showing all available scenery blocks.
	GUIListBox *list = new GUIListBox(imageManager, renderer, 50, 60, 440, 280);
	list->name = "lstAppearance";
	list->eventCallback = root;
	root->addChild(list);

	//TODO: Show the image along with the text in the list box.
	//Currently I don't like to do that because this requires a lot of video memory since there are a lot of available scenery blocks.
	list->addItem(renderer, _("(Use the default appearance for this block)"));
	if (block->customAppearanceName.empty()) list->value = 0;
	for (const std::string& s : parent->sceneryBlockNames) {
	list->addItem(renderer, describeSceneryName(s));
	if (block->customAppearanceName == s) list->value = list->item.size() - 1;
	}
	if (list->value < 0) {
	std::cerr << "WARNING: The custom appearance '" << block->customAppearanceName << "' is unrecognized, added it to the list box anyway" << std::endl;
	list->addItem(renderer, block->customAppearanceName);
	list->value = list->item.size() - 1;
	}

	//Ask the list box to update scrollbar and we scroll the scrollbar to the correct position (FIXME: ad-hoc code)
	list->render(renderer, 0, 0, false);
	list->scrollScrollbar(list->value);

	//Create an image widget showing the appearance of selected scenery block.
	GUIImage *image = new GUIImage(imageManager, renderer, 500, 60, 50, 50);
	image->name = "imgAppearance";
	root->addChild(image);

	//Add a Change event to the list box which will be processed next frame, which is used to update the image widget.
	GUIEventQueue.push_back(GUIEvent{ list->eventCallback, list->name, list, GUIEventChange });

	obj = new GUIButton(imageManager, renderer, root->width*0.3, 400 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgAppearanceOK";
	obj->eventCallback = root;
	root->addChild(obj);
	obj = new GUIButton(imageManager, renderer, root->width*0.7, 400 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	obj->name = "cfgCancel";
	obj->eventCallback = root;
	root->addChild(obj);

	//Add the window to the GUIObjectRoot and the objectWindows map.
	GUIObjectRoot->addChild(root);
	parent->objectWindows[root] = target;

	//And dismiss this popup.
	dismiss();
	return;
	}
	}
	};


	/////////////////LevelEditorSelectionPopup/////////////////

	class LevelEditorSelectionPopup{
	private:
	//The parent object.
	LevelEditor* parent;

	//The position of window.
	SDL_Rect rect;

	//GUI image.
	SharedTexture bmGUI;

	//The selection
	std::vector<GameObject*> selection;

	//The scrollbar.
	GUIScrollBar* scrollBar;

	//Highlighted object.
	GameObject* highlightedObj;

	//Highlighted button index. 0=none 1=select/deselect 2=delete 3=configure
	int highlightedBtn;
	public:
	int startRow,showedRow;

	//If selection is dirty
	bool dirty;

	public:
	SDL_Rect getRect(){
	return rect;
	}
	int width(){
	return rect.w;
	}
	int height(){
	return rect.h;
	}
	void updateScrollBar(ImageManager& imageManager, SDL_Renderer& renderer){
	int m=selection.size()-showedRow;
	if(m>0){
	if(startRow<0) startRow=0;
	else if(startRow>m) startRow=m;

	if(scrollBar==NULL){
	scrollBar=new GUIScrollBar(imageManager,renderer,0,0,16,rect.h-16,ScrollBarVertical,startRow,0,m,1,showedRow);
	}

	scrollBar->visible=true;
	scrollBar->maxValue=m;
	scrollBar->value=startRow;
	}else{
	startRow=0;
	if(scrollBar){
	scrollBar->visible=false;
	scrollBar->value=0;
	}
	}
	}
	void updateSelection(ImageManager& imageManager, SDL_Renderer& renderer){
	if(parent!=NULL){
	std::vector<Block*>& v=parent->levelObjects;

	for(int i=selection.size()-1;i>=0;i--){
	if(find(v.begin(),v.end(),selection[i])==v.end()){
	selection.erase(selection.begin()+i);
	}
	}

	updateScrollBar(imageManager,renderer);
	}
	}
	void dismiss(){
	if(parent!=NULL && parent->selectionPopup==this){
	parent->selectionPopup=NULL;
	}
	delete this;
	}
	LevelEditorSelectionPopup(LevelEditor* parent, ImageManager& imageManager, SDL_Renderer& renderer, std::vector<GameObject*>& selection, int x=0, int y=0){
	this->parent=parent;
	this->selection=selection;

	dirty=false;
	scrollBar=NULL;
	highlightedObj=NULL;
	highlightedBtn=0;

	//calc window size
	startRow=0;
	showedRow=selection.size();
	int m=SCREEN_HEIGHT/64-1;
	if(showedRow>m) showedRow=m;

	rect.w=320;
	rect.h=showedRow*64+16;

	if(x>SCREEN_WIDTH-rect.w) x=SCREEN_WIDTH-rect.w;
	else if(x<0) x=0;
	if(y>SCREEN_HEIGHT-rect.h) y=SCREEN_HEIGHT-rect.h;
	else if(y<0) y=0;
	rect.x=x;
	rect.y=y;

	updateScrollBar(imageManager,renderer);

	//Load the gui images.
	bmGUI=imageManager.loadTexture(getDataPath()+"gfx/gui.png",renderer);
	}
	virtual ~LevelEditorSelectionPopup(){
	if(scrollBar)
	delete scrollBar;
	}
	void move(int x,int y){
	if(x>SCREEN_WIDTH-rect.w) x=SCREEN_WIDTH-rect.w;
	else if(x<0) x=0;
	if(y>SCREEN_HEIGHT-rect.h) y=SCREEN_HEIGHT-rect.h;
	else if(y<0) y=0;
	rect.x=x;
	rect.y=y;
	}
	void render(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check dirty
	if(dirty){
	updateSelection(imageManager,renderer);
	if(selection.empty()){
	dismiss();
	return;
	}
	dirty=false;
	}

	//background
	drawGUIBox(rect.x,rect.y,rect.w,rect.h,renderer,0xFFFFFFFFU);

	//get mouse position
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//the tool tip of item
	SDL_Rect tooltipRect;
	//string tooltip;

	if(scrollBar && scrollBar->visible){
	startRow=scrollBar->value;
	}

	highlightedObj=NULL;
	highlightedBtn=0;

	ToolTips toolTip = ToolTips::TooltipMax;

	//draw avaliable item
	for(int i=0;i<showedRow;i++){
	int j=startRow+i;
	if(j>=(int)selection.size()) break;

	SDL_Rect r={rect.x+8,rect.y+i*64+8,rect.w-16,64};
	if(scrollBar && scrollBar->visible) r.w-=24;

	//check highlight
	if(checkCollision(mouse,r)){
	highlightedObj=selection[j];
	//0xCCCCCC
	SDL_SetRenderDrawColor(&renderer,0xCC,0xCC,0xCC,0xFF);
	SDL_RenderFillRect(&renderer,&r);
	}

	const int type = selection[j]->type;
	Scenery scenery = dynamic_cast<Scenery>(selection[j]);
	if (scenery) {
	if (scenery->themeBlock == &(scenery->internalThemeBlock)) {
	// custom scenery, draw an ad-hoc stupid icon
	if (parent) {
	const SDL_Rect srcRect = { 48, 16, 16, 16 };
	const SDL_Rect dstRect = { r.x + 7, r.y + 7, 16, 16 };
	SDL_RenderCopy(&renderer, parent->bmGUI.get(), &srcRect, &dstRect);
	}
	} else {
	scenery->themeBlock->editorPicture.draw(renderer, r.x + 7, r.y + 7);
	}
	} else {
	//draw tile picture
	ThemeBlock* obj = objThemes.getBlock(type);
	if (obj){
	//obj->editorPicture.draw(screen,r.x+7,r.y+7);
	obj->editorPicture.draw(renderer, r.x + 7, r.y + 7);
	}
	}

	if(parent!=NULL){
	//draw name
	TexturePtr& tex = scenery ? (parent->getCachedTextTexture(renderer, scenery->sceneryName_.empty()
	? std::string(_("Custom scenery block")) : describeSceneryName(scenery->sceneryName_)))
	: parent->typeTextTextures.at(type);
	if (tex) {
	applyTexture(r.x + 64, r.y + (64 - textureHeight(tex)) / 2, tex, renderer);
	}

	//draw selected
	{
	std::vector<GameObject*> &v=parent->selection;
	bool isSelected=find(v.begin(),v.end(),selection[j])!=v.end();

	SDL_Rect r1={isSelected?16:0,0,16,16};
	SDL_Rect r2={r.x+r.w-72,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Select");
	highlightedBtn=1;
	toolTip=ToolTips::Select;
	}
	r2.x+=4;
	r2.y+=4;
	r2.w=r1.w;
	r2.h=r1.h;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r1,&r2);
	}

	//draw delete
	{
	SDL_Rect r1={112,0,16,16};
	SDL_Rect r2={r.x+r.w-48,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Delete");
	highlightedBtn=2;
	toolTip=ToolTips::Delete;
	}
	r2.x+=4;
	r2.y+=4;
	r2.w=r1.w;
	r2.h=r1.h;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r1,&r2);
	}

	//draw configure
	{
	SDL_Rect r1={112,16,16,16};
	SDL_Rect r2={r.x+r.w-24,r.y+20,24,24};
	if(checkCollision(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Configure");
	toolTip=ToolTips::Configure;
	highlightedBtn=3;
	}
	r2.x+=4;
	r2.y+=4;
	r2.w=r1.w;
	r2.h=r1.h;
	SDL_RenderCopy(&renderer, bmGUI.get(),&r1,&r2);
	}
	}
	}

	//draw scrollbar
	if(scrollBar && scrollBar->visible){
	scrollBar->render(renderer,rect.x+rect.w-24,rect.y+8);
	}

	//draw tooltip
	if(parent && int(toolTip) < parent->tooltipTextures.size()){
	//Tool specific text.
	TexturePtr& tip=parent->tooltipTextures.at(size_t(toolTip));

	//Draw only if there's a tooltip available
	if(tip){
	const auto tipSize = rectFromTexture(tip);
	tooltipRect.y-=4;
	tooltipRect.h+=8;
	if(tooltipRect.y+tooltipRect.h+tipSize.h>SCREEN_HEIGHT-20)
	tooltipRect.y-=tipSize.h;
	else
	tooltipRect.y+=tooltipRect.h;

	if(tooltipRect.x+tipSize.w>SCREEN_WIDTH-20)
	tooltipRect.x=SCREEN_WIDTH-20-tipSize.w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(tooltipRect.x-2,tooltipRect.y-2,tipSize.w+4,tipSize.h+4,renderer,color);

	//Draw tooltip's text
	applyTexture(tooltipRect.x,tooltipRect.y,tip,renderer);
	}
	}
	}
	void handleEvents(ImageManager& imageManager,SDL_Renderer& renderer){
	//Check dirty
	if(dirty){
	updateSelection(imageManager,renderer);
	if(selection.empty()){
	dismiss();
	return;
	}
	dirty=false;
	}

	//Check scrollbar event
	if(scrollBar && scrollBar->visible){
	if(scrollBar->handleEvents(renderer,rect.x+rect.w-24,rect.y+8)) return;
	}

	if(event.type==SDL_MOUSEBUTTONDOWN){
	if(event.button.button==SDL_BUTTON_LEFT){
	SDL_Rect mouse={event.button.x,event.button.y,0,0};

	//Check if close it
	if(!checkCollision(mouse,rect)){
	dismiss();
	return;
	}

	//Check if item is clicked
	if(highlightedObj!=NULL && highlightedBtn>0 && parent!=NULL){
	//std::vector<Block*>& v=parent->levelObjects;

	if(/find(v.begin(),v.end(),highlightedObj)!=v.end()/true/???/){
	switch(highlightedBtn){
	case 1:
	{
	std::vector<GameObject*>& v2=parent->selection;
	std::vector<GameObject*>::iterator it=find(v2.begin(),v2.end(),highlightedObj);

	if(it==v2.end()){
	v2.push_back(highlightedObj);
	}else{
	v2.erase(it);
	}
	}
	break;
	case 2:
	parent->commandManager->doCommand(new AddRemoveGameObjectCommand(parent, highlightedObj, false));
	break;
	case 3:
	if(parent->actionsPopup)
	delete parent->actionsPopup;
	parent->actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,parent,highlightedObj,mouse.x,mouse.y);
	break;
	}
	}
	}
	}
	}
	else if(event.type == SDL_MOUSEWHEEL) {
	//check mousewheel
	if(event.wheel.y < 0){
	startRow-=2;
	updateScrollBar(imageManager,renderer);
	return;
	} else {
	startRow+=2;
	updateScrollBar(imageManager,renderer);
	return;
	}
	}
	}
	};

	/////////////////MovingPosition////////////////////////////
	MovingPosition::MovingPosition(int x,int y,int time){
	this->x=x;
	this->y=y;
	this->time=time;
	}

	MovingPosition::~MovingPosition(){}

	void MovingPosition::updatePosition(int x,int y){
	this->x=x;
	this->y=y;
	}

	/////////////////LEVEL EDITOR//////////////////////////////
	LevelEditor::LevelEditor(SDL_Renderer& renderer, ImageManager& imageManager):Game(renderer, imageManager){
	//This will set some default settings.
	reset();

	//Create the GUI root.
	GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Load the toolbar.
	toolbar=imageManager.loadTexture(getDataPath()+"gfx/menu/toolbar.png",renderer);
	toolbarRect={(SCREEN_WIDTH-460)/2,SCREEN_HEIGHT-50,460,50};

	selectionPopup=NULL;
	actionsPopup=NULL;

	movingSpeedWidth=-1;

	//Load the selectionMark.
	selectionMark=imageManager.loadTexture(getDataPath()+"gfx/menu/selection.png",renderer);

	//Load the movingMark.
	movingMark=imageManager.loadTexture(getDataPath()+"gfx/menu/moving.png",renderer);

	//Load the gui images.
	bmGUI=imageManager.loadTexture(getDataPath()+"gfx/gui.png",renderer);
	toolboxText=textureFromText(renderer,*fontText,_("Toolbox"),objThemes.getTextColor(true));

	for(size_t i = 0;i < typeTextTextures.size();++i) {
	typeTextTextures[i] =
	textureFromText(renderer,
	*fontText,
	_(blockNames[i]),
	objThemes.getTextColor(true));
	}

	for(size_t i = 0;i < tooltipTextures.size();++i) {
	if (tooltipNames[i][0]) {
	tooltipTextures[i] =
	textureFromText(renderer,
	*fontText,
	_(tooltipNames[i]),
	objThemes.getTextColor(true));
	}
	}

	//Count the level editing time.
	statsMgr.startLevelEdit();

	//Create the command manager with a maximum of 100 commands.
	commandManager = new CommandManager(100);
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string MoveGameObjectCommand::describe() {
	if (objects.size() == 1) {
	const bool isResize = oldPosition[0].w != newPosition[0].w \|\| oldPosition[0].h != newPosition[0].h;
	Scenery scenery = dynamic_cast<Scenery>(objects[0]);
	return tfm::format(isResize ? _("Resize %s") : _("Move %s"), scenery ? (scenery->sceneryName_.empty() ? _("Custom scenery block")
	: describeSceneryName(scenery->sceneryName_).c_str())
	: _(blockNames[objects[0]->type]));
	} else {
	return tfm::format(_("Move %d objects"), objects.size());
	}
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string AddRemoveGameObjectCommand::describe() {
	if (objects.size() == 1) {
	Scenery scenery = dynamic_cast<Scenery>(objects[0]);
	return tfm::format(isAdd ? _("Add %s") : _("Remove %s"), scenery ? (scenery->sceneryName_.empty() ? _("Custom scenery block")
	: describeSceneryName(scenery->sceneryName_).c_str())
	: _(blockNames[objects[0]->type]));
	} else {
	return tfm::format(isAdd ? _("Add %d objects") : _("Remove %d objects"), objects.size());
	}
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string AddRemovePathCommand::describe() {
	return tfm::format(isAdd ? _("Add path to %s") : _("Remove a path point from %s"), _(blockNames[target->type]));
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string RemovePathCommand::describe() {
	return tfm::format(_("Remove all paths from %s"), _(blockNames[target->type]));
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string AddLinkCommand::describe() {
	return tfm::format(_("Add link from %s to %s"), _(blockNames[target->type]), _(blockNames[clickedObj->type]));
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string RemoveLinkCommand::describe() {
	return tfm::format(_("Remove all links from %s"), _(blockNames[target->type]));
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string SetEditorPropertyCommand::describe() {
	Scenery scenery = dynamic_cast<Scenery>(target);
	std::string s = _("Modify the %2 property of %1");
	size_t lp = s.find("%1");
	if (lp != string::npos) {
	std::string s1 = scenery ? (scenery->sceneryName_.empty() ? _("Custom scenery block")
	: describeSceneryName(scenery->sceneryName_).c_str())
	: _(blockNames[target->type]);
	s = s.substr(0, lp) + s1 + s.substr(lp + 2);
	}
	lp = s.find("%2");
	if (lp != string::npos) {
	s = s.substr(0, lp) + desc + s.substr(lp + 2);
	}
	return s;
	}

	// FIXME: I have to write this function here since we need to access the static variable levelTime and levelRecordings
	SetLevelPropertyCommand::SetLevelPropertyCommand(LevelEditor* levelEditor, const LevelProperty& levelProperty)
	: editor(levelEditor), newProperty(levelProperty)
	{
	oldProperty.levelName = editor->levelName;
	oldProperty.levelTheme = editor->levelTheme;
	oldProperty.levelMusic = editor->levelMusic;
	oldProperty.levelTime = levelTime;
	oldProperty.levelRecordings = levelRecordings;
	}

	// FIXME: I have to write this function here since we need to access the static variable levelTime and levelRecordings
	void SetLevelPropertyCommand::setLevelProperty(const LevelProperty& levelProperty) {
	bool musicChanged = editor->levelMusic != levelProperty.levelMusic;

	editor->levelName = levelProperty.levelName;
	editor->levelTheme = levelProperty.levelTheme;
	editor->levelMusic = levelProperty.levelMusic;
	levelTime = levelProperty.levelTime;
	levelRecordings = levelProperty.levelRecordings;

	if (musicChanged) {
	#ifdef _DEBUG
	printf("DEBUG: Level music is changed dynamically in level editor\n");
	#endif
	editor->editorData["music"] = editor->levelMusic;
	editor->reloadMusic();
	}
	}

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string SetScriptCommand::describe() {
	if (target) {
	return tfm::format(_("Edit the script of %s"), _(blockNames[target->type]));
	} else {
	return _("Edit the script of level");
	}
	}

	LevelEditor::~LevelEditor(){
	//Delete the command manager.
	delete commandManager;

	// NOTE: We don't need to delete levelObjects, etc. since they are deleted in Game::~Game().

	// Clear selection
	selection.clear();

	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Delete the popup
	if(selectionPopup){
	delete selectionPopup;
	selectionPopup=NULL;
	}

	//Delete the popup
	if(actionsPopup){
	delete actionsPopup;
	actionsPopup=NULL;
	}

	//Reset the camera.
	camera.x=0;
	camera.y=0;

	//Count the level editing time.
	statsMgr.endLevelEdit();
	}

	TexturePtr& LevelEditor::getCachedTextTexture(SDL_Renderer& renderer, const std::string& text) {
	auto it = cachedTextTextures.find(text);
	if (it != cachedTextTextures.end()) return it->second;
	return (cachedTextTextures[text] = textureFromText(renderer,
	*fontText,
	text.c_str(),
	objThemes.getTextColor(true)));
	}

	void LevelEditor::reset(){
	//Set some default values.
	playMode=false;
	tool=ADD;
	currentType=0;
	toolboxVisible=false;
	toolboxRect.x=-1;
	toolboxRect.y=-1;
	toolboxRect.w=0;
	toolboxRect.h=0;
	toolboxIndex=0;
	pressedShift=false;
	pressedLeftMouse=false;
	dragging=false;
	selectionDrag=-1;
	dragCenter=NULL;
	cameraXvel=0;
	cameraYvel=0;
	linking=false;
	linkingTrigger=NULL;
	currentId=0;
	movingBlock=NULL;
	moving=false;
	movingSpeed=10;
	pauseTime = 0;
	tooltip=-1;

	//Set the player and shadow to their starting position.
	player.setLocation(player.fx,player.fy);
	shadow.setLocation(shadow.fx,shadow.fy);

	selection.clear();
	clipboard.clear();
	triggers.clear();
	movingBlocks.clear();

	//Delete any gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	//Clear the GUIWindow object map.
	objectWindows.clear();
	}

	void LevelEditor::loadLevelFromNode(ImageManager& imageManager, SDL_Renderer& renderer,TreeStorageNode* obj, const std::string& fileName){
	//call the method of base class.
	Game::loadLevelFromNode(imageManager,renderer,obj,fileName);

	//now do our own stuff.
	string s=editorData["time"];
	if(s.empty() \|\| !(s[0]>='0' && s[0]<='9')){
	levelTime=-1;
	}else{
	levelTime=atoi(s.c_str());
	}

	s=editorData["recordings"];
	if(s.empty() \|\| !(s[0]>='0' && s[0]<='9')){
	levelRecordings=-1;
	}else{
	levelRecordings=atoi(s.c_str());
	}

	levelTheme = editorData["theme"];
	levelMusic = editorData["music"];

	//NOTE: We set the camera here since we know the dimensions of the level.
	if(LEVEL_WIDTH<SCREEN_WIDTH)
	camera.x=-(SCREEN_WIDTH-LEVEL_WIDTH)/2;
	else
	camera.x=0;
	if(LEVEL_HEIGHT<SCREEN_HEIGHT)
	camera.y=-(SCREEN_HEIGHT-LEVEL_HEIGHT)/2;
	else
	camera.y=0;

	//The level is loaded, so call postLoad.
	postLoad();
	}

	void LevelEditor::saveLevel(string fileName){
	//Create the output stream and check if it starts.
	std::ofstream save(fileName.c_str());
	if(!save) return;

	//The dimensions of the level.
	int maxX=0;
	int maxY=0;

	//The storageNode to put the level data in before writing it away.
	TreeStorageNode node;
	char s[64];

	//The name of the level.
	if(!levelName.empty()){
	node.attributes["name"].push_back(levelName);

	//Update the level name in the levelpack.
	levels->getLevel()->name=levelName;
	}

	//The level theme.
	if(!levelTheme.empty())
	node.attributes["theme"].push_back(levelTheme);

	//The level music.
	if (!levelMusic.empty())
	node.attributes["music"].push_back(levelMusic);

	//target time and recordings.
	{
	char c[32];
	if(levelTime>=0){
	sprintf(c,"%d",levelTime);
	node.attributes["time"].push_back(c);

	//Update the target time the levelpack.
	levels->getLevel()->targetTime=levelTime;
	}
	if(levelRecordings>=0){
	sprintf(c,"%d",levelRecordings);
	node.attributes["recordings"].push_back(c);

	//Update the target recordings the levelpack.
	levels->getLevel()->targetRecordings=levelRecordings;
	}
	}

	//The width of the level.
	maxX=LEVEL_WIDTH;
	sprintf(s,"%d",maxX);
	node.attributes["size"].push_back(s);

	//The height of the level.
	maxY=LEVEL_HEIGHT;
	sprintf(s,"%d",maxY);
	node.attributes["size"].push_back(s);

	//Loop through the gameObjects and save them.
	for(int o=0;o<(signed)levelObjects.size();o++){
	int objectType=levelObjects[o]->type;

	//Check if it's a legal gameObject type.
	if(objectType>=0 && objectType<TYPE_MAX){
	TreeStorageNode* obj1=new TreeStorageNode;
	node.subNodes.push_back(obj1);

	//It's a tile so name the node tile.
	obj1->name="tile";

	//Write away the type of the gameObject.
	obj1->value.push_back(blockName[objectType]);

	//Get the box for the location of the gameObject.
	SDL_Rect box=levelObjects[o]->getBox(BoxType_Base);
	//Put the location and size in the storageNode.
	sprintf(s,"%d",box.x);
	obj1->value.push_back(s);
	sprintf(s,"%d",box.y);
	obj1->value.push_back(s);
	sprintf(s,"%d",box.w);
	obj1->value.push_back(s);
	sprintf(s,"%d",box.h);
	obj1->value.push_back(s);

	//Loop through the editor data and save it also.
	vector<pair<string,string> > obj;
	levelObjects[o]->getEditorData(obj);
	for(unsigned int i=0;i<obj.size();i++){
	if((!obj[i].first.empty()) && (!obj[i].second.empty())){
	obj1->attributes[obj[i].first].push_back(obj[i].second);
	}
	}

	//Loop through the scripts and add them to the storage node of the game object.
	map<int,string>::iterator it;
	Block* object=(dynamic_cast<Block*>(levelObjects[o]));
	for(it=object->scripts.begin();it!=object->scripts.end();++it){
	//Make sure the script isn't an empty string.
	if(it->second.empty())
	continue;

	TreeStorageNode* script=new TreeStorageNode;
	obj1->subNodes.push_back(script);

	script->name="script";
	script->value.push_back(gameObjectEventTypeMap[it->first]);

	script->attributes["script"].push_back(it->second);
	}
	}
	}

	//Loop through the level scripts and save them.
	for(auto it=scripts.begin();it!=scripts.end();++it){
	//Make sure the script isn't an empty string.
	if(it->second.empty())
	continue;

	TreeStorageNode* script=new TreeStorageNode;
	node.subNodes.push_back(script);

	script->name="script";
	script->value.push_back(levelEventTypeMap[it->first]);

	script->attributes["script"].push_back(it->second);
	}

	//Loop through the scenery layers and save them.
	for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it) {
	TreeStorageNode* layer = new TreeStorageNode;
	node.subNodes.push_back(layer);

	layer->name = "scenerylayer";
	layer->value.push_back(it->first);

	- //Loop through the scenery blocks and save them.
	- for (int o = 0; o<(signed)it->second.size(); o++){
	- Scenery *scenery = it->second[o];
	-
	- TreeStorageNode* obj1 = new TreeStorageNode;
	- layer->subNodes.push_back(obj1);
	-
	- // Check if it's custom scenery block
	- if (scenery->themeBlock == &(scenery->internalThemeBlock)) {
	- // load the dump of TreeStorageNode
	- POASerializer serializer;
	- std::istringstream i(scenery->customScenery_);
	- serializer.readNode(i, obj1, true);
	-
	- // custom scenery
	- obj1->name = "object";
	-
	- // clear the value in case that the serializer is buggy
	- obj1->value.clear();
	-
	- // clear the attributes in case that the user inputs some attributes
	- obj1->attributes.clear();
	- } else {
	- // predefined scenery
	- obj1->name = "scenery";
	-
	- //Write away the name of the scenery.
	- obj1->value.push_back(scenery->sceneryName_);
	- }
	-
	- //Get the box for the location of the scenery.
	- SDL_Rect box = scenery->getBox(BoxType_Base);
	- //Put the location and size in the storageNode.
	- sprintf(s, "%d", box.x);
	- obj1->value.push_back(s);
	- sprintf(s, "%d", box.y);
	- obj1->value.push_back(s);
	- sprintf(s, "%d", box.w);
	- obj1->value.push_back(s);
	- sprintf(s, "%d", box.h);
	- obj1->value.push_back(s);
	-
	- //Get the repeat mode of the scenery if it's not default value
	- if (scenery->repeatMode) {
	- std::vector<std::string> &v = obj1->attributes["repeatMode"];
	- for (int i = 0; i < 4; i++) {
	- sprintf(s, "%d", ((scenery->repeatMode) >> (i * 8)) & 0xFF);
	- v.push_back(s);
	- }
	- }
	- }
	+ it->second->saveToNode(layer);
	}

	//Create a POASerializer and write away the level node.
	POASerializer objSerializer;
	objSerializer.writeNode(&node,save,true,true);
	}

	void LevelEditor::deselectAll() {
	selection.clear();
	dragCenter = NULL;
	selectionDrag = -1;
	selectionDirty();
	}

	///////////////EVENT///////////////////
	void LevelEditor::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check if we need to quit, if so we enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//If playing/testing we should the game handle the events.
	if(playMode){
	Game::handleEvents(imageManager,renderer);

	//Also check if we should exit the playMode.
	if(inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	//Reset the game and disable playMode, disable script.
	Game::reset(true, true);
	playMode=false;
	GUIObjectRoot->visible=true;
	camera.x=cameraSave.x;
	camera.y=cameraSave.y;

	//NOTE: To prevent the mouse to still "be pressed" we set it to false.
	pressedLeftMouse=false;
	}
	}else{
	//Also check if we should exit the editor.
	if(inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	std::string s;
	//Check if the file is changed
	if (commandManager->isChanged()) {
	s = _("The level has unsaved changes.");
	s.push_back('\n');
	}
	//Before we quit ask a make sure question.
	if(msgBox(imageManager,renderer,s+_("Are you sure you want to quit?"),MsgBoxYesNo,_("Quit prompt"))==MsgBoxYes){
	//We exit the level editor.
	setNextState(STATE_LEVEL_EDIT_SELECT);

	//Play the menu music again.
	getMusicManager()->playMusic("menu");

	//No need for handling other events, so return.
	return;
	}
	}

	//Check if we should redirect the event to the actions popup
	if(actionsPopup!=NULL){
	actionsPopup->handleEvents(renderer);
	return;
	}
	//Check if we should redirect the event to selection popup
	if(selectionPopup!=NULL){
	if(event.type==SDL_MOUSEBUTTONDOWN
	\|\| event.type==SDL_MOUSEBUTTONUP
	\|\| event.type==SDL_MOUSEMOTION)
	{
	selectionPopup->handleEvents(imageManager,renderer);
	return;
	}
	}
	//TODO: Don't handle any Events when GUIWindows process them.
	{
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x,y,0,0};
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	SDL_Rect box={0,0,0,0};
	box.x=GUIObjectRoot->childControls[i]->left;
	box.y=GUIObjectRoot->childControls[i]->top;
	box.w=GUIObjectRoot->childControls[i]->width;
	box.h=GUIObjectRoot->childControls[i]->height;
	if(checkCollision(mouse,box))
	return;
	}
	}

	//Check if toolbar is clicked.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT && tooltip>=0){
	int t=tooltip;

	if(t<NUMBER_TOOLS){
	tool=(Tools)t;

	//Stop linking or moving if the mode is not SELECT.
	if (tool != SELECT) {
	if (linking) {
	linking = false;
	linkingTrigger = NULL;
	}
	if (moving) {
	moving = false;
	movingBlock = NULL;
	}
	}
	}else{
	//The selected button isn't a tool.
	//Now check which button it is.
	if (t == (int)ToolTips::Play){
	enterPlayMode();
	}
	if (t == (int)ToolTips::LevelSettings){
	//Open up level settings dialog
	levelSettings(imageManager,renderer);
	}
	if (t == (int)ToolTips::BackToMenu){
	//If the file is changed we show a confirmation dialog
	if (commandManager->isChanged()) {
	std::string s = _("The level has unsaved changes.");
	s.push_back('\n');
	if (msgBox(imageManager, renderer, s + _("Are you sure you want to quit?"), MsgBoxYesNo, _("Quit prompt")) != MsgBoxYes) return;
	}

	//Go back to the level selection screen of Level Editor
	setNextState(STATE_LEVEL_EDIT_SELECT);
	//Change the music back to menu music.
	getMusicManager()->playMusic("menu");
	}
	if (t == (int)ToolTips::SaveLevel){
	//Save current level
	saveCurrentLevel(imageManager, renderer);
	}
	if (t == (int)ToolTips::UndoNoTooltip) {
	commandManager->undo();
	}
	if (t == (int)ToolTips::RedoNoTooltip) {
	commandManager->redo();
	}
	}

	return;
	}

	//Check if tool box is clicked.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT && toolboxRect.w>0){
	if(toolboxVisible){
	if(event.button.y<64){
	//Check if we need to hide it
	if(event.button.x>=SCREEN_WIDTH-24 && event.button.x<SCREEN_WIDTH && event.button.y<20){
	toolboxVisible=false;
	return;
	}

	const int m = (SCREEN_WIDTH - 48) / 64;

	//Check if a block is clicked.
	if(event.button.x>=24 && event.button.x<SCREEN_WIDTH-24){
	int i=(event.button.x-24)/64;
	if(i<m && i+toolboxIndex<getEditorOrderMax()){
	currentType=i+toolboxIndex;
	}
	}

	//Check if move left button is clicked
	if (event.button.x >= 0 && event.button.x < 24 && event.button.y >= 20 && event.button.y < 44) {
	toolboxIndex -= m;
	if (toolboxIndex < 0) toolboxIndex = 0;
	}

	//Check if move right button is clicked
	if (event.button.x >= SCREEN_WIDTH - 24 && event.button.x < SCREEN_WIDTH && event.button.y >= 20 && event.button.y < 44) {
	toolboxIndex += m;
	if (toolboxIndex > getEditorOrderMax() - m) toolboxIndex = getEditorOrderMax() - m;
	if (toolboxIndex < 0) toolboxIndex = 0;
	}

	return;
	}
	}else if(event.button.x>=toolboxRect.x && event.button.x<toolboxRect.x+toolboxRect.w
	&& event.button.y>=toolboxRect.y && event.button.y<toolboxRect.y+toolboxRect.h)
	{
	toolboxVisible=true;
	return;
	}
	}

	//Check if shift is pressed.
	pressedShift=inputMgr.isKeyDown(INPUTMGR_SHIFT);

	//Check if delete is pressed.
	if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_DELETE){
	if (!selection.empty()){
	AddRemoveGameObjectCommand *command = new AddRemoveGameObjectCommand(this, selection, false);

	//clear the selection vector first.
	deselectAll();

	//perform the actual deletion.
	commandManager->doCommand(command);
	}
	}

	//Check for copy (Ctrl+c) or cut (Ctrl+x).
	if(event.type==SDL_KEYDOWN && (event.key.keysym.sym==SDLK_c \|\| event.key.keysym.sym==SDLK_x) && (event.key.keysym.mod & KMOD_CTRL)){
	//Check if the selection isn't empty.
	if(!selection.empty()){
	//Clear the current clipboard.
	clipboard.clear();

	//Loop through the selection to find the left-top block.
	int x=selection[0]->getBox().x;
	int y=selection[0]->getBox().y;
	for(unsigned int o=1; o<selection.size(); o++){
	if(selection[o]->getBox().x<x \|\| selection[o]->getBox().y<y){
	x=selection[o]->getBox().x;
	y=selection[o]->getBox().y;
	}
	}

	//Loop through the selection for the actual copying.
	for(unsigned int o=0; o<selection.size(); o++){
	//Get the editor data of the object.
	vector<pair<string,string> > obj;
	selection[o]->getEditorData(obj);

	//Loop through the editor data and convert it.
	map<string,string> objMap;
	for(unsigned int i=0;i<obj.size();i++){
	objMap[obj[i].first]=obj[i].second;
	}
	//Add some entries to the map.
	char s[64];
	SDL_Rect r = selection[o]->getBox();
	sprintf(s, "%d", r.x - x);
	objMap["x"]=s;
	sprintf(s, "%d", r.y - y);
	objMap["y"]=s;
	sprintf(s, "%d", selection[o]->getBox().w);
	objMap["w"] = s;
	sprintf(s, "%d", selection[o]->getBox().h);
	objMap["h"] = s;

	Scenery scenery = dynamic_cast<Scenery>(selection[o]);
	if (scenery) {
	objMap["sceneryName"] = scenery->sceneryName_;
	objMap["customScenery"] = scenery->customScenery_;
	} else {
	sprintf(s, "%d", selection[o]->type);
	objMap["type"] = s;
	}

	//Overwrite the id to prevent triggers, portals, buttons, movingblocks, etc. from malfunctioning.
	//We give an empty string as id, which is invalid and thus suitable.
	objMap["id"]="";
	//Do the same for destination if the type is portal.
	if(selection[o]->type==TYPE_PORTAL){
	objMap["destination"]="";
	}

	//And add the map to the clipboard vector.
	clipboard.push_back(objMap);
	}

	//Cutting means deleting the game object.
	if (event.key.keysym.sym == SDLK_x && !selection.empty()){
	AddRemoveGameObjectCommand *command = new AddRemoveGameObjectCommand(this, selection, false);

	//clear the selection vector first.
	deselectAll();

	//perform the actual deletion.
	commandManager->doCommand(command);
	}
	}
	}

	//Check for paste (Ctrl+v).
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_v && (event.key.keysym.mod & KMOD_CTRL)){
	//First make sure that the clipboard isn't empty.
	if(!clipboard.empty()){
	//Clear the current selection.
	deselectAll();

	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	std::vector<GameObject*> newObjects;

	//Loop through the clipboard.
	for(unsigned int o=0;o<clipboard.size();o++){
	GameObject *obj = NULL;

	if (clipboard[o].find("sceneryName") == clipboard[o].end()) {
	// a normal block
	if (!selectedLayer.empty()) continue;
	obj = new Block(this, 0, 0, 50, 50, atoi(clipboard[o]["type"].c_str()));
	} else {
	// a scenery block
	if (selectedLayer.empty()) continue;
	Scenery *scenery = new Scenery(this, 0, 0, 50, 50, clipboard[o]["sceneryName"]);
	if (clipboard[o]["sceneryName"].empty()) {
	scenery->customScenery_ = clipboard[o]["customScenery"];
	scenery->updateCustomScenery(imageManager, renderer);
	}
	obj = scenery;
	}

	obj->setBaseLocation(atoi(clipboard[o]["x"].c_str())+x,atoi(clipboard[o]["y"].c_str())+y);
	obj->setBaseSize(atoi(clipboard[o]["w"].c_str()), atoi(clipboard[o]["h"].c_str()));
	obj->setEditorData(clipboard[o]);

	//add the object.
	newObjects.push_back(obj);

	//Also add the block to the selection.
	selection.push_back(obj);
	}

	// Do the actual object insertion
	if (!newObjects.empty()) {
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, newObjects, true));
	}
	}
	}

	//Check for the arrow keys, used for moving the camera when playMode=false.
	cameraXvel=0;
	cameraYvel=0;
	if(inputMgr.isKeyDown(INPUTMGR_RIGHT)){
	if(pressedShift){
	cameraXvel+=10;
	}else{
	cameraXvel+=5;
	}
	}
	if(inputMgr.isKeyDown(INPUTMGR_LEFT)){
	if(pressedShift){
	cameraXvel-=10;
	}else{
	cameraXvel-=5;
	}
	}
	if(inputMgr.isKeyDown(INPUTMGR_UP)){
	if(pressedShift){
	cameraYvel-=10;
	}else{
	cameraYvel-=5;
	}
	}
	if(inputMgr.isKeyDown(INPUTMGR_DOWN)){
	if(pressedShift){
	cameraYvel+=10;
	}else{
	cameraYvel+=5;
	}
	}

	//Check if the left mouse button is pressed/holded.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT){
	pressedLeftMouse=true;
	}
	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT){
	pressedLeftMouse=false;

	//We also need to check if dragging is true.
	if(dragging){
	//Set dragging false and call the onDrop event.
	dragging=false;
	int x,y;
	SDL_GetMouseState(&x,&y);
	//We call the drop event.
	onDrop(x+camera.x,y+camera.y);
	}
	}

	//Check if the mouse is dragging.
	if(pressedLeftMouse && event.type==SDL_MOUSEMOTION){
	if(abs(event.motion.xrel)+abs(event.motion.yrel)>=2){
	//Check if this is the start of the dragging.
	if(!dragging){
	//The mouse is moved enough so let's set dragging true.
	dragging=true;
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//We call the dragStart event.
	// NOTE: We start drag from previous mouse position to prevent resize area hit test bug
	onDragStart(x - event.motion.xrel + camera.x, y - event.motion.yrel + camera.y);
	onDrag(event.motion.xrel, event.motion.yrel);
	} else {
	//Dragging was already true meaning we call onDrag() instead of onDragStart().
	onDrag(event.motion.xrel,event.motion.yrel);
	}
	}
	}

	//Update cursor.
	if(dragging){
	if (tool == REMOVE) {
	currentCursor = CURSOR_REMOVE;
	} else {
	switch (selectionDrag) {
	case 0: case 8:
	currentCursor = CURSOR_SIZE_FDIAG;
	break;
	case 1: case 7:
	currentCursor = CURSOR_SIZE_VER;
	break;
	case 2: case 6:
	currentCursor = CURSOR_SIZE_BDIAG;
	break;
	case 3: case 5:
	currentCursor = CURSOR_SIZE_HOR;
	break;
	case 4:
	currentCursor = CURSOR_DRAG;
	break;
	default:
	currentCursor = CURSOR_POINTER;
	break;
	}
	}
	}

	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x,y,0,0};

	//Check if we scroll up, meaning the currentType++;
	if((event.type==SDL_MOUSEWHEEL && event.wheel.y > 0) \|\| inputMgr.isKeyDownEvent(INPUTMGR_NEXT)){
	switch(tool){
	case ADD:
	//Check if mouse is in tool box.
	if(toolboxVisible && toolboxRect.w>0){
	int x,y;
	SDL_GetMouseState(&x,&y);
	if(y<64){
	const int m = getEditorOrderMax() - (SCREEN_WIDTH - 48) / 64;
	toolboxIndex -= 2;
	if (toolboxIndex>m) toolboxIndex = m;
	if (toolboxIndex<0) toolboxIndex = 0;
	break;
	}
	}
	//Only change the current type when using the add tool.
	currentType++;
	if (currentType >= getEditorOrderMax()){
	currentType=0;
	}
	break;
	case SELECT:
	//When configuring moving blocks.
	if(moving){
	if (pauseMode) {
	//Here we have to use Ctrl because Shift means snap
	pauseTime += (SDL_GetModState() & KMOD_CTRL) ? 10 : 1;
	} else {
	//Here we have to use Ctrl because Shift means snap
	movingSpeed += (SDL_GetModState() & KMOD_CTRL) ? 10 : 1;
	//The movingspeed is capped at 125 (10 block/s).
	if (movingSpeed > 125){
	movingSpeed = 125;
	}
	}
	break;
	}
	//Fall through.
	default:
	//When in other mode, just scrolling the map
	if(pressedShift)
	camera.x-=200;
	else camera.y-=200;
	break;
	}
	}
	//Check if we scroll down, meaning the currentType--;
	if((event.type==SDL_MOUSEWHEEL && event.wheel.y < 0) \|\| inputMgr.isKeyDownEvent(INPUTMGR_PREVIOUS)){
	switch(tool){
	case ADD:
	//Check if mouse is in tool box.
	if(toolboxVisible && toolboxRect.w>0){
	int x,y;
	SDL_GetMouseState(&x,&y);
	if(y<64){
	const int m = getEditorOrderMax() - (SCREEN_WIDTH - 48) / 64;
	toolboxIndex+=2;
	if(toolboxIndex>m) toolboxIndex=m;
	if(toolboxIndex<0) toolboxIndex=0;
	break;
	}
	}
	//Only change the current type when using the add tool.
	currentType--;
	if(currentType<0){
	currentType = getEditorOrderMax() - 1;
	}
	break;
	case SELECT:
	//When configuring moving blocks.
	if(moving){
	if (pauseMode) {
	//Here we have to use Ctrl because Shift means snap
	pauseTime -= (SDL_GetModState() & KMOD_CTRL) ? 10 : 1;
	if (pauseTime < -1){
	pauseTime = -1;
	}
	} else {
	//Here we have to use Ctrl because Shift means snap
	movingSpeed -= (SDL_GetModState() & KMOD_CTRL) ? 10 : 1;
	if (movingSpeed <= 0){
	movingSpeed = 1;
	}
	}
	break;
	}
	//Fall through.
	default:
	//When in other mode, just scrolling the map
	if(pressedShift) camera.x+=200;
	else camera.y+=200;
	break;
	}
	}

	if (event.type == SDL_KEYDOWN) {
	bool unlink = false;

	//Check if we should enter playMode.
	if (event.key.keysym.sym == SDLK_F5){
	enterPlayMode();
	}
	//Check for tool shortcuts.
	if (event.key.keysym.sym == SDLK_F2){
	tool = SELECT;
	}
	if (event.key.keysym.sym == SDLK_F3){
	tool = ADD;
	unlink = true;
	}
	if (event.key.keysym.sym == SDLK_F4){
	tool = REMOVE;
	unlink = true;
	}

	//Stop linking or moving if the mode is not SELECT.
	if (unlink) {
	if (linking) {
	linking = false;
	linkingTrigger = NULL;
	}
	if (moving) {
	moving = false;
	movingBlock = NULL;
	}
	}
	}

	//Check for certain events.

	//First make sure the mouse isn't above the toolbar.
	if(!checkCollision(mouse,toolbarRect) && !checkCollision(mouse,toolboxRect)){
	mouse.x+=camera.x;
	mouse.y+=camera.y;

	//Boolean if there's a click event fired.
	bool clickEvent=false;
	//Check if a mouse button is pressed.
	if(event.type==SDL_MOUSEBUTTONDOWN){
	std::vector<GameObject*> clickObjects;

	//Loop through the objects to check collision.
	if (selectedLayer.empty()) {
	if (layerVisibility[selectedLayer]) {
	for (unsigned int o = 0; o<levelObjects.size(); o++){
	if (checkCollision(levelObjects[o]->getBox(), mouse) == true){
	clickObjects.push_back(levelObjects[o]);
	}
	}
	}
	} else {
	auto it = sceneryLayers.find(selectedLayer);
	if (it != sceneryLayers.end() && layerVisibility[selectedLayer]) {
	- for (unsigned int o = 0; o<it->second.size(); o++){
	- if (checkCollision(it->second[o]->getBox(), mouse) == true){
	- clickObjects.push_back(it->second[o]);
	+ for (auto o : it->second->objects){
	+ if (checkCollision(o->getBox(), mouse) == true){
	+ clickObjects.push_back(o);
	}
	}
	}
	}

	//Check if there are multiple objects above eachother or just one.
	if(clickObjects.size()==1){
	//We have collision meaning that the mouse is above an object.
	std::vector<GameObject*>::iterator it;
	it=find(selection.begin(),selection.end(),clickObjects[0]);

	//Set event true since there's a click event.
	clickEvent=true;

	//Check if the clicked object is in the selection or not.
	bool isSelected=(it!=selection.end());
	if(event.button.button==SDL_BUTTON_LEFT){
	onClickObject(clickObjects[0],isSelected);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	onRightClickObject(imageManager,renderer,clickObjects[0],isSelected);
	}
	}else if(clickObjects.size()>=1){
	//There are more than one object under the mouse
	//SDL2 port (never managed to trigger this without changing the parameters.
	std::vector<GameObject*>::iterator it;
	it=find(selection.begin(),selection.end(),clickObjects[0]);

	//Set event true since there's a click event.
	clickEvent=true;

	//Check if the clicked object is in the selection or not.
	bool isSelected=(it!=selection.end());

	//Only show the selection popup when right clicking.
	if(event.button.button==SDL_BUTTON_LEFT){
	onClickObject(clickObjects[0],isSelected);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	//Remove the selection popup if there's one.
	if(selectionPopup!=NULL)
	delete selectionPopup;

	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	selectionPopup=new LevelEditorSelectionPopup(this,imageManager,renderer,clickObjects,x,y);
	}
	}
	}

	//If event is false then we clicked on void.
	if(!clickEvent){
	if(event.type==SDL_MOUSEBUTTONDOWN){
	if(event.button.button==SDL_BUTTON_LEFT){
	//Left mouse button on void.
	onClickVoid(mouse.x,mouse.y);
	}else if(event.button.button==SDL_BUTTON_RIGHT /&& tool==SELECT/){
	//Stop linking.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	//NOTE: We shouldn't be able to be linking AND moving so return to prevent actions popup.
	return;
	}

	//Stop moving.
	if(moving){
	moving=false;
	movingBlock=NULL;
	return;
	}

	//No return so far so call onRightClickVoid.
	onRightClickVoid(imageManager,renderer,mouse.x,mouse.y);
	}
	}
	}
	}

	//Check for backspace when moving to remove a movingposition.
	if(moving && event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_BACKSPACE){
	if(movingBlocks[movingBlock].size()>0){
	commandManager->doCommand(new AddRemovePathCommand(this, movingBlock, MovingPosition(0, 0, 0), false));
	}
	}

	//Check for the tab key, level settings.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	//Show the levelSettings.
	levelSettings(imageManager,renderer);
	}

	//Check if we should save the level (Ctrl+s).
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_s && (event.key.keysym.mod & KMOD_CTRL)){
	saveCurrentLevel(imageManager, renderer);
	}

	//Undo ctrl+z
	if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_z && (event.key.keysym.mod & KMOD_CTRL)){
	undo();
	}

	//Redo ctrl+y
	if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_y && (event.key.keysym.mod & KMOD_CTRL)){
	redo();
	}
	}
	}

	void LevelEditor::saveCurrentLevel(ImageManager& imageManager, SDL_Renderer& renderer) {
	saveLevel(levelFile);

	//Clear the dirty flag
	commandManager->resetChange();

	//And give feedback to the user.
	if (levelName.empty())
	msgBox(imageManager, renderer, tfm::format(_("Level \"%s\" saved"), fileNameFromPath(levelFile)), MsgBoxOKOnly, _("Saved"));
	else
	msgBox(imageManager, renderer, tfm::format(_("Level \"%s\" saved"), levelName), MsgBoxOKOnly, _("Saved"));
	}

	void LevelEditor::enterPlayMode(){
	//Check if we are already in play mode.
	if(playMode) return;

	//Stop linking or moving.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	}

	if(moving){
	moving=false;
	movingBlock=NULL;
	}

	//We need to reposition player and shadow here, since the related code is removed from object placement.
	for (auto obj : levelObjects) {
	//If the object is a player or shadow start then change the start position of the player or shadow.
	if (obj->type == TYPE_START_PLAYER){
	//Center the player horizontally.
	player.fx = obj->getBox().x + (obj->getBox().w - player.getBox().w) / 2;
	player.fy = obj->getBox().y;
	}
	if (obj->type == TYPE_START_SHADOW){
	//Center the shadow horizontally.
	shadow.fx = obj->getBox().x + (obj->getBox().w - shadow.getBox().w) / 2;
	shadow.fy = obj->getBox().y;
	}
	}

	//Change mode.
	playMode=true;
	GUIObjectRoot->visible=false;
	cameraSave.x=camera.x;
	cameraSave.y=camera.y;

	//Restart the game with scripting enabled.
	Game::reset(true, false);
	}

	void LevelEditor::undo(){
	commandManager->undo();
	}

	void LevelEditor::redo(){
	commandManager->redo();
	}

	void LevelEditor::levelSettings(ImageManager& imageManager,SDL_Renderer& renderer){
	//It isn't so open a popup asking for a name.
	GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-450)/2,600,450,true,true,_("Level settings"));
	root->name="lvlSettingsWindow";
	root->eventCallback=this;
	GUIObject* obj;

	//Create the two textboxes with a label.
	obj=new GUILabel(imageManager,renderer,40,60,240,36,_("Name:"));
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,60,410,36,levelName.c_str());
	obj->name="name";
	root->addChild(obj);

	obj = new GUILabel(imageManager, renderer, 40, 110, 240, 36, (std::string("* ") + _("Theme:")).c_str());
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,110,410,36,levelTheme.c_str());
	obj->name="theme";
	root->addChild(obj);

	obj = new GUILabel(imageManager, renderer, 40, 150, 510, 36, _("Examples: %DATA%/themes/classic"));
	root->addChild(obj);
	obj = new GUILabel(imageManager, renderer, 40, 174, 510, 36, _("or %USER%/themes/Orange"));
	root->addChild(obj);

	obj = new GUILabel(imageManager, renderer, 40, 210, 240, 36, _("Music:"));
	root->addChild(obj);
	obj = new GUITextBox(imageManager, renderer, 140, 210, 410, 36, levelMusic.c_str());
	obj->name = "music";
	root->addChild(obj);

	//target time and recordings.
	{
	obj=new GUILabel(imageManager,renderer,40,260,240,36,_("Target time (s):"));
	root->addChild(obj);
	GUISpinBox* obj2=new GUISpinBox(imageManager,renderer,290,260,260,36);
	obj2->name="time";

	ostringstream ss;
	ss << levelTime/40.0f;
	obj2->caption=ss.str();

	obj2->limitMin=0.0f;
	obj2->format = "%0.3f";
	obj2->change=0.1f;
	obj2->update();
	root->addChild(obj2);

	obj=new GUILabel(imageManager,renderer,40,310,240,36,_("Target recordings:"));
	root->addChild(obj);
	obj2=new GUISpinBox(imageManager,renderer,290,310,260,36);

	ostringstream ss2;
	ss2 << levelRecordings;
	obj2->caption=ss2.str();

	obj2->limitMin=0.0f;
	obj2->format="%1.0f";
	obj2->name="recordings";
	obj2->update();
	root->addChild(obj2);
	}

	obj = new GUILabel(imageManager, renderer, 40, 350, 510, 36, (std::string("* ") + _("Restart level editor is required")).c_str());
	root->addChild(obj);

	//Ok and cancel buttons.
	obj=new GUIButton(imageManager,renderer,root->width*0.3,450-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="lvlSettingsOK";
	obj->eventCallback=root;
	root->addChild(obj);
	obj=new GUIButton(imageManager,renderer,root->width*0.7,450-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->name="lvlSettingsCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	GUIObjectRoot->addChild(root);
	}

	void LevelEditor::postLoad(){
	//We need to find the triggers.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Check for the highest id.
	unsigned int id=atoi(levelObjects[o]->getEditorProperty("id").c_str());
	if(id>=currentId)
	currentId=id+1;

	switch(levelObjects[o]->type){
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	//Add the object to the triggers vector.
	vector<GameObject*> linked;
	triggers[levelObjects[o]]=linked;
	//Now loop through the levelObjects in search for objects with the same id.
	for(unsigned int oo=0;oo<levelObjects.size();oo++){
	//Check if it isn't the same object but has the same id.
	if(o!=oo && (dynamic_cast<Block>(levelObjects[o]))->id==(dynamic_cast<Block>(levelObjects[oo]))->id){
	//Add the object to the link vector of the trigger.
	triggers[levelObjects[o]].push_back(levelObjects[oo]);
	}
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Add the object to the triggers vector.
	vector<GameObject*> linked;
	triggers[levelObjects[o]]=linked;

	//If the destination is empty we return.
	if((dynamic_cast<Block*>(levelObjects[o]))->destination.empty()){
	break;
	}

	//Now loop through the levelObjects in search for objects with the same id as destination.
	for(unsigned int oo=0;oo<levelObjects.size();oo++){
	//Check if it isn't the same object but has the same id.
	if(o!=oo && (dynamic_cast<Block>(levelObjects[o]))->destination==(dynamic_cast<Block>(levelObjects[oo]))->id){
	//Add the object to the link vector of the trigger.
	triggers[levelObjects[o]].push_back(levelObjects[oo]);
	}
	}
	break;
	}
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//Get the moving position.
	const vector<SDL_Rect> &movingPos = levelObjects[o]->movingPos;

	//Add the object to the movingBlocks vector.
	movingBlocks[levelObjects[o]].clear();

	for (int i = 0, m = movingPos.size(); i < m; i++) {
	MovingPosition position(movingPos[i].x, movingPos[i].y, movingPos[i].w);
	movingBlocks[levelObjects[o]].push_back(position);
	}

	break;
	}
	default:
	break;
	}
	}

	// Set the visibility of all layers to true
	layerVisibility.clear();
	for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it) {
	layerVisibility[it->first] = true;
	}
	layerVisibility[std::string()] = true;

	// Also set the current layer to the Block layer
	selectedLayer.clear();

	// Get all available scenery blocks
	std::set<std::string> tmpset;
	objThemes.getSceneryBlockNames(tmpset);
	sceneryBlockNames.clear();
	sceneryBlockNames.insert(sceneryBlockNames.end(), tmpset.begin(), tmpset.end());
	}

	void LevelEditor::snapToGrid(int* x,int* y){
	//Check if the x location is negative.
	if(*x<0){
	x=-((abs(x-50)/50)*50);
	}else{
	x=(x/50)*50;
	}

	//Now the y location.
	if(*y<0){
	y=-((abs(y-50)/50)*50);
	}else{
	y=(y/50)*50;
	}
	}

	void LevelEditor::setCamera(const SDL_Rect* r,int count){
	//SetCamera only works in the Level editor and when mouse is inside window.
	if(stateID==STATE_LEVEL_EDITOR&&(SDL_GetMouseFocus() == sdlWindow)){
	//Get the mouse coordinates.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//Don't continue here if mouse is inside one of the boxes given as parameter.
	for(int i=0;i<count;i++){
	if(checkCollision(mouse,r[i]))
	return;
	}

	//Check if the mouse is near the left edge of the screen.
	//Else check if the mouse is near the right edge.
	if(x<50){
	//We're near the left edge so move the camera.
	camera.x-=5;
	}else if(x>SCREEN_WIDTH-50){
	//We're near the right edge so move the camera.
	camera.x+=5;
	}

	//Check if the tool box is visible and we need to calc screen size correctly.
	int y0=50;
	if(toolboxVisible && toolboxRect.w>0) y0+=64;

	//Check if the mouse is near the top edge of the screen.
	//Else check if the mouse is near the bottom edge.
	if(y<y0){
	//We're near the top edge so move the camera.
	camera.y-=5;
	}else if(y>SCREEN_HEIGHT-50){
	//We're near the bottom edge so move the camera.
	camera.y+=5;
	}
	}
	}

	void LevelEditor::onClickObject(GameObject* obj,bool selected){
	switch(tool){
	case SELECT:
	{
	//Check if we are linking.
	if(linking){
	//Check if the obj is valid to link to.
	switch(obj->type){
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//It's only valid when not linking a portal.
	if(linkingTrigger->type==TYPE_PORTAL){
	//You can't link a portal to moving blocks, etc.
	//Stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Make sure that the linkingTrigger is also a portal.
	if(linkingTrigger->type!=TYPE_PORTAL){
	//The linkingTrigger isn't a portal so stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	}
	break;
	}
	default:
	//It isn't valid so stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	break;
	}

	AddLinkCommand* pCommand = new AddLinkCommand(this, linkingTrigger, obj);
	commandManager->doCommand(pCommand);

	//We return to prevent configuring stuff like conveyor belts, etc...
	linking=false;
	linkingTrigger=NULL;
	return;
	}

	//If we're moving add a movingposition.
	if(moving){
	//Get the current mouse location.
	int x, y;
	SDL_GetMouseState(&x, &y);
	x += camera.x;
	y += camera.y;

	addMovingPosition(x, y);
	return;
	}
	}
	case ADD:
	{
	//Check if object is already selected.
	if(!selected){
	//First check if shift is pressed or not.
	if(!pressedShift){
	//Clear the selection.
	deselectAll();
	}

	//Add the object to the selection.
	selection.push_back(obj);
	}
	break;
	}
	case REMOVE:
	{
	//Remove the object.
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, obj, false));
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::addMovingPosition(int x,int y) {
	//Apply snap to grid.
	if (!pressedShift){
	snapToGrid(&x, &y);
	} else{
	x -= 25;
	y -= 25;
	}

	x -= movingBlock->getBox().x;
	y -= movingBlock->getBox().y;

	//Calculate the length.
	//First get the delta x and y.
	int dx, dy;
	if (movingBlocks[movingBlock].empty()){
	dx = x;
	dy = y;
	} else{
	dx = x - movingBlocks[movingBlock].back().x;
	dy = y - movingBlocks[movingBlock].back().y;
	}

	AddRemovePathCommand* pCommand = NULL;

	if (dx == 0 && dy == 0) {
	// pause mode
	if (pauseTime != 0) pCommand = new AddRemovePathCommand(this, movingBlock, MovingPosition(x, y, std::max(pauseTime, 0)), true);
	pauseTime = 0;
	} else {
	// add new point mode
	const double length = sqrt(double(dxdx + dydy));
	pCommand = new AddRemovePathCommand(this, movingBlock, MovingPosition(x, y, (int)(length*(10 / (double)movingSpeed))), true);
	}
	if (pCommand) commandManager->doCommand(pCommand);
	}

	void LevelEditor::onRightClickObject(ImageManager& imageManager,SDL_Renderer& renderer,GameObject* obj,bool){
	//Create an actions popup for the game object.
	if(actionsPopup==NULL){
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,this,obj,x,y);
	return;
	}
	}

	void LevelEditor::onClickVoid(int x,int y){
	switch(tool){
	case ADD:
	{
	//We need to clear the selection.
	deselectAll();

	//Now place an object.
	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}
	if (currentType >= 0 && currentType < getEditorOrderMax()) {
	GameObject *obj;
	if (selectedLayer.empty()) {
	obj = new Block(this, x, y, 50, 50, editorTileOrder[currentType]);
	} else {
	obj = new Scenery(this, x, y, 50, 50,
	currentType < (int)sceneryBlockNames.size() ? sceneryBlockNames[currentType] : std::string());
	}
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, obj, true));
	}
	break;
	}
	case SELECT:
	{
	//We need to clear the selection.
	deselectAll();

	//If we're linking we should stop, user abort.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	//And return.
	return;
	}

	//If we're moving we should add a point.
	if(moving){
	addMovingPosition(x, y);

	//And return.
	return;
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onRightClickVoid(ImageManager& imageManager,SDL_Renderer& renderer,int,int){
	//Create an actions popup for the game object.
	if(actionsPopup==NULL){
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,this,NULL,x,y);
	return;
	}
	}

	void LevelEditor::onDragStart(int x,int y){
	switch(tool){
	case SELECT:
	case ADD:
	{
	//We can drag the selection so check if the selection isn't empty.
	if(!selection.empty()){
	//The selection isn't empty so search the dragCenter.
	//Create a mouse rectangle.
	SDL_Rect mouse={x,y,0,0};

	// record the drag start position
	dragSrartPosition.x = x;
	dragSrartPosition.y = y;

	//Loop through the objects to check collision.
	for(unsigned int o=0; o<selection.size(); o++){
	SDL_Rect r = selection[o]->getBox();
	if(checkCollision(r,mouse)){
	//We have collision so set the dragCenter.
	dragCenter=selection[o];

	// determine which part is dragged
	selectionDrag = 4;
	int midx = r.x + r.w / 2 - 2;
	int midy = r.y + r.h / 2 - 2;
	if (mouse.x >= r.x && mouse.x < r.x + 5) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	selectionDrag = 0;
	} else if (mouse.y >= midy && mouse.y < midy + 5) {
	selectionDrag = 3;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	selectionDrag = 6;
	}
	} else if (mouse.x >= midx && mouse.x < midx + 5) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	selectionDrag = 1;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	selectionDrag = 7;
	}
	} else if (mouse.x >= r.x + r.w - 5 && mouse.x < r.x + r.w) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	selectionDrag = 2;
	} else if (mouse.y >= midy && mouse.y < midy + 5) {
	selectionDrag = 5;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	selectionDrag = 8;
	}
	}

	break;
	}
	}
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onDrag(int dx,int dy){
	switch(tool){
	case REMOVE:
	{
	//No matter what we delete the item the mouse is above.
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x+camera.x,y+camera.y,0,0};

	currentCursor=CURSOR_REMOVE;

	std::vector<GameObject*> objects;

	//Loop through the objects to check collision.
	if (selectedLayer.empty()) {
	if (layerVisibility[selectedLayer]) {
	for (unsigned int o = 0; o<levelObjects.size(); o++){
	if (checkCollision(levelObjects[o]->getBox(), mouse) == true){
	objects.push_back(levelObjects[o]);
	}
	}
	}
	} else {
	auto it = sceneryLayers.find(selectedLayer);
	if (it != sceneryLayers.end() && layerVisibility[selectedLayer]) {
	- for (unsigned int o = 0; o<it->second.size(); o++){
	- if (checkCollision(it->second[o]->getBox(), mouse) == true){
	- objects.push_back(it->second[o]);
	+ for (auto o : it->second->objects){
	+ if (checkCollision(o->getBox(), mouse) == true){
	+ objects.push_back(o);
	}
	}
	}
	}

	// Do the actual object deletion.
	if (!objects.empty()) {
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, objects, false));
	}

	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onDrop(int x,int y){
	switch(tool){
	case SELECT:
	case ADD:
	{
	//Check if the drag center isn't null.
	if(dragCenter==NULL)
	return;
	//The location of the dragCenter.
	SDL_Rect r=dragCenter->getBox();

	if (selectionDrag == 4) { // dragging
	//Apply snap to grid.
	determineNewPosition(x, y);

	commandManager->doCommand(new MoveGameObjectCommand(this, selection, x - r.x, y - r.y));
	} else if (selectionDrag >= 0) { // resizing
	determineNewSize(x, y, r);

	commandManager->doCommand(new MoveGameObjectCommand(this, dragCenter, r.x, r.y, r.w, r.h));
	}

	//Make sure the dragCenter is null and set selectionDrag false.
	dragCenter=NULL;
	selectionDrag=-1;
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onCameraMove(int dx,int dy){
	switch(tool){
	case REMOVE:
	{
	//Only delete when the left mouse button is pressed.
	if(pressedLeftMouse){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x+camera.x,y+camera.y,0,0};

	std::vector<GameObject*> objects;

	//Loop through the objects to check collision.
	if (selectedLayer.empty()) {
	if (layerVisibility[selectedLayer]) {
	for (unsigned int o = 0; o<levelObjects.size(); o++){
	if (checkCollision(levelObjects[o]->getBox(), mouse) == true){
	objects.push_back(levelObjects[o]);
	}
	}
	}
	} else {
	auto it = sceneryLayers.find(selectedLayer);
	if (it != sceneryLayers.end() && layerVisibility[selectedLayer]) {
	- for (unsigned int o = 0; o<it->second.size(); o++){
	- if (checkCollision(it->second[o]->getBox(), mouse) == true){
	- objects.push_back(it->second[o]);
	+ for (auto o : it->second->objects){
	+ if (checkCollision(o->getBox(), mouse) == true){
	+ objects.push_back(o);
	}
	}
	}
	}

	// Do the actual object deletion.
	if (!objects.empty()) {
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, objects, false));
	}
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::selectionDirty() {
	if (selectionPopup != NULL) selectionPopup->dirty = true;
	}

	void LevelEditor::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check if one of the windows is closed.
	if (eventType == GUIEventClick && name.size() >= 6 && name.substr(name.size() - 6) == "Window") {
	destroyWindow(obj);
	return;
	}
	//TODO: Add resize code for each GUIWindow.
	if (name.size() >= 6 && name.substr(name.size() - 6) == "Window") {
	return;
	}

	//Check for GUI events.
	//Notification block configure events.
	if(name=="cfgNotificationBlockOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	//Get the message textbox from the GUIWindow.
	GUITextArea* message=(GUITextArea*)obj->getChild("message");

	if(message){
	//Set the message of the notification block.
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	configuredObject, "message", message->getString(), _("Message")));
	}
	}
	}
	//Conveyor belt block configure events.
	else if(name=="cfgConveyorBlockOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	//Get the speed textbox from the GUIWindow.
	GUISpinBox* speed=(GUISpinBox*)obj->getChild("speed");

	if(speed){
	//Set the speed of the conveyor belt.
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	configuredObject, "speed10", speed->caption, _("Speed")));
	}
	}
	}
	//LevelSetting events.
	else if(name=="lvlSettingsOK"){
	SetLevelPropertyCommand::LevelProperty prop;

	prop.levelTime = -1;
	prop.levelRecordings = -1;

	GUIObject* object=obj->getChild("name");
	if(object)
	prop.levelName=object->caption;
	object=obj->getChild("theme");
	if(object)
	prop.levelTheme=object->caption;
	object = obj->getChild("music");
	if (object)
	prop.levelMusic = object->caption;

	//target time and recordings.
	GUISpinBox* object2=(GUISpinBox*)obj->getChild("time");
	if(object2){
	float number=atof(object2->caption.c_str());
	if(number<=0){
	prop.levelTime=-1;
	}else{
	prop.levelTime=int(floor(number*40.0f+0.5f));
	}
	}

	object2=(GUISpinBox*)obj->getChild("recordings");
	if(object){
	int number=atoi(object2->caption.c_str());
	if(number<=0){
	prop.levelRecordings=-1;
	}else{
	prop.levelRecordings=number;
	}
	}

	// Perform the level setting modification
	commandManager->doCommand(new SetLevelPropertyCommand(this, prop));
	}
	//Level scripting window events.
	else if(name=="cfgLevelScriptingEventType"){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgLevelScriptingEventType");

	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	GUIObject* script=obj->getChild(list->item[i].first);
	if(script){
	script->visible=(script->name==list->item[list->value].first);
	script->enabled=(script->name==list->item[list->value].first);
	}
	}
	}
	return;
	}
	else if(name=="cfgLevelScriptingOK"){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgLevelScriptingEventType");

	if(list){
	std::map<int, std::string> newScript;

	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	//Get the GUITextArea.
	GUITextArea* script=dynamic_cast<GUITextArea*>(obj->getChild(list->item[i].first));
	if(script){
	//Set the script for the target block.
	string str=script->getString();
	if(!str.empty())
	newScript[levelEventNameMap[script->name]]=str;
	}
	}

	// Check achievement
	if (!newScript.empty()) {
	statsMgr.newAchievement("helloworld");
	}

	// Do the actual changes
	commandManager->doCommand(new SetScriptCommand(this, NULL, newScript));
	}
	}
	//Scripting window events.
	else if (name == "cfgScriptingEventType"){
	//TODO: Save any unsaved scripts? (Or keep track of all scripts and save upon cfgScriptingOK?)
	//Get the configuredObject.
	Block* configuredObject=dynamic_cast<Block*>(objectWindows[obj]);
	if(configuredObject){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=dynamic_cast<GUISingleLineListBox*>(obj->getChild("cfgScriptingEventType"));

	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	GUIObject* script=obj->getChild(list->item[i].first);
	if(script){
	script->visible=script->enabled=(script->name==list->item[list->value].first);
	}
	}
	}
	}
	return;
	}
	else if(name=="cfgScriptingOK"){
	//Get the configuredObject.
	Block* block = dynamic_cast<Block*>(objectWindows[obj]);
	if (block){
	std::map<int, std::string> newScript;
	std::string newId;

	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgScriptingEventType");
	GUIObject* id=obj->getChild("id");

	if (list){
	//Loop through the scripts.
	for (unsigned int i = 0; i < list->item.size(); i++){
	//Get the GUITextArea.
	GUITextArea* script = dynamic_cast<GUITextArea*>(obj->getChild(list->item[i].first));
	if (script){
	//Set the script for the target block.
	string str = script->getString();
	if (!str.empty())
	newScript[gameObjectEventNameMap[script->name]] = str;
	}
	}
	}
	newId = block->id;
	if (id){
	newId = id->caption;
	}

	// Check achievement
	if (!newScript.empty()) {
	statsMgr.newAchievement("helloworld");
	}

	// now do the actual changes
	commandManager->doCommand(new SetScriptCommand(this, block, newScript, newId));
	}
	}
	else if (name == "cfgAddLayerOK") {
	GUIObject* object = obj->getChild("layerName");
	if (!object) return;
	if (object->caption.empty()) {
	msgBox(imageManager, renderer, _("Please enter a layer name."), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (sceneryLayers.find(object->caption) != sceneryLayers.end()) {
	msgBox(imageManager, renderer, tfm::format(_("The layer '%s' already exists."), object->caption), MsgBoxOKOnly, _("Error"));
	return;
	}

	// do the actual operation
	commandManager->doCommand(new AddRemoveLayerCommand(this, object->caption, true));
	}
	else if (name == "cfgRenameLayerOK") {
	GUIObject* object = obj->getChild("layerName");
	if (!object) return;
	const std::string& layerName = object->caption;

	object = obj->getChild("oldName");
	if (!object) return;
	const std::string& oldName = object->caption;

	if (layerName.empty()) {
	msgBox(imageManager, renderer, _("Please enter a layer name."), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (sceneryLayers.find(layerName) != sceneryLayers.end()) {
	// this includes the case that oldName == layerName
	msgBox(imageManager, renderer, tfm::format(_("The layer '%s' already exists."), layerName), MsgBoxOKOnly, _("Error"));
	return;
	}

	// do the actual operation
	commandManager->doCommand(new RenameLayerCommand(this, oldName, layerName));
	}
	else if (name == "cfgMoveToLayerOK") {
	GUIObject* object = obj->getChild("layerName");
	if (!object) return;
	const std::string& layerName = object->caption;

	object = obj->getChild("oldName");
	if (!object) return;
	const std::string& oldName = object->caption;

	if (layerName.empty()) {
	msgBox(imageManager, renderer, _("Please enter a layer name."), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (oldName == layerName) {
	msgBox(imageManager, renderer, _("Source and destination layers are the same."), MsgBoxOKOnly, _("Error"));
	return;
	}

	// do the actual operation
	commandManager->doCommand(new MoveToLayerCommand(this, selection, oldName, layerName));
	}
	else if (name == "cfgCustomSceneryOK") {
	//Get the configuredObject.
	Scenery* configuredObject = dynamic_cast<Scenery*>(objectWindows[obj]);
	if (configuredObject){
	//Get the custom scenery from the GUIWindow.
	GUITextArea* txt = (GUITextArea*)obj->getChild("cfgCustomScenery");

	if (txt){
	//Set the custom scenery.
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	configuredObject, "customScenery", txt->getString(), _("Scenery")));
	}
	}
	}
	else if (name == "lstAppearance") {
	//Get the configuredObject.
	Block block = dynamic_cast<Block>(objectWindows[obj]);
	GUIListBox list = dynamic_cast<GUIListBox>(obj->getChild("lstAppearance"));
	GUIImage image = dynamic_cast<GUIImage>(obj->getChild("imgAppearance"));
	if (block && list && image) {
	//Reset the image first.
	image->setImage(NULL);
	image->setClipRect(SDL_Rect{ 0, 0, 0, 0 });

	//Get the appearance name.
	std::string appearanceName;
	if (list->value <= 0) {
	//Do nothing since the selected is the default appearance.
	} else if (list->value <= (int)sceneryBlockNames.size()) {
	//A custom appearance is selected.
	appearanceName = sceneryBlockNames[list->value - 1];
	} else {
	//The configured object has an invalid custom appearance name.
	appearanceName = block->customAppearanceName;
	}

	//Try to find the theme block.
	ThemeBlock *themeBlock = NULL;
	if (!appearanceName.empty()) {
	themeBlock = objThemes.getScenery(appearanceName);
	}
	if (themeBlock == NULL) {
	themeBlock = objThemes.getBlock(block->type);
	}
	if (themeBlock) {
	image->setImage(themeBlock->editorPicture.texture);
	const auto& offsetData = themeBlock->editorPicture.offset.offsetData;
	if (offsetData.size() > 0) {
	const auto& r = offsetData[0];
	image->setClipRect(SDL_Rect{ r.x, r.y, r.w, r.h });
	}
	}
	}
	return;
	}
	else if (name == "cfgAppearanceOK") {
	//Get the configuredObject.
	Block block = dynamic_cast<Block>(objectWindows[obj]);
	GUIListBox list = dynamic_cast<GUIListBox>(obj->getChild("lstAppearance"));
	if (block && list) {
	//Get the appearance name.
	std::string appearanceName;
	if (list->value <= 0) {
	//Do nothing since the selected is the default appearance.
	} else if (list->value <= (int)sceneryBlockNames.size()) {
	//A custom appearance is selected.
	appearanceName = sceneryBlockNames[list->value - 1];
	} else {
	//The configured object has an invalid custom appearance name.
	appearanceName = block->customAppearanceName;
	}

	//Update the block property if it's changed.
	if (appearanceName != block->customAppearanceName) {
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	block, "appearance", appearanceName, _("Appearance")));
	}
	}
	}

	//NOTE: We assume every event came from a window
	//and the event is either window closed event or OK/Cancel button click event, so we remove it.
	destroyWindow(obj);
	}

	void LevelEditor::destroyWindow(GUIObject* window){
	//Make sure the given pointer isn't null.
	if(!window)
	return;

	//Remove the window from the GUIObject root.
	if(GUIObjectRoot){
	vector<GUIObject*>::iterator it;
	it=find(GUIObjectRoot->childControls.begin(),GUIObjectRoot->childControls.end(),window);
	if(it!=GUIObjectRoot->childControls.end()){
	GUIObjectRoot->childControls.erase(it);
	}
	}

	//Also remove the window from the objectWindows map.
	map<GUIObject,GameObject>::iterator it;
	it=objectWindows.find(window);
	if(it!=objectWindows.end()){
	objectWindows.erase(it);
	}

	//And delete the GUIWindow.
	delete window;
	}

	////////////////LOGIC////////////////////
	void LevelEditor::logic(ImageManager& imageManager, SDL_Renderer& renderer){
	if(playMode){
	//PlayMode so let the game do it's logic.
	Game::logic(imageManager,renderer);
	}else{
	//Update animation even under edit mode. (There are checks in Block::move() which don't do game logic in edit mode.)
	for (unsigned int i = 0; i<levelObjects.size(); i++){
	//Let the gameobject handle movement.
	levelObjects[i]->move();
	}

	//Also update the scenery.
	for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it){
	- for (unsigned int i = 0; i<it->second.size(); i++)
	- it->second[i]->move();
	+ it->second->updateAnimation();
	}

	//In case of a selection or actions popup prevent the camera from moving.
	if(selectionPopup \|\| actionsPopup)
	return;

	//Move the camera.
	if(cameraXvel!=0 \|\| cameraYvel!=0){
	camera.x+=cameraXvel;
	camera.y+=cameraYvel;
	//Call the onCameraMove event.
	onCameraMove(cameraXvel,cameraYvel);
	}

	//Move the camera with the mouse.
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};
	{
	//Check if the mouse isn't above a GUIObject (window).
	bool inside=false;
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	SDL_Rect box={0,0,0,0};
	box.x=GUIObjectRoot->childControls[i]->left;
	box.y=GUIObjectRoot->childControls[i]->top;
	box.w=GUIObjectRoot->childControls[i]->width;
	box.h=GUIObjectRoot->childControls[i]->height;
	if(checkCollision(mouse,box))
	inside=true;
	}

	if(!inside){
	SDL_Rect r[3]={toolbarRect,toolboxRect};
	int m=2;
	//TODO: Also call onCameraMove when moving using the mouse.
	setCamera(r,m);
	}
	}

	//It isn't playMode so the mouse should be checked.
	tooltip=-1;

	//We loop through the number of tools + the number of buttons.
	for (int t = 0; t <= (int)ToolTips::BackToMenu; t++){
	SDL_Rect toolRect={(SCREEN_WIDTH-460)/2+(t40)+((t+1)10),SCREEN_HEIGHT-45,40,40};

	//Check for collision.
	if(checkCollision(mouse,toolRect)==true){
	//Set the tooltip tool.
	tooltip=t;
	}
	}
	}
	}

	/////////////////RENDER//////////////////////
	void LevelEditor::render(ImageManager& imageManager,SDL_Renderer& renderer){
	//Let the game render the game when it is the play mode.
	if (playMode) {
	Game::render(imageManager, renderer);
	} else {
	// The following code are partially copied from Game::render()

	//First of all render the background.
	{
	//Get a pointer to the background.
	ThemeBackground* bg = background;

	//Check if the background is null, but there are themes.
	if (bg == NULL && objThemes.themeCount()>0){
	//Get the background from the first theme in the stack.
	bg = objThemes[0]->getBackground(false);
	}

	//Check if the background isn't null.
	if (bg){
	//It isn't so draw it.
	bg->draw(renderer);

	//And if it's the loaded background then also update the animation.
	//FIXME: Updating the animation in the render method?
	if (bg == background)
	bg->updateAnimation();
	} else{
	//There's no background so fill the screen with white.
	SDL_SetRenderDrawColor(&renderer, 255, 255, 255, 255);
	SDL_RenderClear(&renderer);
	}
	}

	//Now draw the background layers.
	- std::map<std::string, std::vector<Scenery*> >::iterator it;
	- for (it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it){
	+ auto it = sceneryLayers.begin();
	+ for (; it != sceneryLayers.end(); ++it){
	if (it->first >= "f") break; // now we meet a foreground layer
	if (layerVisibility[it->first]) {
	- for (unsigned int i = 0; i < it->second.size(); i++)
	- it->second[i]->show(renderer);
	+ it->second->show(renderer);
	}
	}

	//Now we draw the levelObjects.
	if (layerVisibility[std::string()]) {
	for (unsigned int o = 0; o < levelObjects.size(); o++){
	levelObjects[o]->show(renderer);
	}
	}

	//We don't draw the player and the shadow at all.

	//Now draw the foreground layers.
	for (; it != sceneryLayers.end(); ++it){
	if (layerVisibility[it->first]) {
	- for (unsigned int i = 0; i < it->second.size(); i++)
	- it->second[i]->show(renderer);
	+ it->second->show(renderer);
	}
	}
	}

	//Only render extra stuff like the toolbar, selection, etc.. when not in playMode.
	if(!playMode){
	//Get the current mouse location.
	int x, y;
	SDL_GetMouseState(&x, &y);
	//Create the rectangle.
	SDL_Rect mouse = { x + camera.x, y + camera.y, 0, 0 };

	//Render the selectionmarks.
	//TODO: Check if block is in sight.
	for(unsigned int o=0; o<selection.size(); o++){
	//Get the location to draw.
	SDL_Rect r=selection[o]->getBox();

	// Change the mouse cursor if necessary
	if (selectionDrag < 0 && tool != REMOVE) {
	int midx = r.x + r.w / 2 - 2;
	int midy = r.y + r.h / 2 - 2;
	if (mouse.x >= r.x && mouse.x < r.x + 5) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	currentCursor = CURSOR_SIZE_FDIAG;
	} else if (mouse.y >= midy && mouse.y < midy + 5) {
	currentCursor = CURSOR_SIZE_HOR;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	currentCursor = CURSOR_SIZE_BDIAG;
	}
	} else if (mouse.x >= midx && mouse.x < midx + 5) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	currentCursor = CURSOR_SIZE_VER;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	currentCursor = CURSOR_SIZE_VER;
	}
	} else if (mouse.x >= r.x + r.w - 5 && mouse.x < r.x + r.w) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	currentCursor = CURSOR_SIZE_BDIAG;
	} else if (mouse.y >= midy && mouse.y < midy + 5) {
	currentCursor = CURSOR_SIZE_HOR;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	currentCursor = CURSOR_SIZE_FDIAG;
	}
	}
	}

	bool mouseIn = checkCollision(r, mouse);

	r.x-=camera.x;
	r.y-=camera.y;

	drawGUIBox(r.x,r.y,r.w,r.h,renderer,0xFFFFFF33);

	//Draw the selectionMarks.
	applyTexture(r.x,r.y,selectionMark,renderer);
	applyTexture(r.x+r.w-5,r.y,selectionMark,renderer);
	applyTexture(r.x,r.y+r.h-5,selectionMark,renderer);
	applyTexture(r.x+r.w-5,r.y+r.h-5,selectionMark,renderer);

	// draw additional selection marks
	if (mouseIn && selectionDrag < 0 && tool != REMOVE) {
	applyTexture(r.x + r.w / 2 - 2, r.y, selectionMark, renderer);
	applyTexture(r.x + r.w / 2 - 2, r.y + r.h - 5, selectionMark, renderer);
	applyTexture(r.x, r.y + r.h / 2 - 2, selectionMark, renderer);
	applyTexture(r.x + r.w - 5, r.y + r.h / 2 - 2, selectionMark, renderer);
	}
	}

	//Set the color for the borders.
	{
	SDL_Color c = objThemes.getTextColor(false);
	SDL_SetRenderDrawColor(&renderer, c.r, c.g, c.b, 115);
	}

	int leftWidth=0;
	int rightWidth=0;

	//Draw the dark areas marking the outside of the level.
	SDL_Rect r{0,0,0,0};
	if(camera.x<0){
	//Draw left side.
	r.x=0;
	r.y=0;
	r.w=0-camera.x;
	leftWidth=r.w;
	r.h=SCREEN_HEIGHT;
	SDL_RenderFillRect(&renderer, &r);
	}
	if(camera.y<0){
	//Draw the top.
	r.x=leftWidth;
	r.y=0;
	r.w=SCREEN_WIDTH;
	r.h=0-camera.y;
	SDL_RenderFillRect(&renderer, &r);
	} else {
	r.h=0;
	}
	if(camera.x>LEVEL_WIDTH-SCREEN_WIDTH){
	//Draw right side.
	r.x=LEVEL_WIDTH-camera.x;
	r.y=std::max(r.y+r.h,0);
	r.w=SCREEN_WIDTH-(LEVEL_WIDTH-camera.x);
	rightWidth=r.w;
	r.h=SCREEN_HEIGHT;
	SDL_RenderFillRect(&renderer, &r);
	}
	if(camera.y>LEVEL_HEIGHT-SCREEN_HEIGHT){
	//Draw the bottom.
	r.x=leftWidth;
	r.y=LEVEL_HEIGHT-camera.y;
	r.w=SCREEN_WIDTH-rightWidth-leftWidth;
	r.h=SCREEN_HEIGHT-(LEVEL_HEIGHT-camera.y);
	SDL_RenderFillRect(&renderer, &r);
	}

	//Check if we should draw on stuff.
	showConfigure(renderer);
	if (selectionDrag >= 0 && tool != REMOVE) {
	showSelectionDrag(renderer);
	}

	//Find a block where the mouse is hovering on.
	bool isMouseOnSomething = false;
	if (selectedLayer.empty()){
	if (layerVisibility[selectedLayer]) {
	// Current layer is Blocks layer
	for (unsigned int o = 0; o<levelObjects.size(); o++){
	SDL_Rect rect = levelObjects[o]->getBox();
	if (checkCollision(rect, mouse) == true){
	isMouseOnSomething = true;
	if (tool == REMOVE){
	drawGUIBox(rect.x - camera.x, rect.y - camera.y, rect.w, rect.h, renderer, 0xFF000055);
	currentCursor = CURSOR_REMOVE;
	} else{
	drawGUIBox(rect.x - camera.x, rect.y - camera.y, rect.w, rect.h, renderer, 0xFFFFFF33);
	}
	}
	}
	}
	} else {
	auto it = sceneryLayers.find(selectedLayer);
	if (it != sceneryLayers.end() && layerVisibility[selectedLayer]) {
	// Current layer is scenery layer
	- for (unsigned int o = 0; o<it->second.size(); o++){
	- SDL_Rect rect = it->second[o]->getBox();
	+ for (auto o : it->second->objects){
	+ SDL_Rect rect = o->getBox();
	if (checkCollision(rect, mouse) == true){
	isMouseOnSomething = true;
	if (tool == REMOVE){
	drawGUIBox(rect.x - camera.x, rect.y - camera.y, rect.w, rect.h, renderer, 0xFF000055);
	currentCursor = CURSOR_REMOVE;
	} else{
	drawGUIBox(rect.x - camera.x, rect.y - camera.y, rect.w, rect.h, renderer, 0xFFFFFF33);
	}
	}
	}
	}
	}

	// show current object only when mouse is not hover on any blocks
	if (!isMouseOnSomething && tool == ADD && selectionDrag < 0) {
	showCurrentObject(renderer);
	}

	//Draw the level borders.
	drawRect(-camera.x,-camera.y,LEVEL_WIDTH,LEVEL_HEIGHT,renderer);

	//Render the hud layer.
	renderHUD(renderer);

	//Render selection popup (if any).
	if(selectionPopup!=NULL){
	if(linking \|\| moving){
	//If we switch to linking mode then delete it
	//FIXME: Logic in the render method.
	delete selectionPopup;
	selectionPopup=NULL;
	}else{
	selectionPopup->render(imageManager,renderer);
	}
	}

	//Render actions popup (if any).
	if(actionsPopup!=NULL){
	actionsPopup->render(renderer);
	}
	}
	}

	void LevelEditor::renderHUD(SDL_Renderer& renderer){
	//If moving show the moving speed in the top right corner.
	if(moving){
	//Calculate width of text "Movespeed: 125" to keep the same position with every value
	if (movingSpeedWidth == -1){
	int w;
	TTF_SizeUTF8(fontText, tfm::format(_("Speed: %d = %0.2f block/s"), 125, 10.0f).c_str(), &w, NULL);
	movingSpeedWidth = w + 4;
	}

	SDL_Texture *tex = NULL;

	//Check which text should we use.
	if (pauseMode) {
	//Update the text if necessary.
	if (pauseTimeTexture.needsUpdate(pauseTime)) {
	if (pauseTime < 0) {
	pauseTimeTexture.update(pauseTime,
	textureFromText(renderer, *fontText,
	_("Stop at this point"),
	objThemes.getTextColor(true)));
	} else {
	pauseTimeTexture.update(pauseTime,
	textureFromText(renderer, *fontText,
	tfm::format(_("Pause: %d = %0.3fs"), pauseTime, float(pauseTime)*0.025f).c_str(),
	objThemes.getTextColor(true)));
	}
	}
	tex = pauseTimeTexture.get();
	} else {
	//Update the text if necessary.
	if (movementSpeedTexture.needsUpdate(movingSpeed)) {
	movementSpeedTexture.update(movingSpeed,
	textureFromText(renderer, *fontText,
	tfm::format(_("Speed: %d = %0.2f block/s"), movingSpeed, float(movingSpeed)*0.08f).c_str(),
	objThemes.getTextColor(true)));
	}
	tex = movementSpeedTexture.get();
	}

	//Draw the text in the box.
	drawGUIBox(SCREEN_WIDTH-movingSpeedWidth-2,-2,movingSpeedWidth+8,
	textureHeight(*tex)+6,renderer,0xFFFFFFFF);
	applyTexture(SCREEN_WIDTH-movingSpeedWidth,2,*tex,renderer,NULL);
	}

	//On top of all render the toolbar.
	drawGUIBox(toolbarRect.x,toolbarRect.y,9*50+10,52,renderer,0xEDEDEDFF);
	//Draw the first four options.
	SDL_Rect srcRect={0,0,200,50};
	SDL_Rect dstRect={toolbarRect.x+5, toolbarRect.y, srcRect.w, srcRect.h};
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);

	//Draw the undo/redo button.
	SDL_SetTextureAlphaMod(toolbar.get(), commandManager->canUndo() ? 255 : 128);
	srcRect.x = 200;
	srcRect.w = 50;
	dstRect.x = toolbarRect.x + 205;
	dstRect.w = srcRect.w;
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);
	SDL_SetTextureAlphaMod(toolbar.get(), commandManager->canRedo() ? 255 : 128);
	srcRect.x = 250;
	srcRect.w = 50;
	dstRect.x = toolbarRect.x + 255;
	dstRect.w = srcRect.w;
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);
	SDL_SetTextureAlphaMod(toolbar.get(), 255);

	//And the last three.
	srcRect.x=300;
	srcRect.w=150;
	dstRect.x=toolbarRect.x+305;
	dstRect.w=srcRect.w;
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);

	//Now render a tooltip.
	if(tooltip>=0 && static_cast<std::size_t>(tooltip)<tooltipTextures.size()) {
	SDL_Texture *tex = tooltipTextures.at(tooltip).get();

	if (tooltip == (int)ToolTips::UndoNoTooltip) {
	std::string s = commandManager->describeUndo();
	if (undoTooltipTexture.needsUpdate(s)) {
	undoTooltipTexture.update(s, textureFromText(renderer, *fontText, s.c_str(), objThemes.getTextColor(true)));
	}
	tex = undoTooltipTexture.get();
	} else if (tooltip == (int)ToolTips::RedoNoTooltip) {
	std::string s = commandManager->describeRedo();
	if (redoTooltipTexture.needsUpdate(s)) {
	redoTooltipTexture.update(s, textureFromText(renderer, *fontText, s.c_str(), objThemes.getTextColor(true)));
	}
	tex = redoTooltipTexture.get();
	}

	if(tex) {
	const SDL_Rect texSize = rectFromTexture(*tex);
	SDL_Rect r={(SCREEN_WIDTH-440)/2+(tooltip40)+(tooltip10),SCREEN_HEIGHT-45,40,40};
	r.y=SCREEN_HEIGHT-50-texSize.h;
	if(r.x+texSize.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-texSize.w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(r.x-2,r.y-2,texSize.w+4,texSize.h+4,renderer,color);
	applyTexture(r.x, r.y, *tex, renderer);
	}
	}

	// for toolbox button animation (0-31)
	static int tick = 8;

	const int mmm = getEditorOrderMax();
	if (currentType >= mmm)currentType = mmm - 1;
	if (currentType < 0) currentType = 0;

	//Render the tool box.
	if(!playMode && !moving && tool==ADD && selectionPopup==NULL && actionsPopup==NULL && objectWindows.empty()){
	// get mouse position
	int x, y;
	SDL_GetMouseState(&x, &y);

	if (toolboxVisible){
	toolboxRect.x=0;
	toolboxRect.y=0;
	toolboxRect.w=SCREEN_WIDTH;
	toolboxRect.h=64;

	drawGUIBox(-2,-2,SCREEN_WIDTH+4,66,renderer,0xFFFFFF00\|230);

	bool isMouseOnSomething = false;

	//Draw the hide icon.
	SDL_Rect r={SCREEN_WIDTH-20,2,16,16};
	SDL_Rect r2={80,0,r.w,r.h};
	if (x >= SCREEN_WIDTH - 24 && x < SCREEN_WIDTH && y < 20) {
	isMouseOnSomething = true;
	tick = (tick + 1) & 31;
	r.y -= (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	}
	SDL_RenderCopy(&renderer, bmGUI.get(), &r2, &r);

	//Calculate the maximal number of blocks can be displayed.
	const int m=(SCREEN_WIDTH-48)/64;
	if(toolboxIndex>=mmm-m){
	toolboxIndex = mmm - m;
	}else{
	//Draw an icon.
	r.x=SCREEN_WIDTH-20;
	r.y=24;
	r2.x=96;
	r2.y=16;
	if (x >= SCREEN_WIDTH - 24 && x < SCREEN_WIDTH && y >= 20 && y < 44) {
	isMouseOnSomething = true;
	tick = (tick + 1) & 31;
	r.x += (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	}
	SDL_RenderCopy(&renderer, bmGUI.get(),&r2,&r);
	}
	if(toolboxIndex<=0){
	toolboxIndex=0;
	}else{
	//Draw an icon.
	r.x=4;
	r.y=24;
	r2.x=80;
	r2.y=16;
	if (x >= 0 && x < 24 && y >= 20 && y < 44) {
	isMouseOnSomething = true;
	tick = (tick + 1) & 31;
	r.x -= (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	}
	SDL_RenderCopy(&renderer, bmGUI.get(), &r2, &r);
	}

	// reset animation timer if there is no animation
	if (!isMouseOnSomething) {
	tick = 8;
	}

	//Draw available blocks.
	for(int i=0;i<m;i++){
	if (i + toolboxIndex >= mmm) break;

	//Draw a rectangle around the current tool.
	if(i+toolboxIndex==currentType){
	drawGUIBox(i*64+24,3,64,58,renderer,0xDDDDDDFF);
	}

	if (selectedLayer.empty()) {
	// show normal blocks
	ThemeBlock* obj = objThemes.getBlock(editorTileOrder[i + toolboxIndex]);
	if (obj){
	obj->editorPicture.draw(renderer, i * 64 + 24 + 7, 7);
	}
	} else {
	// show scenery blocks
	if (i + toolboxIndex < (int)sceneryBlockNames.size()) {
	ThemeBlock* obj = objThemes.getScenery(sceneryBlockNames[i + toolboxIndex]);
	if (obj){
	obj->editorPicture.draw(renderer, i * 64 + 24 + 7, 7);
	}
	} else {
	// it's custom scenery block
	// just draw a stupid icon
	const SDL_Rect r = { 48, 16, 16, 16 };
	const SDL_Rect dstRect = { i * 64 + 24 + 7, 7, 16, 16 };
	SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	}
	}
	}

	//Draw a tool tip.
	if(y<64 && x>=24 && x<24+m*64){
	int i=(x-24)/64;
	if (i + toolboxIndex < getEditorOrderMax()){
	TexturePtr& tip = (!selectedLayer.empty())
	? getCachedTextTexture(renderer, (i + toolboxIndex < (int)sceneryBlockNames.size())
	? describeSceneryName(sceneryBlockNames[i + toolboxIndex]).c_str() : _("Custom scenery block"))
	: typeTextTextures.at(editorTileOrder[i + toolboxIndex]);

	const SDL_Rect tipSize = rectFromTexture(*tip);

	SDL_Rect r = { 24 + i * 64, 64, 40, 40 };
	if (r.x + tipSize.w>SCREEN_WIDTH - 50)
	r.x = SCREEN_WIDTH - 50 - tipSize.w;

	//Draw borders around text
	Uint32 color = 0xFFFFFF00 \| 230;
	drawGUIBox(r.x - 2, r.y - 2, tipSize.w + 4, tipSize.h + 4, renderer, color);

	//Draw tooltip's text
	applyTexture(r.x, r.y, tip, renderer);
	}
	}
	}else{
	const SDL_Rect tbtSize = rectFromTexture(*toolboxText);

	toolboxRect.x=SCREEN_WIDTH-tbtSize.w-28;
	toolboxRect.y=0;
	toolboxRect.w=tbtSize.w+28;
	toolboxRect.h=tbtSize.h+4;

	SDL_Rect r={SCREEN_WIDTH-tbtSize.w-24,2,16,16};
	drawGUIBox(r.x-4,-2,tbtSize.w+32,tbtSize.h+6,renderer,0xFFFFFFFF);

	//Draw "Toolbox" text.
	applyTexture(r.x, r.y, toolboxText, renderer);

	const SDL_Rect r2={96,0,16,16};
	r.x=SCREEN_WIDTH-20;
	r.w=r2.w;
	r.h=r2.h;

	// check if mouse is hovering on
	if (x >= toolboxRect.x && x < toolboxRect.x + toolboxRect.w && y >= toolboxRect.y && y < toolboxRect.y + toolboxRect.h) {
	tick = (tick + 1) & 31;
	r.y += (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	} else {
	tick = 8;
	}

	//Draw arrow.
	SDL_RenderCopy(&renderer, bmGUI.get(),&r2,&r);
	}
	}else{
	toolboxRect.x=-1;
	toolboxRect.y=-1;
	toolboxRect.w=0;
	toolboxRect.h=0;
	}

	//Draw a rectangle around the current tool.
	Uint32 color=0xFFFFFF00;
	drawGUIBox((SCREEN_WIDTH-440)/2+(tool40)+(tool10),SCREEN_HEIGHT-46,42,42,renderer,color);
	}

	void LevelEditor::showCurrentObject(SDL_Renderer& renderer){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	//Check if we should snap the block to grid or not.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	//Check if the currentType is a legal type.
	if(currentType>=0 && currentType<getEditorOrderMax()){
	if (selectedLayer.empty()) {
	// show normal blocks
	ThemeBlock* obj = objThemes.getBlock(editorTileOrder[currentType]);
	if (obj){
	obj->editorPicture.draw(renderer, x - camera.x, y - camera.y);
	}
	} else {
	// show scenery blocks
	if (currentType < (int)sceneryBlockNames.size()) {
	ThemeBlock* obj = objThemes.getScenery(sceneryBlockNames[currentType]);
	if (obj){
	obj->editorPicture.draw(renderer, x - camera.x, y - camera.y);
	}
	} else {
	// it's custom scenery block
	// just draw a stupid icon
	const SDL_Rect r = { 48, 16, 16, 16 };
	const SDL_Rect dstRect = { x - camera.x, y - camera.y, 16, 16 };
	SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	}
	}
	}
	}

	void LevelEditor::determineNewPosition(int& x, int& y) {
	if (dragCenter) {
	SDL_Rect r = dragCenter->getBox();
	x -= dragSrartPosition.x - r.x;
	y -= dragSrartPosition.y - r.y;
	} else {
	x -= 25;
	y -= 25;
	}

	// Check if we should snap the block to grid or not.
	if (!pressedShift) {
	x = int(floor(x/50.0f + 0.5f)) * 50;
	y = int(floor(y/50.0f + 0.5f)) * 50;
	}
	}

	void LevelEditor::determineNewSize(int x, int y, SDL_Rect& r) {
	switch (selectionDrag % 3) {
	case 0:
	if (x > r.x + r.w - 15) x = r.x + r.w - 15;
	if (!pressedShift) {
	x = int(floor(x/50.0f + 0.5f)) * 50;
	while (x > r.x + r.w - 15) x -= 50;
	}
	r.w += r.x - x;
	r.x = x;
	break;
	case 2:
	if (x < r.x + 15) x = r.x + 15;
	if (!pressedShift) {
	x = int(floor(x/50.0f + 0.5f)) * 50;
	while (x < r.x + 15) x += 50;
	}
	r.w = x - r.x;
	break;
	}
	switch (selectionDrag / 3) {
	case 0:
	if (y > r.y + r.h - 15) y = r.y + r.h - 15;
	if (!pressedShift) {
	y = int(floor(y/50.0f + 0.5f)) * 50;
	while (y > r.y + r.h - 15) y -= 50;
	}
	r.h += r.y - y;
	r.y = y;
	break;
	case 2:
	if (y < r.y + 15) y = r.y + 15;
	if (!pressedShift) {
	y = int(floor(y/50.0f + 0.5f)) * 50;
	while (y < r.y + 15) y += 50;
	}
	r.h = y - r.y;
	break;
	}
	}

	void LevelEditor::showSelectionDrag(SDL_Renderer& renderer){
	//Check if the drag center isn't null.
	if (dragCenter == NULL) return;

	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Create the rectangle.
	x+=camera.x;
	y+=camera.y;

	//The location of the dragCenter.
	SDL_Rect r = dragCenter->getBox();

	if (selectionDrag == 4) { // dragging
	// Check if we should snap the block to grid or not.
	determineNewPosition(x, y);

	//Loop through the selection.
	//TODO: Check if block is in sight.
	for (unsigned int o = 0; o < selection.size(); o++){
	// FIXME: ad-hoc code which moves blocks temporarily, draw, and moves them back
	const SDL_Rect r1 = selection[o]->getBox();

	selection[o]->setBaseLocation((r1.x - r.x) + x, (r1.y - r.y) + y);
	selection[o]->show(renderer);
	selection[o]->setBaseLocation(r1.x, r1.y);
	}
	} else if (selectionDrag >= 0) { // resizing
	// Check if we should snap the block to grid or not.
	determineNewSize(x, y, r);

	drawGUIBox(r.x - camera.x, r.y - camera.y, r.w, r.h, renderer, 0xFFFFFF33);
	}
	}

	void LevelEditor::showConfigure(SDL_Renderer& renderer){
	//arrow animation value. go through 0-65535 and loops.
	static unsigned short arrowAnimation=0;
	arrowAnimation++;

	// skip if the Blocks layer is invisinble
	if (!layerVisibility[std::string()]) return;

	//Use theme color for arrows.
	Uint32 color;
	{
	SDL_Color c = objThemes.getTextColor(false);
	color = (Uint32(c.r) << 24) \| (Uint32(c.g) << 16) \| (Uint32(c.b) << 8) \| 0xff;
	}

	//Draw the trigger lines.
	{
	map<Block,vector<GameObject> >::iterator it;
	for(it=triggers.begin();it!=triggers.end();++it){
	//Check if the trigger has linked targets.
	if(!(*it).second.empty()){
	//The location of the trigger.
	SDL_Rect r=(*it).first->getBox();

	//Loop through the targets.
	for(unsigned int o=0;o<(*it).second.size();o++){
	//Get the location of the target.
	SDL_Rect r1=(*it).second[o]->getBox();

	//Draw the line from the center of the trigger to the center of the target.
	drawLineWithArrow(r.x-camera.x+25,r.y-camera.y+25,r1.x-camera.x+25,r1.y-camera.y+25,renderer,color,32,arrowAnimation%32);

	//Also draw two selection marks.
	applyTexture(r.x-camera.x+25-2,r.y-camera.y+25-2,selectionMark,renderer);
	applyTexture(r1.x-camera.x+25-2,r1.y-camera.y+25-2,selectionMark,renderer);
	}
	}
	}

	//Draw a line to the mouse from the linkingTrigger when linking.
	if(linking){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Draw the line from the center of the trigger to mouse.
	drawLineWithArrow(linkingTrigger->getBox().x-camera.x+25,linkingTrigger->getBox().y-camera.y+25,x,y,renderer,color,32,arrowAnimation%32);
	}
	}

	//Draw the moving positions.
	map<Block*,vector<MovingPosition> >::iterator it;
	for(it=movingBlocks.begin();it!=movingBlocks.end();++it){
	//Check if the block has positions.
	if(!(*it).second.empty()){
	//The location of the moving block.
	SDL_Rect block=(*it).first->getBox();
	block.x+=25-camera.x;
	block.y+=25-camera.y;

	//The location of the previous position.
	//The first time it's the moving block's position self.
	SDL_Rect r=block;

	//Loop through the positions.
	for(unsigned int o=0;o<(*it).second.size();o++){
	//Draw the line from the center of the previous position to the center of the position.
	//x and y are the coordinates for the current moving position.
	int x=block.x+(*it).second[o].x;
	int y=block.y+(*it).second[o].y;

	//Check if we need to draw line
	double dx=r.x-x;
	double dy=r.y-y;
	double d=sqrt(dxdx+dydy);
	if(d>0.001f){
	if(it->second[o].time>0){
	//Calculate offset to contain the moving speed.
	int offset=int(d*arrowAnimation/it->second[o].time)%32;
	drawLineWithArrow(r.x,r.y,x,y,renderer,color,32,offset);
	}else{
	//time==0 ???? so don't draw arrow at all
	drawLine(r.x,r.y,x,y,renderer);
	}
	} else {
	// distance==0 which means pause mode
	// FIXME: it's ugly
	SDL_Texture *tex;
	if (it->second[o].time) {
	tex = getCachedTextTexture(renderer, tfm::format("%0.3fs", float(it->second[o].time)*0.025f)).get();
	} else {
	tex = getCachedTextTexture(renderer, _("Stop")).get();
	}
	applyTexture(x - textureWidth(tex) / 2, y + 5, tex, renderer);
	}

	//And draw a marker at the end.
	applyTexture(x-13,y-13,movingMark,renderer);

	//Get the box of the previous position.
	SDL_Rect tmp={x,y,0,0};
	r=tmp;
	}
	}
	}

	//Draw a line to the mouse from the previous moving pos.
	if(moving){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Check if we should snap the block to grid or not.
	if(!pressedShift){
	x+=camera.x;
	y+=camera.y;
	snapToGrid(&x,&y);
	x-=camera.x;
	y-=camera.y;
	}else{
	x-=25;
	y-=25;
	}

	int posX,posY;

	//Check if there are moving positions for the moving block.
	if(!movingBlocks[movingBlock].empty()){
	//Draw the line from the center of the previouse moving positions to mouse.
	posX=movingBlocks[movingBlock].back().x;
	posY=movingBlocks[movingBlock].back().y;

	posX-=camera.x;
	posY-=camera.y;

	posX+=movingBlock->getBox().x;
	posY+=movingBlock->getBox().y;
	}else{
	//Draw the line from the center of the movingblock to mouse.
	posX=movingBlock->getBox().x-camera.x;
	posY=movingBlock->getBox().y-camera.y;
	}

	//Check if the current point is the same as the previous point
	if (posX == x && posY == y) {
	pauseMode = true;
	} else {
	pauseMode = false;

	//Calculate offset to contain the moving speed.
	int offset = int(double(arrowAnimation)*movingSpeed / 10.0) % 32;

	//Draw the line.
	drawLineWithArrow(posX + 25, posY + 25, x + 25, y + 25, renderer, color, 32, offset);
	}

	//Draw a marker.
	applyTexture(x+12,y+12,movingMark,renderer);
	}

	}

	void LevelEditor::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Call the resize method of the Game.
	Game::resize(imageManager, renderer);

	//Move the toolbar's position rect used for collision.
	toolbarRect.x=(SCREEN_WIDTH-460)/2;
	toolbarRect.y=SCREEN_HEIGHT-50;
	}

	//Filling the order array
	const int LevelEditor::editorTileOrder[EDITOR_ORDER_MAX]={
	TYPE_BLOCK,
	TYPE_SHADOW_BLOCK,
	TYPE_SPIKES,
	TYPE_FRAGILE,
	TYPE_MOVING_BLOCK,
	TYPE_MOVING_SHADOW_BLOCK,
	TYPE_MOVING_SPIKES,
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,
	TYPE_BUTTON,
	TYPE_SWITCH,
	TYPE_PORTAL,
	TYPE_SWAP,
	TYPE_CHECKPOINT,
	TYPE_NOTIFICATION_BLOCK,
	TYPE_START_PLAYER,
	TYPE_START_SHADOW,
	TYPE_EXIT,
	TYPE_COLLECTABLE,
	TYPE_PUSHABLE
	};
	diff --git a/src/SceneryLayer.cpp b/src/SceneryLayer.cpp
	new file mode 100644
	index 0000000..728b806
	--- /dev/null
	+++ b/src/SceneryLayer.cpp
	@@ -0,0 +1,194 @@
	+/*
	+ * Copyright (C) 2018 Me and My Shadow
	+ *
	+ * This file is part of Me and My Shadow.
	+ *
	+ * Me and My Shadow is free software: you can redistribute it and/or modify
	+ * it under the terms of the GNU General Public License as published by
	+ * the Free Software Foundation, either version 3 of the License, or
	+ * (at your option) any later version.
	+ *
	+ * Me and My Shadow is distributed in the hope that it will be useful,
	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	+ * GNU General Public License for more details.
	+ *
	+ * You should have received a copy of the GNU General Public License
	+ * along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	+ */
	+
	+#include "SceneryLayer.h"
	+#include "ImageManager.h"
	+#include "Render.h"
	+#include "POASerializer.h"
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <sstream>
	+
	+SceneryLayer::SceneryLayer()
	+ : speedX(0), speedY(0)
	+ , cameraX(1), cameraY(1)
	+ , currentX(0), currentY(0)
	+ , savedX(0), savedY(0)
	+{
	+}
	+
	+SceneryLayer::~SceneryLayer() {
	+ for (auto o : objects) {
	+ delete o;
	+ }
	+ objects.clear();
	+}
	+
	+void SceneryLayer::loadFromNode(Game parent, ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode obj) {
	+ //Retrieve the speed.
	+ {
	+ auto &v = obj->attributes["speed"];
	+ if (v.size() >= 2) {
	+ speedX = atof(v[0].c_str());
	+ speedY = atof(v[1].c_str());
	+ }
	+ }
	+
	+ //Retrieve the camera speed.
	+ {
	+ auto &v = obj->attributes["cameraSpeed"];
	+ if (v.size() >= 2) {
	+ cameraX = atof(v[0].c_str());
	+ cameraY = atof(v[1].c_str());
	+ }
	+ }
	+
	+ //Loop through the sub nodes.
	+ for (auto obj2 : obj->subNodes){
	+ if (obj2 == NULL) continue;
	+
	+ if (obj2->name == "object" \|\| obj2->name == "scenery"){
	+ //Load the scenery from node.
	+ Scenery* scenery = new Scenery(parent);
	+ if (!scenery->loadFromNode(imageManager, renderer, obj2)){
	+ delete scenery;
	+ continue;
	+ }
	+
	+ objects.push_back(scenery);
	+ }
	+ }
	+}
	+
	+void SceneryLayer::updateAnimation() {
	+ //Update the animation of the layer itself.
	+ currentX += speedX;
	+ currentY += speedY;
	+
	+ //Update the animation of objects.
	+ for (auto obj : objects) {
	+ obj->move();
	+ }
	+}
	+
	+void SceneryLayer::resetAnimation(bool save) {
	+ currentX = 0.0f;
	+ currentY = 0.0f;
	+ if (save){
	+ savedX = 0.0f;
	+ savedY = 0.0f;
	+ }
	+
	+ for (auto obj : objects) {
	+ obj->reset(save);
	+ }
	+}
	+
	+void SceneryLayer::saveAnimation() {
	+ savedX = currentX;
	+ savedY = currentY;
	+
	+ for (auto obj : objects) {
	+ obj->saveState();
	+ }
	+}
	+
	+void SceneryLayer::loadAnimation() {
	+ currentX = savedX;
	+ currentY = savedY;
	+
	+ for (auto obj : objects) {
	+ obj->loadState();
	+ }
	+}
	+
	+void SceneryLayer::show(SDL_Renderer& renderer) {
	+ //TODO: offset the objects by currentX/Y, etc.
	+
	+ //Show objects.
	+ for (auto obj : objects) {
	+ obj->show(renderer);
	+ }
	+}
	+
	+void SceneryLayer::saveToNode(TreeStorageNode* obj) {
	+ char s[64];
	+
	+ //Save the speed.
	+ sprintf(s, "%g", speedX);
	+ obj->attributes["speed"].push_back(s);
	+ sprintf(s, "%g", speedY);
	+ obj->attributes["speed"].push_back(s);
	+
	+ //Save the camera speed.
	+ sprintf(s, "%g", cameraX);
	+ obj->attributes["cameraSpeed"].push_back(s);
	+ sprintf(s, "%g", cameraY);
	+ obj->attributes["cameraSpeed"].push_back(s);
	+
	+ //Loop through the scenery blocks and save them.
	+ for (auto scenery : objects) {
	+ TreeStorageNode* obj1 = new TreeStorageNode;
	+ obj->subNodes.push_back(obj1);
	+
	+ // Check if it's custom scenery block
	+ if (scenery->themeBlock == &(scenery->internalThemeBlock)) {
	+ // load the dump of TreeStorageNode
	+ POASerializer serializer;
	+ std::istringstream i(scenery->customScenery_);
	+ serializer.readNode(i, obj1, true);
	+
	+ // custom scenery
	+ obj1->name = "object";
	+
	+ // clear the value in case that the serializer is buggy
	+ obj1->value.clear();
	+
	+ // clear the attributes in case that the user inputs some attributes
	+ obj1->attributes.clear();
	+ } else {
	+ // predefined scenery
	+ obj1->name = "scenery";
	+
	+ //Write away the name of the scenery.
	+ obj1->value.push_back(scenery->sceneryName_);
	+ }
	+
	+ //Get the box for the location of the scenery.
	+ SDL_Rect box = scenery->getBox(BoxType_Base);
	+ //Put the location and size in the storageNode.
	+ sprintf(s, "%d", box.x);
	+ obj1->value.push_back(s);
	+ sprintf(s, "%d", box.y);
	+ obj1->value.push_back(s);
	+ sprintf(s, "%d", box.w);
	+ obj1->value.push_back(s);
	+ sprintf(s, "%d", box.h);
	+ obj1->value.push_back(s);
	+
	+ //Get the repeat mode of the scenery if it's not default value
	+ if (scenery->repeatMode) {
	+ std::vector<std::string> &v = obj1->attributes["repeatMode"];
	+ for (int i = 0; i < 4; i++) {
	+ sprintf(s, "%d", ((scenery->repeatMode) >> (i * 8)) & 0xFF);
	+ v.push_back(s);
	+ }
	+ }
	+ }
	+}
	diff --git a/src/SceneryLayer.h b/src/SceneryLayer.h
	new file mode 100644
	index 0000000..5277ece
	--- /dev/null
	+++ b/src/SceneryLayer.h
	@@ -0,0 +1,85 @@
	+/*
	+ * Copyright (C) 2011-2013 Me and My Shadow
	+ *
	+ * This file is part of Me and My Shadow.
	+ *
	+ * Me and My Shadow is free software: you can redistribute it and/or modify
	+ * it under the terms of the GNU General Public License as published by
	+ * the Free Software Foundation, either version 3 of the License, or
	+ * (at your option) any later version.
	+ *
	+ * Me and My Shadow is distributed in the hope that it will be useful,
	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	+ * GNU General Public License for more details.
	+ *
	+ * You should have received a copy of the GNU General Public License
	+ * along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	+ */
	+
	+#ifndef SCENERYLAYER_H
	+#define SCENERYLAYER_H
	+
	+#include <SDL.h>
	+#include <array>
	+#include <vector>
	+#include <map>
	+#include <string>
	+
	+#include "Scenery.h"
	+
	+class ImageManager;
	+class TreeStorageNode;
	+class Game;
	+
	+//The class representing a scenery layer.
	+//NOTE: The name of the layer is not stored inside the class.
	+class SceneryLayer {
	+public:
	+ //Vector containing all the objects in the current game.
	+ std::vector<Scenery*> objects;
	+
	+ //Float containing the speed the layer moves (in pixel/frame).
	+ float speedX, speedY;
	+
	+ //Float containing the speed the layer will have when moving the camera.
	+ float cameraX, cameraY;
	+private:
	+ //Float with the current position.
	+ float currentX, currentY;
	+
	+ //Stored location for when loading a state.
	+ float savedX, savedY;
	+public:
	+ //Constructor.
	+ SceneryLayer();
	+
	+ SceneryLayer(const SceneryLayer& other) = delete;
	+
	+ //Destructor, which will delete objects in "objects" automatically.
	+ ~SceneryLayer();
	+
	+ //Add objects load from the node to the object list. NOTE: The name of the layer is not loaded here.
	+ void loadFromNode(Game parent, ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode obj);
	+
	+ //Save all objects to the node.
	+ void saveToNode(TreeStorageNode* obj);
	+
	+ //Method that will update the animation of all the objects.
	+ void updateAnimation();
	+
	+ //Method that will reset the animation of all the objects.
	+ //save: Boolean if the saved state should be deleted.
	+ void resetAnimation(bool save);
	+
	+ //Method that will save the animation of all the objects.
	+ void saveAnimation();
	+
	+ //Method that will load the animation of all the objects.
	+ void loadAnimation();
	+
	+ //Method used to draw the scenery.
	+ void show(SDL_Renderer& renderer);
	+};
	+
	+#endif

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 16, 8:19 PM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 63789
Default Alt Text: (267 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions