No OneTemporary
Actions

Authored By

Unknown

Size

285 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/docs/ScriptAPI.txt b/docs/ScriptAPI.txt
	index 70fc954..a13ef06 100644
	--- a/docs/ScriptAPI.txt
	+++ b/docs/ScriptAPI.txt
	@@ -1,291 +1,294 @@
	Me and My Shadow Script API Reference
	=====================================

	(draft)

	The script language is Lua 5.2 (later we may bump it to 5.3).

	Always check ScriptAPI.cpp for the newest API changed unmentioned in this document.

	How to edit script
	==================

	To edit the script of a block, right click the block and select "Scripting".

	To edit the script of the level, right click the block and select "Scripting".

	Currently the scenery block doesn't support scripting.

	Available event types of block:

	"playerWalkOn": Fired once when the player walks on. (For example this is used in fragile block.)
	"playerIsOn": Fired every frame when the player is on.
	"playerLeave": Fired once when the player leaves.
	"onCreate": Fired when object creates.
	"onEnterFrame": Fired every frame.
	"onToggle": Fired when the block receives "toggle" from a switch/button.
	"onSwitchOn": Fired when the block receives "switch on" from a switch/button.
	"onSwitchOff": Fired when the block receives "switch off" from a switch/button.

	NOTE: During the event execution the global variable "this" temporarily points to current block. (Ad-hoc workaround!)
	When the event execution ends the global variable "this" is reset to `nil`.

	Available event types of level:

	"onCreate": Fired when the level creates. This happens after all the blocks are created and their onCreate is called.
	"onSave": Fired when the game is saved.
	"onLoad": Fired when the game is loaded.
	"onReset": Fired when the game is reset.

	For the newest lists of event types, see init() function in Functions.cpp.

	NOTE: the following methods to specify scripts can be used:

	* Specify scripts for each events in the block script editing dialog.
	* Only specify "onCreate" script in the block script editing dialog,
	and use setEventHandler() function in script to specify scripts for other events dynamically.
	* Only specify "onCreate" script in the level script editing dialog,
	and use setEventHandler() function in script to specify scripts for other events for level/blocks dynamically.

	Script API reference
	====================

	The "block" library
	-------------------

	Static functions:

	* getBlockById(id)

	Returns the first block with specified id. If not found, returns `nil`.

	Example:

	local b=block.getBlockById("1")
	local x,y=b:getLocation()
	print(x,y)

	* getBlocksById(id)

	Returns the list of all blocks with specified id.

	Example:

	local l=block.getBlocksById("1")
	for i,b in ipairs(l) do
	local x,y=b:getLocation()
	print(x,y)
	end

	Member functions:

	* moveTo(x,y)

	Move the block to the new position, update the velocity of block according to the position changed.

	Example:

	local b=block.getBlockById("1")
	local x,y=b:getLocation()
	b:moveTo(x+1,y)

	* getLocation()

	Returns the position of the block.

	Example: see the example for moveTo().

	* setLocation(x,y)

	Move the block to the new position without updating the velocity of block.

	Example: omitted since it's almost the same as moveTo().

	* growTo(w,h)

	Resize the block, update the velocity of block according to the size changed.

	NOTE: I don't think the velocity need to be updated when resizing block, so don't use this function.

	Example: omitted since it's almost the same as setSize().

	* getSize()

	Returns the size of the block.

	Example:

	local b=block.getBlockById("1")
	local w,h=b:getSize()
	print(w,h)

	* setSize(w,h)

	Resize the block without updating the velocity of block.

	Example:

	local b=block.getBlockById("1")
	local w,h=b:getSize()
	b:setSize(w+1,h)

	* getType()

	Returns the type of the block (which is a string).

	Example:

	local b=block.getBlockById("1")
	local s=b:getType()
	print(s)

	* changeThemeState(new_state)

	Change the state of the block to new_state (which is a string).

	Example:

	local b=block.getBlockById("1")
	b:changeThemeState("activated")

	-* setEnabled(b)
	+* setVisible(b)

	-Enable or disable the block.
	+Set the visibility the block.

	-NOTE: The default value is `true`. If set to `false` the block is hidden completely.
	+NOTE: The default value is `true`. If set to `false` the block is hidden completely,
	+the animation is stopped, can't receive any event, can't execute any scripts, can't be used as a portal destination,
	+doesn't participate in collision check and game logic, etc...

	-NOTE: This is newly added feature.
	-If you find any bugs (e.g. if a disabled block still affects the game logic) please report them to GitHub issue tracker.
	+NOTE: This is a newly added feature.
	+If you find any bugs (e.g. if an invisible block still affects the game logic)
	+please report the bugs to GitHub issue tracker.

	Example:

	local b=block.getBlockById("1")
	-if b:isEnabled() then
	- b:setEnabled(false)
	+if b:isVisible() then
	+ b:setVisible(false)
	else
	- b:setEnabled(true)
	+ b:setVisible(true)
	end

	-* isEnabled()
	+* isVisible()

	-Returns whether the block is enabled.
	+Returns whether the block is visible.

	-Example: see the example for setEnabled().
	+Example: see the example for setVisible().

	* getEventHandler(event_type)

	Returns the event handler of event_type (which is a string).

	Example:

	local b=block.getBlockById("1")
	local f=b:getEventHandler("onSwitchOn")
	b:setEventHandler("onSwitchOff",f)

	* setEventHandler(event_type,handler)

	Set the handler of event_type (which is a string). The handler should be a function or `nil`.
	Returns the previous event handler.

	Example: see the example for getEventHandler().

	The "playershadow" library
	--------------------------

	Global constants:

	* player

	The player object.

	* shadow

	The shadow object.

	Member functions:

	* getLocation()

	Returns the location of player/shadow.

	Example:

	print(player:getLocation())
	print(shadow:getLocation())

	* setLocation(x,y)

	Set the location of player/shadow.

	Example:

	local x,y=player:getLocation()
	player:setLocation(x+1,y)

	* jump([strength])

	Let the player/shadow jump if it's allowed.
	strength: Jump strength. Default is 13.

	Example:

	player:jump(20)

	* isShadow()

	Returns whether the current object is shadow.

	Example:

	print(player:isShadow())
	print(shadow:isShadow())

	* getCurrentStand()

	Returns the block on which the player/shadow is standing on. Can be `nil`.

	Example:

	local b=player:getCurrentStand()
	if b then
	print(b:getType())
	else
	print(nil)
	end

	The "level" library
	-------------------

	Static functions:

	* getSize() -- get the level size

	* getWidth() -- get the level width

	* getHeight() -- get the level height

	* getName() -- get the level name

	* getEventHandler(event_type) -- get the event handler

	* setEventHandler(event_type,handler) -- set the event handler, return the old handler

	* win() -- win the game

	* getTime() -- get the game time (in frames)

	* getRecordings() -- get the game recordings

	The "camera" library
	--------------------

	Static functions:

	* setMode(mode) -- set the camera mode, which is "player" or "shadow"

	* lookAt(x,y) -- set the camera mode to "custom" and set the new center of camera

	The "audio" library
	-------------------

	Documents to be written...
	diff --git a/src/Block.cpp b/src/Block.cpp
	index 026b354..a25dc4c 100644
	--- a/src/Block.cpp
	+++ b/src/Block.cpp
	@@ -1,1155 +1,1182 @@
	/*
	* 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 "Functions.h"
	#include "LevelEditor.h"
	#include <iostream>
	#include <stdlib.h>
	#include <stdio.h>
	#include <assert.h>
	using namespace std;

	Block::Block(Game* parent,int x,int y,int w,int h,int type):
	GameObject(parent),
	animation(0),
	animationSave(0),
	flags(0),
	flagsSave(0),
	temp(0),
	tempSave(0),
	dx(0),
	dxSave(0),
	dy(0),
	dySave(0),
	loop(true),
	speed(0),
	speedSave(0),
	editorSpeed(0),
	editorFlags(0),
	- enabled(true),
	- enabledSave(true)
	+ visible(true),
	+ visibleSave(true)
	{
	//Make sure the type is set, if not init should be called somewhere else with this information.
	if(type>=0 && type<TYPE_MAX)
	init(x,y,w,h,type);
	}

	Block::~Block(){}

	void Block::init(int x,int y,int w,int h,int type){
	//First set the location and size of the box.
	//The default size is 50x50.
	box.x=boxBase.x=x;
	box.y=boxBase.y=y;
	box.w=boxBase.w=w;
	box.h=boxBase.h=h;

	//Set the save values.
	boxSave.x=x;
	boxSave.y=y;
	boxSave.w=w;
	boxSave.h=h;

	//Set the type.
	this->type=type;

	//Some types need type specific code.
	if(type==TYPE_START_PLAYER){
	//This is the player start so set the player here.
	//We center the player, the player is 23px wide.
	parent->player.setLocation(box.x+(box.w-23)/2,box.y);
	parent->player.fx=box.x+(box.w-23)/2;
	parent->player.fy=box.y;
	}else if(type==TYPE_START_SHADOW){
	//This is the shadow start so set the shadow here.
	//We center the shadow, the shadow is 23px wide.
	parent->shadow.setLocation(box.x+(box.w-23)/2,box.y);
	parent->shadow.fx=box.x+(box.w-23)/2;
	parent->shadow.fy=box.y;
	}

	objCurrentStand=NULL;
	inAir=inAirSave=true;
	xVel=yVel=xVelBase=yVelBase=0;
	xVelSave=yVelSave=xVelBaseSave=yVelBaseSave=0;

	//And load the appearance.
	objThemes.getBlock(type)->createInstance(&appearance);
	}

	void Block::show(SDL_Renderer& renderer){
	- //Make sure we are enabled.
	- if(!enabled)
	+ //Make sure we are visible.
	+ if (!visible && (stateID != STATE_LEVEL_EDITOR \|\| static_cast<LevelEditor*>(parent)->isPlayMode()))
	return;

	//Check if the block is visible.
	if(checkCollision(camera,box)==true \|\| (stateID==STATE_LEVEL_EDITOR && checkCollision(camera,boxBase)==true)){
	//Some type of block needs additional state check.
	switch(type){
	case TYPE_CHECKPOINT:
	//Check if the checkpoint is last used.
	if(parent!=NULL && parent->objLastCheckPoint==this){
	if(!temp) appearance.changeState("activated");
	temp=1;
	}else{
	if(temp) appearance.changeState("default");
	temp=0;
	}
	break;
	}

	//Always draw the base.
	appearance.drawState("base", renderer, boxBase.x - camera.x, boxBase.y - camera.y, boxBase.w, boxBase.h);

	//What we need to draw depends on the type of block.
	switch (type) {
	default:
	//Draw normal.
	appearance.draw(renderer, box.x - camera.x, box.y - camera.y, box.w, box.h);
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	//Draw conveyor belt.
	if (animation) {
	// FIXME: ad-hoc code. Should add a new animation type in theme system.
	const int a = animation / 10;
	const SDL_Rect r = { box.x - camera.x, box.y - camera.y, box.w, box.h };
	appearance.draw(renderer, box.x - camera.x - 50 + a, box.y - camera.y, box.w + 50 - a, box.h, &r);
	} else {
	appearance.draw(renderer, box.x - camera.x, box.y - camera.y, box.w, box.h);
	}
	break;
	}

	//Some types need to draw something on top of the base/default.
	switch(type){
	case TYPE_BUTTON:
	if(flags&4){
	if(animation<5) animation++;
	}else{
	if(animation>0) animation--;
	}
	appearance.drawState("button",renderer,box.x-camera.x,box.y-camera.y-5+animation);
	break;
	}

	- //Draw a stupid icon for scrpited blocks in edit mode.
	- if(stateID==STATE_LEVEL_EDITOR && !scripts.empty()){
	- auto bmGUI = static_cast<LevelEditor*>(parent)->getGuiTexture();
	- if(!bmGUI) {
	- return;
	- }
	- const SDL_Rect r={0,32,16,16};
	- const SDL_Rect dstRect={box.x - camera.x + 2,box.y - camera.y + 2,16,16};
	- SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	+ //Draw some stupid icons during edit mode.
	+ if (stateID == STATE_LEVEL_EDITOR) {
	+ auto bmGUI = static_cast<LevelEditor*>(parent)->getGuiTexture();
	+ if (!bmGUI) {
	+ return;
	+ }
	+
	+ int x = box.x - camera.x + 2;
	+
	+ //Scripted blocks
	+ if (!scripts.empty()){
	+ const SDL_Rect r = { 0, 32, 16, 16 };
	+ const SDL_Rect dstRect = { x, box.y - camera.y + 2, 16, 16 };
	+ SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	+ x += 16;
	+ }
	+
	+ //Invisible blocks
	+ if (!visible) {
	+ const SDL_Rect r = { 16, 48, 16, 16 };
	+ const SDL_Rect dstRect = { x, box.y - camera.y + 2, 16, 16 };
	+ SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	+ x += 16;
	+ }
	}
	}
	}

	SDL_Rect Block::getBox(int boxType){
	SDL_Rect r={0,0,0,0};
	switch(boxType){
	case BoxType_Base:
	return boxBase;
	case BoxType_Previous:
	r.x=box.x-dx;
	r.y=box.y-dy;
	r.w=box.w;
	r.h=box.h;
	return r;
	case BoxType_Delta:
	r.x=dx;
	r.y=dy;
	return r;
	case BoxType_Velocity:
	r.x=xVel;
	r.y=yVel;
	//NOTE: In case of the pushable block we sometimes need to substract one from the vertical velocity.
	//The yVel is set to one when it's resting, but should be handled as zero in collision.
	if(type==TYPE_PUSHABLE && !inAir)
	r.y=0;
	return r;
	case BoxType_Current:
	return box;
	}
	return r;
	}

	void Block::moveTo(int x,int y){
	//The block has moved so calculate the delta.
	//NOTE: Every delta is summed since they all happened within one frame and for collision/movement we need the resulting delta.
	int delta=(x-box.x);
	dx+=delta;
	xVel+=delta;
	delta=(y-box.y);
	dy+=delta;
	yVel+=delta;

	//And set the new location.
	box.x=x;
	box.y=y;
	}

	void Block::growTo(int w,int h){
	//The block has changed size
	//NOTE: Every delta is summed since they all happened within one frame and for collision/movement we need the resulting delta.
	int delta=(w-box.w);
	dx+=delta;
	xVel+=delta;
	delta=(h-box.h);
	dy+=delta;
	yVel+=delta;

	//And set the new location.
	box.w=w;
	box.h=h;
	}

	void Block::saveState(){
	animationSave=animation;
	flagsSave=flags;
	tempSave=temp;
	dxSave=dx;
	dySave=dy;
	boxSave.x=box.x-boxBase.x;
	boxSave.y=box.y-boxBase.y;
	boxSave.w=box.w-boxBase.w;
	boxSave.h=box.h-boxBase.h;
	xVelSave=xVel;
	yVelSave=yVel;
	- enabledSave=enabled;
	+ visibleSave=visible;
	appearance.saveAnimation();

	//In case of a certain blocks we need to save some more.
	switch(type){
	case TYPE_PUSHABLE:
	xVelBaseSave=xVelBase;
	yVelBaseSave=yVelBase;
	inAirSave=inAir;
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	speedSave=speed;
	break;
	}
	}

	void Block::loadState(){
	//Restore the flags and animation var.
	animation=animationSave;
	flags=flagsSave;
	temp=tempSave;
	dx=dxSave;
	dy=dySave;
	//Restore the location.
	box.x=boxBase.x+boxSave.x;
	box.y=boxBase.y+boxSave.y;
	box.w=boxBase.w+boxSave.w;
	box.h=boxBase.h+boxSave.h;
	//And the velocity.
	xVel=xVelSave;
	yVel=yVelSave;
	//The enabled status.
	- enabled=enabledSave;
	+ visible=visibleSave;

	//Handle block type specific variables.
	switch(type){
	case TYPE_PUSHABLE:
	xVelBase=xVelBaseSave;
	yVelBase=yVelBaseSave;
	inAir=inAirSave;
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	speed=speedSave;
	break;
	}

	//And load the animation.
	appearance.loadAnimation();
	}

	void Block::reset(bool save){
	//We need to reset so we clear the animation and saves.
	if(save){
	animation=animationSave=0;
	boxSave.x=boxSave.y=boxSave.w=boxSave.h=0;
	flags=flagsSave=editorFlags;
	temp=tempSave=0;
	dx=dxSave=0;
	dy=dySave=0;
	}else{
	animation=0;
	flags=editorFlags;
	temp=0;
	dx=0;
	dy=0;
	}

	//Reset the block to its original location.
	box.x=boxBase.x;
	box.y=boxBase.y;
	box.w=boxBase.w;
	box.h=boxBase.h;

	//Reset any velocity.
	xVel=yVel=xVelBase=yVelBase=0;
	if(save)
	xVelSave=yVelSave=xVelBaseSave=yVelBaseSave=0;

	- //Reset the enabled status.
	- enabled=true;
	+ //TODO: Visibility changes by script shouldn't affect the visibility in edit mode. Same goes for other properties.
	+ /*//Reset the visible status.
	+ visible=true;
	if(save)
	- enabledSave=true;
	+ visibleSave=true;*/

	//Also reset the appearance.
	appearance.resetAnimation(save);
	appearance.changeState("default");
	//NOTE: We load the animation right after changing it to prevent a transition.
	if(save)
	appearance.loadAnimation();

	//Some types of block requires type specific code.
	switch(type){
	case TYPE_FRAGILE:
	{
	const char* s=(flags==0)?"default":((flags==1)?"fragile1":((flags==2)?"fragile2":"fragile3"));
	appearance.changeState(s);
	}
	break;
	case TYPE_PUSHABLE:
	inAir=false;
	if(save)
	inAirSave=false;
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	if(save)
	speed=speedSave=editorSpeed;
	else
	speed=editorSpeed;
	break;
	}
	}


	void Block::playAnimation(){
	switch(type){
	case TYPE_SWAP:
	appearance.changeState("activated");
	break;
	case TYPE_SWITCH:
	temp^=1;
	appearance.changeState(temp?"activated":"default");
	break;
	}
	}

	void Block::onEvent(int eventType){
	- //Make sure we are enabled, otherwise no events should be handled.
	- if(!enabled)
	+ //Make sure we are visible, otherwise no events should be handled.
	+ if(!visible)
	return;

	//Iterator used to check if the map contains certain entries.
	map<int,int>::iterator it;

	//Check if there's a script for the event.
	it=compiledScripts.find(eventType);
	if(it!=compiledScripts.end()){
	//There is a script so execute it and check return value.
	int ret=getScriptExecutor()->executeScript(it->second,this);

	//Return value 1 means do default event process.
	//Other values are coming soon...
	if(ret!=1) return;
	}

	//Event handling.
	switch(eventType){
	case GameObjectEvent_PlayerWalkOn:
	switch(type){
	case TYPE_FRAGILE:
	flags++;
	{
	const char* s=(flags==0)?"default":((flags==1)?"fragile1":((flags==2)?"fragile2":"fragile3"));
	appearance.changeState(s);
	}
	break;
	}
	break;
	case GameObjectEvent_PlayerIsOn:
	switch(type){
	case TYPE_BUTTON:
	temp=1;
	break;
	}
	break;
	case GameObjectEvent_OnToggle:
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	flags^=1;
	break;
	case TYPE_PORTAL:
	appearance.changeState("activated");
	break;
	case TYPE_COLLECTABLE:
	appearance.changeState("inactive");
	flags=1;
	break;
	}
	break;
	case GameObjectEvent_OnSwitchOn:
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	flags&=~1;
	break;
	case TYPE_EXIT:
	appearance.changeState("default");
	break;
	}
	break;
	case GameObjectEvent_OnSwitchOff:
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	flags\|=1;
	break;
	case TYPE_EXIT:
	appearance.changeState("closed");
	break;
	}
	break;
	}
	}

	int Block::queryProperties(int propertyType,Player* obj){
	switch(propertyType){
	case GameObjectProperty_PlayerCanWalkOn:
	switch(type){
	case TYPE_BLOCK:
	case TYPE_MOVING_BLOCK:
	case TYPE_CONVEYOR_BELT:
	case TYPE_BUTTON:
	case TYPE_PUSHABLE:
	return 1;
	case TYPE_SHADOW_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_SHADOW_CONVEYOR_BELT:
	if(obj!=NULL && obj->isShadow()) return 1;
	break;
	case TYPE_FRAGILE:
	if(flags<3) return 1;
	break;
	}
	break;
	case GameObjectProperty_IsSpikes:
	switch(type){
	case TYPE_SPIKES:
	case TYPE_MOVING_SPIKES:
	return 1;
	}
	break;
	case GameObjectProperty_Flags:
	return flags;
	break;
	default:
	break;
	}
	return 0;
	}

	void Block::getEditorData(std::vector<std::pair<std::string,std::string> >& obj){
	//Every block has an id.
	obj.push_back(pair<string,string>("id",id));

	+ //And visibility.
	+ obj.push_back(pair<string, string>("visible", visible ? "1" : "0"));
	+
	//Block specific properties.
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	char s[64],s0[64];
	sprintf(s,"%d",(int)movingPos.size());
	obj.push_back(pair<string,string>("MovingPosCount",s));
	obj.push_back(pair<string,string>("activated",(editorFlags&0x1)?"0":"1"));
	obj.push_back(pair<string,string>("loop",loop?"1":"0"));
	for(unsigned int i=0;i<movingPos.size();i++){
	sprintf(s0+1,"%u",i);
	sprintf(s,"%d",movingPos[i].x);
	s0[0]='x';
	obj.push_back(pair<string,string>(s0,s));
	sprintf(s,"%d",movingPos[i].y);
	s0[0]='y';
	obj.push_back(pair<string,string>(s0,s));
	sprintf(s,"%d",movingPos[i].w);
	s0[0]='t';
	obj.push_back(pair<string,string>(s0,s));
	}
	}
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	char s[64];
	obj.push_back(pair<string,string>("activated",(editorFlags&0x1)?"0":"1"));
	sprintf(s,"%d",editorSpeed);
	obj.push_back(pair<string,string>("speed10",s));
	}
	break;
	case TYPE_PORTAL:
	obj.push_back(pair<string,string>("automatic",(editorFlags&0x1)?"1":"0"));
	obj.push_back(pair<string,string>("destination",destination));
	break;
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	string s;
	switch(editorFlags&0x3){
	case 1:
	s="on";
	break;
	case 2:
	s="off";
	break;
	default:
	s="toggle";
	break;
	}
	obj.push_back(pair<string,string>("behaviour",s));
	}
	break;
	case TYPE_NOTIFICATION_BLOCK:
	{
	string value=message;
	//Change \n with the characters '\n'.
	while(value.find('\n',0)!=string::npos){
	size_t pos=value.find('\n',0);
	value=value.replace(pos,1,"\\n");
	}

	obj.push_back(pair<string,string>("message",value));
	}
	break;
	case TYPE_FRAGILE:
	{
	char s[64];
	sprintf(s,"%d",editorFlags);
	obj.push_back(pair<string,string>("state",s));
	}
	break;
	}
	}

	void Block::setEditorData(std::map<std::string,std::string>& obj){
	//Iterator used to check if the map contains certain entries.
	map<string,string>::iterator it;

	//Check if the data contains the id block.
	it=obj.find("id");
	if(it!=obj.end()){
	//Set the id of the block.
	id=obj["id"];
	}

	+ //Check if the data contains the visibility
	+ it = obj.find("visible");
	+ if (it != obj.end()) {
	+ //Set the visibility.
	+ const string& s = it->second;
	+ visible = (s == "true" \|\| atoi(s.c_str()));
	+ }
	+
	//Block specific properties.
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//Make sure that the editor data contains MovingPosCount.
	it=obj.find("MovingPosCount");
	if(it!=obj.end()){
	char s0[64];
	int m=atoi(obj["MovingPosCount"].c_str());
	movingPos.clear();
	for(int i=0;i<m;i++){
	SDL_Rect r={0,0,0,0};
	sprintf(s0+1,"%d",i);
	s0[0]='x';
	r.x=atoi(obj[s0].c_str());
	s0[0]='y';
	r.y=atoi(obj[s0].c_str());
	s0[0]='t';
	r.w=atoi(obj[s0].c_str());
	movingPos.push_back(r);
	}
	}

	//Check if the activated or disabled key is in the data.
	//NOTE: 'disabled' is obsolete in V0.5.
	it=obj.find("activated");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(!(s=="true" \|\| atoi(s.c_str()))) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}else{
	it=obj.find("disabled");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}
	}

	//Check if the loop key is in the data.
	it=obj.find("loop");
	if(it!=obj.end()){
	string s=obj["loop"];
	loop=false;
	if(s=="true" \|\| atoi(s.c_str()))
	loop=true;
	}

	}
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	//Check if there's a speed key in the editor data.
	//NOTE: 'speed' is obsolete in V0.5.
	it=obj.find("speed10");
	if(it!=obj.end()){
	editorSpeed=atoi(obj["speed10"].c_str());
	speed=speedSave=editorSpeed;
	}else{
	it = obj.find("speed");
	if (it != obj.end()){
	editorSpeed = atoi(obj["speed"].c_str()) * 10;
	speed = speedSave = editorSpeed;
	}
	}

	//Check if the activated or disabled key is in the data.
	//NOTE: 'disabled' is obsolete in V0.5.
	it=obj.find("activated");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(!(s=="true" \|\| atoi(s.c_str()))) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}else{
	it=obj.find("disabled");
	if(it!=obj.end()){
	string s=it->second;
	editorFlags=0;
	if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}
	}
	}
	break;
	case TYPE_PORTAL:
	{
	//Check if the automatic key is in the data.
	it=obj.find("automatic");
	if(it!=obj.end()){
	string s=obj["automatic"];
	editorFlags=0;
	if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	flags=flagsSave=editorFlags;
	}

	//Check if the destination key is in the data.
	it=obj.find("destination");
	if(it!=obj.end()){
	destination=obj["destination"];
	}
	}
	break;
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	//Check if the behaviour key is in the data.
	it=obj.find("behaviour");
	if(it!=obj.end()){
	string s=obj["behaviour"];
	editorFlags=0;
	if(s=="on" \|\| s==_("On")) editorFlags\|=1;
	else if(s=="off" \|\| s==_("Off")) editorFlags\|=2;
	flags=flagsSave=editorFlags;
	}
	}
	break;
	case TYPE_NOTIFICATION_BLOCK:
	{
	//Check if the message key is in the data.
	it=obj.find("message");
	if(it!=obj.end()){
	message=obj["message"];
	//Change the characters '\n' to a real \n
	while(message.find("\\n")!=string::npos){
	message=message.replace(message.find("\\n"),2,"\n");
	}
	}
	}
	break;
	case TYPE_FRAGILE:
	{
	//Check if the status is in the data.
	it=obj.find("state");
	if(it!=obj.end()){
	editorFlags=atoi(obj["state"].c_str());
	flags=editorFlags;
	{
	const char* s=(flags==0)?"default":((flags==1)?"fragile1":((flags==2)?"fragile2":"fragile3"));
	appearance.changeState(s);
	}
	}
	}
	}
	}

	std::string Block::getEditorProperty(std::string property){
	//First get the complete editor data.
	vector<pair<string,string> > objMap;
	vector<pair<string,string> >::iterator it;
	getEditorData(objMap);

	//Loop through the entries.
	for(it=objMap.begin();it!=objMap.end();++it){
	if(it->first==property)
	return it->second;
	}

	//Nothing found.
	return "";
	}

	void Block::setEditorProperty(std::string property,std::string value){
	//Create a map to hold the property.
	std::map<std::string,std::string> editorData;
	editorData[property]=value;

	//And call the setEditorData method.
	setEditorData(editorData);
	}

	bool Block::loadFromNode(ImageManager&, SDL_Renderer&, TreeStorageNode* objNode){
	//Make sure there are enough parameters.
	if(objNode->value.size()<3)
	return false;

	//Load the type and location.
	int type=Game::blockNameMap[objNode->value[0]];
	int x=atoi(objNode->value[1].c_str());
	int y=atoi(objNode->value[2].c_str());
	int w=50;
	int h=50;
	if(objNode->value.size()>3)
	w=atoi(objNode->value[3].c_str());
	if(objNode->value.size()>4)
	h=atoi(objNode->value[4].c_str());
	//Call the init method.
	init(x,y,w,h,type);

	//Loop through the attributes as editorProperties.
	map<string,string> obj;
	for(map<string,vector<string> >::iterator i=objNode->attributes.begin();i!=objNode->attributes.end();++i){
	if(i->second.size()>0) obj[i->first]=i->second[0];
	}
	setEditorData(obj);

	//Loop through the subNodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	//FIXME: Ugly variable naming.
	TreeStorageNode* obj=objNode->subNodes[i];
	if(obj==NULL) continue;

	//Check for a script block.
	if(obj->name=="script" && !obj->value.empty()){
	map<string,int>::iterator it=Game::gameObjectEventNameMap.find(obj->value[0]);
	if(it!=Game::gameObjectEventNameMap.end()){
	int eventType=it->second;
	const std::string& script=obj->attributes["script"][0];
	if(!script.empty()) scripts[eventType]=script;
	}
	}
	}

	return true;
	}

	void Block::prepareFrame(){
	//Reset the delta variables.
	dx=dy=0;
	//Also reset the velocity, these should be set in the move method.
	if(type!=TYPE_PUSHABLE)
	xVel=yVel=0;
	}

	/*//debug
	int block_test_count=-1;
	bool block_test_only=false;*/

	void Block::move(){
	- //Make sure we are enabled, if not return.
	- if(!enabled)
	+ //Make sure we are visible, if not return.
	+ if(!visible)
	return;

	//First update the animation of the appearance.
	appearance.updateAnimation();

	//Block specific move code.
	switch(type){
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	/*//debug
	if(block_test_only \|\| parent->time==416){
	cout<<"Time:"<<(parent->time)<<" Recorded:"<<block_test_count<<" Coord:"<<box.x<<","<<box.y<<endl;
	block_test_only=false;
	}*/

	//Make sure the block is enabled, if so increase the time.
	if(!(flags&0x1)) temp++;
	int t=temp;
	SDL_Rect r0={0,0,0,0},r1;
	dx=0;
	dy=0;

	//Loop through the moving positions.
	for(unsigned int i=0;i<movingPos.size();i++){
	r1.x=movingPos[i].x;
	r1.y=movingPos[i].y;
	r1.w=movingPos[i].w;
	if(t==0&&r1.w==0){
	r1.w=1;
	flags\|=0x1;
	}
	if(t>=0 && t<(int)r1.w){
	int newX=boxBase.x+(int)(float(r0.x)+(float(r1.x)-float(r0.x))*float(t)/float(r1.w));
	int newY=boxBase.y+(int)(float(r0.y)+(float(r1.y)-float(r0.y))*float(t)/float(r1.w));
	//Calculate the delta and velocity.
	xVel=dx=newX-box.x;
	yVel=dy=newY-box.y;
	//Set the new location of the moving block.
	box.x=newX;
	box.y=newY;
	return;
	}else if(t==(int)r1.w){
	//If the time is the time of the movingPosition then set it equal to the location.
	//We do this to prevent a slight edge between normal blocks and moving blocks.
	int newX=boxBase.x+r1.x;
	int newY=boxBase.y+r1.y;
	xVel=dx=newX-box.x;
	yVel=dy=newY-box.y;
	box.x=newX;
	box.y=newY;
	return;
	}
	t-=r1.w;
	r0.x=r1.x;
	r0.y=r1.y;
	}
	//Only reset the stuff when we're looping.
	if(loop){
	//Set the time back to zero.
	temp=0;
	//Calculate the delta movement.
	if(!movingPos.empty() && movingPos.back().x==0 && movingPos.back().y==0){
	dx=boxBase.x-box.x;
	dy=boxBase.y-box.y;
	}
	//Set the movingblock back to it's initial location.
	box.x=boxBase.x;
	box.y=boxBase.y;
	}
	}
	break;
	case TYPE_BUTTON:
	{
	//Check the third bit of flags to see if temp changed.
	int new_flags=temp?4:0;
	if((flags^new_flags)&4){
	//The button has been pressed or unpressed so change the third bit on flags.
	flags=(flags&~4)\|new_flags;

	if(parent && (new_flags \|\| (flags&3)==0)){
	//Make sure that id isn't empty.
	if(!id.empty()){
	parent->broadcastObjectEvent(0x10000\|(flags&3),-1,id.c_str());
	}else{
	cerr<<"WARNING: invalid button id!"<<endl;
	}
	}
	}
	temp=0;
	}
	break;
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	//Increase the conveyor belt animation.
	if((flags&1)==0){
	//Since now 1 speed = 0.1 pixel/s we need some more sophisticated calculation.
	int a = animation + speed, d = 0;
	if (a < 0) {
	//Add a delta value to make it positive
	d = (((-a) / 500) + 1) * 500;
	}

	//Set the velocity NOTE This isn't the actual velocity of the block, but the speed of the player/shadow standing on it.
	xVel = (a + d) / 10 - (animation + d) / 10;

	//Update animation value
	animation = (a + d) % 500;
	assert(animation >= 0);
	} else {
	//Clear the velocity NOTE This isn't the actual velocity of the block, but the speed of the player/shadow standing on it.
	xVel = 0;
	}
	break;
	case TYPE_PUSHABLE:
	{
	//Update the vertical velocity, horizontal is set by the player.
	if(inAir==true){
	yVel+=1;

	//Cap fall speed to 13.
	if(yVel>13)
	yVel=13;
	}
	if(objCurrentStand!=NULL){
	//Now get the velocity and delta of the object the player is standing on.
	SDL_Rect v=objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=objCurrentStand->getBox(BoxType_Delta);

	switch(objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	xVelBase+=v.x;
	}
	break;
	//In other cases, such as, player on shadow, player on crate... the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	xVelBase+=delta.x;
	}
	break;
	}
	//NOTE: Only copy the velocity of the block when moving down.
	//Upwards is automatically resolved before the player is moved.
	if(v.y>0)
	yVelBase=v.y;
	else
	yVelBase=0;
	}

	//Set the object the player is currently standing to NULL.
	objCurrentStand=NULL;

	//Store the location of the player.
	int lastX=box.x;
	int lastY=box.y;

	//An array that will hold all the GameObjects that are involved in the collision/movement.
	vector<Block*> objects;
	//All the blocks have moved so if there's collision with the player, the block moved into him.
	for(unsigned int o=0;o<parent->levelObjects.size();o++){
	- //Make sure to only check enabled blocks.
	- if(!parent->levelObjects[o]->enabled)
	+ //Make sure to only check visible blocks.
	+ if(!parent->levelObjects[o]->visible)
	continue;
	//Make sure we aren't the block.
	if(parent->levelObjects[o]==this)
	continue;
	//Make sure the object is solid for the player.
	if(!parent->levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,&parent->player))
	continue;

	//Check for collision.
	if(checkCollision(box,parent->levelObjects[o]->getBox()))
	objects.push_back(parent->levelObjects[o]);
	}
	//There was collision so try to resolve it.
	if(!objects.empty()){
	//FIXME: When multiple moving blocks are overlapping the player can be "bounced" off depending on the block order.
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	SDL_Rect delta=objects[o]->getBox(BoxType_Delta);

	//Check on which side of the box the player is.
	if(delta.x!=0){
	if(delta.x>0){
	if((r.x+r.w)-box.x<=delta.x)
	box.x=r.x+r.w;
	}else{
	if((box.x+box.w)-r.x<=-delta.x)
	box.x=r.x-box.w;
	}
	}
	if(delta.y!=0){
	if(delta.y>0){
	if((r.y+r.h)-box.y<=delta.y)
	box.y=r.y+r.h;
	}else{
	if((box.y+box.h)-r.y<=-delta.y)
	box.y=r.y-box.h;
	}
	}
	}
	}

	//Reuse the objects array, this time for blocks the block moves into.
	objects.clear();
	//Determine the collision frame.
	SDL_Rect frame={box.x,box.y,box.w,box.h};
	//Keep the horizontal movement of the block in mind.
	if(xVel+xVelBase>=0){
	frame.w+=(xVel+xVelBase);
	}else{
	frame.x+=(xVel+xVelBase);
	frame.w-=(xVel+xVelBase);
	}
	//And the vertical movement.
	if(yVel+yVelBase>=0){
	frame.h+=(yVel+yVelBase);
	}else{
	frame.y+=(yVel+yVelBase);
	frame.h-=(yVel+yVelBase);
	}
	//Loop through the game objects.
	for(unsigned int o=0; o<parent->levelObjects.size(); o++){
	- //Make sure the object is enabled.
	- if(!parent->levelObjects[o]->enabled)
	+ //Make sure the object is visible.
	+ if(!parent->levelObjects[o]->visible)
	continue;
	//Make sure we aren't the block.
	if(parent->levelObjects[o]==this)
	continue;
	//Check if the player can collide with this game object.
	if(!parent->levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,&parent->player))
	continue;

	//Check if the block is inside the frame.
	if(checkCollision(frame,parent->levelObjects[o]->getBox()))
	objects.push_back(parent->levelObjects[o]);
	}
	//Horizontal pass.
	if(xVel+xVelBase!=0){
	box.x+=xVel+xVelBase;
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	if(xVel+xVelBase>0){
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if((box.x+box.w)-r.x<=xVel+xVelBase)
	box.x=r.x-box.w;
	}else{
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if(box.x-(r.x+r.w)<=-(xVel+xVelBase))
	box.x=r.x+r.w;
	}
	}
	}
	//Some variables that are used in vertical movement.
	Block* lastStand=NULL;
	inAir=true;

	//Vertical pass.
	if(yVel+yVelBase!=0){
	box.y+=yVel+yVelBase;
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	//Now check how we entered the block (vertically or horizontally).
	if(yVel+yVelBase>0){
	//We came from the top so the bottom edge of the player must be less or equal than yVel+yVelBase.
	if((box.y+box.h)-r.y<=yVel+yVelBase){
	//NOTE: lastStand is handled later since the player can stand on only one block at the time.

	//Check if there's already a lastStand.
	if(lastStand){
	//There is one, so check 'how much' the player is on the blocks.
	SDL_Rect r=objects[o]->getBox();
	int w=0;
	if(box.x+box.w>r.x+r.w)
	w=(r.x+r.w)-box.x;
	else
	w=(box.x+box.w)-r.x;

	//Do the same for the other box.
	r=lastStand->getBox();
	int w2=0;
	if(box.x+box.w>r.x+r.w)
	w2=(r.x+r.w)-box.x;
	else
	w2=(box.x+box.w)-r.x;

	//NOTE: It doesn't matter which block the player is on if they are both stationary.
	SDL_Rect v=objects[o]->getBox(BoxType_Velocity);
	SDL_Rect v2=lastStand->getBox(BoxType_Velocity);

	if(v.y==v2.y){
	if(w>w2)
	lastStand=objects[o];
	}else if(v.y<v2.y){
	lastStand=objects[o];
	}
	}else{
	lastStand=objects[o];
	}
	}
	}else{
	//We came from the bottom so the upper edge of the player must be less or equal than yVel+yVelBase.
	if(box.y-(r.y+r.h)<=-(yVel+yVelBase)){
	box.y=r.y+r.h;
	yVel=0;
	}
	}
	}
	}
	if(lastStand){
	inAir=false;
	yVel=1;
	SDL_Rect r=lastStand->getBox();
	box.y=r.y-box.h;
	}

	//Block will currently be standing on whatever it was last standing on.
	objCurrentStand=lastStand;

	dx=box.x-lastX;
	dy=box.y-lastY;
	xVel=0;
	xVelBase=0;
	}
	break;
	}
	}
	diff --git a/src/Block.h b/src/Block.h
	index c8e12ee..c8b6d9a 100644
	--- a/src/Block.h
	+++ b/src/Block.h
	@@ -1,199 +1,199 @@
	/*
	* 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 BLOCK_H
	#define BLOCK_H

	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "ScriptUserData.h"
	#include "ScriptExecutor.h"
	#include <vector>
	#include <SDL.h>

	class Block: public GameObject, public ScriptUserClass<'B','L','O','K',Block>{
	private:
	//Integer that a block can use for all animation or visual related things.
	int animation;
	//The save for animation when the state of the block is saved.
	int animationSave;

	//flags:
	//moving object 0x1=disabled
	//button bit0-1=behavior 0x4=pressed
	//switch bit0-1=behavior
	int flags;
	//The save for flags when the state of the block is saved.
	int flagsSave;

	//Temp variables used to keep track of time/state.
	int temp;
	//The save for temp when the state of the block is saved.
	int tempSave;

	//Save variables for the current location and size of the block.
	SDL_Rect boxSave;

	//Delta variables, if the block moves these must be set to the delta movement.
	int dx,dy;
	int dxSave,dySave;

	//Vector containing the poisitions of the moving block.
	std::vector<SDL_Rect> movingPos;
	//Boolean if the moving block loops his movement.
	//Default value is true.
	bool loop;

	//Integer containing the speed for conveyorbelts.
	//NOTE: in V0.5 the speed 1 means 0.1 pixel/frame = 0.08 block/s
	//which is 1/10 of the old speed, and named "speed10" in the level file to keep compatibility
	int speed;
	int speedSave;
	int editorSpeed;

	//Following is for the pushable block.
	Block* objCurrentStand;

	//Flags of the block for the editor.
	//moving object 0x1=disabled
	//portal 0x1=automatic
	//fragile =state
	int editorFlags;
	public:
	//The Appearance of the block.
	ThemeBlockInstance appearance;

	//Velocity variables for the block, if the block moves these must be set for collision/movement of the player.
	int xVel,yVel;
	//Save variables for the velocity.
	int xVelSave,yVelSave;

	//Follwing is for pushable block.
	bool inAir;
	int xVelBase,yVelBase;
	//The save variables for each of the above.
	bool inAirSave;
	int xVelBaseSave,yVelBaseSave;

	//The id of the block.
	std::string id;
	//String containing the id of the destination for portals.
	std::string destination;
	//String containing the message of the notification block.
	std::string message;

	//The map that holds a script for every event.
	map<int,std::string> scripts;

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

	- //Boolean if the block is enabled.
	- //If it's not enabled it will not collide with anything or execute any scripts.
	- bool enabled,enabledSave;
	+ //Boolean if the block is visible. Default value is true.
	+ //If it's not visible it will not collide with anything or execute any scripts.
	+ bool visible,visibleSave;

	//Constructor.
	//objParent: Pointer to the Game object.
	//x: The x location of the block.
	//y: The y location of the block.
	//w: The width of the block.
	//h: The height of the block.
	//type: The block type.
	Block(Game* objParent,int x=0,int y=0,int w=50,int h=50,int type=-1);
	//Desturctor.
	~Block();

	//Method for initializing the block.
	//x: The x location of the block.
	//y: The y location of the block.
	//w: The width of the block.
	//h: The height of the block.
	//type: The block type.
	void init(int x,int y,int w,int h,int type);

	//Method used to draw the block.
	void show(SDL_Renderer &renderer) override;

	//Returns the box of a given type.
	//boxType: The type of box that should be returned.
	//See GameObjects.h for the types.
	//Returns: The box.
	virtual SDL_Rect getBox(int boxType=BoxType_Current);

	//Method for setting the block to a given location as if it moved there.
	//x: The new x location.
	//y: The new y location.
	void moveTo(int x,int y);

	//Method for setting a new size as if the block grew,
	//w: The new width of the block.
	//h: The new height of the block.
	void growTo(int w,int h);

	//Save the state of the block so we can load it later on.
	virtual void saveState();
	//Load the saved state of the block so.
	virtual void loadState();
	//Reset the block.
	//save: Boolean if the saved state should also be deleted.
	virtual void reset(bool save);

	//Play an animation.
	virtual void playAnimation();

	//Method called when there's an event.
	//eventType: The type of event.
	//See GameObjects.h for the eventtypes.
	virtual void onEvent(int eventType);

	//Method used to retrieve a property from the block.
	//propertyType: The type of property requested.
	//See GameObjects.h for the properties.
	//obj: Pointer to the player.
	//Returns: Integer containing the value of the property.
	virtual int queryProperties(int propertyType,Player* obj);

	//Get the editor data of the block.
	//obj: The vector that will be filled with the editorData.
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editor data of the block.
	//obj: The new editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj);

	//Get a single property of the block.
	//property: The property to return.
	//Returns: The value for the requested property.
	virtual std::string getEditorProperty(std::string property);
	//Set a single property of the block.
	//property: The property to set.
	//value: The new value for the property.
	virtual void setEditorProperty(std::string property,std::string value);

	//Method for loading the Block from a node.
	//objNode: Pointer to the storage node to load from.
	//Returns: True if it succeeds without errors.
	virtual bool loadFromNode(ImageManager&, SDL_Renderer&, TreeStorageNode* objNode) override;

	//Method used for resetting the dx/dy and xVel/yVel variables.
	virtual void prepareFrame();
	//Method used for updating moving blocks or elements of blocks.
	virtual void move();
	};

	#endif
	diff --git a/src/LevelEditor.cpp b/src/LevelEditor.cpp
	index 6dfc5af..1c64d89 100644
	--- a/src/LevelEditor.cpp
	+++ b/src/LevelEditor.cpp
	@@ -1,4456 +1,4470 @@
	/*
	* 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
	};

	/////////////////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.
	SDL_Color fg={0,0,0};
	SurfacePtr tip(TTF_RenderUTF8_Blended(fontText,caption,fg));
	SDL_SetSurfaceAlphaMod(tip.get(), 0xFF);
	//Create the surface, we add 16px to the width for an icon,
	//plus 8px for the border to make it looks better.
	SurfacePtr item(SDL_CreateRGBSurface(SDL_SWSURFACE,tip->w+24+(icon>=0x100?24:0),24,32,RMASK,GMASK,BMASK,AMASK));
	SDL_Rect itemRect={0,0,item->w,item->h};
	SDL_FillRect(item.get(),&itemRect,0x00FFFFFF);
	//Not sure why there is this extra highlight.
	itemRect.y=3;
	itemRect.h=16;
	SDL_FillRect(item.get(),&itemRect,0xFFFFFFFF);
	//Draw the text on the item surface.
	applySurface(24 + (icon >= 0x100 ? 24 : 0), 0, tip.get(), item.get(), NULL);

	//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);
	}

	//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(_("Veritcal 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"));

	- //FIXME: We use hardcoded indeces, if the order changes we have a problem.
	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"));
	//Finally add scripting to the bottom.
	addItem(renderer,"Scripting",_("Scripting"),8*2+1);
	}

	void addLevelItems(SDL_Renderer& renderer){
	// add the layers
	{
	// blackground layers.
	std::map<std::string, std::vector<Scenery*> >::iterator it;
	for (it = parent->sceneryLayers.begin(); 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=="Looping"){
	+ } 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;
	}
	}
	};


	/////////////////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")) : 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){
	//Get the target time and recordings.
	levelTime=levels->getLevel()->targetTime;
	levelRecordings=levels->getLevel()->targetRecordings;

	//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"),SDL_Color{0,0,0,0});

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

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

	//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") : 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") : 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 AddPathCommand::describe() {
	return tfm::format(_("Add path to %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") : 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.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) {
	editor->levelName = levelProperty.levelName;
	editor->levelTheme = levelProperty.levelTheme;
	levelTime = levelProperty.levelTime;
	levelRecordings = levelProperty.levelRecordings;
	}

	// 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(),
	BLACK));
	}

	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());
	}

	//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 leveltheme.
	if(!levelTheme.empty())
	node.attributes["theme"].push_back(levelTheme);

	//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);
	}
	}
	}
	}

	//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.
	Game::reset(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;
	}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));
	}
	}
	}

	// NOTE: since onEnterObject is deprecated this code becomes no-op.

	/*//Check if the return button is pressed.
	//If so run the configure tool.
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_RETURN){
	//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};

	//Loop through the selected game objects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	//Check for collision.
	if(checkCollision(mouse,levelObjects[o]->getBox())){
	//Invoke the onEnterObject.
	onEnterObject(levelObjects[o]);
	//Break out of the for loop.
	break;
	}
	}
	}*/

	//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 < 0){
	pauseTime = 0;
	}
	} 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;
	}
	}

	//Check if we should enter playMode.
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_p){
	enterPlayMode();
	}
	//Check for tool shortcuts.
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_a){
	tool=ADD;
	}
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_s){
	tool=SELECT;
	}
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_d){
	//We clear the selection since that can't be used in the deletion tool.
	deselectAll();
	tool=REMOVE;
	}

	//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]);
	}
	}
	}
	}

	//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;
	}

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

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

	//Stop 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){
	movingBlocks[movingBlock].pop_back();
	}
	}

	//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){
	//Write the path to the moving block.
	std::map<std::string,std::string> editorData;
	char s[64], s0[64];

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

	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;
	//Now reset the player to get him to it's new start position.
	player.reset(true);
	}
	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;
	//Now reset the shadow to get him to it's new start position.
	shadow.reset(true);
	}
	}

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

	//Change mode.
	playMode=true;
	GUIObjectRoot->visible=false;
	cameraSave.x=camera.x;
	cameraSave.y=camera.y;

	//Compile and run script.
	//NOTE: The scriptExecutor should have been reset because we called Game::reset() before.
	compileScript();
	}

	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-300)/2,600,300,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,50,240,36,_("Name:"));
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,50,410,36,levelName.c_str());
	obj->name="name";
	root->addChild(obj);

	obj=new GUILabel(imageManager,renderer,40,100,240,36,_("Theme:"));
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,100,410,36,levelTheme.c_str());
	obj->name="theme";
	root->addChild(obj);

	//target time and recordings.
	{
	obj=new GUILabel(imageManager,renderer,40,150,240,36,_("Target time (s):"));
	root->addChild(obj);
	GUISpinBox* obj2=new GUISpinBox(imageManager,renderer,290,150,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,200,240,36,_("Target recordings:"));
	root->addChild(obj);
	obj2=new GUISpinBox(imageManager,renderer,290,200,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);
	}


	//Ok and cancel buttons.
	obj=new GUIButton(imageManager,renderer,root->width*0.3,300-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,300-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 editor data.
	vector<pair<string,string> > objMap;
	levelObjects[o]->getEditorData(objMap);

	//Add the object to the movingBlocks vector.
	vector<MovingPosition> positions;
	movingBlocks[levelObjects[o]]=positions;

	//Get the number of entries of the editor data.
	int m=objMap.size();

	//Check if the editor data isn't empty.
	if(m>0){
	//Integer containing the positions.
	int pos;
	int currentPos=0;

	//Get the number of movingpositions.
	pos=atoi(objMap[1].second.c_str());

	while(currentPos<pos){
	int x=atoi(objMap[currentPos*3+4].second.c_str());
	int y=atoi(objMap[currentPos*3+5].second.c_str());
	int t=atoi(objMap[currentPos*3+6].second.c_str());

	//Create a new movingPosition.
	MovingPosition position(x,y,t);
	movingBlocks[levelObjects[o]].push_back(position);

	//Increase currentPos by one.
	currentPos++;
	}
	}
	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;
	}

	AddPathCommand* pCommand = NULL;

	if (dx == 0 && dy == 0) {
	// pause mode
	if (pauseTime > 0) pCommand = new AddPathCommand(this, movingBlock, MovingPosition(x, y, pauseTime));
	pauseTime = 0;
	} else {
	// add new point mode
	const double length = sqrt(double(dxdx + dydy));
	pCommand = new AddPathCommand(this, movingBlock, MovingPosition(x, y, (int)(length*(10 / (double)movingSpeed))));
	}
	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]);
	}
	}
	}
	}

	// 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]);
	}
	}
	}
	}

	// 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.
	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.
	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;

	//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.
	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;
	}
	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;
	}
	}

	// Do the actual changes
	commandManager->doCommand(new SetScriptCommand(this, NULL, newScript));
	}
	}
	//Scripting window events.
	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=(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;
	}
	if(name=="cfgScriptingOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	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");

	Block* block=dynamic_cast<Block*>(configuredObject);
	if(block){
	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;
	}

	// now do the actual changes
	commandManager->doCommand(new SetScriptCommand(this, block, newScript, newId));
	}
	}
	}
	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));
	}
	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));
	}
	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));
	}
	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")));
	}
	}

	}

	//NOTE: We assume every event came from a window so 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{
	//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 blackground layers.
	std::map<std::string, std::vector<Scenery*> >::iterator it;
	for (it = sceneryLayers.begin(); 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);
	}
	}

	//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);
	}
	}
	}

	//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_SetRenderDrawColor(&renderer,themeTextColor.r,themeTextColor.g,themeTextColor.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();
	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)) {
	pauseTimeTexture.update(pauseTime,
	textureFromText(renderer, *fontText,
	tfm::format(_("Pause: %d = %0.3fs"), pauseTime, float(pauseTime)*0.025f).c_str(),
	BLACK));
	}
	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(),
	BLACK));
	}
	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,8*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(), BLACK));
	}
	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(), BLACK));
	}
	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())
	? 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 black
	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;

	//By default use black color for arrows.
	Uint32 color=0x00000000;

	//Theme can change the color.
	//TODO: use the actual color from the theme.
	if(themeTextColor.r>128 && themeTextColor.g>128 && themeTextColor.b>128)
	color=0xffffffff;

	//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 = getCachedTextTexture(renderer, tfm::format("%0.3fs", float(it->second[o].time)0.025f)).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/LevelEditor.h b/src/LevelEditor.h
	index 3dcea08..835360d 100644
	--- a/src/LevelEditor.h
	+++ b/src/LevelEditor.h
	@@ -1,401 +1,407 @@
	/*
	* Copyright (C) 2011-2012 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 LEVELEDITOR_H
	#define LEVELEDITOR_H

	#include "CachedTexture.h"
	#include "GameState.h"
	#include "GameObjects.h"
	#include "Player.h"
	#include "Game.h"
	#include "GUIObject.h"
	#include <vector>
	#include <map>
	#include <string>

	enum class ToolTips {
	Select = 0,
	Add,
	Delete,
	Play,
	UndoNoTooltip, // dynamically generated
	RedoNoTooltip, // dynamically generated
	LevelSettings,
	SaveLevel,
	BackToMenu,
	Configure,
	TooltipMax,
	};

	//Class that represents a moving position for moving blocks.
	class MovingPosition{
	public:
	//Integer containing the relative time used to store in the level.
	int time;
	//The x location.
	int x;
	//The x location.
	int y;

	//Constructor.
	//x: The x position relative to the moving block's position.
	//y: The y position relative to the moving block's position.
	//time: The time it takes from the previous position to here.
	MovingPosition(int x,int y,int time);
	//Destructor.
	~MovingPosition();

	//This will update the moving position.
	//x: The x position relative to the moving block's position.
	//y: The y position relative to the moving block's position.
	void updatePosition(int x,int y);
	};

	//Internal selection popup class.
	class LevelEditorSelectionPopup;

	//Internal actions popup class.
	class LevelEditorActionsPopup;

	class CommandManager;

	class AddRemoveGameObjectCommand;
	class AddLinkCommand;
	class RemoveLinkCommand;
	class AddPathCommand;
	class RemovePathCommand;
	class SetLevelPropertyCommand;
	class SetScriptCommand;
	class AddRemoveLayerCommand;
	class RenameLayerCommand;
	class MoveToLayerCommand;

	//The LevelEditor state, it's based on the Game state.
	class LevelEditor: public Game{
	friend class LevelEditorSelectionPopup;
	friend class LevelEditorActionsPopup;

	friend class AddRemoveGameObjectCommand;
	friend class AddLinkCommand;
	friend class RemoveLinkCommand;
	friend class AddPathCommand;
	friend class RemovePathCommand;
	friend class SetLevelPropertyCommand;
	friend class SetScriptCommand;
	friend class AddRemoveLayerCommand;
	friend class RenameLayerCommand;
	friend class MoveToLayerCommand;
	private:
	//Boolean if the user isplaying/testing the level.
	bool playMode;

	//Enumaration containing the tools.
	//SELECT: The select tool, for selecting/dragging blocks.
	//ADD: For adding blocks.
	//REMOVE: For removing blocks.
	enum Tools{
	SELECT,
	ADD,
	REMOVE,
	NUMBER_TOOLS
	};
	//The tool the user has selected.
	Tools tool;
	//The toolbar surface.
	SharedTexture toolbar;
	//Rectangle the size and location of the toolbar on screen.
	SDL_Rect toolbarRect;

	//The selection popup (if any)
	LevelEditorSelectionPopup* selectionPopup;
	//The actions popup (if any)
	LevelEditorActionsPopup* actionsPopup;

	//Map used to get the GameObject that belongs to a certain GUIWindow.
	map<GUIObject,GameObject> objectWindows;

	//Map which store the visibility of each scenery layers, "" (empty) means the Block layer
	map<string, bool> layerVisibility;

	//The selected layer, "" (empty) means the Block layer
	string selectedLayer;

	//Vector containing pointers to the selected GameObjects.
	vector<GameObject*> selection;
	//The selection square.
	SharedTexture selectionMark;

	//A circle at the location of moving positions in configure mode.
	SharedTexture movingMark;

	//Texture showing the movement speed.
	CachedTexture<int> movementSpeedTexture;

	//Texture showing the pause time
	CachedTexture<int> pauseTimeTexture;

	//GUI image.
	SharedTexture bmGUI;
	//Texture containing the text "Toolbox"
	TexturePtr toolboxText;

	//Keeps track of commands for undo and redo.
	CommandManager* commandManager;

	//The current type of block to place in Add mode.
	int currentType;

	std::array<TexturePtr,TYPE_MAX> typeTextTextures;
	std::array<TexturePtr,static_cast<size_t>(ToolTips::TooltipMax)> tooltipTextures;

	CachedTexture<std::string> undoTooltipTexture;
	CachedTexture<std::string> redoTooltipTexture;

	std::map<std::string, TexturePtr> cachedTextTextures;

	TexturePtr& getCachedTextTexture(SDL_Renderer& renderer, const std::string& text);

	//Boolean if the tool box is displayed.
	bool toolboxVisible;
	//The rect of tool box tip.
	SDL_Rect toolboxRect;
	//The first item in tool box.
	int toolboxIndex;

	//Boolean if the shift button is pressed.
	bool pressedShift;
	//Boolean if the left mouse button is pressed.
	bool pressedLeftMouse;
	//Boolean if the mouse is dragged. (Left button pressed and moved)
	bool dragging;

	//The camera x velocity.
	int cameraXvel;
	int cameraYvel;
	//SDL_Rect used to store the camera's location when entering playMode.
	SDL_Rect cameraSave;

	//Integer indicating if the selection is dragged and the drag mode.
	// -1: not dragged
	// 4: dragged
	// 0,1,2,3,5,6,7,8: resizing the dragCenter
	// 012
	// 3x5
	// 678
	int selectionDrag;

	//Pointer to the gameobject that's the center of the drag.
	GameObject* dragCenter;

	// The drag start position which is used when dragging blocks
	SDL_Point dragSrartPosition;

	//Integer containing a unique id.
	//Everytime a new id is needed it will increase by one.
	unsigned int currentId;

	typedef map<Block, vector<GameObject> > Triggers;

	//Vector containing the trigger GameObjects.
	Triggers triggers;
	//Boolean used in configure mode when linking triggers with their targets.
	bool linking;
	//Pointer to the trigger that's is being linked.
	Block* linkingTrigger;

	//Vector containing the moving GameObjects.
	map<Block*,vector<MovingPosition> > movingBlocks;
	//Integer containing the speed the block is moving for newly added blocks. 1 movingSpeed = 0.1 pixel/frame = 0.08 block/s
	//The movingSpeed is capped at 125 (10 block/s).
	int movingSpeed;
	//The pause time for path edit if the current point is equal to the previous time. 1 pauseTime = 1 frame = 0.04s
	int pauseTime;
	//Boolean used in configure mode when configuring moving blocks.
	bool moving;
	//Another boolean used in configure mode when configuring moving blocks.
	bool pauseMode;
	//Pointer to the moving block that's is being configured.
	Block* movingBlock;

	//Value used for placing the Movespeed label
	int movingSpeedWidth;

	//The clipboard.
	vector<map<string,string> > clipboard;

	//String containing the levelTheme.
	std::string levelTheme;

	//Integer containing the button of which a tool tip should be shown.
	int tooltip;

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

	//Method for deleting a GUIWindow.
	//NOTE: This function checks for the presence of the window in the GUIObjectRoot and objectWindows map.
	//window: Pointer to the GUIWindow.
	void destroyWindow(GUIObject* window);

	//Method that will let you configure the levelSettings.
	void levelSettings(ImageManager& imageManager,SDL_Renderer &renderer);

	//Method used to save the level.
	//fileName: Thge filename to write the level to.
	void saveLevel(string fileName);

	//Method used to convert a given x and y to snap to grid.
	//x: Pointer to the x location.
	//y: Pointer to the y location.
	void snapToGrid(int* x,int* y);

	//Method used to check if the cursor is near the border of screen and we should move the camera.
	//This method will check if the mouse is near a screen edge.
	//r: An array of SDL_Rect, does nothing if mouse inside these rectange(s).
	//count: Number of rectangles.
	//If so it will move the camera.
	void setCamera(const SDL_Rect* r,int count);

	public:
	//Array containing the ids of different block types in a wanted order
	//Maybe also useful to disable deprecated block types in the editor
	//PLEASE NOTE: Must be updated for new block types
	//Ordered for Edward Liis proposal:

	//Normal->Shadow->Spikes->Fragile
	//Normal moving->Shadow moving->Moving spikes
	//Conveyor belt->Shadow conveyor belt
	//Button->Switch->Portal->Swap->Checkpoint->Notification block
	//Player start->Shadow start->Exit
	//Collectable->Pushable

	static const int EDITOR_ORDER_MAX=20;
	static const int editorTileOrder[EDITOR_ORDER_MAX];

	//Array containing the names of available scenery blocks
	std::vector<std::string> sceneryBlockNames;

	// get the number of available blocks depending on the selected layer
	int getEditorOrderMax() const {
	if (selectedLayer.empty()) return EDITOR_ORDER_MAX;
	return sceneryBlockNames.size() + 1; // the added one is for custom scenery block
	}

	protected:
	//Inherits the function loadLevelFromNode from Game class.
	virtual void loadLevelFromNode(ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode* obj, const std::string& fileName) override;

	public:
	//Constructor.
	LevelEditor(SDL_Renderer &renderer, ImageManager &imageManager);
	//Destructor.
	~LevelEditor();

	//Method that will reset some default values.
	void reset();

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

	//Method used to draw the currentType on the placement surface.
	//This will only be called when the tool is ADD.
	void showCurrentObject(SDL_Renderer &renderer);
	//Method used to draw the selection that's being dragged.
	void showSelectionDrag(SDL_Renderer &renderer);
	//Method used to draw configure tool specific things like moving positions, teleport lines.
	void showConfigure(SDL_Renderer &renderer);

	//Method that will render the HUD.
	//It will be rendered after the placement suface but before the toolbar.
	void renderHUD(SDL_Renderer &renderer);

	//Method called after loading a level.
	//It will fill the triggers vector.
	void postLoad();

	//Event that is invoked when there's a mouse click on an object.
	//obj: Pointer to the GameObject clicked on.
	//selected: Boolean if the GameObject that has been clicked on was selected.
	void onClickObject(GameObject* obj,bool selected);
	//Event that is invoked when there's a right mouse button click on an object.
	//obj: Pointer to the GameObject clicked on.
	//selected: Boolean if the GameObject that has been clicked on was selected.
	void onRightClickObject(ImageManager& imageManager, SDL_Renderer& renderer, GameObject* obj, bool);
	//Event that is invoked when there's a mouse click but not on any object.
	//x: The x location of the click on the game field (+= camera.x).
	//y: The y location of the click on the game field (+= camera.y).
	void onClickVoid(int x,int y);
	//Event that is invoked when there's a mouse right click but not on any object.
	//x: The x location of the click on the game field (+= camera.x).
	//y: The y location of the click on the game field (+= camera.y).
	void onRightClickVoid(ImageManager& imageManager, SDL_Renderer& renderer, int x,int y);
	//Event that is invoked when the dragging starts.
	//x: The x location the drag started. (mouse.x+camera.x)
	//y: The y location the drag started. (mouse.y+camera.y)
	void onDragStart(int x,int y);
	//Event that is invoked when the mouse is dragged.
	//dx: The relative x distance the mouse dragged.
	//dy: The relative y distance the mouse dragged.
	void onDrag(int dx,int dy);
	//Event that is invoked when the mouse stopped dragging.
	//x: The x location the drag stopped. (mouse.x+camera.x)
	//y: The y location the drag stopped. (mouse.y+camera.y)
	void onDrop(int x,int y);
	//Event that is invoked when the camera is moved.
	//dx: The relative x distance the camera moved.
	//dy: The relative y distance the camera moved.
	void onCameraMove(int dx,int dy);

	/*//Event that is invoked when enter is pressed above an object.
	//obj: Pointer to the GameObject entered above.
	void onEnterObject(GameObject* obj);*/

	//internal function called by onClickObject() and onClickVoid().
	void addMovingPosition(int x,int y);

	//Set dirty of selection popup
	void selectionDirty();
	//Deselect all blocks
	void deselectAll();

	//Save current level and show a notification dialog
	void saveCurrentLevel(ImageManager& imageManager, SDL_Renderer& renderer);

	// An internal function to determine new position in drag mode.
	// Make sure selectionDrag=4 when calling this function.
	void determineNewPosition(int& x, int& y);
	// An internal function to determine new size in resize mode.
	// Make sure selectionDrag=0,1,2,3,5,6,7,8 when calling this function.
	void determineNewSize(int x, int y, SDL_Rect& r);

	//Call this function to start test play.
	void enterPlayMode();

	void undo();
	void redo();

	+ //Get the GUI texture.
	inline SharedTexture& getGuiTexture() {
	return bmGUI;
	}
	+
	+ //Get the play mode.
	+ bool isPlayMode() const {
	+ return playMode;
	+ }
	};
	#endif
	diff --git a/src/Player.cpp b/src/Player.cpp
	index 5f06915..23a6eaa 100644
	--- a/src/Player.cpp
	+++ b/src/Player.cpp
	@@ -1,1662 +1,1662 @@
	/*
	* 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 "Player.h"
	#include "Game.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "InputManager.h"
	#include "SoundManager.h"
	#include "StatisticsManager.h"
	#include "MD5.h"
	#include <iostream>
	#include <SDL.h>
	using namespace std;

	#ifdef RECORD_FILE_DEBUG
	string recordKeyPressLog,recordKeyPressLog_saved;
	vector<SDL_Rect> recordPlayerPosition,recordPlayerPosition_saved;
	#endif

	//static internal array to store time of recent deaths for achievements
	static Uint32 recentDeaths[10]={0};
	static int loadAndDieTimes=0;

	//static internal function to add recent deaths and update achievements
	static inline void addRecentDeaths(Uint32 recentLoad){
	//Get current time in ms.
	//We added it by 5 seconds to avoid bug if you choose a level to play
	//and die in 5 seconds after the game has startup.
	Uint32 t=SDL_GetTicks()+5000;

	for(int i=9;i>0;i--){
	recentDeaths[i]=recentDeaths[i-1];
	}
	recentDeaths[0]=t;

	//Update achievements
	if(recentDeaths[4]+5000>t){
	statsMgr.newAchievement("die5in5");
	}
	if(recentDeaths[9]+5000>t){
	statsMgr.newAchievement("die10in5");
	}
	if(recentLoad+1000>t){
	statsMgr.newAchievement("loadAndDie");
	}
	}

	Player::Player(Game* objParent):xVelBase(0),yVelBase(0),objParent(objParent),recordSaved(false),
	inAirSaved(false),isJumpSaved(false),canMoveSaved(false),holdingOtherSaved(false){
	//Set the dimensions of the player.
	//The size of the player is 21x40.
	box.x=0;
	box.y=0;
	box.w=23;
	box.h=40;

	//Set the dimensions of the other equal to the player's.
	boxOther = box;

	//Set his velocity to zero.
	xVel=0;
	yVel=0;

	//Set the start position.
	fx=0;
	fy=0;

	//Set some default values.
	inAir=true;
	isJump=false;
	shadowCall=false;
	shadow=false;
	canMove=true;
	holdingOther=false;
	dead=false;
	record=false;
	downKeyPressed=false;
	spaceKeyPressed=false;
	onGroundSaved=false;

	recordIndex=-1;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog.clear();
	recordKeyPressLog_saved.clear();
	recordPlayerPosition.clear();
	recordPlayerPosition_saved.clear();
	#endif
	objNotificationBlock=objCurrentStandSave=objLastStandSave=NULL;

	//Some default values for animation variables.
	direction=0;
	jumpTime=0;

	state=stateSaved=0;

	//xVelSaved is used to store if there's a state saved or not.
	xVelSaved=yVelSaved=0x80000000;

	objCurrentStand=objLastStand=objLastTeleport=objShadowBlock=NULL;
	}

	Player::~Player(){
	//Do nothing here
	}

	bool Player::isPlayFromRecord(){
	return recordIndex>=0; // && recordIndex<(int)recordButton.size();
	}

	//get the game record object.
	std::vector<int>* Player::getRecord(){
	return &recordButton;
	}

	#ifdef RECORD_FILE_DEBUG
	string& Player::keyPressLog(){
	return recordKeyPressLog;
	}
	vector<SDL_Rect>& Player::playerPosition(){
	return recordPlayerPosition;
	}
	#endif

	//play the record.
	void Player::playRecord(){
	recordIndex=0;
	}

	void Player::spaceKeyDown(class Shadow* shadow){
	//Start recording or stop, depending on the recording state.
	if(record==false){
	//We start recording.
	if(shadow->called==true){
	//The shadow is still busy so first stop him before we can start recording.
	shadowCall=false;
	shadow->called=false;
	shadow->playerButton.clear();
	}else if(!dead){
	//Check if shadow is dead.
	if(shadow->dead){
	//Show tooltip.
	//Just reset the countdown (the shadow's jumptime).
	shadow->jumpTime=80;

	//Play the error sound.
	getSoundManager()->playSound("error");
	}else{
	//The shadow isn't moving and both player and shadow aren't dead so start recording.
	record=true;

	//We start a recording meaning we need to increase recordings by one.
	objParent->recordings++;

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	statsMgr.recordTimes++;

	if(statsMgr.recordTimes==100) statsMgr.newAchievement("record100");
	if(statsMgr.recordTimes==1000) statsMgr.newAchievement("record1k");
	}
	}
	}
	}else{
	//The player is recording so stop recording and call the shadow.
	record=false;
	shadowCall=true;
	}
	}

	void Player::handleInput(class Shadow* shadow){
	//Check if we should read the input from record file.
	//Actually, we read input from record file in
	//another function shadowSetState.
	bool readFromRecord=false;
	if(recordIndex>=0 && recordIndex<(int)recordButton.size()) readFromRecord=true;

	if(!readFromRecord){
	//Reset horizontal velocity.
	xVel=0;
	if(inputMgr.isKeyDown(INPUTMGR_RIGHT)){
	//Walking to the right.
	xVel+=7;
	}
	if(inputMgr.isKeyDown(INPUTMGR_LEFT)){
	//Walking to the left.
	if(xVel!=0 && !dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	//Horizontal confusion achievement :)
	statsMgr.newAchievement("horizontal");
	}
	xVel-=7;
	}

	//Check if the action key has been released.
	if(!inputMgr.isKeyDown(INPUTMGR_ACTION)){
	//It has so downKeyPressed can't be true.
	downKeyPressed=false;
	}
	/*
	//Don't reset spaceKeyPressed or when you press the space key
	//and release another key then the bug occurs. (ticket #44)
	if(event.type==SDL_KEYUP \|\| !inputMgr.isKeyDown(INPUTMGR_SPACE)){
	spaceKeyPressed=false;
	}*/
	}

	//Check if a key is pressed (down).
	if(inputMgr.isKeyDownEvent(INPUTMGR_JUMP) && !readFromRecord){
	//The up key, if we aren't in the air we start jumping.
	//Fixed a potential bug
	if(!inAir && !isJump){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Jump key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	isJump=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SPACE) && !readFromRecord){
	//Fixed a potential bug
	if(!spaceKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Space key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	spaceKeyDown(shadow);
	spaceKeyPressed=true;
	}
	}else if(inputMgr.isKeyUpEvent(INPUTMGR_SPACE) && !readFromRecord){
	if(record && getSettings()->getBoolValue("quickrecord")){
	spaceKeyDown(shadow);
	spaceKeyPressed=true;
	}
	}else if(record && !readFromRecord && inputMgr.isKeyDownEvent(INPUTMGR_CANCELRECORDING)){
	//Cancel current recording

	//Search the recorded button and clear the last space key press
	int i=recordButton.size()-1;
	for(;i>=0;i--){
	if(recordButton[i] & PlayerButtonSpace){
	recordButton[i] &= ~PlayerButtonSpace;
	break;
	}
	}

	if(i>=0){
	//Clear the recording at the player's side.
	playerButton.clear();
	line.clear();

	//reset the record flag
	record=false;

	//decrese the record count
	objParent->recordings--;
	}else{
	cout<<"Failed to find last recording"<<endl;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_ACTION)){
	//Downkey is pressed.
	//Fixed a potential bug
	if(!downKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Action key pressed\n",objParent->time);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	downKeyPressed=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SAVE)){
	//F2 only works in the level editor.
	if(!(dead \|\| shadow->dead) && stateID==STATE_LEVEL_EDITOR){
	//Save the state. (delayed)
	if(objParent)
	objParent->saveStateNextTime=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_LOAD) && !readFromRecord){
	//F3 is used to load the last state.
	if(objParent)
	objParent->loadStateNextTime=true;
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SWAP)){
	//F4 will swap the player and the shadow, but only in the level editor.
	if(!(dead \|\| shadow->dead) && stateID==STATE_LEVEL_EDITOR){
	swapState(shadow);
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_TELEPORT)){
	//F5 will revive and teleoprt the player to the cursor. Only works in the level editor.
	//Shift+F5 teleports the shadow.
	if(stateID==STATE_LEVEL_EDITOR){
	//get the position of the cursor.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	if(inputMgr.isKeyDown(INPUTMGR_SHIFT)){
	//teleports the shadow.
	shadow->dead=false;
	shadow->box.x=x;
	shadow->box.y=y;
	}else{
	//teleports the player.
	dead=false;
	box.x=x;
	box.y=y;
	}

	//play sound?
	getSoundManager()->playSound("swap");
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_SUICIDE)){
	//F12 is suicide and only works in the leveleditor.
	if(stateID==STATE_LEVEL_EDITOR){
	die();
	shadow->die();
	}
	}
	}

	void Player::setLocation(int x,int y){
	box.x=x;
	box.y=y;
	}

	void Player::move(vector<Block*> &levelObjects,int lastX,int lastY){
	//Only move when the player isn't dead.
	//Fixed the bug that player/shadow can teleport or pull the switch even if died.
	//FIXME: Don't know if there will be any side-effects.
	if(dead) return;

	//Pointer to a checkpoint.
	Block* objCheckPoint=NULL;
	//Pointer to a swap.
	Block* objSwap=NULL;

	//Set the objShadowBlock to NULL.
	//Only for swapping to prevent the shadow from swapping in a shadow block.
	objShadowBlock=NULL;

	//Set the objNotificationBlock to NULL.
	objNotificationBlock=NULL;

	//NOTE: to fix bugs regarding player/shadow swap, we should first process collision of player/shadow
	//then move them. The code is moved to Game::logic().

	/*//Store the location.
	int lastX=box.x;
	int lastY=box.y;

	collision(levelObjects);*/

	bool canTeleport=true;
	bool isTraveling=true;

	// for checking the achievenemt that player and shadow come to exit simultaneously.
	bool weWon = false;

	//Now check the functional blocks.
	for(unsigned int o=0;o<levelObjects.size();o++){
	- //Skip block which is not enabled.
	- if (!levelObjects[o]->enabled) continue;
	+ //Skip block which is not visible.
	+ if (!levelObjects[o]->visible) continue;

	//Check for collision.
	if(checkCollision(box,levelObjects[o]->getBox())){
	//Now switch the type.
	switch(levelObjects[o]->type){
	case TYPE_CHECKPOINT:
	{
	//If we're not the shadow set the gameTip to Checkpoint.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_CHECKPOINT;

	//And let objCheckPoint point to this object.
	objCheckPoint=levelObjects[o];
	break;
	}
	case TYPE_SWAP:
	{
	//If we're not the shadow set the gameTip to swap.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_SWAP;

	//And let objSwap point to this object.
	objSwap=levelObjects[o];
	break;
	}
	case TYPE_EXIT:
	{
	//Make sure we're not in the leveleditor.
	if(stateID==STATE_LEVEL_EDITOR)
	break;

	//Check to see if we have enough keys to finish the level
	if(objParent->currentCollectables>=objParent->totalCollectables){
	//Update achievements
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(objParent->player.dead \|\| objParent->shadow.dead){
	//Finish the level with player or shadow died.
	statsMgr.newAchievement("forget");
	}
	if(objParent->won && !weWon){ // This checks if somebody already hit the exit but we haven't hit the exit yet.
	//Player and shadow come to exit simultaneously.
	statsMgr.newAchievement("jit");
	}
	}

	//We can't just handle the winning here (in the middle of the update cycle)/
	//So set won in Game true.
	objParent->won=true;

	//We hit the exit.
	weWon = true;
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Check if the teleport id isn't empty.
	if(levelObjects[o]->id.empty()){
	std::cerr<<"WARNING: Invalid teleport id!"<<std::endl;
	canTeleport=false;
	}

	//If we're not the shadow set the gameTip to portal.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_PORTAL;

	//Check if we can teleport and should (downkey -or- auto).
	if(canTeleport && (downKeyPressed \|\| (levelObjects[o]->queryProperties(GameObjectProperty_Flags,this)&1))){
	canTeleport=false;
	if(downKeyPressed \|\| levelObjects[o]!=objLastTeleport){
	downKeyPressed=false;

	//Loop the levelobjects again to find the destination.
	for(unsigned int oo=o+1;;){
	//We started at our index+1.
	//Meaning that if we reach the end of the vector then we need to start at the beginning.
	if(oo>=levelObjects.size())
	oo-=(int)levelObjects.size();
	//It also means that if we reach the same index we need to stop.
	//If the for loop breaks this way then we have no succes.
	if(oo==o){
	//Couldn't teleport so play the error sound.
	getSoundManager()->playSound("error");
	break;
	}

	//Check if the second (oo) object is a portal.
	if(levelObjects[oo]->type==TYPE_PORTAL){
	//Check the id against the destination of the first portal.
	if(levelObjects[o]->destination==levelObjects[oo]->id){
	//Call the event.
	objParent->broadcastObjectEvent(GameObjectEvent_OnToggle,-1,NULL,levelObjects[o]);
	objLastTeleport=levelObjects[oo];

	//Get the destination location and teleport the player.
	SDL_Rect r=levelObjects[oo]->getBox();
	box.x=r.x+5;
	box.y=r.y+2;

	//We don't count it to traveling distance.
	isTraveling=false;

	//Play the swap sound.
	getSoundManager()->playSound("swap");
	break;
	}
	}

	//Increase oo.
	oo++;
	}
	}
	}
	break;
	}
	case TYPE_SWITCH:
	{
	//If we're not the shadow set the gameTip to switch.
	if(!shadow && objParent!=NULL)
	objParent->gameTipIndex=TYPE_SWITCH;

	//If the down key is pressed then invoke an event.
	if(downKeyPressed){
	//Play the animation.
	levelObjects[o]->playAnimation();

	//Play the toggle sound.
	getSoundManager()->playSound("toggle");

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	statsMgr.switchTimes++;

	//Update achievements
	switch(statsMgr.switchTimes){
	case 100:
	statsMgr.newAchievement("switch100");
	break;
	case 1000:
	statsMgr.newAchievement("switch1k");
	break;
	}
	}

	if(objParent!=NULL){
	//Make sure that the id isn't emtpy.
	if(!levelObjects[o]->id.empty()){
	objParent->broadcastObjectEvent(0x10000 \| (levelObjects[o]->queryProperties(GameObjectProperty_Flags,this)&3),
	-1,levelObjects[o]->id.c_str());
	}else{
	cerr<<"WARNING: invalid switch id!"<<endl;
	}
	}
	}
	break;
	}
	case TYPE_SHADOW_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	{
	//This only applies to the player.
	if(!shadow)
	objShadowBlock=levelObjects[o];
	break;
	}
	case TYPE_NOTIFICATION_BLOCK:
	{
	//This only applies to the player.
	if(!shadow)
	objNotificationBlock=levelObjects[o];
	break;
	}
	case TYPE_COLLECTABLE:
	{
	//Check if collectable is active (if it's not it's equal to 1(inactive))
	if(levelObjects[o]->queryProperties(GameObjectProperty_Flags, this)==0) {
	//Toggle an event
	objParent->broadcastObjectEvent(GameObjectEvent_OnToggle,-1,NULL,levelObjects[o]);
	//Increase the current number of collectables
	objParent->currentCollectables++;
	getSoundManager()->playSound("collect");
	//Open exit(s)
	if(objParent->currentCollectables>=objParent->totalCollectables){
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->type==TYPE_EXIT){
	objParent->broadcastObjectEvent(GameObjectEvent_OnSwitchOn,-1,NULL,levelObjects[i]);
	}
	}
	}
	}
	break;
	}
	}

	//Now check for the spike property.
	if(levelObjects[o]->queryProperties(GameObjectProperty_IsSpikes,this)){
	//It is so get the collision box.
	SDL_Rect r=levelObjects[o]->getBox();

	//TODO: pixel-accuracy hit test.
	//For now we shrink the box.
	r.x+=2;
	r.y+=2;
	r.w-=4;
	r.h-=4;

	//Check collision, if the player collides then let him die.
	if(checkCollision(box,r)){
	die();
	}
	}
	}
	}

	//Check if the player can teleport.
	if(canTeleport)
	objLastTeleport=NULL;

	//Check the checkpoint pointer only if the downkey is pressed.
	//new: don't save the game if playing game record
	if(objParent!=NULL && downKeyPressed && objCheckPoint!=NULL && !isPlayFromRecord()){
	//Checkpoint thus save the state.
	if(objParent->canSaveState()){
	objParent->saveStateNextTime=true;
	objParent->objLastCheckPoint=objCheckPoint;
	}
	}
	//Check the swap pointer only if the down key is pressed.
	if(objSwap!=NULL && downKeyPressed && objParent!=NULL){
	//Now check if the shadow we're the shadow or not.
	if(shadow){
	if(!(dead \|\| objParent->player.dead)){
	//Check if the player isn't in front of a shadow block.
	if(!objParent->player.objShadowBlock){
	objParent->player.swapState(this);
	objSwap->playAnimation();
	//We don't count it to traveling distance.
	isTraveling=false;
	//NOTE: Statistics updated in swapState() function.
	}else{
	//We can't swap so play the error sound.
	getSoundManager()->playSound("error");
	}
	}
	}else{
	if(!(dead \|\| objParent->shadow.dead)){
	//Check if the player isn't in front of a shadow block.
	if(!objShadowBlock){
	swapState(&objParent->shadow);
	objSwap->playAnimation();
	//We don't count it to traveling distance.
	isTraveling=false;
	//NOTE: Statistics updated in swapState() function.
	}else{
	//We can't swap so play the error sound.
	getSoundManager()->playSound("error");
	}
	}
	}
	}

	//Determine the correct theme state.
	if(!dead){
	//Set the direction depending on the velocity.
	if(xVel>0)
	direction=0;
	else if(xVel<0)
	direction=1;

	//Check if the player is in the air.
	if(!inAir){
	//On the ground so check the direction and movement.
	if(xVel>0){
	if(appearance.currentStateName!="walkright"){
	appearance.changeState("walkright");
	}
	}else if(xVel<0){
	if(appearance.currentStateName!="walkleft"){
	appearance.changeState("walkleft");
	}
	}else if(xVel==0){
	if(direction==1){
	appearance.changeState("standleft");
	}else{
	appearance.changeState("standright");
	}
	}
	}else{
	//Check for jump appearance (inAir).
	if(direction==1){
	if(yVel>0){
	if(appearance.currentStateName!="fallleft")
	appearance.changeState("fallleft");
	}else{
	if(appearance.currentStateName!="jumpleft")
	appearance.changeState("jumpleft");
	}
	}else{
	if(yVel>0){
	if(appearance.currentStateName!="fallright")
	appearance.changeState("fallright");
	}else{
	if(appearance.currentStateName!="jumpright")
	appearance.changeState("jumpright");
	}
	}
	}
	}


	//Update traveling distance statistics.
	if(isTraveling && (lastX!=box.x \|\| lastY!=box.y) && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	float dx=float(lastX-box.x),dy=float(lastY-box.y);
	float d0=statsMgr.playerTravelingDistance+statsMgr.shadowTravelingDistance,
	d=sqrtf(dxdx+dydy)/50.0f;
	if(shadow) statsMgr.shadowTravelingDistance+=d;
	else statsMgr.playerTravelingDistance+=d;

	//Update achievement
	d+=d0;
	if(d0<=100.0f && d>=100.0f) statsMgr.newAchievement("travel100");
	if(d0<=1000.0f && d>=1000.0f) statsMgr.newAchievement("travel1k");
	if(d0<=10000.0f && d>=10000.0f) statsMgr.newAchievement("travel10k");
	if(d0<=42195.0f && d>=42195.0f) statsMgr.newAchievement("travel42k");
	}

	//Reset the downKeyPressed flag.
	downKeyPressed=false;
	}

	void Player::collision(vector<Block*> &levelObjects){
	//Only move when the player isn't dead.
	if(dead)
	return;

	//First sort out the velocity.
	//Add gravity acceleration to the vertical velocity.
	if(!canMove)
	//FIXME: xVel should be set to zero instead of substracting it from xVelBase.
	//This isn't done since xVel won't be set back every frame but in handleInput.
	xVelBase-=xVel;
	if(isJump)
	jump();
	if(inAir==true){
	yVel+=1;

	//Cap fall speed to 13.
	if(yVel>13)
	yVel=13;
	}
	if(objCurrentStand!=NULL){
	//Now get the velocity and delta of the object the player is standing on.
	SDL_Rect v=objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=objCurrentStand->getBox(BoxType_Delta);

	switch(objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	xVelBase=v.x;
	}
	break;
	//In other cases, such as player on shadow, player on crate. the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	xVelBase+=delta.x;
	}
	break;
	}
	//NOTE: Only copy the velocity of the block when moving down.
	//Upwards is automatically resolved before the player is moved.
	if(delta.y>0){
	//Fixes the jitters when the player is on a pushable block on a downward moving box.
	box.y+=delta.y;
	yVelBase=v.y;
	}
	else
	yVelBase=0;
	}

	//Set the object the player is currently standing to NULL.
	objCurrentStand=NULL;

	//Store the location of the player.
	int lastX=box.x;
	int lastY=box.y;

	//An array that will hold all the GameObjects that are involved in the collision/movement.
	vector<Block*> objects;
	//All the blocks have moved so if there's collision with the player, the block moved into him.
	for(unsigned int o=0;o<levelObjects.size();o++){
	- //Make sure to only check enabled blocks.
	- if(!levelObjects[o]->enabled)
	+ //Make sure to only check visible blocks.
	+ if(!levelObjects[o]->visible)
	continue;
	//Make sure the object is solid for the player.
	if(!levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this))
	continue;

	//Check for collision.
	if(checkCollision(box,levelObjects[o]->getBox()))
	objects.push_back(levelObjects[o]);
	}
	//There was collision so try to resolve it.
	if(!objects.empty()){
	//FIXME: When multiple moving blocks are overlapping the player can be "bounced" off depending on the block order.
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	SDL_Rect delta=objects[o]->getBox(BoxType_Delta);

	//Check on which side of the box the player is.
	if(delta.x!=0){
	if(delta.x>0){
	if((r.x+r.w)-box.x<=delta.x)
	box.x=r.x+r.w;
	}else{
	if((box.x+box.w)-r.x<=-delta.x)
	box.x=r.x-box.w;
	}
	}
	if(delta.y!=0){
	if(delta.y>0){
	if((r.y+r.h)-box.y<=delta.y)
	box.y=r.y+r.h;
	}else{
	if((box.y+box.h)-r.y<=-delta.y)
	box.y=r.y-box.h;
	}
	}
	}

	//Check if the player is squashed.
	for(unsigned int o=0;o<levelObjects.size();o++){
	- //Make sure the object is enabled.
	- if(!levelObjects[o]->enabled)
	+ //Make sure the object is visible.
	+ if(!levelObjects[o]->visible)
	continue;
	//Make sure the object is solid for the player.
	if(!levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this))
	continue;

	if(checkCollision(box,levelObjects[o]->getBox())){
	//The player is squashed so first move him back.
	box.x=lastX;
	box.y=lastY;

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(shadow) statsMgr.shadowSquashed++;
	else statsMgr.playerSquashed++;

	switch(statsMgr.playerSquashed+statsMgr.shadowSquashed){
	case 1:
	statsMgr.newAchievement("squash1");
	break;
	case 50:
	statsMgr.newAchievement("squash50");
	break;
	}
	}

	//Now call the die method.
	die();
	return;
	}
	}
	}

	//Reuse the objects array, this time for blocks the player walks into.
	objects.clear();
	//Determine the collision frame.
	SDL_Rect frame={box.x,box.y,box.w,box.h};
	//Keep the horizontal movement of the player in mind.
	if(xVel+xVelBase>=0){
	frame.w+=(xVel+xVelBase);
	}else{
	frame.x+=(xVel+xVelBase);
	frame.w-=(xVel+xVelBase);
	}
	//And the vertical movement.
	if(yVel+yVelBase>=0){
	frame.h+=(yVel+yVelBase);
	}else{
	frame.y+=(yVel+yVelBase);
	frame.h-=(yVel+yVelBase);
	}
	//Loop through the game objects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	- //Make sure the block isn't enabled.
	- if(!levelObjects[o]->enabled)
	+ //Make sure the block is visible.
	+ if(!levelObjects[o]->visible)
	continue;
	//Check if the player can collide with this game object.
	if(!levelObjects[o]->queryProperties(GameObjectProperty_PlayerCanWalkOn,this))
	continue;

	//Check if the block is inside the frame.
	if(checkCollision(frame,levelObjects[o]->getBox()))
	objects.push_back(levelObjects[o]);
	}
	//Horizontal pass.
	if(xVel+xVelBase!=0){
	box.x+=xVel+xVelBase;
	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	//In case of a pushable block we give it velocity.
	if(objects[o]->type==TYPE_PUSHABLE){
	objects[o]->xVel+=(xVel+xVelBase)/2;
	}

	if(xVel+xVelBase>0){
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if((box.x+box.w)-r.x<=xVel+xVelBase)
	box.x=r.x-box.w;
	}else{
	//We came from the left so the right edge of the player must be less or equal than xVel+xVelBase.
	if(box.x-(r.x+r.w)<=-(xVel+xVelBase))
	box.x=r.x+r.w;
	}
	}
	}
	//Some variables that are used in vertical movement.
	Block* lastStand=NULL;
	inAir=true;

	//Vertical pass.
	if(yVel+yVelBase!=0){
	box.y+=yVel+yVelBase;

	//Value containing the previous 'depth' of the collision.
	int prevDepth=0;

	for(unsigned int o=0;o<objects.size();o++){
	SDL_Rect r=objects[o]->getBox();
	if(!checkCollision(box,r))
	continue;

	//Now check how we entered the block (vertically or horizontally).
	if(yVel+yVelBase>0){
	//Calculate the number of pixels the player is in the block (vertically).
	int depth=(box.y+box.h)-r.y;

	//We came from the top so the bottom edge of the player must be less or equal than yVel+yVelBase.
	if(depth<=yVel+yVelBase){
	//NOTE: lastStand is handled later since the player can stand on only one block at the time.

	//Check if there's already a lastStand.
	if(lastStand){
	//Since the player fell he will stand on the highest block, meaning the highest 'depth'.
	if(depth>prevDepth){
	lastStand=objects[o];
	prevDepth=depth;
	}else if(depth==prevDepth){
	//Both blocks are at the same height so determine the block by the amount the player is standing on them.
	SDL_Rect r=objects[o]->getBox();
	int w=0;
	if(box.x+box.w>r.x+r.w)
	w=(r.x+r.w)-box.x;
	else
	w=(box.x+box.w)-r.x;

	//Do the same for the other box.
	r=lastStand->getBox();
	int w2=0;
	if(box.x+box.w>r.x+r.w)
	w2=(r.x+r.w)-box.x;
	else
	w2=(box.x+box.w)-r.x;

	//NOTE: It doesn't matter which block the player is on if they are both stationary.
	SDL_Rect v=objects[o]->getBox(BoxType_Velocity);
	SDL_Rect v2=lastStand->getBox(BoxType_Velocity);

	//Either the have the same (vertical) velocity so most pixel standing on is the lastStand...
	// ... OR one is moving slower down/faster up and that's the one the player is standing on.
	if((v.y==v2.y && w>w2) \|\| v.y<v2.y){
	lastStand=objects[o];
	prevDepth=depth;
	}
	}
	}else{
	//There isn't one so assume the current block for now.
	lastStand=objects[o];
	prevDepth=depth;
	}
	}
	}else{
	//We came from the bottom so the upper edge of the player must be less or equal than yVel+yVelBase.
	if(box.y-(r.y+r.h)<=-(yVel+yVelBase)){
	box.y=r.y+r.h;
	yVel=0;
	}
	}
	}
	}
	if(lastStand){
	inAir=false;
	yVel=1;
	SDL_Rect r=lastStand->getBox();
	box.y=r.y-box.h;
	}

	//Check if the player fell of the level, if so let him die but without animation.
	if(box.y>LEVEL_HEIGHT)
	die(false);

	//Check if the player changed blocks, meaning stepped onto a block.
	objCurrentStand=lastStand;
	if(lastStand!=objLastStand){
	//The player has changed block so call the playerleave event.
	if(objLastStand)
	objParent->broadcastObjectEvent(GameObjectEvent_PlayerLeave,-1,NULL,objLastStand);

	//Set the new lastStand.
	objLastStand=lastStand;
	if(lastStand){
	//Call the walk on event of the laststand.
	objParent->broadcastObjectEvent(GameObjectEvent_PlayerWalkOn,-1,NULL,lastStand);

	//Bugfix for Fragile blocks.
	if(lastStand->type==TYPE_FRAGILE && !lastStand->queryProperties(GameObjectProperty_PlayerCanWalkOn,this)){
	inAir=true;
	isJump=false;
	}
	}
	}
	//NOTE: The PlayerIsOn event must be handled here so that the script can change the location of a block without interfering with the collision detection.
	//Handlingin it here also guarantees that this event will only be called once for one block per update.
	if(objCurrentStand)
	objParent->broadcastObjectEvent(GameObjectEvent_PlayerIsOn,-1,NULL,objCurrentStand);

	//Reset the base velocity.
	xVelBase=yVelBase=0;
	canMove=true;
	}

	void Player::jump(int strength){
	//Check if the player can jump.
	if(inAir==false){
	//Set the jump velocity.
	yVel=-strength;
	inAir=true;
	isJump=false;
	jumpTime++;

	//Update statistics
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(shadow) statsMgr.shadowJumps++;
	else statsMgr.playerJumps++;

	if(statsMgr.playerJumps+statsMgr.shadowJumps==1000) statsMgr.newAchievement("frog");
	}

	//Check if sound is enabled, if so play the jump sound.
	getSoundManager()->playSound("jump");
	}
	}

	void Player::show(SDL_Renderer& renderer){
	//Check if we should render the recorded line.
	//Only do this when we're recording and we're not the shadow.
	if(shadow==false && record==true){
	//FIXME: Adding an entry not in update but in render?
	line.push_back(SDL_Rect());
	line[line.size()-1].x=box.x+11;
	line[line.size()-1].y=box.y+20;

	//Loop through the line dots and draw them.
	for(int l=0; l<(signed)line.size(); l++){
	appearance.drawState("line",renderer,line[l].x-camera.x,line[l].y-camera.y);
	}
	}

	//NOTE: We do logic here, because it's only needed by the appearance.
	appearance.updateAnimation();
	appearance.draw(renderer, box.x-camera.x, box.y-camera.y);
	}

	void Player::shadowSetState(){
	int currentKey=0;

	/*//debug
	extern int block_test_count;
	extern bool block_test_only;
	if(SDL_GetKeyState(NULL)[SDLK_p]){
	block_test_count=recordButton.size();
	}
	if(block_test_count==(int)recordButton.size()){
	block_test_only=true;
	}*/

	//Check if we should read the input from record file.
	if(recordIndex>=0){ // && recordIndex<(int)recordButton.size()){
	//read the input from record file
	if(recordIndex<(int)recordButton.size()){
	currentKey=recordButton[recordIndex];
	recordIndex++;
	}

	//Reset horizontal velocity.
	xVel=0;
	if(currentKey&PlayerButtonRight){
	//Walking to the right.
	xVel+=7;
	}
	if(currentKey&PlayerButtonLeft){
	//Walking to the left.
	xVel-=7;
	}

	if(currentKey&PlayerButtonJump){
	//The up key, if we aren't in the air we start jumping.
	if(inAir==false){
	isJump=true;
	}else{
	//Shouldn't go here
	cout<<"Replay BUG"<<endl;
	}
	}

	//check the down key
	downKeyPressed=(currentKey&PlayerButtonDown)!=0;

	//check the space key
	if(currentKey&PlayerButtonSpace){
	spaceKeyDown(&objParent->shadow);
	}
	}else{
	//read the input from keyboard.
	recordIndex=-1;

	//Check for xvelocity.
	if(xVel>0)
	currentKey\|=PlayerButtonRight;
	if(xVel<0)
	currentKey\|=PlayerButtonLeft;

	//Check for jumping.
	if(isJump){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Jump key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonJump;
	}

	//Check if the downbutton is pressed.
	if(downKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Action key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonDown;
	}

	if(spaceKeyPressed){
	#ifdef RECORD_FILE_DEBUG
	char c[64];
	sprintf(c,"[%05d] Space key recorded\n",objParent->time-1);
	cout<<c;
	recordKeyPressLog+=c;
	#endif
	currentKey\|=PlayerButtonSpace;
	}

	//Record it.
	recordButton.push_back(currentKey);
	}

	#ifdef RECORD_FILE_DEBUG
	if(recordIndex>=0){
	if(recordIndex>0 && recordIndex<=int(recordPlayerPosition.size())/2){
	SDL_Rect &r1=recordPlayerPosition[recordIndex*2-2];
	SDL_Rect &r2=recordPlayerPosition[recordIndex*2-1];
	if(r1.x!=box.x \|\| r1.y!=box.y \|\| r2.x!=objParent->shadow.box.x \|\| r2.y!=objParent->shadow.box.y){
	char c[192];
	sprintf(c,"Replay ERROR [%05d] %d %d %d %d Expected: %d %d %d %d\n",
	objParent->time-1,box.x,box.y,objParent->shadow.box.x,objParent->shadow.box.y,r1.x,r1.y,r2.x,r2.y);
	cout<<c;
	}
	}
	}else{
	recordPlayerPosition.push_back(box);
	recordPlayerPosition.push_back(objParent->shadow.box);
	}
	#endif

	//reset spaceKeyPressed.
	spaceKeyPressed=false;

	//Only add an entry if the player is recording.
	if(record){
	//Add the action.
	if(!dead && !objParent->shadow.dead){
	playerButton.push_back(currentKey);

	//Change the state.
	state++;
	}else{
	//Either player or shadow is dead, stop recording.
	playerButton.clear();
	state=0;
	record=false;
	}
	}
	}

	void Player::shadowGiveState(Shadow* shadow){
	//Check if the player calls the shadow.
	if(shadowCall==true){
	//Clear any recording still with the shadow.
	shadow->playerButton.clear();

	//Loop the recorded moves and add them to the one of the shadow.
	for(unsigned int s=0;s<playerButton.size();s++){
	shadow->playerButton.push_back(playerButton[s]);
	}

	//Reset the state of both the player and the shadow.
	stateReset();
	shadow->stateReset();

	//Clear the recording at the player's side.
	playerButton.clear();
	line.clear();

	//Set shadowCall false
	shadowCall=false;
	//And let the shadow know that the player called him.
	shadow->meCall();
	}
	}

	void Player::stateReset(){
	//Reset the state by setting it to 0.
	state=0;
	}

	void Player::otherCheck(class Player* other){
	//Now check if the player is on the shadow.
	//First make sure they are both alive.
	if(!dead && !other->dead){
	//Get the box of the shadow.
	SDL_Rect boxShadow=other->getBox();

	//Check if the player is on top of the shadow.
	if(checkCollision(box,boxShadow)==true){
	//We have collision now check if the other is standing on top of you.
	if(box.y+box.h<=boxShadow.y+13 && !other->inAir){
	//Player is on shadow.
	int yVelocity=yVel-1;
	if(yVelocity>0){
	box.y-=yVel;
	box.y+=boxShadow.y-(box.y+box.h);
	inAir=false;
	canMove=false;
	//Reset the vertical velocity.
	yVel=2;
	other->holdingOther=true;
	other->appearance.changeState("holding");

	//Change our own appearance to standing.
	if(direction==1){
	appearance.changeState("standleft");
	}else{
	appearance.changeState("standright");
	}

	//Set the velocity things.
	objCurrentStand=NULL;
	if(other->objCurrentStand){
	SDL_Rect v=other->objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=other->objCurrentStand->getBox(BoxType_Delta);

	//If the shadow has moved, then change the movement of the player.
	if(boxOther.x != boxShadow.x){
	switch(other->objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	xVelBase=v.x;
	}
	break;
	//In other cases, such as player on shadow, player on crate. the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	xVelBase+=delta.x;
	}
	break;
	}
	}
	yVelBase=v.y;
	}
	}
	}else if(boxShadow.y+boxShadow.h<=box.y+13 && !inAir){
	//Shadow is on player.
	int yVelocity=other->yVel-1;
	if(yVelocity>0){
	other->box.y-=other->yVel;
	other->box.y+=box.y-(other->box.y+other->box.h);
	other->inAir=false;
	other->canMove=false;
	//Reset the vertical velocity of the other.
	other->yVel=2;
	holdingOther=true;
	appearance.changeState("holding");

	//Change our own appearance to standing.
	if(other->direction==1){
	other->appearance.changeState("standleft");
	}else{
	other->appearance.changeState("standright");
	}

	//Set the velocity things.
	other->objCurrentStand=NULL;
	if(objCurrentStand){
	SDL_Rect v=objCurrentStand->getBox(BoxType_Velocity);
	SDL_Rect delta=objCurrentStand->getBox(BoxType_Delta);

	//If the player has moved, then change the movement of the shadow.
	if(other->boxOther.x != box.x){
	switch(objCurrentStand->type){
	//For conveyor belts the velocity is transfered.
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	{
	other->xVelBase=v.x;
	}
	break;
	//In other cases, such as player on shadow, player on crate. the change in x position must be considered.
	default:
	{
	if(delta.x != 0)
	other->xVelBase+=delta.x;
	}
	break;
	}
	}
	other->yVelBase=v.y;
	}
	}
	}
	}else{
	holdingOther=false;
	other->holdingOther=false;
	}
	boxOther=boxShadow;
	other->boxOther=box;
	}
	}

	SDL_Rect Player::getBox(){
	return box;
	}

	void Player::setMyCamera(){
	//Only change the camera when the player isn't dead.
	if(dead)
	return;

	//Check if the level fit's horizontally inside the camera.
	if(camera.w>LEVEL_WIDTH){
	camera.x=-(camera.w-LEVEL_WIDTH)/2;
	}else{
	//Check if the player is halfway pass the halfright of the screen.
	if(box.x>camera.x+(SCREEN_WIDTH/2+50)){
	//It is so ease the camera to the right.
	camera.x+=(box.x-camera.x-(SCREEN_WIDTH/2))>>4;

	//Check if the camera isn't going too far.
	if(box.x<camera.x+(SCREEN_WIDTH/2+50)){
	camera.x=box.x-(SCREEN_WIDTH/2+50);
	}
	}

	//Check if the player is halfway pass the halfleft of the screen.
	if(box.x<camera.x+(SCREEN_WIDTH/2-50)){
	//It is so ease the camera to the left.
	camera.x+=(box.x-camera.x-(SCREEN_WIDTH/2))>>4;

	//Check if the camera isn't going too far.
	if(box.x>camera.x+(SCREEN_WIDTH/2-50)){
	camera.x=box.x-(SCREEN_WIDTH/2-50);
	}
	}

	//If the camera is too far to the left we set it to 0.
	if(camera.x<0){
	camera.x=0;
	}
	//If the camera is too far to the right we set it to the max right.
	if(camera.x+camera.w>LEVEL_WIDTH){
	camera.x=LEVEL_WIDTH-camera.w;
	}
	}

	//Check if the level fit's vertically inside the camera.
	if(camera.h>LEVEL_HEIGHT){
	//We don't centre vertical because the bottom line of the level (deadly) will be mid air.
	camera.y=-(camera.h-LEVEL_HEIGHT);
	}else{
	//Check if the player is halfway pass the lower half of the screen.
	if(box.y>camera.y+(SCREEN_HEIGHT/2+50)){
	//If is so ease the camera down.
	camera.y+=(box.y-camera.y-(SCREEN_HEIGHT/2))>>4;

	//Check if the camera isn't going too far.
	if(box.y<camera.y+(SCREEN_HEIGHT/2+50)){
	camera.y=box.y-(SCREEN_HEIGHT/2+50);
	}
	}

	//Check if the player is halfway pass the upper half of the screen.
	if(box.y<camera.y+(SCREEN_HEIGHT/2-50)){
	//It is so ease the camera up.
	camera.y+=(box.y-camera.y-(SCREEN_HEIGHT/2))>>4;

	//Check if the camera isn't going too far.
	if(box.y>camera.y+(SCREEN_HEIGHT/2-50)){
	camera.y=box.y-(SCREEN_HEIGHT/2-50);
	}
	}

	//If the camera is too far up we set it to 0.
	if(camera.y<0){
	camera.y=0;
	}
	//If the camera is too far down we set it to the max down.
	if(camera.y+camera.h>LEVEL_HEIGHT){
	camera.y=LEVEL_HEIGHT-camera.h;
	}
	}
	}

	void Player::reset(bool save){
	//Set the location of the player to it's initial state.
	box.x=fx;
	box.y=fy;

	//Reset back to default value.
	inAir=true;
	isJump=false;
	shadowCall=false;
	canMove=true;
	holdingOther=false;
	dead=false;
	record=false;
	downKeyPressed=false;
	spaceKeyPressed=false;

	//Some animation variables.
	appearance.resetAnimation(save);
	appearance.changeState("standright");
	direction=0;

	state=0;
	xVel=0; //??? fixed a strange bug in game replay
	yVel=0;

	//Reset the gameObject pointers.
	objCurrentStand=objLastStand=objLastTeleport=objNotificationBlock=objShadowBlock=NULL;
	if(save)
	objCurrentStandSave=objLastStandSave=NULL;

	//Clear the recording.
	line.clear();
	playerButton.clear();
	recordButton.clear();
	recordIndex=-1;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog.clear();
	recordPlayerPosition.clear();
	#endif

	if(save){
	//xVelSaved is used to indicate if there's a state saved or not.
	xVelSaved=0x80000000;

	loadAndDieTimes=0;
	}
	}

	void Player::saveState(){
	//We can only save the state when the player isn't dead.
	if(!dead){
	boxSaved.x=box.x;
	boxSaved.y=box.y;
	xVelSaved=xVel;
	yVelSaved=yVel;
	inAirSaved=inAir;
	isJumpSaved=isJump;
	canMoveSaved=canMove;
	holdingOtherSaved=holdingOther;
	stateSaved=state;

	//Let the appearance save.
	appearance.saveAnimation();

	//Save the lastStand and currentStand pointers.
	objCurrentStandSave=objCurrentStand;
	objLastStandSave=objLastStand;

	//Save any recording stuff.
	recordSaved=record;
	playerButtonSaved=playerButton;
	lineSaved=line;

	//Save the record
	savedRecordButton=recordButton;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog_saved=recordKeyPressLog;
	recordPlayerPosition_saved=recordPlayerPosition;
	#endif

	//To prevent playing the sound twice, only the player can cause the sound.
	if(!shadow)
	getSoundManager()->playSound("checkpoint");

	//We saved a new state so reset the counter
	loadAndDieTimes=0;
	}
	}

	void Player::loadState(){
	//Check with xVelSaved if there's a saved state.
	if(xVelSaved==int(0x80000000)){
	//There isn't so reset the game to load the first initial state.
	//NOTE: There's no need in removing the saved state since there is none.
	reset(false);
	return;
	}

	//Restore the saved values.
	box.x=boxSaved.x;
	box.y=boxSaved.y;
	//xVel is set to 0 since it's saved counterpart is used to indicate a saved state.
	xVel=0;
	yVel=yVelSaved;

	//Restore the saved values.
	inAir=inAirSaved;
	isJump=isJumpSaved;
	canMove=canMoveSaved;
	holdingOther=holdingOtherSaved;
	dead=false;
	record=false;
	shadowCall=false;
	state=stateSaved;

	objCurrentStand=objCurrentStandSave;
	objLastStand=objLastStandSave;

	//Restore the appearance.
	appearance.loadAnimation();

	//Restore any recorded stuff.
	record=recordSaved;
	playerButton=playerButtonSaved;
	line=lineSaved;

	//Load the previously saved record
	recordButton=savedRecordButton;
	#ifdef RECORD_FILE_DEBUG
	recordKeyPressLog=recordKeyPressLog_saved;
	recordPlayerPosition=recordPlayerPosition_saved;
	#endif
	}

	void Player::swapState(Player* other){
	//We need to swap the values of the player with the ones of the given player.
	swap(box.x,other->box.x);
	swap(box.y,other->box.y);
	swap(xVelBase, other->yVelBase);
	swap(yVelBase, other->yVelBase);
	swap(objCurrentStand, other->objCurrentStand);
	//NOTE: xVel isn't there since it's used for something else.
	swap(yVel,other->yVel);
	swap(inAir,other->inAir);
	swap(isJump,other->isJump);
	swap(canMove,other->canMove);
	swap(holdingOther,other->holdingOther);
	swap(dead, other->dead);

	//Also reset the state of the other.
	other->stateReset();

	//Play the swap sound.
	getSoundManager()->playSound("swap");

	//Update statistics.
	if(!dead && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	if(objParent->time < objParent->recentSwap + FPS){
	//Swap player and shadow twice in 1 senond.
	statsMgr.newAchievement("quickswap");
	}
	objParent->recentSwap=objParent->time;

	statsMgr.swapTimes++;

	//Update achievements
	switch(statsMgr.swapTimes){
	case 100:
	statsMgr.newAchievement("swap100");
	break;
	case 1000:
	statsMgr.newAchievement("swap1k");
	break;
	}
	}
	}

	bool Player::canSaveState(){
	//We can only save the state if the player isn't dead.
	return !dead;
	}

	bool Player::canLoadState(){
	//We use xVelSaved to indicate if a state is saved or not.
	return xVelSaved != int(0x80000000);
	}

	void Player::die(bool animation){
	//Make sure the player isn't already dead.
	if(!dead){
	dead=true;

	//If sound is enabled run the hit sound.
	getSoundManager()->playSound("hit");

	//Change the apearance to die (if animation is true).
	if(animation){
	if(direction==1){
	appearance.changeState("dieleft");
	}else{
	appearance.changeState("dieright");
	}
	}

	//Update statistics
	if(!objParent->player.isPlayFromRecord() && !objParent->interlevel){
	addRecentDeaths(objParent->recentLoad);

	if(shadow) statsMgr.shadowDies++;
	else statsMgr.playerDies++;

	switch(statsMgr.playerDies+statsMgr.shadowDies){
	case 1:
	statsMgr.newAchievement("die1");
	break;
	case 50:
	statsMgr.newAchievement("die50");
	break;
	case 1000:
	statsMgr.newAchievement("die1000");
	break;
	}

	if(canLoadState() && (++loadAndDieTimes)==100){
	statsMgr.newAchievement("loadAndDie100");
	}

	if(objParent->player.dead && objParent->shadow.dead) statsMgr.newAchievement("doubleKill");
	}
	}

	//We set the jumpTime to 80 when this is the shadow.
	//That's the countdown for the "Your shadow has died." message.
	if(shadow){
	jumpTime=80;
	}
	}
	diff --git a/src/ScriptAPI.cpp b/src/ScriptAPI.cpp
	index ec0d349..5e662b3 100644
	--- a/src/ScriptAPI.cpp
	+++ b/src/ScriptAPI.cpp
	@@ -1,1081 +1,1081 @@
	/*
	* Copyright (C) 2012-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 "ScriptAPI.h"
	#include "ScriptExecutor.h"
	#include "SoundManager.h"
	#include "Functions.h"
	#include "Game.h"
	#include "MusicManager.h"
	#include <iostream>
	using namespace std;

	///////////////////////////BLOCK SPECIFIC///////////////////////////
	int getBlockById(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getBlockById, expected 1.");
	lua_error(state);
	}
	//Make sure the given argument is an id (string).
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getBlockById, should be string.");
	lua_error(state);
	}

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Get the actual game object.
	string id=lua_tostring(state,1);
	std::vector<Block*>& levelObjects=game->levelObjects;
	Block* object=NULL;
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->getEditorProperty("id")==id){
	object=levelObjects[i];
	break;
	}
	}
	if(object==NULL){
	//Unable to find the requested object.
	//Return nothing, will result in a nil in the script.
	return 0;
	}

	//Create the userdatum.
	object->createUserData(state,"block");

	//We return one object, the userdatum.
	return 1;
	}

	int getBlocksById(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getBlocksById, expected 1.");
	lua_error(state);
	}
	//Make sure the given argument is an id (string).
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getBlocksById, should be string.");
	lua_error(state);
	}

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Get the actual game object.
	string id=lua_tostring(state,1);
	std::vector<Block*>& levelObjects=game->levelObjects;
	std::vector<Block*> result;
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->getEditorProperty("id")==id){
	result.push_back(levelObjects[i]);
	}
	}

	//Create the table that will hold the result.
	lua_createtable(state,result.size(),0);

	//Loop through the results.
	for(unsigned int i=0;i<result.size();i++){
	//Create the userdatum.
	result[i]->createUserData(state,"block");
	//And set the table.
	lua_rawseti(state,-2,i+1);
	}

	//We return one object, the userdatum.
	return 1;
	}

	int moveBlockTo(lua_State* state){
	//Check the number of arguments.
	int args=lua_gettop(state);

	//Make sure the number of arguments is correct.
	if(args!=3){
	lua_pushstring(state,"Incorrect number of arguments for moveBlockTo, expected 3.");
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of moveBlockTo.");
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of moveBlockTo, should be integer.");
	lua_error(state);
	}
	if(!lua_isnumber(state,3)){
	lua_pushstring(state,"Invalid type for argument 3 of moveBlockTo, should be integer.");
	lua_error(state);
	}

	//Now get the pointer to the object.
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	int x=lua_tonumber(state,2);
	int y=lua_tonumber(state,3);
	object->moveTo(x,y);

	return 0;
	}

	int getBlockLocation(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getBlockLocation, expected 1.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getBlockLocation.");
	lua_error(state);
	}
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	//Get the object.
	lua_pushnumber(state,object->getBox().x);
	lua_pushnumber(state,object->getBox().y);
	return 2;
	}

	int setBlockLocation(lua_State* state){
	//Check the number of arguments.
	int args=lua_gettop(state);

	//Make sure the number of arguments is correct.
	if(args!=3){
	lua_pushstring(state,"Incorrect number of arguments for setBlockLocation, expected 3.");
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setBlockLocation.");
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of setBlockLocation, should be integer.");
	lua_error(state);
	}
	if(!lua_isnumber(state,3)){
	lua_pushstring(state,"Invalid type for argument 3 of setBlockLocation, should be integer.");
	lua_error(state);
	}

	//Now get the pointer to the object.
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	int x=lua_tonumber(state,2);
	int y=lua_tonumber(state,3);
	object->setLocation(x,y);

	return 0;
	}

	int growBlockTo(lua_State* state){
	//Check the number of arguments.
	int args=lua_gettop(state);

	//Make sure the number of arguments is correct.
	if(args!=3){
	lua_pushstring(state,"Incorrect number of arguments for growBlockTo, expected 3.");
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of growBlockTo.");
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of growBlockTo, should be integer.");
	lua_error(state);
	}
	if(!lua_isnumber(state,3)){
	lua_pushstring(state,"Invalid type for argument 3 of growBlockTo, should be integer.");
	lua_error(state);
	}

	//Now get the pointer to the object.
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	int w=lua_tonumber(state,2);
	int h=lua_tonumber(state,3);
	object->growTo(w,h);

	return 0;
	}

	int getBlockSize(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getBlockSize, expected 1.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getBlockSize.");
	lua_error(state);
	}
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	//Get the object.
	lua_pushnumber(state,object->getBox().w);
	lua_pushnumber(state,object->getBox().h);
	return 2;
	}

	int setBlockSize(lua_State* state){
	//Check the number of arguments.
	int args=lua_gettop(state);

	//Make sure the number of arguments is correct.
	if(args!=3){
	lua_pushstring(state,"Incorrect number of arguments for setBlockSize, expected 3.");
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setBlockSize.");
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of setBlockSize, should be integer.");
	lua_error(state);
	}
	if(!lua_isnumber(state,3)){
	lua_pushstring(state,"Invalid type for argument 3 of setBlockSize, should be integer.");
	lua_error(state);
	}

	//Now get the pointer to the object.
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	int w=lua_tonumber(state,2);
	int h=lua_tonumber(state,3);
	object->setSize(w,h);

	return 0;
	}

	int getBlockType(lua_State* state){
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getBlockType, expected 1.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getBlockType.");
	lua_error(state);
	}
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL \|\| object->type<0 \|\| object->type>=TYPE_MAX) return 0;

	lua_pushstring(state,Game::blockName[object->type]);
	return 1;
	}

	int changeBlockThemeState(lua_State* state){
	int args=lua_gettop(state);
	if(args!=2){
	lua_pushstring(state,"Incorrect number of arguments for changeBlockThemeState, expected 2.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of changeBlockThemeState.");
	lua_error(state);
	}
	if(!lua_isstring(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of changeBlockThemeState, should be string.");
	lua_error(state);
	}
	Block* object = Block::getObjectFromUserData(state,1);
	object->appearance.changeState(lua_tostring(state,2));

	return 0;
	}

	-int setBlockEnabled(lua_State* state){
	+int setBlockVisible(lua_State* state){
	int args=lua_gettop(state);
	if(args!=2){
	lua_pushstring(state,"Incorrect number of arguments for setBlockEnabled, expected 2.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setBlockEnabled.");
	lua_error(state);
	}
	if(!lua_isboolean(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of setBlockEnabled, should be boolean.");
	lua_error(state);
	}

	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL)
	return 0;

	- bool enabled=lua_toboolean(state,2);
	- object->enabled=enabled;
	+ bool visible=lua_toboolean(state,2);
	+ object->visible=visible;

	return 0;
	}

	-int isBlockEnabled(lua_State* state){
	+int isBlockVisible(lua_State* state){
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for isBlockEnabled, expected 1.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of isBlockEnabled.");
	lua_error(state);
	}

	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL)
	return 0;

	- lua_pushboolean(state,object->enabled);
	+ lua_pushboolean(state,object->visible);
	return 1;
	}

	int getBlockEventHandler(lua_State* state){
	int args=lua_gettop(state);
	if(args!=2){
	lua_pushstring(state,"Incorrect number of arguments for getBlockEventHandler, expected 2.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getBlockEventHandler.");
	lua_error(state);
	}
	if(!lua_isstring(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of getBlockEventHandler, should be string.");
	lua_error(state);
	}

	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	//Check event type
	string eventType=lua_tostring(state,2);
	map<string,int>::iterator it=Game::gameObjectEventNameMap.find(eventType);
	if(it==Game::gameObjectEventNameMap.end()) return 0;

	//Check compiled script
	map<int,int>::iterator script=object->compiledScripts.find(it->second);
	if(script==object->compiledScripts.end()) return 0;

	//Get event handler
	lua_rawgeti(state,LUA_REGISTRYINDEX,script->second);
	return 1;
	}

	//It will return old event handler.
	int setBlockEventHandler(lua_State* state){
	int args=lua_gettop(state);
	if(args!=3){
	lua_pushstring(state,"Incorrect number of arguments for setBlockEventHandler, expected 3.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setBlockEventHandler.");
	lua_error(state);
	}
	if(!lua_isstring(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of setBlockEventHandler, should be string.");
	lua_error(state);
	}
	if(!lua_isfunction(state,3) && !lua_isnil(state,3)){
	lua_pushstring(state,"Invalid type for argument 3 of setBlockEventHandler, should be function.");
	lua_error(state);
	}

	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	//Check event type
	string eventType=lua_tostring(state,2);
	map<string,int>::const_iterator it=Game::gameObjectEventNameMap.find(eventType);
	if(it==Game::gameObjectEventNameMap.end()){
	lua_pushfstring(state,"Unknown block event type: '%s'.",eventType.c_str());
	lua_error(state);
	}

	//Check compiled script
	int scriptIndex=LUA_REFNIL;
	{
	map<int,int>::iterator script=object->compiledScripts.find(it->second);
	if(script!=object->compiledScripts.end()) scriptIndex=script->second;
	}

	//Set new event handler
	object->compiledScripts[it->second]=luaL_ref(state,LUA_REGISTRYINDEX);

	//Get old event handler and unreference it
	lua_rawgeti(state,LUA_REGISTRYINDEX,scriptIndex);
	luaL_unref(state,LUA_REGISTRYINDEX,scriptIndex);
	return 1;
	}

	//Array with the methods for the block library.
	static const struct luaL_Reg blocklib_m[]={
	{"getBlockById",getBlockById},
	{"getBlocksById",getBlocksById},
	{"moveTo",moveBlockTo},
	{"getLocation",getBlockLocation},
	{"setLocation",setBlockLocation},
	{"growTo",growBlockTo},
	{"getSize",getBlockSize},
	{"setSize",setBlockSize},
	{"getType",getBlockType},
	{"changeThemeState",changeBlockThemeState},
	- {"setEnabled",setBlockEnabled},
	- {"isEnabled",isBlockEnabled},
	+ {"setVisible",setBlockVisible},
	+ {"isVisible",isBlockVisible},
	{"getEventHandler",getBlockEventHandler},
	{"setEventHandler",setBlockEventHandler},
	{NULL,NULL}
	};

	int luaopen_block(lua_State* state){
	luaL_newlib(state,blocklib_m);

	//Create the metatable for the block userdata.
	luaL_newmetatable(state,"block");

	lua_pushstring(state,"__index");
	lua_pushvalue(state,-2);
	lua_settable(state,-3);

	Block::registerMetatableFunctions(state,-3);

	//Register the functions and methods.
	luaL_setfuncs(state,blocklib_m,0);
	return 1;
	}

	//////////////////////////PLAYER SPECIFIC///////////////////////////

	struct PlayerUserDatum{
	char sig1,sig2,sig3,sig4;
	};

	Player* getPlayerFromUserData(lua_State* state,int idx){
	PlayerUserDatum* ud=(PlayerUserDatum*)lua_touserdata(state,1);
	//Make sure the user datum isn't null.
	if(!ud) return NULL;

	//Get the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return NULL;

	Player* player=NULL;

	//Check the signature to see if it's the player or the shadow.
	if(ud->sig1=='P' && ud->sig2=='L' && ud->sig3=='Y' && ud->sig4=='R')
	player=&game->player;
	else if(ud->sig1=='S' && ud->sig2=='H' && ud->sig3=='D' && ud->sig4=='W')
	player=&game->shadow;

	return player;
	}


	int getPlayerLocation(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getPlayerLocation, expected 1.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getPlayerLocation.");
	lua_error(state);
	}

	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the object.
	lua_pushnumber(state,player->getBox().x);
	lua_pushnumber(state,player->getBox().y);
	return 2;
	}

	int setPlayerLocation(lua_State* state){
	//Make sure there are three arguments, userdatum and two integers.
	int args=lua_gettop(state);
	if(args!=3){
	lua_pushstring(state,"Incorrect number of arguments for setPlayerLocation, expected 3.");
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setPlayerLocation.");
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of setPlayerLocation, should be integer.");
	lua_error(state);
	}
	if(!lua_isnumber(state,3)){
	lua_pushstring(state,"Invalid type for argument 3 of setPlayerLocation, should be integer.");
	lua_error(state);
	}

	//Get the player.
	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the new location.
	int x=lua_tonumber(state,2);
	int y=lua_tonumber(state,3);
	player->setLocation(x,y);

	return 0;
	}

	int setPlayerJump(lua_State* state){
	//Make sure there are three arguments, userdatum and one integers.
	int args=lua_gettop(state);
	if(args!=1 && args!=2){
	lua_pushstring(state,"Incorrect number of arguments for setPlayerJump, expected 1 or 2.");
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setPlayerJump.");
	lua_error(state);
	}
	if(args==2 && !lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of setPlayerJump, should be integer.");
	lua_error(state);
	}

	//Get the player.
	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the new location.
	if(args==2){
	int yVel=lua_tonumber(state,2);
	player->jump(yVel);
	}else{
	//Use default jump strength.
	player->jump();
	}

	return 0;
	}

	int isPlayerShadow(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for isPlayerShadow, expected 1.");
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of isPlayerShadow.");
	lua_error(state);
	}

	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	lua_pushboolean(state,player->isShadow());
	return 1;
	}

	int getPlayerCurrentStand(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getPlayerCurrentStand, expected 1.");
	lua_error(state);
	}
	//Make sure the given argument is a player userdatum.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getPlayerCurrentStand.");
	lua_error(state);
	}

	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the actual game object.
	Block* object=player->getObjCurrentStand();
	if(object==NULL){
	return 0;
	}

	//Create the userdatum.
	object->createUserData(state,"block");

	//We return one object, the userdatum.
	return 1;
	}

	//Array with the methods for the player and shadow library.
	static const struct luaL_Reg playerlib_m[]={
	{"getLocation",getPlayerLocation},
	{"setLocation",setPlayerLocation},
	{"jump",setPlayerJump},
	{"isShadow",isPlayerShadow},
	{"getCurrentStand",getPlayerCurrentStand},
	{NULL,NULL}
	};

	int luaopen_player(lua_State* state){
	luaL_newlib(state,playerlib_m);

	//Create the metatable for the player userdata.
	luaL_newmetatable(state,"player");

	lua_pushstring(state,"__index");
	lua_pushvalue(state,-2);
	lua_settable(state,-3);

	//Now create two default player user data, one for the player and one for the shadow.
	PlayerUserDatum* ud=(PlayerUserDatum*)lua_newuserdata(state,sizeof(PlayerUserDatum));
	ud->sig1='P';ud->sig2='L';ud->sig3='Y';ud->sig4='R';
	luaL_getmetatable(state,"player");
	lua_setmetatable(state,-2);
	lua_setglobal(state,"player");

	ud=(PlayerUserDatum*)lua_newuserdata(state,sizeof(PlayerUserDatum));
	ud->sig1='S';ud->sig2='H';ud->sig3='D';ud->sig4='W';
	luaL_getmetatable(state,"player");
	lua_setmetatable(state,-2);
	lua_setglobal(state,"shadow");

	//Register the functions and methods.
	luaL_setfuncs(state,playerlib_m,0);
	return 1;
	}

	//////////////////////////LEVEL SPECIFIC///////////////////////////

	int getLevelSize(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Returns level size.
	lua_pushinteger(state,LEVEL_WIDTH);
	lua_pushinteger(state,LEVEL_HEIGHT);
	return 2;
	}

	int getLevelWidth(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Returns level size.
	lua_pushinteger(state,LEVEL_WIDTH);
	return 1;
	}

	int getLevelHeight(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Returns level size.
	lua_pushinteger(state,LEVEL_HEIGHT);
	return 1;
	}

	int getLevelName(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Returns level name.
	lua_pushstring(state,game->getLevelName().c_str());
	return 1;
	}

	int getLevelEventHandler(lua_State* state){
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for getLevelEventHandler, expected 1.");
	lua_error(state);
	}
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of getLevelEventHandler, should be string.");
	lua_error(state);
	}

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Check event type
	string eventType=lua_tostring(state,1);
	map<string,int>::iterator it=Game::levelEventNameMap.find(eventType);
	if(it==Game::levelEventNameMap.end()) return 0;

	//Check compiled script
	map<int,int>::iterator script=game->compiledScripts.find(it->second);
	if(script==game->compiledScripts.end()) return 0;

	//Get event handler
	lua_rawgeti(state,LUA_REGISTRYINDEX,script->second);
	return 1;
	}

	//It will return old event handler.
	int setLevelEventHandler(lua_State* state){
	int args=lua_gettop(state);
	if(args!=2){
	lua_pushstring(state,"Incorrect number of arguments for setLevelEventHandler, expected 2.");
	lua_error(state);
	}
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setLevelEventHandler, should be string.");
	lua_error(state);
	}
	if(!lua_isfunction(state,2) && !lua_isnil(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of setLevelEventHandler, should be function.");
	lua_error(state);
	}

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Check event type
	string eventType=lua_tostring(state,1);
	map<string,int>::const_iterator it=Game::levelEventNameMap.find(eventType);
	if(it==Game::levelEventNameMap.end()){
	lua_pushfstring(state,"Unknown level event type: '%s'.",eventType.c_str());
	lua_error(state);
	}

	//Check compiled script
	int scriptIndex=LUA_REFNIL;
	{
	map<int,int>::iterator script=game->compiledScripts.find(it->second);
	if(script!=game->compiledScripts.end()) scriptIndex=script->second;
	}

	//Set new event handler
	game->compiledScripts[it->second]=luaL_ref(state,LUA_REGISTRYINDEX);

	//Get old event handler and unreference it
	lua_rawgeti(state,LUA_REGISTRYINDEX,scriptIndex);
	luaL_unref(state,LUA_REGISTRYINDEX,scriptIndex);
	return 1;
	}

	int winGame(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Check if the currentState is the game state.
	if(stateID==STATE_LEVEL_EDITOR)
	return 0;
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	game->won=true;
	return 0;
	}

	int getGameTime(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Returns level size.
	lua_pushinteger(state,game->time);
	return 1;
	}

	int getGameRecordings(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Returns level size.
	lua_pushinteger(state,game->recordings);
	return 1;
	}

	//Array with the methods for the level library.
	static const struct luaL_Reg levellib_m[]={
	{"getSize",getLevelSize},
	{"getWidth",getLevelWidth},
	{"getHeight",getLevelHeight},
	{"getName",getLevelName},
	{"getEventHandler",getLevelEventHandler},
	{"setEventHandler",setLevelEventHandler},
	{"win",winGame},
	{"getTime",getGameTime},
	{"getRecordings",getGameRecordings},
	{NULL,NULL}
	};

	int luaopen_level(lua_State* state){
	luaL_newlib(state,levellib_m);

	//Register the functions and methods.
	luaL_setfuncs(state,levellib_m,0);
	return 1;
	}

	/////////////////////////CAMERA SPECIFIC///////////////////////////

	int setCameraMode(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for setCameraMode, expected 1.");
	lua_error(state);
	}
	//Make sure the given argument is a string.
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setCameraMode, should be string.");
	lua_error(state);
	}

	string mode=lua_tostring(state,1);

	//Get the game for setting the camera.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;
	//Check which mode.
	if(mode=="player"){
	game->cameraMode=Game::CAMERA_PLAYER;
	}else if(mode=="shadow"){
	game->cameraMode=Game::CAMERA_SHADOW;
	}else{
	//Unkown OR invalid camera mode.
	lua_pushfstring(state,"Unkown or invalid camera mode for setCameraMode: '%s'.",mode.c_str());
	lua_error(state);
	}

	//Returns nothing.
	return 0;
	}

	int cameraLookAt(lua_State* state){
	//Get the number of args, this MUST be two (x and y).
	int args=lua_gettop(state);
	if(args!=2){
	lua_pushstring(state,"Incorrect number of arguments for cameraLookAt, expected 2.");
	lua_error(state);
	}
	//Make sure the given arguments are integers.
	if(!lua_isnumber(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of cameraLookAt, should be integer.");
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of cameraLookAt, should be integer.");
	lua_error(state);
	}

	//Get the point.
	int x=lua_tonumber(state,1);
	int y=lua_tonumber(state,2);

	//Get the game for setting the camera.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;
	game->cameraMode=Game::CAMERA_CUSTOM;
	game->cameraTarget.x=x;
	game->cameraTarget.y=y;

	return 0;
	}

	//Array with the methods for the camera library.
	static const struct luaL_Reg cameralib_m[]={
	{"setMode",setCameraMode},
	{"lookAt",cameraLookAt},
	{NULL,NULL}
	};

	int luaopen_camera(lua_State* state){
	luaL_newlib(state,cameralib_m);

	//Register the functions and methods.
	luaL_setfuncs(state,cameralib_m,0);
	return 1;
	}

	/////////////////////////AUDIO SPECIFIC///////////////////////////

	int playSound(lua_State* state){
	//Get the number of args, this can be anything from one to three.
	int args=lua_gettop(state);
	if(args<1 \|\| args>3){
	lua_pushstring(state,"Incorrect number of arguments for playSound, expected 1-3.");
	lua_error(state);
	}
	//Make sure the first argument is a string.
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of playSound, should be string.");
	lua_error(state);
	}

	//Default values for concurrent and force.
	//See SoundManager.h
	int concurrent=1;
	bool force=false;

	//If there's a second one it should be an integer.
	if(args>1){
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of playSound, should be integer.");
	lua_error(state);
	}else{
	concurrent=lua_tonumber(state,2);
	}
	}
	//If there's a third one it should be a boolean.
	if(args>2){
	if(!lua_isboolean(state,3)){
	lua_pushstring(state,"Invalid type for argument 3 of playSound, should be boolean.");
	lua_error(state);
	}else{
	force=lua_toboolean(state,3);
	}
	}

	//Get the name of the sound.
	string sound=lua_tostring(state,1);
	//Try to play the sound.
	getSoundManager()->playSound(sound,concurrent,force);

	//Returns nothing.
	return 0;
	}

	int playMusic(lua_State* state){
	//Get the number of args, this can be either one or two.
	int args=lua_gettop(state);
	if(args<1 \|\| args>2){
	lua_pushstring(state,"Incorrect number of arguments for playMusic, expected 1 or 2.");
	lua_error(state);
	}
	//Make sure the first argument is a string.
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of playMusic, should be string.");
	lua_error(state);
	}

	//Default value of fade for playMusic.
	//See MusicManager.h.
	bool fade=true;

	//If there's a second one it should be a boolean.
	if(args>1){
	if(!lua_isboolean(state,2)){
	lua_pushstring(state,"Invalid type for argument 2 of playMusic, should be boolean.");
	lua_error(state);
	}else{
	fade=lua_toboolean(state,2);
	}
	}

	//Get the name of the music.
	string music=lua_tostring(state,1);
	//Try to switch to the new music.
	getMusicManager()->playMusic(music,fade);

	//Returns nothing.
	return 0;
	}

	int pickMusic(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Let the music manager pick a song from the current music list.
	getMusicManager()->pickMusic();
	return 0;
	}

	int setMusicList(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,"Incorrect number of arguments for setMusicList, expected 1.");
	lua_error(state);
	}
	//Make sure the given argument is a string.
	if(!lua_isstring(state,1)){
	lua_pushstring(state,"Invalid type for argument 1 of setMusicList, should be string.");
	lua_error(state);
	}

	//And set the music list in the music manager.
	string list=lua_tostring(state,1);
	getMusicManager()->setMusicList(list);
	return 0;
	}

	int getMusicList(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Return the name of the song (contains list prefix).
	lua_pushstring(state,getMusicManager()->getCurrentMusicList().c_str());
	return 1;
	}


	int currentMusicPlaying(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Return the name of the song (contains list prefix).
	lua_pushstring(state,getMusicManager()->getCurrentMusic().c_str());
	return 1;
	}

	//Array with the methods for the audio library.
	static const struct luaL_Reg audiolib_m[]={
	{"playSound",playSound},
	{"playMusic",playMusic},
	{"pickMusic",pickMusic},
	{"setMusicList",setMusicList},
	{"getMusicList",getMusicList},
	{"currentMusic",currentMusicPlaying},
	{NULL,NULL}
	};

	int luaopen_audio(lua_State* state){
	luaL_newlib(state,audiolib_m);

	//Register the functions and methods.
	luaL_setfuncs(state,audiolib_m,0);
	return 1;
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 1:08 AM (2 w, 23 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 70176
Default Alt Text: (285 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions