No OneTemporary
Actions

Authored By

Unknown

Size

1 MB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.travis.yml b/.travis.yml.backup
	similarity index 100%
	rename from .travis.yml
	rename to .travis.yml.backup
	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 6321d9d..e5c7fab 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,185 +1,193 @@
	Project (meandmyshadow)
	CMake_Minimum_Required (VERSION 3.1)
	Set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")

	#Path options
	Set (BINDIR "bin" CACHE STRING "Where to install binaries")
	Set (DATAROOTDIR "${CMAKE_INSTALL_PREFIX}/share" CACHE STRING "Sets the root of data directories to a non-default location")
	Set (ICONDIR "${DATAROOTDIR}/icons" CACHE STRING "Sets the icon directory for desktop entry to a non-default location.")
	Set (DESKTOPDIR "${DATAROOTDIR}/applications" CACHE STRING "Sets the desktop file directory for desktop entry to a non-default location.")

	#Options
	Option (DEBUG_MODE "Compile the game with debug mode enabled" OFF)
	Option (DISABLED_DEBUG_STUFF "Enable this you'll see a lot of annoying script debug messages which will lag the game." OFF)

	#Find the required libraries.
	Find_Package (SDL2 REQUIRED)
	Find_Package (SDL2_image REQUIRED)
	-Find_Package (SDL2_ttf REQUIRED)
	+Find_Package (Freetype REQUIRED)
	Find_Package (SDL2_mixer REQUIRED)
	Find_Package (CURL REQUIRED)
	Find_Package (LibArchive REQUIRED)
	-Find_Package (Lua REQUIRED)
	+Find_Package (Lua 5.3 REQUIRED)

	if (NOT SDL2_FOUND)
	message (FATAL_ERROR "SDL2 library could not be found!")
	endif (NOT SDL2_FOUND)

	if (NOT SDL2_IMAGE_FOUND)
	message (FATAL_ERROR "SDL2_image library could not be found!")
	endif (NOT SDL2_IMAGE_FOUND)

	-if (NOT SDL2_TTF_FOUND)
	- message (FATAL_ERROR "SDL2_ttf library could not be found!")
	-endif (NOT SDL2_TTF_FOUND)
	+if (NOT FREETYPE_FOUND)
	+ message (FATAL_ERROR "Freetype library could not be found!")
	+endif (NOT FREETYPE_FOUND)

	if (NOT SDL2_MIXER_FOUND)
	message (FATAL_ERROR "SDL2_mixer library could not be found!")
	endif (NOT SDL2_MIXER_FOUND)

	if (NOT CURL_FOUND)
	message(FATAL_ERROR "CURL library could not be found!")
	endif (NOT CURL_FOUND)

	if (NOT LibArchive_FOUND)
	message (FATAL_ERROR "LibArchive library could not be found!")
	endif (NOT LibArchive_FOUND)

	if (NOT LUA_FOUND)
	message (FATAL_ERROR "Lua library could not be found!")
	endif (NOT LUA_FOUND)

	-if (LUA_VERSION_STRING VERSION_LESS "5.2")
	- message (FATAL_ERROR "Lua version too old ${LUA_VERSION_STRING}, expected at least 5.2!")
	+if (LUA_VERSION_STRING VERSION_LESS "5.3")
	+ message (FATAL_ERROR "Lua version too old ${LUA_VERSION_STRING}, expected at least 5.3!")
	endif ()

	# check version from Globals.h
	file(READ "${PROJECT_SOURCE_DIR}/src/Globals.h" GLOBALS_H)
	string(REGEX MATCH "version[ ]=[ ]\"[^\"]*\"" MNMS_VERSION_STR ${GLOBALS_H})
	string(REGEX REPLACE "^[^\"]\"([^\"])\".*$" "\\1" MNMS_VERSION_STR ${MNMS_VERSION_STR})
	message(STATUS "The version read from Globals.h is: ${MNMS_VERSION_STR}")

	string(REGEX REPLACE "^V([0-9.]+).*$" "\\1" MNMS_VERSION_NUM ${MNMS_VERSION_STR})
	set(MNMS_VERSION_NUM "${MNMS_VERSION_NUM}.0.0.0.0")
	string(REGEX REPLACE "^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+).*$" "\\1,\\2,\\3,\\4" MNMS_VERSION_NUM ${MNMS_VERSION_NUM})
	message(STATUS "which is: ${MNMS_VERSION_NUM}")

	# check version from git
	find_package(Git)
	if(GIT_FOUND)
	- exec_program(${GIT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR} ARGS "describe"
	+ exec_program(${GIT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR} ARGS "describe --tags"
	OUTPUT_VARIABLE MNMS_GIT_VERSION RETURN_VALUE GIT_RETURN_VALUE)
	if(GIT_RETURN_VALUE STREQUAL "0")
	set(MNMS_VERSION_STR "${MNMS_VERSION_STR} (${MNMS_GIT_VERSION})")
	message(STATUS "The version read from git is: ${MNMS_GIT_VERSION}")
	else()
	# possibly there are no any tags
	exec_program(${GIT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR} ARGS "rev-parse --short HEAD"
	OUTPUT_VARIABLE MNMS_GIT_VERSION RETURN_VALUE GIT_RETURN_VALUE)
	if(GIT_RETURN_VALUE STREQUAL "0")
	set(MNMS_VERSION_STR "${MNMS_VERSION_STR} (git ${MNMS_GIT_VERSION})")
	message(STATUS "The version read from git is: ${MNMS_GIT_VERSION}")
	endif()
	endif()
	endif()

	# show version information on Windows
	Set(WIN32_RESOURCES )
	if(WIN32)
	Configure_File (
	"${PROJECT_SOURCE_DIR}/icons/windows-icon/res.rc.in"
	"${PROJECT_BINARY_DIR}/res.rc"
	)
	Set(WIN32_RESOURCES ${PROJECT_BINARY_DIR}/res.rc)
	Include_Directories(${PROJECT_SOURCE_DIR}/icons/windows-icon/)
	SOURCE_GROUP("Source Files\\Resources" FILES ${WIN32_RESOURCES})
	endif()

	#Parse the configure file.
	Configure_File (
	"${PROJECT_SOURCE_DIR}/src/config.h.in"
	"${PROJECT_BINARY_DIR}/config.h"
	)

	#Add some missing libraries to Windows.
	if(WIN32)
	include_directories(${PROJECT_SOURCE_DIR}/src/libs/dirent)
	endif(WIN32)

	#Disable some annoying warnings.
	if(MSVC)
	# warning C4996: '***': This function or variable may be unsafe
	add_definitions(/wd4996)
	+
	+ # force the source code encoding to UTF-8 (which is available since VC2015)
	+ if (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0))
	+ add_definitions(-utf-8)
	+ endif()
	else()
	# Assume it's gcc or clang
	# warning: '***' overrides a member function but is not marked 'override'
	add_definitions(-Wno-inconsistent-missing-override)
	endif()

	#Define some debug stuff.
	if(DEBUG_MODE)
	add_definitions(-DDEBUG)
	add_definitions(-D_DEBUG)
	endif(DEBUG_MODE)
	if(DISABLED_DEBUG_STUFF)
	add_definitions(-DDISABLED_DEBUG_STUFF)
	endif(DISABLED_DEBUG_STUFF)

	#Add the include directories of the (found) libraries.
	Include_Directories(
	${PROJECT_BINARY_DIR}
	${SDL2_INCLUDE_DIR}
	${SDL2_IMAGE_INCLUDE_DIR}
	- ${SDL2_TTF_INCLUDE_DIR}
	+ ${FREETYPE_INCLUDE_DIRS}
	${SDL2_MIXER_INCLUDE_DIR}
	${CURL_INCLUDE_DIR}
	${LibArchive_INCLUDE_DIR}
	${LUA_INCLUDE_DIR}
	${PROJECT_SOURCE_DIR}/src/libs
	+ ${PROJECT_SOURCE_DIR}/src/libs/SDL2_ttf
	)

	#Set the output path and the source path.
	Set (EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR})
	Set (SRC_DIR ${PROJECT_SOURCE_DIR}/src)

	#List the source files.
	File (GLOB SOURCES ${SRC_DIR}/*.cpp)
	File (GLOB TINYFORMAT ${SRC_DIR}/libs/tinyformat/*.cpp)
	File (GLOB TINYGETTEXT ${SRC_DIR}/libs/tinygettext/*.cpp)
	File (GLOB FINDLOCALE ${SRC_DIR}/libs/findlocale/*.cpp)
	+File (GLOB SDL2TTF ${SRC_DIR}/libs/SDL2_ttf/*.c)

	#Always use SDL_iconv in tinygettext
	add_definitions(-DHAVE_SDL)

	SOURCE_GROUP("Source Files\\tinyformat" FILES ${TINYFORMAT})
	SOURCE_GROUP("Source Files\\tinygettext" FILES ${TINYGETTEXT})
	SOURCE_GROUP("Source Files\\findlocale" FILES ${FINDLOCALE})
	+SOURCE_GROUP("Source Files\\SDL2_ttf" FILES ${SDL2TTF})

	-Add_Executable (meandmyshadow ${SOURCES} ${TINYFORMAT} ${TINYGETTEXT} ${FINDLOCALE} ${WIN32_RESOURCES})
	+Add_Executable (meandmyshadow ${SOURCES} ${TINYFORMAT} ${TINYGETTEXT} ${FINDLOCALE} ${WIN32_RESOURCES} ${SDL2TTF})

	set_property(TARGET meandmyshadow PROPERTY CXX_STANDARD 11)

	Target_Link_Libraries (
	meandmyshadow
	${SDL2_LIBRARY}
	${SDL2_IMAGE_LIBRARY}
	- ${SDL2_TTF_LIBRARY}
	+ ${FREETYPE_LIBRARIES}
	${SDL2_MIXER_LIBRARY}
	${SDL2MAIN_LIBRARY}
	${CURL_LIBRARY}
	${LibArchive_LIBRARY}
	${LUA_LIBRARIES}
	)

	#Install locations
	Install (DIRECTORY ${PROJECT_SOURCE_DIR}/data DESTINATION ${DATAROOTDIR}/meandmyshadow/)
	Install (FILES AUTHORS DESTINATION ${DATAROOTDIR}/meandmyshadow/)
	Install (TARGETS meandmyshadow RUNTIME DESTINATION ${BINDIR})

	if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	Install (FILES meandmyshadow.desktop DESTINATION ${DESKTOPDIR})
	Install (FILES icons/16x16/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/16x16/apps/)
	Install (FILES icons/32x32/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/32x32/apps/)
	Install (FILES icons/48x48/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/48x48/apps/)
	Install (FILES icons/64x64/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/64x64/apps/)
	endif ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	diff --git a/appveyor.yml b/appveyor.yml.backup
	similarity index 100%
	rename from appveyor.yml
	rename to appveyor.yml.backup
	diff --git a/data/Credits.txt b/data/Credits.txt
	index 3695ab8..b2e29b8 100644
	--- a/data/Credits.txt
	+++ b/data/Credits.txt
	@@ -1,171 +1,171 @@
	The following list contains the data files in Me and My Shadow.
	It should contain all files with their correct attribution and license information.
	If something is missing please contact the developers.


	font/
	- Blokletters-Viltstift.ttf
	Name: Blokletters Viltstift
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: http://lefly.vepar.nl/
	- knewave.ttf
	License: Open Font License <http://scripts.sil.org/OFL>
	Attribution: Tyler Finck (http://www.sursly.com)
	- DroidSansFallback.ttf
	License: Apache License <http://www.apache.org/licenses/LICENSE-2.0>
	Source: http://www.droidfonts.com
	- - DejaVuSansMono.ttf and DejaVuSansCondensed-Oblique.ttf
	+ - DejaVuSansMono.ttf, DejaVuSansCondensed.ttf and DejaVuSansCondensed-Oblique.ttf
	License: <https://dejavu-fonts.github.io/License.html>
	Source: https://dejavu-fonts.github.io/


	gfx/menu/
	- clear-progress.png
	License: CC BY 3.0 <https://creativecommons.org/licenses/by/3.0/>
	Attribution: Tedium
	- credits.png
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	- moving.png
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	- questionmark.png
	License: GNU LGPL <https://www.gnu.org/licenses/lgpl>
	Source: Wine <https://www.winehq.org/>
	Note: Modified by acme_pjz
	- selection.png
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	- statistics.png
	License: CC BY 3.0 <https://creativecommons.org/licenses/by/3.0/>
	Attribution: odamite
	- title.png
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	- toolbar.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: odamite, Tedium
	Undo and redo icon in this file is copied from Inkscape icon
	License: GNU GPL v2.0 or later <https://www.gnu.org/licenses/gpl>
	Source: Inkscape <https://inkscape.org/>


	gfx/achievements
	- *.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Wuzzy
	Note: Contains work from the Cloudscape theme.
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Note: Contains work from Openclipart <https://openclipart.org/>
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>


	gfx/
	- actions.png
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	- addon0.png
	License: CC BY-SA 4.0 <https://creativecommons.org/licenses/by-sa/4.0/>
	Attribution: hellcp
	Website: https://forum.freegamedev.net/viewtopic.php?f=17&t=7974#p77218
	Note: Modified by acme_pjz
	- addon1.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium
	Note: Contains work from the Cloudscape theme.
	- addon2.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium
	Note: Contains work from the Cloudscape theme.
	- addon3.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium
	Note: Contains work from the Cloudscape theme.
	- dropshadow.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Me and My Shadow <http://meandmyshadow.sf.net>
	- emotions.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium, acme_pjz
	Note: Another programmer art
	- gui.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Me and My Shadow <http://meandmyshadow.sf.net>
	Note: contains work by Wuzzy
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	- medals.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium
	- playbutton.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium
	- recordings.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium
	- screenshot.png
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	Note: Made using the knewave font.
	- time.png
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Tedium


	levelpacks/
	Note that the translations inside the levelpacks are all licensed under the GNU GPLv3.
	For the copyright notice(s) of the individual translations see the relevant .po file's header.
	- classic/
	License: GPLv3 <https://www.gnu.org/licenses/gpl>
	Copyright: 2011 Luka Horvat
	Copyright: 2011-2012 Me and My Shadow
	Note: Levels originally made by Luka Horvat and extended and updated by Me and My Shadow.
	- default/
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	- tutorial/
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>


	levels/
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	Note: All single levels distributed with Me and My Shadow are public domain.


	locale/
	For the copyright notice(s) of the translations see the header of the relevant .po file.
	- messages.pot
	License: GPLv3 <https://www.gnu.org/licenses/gpl>
	Copyright: 2012 Me and My Shadow <http://meandmyshadow.sf.net>


	music/
	See the header of the .music files for the license and attribution of the music files.


	sfx/
	- achievement.ogg
	Name: UI Sound effects pack
	License: CC BY 3.0 <https://creativecommons.org/licenses/by/3.0/>
	Attribution: David McKee (ViRiX) soundcloud.com/virix
	Source: https://opengameart.org/content/ui-sound-effects-pack
	- checkpoint.wav
	License: GNU GPL <https://www.gnu.org/licenses/gpl>
	Copyright: XMoto <https://xmoto.tuxfamily.org>
	- collect.wav
	License: CC BY 3.0 <https://creativecommons.org/licenses/by/3.0/>
	Attribution: odamite
	- error.wav
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	Source: https://opengameart.org/content/skweaks
	Note: converted to .wav
	- hit.wav
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	Note: Made with sfxr <http://www.drpetter.se/project_sfxr.html>
	- jump.wav
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	Note: Made with sfxr <http://www.drpetter.se/project_sfxr.html>
	- swap.wav
	Name: Ambient Pulse Noise
	License: CC BY-SA 3.0 <https://creativecommons.org/licenses/by-sa/3.0/>
	Attribution: Gobusto
	Source: https://opengameart.org/content/ambient-pulse-noise
	- toggle.wav
	License: CC0 <https://creativecommons.org/publicdomain/zero/1.0/>
	Source: https://www.opengameart.org/content/hit-sounds


	themes/
	See the individual themes for their license(s).
	diff --git a/data/font/DejaVuSansCondensed.ttf b/data/font/DejaVuSansCondensed.ttf
	new file mode 100644
	index 0000000..3259bc2
	Binary files /dev/null and b/data/font/DejaVuSansCondensed.ttf differ
	diff --git a/data/font/fonts.list b/data/font/fonts.list
	new file mode 100644
	index 0000000..51f7ac2
	--- /dev/null
	+++ b/data/font/fonts.list
	@@ -0,0 +1,48 @@
	+# This file contains the list of fonts used in the game.
	+# Currently, this file MUST contains the following fonts:
	+#
	+# fontTitle, fontGUI, fontGUISmall, fontText, fontMono, fontArrow.
	+#
	+# Each font is a node of the following form:
	+#
	+# font(<name>,<file name>,<font size>) { ... }
	+#
	+# There can be optional subnodes of font fallback:
	+#
	+# fallback(<file name>,[<font size>]) // if the size is omitted the main font size will be used
	+# or fallback(<file name>,relative,<relative size>) // add the relative size to font size
	+# or fallback(<file name>,scale,<scale>) // multiply the scale to font size
	+#
	+# If the file name doesn't have an extension, the ".ttf" will be added as extension.
	+
	+font(fontTitle,knewave,55){
	+ fallback("DejaVuSansCondensed-Oblique")
	+ fallback(DejaVuSansCondensed)
	+ fallback(DroidSansFallback)
	+}
	+
	+font(fontGUI,knewave,32){
	+ fallback("DejaVuSansCondensed-Oblique")
	+ fallback(DejaVuSansCondensed)
	+ fallback(DroidSansFallback)
	+}
	+
	+font(fontGUISmall,knewave,24){
	+ fallback("DejaVuSansCondensed-Oblique")
	+ fallback(DejaVuSansCondensed)
	+ fallback(DroidSansFallback)
	+}
	+
	+font(fontText,"Blokletters-Viltstift",16){
	+ fallback("DejaVuSansCondensed-Oblique",scale,1.15)
	+ fallback(DejaVuSansCondensed,scale,1.15)
	+ fallback(DroidSansFallback,scale,1.15)
	+}
	+
	+font(fontMono,DejaVuSansMono,12){
	+ fallback(DejaVuSansCondensed)
	+ fallback(DroidSansFallback)
	+}
	+
	+font(fontArrow,knewave,18){
	+}
	diff --git a/data/levelpacks/classic/Control.map b/data/levelpacks/classic/Control.map
	index e77fab1..8abfbbe 100644
	--- a/data/levelpacks/classic/Control.map
	+++ b/data/levelpacks/classic/Control.map
	@@ -1,43 +1,44 @@
	"name"="Control"
	"size"="900","600"
	time=280
	recordings=1
	"tile"("ShadowBlock","0","150")
	"tile"("ShadowBlock","100","150")
	"tile"("ShadowBlock","200","150")
	"tile"("ShadowBlock","300","150")
	"tile"("ShadowBlock","400","150")
	"tile"("ShadowBlock","500","150")
	+"tile"("ShadowBlock","0","200")
	"tile"("Spikes","150","150")
	"tile"("Spikes","250","150")
	"tile"("Spikes","350","150")
	"tile"("Spikes","450","150")
	"tile"("Block","0","250")
	"tile"("Block","50","250")
	"tile"("Block","100","250")
	"tile"("Block","150","250")
	"tile"("Block","200","250")
	"tile"("Block","250","250")
	"tile"("Block","300","250")
	"tile"("Block","300","250")
	"tile"("Block","350","250")
	"tile"("Block","400","250")
	"tile"("Block","400","250")
	"tile"("Block","450","250")
	"tile"("Block","500","250")
	"tile"("ShadowStart","0","100")
	"tile"("PlayerStart","0","200")
	"tile"("Block","550","250")
	"tile"("Block","600","250")
	"tile"("Block","650","250")
	"tile"("Block","700","200")
	"tile"("Block","700","150")
	"tile"("Block","750","150")
	"tile"("Block","800","150")
	"tile"("Exit","800","100")
	"tile"("Block","850","150")
	"tile"("Block","850","100")
	"tile"("Block","850","150")
	"tile"("Block","850","50")
	"tile"("Block","850","0")
	"tile"("ShadowBlock","50","150")
	diff --git a/data/levelpacks/tutorial/tut01.map b/data/levelpacks/tutorial/tut01.map
	index 5e854e7..6631182 100755
	--- a/data/levelpacks/tutorial/tut01.map
	+++ b/data/levelpacks/tutorial/tut01.map
	@@ -1,20 +1,20 @@
	name="Walk in the park"
	recordings=0
	size=800,600
	time=60
	tile(Block,150,300)
	tile(Block,200,300)
	tile(Block,250,300)
	tile(Block,300,300)
	tile(Block,350,300)
	tile(Block,400,300)
	tile(Block,450,300)
	tile(Block,500,300)
	tile(Block,550,300)
	tile(Block,600,300)
	tile(ShadowStart,200,250)
	tile(PlayerStart,250,250)
	tile(NotificationBlock,300,250){
	- message="Welcome to Me and My Shadow.\nYou can use the arrow keys to walk to the exit.\n\nGood luck!"
	+ message="Welcome to Me and My Shadow.\nYou can use the {{{key_left}}} key\nand {{{key_right}}} key to walk to the exit.\n\nGood luck!"
	}
	tile(Exit,550,250)
	diff --git a/data/levelpacks/tutorial/tut02.map b/data/levelpacks/tutorial/tut02.map
	index ca81650..cfcf200 100755
	--- a/data/levelpacks/tutorial/tut02.map
	+++ b/data/levelpacks/tutorial/tut02.map
	@@ -1,23 +1,23 @@
	name="First jumps"
	size=800,600
	time=80
	recordings=0
	tile(Block,150,300)
	tile(Block,200,300)
	tile(Block,300,300)
	tile(Block,350,300)
	tile(Block,400,300)
	tile(Block,450,300)
	tile(Block,500,300)
	tile(Block,600,300)
	tile(Block,550,300)
	tile(Block,250,300)
	tile(ShadowStart,200,250)
	tile(PlayerStart,250,250)
	tile(NotificationBlock,300,250){
	- message="You can jump using the up key.\nTry jumping over these blocks."
	+ message="You can jump using the {{{key_jump}}} key.\nTry jumping over these blocks."
	}
	tile(Block,450,250)
	tile(Block,400,250)
	tile(Exit,550,250)
	tile(Block,450,200)
	diff --git a/data/levelpacks/tutorial/tut05.map b/data/levelpacks/tutorial/tut05.map
	index eb5f4f5..c1d19bc 100755
	--- a/data/levelpacks/tutorial/tut05.map
	+++ b/data/levelpacks/tutorial/tut05.map
	@@ -1,33 +1,33 @@
	name=Shadow
	size=800,600
	time=120
	recordings=1
	tile(Block,150,300)
	tile(Block,200,300)
	tile(Block,250,300)
	tile(Block,350,300)
	tile(Block,400,300)
	tile(Block,450,300)
	tile(Block,500,300)
	tile(Block,300,300)
	tile(Block,550,300)
	tile(Block,600,300)
	tile(Exit,550,100)
	tile(ShadowStart,200,100)
	tile(PlayerStart,200,250)
	tile(Block,150,150)
	tile(Block,200,150)
	tile(Block,250,150)
	tile(Block,300,150)
	tile(Block,350,150)
	tile(Block,400,150)
	tile(Block,450,150)
	tile(Block,550,150)
	tile(Block,500,150)
	tile(Block,600,150)
	tile(NotificationBlock,250,250){
	- message="You can't reach the exit, but your shadow can.\nPress space to record your moves.\nPress space once again to let your shadow\nmimic your recording."
	+ message="You can't reach the exit, but your shadow can.\nPress {{{key_space}}} to record your moves.\nPress {{{key_space}}} once again to let your shadow\nmimic your recording."
	}
	tile(NotificationBlock,550,250){
	message="TIP:\nThink what moves your shadow has to make.\nThen let your character record those moves.\nYou can break it down into smaller recordings."
	}
	diff --git a/data/levelpacks/tutorial/tut07.map b/data/levelpacks/tutorial/tut07.map
	index b9b3c4a..26c73a9 100755
	--- a/data/levelpacks/tutorial/tut07.map
	+++ b/data/levelpacks/tutorial/tut07.map
	@@ -1,34 +1,34 @@
	name="Shadow challenge"
	size=800,600
	time=120
	recordings=1
	tile(Block,150,300)
	tile(Block,200,300)
	tile(Block,250,300)
	tile(Block,300,300)
	tile(Block,350,300)
	tile(Block,400,300)
	tile(Block,450,300)
	tile(Block,500,300)
	tile(Block,550,300)
	tile(Block,600,300)
	tile(Exit,550,100)
	tile(ShadowStart,200,100)
	tile(PlayerStart,200,250)
	tile(NotificationBlock,250,250){
	message="Spikes are not only deadly for you,\nbut also for your shadow."
	}
	tile(Spikes,400,100)
	tile(ShadowBlock,150,150)
	tile(ShadowBlock,200,150)
	tile(ShadowBlock,250,150)
	tile(ShadowBlock,350,150)
	tile(ShadowBlock,300,150)
	tile(ShadowBlock,400,150)
	tile(ShadowBlock,450,150)
	tile(ShadowBlock,500,150)
	tile(ShadowBlock,550,150)
	tile(ShadowBlock,600,150)
	tile(NotificationBlock,550,250){
	- message="If your shadow dies you'll have to restart.\nRestart the game by pressing the 'R' key."
	+ message="If your shadow dies you'll have to restart.\nRestart the game by pressing the {{{key_restart}}} key."
	}
	diff --git a/data/levelpacks/tutorial/tut10.map b/data/levelpacks/tutorial/tut10.map
	index e81924d..0d7954f 100755
	--- a/data/levelpacks/tutorial/tut10.map
	+++ b/data/levelpacks/tutorial/tut10.map
	@@ -1,71 +1,71 @@
	name=Checkpoints
	recordings=1
	size=2900,600
	time=260
	tile(Block,150,300)
	tile(Block,200,300)
	tile(Block,250,300)
	tile(Block,300,300)
	tile(Block,350,300)
	tile(Block,400,300)
	tile(Block,450,350)
	tile(Block,950,450)
	tile(Block,1000,300)
	tile(Block,1050,300)
	tile(Exit,2650,150)
	tile(ShadowStart,200,250)
	tile(PlayerStart,250,250)
	tile(NotificationBlock,300,250){
	- message="You can save your progress in a level with\ncheckpoints. You can restore them at any\ntime using the F3 button."
	+ message="You can save your progress in a level with\ncheckpoints. You can restore them at any\ntime using the {{{key_load}}} key."
	}
	tile(Block,500,350)
	tile(Block,650,350)
	tile(Block,750,350)
	tile(Block,700,350)
	tile(Block,850,450)
	tile(Block,800,250)
	tile(Block,850,250)
	tile(Block,900,250)
	tile(Block,900,450)
	tile(Checkpoint,500,150)
	tile(NotificationBlock,450,150){
	message="Save your progress here."
	}
	tile(Block,450,200)
	tile(Block,500,200)
	tile(Block,550,200)
	tile(Block,400,200)
	tile(Block,1050,500)
	tile(Block,1150,500)
	tile(Block,1100,500)
	tile(Block,1100,300)
	tile(Block,1200,250)
	tile(Block,1250,250)
	tile(Block,1300,250)
	tile(NotificationBlock,1250,200){
	message="You've chosen the right way."
	}
	tile(Teleporter,1300,200){
	automatic=0
	destination=4
	id=1
	}
	tile(NotificationBlock,1100,450){
	- message="This is the wrong way.\nGo back to the previous checkpoint by pressing F3."
	+ message="This is the wrong way.\nGo back to the previous checkpoint by pressing {{{key_load}}}."
	}
	tile(Teleporter,1150,450){
	automatic=0
	id=3
	}
	tile(Block,2600,250)
	tile(Block,2650,250)
	tile(Block,2700,250)
	tile(Block,2550,250)
	tile(Teleporter,2600,200){
	automatic=0
	destination=1
	id=4
	}
	tile(Block,2650,200)
	tile(Block,550,150)
	tile(Block,550,100)
	diff --git a/data/levelpacks/tutorial/tut18.map b/data/levelpacks/tutorial/tut18.map
	index c1b253d..0f8e1d1 100755
	--- a/data/levelpacks/tutorial/tut18.map
	+++ b/data/levelpacks/tutorial/tut18.map
	@@ -1,66 +1,66 @@
	name="Stop trigger"
	size=1150,600
	time=410
	recordings=0
	tile(Block,150,300)
	tile(Block,200,300)
	tile(Block,250,300)
	tile(Block,300,300)
	tile(Block,350,300)
	tile(Block,400,300)
	tile(ShadowStart,200,250)
	tile(PlayerStart,250,250)
	tile(NotificationBlock,300,250){
	- message="This trigger will deactivate the moving block.\nTry to stop it at the right moment.\nYou can only do this once, so if it fails you'll\nhave to reset the level with the 'R' key."
	+ message="This trigger will deactivate the moving block.\nTry to stop it at the right moment.\nYou can only do this once, so if it fails you'll\nhave to reset the level with the {{{key_restart}}} key."
	}
	tile(ConveyorBelt,500,300){
	disabled=0
	speed=-5
	}
	tile(Block,850,300)
	tile(Exit,900,250)
	tile(ConveyorBelt,550,300){
	disabled=0
	speed=-5
	}
	tile(ConveyorBelt,600,300){
	disabled=0
	speed=-5
	}
	tile(ConveyorBelt,650,300){
	disabled=0
	speed=-5
	}
	tile(ConveyorBelt,700,300){
	disabled=0
	speed=-5
	}
	tile(MovingBlock,800,250){
	MovingPosCount=2
	disabled=0
	id=8
	loop=1
	t0=120
	t1=120
	x0=-300
	x1=0
	y0=0
	y1=0
	}
	tile(ConveyorBelt,750,300){
	disabled=0
	speed=-5
	}
	tile(Spikes,500,200)
	tile(Spikes,550,200)
	tile(Spikes,600,200)
	tile(Spikes,650,200)
	tile(Spikes,700,200)
	tile(Switch,400,250){
	behaviour=off
	id=8
	}
	tile(Block,450,300)
	tile(Block,800,300)
	tile(Block,900,300)
	tile(Block,950,300)
	diff --git a/data/levelpacks/tutorial/tut19.map b/data/levelpacks/tutorial/tut19.map
	index 056293b..8c09a8f 100755
	--- a/data/levelpacks/tutorial/tut19.map
	+++ b/data/levelpacks/tutorial/tut19.map
	@@ -1,43 +1,43 @@
	name="First portals"
	recordings=0
	size=800,600
	time=100
	tile(Block,150,300)
	tile(Block,200,300)
	tile(Block,250,300)
	tile(Block,300,300)
	tile(Block,350,300)
	tile(Block,400,300)
	tile(Block,450,300)
	tile(Block,500,300)
	tile(Block,550,300)
	tile(Block,600,300)
	tile(ShadowStart,200,250)
	tile(PlayerStart,250,250)
	tile(Teleporter,550,250){
	automatic=0
	destination=2
	id=1
	}
	tile(Teleporter,200,100){
	automatic=1
	destination=1
	id=2
	}
	tile(Block,150,150)
	tile(Block,200,150)
	tile(Block,250,150)
	tile(Block,300,150)
	tile(Block,350,150)
	tile(Block,400,150)
	tile(Block,450,150)
	tile(Block,550,150)
	tile(Block,500,150)
	tile(Block,600,150)
	tile(Exit,550,100)
	tile(NotificationBlock,300,250){
	- message="Now it's time to check out the portals.\nTo get to the exit you'll have to take the portal.\nWalk to it and press the down arrow to\nactivate."
	+ message="Now it's time to check out the portals.\nTo get to the exit you'll have to take the portal.\nWalk to it and press the {{{key_action}}} key to\nactivate."
	}
	tile(NotificationBlock,300,100){
	- message="NOTE:\nYou can go back by entering this portal.\nIt is however a bit different, you don't have to\npress the down key, it will activate when you walk in it."
	+ message="NOTE:\nYou can go back by entering this portal.\nIt is however a bit different, you don't have to\npress the {{{key_action}}} key, it will activate when you walk in it."
	}
	diff --git a/data/levelpacks/tutorial/tut21.map b/data/levelpacks/tutorial/tut21.map
	index 62d27df..47fbfca 100755
	--- a/data/levelpacks/tutorial/tut21.map
	+++ b/data/levelpacks/tutorial/tut21.map
	@@ -1,50 +1,50 @@
	name=Swappoints
	recordings=1
	size=1100,700
	time=200
	tile(ShadowStart,350,250)
	tile(PlayerStart,350,450)
	tile(NotificationBlock,400,450){
	message="Now it's time for something completely\ndifferent: swappoints. When you or your\nshadow activate them you'll swap places."
	}
	tile(ShadowBlock,400,300)
	tile(ShadowBlock,450,300)
	tile(ShadowBlock,500,300)
	tile(ShadowBlock,550,300)
	tile(ShadowBlock,600,300)
	tile(ShadowBlock,650,300)
	tile(Block,700,300)
	tile(Block,350,500)
	tile(Block,400,500)
	tile(Block,450,500)
	tile(Block,500,500)
	tile(Block,550,500)
	tile(Block,600,500)
	tile(Block,650,500)
	tile(Block,700,500)
	tile(Block,750,450)
	tile(Block,750,350)
	tile(Block,750,400)
	tile(Block,750,300)
	tile(Block,800,300)
	tile(Block,850,300)
	tile(Block,900,300)
	tile(Swap,600,450)
	tile(ShadowBlock,750,250)
	tile(ShadowBlock,750,200)
	tile(ShadowBlock,750,150)
	tile(Exit,850,250)
	tile(ShadowBlock,350,300)
	tile(ShadowBlock,300,300)
	tile(ShadowBlock,200,300)
	tile(ShadowBlock,250,300)
	tile(Block,300,500)
	tile(Block,200,500)
	tile(Block,250,500)
	tile(Block,200,350)
	tile(Block,200,450)
	tile(Block,200,400)
	tile(Block,750,500)
	tile(NotificationBlock,700,450){
	- message="If your shadow falls down here you will have to restart.\nPress 'R' to restart the level."
	+ message="If your shadow falls down here you will have to restart.\nPress {{{key_restart}}} to restart the level."
	}
	diff --git a/data/levelpacks/tutorial/tut22.map b/data/levelpacks/tutorial/tut22.map
	index ef7f0df..c5ae3df 100755
	--- a/data/levelpacks/tutorial/tut22.map
	+++ b/data/levelpacks/tutorial/tut22.map
	@@ -1,42 +1,42 @@
	name="Shadow swap"
	size=950,650
	time=210
	recordings=1
	tile(Block,150,350)
	tile(Block,200,350)
	tile(Block,250,350)
	tile(Block,300,350)
	tile(Block,350,350)
	tile(Block,400,350)
	tile(Block,450,350)
	tile(Block,500,350)
	tile(Block,550,350)
	tile(Block,600,350)
	tile(Block,150,50)
	tile(Block,150,100)
	tile(Block,250,100)
	tile(Block,250,50)
	tile(ShadowStart,200,50)
	tile(PlayerStart,200,300)
	tile(NotificationBlock,250,300){
	message="You need your shadow to reach the exit.\nMake use of the swapper to get him down (or \nto get yourself down)."
	}
	tile(ShadowBlock,200,100)
	tile(ShadowBlock,350,300)
	tile(ShadowBlock,350,250)
	tile(ShadowBlock,400,250)
	tile(ShadowBlock,450,250)
	tile(ShadowBlock,450,300)
	tile(Swap,400,300)
	tile(Block,650,350)
	tile(NotificationBlock,550,300){
	- message="TIP:\nWhen your shadow is trapped stand on the\nright side of the shadow blocks. Now record \nthe down key and let your shadow mimic."
	+ message="TIP:\nWhen your shadow is trapped stand on the\nright side of the shadow blocks. Now record \nthe {{{key_action}}} key and let your shadow mimic."
	}
	tile(Block,650,300)
	tile(Block,650,250)
	tile(Exit,700,200)
	tile(Block,700,250)
	tile(Block,750,250)
	tile(Block,150,0)
	tile(Block,200,0)
	tile(Block,250,0)
	diff --git a/docs/ScriptAPI.md b/docs/ScriptAPI.md
	index ef2e840..8addc8d 100644
	--- a/docs/ScriptAPI.md
	+++ b/docs/ScriptAPI.md
	@@ -1,530 +1,754 @@
	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 empty space of the level and select "Scripting".

	Currently the scenery block doesn't support scripting.

	Available event types of block:

	Event type \| Description
	----------------------\|--------------
	"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.
	"onPlayerInteraction" \| Fired when the player press DOWN key. Currently this event only fires when the block type is TYPE_SWITCH.
	"onToggle" \| Fired when the block receives "toggle" from a switch/button. NOTE: The switch/button itself will also receive this event. This is used in an old example found on my old computer.
	"onSwitchOn" \| Fired when the block receives "switch on" from a switch/button. NOTE: The switch/button itself will also receive this event. This is used in an old example found on my old computer.
	"onSwitchOff" \| Fired when the block receives "switch off" from a switch/button. NOTE: The switch/button itself will also receive this event. This is used in an old example found on my old computer.

	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 its previous value.

	The block event may return an integer value (default is 0) to alter the game logic:

	Return value \| Description
	-------------\|--------------
	0 \| Skip the default game logic for this event.
	1 \| Do the default game logic for this event.

	Available event types of level:

	Event type \| Description
	-----------\|--------------
	"onCreate" \| Fired when the level is created or the game is reset. 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.

	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:

	~~~lua
	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:

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

	+* removeAll()
	+
	+Remove all blocks.
	+
	+* addBlock(string,[x],[y],[w],[h])
	+
	+Add a new block (optionally give it a new position and size) and return the newly created block.
	+
	+The `string` is the text representation of a block which is used in `.map` file.
	+
	+The new block can have scripts and the `onCreate` script will be executed immediately.
	+
	+Example:
	+
	+~~~lua
	+-- Assume we have moving blocks of id 1,
	+-- then this newly added switch can operate existing moving blocks.
	+block.addBlock([[
	+tile(Switch,0,0,50,50){
	+ behaviour=toggle
	+ id=1
	+ script(onCreate){
	+ script="print('Hello world from onCreate of dynamically added block')"
	+ }
	+}]],250,300)
	+~~~
	+
	+Another example:
	+
	+~~~lua
	+local b=block.addBlock('tile(MovingBlock,0,0)')
	+b:setBaseLocation(
	+ math.random()*level.getWidth(),
	+ math.random()*level.getHeight())
	+local bx,by=b:getBaseLocation()
	+for i=1,10 do
	+ b:addMovingPos({
	+ math.random()*level.getWidth()-bx,
	+ math.random()*level.getHeight()-by,
	+ math.random()*80+40
	+ })
	+end
	+b:addMovingPos({0,0,math.random()*80+40})
	+~~~
	+
	+* addBlocks(string,[positions]) / addBlocks(string,offsetX,offsetY)
	+
	+Add new blocks (optionally give them new positions and sizes) and return an array the newly created blocks.
	+
	+The `string` is the text representation of blocks which is used in `.map` file.
	+
	+In the first form,
	+If `string` contains only one block, then it will be created repeatedly using the specified positions.
	+If it contains more than one block, then each block will use corresponding position in `positions`.
	+The `positions` is an array of new positions whose entry is of format `{[x],[y],[w],[h]}`.
	+
	+In the second form,
	+the `string` can contain one or more blocks,
	+and the position of each block will be offset by two numbers `offsetX` and `offsetY`.
	+
	+The new blocks can have scripts and the `onCreate` script will be executed immediately.
	+
	### Member functions:

	* isValid() -- check the object is valid (i.e. not deleted, etc.)

	* moveTo(x,y)

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

	Example:

	~~~lua
	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().

	-* getBaseLocation()
	-
	-Returns the base position of the block. Mainly used for moving blocks.
	-
	* 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().

	+* getBaseLocation() / setBaseLocation(x,y)
	+
	+Get or set the base position of the block. Mainly used for moving blocks.
	+
	* 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:

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

	-* getBaseSize()
	-
	-Returns the base size of the block. Mainly used for moving blocks.
	-
	* setSize(w,h)

	Resize the block without updating the velocity of block.

	Example:

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

	+* getBaseSize() / setBaseSize(x,y)
	+
	+Get or set the base size of the block. Mainly used for moving blocks.
	+
	* getType()

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

	Example:

	~~~lua
	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:

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

	* setVisible(b)

	Set the visibility the block.

	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 (except for `onCreate`),
	can't be used as a portal destination,
	doesn't participate in collision check and game logic, etc...

	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:

	~~~lua
	local b=block.getBlockById("1")
	if b:isVisible() then
	b:setVisible(false)
	else
	b:setVisible(true)
	end
	~~~

	* isVisible()

	Returns whether the block is visible.

	Example: see the example for setVisible().

	* getEventHandler(event_type)

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

	Example:

	~~~lua
	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:

	~~~lua
	local b=block.getBlockById("1")
	b:setEventHandler("onSwitchOff",function()
	print("I am switched off.")
	end)
	~~~

	* onEvent(eventType)

	Fire an event to specified block.

	NOTE: The event will be processed immediately.

	Example:

	~~~lua
	local b=block.getBlockById("1")
	b:onEvent("onToggle")
	~~~

	NOTE: Be careful not to write infinite recursive code! Bad example:

	~~~lua
	-- onToggle event of a moving block
	this:onEvent("onToggle")
	~~~

	-* isActivated() / setActivated(bool) -- get/set a boolean indicates if the block is activated
	- -- the block should be one of TYPE_MOVING_BLOCK, TYPE_MOVING_SHADOW_BLOCK, TYPE_MOVING_SPIKES,
	- TYPE_CONVEYOR_BELT, TYPE_SHADOW_CONVEYOR_BELT.
	+* isActivated() / setActivated(bool)
	+
	+Get/set a boolean indicates if the block is activated.
	+
	+The block should be one of TYPE_MOVING_BLOCK, TYPE_MOVING_SHADOW_BLOCK, TYPE_MOVING_SPIKES,
	+TYPE_CONVEYOR_BELT, TYPE_SHADOW_CONVEYOR_BELT.
	+
	+* isAutomatic() / setAutomatic(bool)
	+
	+Get/set a boolean indicates if the portal is automatic.
	+
	+The block should be TYPE_PORTAL.
	+
	+* getBehavior() / setBehavior(str)
	+
	+Get/set a string (must be "on", "off" or "toggle"),
	+representing the behavior of the block.
	+
	+The block should be TYPE_BUTTON, TYPE_SWITCH.
	+
	+* getState() / setState(num)
	+
	+Get/set a number (must be 0,1,2 or 3),
	+representing the state of a fragile block.
	+
	+The block should be TYPE_FRAGILE.
	+
	+* isPlayerOn()
	+
	+Get a boolean indicates if the player is on.
	+
	+Currently only works for TYPE_BUTTON.
	+
	+* getPathMaxTime()
	+
	+Get the total time of the path of a moving block.
	+
	+* getPathTime() / setPathTime(num)
	+
	+Get/set the current time of the path of a moving block.
	+
	+* isLooping() / setLooping(bool)
	+
	+Get/set the looping property of a moving block.
	+
	+* getSpeed() / setSpeed(num)
	+
	+Get/set the speed of a conveyor belt.
	+
	+NOTE: 1 Speed = 0.08 block/s = 0.1 pixel/frame.
	+
	+* getAppearance() / setAppearance(str)

	-* isAutomatic() / setAutomatic(bool) -- get/set a boolean indicates if the portal is automatic
	- -- the block should be TYPE_PORTAL
	+Get/set the custom appearance of a block.

	-* getBehavior() / setBehavior(str) -- get/set a string (must be "on", "off" or "toggle")
	- representing the behavior of the block -- the block should be TYPE_BUTTON, TYPE_SWITCH
	+The `str` is the name of the custom appearance, either `"<blockName>_Scenery"` or name of a scenery block.
	+Empty string or nil means the default appearance.

	-* getState() / setState(num) -- get/set a number (must be 0,1,2 or 3)
	- representing the state of a fragile block -- the block should be TYPE_FRAGILE
	+* getId() / setId(str)

	-* isPlayerOn() -- get a boolean indicates if the player is on -- only works for TYPE_BUTTON
	+Get/set the id of a block.

	-* getPathMaxTime() -- get the total time of the path of a moving block
	+* getDestination() / setDestination(str)

	-* getPathTime() / setPathTime(num) -- get/set the current time of the path of a moving block
	+Get/set the destination of a portal.

	-* isLooping() / setLooping(bool) -- get/set the looping property of a moving block
	+The block should be TYPE_PORTAL.

	-* getSpeed() / setSpeed(num) -- get/set the speed of a conveyor belt. NOTE: 1 Speed = 0.08 block/s = 0.1 pixel/frame
	+* getMessage() / setMessage(str)
	+
	+Get/set the message of a notify block.
	+
	+The block should be TYPE_NOTIFICATION_BLOCK.
	+
	+* getMovingPosCount()
	+
	+Get the number of moving positions of a moving block.
	+
	+* getMovingPos() / getMovingPos(index) / getMovingPos(start, length)
	+
	+Get the array of moving positions or the moving position at specified index
	+(the array index starts with 1 in Lua).
	+
	+The individual point is of format `{x,y,t}`.
	+
	+* setMovingPos(array) / setMovingPos(index, point) / setMovingPos(start, length, array)
	+
	+Set the array of moving positions or modify the moving position at specified index
	+(the array index starts with 1 in Lua).
	+
	+NOTE: the last two forms won't change the number of points,
	+while the first form will overwrite the list of points completely.
	+
	+* addMovingPos(p) / addMovingPos(index, p)
	+
	+Insert points to the array of moving positions at the end or at the specified index.
	+
	+The `p` can be one point or a list of points.
	+
	+* removeMovingPos() / removeMovingPos(index) / removeMovingPos(listOfIndices) / removeMovingPos(start, length)
	+
	+Remove points in the array of moving positions: remove all points,
	+or remove a point at specified index, or remove points at specified indices,
	+or remove points in given range.
	+
	+* clone([x],[y],[w],[h])
	+
	+Create a clone of current block, optionally give it a new position and size.
	+
	+The new block can have scripts and the `onCreate` script will be executed immediately.
	+
	+Returns the newly created block.
	+
	+* cloneMultiple(number) / cloneMultiple(positions)
	+
	+Create multiple clones of current block, optionally give them new positions and sizes.
	+
	+The `number` is the number of clones to made, whose positions are the same as the source block,
	+whereas `positions` is an array of new positions whose entry is of format `{[x],[y],[w],[h]}`.
	+
	+The new blocks can have scripts and the `onCreate` script will be executed immediately.
	+
	+Returns an array of newly created blocks.
	+
	+* remove()
	+
	+Remove current block.

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

	### Global constants:

	* player

	The player object.

	* shadow

	The shadow object.

	### Member functions:

	* getLocation()

	Returns the location of player/shadow.

	Example:

	~~~lua
	local x,y=player:getLocation()
	print("player: "..x..","..y)
	x,y=shadow:getLocation()
	print("shadow: "..x..","..y)
	~~~

	* setLocation(x,y)

	Set the location of player/shadow.

	Example:

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

	* jump([strength=13])

	Let the player/shadow jump if it's allowed.

	strength: Jump strength.

	Example:

	~~~lua
	player:jump(20)
	~~~

	* isShadow()

	Returns whether the current object is shadow.

	Example:

	~~~lua
	print(player:isShadow())
	print(shadow:isShadow())
	~~~

	* getCurrentStand()

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

	Example:

	~~~lua
	local b=player:getCurrentStand()
	if b then
	print(b:getType())
	else
	print("The player is not standing on any blocks")
	end
	~~~

	* isInAir() -- returns a boolean indicating if the player is in air

	* canMove() -- returns a boolean indicating if the player can move (i.e. not standing on shadow)

	* isDead() -- returns a boolean indicating if the player is dead

	* isHoldingOther() -- returns a boolean indicating if the player is holding other

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

	### Static functions:

	* getSize() -- get the level size

	+* getRect() / setRect(x,y,w,h) -- get or set the level rect (left,top,width,height)
	+
	* 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

	* broadcastObjectEvent(eventType,[objectType=nil],[id=nil],[target=nil])

	Broadcast the event to blocks satisfying the specified condition.

	NOTE: The event will be processed in next frame.

	Argument name \| Description
	--------------\|-------------
	eventType \| string.
	objectType \| string or nil. If this is set then the event is only received by the block with specified type.
	id \| string or nil. If this is set then the event is only received by the block with specified id.
	target \| block or nil. If this is set then the event is only received by the specified block.

	Example:

	~~~lua
	level.broadcastObjectEvent("onToggle",nil,"1")
	~~~

	The "delayExecution" library
	----------------------------

	### Static functions:

	* schedule(func,time,[repeatCount=1],[repeatInterval],[enabled=true],[arguments...])

	Schedule a delay execution of a given function after the given time.

	Argument name \| Description
	---------------\|-------------
	func \| A function to be executed.
	time \| Time, given in frames (NOTE: 40 frames = 1 second). NOTE: If <=0 it is the same as =1.
	repeatCount \| The number of times the function will be executed. After such number of times executed, the delay execution will be removed from the list and get deleted. If =0 the delay execution object will be deleted soon. If <0 the function will be executed indefinitely.
	repeatInterval \| The repeat interval. If it is `nil` then the `time` argument will be used instead. NOTE: If <=0 the repeat execution will be disabled at all and the repeatCount will be set to 1.
	enabled \| Enabled.
	arguments \| Optional arguments passed to the function.

	Return value: the delayExecution object.

	NOTE: If you want to update time/repeatCount during the function execution,
	notice that the time/repeatCount is updated BEFORE the function execution.

	NOTE: During the execution the global variable `this`
	temporarily points to current delay execution object. (Ad-hoc workaround!)
	When the execution ends the global variable `this` is reset to its previous value.

	Example:

	~~~lua
	local f=function()
	local a
	a=0
	return(function(b)
	shadow:jump()
	print('obj1 '..this:getExecutionTime()..' '..a..' '..tostring(b))
	a=a+2
	end)
	end

	local obj1=delayExecution.schedule(f(),40*2,5,nil,nil,100)

	local obj2=delayExecution.schedule(
	function(o)
	print('obj2 '..tostring(o:isValid()))
	if not o:isValid() then
	this:setFunc(f())
	end
	end,40*1,-1,nil,nil,obj1)

	local obj3=delayExecution.schedule(
	function(o)
	o:cancel()
	end,40*30,1,nil,nil,obj2)
	~~~

	### Member functions:

	* isValid() -- Check if it's valid, i.e. not removed from list.

	* cancel() -- Cancels a delay execution. The canceled delay execution will be removed from the list and can not be restored.

	* isEnabled()/setEnabled(bool) -- get/set enabled of a delay execution. A disabled one will not count down its timer.

	* getTime()/setTime(integer) -- get/set the remaining time until the next execution. NOTE: If <=0 it is the same as =1.

	* getRepeatCount()/setRepeatCount(integer) -- get/set the remaining repeat count. If =0 the object will get deleted soon. If <0 the function will be executed indefinitely.

	* getRepeatInterval()/setRepeatInterval(integer) -- get/set the repeat interval. NOTE: If <=0 then nothing happens.

	* getFunc()/setFunc(func) -- get/set the function to be executed. NOTE: The setFunc will return the original function.

	* getArguments()/setArguments(args...) -- get/set the arguments

	* getExecutionTime()/setExecutionTime(integer) -- get/set the number of times the function being executed. NOTE: this execution time doesn't affect the default logic.

	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
	-------------------

	NOTE: the following functions are not going to work if the sound/music volume is 0.

	### Static functions:

	* playSound(name[,concurrent=-1[,force=false[,fade=-1]]])

	Play a sound effect.

	Argument name \| Description
	--------------\|-------------
	name \| The name of the sound effect. Currently available: "jump", "hit", "checkpoint", "swap", "toggle", "error", "collect", "achievement".
	concurrent \| The number of times the same sfx can be played at once, -1 is unlimited. NOTE: there are 64 channels.
	force \| If the sound must be played even if all channels are used. In this case the sound effect in the first channel will be stopped.
	fade \| A factor to temporarily turn the music volume down (0-128). -1 means don't use this feature.

	Return value: The channel of the sfx. -1 means failed (channel is full, invalid sfx name, sfx volume is 0, etc.)

	* playMusic(name[,fade=true])

	Play a music.

	Argument name \| Description
	--------------\|-------------
	name \| The name of the song, e.g. "default/neverending" or "menu".
	fade \| Boolean if it should fade the current one out or not.

	* pickMusic() - pick a song from the current music list.

	* getMusicList()/setMusicList(name_of_the_music_list) - get/set the music list. Example: "default".

	* currentMusic() - get the current music.
	+
	+The "gettext" library
	+--------------------
	+
	+This library is used for translation support.
	+
	+NOTE: Currently this library only uses the dictionary for current level pack.
	+This means it doesn't work for individual level which doesn't contain in a level pack,
	+and it can't make use of the translations of the core game.
	+
	+### Global functions:
	+
	+* `_(msgid)` -- translate the string using default context
	+
	+* `__(msgid)` -- does nothing, just outputs the original string. However, it will be scanned by `xgettext`.
	+ Mainly used in block:setMessage() since the block message will always be passed to gettext().
	+ Also used in construction of an array of strings, which will be translated dynamically.
	+
	+### Static functions:
	+
	+* gettext(msgid) -- translate the string using default context
	+
	+* pgettext(msgctxt,msgid) -- translate the string using specified context
	+
	+* ngettext(msgid,msgid_plural,n) -- translate the string using default context, taking plural form into consideration
	+
	+* npgettext(msgctxt,msgid,msgid_plural,n) -- translate the string using specified context, taking plural form into consideration
	+
	+The "prng" library
	+--------------------
	+
	+The Mersenne Twister 19937 pseudo-random number generator.
	+
	+The random seed is recreated each time the game starts, and is saved to the record file,
	+which ensures the reproducibility of the replay.
	+
	+### Static functions:
	+
	+* random() / random(n) / random(m,n)
	+
	+These functions have the same arguments as the Lua built-in function `math.random()`. More precisely:
	+
	+When called without arguments, returns a pseudo-random float with uniform distribution in the range `[0,1)`.
	+
	+When called with two integers `m` and `n`, returns a pseudo-random integer with uniform distribution in the range `[m, n]`.
	+The `m` cannot be larger than `n`
	+(othewise it will return a pseudo-random integer with uniform distribution in the union of `[m, 2^63-1]` and `[-2^63, n]`)
	+and must fit in two Lua integers.
	+
	+The call `random(n)` is equivalent to `random(1,n)`.
	+
	+* getSeed() / setSeed(string)
	+
	+Get or set the random seed, which is a string.
	+This is mainly used when you want the pseudo-random number to be reproducible even between each plays.
	diff --git a/src/AchievementList.cpp b/src/AchievementList.cpp
	index 147aa87..1f88d25 100644
	--- a/src/AchievementList.cpp
	+++ b/src/AchievementList.cpp
	@@ -1,116 +1,115 @@
	/*
	* Copyright (C) 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/>.
	*/

	#include "AchievementList.h"

	// We redefined it here to prevent including more header files.
	#ifndef __
	#define __(X) (X)
	#endif

	// Format: {<id>, <name>, <file>, <pos>, <description>, <type>, nullptr}
	// id: Identifier of achievement. Should not change once the new achievement is added,
	// otherwise the old statistics will be lost.
	// name: Name of achievement. Translatable.
	// file: The icon file. NULL for no icon.
	// pos: Specifies which part of the icon will be displayed (left, top, width, height).
	// description: Description of achievement. Translatable. Can be multi-line text.
	// type [optional]: Specifies the display type of achievement.
	// ACHIEVEMENT_HIDDEN [default]: Show "Unknown achievement" when unfinished.
	// ACHIEVEMENT_TITLE: Only show icon and title when unfinished.
	// ACHIEVEMENT_ALL: Always show icon, title and description.
	// ACHIEVEMENT_PROGRESS: Show icon, title and description and a progress bar.
	// StatisticsManager::getAchievementProgress() function should return the progress (between 0 and 1).
	// NOTE: WARNING: All arguments should now be specified, as surface being nullptr is being relied upon.

	AchievementInfo achievementList[]={
	{"newbie",__("Newbie"),"gfx/medals.png",{0,0,30,30},__("Complete a level."),ACHIEVEMENT_ALL,nullptr},
	{"tutorial",__("Graduate"),"gfx/achievements/tutorial.png",{0,0,51,27},__("Complete the tutorial level pack."),ACHIEVEMENT_PROGRESS,nullptr},
	{"experienced",__("Experienced player"),"gfx/achievements/experienced.png",{0,0,51,51},__("Complete 50 levels."),ACHIEVEMENT_PROGRESS,nullptr},

	{"goodjob",__("Good job!"),"gfx/medals.png",{60,0,30,30},__("Receive a gold medal."),ACHIEVEMENT_ALL,nullptr},
	{"tutorialGold",__("Outstanding graduate"),"gfx/achievements/tutorialgold.png",{0,0,51,27},__("Complete the tutorial level pack with gold for all levels."),ACHIEVEMENT_PROGRESS,nullptr},
	- // FIXME: Fix typo
	- {"expert",__("Expert"),"gfx/achievements/expert.png",{0,0,51,51},__("Earn 50 gold medal."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"expert",__("Expert"),"gfx/achievements/expert.png",{0,0,51,51},__("Earn 50 gold medals."),ACHIEVEMENT_PROGRESS,nullptr},

	{"addicted",__("Hooked"),"gfx/achievements/addicted.png",{0,0,50,50},__("Play Me and My Shadow for more than 2 hours."),ACHIEVEMENT_TITLE,nullptr},
	{"loyalFan",__("Loyal fan of Me and My Shadow"),"gfx/achievements/loyalfan.png",{0,0,50,50},__("Play Me and My Shadow for more than 24 hours."),ACHIEVEMENT_HIDDEN,nullptr},

	{"constructor",__("Constructor"),"gfx/achievements/constructor.png",{0,0,50,50},__("Use the level editor for more than 2 hours."),ACHIEVEMENT_HIDDEN,nullptr},
	- {"constructor2",__("The creator"),"gfx/achievements/constructor2.png",{0,0,50,50},__("Use the level editor for more than 24 hours."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"constructor2",__("The creator"),"gfx/achievements/constructor2.png",{0,0,50,50},__("Use the level editor for more than 8 hours."),ACHIEVEMENT_HIDDEN,nullptr},

	{"create1",__("Look, cute level!"),"gfx/addon1.png",{0,0,64,64},__("Create a level for the first time."),ACHIEVEMENT_ALL,nullptr},
	- {"create50",__("The level museum"),"gfx/addon2.png",{0,0,64,64},__("Create 50 levels."),ACHIEVEMENT_PROGRESS,nullptr},
	+ {"create10",__("The level museum"),"gfx/addon2.png",{0,0,64,64},__("Create 10 levels."),ACHIEVEMENT_PROGRESS,nullptr},

	{ "helloworld", __("Hello, World!"), "gfx/achievements/helloworld.png", { 0, 0, 50, 50 }, __("Write a script for the first time."), ACHIEVEMENT_TITLE, nullptr },

	- {"frog",__("Frog"),"themes/Cloudscape/characters/player.png",{230,0,23,40},__("Jump 1000 times."),ACHIEVEMENT_PROGRESS,nullptr},
	+ { "jump100", __("Frog"), "themes/Cloudscape/characters/player.png", { 230, 0, 23, 40 }, __("Jump 100 times."), ACHIEVEMENT_PROGRESS, nullptr },
	+ { "jump1k", __("Kangaroo"), "themes/Cloudscape/characters/player.png", { 230, 0, 23, 40 }, __("Jump 1000 times."), ACHIEVEMENT_PROGRESS, nullptr },

	{"travel100",__("Wanderer"),"themes/Cloudscape/characters/player.png",{69,0,23,40},__("Travel 100 meters."),ACHIEVEMENT_PROGRESS,nullptr},
	{"travel1k",__("Runner"),"themes/Cloudscape/characters/player.png",{23,0,23,40},__("Travel 1 kilometer."),ACHIEVEMENT_PROGRESS,nullptr},
	{"travel10k",__("Long distance runner"),"themes/Cloudscape/characters/player.png",{46,0,23,40},__("Travel 10 kilometers."),ACHIEVEMENT_PROGRESS,nullptr},
	{"travel42k",__("Marathon runner"),"themes/Cloudscape/characters/player.png",{92,0,23,40},__("Travel 42,195 meters."),ACHIEVEMENT_PROGRESS,nullptr},

	{"die1",__("Be careful!"),"themes/Cloudscape/characters/deathright.png",{0,14,23,40},__("Die for the first time."),ACHIEVEMENT_ALL,nullptr},
	{"die50",__("It doesn't matter..."),"gfx/achievements/die50.png",{0,0,50,50},__("Die 50 times."),ACHIEVEMENT_HIDDEN,nullptr},
	{"die1000",__("Expert of trial and error"),"gfx/achievements/die1000.png",{0,0,50,50},__("Die 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},

	{"squash1",__("Keep an eye for moving blocks!"),"gfx/achievements/squash1.png",{0,0,50,50},__("Get squashed for the first time."),ACHIEVEMENT_HIDDEN,nullptr},
	{"squash50",__("Potato masher"),"gfx/achievements/squash50.png",{0,0,50,50},__("Get squashed 50 times."),ACHIEVEMENT_HIDDEN,nullptr},

	{"doubleKill",__("Double kill"),"gfx/achievements/doublekill.png",{0,0,50,50},__("Get both the player and the shadow dead."),ACHIEVEMENT_HIDDEN,nullptr},

	{"die5in5",__("Bad luck"),"gfx/achievements/die5in5.png",{0,0,50,50},__("Die 5 times in under 5 seconds."),ACHIEVEMENT_TITLE,nullptr},
	{"die10in5",__("This level is too dangerous"),"gfx/achievements/die10in5.png",{0,0,50,50},__("Die 10 times in under 5 seconds."),ACHIEVEMENT_HIDDEN,nullptr},

	{"forget",__("You forgot your friend"),"gfx/achievements/forget.png",{0,0,45,53},__("Finish the level with the player or the shadow dead."),ACHIEVEMENT_HIDDEN,nullptr},
	{"jit",__("Just in time"),"gfx/achievements/jit.png",{0,0,50,50},__("Reach the exit with the player and the shadow simultaneously."),ACHIEVEMENT_TITLE,nullptr},

	{"record100",__("Recorder"),"gfx/achievements/record100.png",{0,0,50,50},__("Record 100 times."),ACHIEVEMENT_PROGRESS,nullptr},
	{"record1k",__("Shadowmaster"),"themes/Cloudscape/characters/shadow.png",{23,0,23,40},__("Record 1000 times."),ACHIEVEMENT_PROGRESS,nullptr},

	{"switch100",__("Switch puller"),"themes/Cloudscape/tiles/tiles.png",{100,100,50,50},__("Pull the switch 100 times."),ACHIEVEMENT_PROGRESS,nullptr},
	{"switch1k",__("The switch is broken!"),"gfx/achievements/switch1k.png",{0,0,50,50},__("Pull the switch 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},

	{"swap100",__("Swapper"),"themes/Cloudscape/tiles/swap.png",{0,0,50,50},__("Swap 100 times."),ACHIEVEMENT_PROGRESS,nullptr},
	- // {"swap1k",__("Player to shadow to player to shadow..."),"themes/Cloudscape/tiles/swap.png",{0,0,50,50},__("Swap 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},

	- {"save1k",__("Play it save"),"gfx/achievements/save1k.png",{0,0,50,50},__("Save 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},
	- {"load1k",__("This game is too hard"),"gfx/achievements/load1k.png",{0,0,50,50},__("Load the game 1000 times."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"save100",__("Play it save"),"gfx/achievements/save1k.png",{0,0,50,50},__("Save 100 times."),ACHIEVEMENT_HIDDEN,nullptr},
	+ {"load100",__("This game is too hard"),"gfx/achievements/load1k.png",{0,0,50,50},__("Load the game 100 times."),ACHIEVEMENT_HIDDEN,nullptr},

	{ "withoutsave", __("No, thanks"), "gfx/achievements/withoutsave.png", { 0, 0, 50, 50 }, __("Complete a level with checkpoint, but without saving."), ACHIEVEMENT_TITLE, nullptr },

	{"panicSave",__("Panic save"),"gfx/achievements/panicsave.png",{0,0,50,50},__("Save twice in 1 second."),ACHIEVEMENT_HIDDEN,nullptr},
	{"panicLoad",__("Panic load"),"gfx/achievements/panicload.png",{0,0,50,50},__("Load twice in 1 second."),ACHIEVEMENT_HIDDEN,nullptr},

	{"loadAndDie",__("Bad saving position"),"gfx/achievements/loadanddie.png",{0,0,50,50},__("Load the game and die within 1 second."),ACHIEVEMENT_TITLE,nullptr},
	{"loadAndDie100",__("This level is too hard"),"gfx/achievements/loadanddie100.png",{0,0,50,50},__("Load the same save and die 100 times."),ACHIEVEMENT_HIDDEN,nullptr},

	{"quickswap",__("Quick swap"),"gfx/achievements/quickswap.png",{0,0,50,50},__("Swap twice in under a second."),ACHIEVEMENT_HIDDEN,nullptr},

	//ripped from Achievements Unlocked
	{"horizontal",__("Horizontal confusion"),"gfx/emotions.png",{0,0,23,40},__("Press left and right simultaneously."),ACHIEVEMENT_HIDDEN,nullptr},

	{ "cheat", __("Cheater"), "gfx/achievements/cheat.png", { 0, 0, 50, 50 }, __("Cheat in game."), ACHIEVEMENT_HIDDEN, nullptr },

	{"programmer",__("Programmer"),"gfx/achievements/programmer.png",{0,0,50,50},__("Play the development version of Me and My Shadow."),ACHIEVEMENT_TITLE,nullptr},

	//end of achievements
	{}
	};
	diff --git a/src/Addons.h b/src/Addons.h
	index 2e7808b..86ac8c6 100644
	--- a/src/Addons.h
	+++ b/src/Addons.h
	@@ -1,161 +1,161 @@
	/*
	* 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 ADDONS_H
	#define ADDONS_H

	#include "GameState.h"
	#include "GameObjects.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include <array>
	#include <vector>
	#include <string>

	//The addons menu.
	class Addons: public GameState,public GUIEventCallback{
	private:
	//The minimum addon version that is supported.
	static const int MIN_VERSION=2;
	//The maximum addon version that is supported.
	static const int MAX_VERSION=2;

	//An addon entry.
	struct Addon{
	//The name of the addon.
	- string name;
	+ std::string name;
	//The type of addon. (Level, Levelpack, Theme)
	- string type;
	+ std::string type;
	//The link to the addon file.
	- string file;
	+ std::string file;
	//The name of the author.
	- string author;
	+ std::string author;

	//The description of the addon.
	- string description;
	+ std::string description;
	//The license of the addon.
	- string license;
	+ std::string license;
	//The website of the addon.
	- string website;
	+ std::string website;

	//Icon for the addon.
	SDL_Surface* icon;
	//Screenshot for the addon.
	SharedTexture screenshot;

	//The latest version of the addon.
	int version;
	//The version that the user has installed, if installed.
	int installedVersion;

	//Boolean if the addon is installed.
	bool installed;
	//Boolean if the addon is upToDate. (installedVersion==version)
	bool upToDate;

	//Map that contains the content of the addon.
	//NOTE: This is only filled if the addon is installed.
	std::vector<std::pair<std::string,std::string> > content;
	//Array that holds the name of the addons it's dependent on.
	//NOTE: This is only filled if the addon is installed.
	std::vector<std::pair<std::string,std::string> > dependencies;
	};

	//The title.
	TexturePtr title;

	//Placeholder icons for addons in case they don't provide custom icons.
	std::map<std::string, SDL_Surface*> addonIcon;

	//Placeholder screenshot for addons in case they don't provide one.
	SharedTexture screenshot;

	//Map containing a vector of Addons for each addon category.
	std::vector<Addon> addons;

	//String that should contain the error when something fails.
	- string error;
	+ std::string error;

	//The type of addon that is currently selected.
	- string type;
	+ std::string type;
	//Pointer to the addon that is selected.
	Addon* selected;

	//The list used for the selecting of the category.
	GUISingleLineListBox* categoryList;
	//Pointer to the description.
	GUIObject* categoryDescription;
	//The list used for listing the addons.
	GUIListBox* list;
	public:
	//Constructor.
	Addons(SDL_Renderer& renderer, ImageManager& imageManager);
	//Destructor.
	~Addons();

	//Method that will create the GUI.
	void createGUI(SDL_Renderer &renderer, ImageManager &imageManager);

	//Method that loads that downloads the addons list.
	//Returns: True if the file is downloaded successfuly.
	bool getAddonsList(SDL_Renderer& renderer, ImageManager& imageManager);

	void fillAddonList(TreeStorageNode &objAddons,TreeStorageNode &objInstalledAddons,SDL_Renderer& renderer, ImageManager& imageManager);
	//Put all the addons of a given type in a vector.
	//type: The type the addons must be.
	//Returns: Vector containing the addons.
	- void addonsToList(const string &type, SDL_Renderer &renderer, ImageManager &);
	+ void addonsToList(const std::string &type, SDL_Renderer &renderer, ImageManager &);

	//Method that will save the installed addons to the installed_addons file.
	//Returns: True if the file is saved successfuly.
	bool saveInstalledAddons();

	//Method for loading a cached image and downloading if it isn't cached.
	//url: The url to the image.
	//md5sum: The md5sum used for caching.
	//Returns: Shared pointer to the loaded image.
	SDL_Surface* loadCachedImage(const char* url,const char* md5sum, ImageManager& imageManager);
	SharedTexture loadCachedTexture(const char* url, const char* md5sum, SDL_Renderer& renderer, ImageManager& imageManager);

	//Method that will open a GUIOverlay with the an overview of the selected addon.
	void showAddon(ImageManager& imageManager,SDL_Renderer& renderer);

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

	//Method used for GUI event handling.
	//name: The name of the callback.
	//obj: Pointer to the GUIObject that caused the event.
	//eventType: The type of event: click, change, etc..
	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);

	//This method will remove the addon based on the content vector.
	//NOTE It doesn't check if the addon is installed or not.
	//addon: The addon to remove.
	void removeAddon(ImageManager& imageManager,SDL_Renderer &renderer, Addon* addon);
	//This method will install the addon by downloading,extracting and reading.
	//NOTE It doesn't check if the addon is installed or not.
	//addon: The addon to install.
	void installAddon(ImageManager& imageManager, SDL_Renderer &renderer, Addon* addon);

	};
	#endif
	diff --git a/src/Block.cpp b/src/Block.cpp
	index c848694..8b683c7 100644
	--- a/src/Block.cpp
	+++ b/src/Block.cpp
	@@ -1,1286 +1,1196 @@
	/*
	* 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),
	dy(0),
	- dxSave(0),
	- dySave(0),
	movingPosTime(-1),
	speed(0),
	- speedSave(0),
	- editorSpeed(0),
	- editorFlags(0)
	+ objCurrentStand(NULL),
	+ xVel(0), yVel(0),
	+ inAir(false), xVelBase(0), yVelBase(0),
	+ isDelete(false)
	{
	//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(){}
	+Block::Block(const Block& other)
	+ : GameObject(other)
	+ , ScriptProxyUserClass(other)
	+ , animation(other.animation)
	+ , flags(other.flags)
	+ , temp(other.temp)
	+ , dx(other.dx), dy(other.dy)
	+ , movingPos(other.movingPos)
	+ , movingPosTime(-1)
	+ , speed(other.speed)
	+ , objCurrentStand(other.objCurrentStand)
	+ , customAppearanceName(other.customAppearanceName)
	+ , appearance(other.appearance)
	+ , xVel(other.xVel), yVel(other.yVel)
	+ , inAir(other.inAir), xVelBase(other.xVelBase), yVelBase(other.yVelBase)
	+ , id(other.id), destination(other.destination), message(other.message)
	+ , isDelete(other.isDelete)
	+{
	+ auto se = parent->getScriptExecutor();
	+ if (se == NULL) return;
	+
	+ lua_State *state = se->getLuaState();
	+ if (state == NULL) return;
	+
	+ //Copy the compiledScripts.
	+ for (auto it = other.compiledScripts.begin(); it != other.compiledScripts.end(); ++it) {
	+ lua_rawgeti(state, LUA_REGISTRYINDEX, it->second);
	+ compiledScripts[it->first] = luaL_ref(state, LUA_REGISTRYINDEX);
	+ }
	+}
	+
	+Block::~Block() {
	+ auto se = parent->getScriptExecutor();
	+ if (se == NULL) return;
	+
	+ lua_State *state = se->getLuaState();
	+ if (state == NULL) return;
	+
	+ //Delete the compiledScripts.
	+ for (auto it = compiledScripts.begin(); it != compiledScripts.end(); ++it) {
	+ luaL_unref(state, LUA_REGISTRYINDEX, it->second);
	+ }
	+}

	int Block::getPathMaxTime() {
	if (movingPosTime < 0) {
	movingPosTime = 0;
	for (const SDL_Rect& p : movingPos) {
	movingPosTime += p.w;
	}
	}

	return movingPosTime;
	}

	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=objCurrentStandSave=NULL;
	- inAir=inAirSave=true;
	+ objCurrentStand=NULL;
	+ inAir=true;
	xVel=yVel=xVelBase=yVelBase=0;
	- xVelSave=yVelSave=xVelBaseSave=yVelBaseSave=0;

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

	void Block::show(SDL_Renderer& renderer){
	//Make sure we are visible.
	if ((flags & 0x80000000) != 0 && (stateID != STATE_LEVEL_EDITOR \|\| dynamic_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(parent!=NULL && parent->objLastCheckPoint.get()==this){
	if(!temp) appearance.changeState("activated");
	temp=1;
	}else{
	if(temp) appearance.changeState("default");
	temp=0;
	}
	break;
	}

	//Always draw the base. (This is only supposed to show in editor.)
	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, 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, box.w, box.h);
	break;
	}

	//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()){
	+ if (!scripts.empty() \|\| !compiledScripts.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 (editorFlags & 0x80000000) {
	+ if (flags & 0x80000000) {
	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;
	}

	//Block with custom appearance
	if (!customAppearanceName.empty()) {
	const SDL_Rect r = { 48, 16, 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;
	- appearance.saveAnimation();
	-
	- //In case of a certain blocks we need to save some more.
	- switch(type){
	- case TYPE_PUSHABLE:
	- objCurrentStandSave=objCurrentStand;
	- 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;
	-
	- //Invalidates the cache.
	- movingPosTime = -1;
	-
	- //Handle block type specific variables.
	- switch(type){
	- case TYPE_PUSHABLE:
	- objCurrentStand=objCurrentStandSave;
	- 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;
	- }
	-
	- //Invalidates the cache.
	- movingPosTime = -1;
	-
	- //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;
	-
	- //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 int f = flags & 0x3;
	- const char* s=(f==0)?"default":((f==1)?"fragile1":((f==2)?"fragile2":"fragile3"));
	- appearance.changeState(s);
	- }
	- break;
	- case TYPE_PUSHABLE:
	- objCurrentStand=NULL;
	- inAir=false;
	- if(save) {
	- objCurrentStandSave=NULL;
	- 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 visible, otherwise no events should be handled except for 'OnCreate'.
	if ((flags & 0x80000000) != 0 && eventType != GameObjectEvent_OnCreate)
	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=parent->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:
	if ((flags & 0x3) < 3) {
	flags++;
	const int f = flags & 0x3;
	const char* s = (f <= 0) ? "default" : ((f == 1) ? "fragile1" : ((f == 2) ? "fragile2" : "fragile3"));
	appearance.changeState(s);
	}
	break;
	}
	break;
	case GameObjectEvent_PlayerIsOn:
	switch(type){
	case TYPE_BUTTON:
	temp=1;
	break;
	}
	break;
	case GameObjectEvent_OnPlayerInteraction:
	switch (type) {
	case TYPE_SWITCH:
	//Make sure that the id isn't emtpy.
	if (!id.empty()) {
	parent->broadcastObjectEvent(0x10000 \| (flags & 3),
	-1, id.c_str());
	} else {
	cerr << "WARNING: invalid switch id!" << endl;
	}
	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:
	if (flags & 0x80000000) break;
	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 & 0x3) < 3) return 1;
	break;
	}
	break;
	case GameObjectProperty_IsSpikes:
	if (flags & 0x80000000) break;
	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", (editorFlags & 0x80000000) == 0 ? "1" : "0"));
	+ obj.push_back(pair<string, string>("visible", (flags & 0x80000000) == 0 ? "1" : "0"));

	//And custom appearance.
	obj.push_back(pair<string, string>("appearance", customAppearanceName));

	//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",(editorFlags&0x2)?"0":"1"));
	+ obj.push_back(pair<string,string>("activated",(flags&0x1)?"0":"1"));
	+ obj.push_back(pair<string,string>("loop",(flags&0x2)?"0":"1"));
	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>("activated",(flags&0x1)?"0":"1"));
	+ sprintf(s,"%d",speed);
	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>("automatic",(flags&0x1)?"1":"0"));
	obj.push_back(pair<string,string>("destination",destination));
	break;
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	string s;
	- switch(editorFlags&0x3){
	+ switch(flags&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&0x3);
	+ sprintf(s,"%d",flags&0x3);
	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 appearance.
	it = obj.find("appearance");
	if (it != obj.end()) {
	std::string newAppearanceName;
	if (it->second.empty() \|\| it->second == std::string(Game::blockName[type]) + "_Scenery") {
	//Use the default appearance. (Do nothing since newAppearanceName is already empty)
	} else {
	//Use the custom appearance.
	newAppearanceName = it->second;
	}

	if (newAppearanceName != customAppearanceName) {
	//Try to find the custom appearance.
	ThemeBlock *themeBlock = NULL;
	if (!newAppearanceName.empty()) {
	themeBlock = objThemes.getScenery(newAppearanceName);
	if (themeBlock == NULL) {
	std::cerr << "ERROR: failed to load custom appearance '" << newAppearanceName << "' for block " << Game::blockName[type] << std::endl;
	}
	} else {
	themeBlock = objThemes.getBlock(type);
	if (themeBlock == NULL) {
	std::cerr << "ERROR: failed to load default appearance for block " << Game::blockName[type] << std::endl;
	}
	}

	if (themeBlock) {
	//Update the custom appearance name.
	customAppearanceName = newAppearanceName;

	//Recreate the theme block instance.
	themeBlock->createInstance(&appearance);

	//Do some block specific stuff,
	//e.g. reset the state according to block type,
	//or load some missing part of block states from default appearance.
	switch (type) {
	case TYPE_FRAGILE:
	{
	const int f = flags & 0x3;
	const char* s = (f == 0) ? "default" : ((f == 1) ? "fragile1" : ((f == 2) ? "fragile2" : "fragile3"));
	appearance.changeState(s);
	}
	break;
	case TYPE_BUTTON:
	if (appearance.blockStates.find("button") == appearance.blockStates.end()) {
	//Try to load the "button" state from default appearance
	ThemeBlockInstance defaultAppearance;
	objThemes.getBlock(type)->createInstance(&defaultAppearance);
	auto it = defaultAppearance.blockStates.find("button");
	- if (it != defaultAppearance.blockStates.end()) {
	- appearance.blockStates[it->first] = it->second;
	+ if (it != defaultAppearance.blockStates.end() && it->second >= 0 && it->second < (int)defaultAppearance.states.size()) {
	+ appearance.states.push_back(defaultAppearance.states[it->second]);
	+ appearance.blockStates[it->first] = appearance.states.size() - 1;
	}
	}
	break;
	}
	}
	}
	}

	//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;
	- flags = flagsSave = editorFlags = (editorFlags & ~0x80000000) \| ((s == "true" \|\| atoi(s.c_str())) ? 0 : 0x80000000);
	+ flags = (flags & ~0x80000000) \| ((s == "true" \|\| atoi(s.c_str())) ? 0 : 0x80000000);
	}

	//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()){
	const string& s=it->second;
	- editorFlags&=~0x1;
	- if(!(s=="true" \|\| atoi(s.c_str()))) editorFlags\|=0x1;
	- flags=flagsSave=editorFlags;
	+ flags&=~0x1;
	+ if(!(s=="true" \|\| atoi(s.c_str()))) flags\|=0x1;
	}else{
	it=obj.find("disabled");
	if(it!=obj.end()){
	const string& s=it->second;
	- editorFlags&=~0x1;
	- if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	- flags=flagsSave=editorFlags;
	+ flags&=~0x1;
	+ if(s=="true" \|\| atoi(s.c_str())) flags\|=0x1;
	}
	}

	//Check if the loop key is in the data.
	it=obj.find("loop");
	if(it!=obj.end()){
	const string& s=it->second;
	- editorFlags \|= 0x2;
	- if (s == "true" \|\| atoi(s.c_str())) editorFlags &= ~0x2;
	- flags = flagsSave = editorFlags;
	+ flags \|= 0x2;
	+ if (s == "true" \|\| atoi(s.c_str())) flags &= ~0x2;
	}

	}
	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(it->second.c_str());
	- speed=speedSave=editorSpeed;
	+ speed=atoi(it->second.c_str());
	}else{
	it = obj.find("speed");
	if (it != obj.end()){
	- editorSpeed = atoi(it->second.c_str()) * 10;
	- speed = speedSave = editorSpeed;
	+ speed = atoi(it->second.c_str()) * 10;
	}
	}

	//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()){
	const string& s=it->second;
	- editorFlags&=~0x1;
	- if(!(s=="true" \|\| atoi(s.c_str()))) editorFlags\|=0x1;
	- flags=flagsSave=editorFlags;
	+ flags&=~0x1;
	+ if(!(s=="true" \|\| atoi(s.c_str()))) flags\|=0x1;
	}else{
	it=obj.find("disabled");
	if(it!=obj.end()){
	const string& s=it->second;
	- editorFlags&=~0x1;
	- if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	- flags=flagsSave=editorFlags;
	+ flags&=~0x1;
	+ if(s=="true" \|\| atoi(s.c_str())) flags\|=0x1;
	}
	}
	}
	break;
	case TYPE_PORTAL:
	{
	//Check if the automatic key is in the data.
	it=obj.find("automatic");
	if(it!=obj.end()){
	const string& s=it->second;
	- editorFlags&=~0x1;
	- if(s=="true" \|\| atoi(s.c_str())) editorFlags\|=0x1;
	- flags=flagsSave=editorFlags;
	+ flags&=~0x1;
	+ if(s=="true" \|\| atoi(s.c_str())) flags\|=0x1;
	}

	//Check if the destination key is in the data.
	it=obj.find("destination");
	if(it!=obj.end()){
	destination=it->second;
	}
	}
	break;
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	//Check if the behaviour key is in the data.
	it=obj.find("behaviour");
	if(it!=obj.end()){
	const string& s=it->second;
	- editorFlags&=~0x3;
	- if(s=="on" \|\| s==_("On")) editorFlags\|=1;
	- else if(s=="off" \|\| s==_("Off")) editorFlags\|=2;
	- flags=flagsSave=editorFlags;
	+ flags&=~0x3;
	+ if(s=="on" \|\| s==_("On")) flags\|=1;
	+ else if(s=="off" \|\| s==_("Off")) flags\|=2;
	}
	}
	break;
	case TYPE_NOTIFICATION_BLOCK:
	{
	//Check if the message key is in the data.
	it=obj.find("message");
	if(it!=obj.end()){
	message=it->second;
	//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=(editorFlags&~0x3)\|(atoi(it->second.c_str())&0x3);
	- flags=flagsSave=editorFlags;
	- {
	- const int f = flags & 0x3;
	- const char* s=(f==0)?"default":((f==1)?"fragile1":((f==2)?"fragile2":"fragile3"));
	- appearance.changeState(s);
	- }
	+ flags=(flags&~0x3)\|(atoi(it->second.c_str())&0x3);
	+
	+ const int f = flags & 0x3;
	+ const char* s=(f==0)?"default":((f==1)?"fragile1":((f==2)?"fragile2":"fragile3"));
	+ appearance.changeState(s);
	}
	}
	break;
	}
	}

	std::string Block::getEditorProperty(const 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(const std::string& property, const 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 = 0;
	{
	auto it = Game::blockNameMap.find(objNode->value[0]);
	if (it != Game::blockNameMap.end()) {
	type = it->second;
	} else {
	cerr << "WARNING: Unknown block type '" << objNode->value[0] << "'!" << endl;
	}
	}
	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::move(){
	bool isPlayMode = stateID != STATE_LEVEL_EDITOR \|\| dynamic_cast<LevelEditor*>(parent)->isPlayMode();

	//Make sure we are visible, if not return.
	if ((flags & 0x80000000) != 0 && isPlayMode)
	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:
	//Only move block when we are in play mode.
	if (isPlayMode) {
	//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){ // time == 0 means the block deactivates at this point automatically
	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 && i == movingPos.size() - 1) {
	//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((flags & 0x2) == 0){
	//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;
	} else {
	//Reached the end, but not looping
	xVel=yVel=dx=dy=0;
	}
	}
	break;
	case TYPE_BUTTON:
	//Only move block when we are in play mode.
	if (isPlayMode) {
	//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:
	//NOTE: we update conveyor belt animation even in edit mode.
	//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:
	//Only move block when we are in play mode.
	if (isPlayMode) {
	//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){
	+ if (auto ocs = objCurrentStand.get()) {
	//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);
	+ SDL_Rect v=ocs->getBox(BoxType_Velocity);
	+ SDL_Rect delta=ocs->getBox(BoxType_Delta);

	- switch(objCurrentStand->type){
	+ switch(ocs->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)
	yVelBase=delta.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(auto o : parent->levelObjects){
	//Make sure to only check visible blocks.
	if(o->flags & 0x80000000)
	continue;
	//Make sure we aren't the block.
	if(o==this)
	continue;
	//Make sure the object is spike or solid for the player.
	if(o->type!=TYPE_SPIKES && o->type!=TYPE_MOVING_SPIKES && !o->queryProperties(GameObjectProperty_PlayerCanWalkOn,&parent->player))
	continue;

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

	//Check on which side of the box the pushable is.
	if(delta.x!=0){
	if(delta.x>0){
	//Move the pushable right if necessary.
	if((r.x+r.w)-box.x<=delta.x && box.x<r.x+r.w)
	box.x=r.x+r.w;
	}else{
	//Move the pushable left if necessary.
	if((box.x+box.w)-r.x<=-delta.x && box.x>r.x-box.w)
	box.x=r.x-box.w;
	}
	}
	if(delta.y!=0){
	if(delta.y>0){
	//Move the pushable down if necessary.
	if((r.y+r.h)-box.y<=delta.y && box.y<r.y+r.h)
	box.y=r.y+r.h;
	}else{
	//Move the pushable up if necessary.
	if((box.y+box.h)-r.y<=-delta.y && box.y>r.y-box.h)
	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(auto o : parent->levelObjects){
	//Make sure the object is visible.
	if(o->flags & 0x80000000)
	continue;
	//Make sure we aren't the block.
	if(o==this)
	continue;
	//Check if the player can collide with this game object, or this object is spike.
	if(o->type!=TYPE_SPIKES && o->type!=TYPE_MOVING_SPIKES && !o->queryProperties(GameObjectProperty_PlayerCanWalkOn,&parent->player))
	continue;

	//Check if the block is inside the frame.
	if(checkCollision(frame,o->getBox()))
	objects.push_back(o);
	}
	//Horizontal pass.
	if(xVel+xVelBase!=0){
	box.x+=xVel+xVelBase;
	for(auto o : objects){
	SDL_Rect r=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 right so the left edge of the player must be greater 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(auto o : objects){
	SDL_Rect r=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=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=o->getBox(BoxType_Velocity);
	SDL_Rect v2=lastStand->getBox(BoxType_Velocity);

	if(v.y==v2.y){
	if(w>w2)
	lastStand=o;
	}else if(v.y<v2.y){
	lastStand=o;
	}
	}else{
	lastStand=o;
	}
	}
	}else{
	//We came from the bottom so the upper edge of the player must be greater 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;
	}
	}
	+
	+void Block::deleteMe() {
	+ if (isDelete) return;
	+
	+ //Set the delete flag.
	+ isDelete = true;
	+
	+ //Hide this block.
	+ flags \|= 0x80000000;
	+
	+ //Invalidate all references to this block.
	+ if (proxy->object == this) {
	+ proxy->object = NULL;
	+ }
	+
	+ //Update totalCollectables, etc. when removing a collectable
	+ if (type == TYPE_COLLECTABLE) {
	+ if (flags & 0x1) parent->currentCollectables--;
	+ parent->totalCollectables--;
	+ }
	+}
	diff --git a/src/Block.h b/src/Block.h
	index 04c7143..8b2f622 100644
	--- a/src/Block.h
	+++ b/src/Block.h
	@@ -1,213 +1,198 @@
	/*
	* 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 Game; // ad-hoc
	+class Game;
	class LevelEditor;
	class AddRemoveGameObjectCommand;
	class AddRemovePathCommand;
	class BlockScriptAPI;

	-class Block: public GameObject, public ScriptUserClass<'B','L','O','K',Block>{
	- friend class Game; // ad-hoc
	+class Block: public GameObject, public ScriptProxyUserClass<'B','L','O','K',Block>{
	+ friend class Game;
	friend class LevelEditor;
	friend class AddRemoveGameObjectCommand;
	friend class AddRemovePathCommand;
	friend class BlockScriptAPI;
	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:
	//all: 0x80000000=invisible (If it's not visible it will not collide with anything or execute any scripts except for 'onCreate'.)
	//moving object: 0x1=disabled 0x2=NOT loop
	//button: bit0-1=behavior 0x4=pressed
	//switch: bit0-1=behavior
	//portal: 0x1=automatic
	//fragile: bit0-1 state
	//collectible: 0x1=collected
	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;

	//Cached variable for total time ot moving positions. -1 means uninitialized
	//NOTE: should reset it when editing movingPos (except for edit mode since it will reset when level starts)
	int movingPosTime;

	//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;
	- Block* objCurrentStandSave;
	-
	- //Flags of the block for the editor.
	- int editorFlags;
	+ Block::ObservePointer objCurrentStand;
	public:
	// The custom appearance name, whose meaning is the same as Scenery::sceneryName_. "" means using default one
	std::string customAppearanceName;

	//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.
	+ //NOTE: This will NOT get copy constructed since the copy constructor is only used for save/load support!!!
	map<int,std::string> scripts;

	//Compiled scripts. Use lua_rawgeti(L, LUA_REGISTRYINDEX, r) to get the function.
	- std::map<int, int> compiledScripts, savedCompiledScripts, initialCompiledScripts;
	+ std::map<int, int> compiledScripts;
	+
	+ //The boolean indicating if we will be deleted in next (or current) frame.
	+ //Used in dynamic delete of blocks in scripting.
	+ bool isDelete;

	//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);
	+
	+ //Copy constructor (which is only used in save/load support).
	+ Block(const Block& other);
	+
	+ Block& operator=(const Block& other) = delete;
	+
	//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) override;

	//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() override;
	- //Load the saved state of the block so.
	- virtual void loadState() override;
	- //Reset the block.
	- //save: Boolean if the saved state should also be deleted.
	- virtual void reset(bool save) override;

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

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

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

	//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) override;
	//Set the editor data of the block.
	//obj: The new editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj) override;

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

	//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 updating moving blocks or elements of blocks.
	virtual void move() override;

	//Get total time ot moving positions.
	int getPathMaxTime();
	+
	+ //Mark this block to be deleted in next frame. Also hide this block and invalidate references to it.
	+ void deleteMe();
	};

	#endif
	diff --git a/src/CachedTexture.h b/src/CachedTexture.h
	index a8c7a9c..271e230 100644
	--- a/src/CachedTexture.h
	+++ b/src/CachedTexture.h
	@@ -1,44 +1,48 @@
	#ifndef CACHEDTEXTURE_H
	#define CACHEDTEXTURE_H

	#include "Render.h"

	//A class to cache textures that display stuff that is updated regularly
	template <typename T>
	class CachedTexture
	{
	private:
	T id;
	TexturePtr tex;
	public:
	CachedTexture() {}
	TexturePtr& getTexture(){
	return tex;
	}

	SDL_Texture* get(){
	return tex.get();
	}

	+ const T& getId() const {
	+ return id;
	+ }
	+
	// Check if the texture exists.
	bool exists() {
	return tex.get() != nullptr;
	}

	// Check if the contained texture has to be updated.
	bool needsUpdate(const T& id){
	if (this->id!=id \|\| !tex) {
	return true;
	} else {
	return false;
	}
	}

	//Update the contained texture with a new id and texture.
	void update(T id, TexturePtr&& texture) {
	this->id = id;
	this->tex = std::move(texture);
	}
	};

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

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

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

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

	#include <stdio.h>

	#include "libs/tinyformat/tinyformat.h"

	Command::~Command() {

	}

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

	newPosition.push_back(r);

	init();
	}

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

	init();
	}

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

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

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

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

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

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

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

	ResizeLevelCommand::ResizeLevelCommand(LevelEditor* levelEditor, int newWidth, int newHeight, int diffx, int diffy)
	: editor(levelEditor), newLevelWidth(newWidth), newLevelHeight(newHeight), diffx(diffx), diffy(diffy)
	{
	- oldLevelWidth = LEVEL_WIDTH;
	- oldLevelHeight = LEVEL_HEIGHT;
	+ oldLevelWidth = levelEditor->levelRect.w;
	+ oldLevelHeight = levelEditor->levelRect.h;
	}

	ResizeLevelCommand::~ResizeLevelCommand() {
	}

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

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

	void ResizeLevelCommand::resizeLevel(LevelEditor* levelEditor, int newWidth, int newHeight, int diffx, int diffy) {
	- LEVEL_WIDTH = newWidth;
	- LEVEL_HEIGHT = newHeight;
	+ levelEditor->levelRect.w = levelEditor->levelRectSaved.w = levelEditor->levelRectInitial.w = newWidth;
	+ levelEditor->levelRect.h = levelEditor->levelRectSaved.h = levelEditor->levelRectInitial.h = newHeight;

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

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

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

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

	newLevelWidth += diffx;
	newLevelHeight += diffy;

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

	std::string ResizeLevelCommand::describe() {
	/// TRANSLATORS: Context: Undo/Redo ...
	return _("Resize level");
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	break;
	}
	default:
	break;
	}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// now we own this object
	ownObject = true;

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

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

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

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

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

	AddRemovePathCommand::~AddRemovePathCommand(){
	}

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

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

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

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

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

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

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

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

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

	RemovePathCommand::~RemovePathCommand(){
	}

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

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

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

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

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

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

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

	}

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

	AddLinkCommand::~AddLinkCommand(){
	}

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

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

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

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

	//Portals need to get the id of the other instead of give it's own id.
	target->setEditorProperty("destination", clickedObj->getEditorProperty("id"));
	} else{
	//Store the previous id.
	id = clickedObj->getEditorProperty("id");
	if(!id.empty()) {
	//Another block might already be set as trigger for the clickedObj.
	for(auto block : editor->levelObjects) {
	std::string otherId = block->getEditorProperty("id");
	if(id.compare(otherId) == 0) {
	//IDs match, so either one of the trigger itself or one of its (other) targets.
	std::vector<GameObject*>::iterator it;
	//Find the clickedObj in the block's triggers.
	it = std::find(editor->triggers[block].begin(), editor->triggers[block].end(), clickedObj);
	if(it != editor->triggers[block].end()){
	oldTrigger = block;
	editor->triggers[block].erase(it);
	break;
	}
	}
	}
	}

	//Give the clickedObject the same id as the trigger.
	clickedObj->setEditorProperty("id", target->getEditorProperty("id"));
	}
	}

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

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

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

	//Restore old trigger if applicable
	if(oldTrigger != NULL){
	editor->triggers[oldTrigger].push_back(clickedObj);
	}
	break;
	}
	}

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

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

	RemoveLinkCommand::~RemoveLinkCommand(){
	}

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

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

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

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

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

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

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

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

	SetEditorPropertyCommand::~SetEditorPropertyCommand() {
	}

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

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

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

	SetLevelPropertyCommand::~SetLevelPropertyCommand() {
	}

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

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

	std::string SetLevelPropertyCommand::describe() {
	/// TRANSLATORS: Context: Undo/Redo ...
	return _("Modify level property");
	}

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

	SetScriptCommand::~SetScriptCommand() {
	}

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

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

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

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

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

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

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

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

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

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

	// deselect all
	editor->deselectAll();

	// change the ownership
	ownObject = false;
	}

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

	// deselect all
	editor->deselectAll();

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

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

	// change the ownership
	ownObject = true;
	}

	AddRemoveLayerCommand::~AddRemoveLayerCommand() {
	if (ownObject) {
	delete layer;
	}
	}

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

	SetLayerPropertyCommand::SetLayerPropertyCommand(LevelEditor* levelEditor, const std::string& oldName, const LayerProperty& newProperty)
	: editor(levelEditor), newProperty(newProperty)
	{
	auto it = editor->sceneryLayers.find(oldName);

	assert(it != editor->sceneryLayers.end() && it->second);

	oldProperty.name = oldName;
	oldProperty.speedX = it->second->speedX;
	oldProperty.speedY = it->second->speedY;
	oldProperty.cameraX = it->second->cameraX;
	oldProperty.cameraY = it->second->cameraY;
	}

	void SetLayerPropertyCommand::execute() {
	setLayerProperty(oldProperty.name, newProperty);
	}

	void SetLayerPropertyCommand::unexecute() {
	setLayerProperty(newProperty.name, oldProperty);
	}

	SetLayerPropertyCommand::~SetLayerPropertyCommand() {
	}

	std::string SetLayerPropertyCommand::describe() {
	/// TRANSLATORS: Context: Undo/Redo ...
	return tfm::format(_("Modify the property of scenery layer %s"), oldProperty.name);
	}

	void SetLayerPropertyCommand::setLayerProperty(const std::string& oldName, const LayerProperty& newProperty) {
	SceneryLayer *tmp = NULL;

	// Find the existing layer
	{
	auto it = editor->sceneryLayers.find(oldName);
	assert(it != editor->sceneryLayers.end() && it->second);
	tmp = it->second;
	}

	// Check if we need to rename scenery layer
	if (oldName != newProperty.name) {
	assert(editor->sceneryLayers.find(newProperty.name) == editor->sceneryLayers.end());

	// remove the old layer
	editor->sceneryLayers.erase(oldName);

	// then save the temp variable to the new layer
	editor->sceneryLayers[newProperty.name] = tmp;

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

	// Now we update the properties of the layer
	tmp->speedX = newProperty.speedX;
	tmp->speedY = newProperty.speedY;
	tmp->cameraX = newProperty.cameraX;
	tmp->cameraY = newProperty.cameraY;
	}

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

	void MoveToLayerCommand::execute() {
	if (createNewLayer) {
	createNewLayer->execute();
	}

	removeGameObject();
	addGameObject(newName);

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

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

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

	if (createNewLayer) {
	createNewLayer->unexecute();
	}

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

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

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

	std::string MoveToLayerCommand::describe() {
	const size_t number_of_objects = objects.size();
	/// TRANSLATORS: Context: Undo/Redo ...
	return tfm::format(ngettext("Move %d object from layer %s to layer %s", "Move %d objects from layer %s to layer %s", number_of_objects).c_str(),
	number_of_objects, oldName, newName);
	}

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

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

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

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

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

	#ifndef COMMANDS_H
	#define COMMANDS_H

	#include "LevelEditor.h"

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

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

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

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

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

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

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

	//New level size.
	int newLevelWidth, newLevelHeight;

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

	//Old level size.
	int oldLevelWidth, oldLevelHeight;

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

	virtual void execute();

	virtual void unexecute();

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

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

	virtual std::string describe();
	};

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

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

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

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

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

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

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

	virtual ~MoveGameObjectCommand();

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

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

	virtual std::string describe();

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

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

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

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

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

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

	//The working mode.
	bool isAdd;

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

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

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

	//Removes the gameObject.
	void removeGameObject();

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

	virtual void execute();

	virtual void unexecute();

	virtual ~AddRemoveGameObjectCommand();

	virtual std::string describe();

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

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

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

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

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

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

	virtual ~AddRemovePathCommand();

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

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

	virtual std::string describe();

	private:
	void addPath();

	void removePath();

	void setEditorData();
	};

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

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

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

	virtual ~RemovePathCommand();

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

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

	virtual std::string describe();
	};

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

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

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

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

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

	//Previous id of target.
	std::string id;

	//Previous switch/button that was linked to target (can be NULL)
	Block* oldTrigger;
	public:
	AddLinkCommand(LevelEditor* levelEditor, Block* linkingTrigger, GameObject* clickedObject);

	virtual ~AddLinkCommand();

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

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

	virtual std::string describe();
	};

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

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

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

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

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

	virtual ~RemoveLinkCommand();

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

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

	virtual std::string describe();
	};

	//Class that modifies an editor property of an object.
	class SetEditorPropertyCommand : public Command {
	private:
	LevelEditor* editor;
	ImageManager& imageManager;
	SDL_Renderer& renderer;

	//Object being modified.
	GameObject* target;

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

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

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

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

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

	virtual ~SetEditorPropertyCommand();

	virtual void execute();

	virtual void unexecute();

	virtual std::string describe();

	private:
	void updateCustomScenery();
	};

	//Class that modifies the level settings.
	class SetLevelPropertyCommand : public Command {
	public:
	struct LevelProperty {
	std::string levelName;
	std::string levelTheme;
	std::string levelMusic;
	+ bool arcade;
	int levelTime;
	int levelRecordings;
	};

	private:
	LevelEditor* editor;

	LevelProperty oldProperty;
	LevelProperty newProperty;

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

	virtual ~SetLevelPropertyCommand();

	virtual void execute();

	virtual void unexecute();

	virtual std::string describe();

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

	//Class that modifies the scripting for block or level
	// NOTE: currently the scripting for scenery block is unsupported.
	class SetScriptCommand : public Command {
	private:
	LevelEditor* editor;

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

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

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

	std::string oldId;

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

	virtual ~SetScriptCommand();

	virtual void execute();

	virtual void unexecute();

	virtual std::string describe();

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

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

	//Layer added or removed.
	SceneryLayer* layer;

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

	//The working mode.
	bool isAdd;

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

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

	//Removes the layer.
	void removeLayer();

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

	virtual void execute();

	virtual void unexecute();

	virtual ~AddRemoveLayerCommand();

	virtual std::string describe();
	};

	//Class for editing scenery layer properties (including rename scenery layer).
	class SetLayerPropertyCommand : public Command {
	public:
	struct LayerProperty {
	std::string name;
	float speedX, speedY;
	float cameraX, cameraY;
	};

	private:
	LevelEditor* editor;

	LayerProperty oldProperty;
	LayerProperty newProperty;

	public:
	SetLayerPropertyCommand(LevelEditor* levelEditor, const std::string& oldName, const LayerProperty& newProperty);

	virtual void execute();

	virtual void unexecute();

	virtual ~SetLayerPropertyCommand();

	virtual std::string describe();

	private:
	void setLayerProperty(const std::string& oldName, const LayerProperty& newProperty);
	};

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

	std::vector<Scenery*> objects;

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

	AddRemoveLayerCommand* createNewLayer;

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

	virtual void execute();

	virtual void unexecute();

	virtual ~MoveToLayerCommand();

	virtual std::string describe();

	private:
	void removeGameObject();

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

	#endif
	diff --git a/src/FontManager.cpp b/src/FontManager.cpp
	new file mode 100644
	index 0000000..c05ad50
	--- /dev/null
	+++ b/src/FontManager.cpp
	@@ -0,0 +1,136 @@
	+/*
	+ * Copyright (C) 2018 Me and My Shadow
	+ *
	+ * This file is part of Me and My Shadow.
	+ *
	+ * Me and My Shadow is free software: you can redistribute it and/or modify
	+ * it under the terms of the GNU General Public License as published by
	+ * the Free Software Foundation, either version 3 of the License, or
	+ * (at your option) any later version.
	+ *
	+ * Me and My Shadow is distributed in the hope that it will be useful,
	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	+ * GNU General Public License for more details.
	+ *
	+ * You should have received a copy of the GNU General Public License
	+ * along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	+ */
	+
	+#include "FontManager.h"
	+#include "FileManager.h"
	+#include "TreeStorageNode.h"
	+#include "POASerializer.h"
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <SDL_ttf.h>
	+
	+FontManager* fontMgr = NULL;
	+
	+FontManager::FontManager() {
	+}
	+
	+FontManager::~FontManager() {
	+ for (auto it = fonts.begin(); it != fonts.end(); ++it) {
	+ for (auto font : it->second) {
	+ if (font) TTF_CloseFont(font);
	+ }
	+ }
	+}
	+
	+static TTF_Font* loadFont(const std::string& name, int size){
	+ TTF_Font* tmpFont;
	+ if (name.find('.') != std::string::npos) {
	+ tmpFont = TTF_OpenFont((getDataPath() + "font/" + name).c_str(), size);
	+ } else {
	+ tmpFont = TTF_OpenFont((getDataPath() + "font/" + name + ".ttf").c_str(), size);
	+ }
	+ if (tmpFont) {
	+ return tmpFont;
	+ } else{
	+ printf("ERROR: Unable to load font file '%s'!\n", name.c_str());
	+#if defined(ANDROID)
	+ //Android has built-in DroidSansFallback.ttf. (?)
	+ return TTF_OpenFont("/system/fonts/DroidSansFallback.ttf", size);
	+#else
	+ return TTF_OpenFont((getDataPath() + "font/DroidSansFallback.ttf").c_str(), size);
	+#endif
	+ }
	+}
	+
	+void FontManager::loadFonts() {
	+ if (!fonts.empty()) return;
	+
	+ TreeStorageNode root;
	+ POASerializer serializer;
	+ if (!serializer.loadNodeFromFile((getDataPath() + "font/fonts.list").c_str(), &root, true)) {
	+ fprintf(stderr, "FATAL ERROR: Failed to load the font list!\n");
	+ return;
	+ }
	+
	+ for (auto node : root.subNodes) {
	+ if (node->name == "font" && node->value.size() >= 3) {
	+ if (fonts.find(node->value[0]) != fonts.end()) {
	+ printf("WARNING: The font named '%s' already exists!\n", node->value[0].c_str());
	+ continue;
	+ }
	+
	+ const int size = atoi(node->value[2].c_str());
	+ if (size <= 0) {
	+ printf("FATAL ERROR: The font named '%s' has invalid size '%d'!\n", node->value[0].c_str(), size);
	+ continue;
	+ }
	+
	+ TTF_Font *mainFont = loadFont(node->value[1], size);
	+
	+ if (mainFont == NULL) {
	+ printf("FATAL ERROR: Failed to load the main font file for font named '%s'!\n", node->value[0].c_str());
	+ continue;
	+ }
	+
	+ std::vector<TTF_Font*> &fontVector = fonts[node->value[0]];
	+ fontVector.push_back(mainFont);
	+
	+ for (auto subnode : node->subNodes) {
	+ if (subnode->name == "fallback" && subnode->value.size() >= 1) {
	+ int newSize = size;
	+ if (subnode->value.size() >= 2) {
	+ if (subnode->value[1] == "relative" && subnode->value.size() >= 3) {
	+ newSize += atoi(subnode->value[2].c_str());
	+ } else if (subnode->value[1] == "scale" && subnode->value.size() >= 3) {
	+ double scale = atof(subnode->value[2].c_str());
	+ newSize = (int)floor(double(size) * scale + 0.5);
	+ } else {
	+ newSize = atoi(subnode->value[1].c_str());
	+ }
	+ }
	+
	+ if (newSize <= 0) {
	+ printf("WARNING: Invalid font size '%d'!\n", newSize);
	+ continue;
	+ }
	+
	+ TTF_Font *fallbackFont = loadFont(subnode->value[0], newSize);
	+
	+ if (fallbackFont == NULL) continue;
	+
	+ fontVector.push_back(fallbackFont);
	+ }
	+ }
	+
	+ if (fontVector.size() > 1) {
	+ TTF_SetFontFallback(mainFont, fontVector.size() - 1, &(fontVector[1]));
	+ }
	+ }
	+ }
	+}
	+
	+TTF_Font* FontManager::getFont(const std::string& name) {
	+ auto it = fonts.find(name);
	+ if (it == fonts.end() \|\| it->second.empty() \|\| it->second[0] == NULL) {
	+ fprintf(stderr, "FATAL ERROR: Can't find or failed to load font named '%s'!\n", name.c_str());
	+ return NULL;
	+ }
	+ return it->second[0];
	+}
	diff --git a/src/ScriptAPI.h b/src/FontManager.h
	similarity index 51%
	copy from src/ScriptAPI.h
	copy to src/FontManager.h
	index 79d483c..549e140 100644
	--- a/src/ScriptAPI.h
	+++ b/src/FontManager.h
	@@ -1,44 +1,47 @@
	/*
	- * Copyright (C) 2012-2013 Me and My Shadow
	+ * Copyright (C) 2018 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	-#ifndef SCRIPTAPI_H
	-#define SCRIPTAPI_H
	-
	-extern "C" {
	-#include <lua.h>
	-#include <lualib.h>
	-#include <lauxlib.h>
	-}
	-
	-class ScriptExecutor;
	-
	-//Method for loading the block library.
	-int luaopen_block(lua_State* state);
	-//Method for loading the player and shadow library.
	-int luaopen_player(lua_State* state);
	-//Method for loading the level library.
	-int luaopen_level(lua_State* state);
	-//Method for loading the camera library.
	-int luaopen_camera(lua_State* state);
	-//Method for loading the audio library.
	-int luaopen_audio(lua_State* state);
	-//Method for loading the delayExecution library.
	-int luaopen_delayExecution(lua_State* state);
	-
	-#endif
	\ No newline at end of file
	+#ifndef FONT_MANAGER_H
	+#define FONT_MANAGER_H
	+
	+// The forward declaration of TTF_Font is clunky like this
	+// as it's forward declared like this in SDL_ttf.h
	+struct _TTF_Font;
	+typedef struct _TTF_Font TTF_Font;
	+
	+#include <string>
	+#include <vector>
	+#include <map>
	+
	+class FontManager {
	+private:
	+ std::map<std::string, std::vector<TTF_Font*> > fonts;
	+
	+public:
	+ FontManager();
	+ ~FontManager();
	+
	+ void loadFonts();
	+
	+ TTF_Font* getFont(const std::string& name);
	+};
	+
	+extern FontManager* fontMgr;
	+
	+#endif
	diff --git a/src/Functions.cpp b/src/Functions.cpp
	index 9e171a1..2a5cb09 100644
	--- a/src/Functions.cpp
	+++ b/src/Functions.cpp
	@@ -1,1636 +1,1626 @@
	/*
	* 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 <stdio.h>
	#include <math.h>
	-#include <locale.h>
	+#include <string.h>
	#include <algorithm>
	#include <SDL.h>
	#include <SDL_mixer.h>
	#include <SDL_syswm.h>
	#include <SDL_ttf.h>
	#include <string>
	#include "Globals.h"
	#include "Functions.h"
	+#include "FontManager.h"
	#include "FileManager.h"
	#include "GameObjects.h"
	#include "LevelPack.h"
	#include "TitleMenu.h"
	#include "OptionsMenu.h"
	#include "CreditsMenu.h"
	#include "LevelEditSelect.h"
	#include "LevelEditor.h"
	#include "Game.h"
	#include "LevelPlaySelect.h"
	#include "Addons.h"
	#include "InputManager.h"
	#include "ImageManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include "ScriptExecutor.h"
	#include "LevelPackManager.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUIOverlay.h"
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"
	#include "Cursors.h"
	#include "ScriptAPI.h"

	#include "libs/tinyformat/tinyformat.h"
	#include "libs/tinygettext/tinygettext.hpp"
	#include "libs/tinygettext/log.hpp"
	#include "libs/findlocale/findlocale.h"

	using namespace std;

	#ifdef WIN32
	#include <windows.h>
	#include <shellapi.h>
	#include <shlobj.h>
	#define TO_UTF8(SRC, DEST) WideCharToMultiByte(CP_UTF8, 0, SRC, -1, DEST, sizeof(DEST), NULL, NULL)
	#define TO_UTF16(SRC, DEST) MultiByteToWideChar(CP_UTF8, 0, SRC, -1, DEST, sizeof(DEST)/sizeof(DEST[0]))
	#else
	#include <strings.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <dirent.h>
	#endif

	//Initialise the musicManager.
	//The MusicManager is used to prevent loading music files multiple times and for playing/fading music.
	MusicManager musicManager;

	//Initialise the soundManager.
	//The SoundManager is used to keep track of the sfx in the game.
	SoundManager soundManager;

	//Initialise the levelPackManager.
	//The LevelPackManager is used to prevent loading levelpacks multiple times and for the game to know which levelpacks there are.
	LevelPackManager levelPackManager;

	//Map containing changed settings using command line arguments.
	map<string,string> tmpSettings;
	//Pointer to the settings object.
	//It is used to load and save the settings file and change the settings.
	Settings* settings=nullptr;

	SDL_Renderer* sdlRenderer=nullptr;

	+std::string pgettext(const std::string& context, const std::string& message) {
	+ if (dictionaryManager) {
	+ return dictionaryManager->get_dictionary().translate_ctxt(context, message);
	+ } else {
	+ return message;
	+ }
	+}
	+
	std::string ngettext(const std::string& message,const std::string& messageplural,int num) {
	if (dictionaryManager) {
	return dictionaryManager->get_dictionary().translate_plural(message, messageplural, num);
	} else {
	//Assume it's of English plural rule
	return (num != 1) ? messageplural : message;
	}
	}

	void applySurface(int x,int y,SDL_Surface* source,SDL_Surface* dest,SDL_Rect* clip){
	//The offset is needed to draw at the right location.
	SDL_Rect offset;
	offset.x=x;
	offset.y=y;

	//Let SDL do the drawing of the surface.
	SDL_BlitSurface(source,clip,dest,&offset);
	}

	void drawRect(int x,int y,int w,int h,SDL_Renderer& renderer,Uint32 color){
	//NOTE: We let SDL_gfx render it.
	SDL_SetRenderDrawColor(&renderer,color >> 24,color >> 16,color >> 8,255);
	//rectangleRGBA(&renderer,x,y,x+w,y+h,color >> 24,color >> 16,color >> 8,255);
	const SDL_Rect r{x,y,w,h};
	SDL_RenderDrawRect(&renderer,&r);
	}

	//Draw a box with anti-aliased borders using SDL_gfx.
	void drawGUIBox(int x,int y,int w,int h,SDL_Renderer& renderer,Uint32 color){
	SDL_Renderer* rd = &renderer;
	//FIXME, this may get the wrong color on system with different endianness.
	//Fill content's background color from function parameter
	SDL_SetRenderDrawColor(rd,color >> 24,color >> 16,color >> 8,color >> 0);
	{
	const SDL_Rect r{x+1,y+1,w-2,h-2};
	SDL_RenderFillRect(rd, &r);
	}
	SDL_SetRenderDrawColor(rd,0,0,0,255);
	//Draw first black borders around content and leave 1 pixel in every corner
	SDL_RenderDrawLine(rd,x+1,y,x+w-2,y);
	SDL_RenderDrawLine(rd,x+1,y+h-1,x+w-2,y+h-1);
	SDL_RenderDrawLine(rd,x,y+1,x,y+h-2);
	SDL_RenderDrawLine(rd,x+w-1,y+1,x+w-1,y+h-2);

	//Fill the corners with transperent color to create anti-aliased borders
	SDL_SetRenderDrawColor(rd,0,0,0,160);
	SDL_RenderDrawPoint(rd,x,y);
	SDL_RenderDrawPoint(rd,x,y+h-1);
	SDL_RenderDrawPoint(rd,x+w-1,y);
	SDL_RenderDrawPoint(rd,x+w-1,y+h-1);

	//Draw second lighter border around content
	SDL_SetRenderDrawColor(rd,0,0,0,64);
	{
	const SDL_Rect r{x+1,y+1,w-2,h-2};
	SDL_RenderDrawRect(rd,&r);
	}

	SDL_SetRenderDrawColor(rd,0,0,0,50);

	//Create anti-aliasing in corners of second border
	SDL_RenderDrawPoint(rd,x+1,y+1);
	SDL_RenderDrawPoint(rd,x+1,y+h-2);
	SDL_RenderDrawPoint(rd,x+w-2,y+1);
	SDL_RenderDrawPoint(rd,x+w-2,y+h-2);
	}

	void drawLine(int x1,int y1,int x2,int y2,SDL_Renderer& renderer,Uint32 color){
	SDL_SetRenderDrawColor(&renderer,color >> 24,color >> 16,color >> 8,255);
	//NOTE: We let SDL_gfx render it.
	//lineRGBA(&renderer,x1,y1,x2,y2,color >> 24,color >> 16,color >> 8,255);
	SDL_RenderDrawLine(&renderer,x1,y1,x2,y2);
	}

	void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Renderer& renderer,Uint32 color,int spacing,int offset,int xsize,int ysize){
	//Draw line first
	drawLine(x1,y1,x2,y2,renderer,color);

	//calc delta and length
	double dx=x2-x1;
	double dy=y2-y1;
	double length=sqrt(dxdx+dydy);
	if(length<0.001) return;

	//calc the unit vector
	dx/=length; dy/=length;

	//Now draw arrows on it
	for(double p=offset;p<length;p+=spacing){
	drawLine(int(x1+pdx+0.5),int(y1+pdy+0.5),
	int(x1+(p-xsize)dx-ysizedy+0.5),int(y1+(p-xsize)dy+ysizedx+0.5),renderer,color);
	drawLine(int(x1+pdx+0.5),int(y1+pdy+0.5),
	int(x1+(p-xsize)dx+ysizedy+0.5),int(y1+(p-xsize)dy-ysizedx+0.5),renderer,color);
	}
	}

	ScreenData creationFailed() {
	return ScreenData{ nullptr };
	}

	ScreenData createScreen(){
	//Check if we are going fullscreen.
	if(settings->getBoolValue("fullscreen"))
	pickFullscreenResolution();

	//Set the screen_width and height.
	SCREEN_WIDTH=atoi(settings->getValue("width").c_str());
	SCREEN_HEIGHT=atoi(settings->getValue("height").c_str());

	//Update the camera.
	camera.w=SCREEN_WIDTH;
	camera.h=SCREEN_HEIGHT;

	//Set the flags.
	Uint32 flags = 0;
	Uint32 currentFlags = SDL_GetWindowFlags(sdlWindow);

	//#if !defined(ANDROID)
	// flags \|= SDL_DOUBLEBUF;
	//#endif
	if(settings->getBoolValue("fullscreen")) {
	flags\|=SDL_WINDOW_FULLSCREEN; //TODO with SDL2 we can also do SDL_WINDOW_FULLSCREEN_DESKTOP
	}
	else if(settings->getBoolValue("resizable"))
	flags\|=SDL_WINDOW_RESIZABLE;

	//Create the window and renderer if they don't exist and check if there weren't any errors.
	if (!sdlWindow && !sdlRenderer) {
	SDL_CreateWindowAndRenderer(SCREEN_WIDTH, SCREEN_HEIGHT, flags, &sdlWindow, &sdlRenderer);
	if(!sdlWindow \|\| !sdlRenderer){
	std::cerr << "FATAL ERROR: SDL_CreateWindowAndRenderer failed.\nError: " << SDL_GetError() << std::endl;
	return creationFailed();
	}

	SDL_SetRenderDrawBlendMode(sdlRenderer, SDL_BlendMode::SDL_BLENDMODE_BLEND);

	// White background so we see the menu on failure.
	SDL_SetRenderDrawColor(sdlRenderer, 255, 255, 255, 255);
	} else if (sdlWindow) {
	// Try changing to/from fullscreen
	if(SDL_SetWindowFullscreen(sdlWindow, flags & SDL_WINDOW_FULLSCREEN) != 0) {
	std::cerr << "WARNING: Failed to switch to fullscreen: " << SDL_GetError() << std::endl;
	};
	currentFlags = SDL_GetWindowFlags(sdlWindow);

	// Change fullscreen resolution
	if((currentFlags & SDL_WINDOW_FULLSCREEN ) \|\| (currentFlags & SDL_WINDOW_FULLSCREEN_DESKTOP)) {
	SDL_DisplayMode m{0,0,0,0,nullptr};
	SDL_GetWindowDisplayMode(sdlWindow,&m);
	m.w = SCREEN_WIDTH;
	m.h = SCREEN_HEIGHT;
	if(SDL_SetWindowDisplayMode(sdlWindow, &m) != 0) {
	std::cerr << "WARNING: Failed to set display mode: " << SDL_GetError() << std::endl;
	}
	} else {
	SDL_SetWindowSize(sdlWindow, SCREEN_WIDTH, SCREEN_HEIGHT);
	}
	}

	//Now configure the newly created window (if windowed).
	if(settings->getBoolValue("fullscreen")==false)
	configureWindow();

	//Set the the window caption.
	SDL_SetWindowTitle(sdlWindow, ("Me and My Shadow "+version).c_str());
	//FIXME Seems to be obsolete
	// SDL_EnableUNICODE(1);

	//Nothing went wrong so return true.
	return ScreenData{sdlRenderer};
	}

	vector<SDL_Point> getResolutionList(){
	//Vector that will hold the resolutions to choose from.
	vector<SDL_Point> resolutionList;

	//Enumerate available resolutions using SDL_ListModes()
	//NOTE: we enumerate fullscreen resolutions because
	// windowed resolutions always can be arbitrary
	if(resolutionList.empty()){
	// SDL_Rect **modes=SDL_ListModes(NULL,SDL_FULLSCREEN\|SCREEN_FLAGS\|SDL_ANYFORMAT);
	//NOTe - currently only using the first display (0)
	int numDisplayModes = SDL_GetNumDisplayModes(0);

	if(numDisplayModes < 1){
	cerr<<"ERROR: Can't enumerate available screen resolutions."
	" Use predefined screen resolutions list instead."<<endl;

	static const SDL_Point predefinedResolutionList[] = {
	{800,600},
	{1024,600},
	{1024,768},
	{1152,864},
	{1280,720},
	{1280,768},
	{1280,800},
	{1280,960},
	{1280,1024},
	{1360,768},
	{1366,768},
	{1440,900},
	{1600,900},
	{1600,1200},
	{1680,1080},
	{1920,1080},
	{1920,1200},
	{2560,1440},
	{3840,2160}
	};

	//Fill the resolutionList.
	for (unsigned int i = 0; i<sizeof(predefinedResolutionList) / sizeof(SDL_Point); i++){
	resolutionList.push_back(predefinedResolutionList[i]);
	}
	}else{
	//Fill the resolutionList.

	for(int i=0;i < numDisplayModes; ++i){
	SDL_DisplayMode mode;
	int error = SDL_GetDisplayMode(0, i, &mode);
	if(error < 0) {
	//We failed to get a display mode. Should we crash here?
	std::cerr << "ERROR: Failed to get display mode " << i << " " << std::endl;
	}
	//Check if the resolution is higher than the minimum (800x600).
	if(mode.w >= 800 && mode.h >= 600){
	SDL_Point res = { mode.w, mode.h };
	resolutionList.push_back(res);
	}
	}
	//Reverse it so that we begin with the lowest resolution.
	reverse(resolutionList.begin(),resolutionList.end());
	}
	}

	//Return the resolution list.
	return resolutionList;
	}

	void pickFullscreenResolution(){
	//Get the resolution list.
	vector<SDL_Point> resolutionList=getResolutionList();

	//The resolution that will hold the final result, we start with the minimum (800x600).
	SDL_Point closestMatch = { 800, 600 };
	int width=atoi(getSettings()->getValue("width").c_str());
	int height=atoi(getSettings()->getValue("height").c_str());
	int delta = 0x40000000;

	//Now loop through the resolutionList.
	for (int i = 0; i < (int)resolutionList.size(); i++){
	int dx = width - resolutionList[i].x;
	if (dx < 0) dx = -dx;
	int dy = height - resolutionList[i].y;
	if (dy < 0) dy = -dy;

	if (dx + dy < delta){
	delta = dx + dy;
	closestMatch.x = resolutionList[i].x;
	closestMatch.y = resolutionList[i].y;
	}
	}

	//Now set the resolution to the closest match.
	char s[64];
	sprintf(s,"%d",closestMatch.x);
	getSettings()->setValue("width",s);
	sprintf(s,"%d",closestMatch.y);
	getSettings()->setValue("height",s);
	}

	void configureWindow(){
	//We only need to configure the window if it's resizable.
	if(!getSettings()->getBoolValue("resizable"))
	return;

	//We use a new function in SDL2 to restrict minimum window size
	SDL_SetWindowMinimumSize(sdlWindow, 800, 600);
	}

	void onVideoResize(ImageManager& imageManager, SDL_Renderer &renderer){
	//Check if the resize event isn't malformed.
	if(event.window.data1<=0 \|\| event.window.data2<=0)
	return;

	//Check the size limit.
	//TODO: SDL2 porting note: This may break on systems non-X11 or Windows systems as the window size won't be limited
	//there.
	if(event.window.data1<800)
	event.window.data1=800;
	if(event.window.data2<600)
	event.window.data2=600;

	//Check if it really resizes.
	if(SCREEN_WIDTH==event.window.data1 && SCREEN_HEIGHT==event.window.data2)
	return;

	char s[32];

	//Set the new width and height.
	SDL_snprintf(s,32,"%d",event.window.data1);
	getSettings()->setValue("width",s);
	SDL_snprintf(s,32,"%d",event.window.data2);
	getSettings()->setValue("height",s);
	//FIXME: THIS doesn't work properly.
	//Do resizing.
	SCREEN_WIDTH = event.window.data1;
	SCREEN_HEIGHT = event.window.data2;
	//Update the camera.
	camera.w=SCREEN_WIDTH;
	camera.h=SCREEN_HEIGHT;

	//Tell the theme to resize.
	if(!loadTheme(imageManager,renderer,""))
	return;

	//And let the currentState update it's GUI to the new resolution.
	currentState->resize(imageManager, renderer);
	}

	ScreenData init(){
	//Initialze SDL.
	if(SDL_Init(SDL_INIT_TIMER\|SDL_INIT_VIDEO\|SDL_INIT_AUDIO\|SDL_INIT_JOYSTICK)==-1) {
	std::cerr << "FATAL ERROR: SDL_Init failed\nError: " << SDL_GetError() << std::endl;
	return creationFailed();
	}

	//Initialze SDL_mixer (audio).
	//Note for SDL2 port: Changed frequency from 22050 to 44100.
	//22050 caused some sound artifacts on my system, and I'm not sure
	//why one would use it in this day and age anyhow.
	//unless it's for compatability with some legacy system.
	if(Mix_OpenAudio(44100,MIX_DEFAULT_FORMAT,2,1024)==-1){
	std::cerr << "FATAL ERROR: Mix_OpenAudio failed\nError: " << Mix_GetError() << std::endl;
	return creationFailed();
	}
	//Set the volume.
	Mix_Volume(-1,atoi(settings->getValue("sound").c_str()));

	//Increase the number of channels.
	soundManager.setNumberOfChannels(48);

	//Initialze SDL_ttf (fonts).
	if(TTF_Init()==-1){
	std::cerr << "FATAL ERROR: TTF_Init failed\nError: " << TTF_GetError() << std::endl;
	return creationFailed();
	}

	//Create the screen.
	ScreenData screenData(createScreen());
	if(!screenData) {
	return creationFailed();
	}

	//Load key config. Then initialize joystick support.
	inputMgr.loadConfig();
	inputMgr.openAllJoysitcks();

	//Init tinygettext for translations for the right language
	dictionaryManager = new tinygettext::DictionaryManager();
	dictionaryManager->set_use_fuzzy(false);
	dictionaryManager->add_directory(getDataPath()+"locale");
	dictionaryManager->set_charset("UTF-8");
	-
	+
	+ //Disable annoying 'Couldn't translate: blah blah blah'
	+ tinygettext::Log::set_log_info_callback(NULL);
	+
	//Check if user have defined own language. If not, find it out for the player using findlocale
	string lang=getSettings()->getValue("lang");
	if(lang.length()>0){
	printf("Locale set by user to %s\n",lang.c_str());
	language=lang;
	}else{
	FL_Locale *locale;
	FL_FindLocale(&locale,FL_MESSAGES);
	printf("Locale isn't set by user: %s\n",locale->lang);

	language=locale->lang;
	if(locale->country!=NULL){
	language+=string("_")+string(locale->country);
	}
	if(locale->variant!=NULL){
	language+=string("@")+string(locale->variant);
	}

	FL_FreeLocale(&locale);
	}
	//Now set the language in the dictionaryManager.
	dictionaryManager->set_language(tinygettext::Language::from_name(language));

	#ifdef WIN32
	//Some ad-hoc fix for Windows since it accepts "zh-CN" but not "zh_CN"
	std::string language2;
	for (auto c : language) {
	if (isalnum(c)) language2.push_back(c);
	else if (c == '_') language2.push_back('-');
	else break;
	}
	const char* languagePtr = language2.c_str();
	#else
	const char* languagePtr = language.c_str();
	#endif

	- //Also set the language for tinyformat.
	- tfm::setLocale(languagePtr);
	-
	//Set time format.
	setlocale(LC_TIME, languagePtr);

	- //Disable annoying 'Couldn't translate: blah blah blah'
	- tinygettext::Log::set_log_info_callback(NULL);
	+ //Also set the numeric format for tinyformat.
	+ tfm::setNumericFormat(
	+ /// TRANSLATORS: This is the decimal point character in your language.
	+ pgettext("numeric", "."),
	+ /// TRANSLATORS: This is the thousands separator character in your language.
	+ pgettext("numeric", ","),
	+ /// TRANSLATORS: This is the grouping of digits in your language,
	+ /// see <http://www.cplusplus.com/reference/locale/numpunct/grouping/> for more information.
	+ /// However, we use string containing "123..." instead of "\x01\x02\x03...", also, "0" is the same as "".
	+ pgettext("numeric", "3")
	+ );

	//Create the types of blocks.
	for(int i=0;i<TYPE_MAX;i++){
	Game::blockNameMap[Game::blockName[i]]=i;
	}

	//Structure that holds the event type/name pair.
	struct EventTypeName{
	int type;
	const char* name;
	};
	//Create the types of game object event types.
	{
	const EventTypeName types[]={
	{GameObjectEvent_PlayerWalkOn,"playerWalkOn"},
	{GameObjectEvent_PlayerIsOn,"playerIsOn"},
	{GameObjectEvent_PlayerLeave,"playerLeave"},
	{GameObjectEvent_OnCreate,"onCreate"},
	{GameObjectEvent_OnEnterFrame,"onEnterFrame"},
	{ GameObjectEvent_OnPlayerInteraction, "onPlayerInteraction" },
	{GameObjectEvent_OnToggle,"onToggle"},
	{GameObjectEvent_OnSwitchOn,"onSwitchOn"},
	{GameObjectEvent_OnSwitchOff,"onSwitchOff"},
	{0,NULL}
	};
	for(int i=0;types[i].name;i++){
	Game::gameObjectEventNameMap[types[i].name]=types[i].type;
	Game::gameObjectEventTypeMap[types[i].type]=types[i].name;
	}
	}
	//Create the types of level event types.
	{
	const EventTypeName types[]={
	{LevelEvent_OnCreate,"onCreate"},
	{LevelEvent_OnSave,"onSave"},
	{LevelEvent_OnLoad,"onLoad"},
	{0,NULL}
	};
	for(int i=0;types[i].name;i++){
	Game::levelEventNameMap[types[i].name]=types[i].type;
	Game::levelEventTypeMap[types[i].type]=types[i].name;
	}
	}

	//Nothing went wrong so we return true.
	return screenData;
	}

	-static TTF_Font* loadFont(const char* name,int size){
	- TTF_Font* tmpFont=TTF_OpenFont((getDataPath()+"font/"+name+".ttf").c_str(),size);
	- if(tmpFont){
	- return tmpFont;
	- }else{
	-#if defined(ANDROID)
	- //Android has built-in DroidSansFallback.ttf. (?)
	- return TTF_OpenFont("/system/fonts/DroidSansFallback.ttf",size);
	-#else
	- return TTF_OpenFont((getDataPath()+"font/DroidSansFallback.ttf").c_str(),size);
	-#endif
	- }
	-}
	-
	bool loadFonts(){
	//Load the fonts.
	//NOTE: This is a separate method because it will be called separately when re-initing in case of language change.
	-
	- //First close the fonts if needed.
	- if(fontTitle)
	- TTF_CloseFont(fontTitle);
	- if(fontGUI)
	- TTF_CloseFont(fontGUI);
	- if(fontGUISmall)
	- TTF_CloseFont(fontGUISmall);
	- if(fontText)
	- TTF_CloseFont(fontText);
	- if(fontMono)
	- TTF_CloseFont(fontMono);
	-
	- /// TRANSLATORS: Font used in GUI:
	- /// - Use "knewave" for languages using Latin and Latin-derived alphabets
	- /// - "DroidSansFallback" can be used for non-Latin writing systems
	- fontTitle=loadFont(_("knewave"),55);
	- fontGUI=loadFont(_("knewave"),32);
	- fontGUISmall=loadFont(_("knewave"),24);
	- /// TRANSLATORS: Font used for normal text:
	- /// - Use "Blokletters-Viltstift" for languages using Latin and Latin-derived alphabets
	- /// - "DroidSansFallback" can be used for non-Latin writing systems
	- fontText=loadFont(_("Blokletters-Viltstift"),16);
	- fontMono=loadFont("DejaVuSansMono",12);
	- if(fontTitle==NULL \|\| fontGUI==NULL \|\| fontGUISmall==NULL \|\| fontText==NULL \|\| fontMono==NULL){
	- printf("ERROR: Unable to load fonts! \n");
	+ //NOTE2: Since the font fallback is implemented, the font will not be loaded again if call loadFonts() twice.
	+
	+ if (fontMgr) {
	+ return true;
	+ }
	+
	+ fontMgr = new FontManager;
	+ fontMgr->loadFonts();
	+
	+ fontTitle = fontMgr->getFont("fontTitle");
	+ fontGUI = fontMgr->getFont("fontGUI");
	+ fontGUISmall = fontMgr->getFont("fontGUISmall");
	+ fontText = fontMgr->getFont("fontText");
	+ fontMono = fontMgr->getFont("fontMono");
	+
	+ if (fontTitle == NULL \|\| fontGUI == NULL \|\| fontGUISmall == NULL \|\| fontText == NULL \|\| fontMono == NULL){
	+ printf("FATAL ERROR: Unable to load fonts!\n");
	return false;
	}
	-
	+
	//Nothing went wrong so return true.
	return true;
	}

	//Generate small arrows used for some GUI widgets.
	static void generateArrows(SDL_Renderer& renderer){
	- TTF_Font* fontArrow=loadFont(_("knewave"),18);
	-
	+ TTF_Font* fontArrow = fontMgr->getFont("fontArrow");
	+
	arrowLeft1=textureFromText(renderer,*fontArrow,"<",objThemes.getTextColor(false));
	arrowRight1=textureFromText(renderer,*fontArrow,">",objThemes.getTextColor(false));
	arrowLeft2=textureFromText(renderer,*fontArrow,"<",objThemes.getTextColor(true));
	arrowRight2=textureFromText(renderer,*fontArrow,">",objThemes.getTextColor(true));
	-
	- TTF_CloseFont(fontArrow);
	}

	bool loadTheme(ImageManager& imageManager,SDL_Renderer& renderer,std::string name){
	//Load default fallback theme if it isn't loaded yet
	if(objThemes.themeCount()==0){
	if(objThemes.appendThemeFromFile(getDataPath()+"themes/Cloudscape/theme.mnmstheme", imageManager, renderer)==NULL){
	printf("ERROR: Can't load default theme file\n");
	return false;
	}
	}

	//Resize background or load specific theme
	bool success=true;
	if(name==""\|\|name.empty()){
	objThemes.scaleToScreen();
	}else{
	string theme=processFileName(name);
	if(objThemes.appendThemeFromFile(theme+"/theme.mnmstheme", imageManager, renderer)==NULL){
	printf("ERROR: Can't load theme %s\n",theme.c_str());
	success=false;
	}
	}

	generateArrows(renderer);

	//Everything went fine so return true.
	return success;
	}

	static SDL_Cursor* loadCursor(const char* image[]){
	int i,row,col;
	//The array that holds the data (0=white 1=black)
	Uint8 data[4*32];
	//The array that holds the alpha mask (0=transparent 1=visible)
	Uint8 mask[4*32];
	//The coordinates of the hotspot of the cursor.
	int hotspotX, hotspotY;

	i=-1;
	//Loop through the rows and columns.
	//NOTE: We assume a cursor size of 32x32.
	for(row=0;row<32;++row){
	for(col=0; col<32;++col){
	if(col % 8) {
	data[i]<<=1;
	mask[i]<<=1;
	}else{
	++i;
	data[i]=mask[i]=0;
	}
	switch(image[4+row][col]){
	case '+':
	data[i] \|= 0x01;
	mask[i] \|= 0x01;
	break;
	case '.':
	mask[i] \|= 0x01;
	break;
	default:
	break;
	}
	}
	}
	//Get the hotspot x and y locations from the last line of the cursor.
	sscanf(image[4+row],"%d,%d",&hotspotX,&hotspotY);
	return SDL_CreateCursor(data,mask,32,32,hotspotX,hotspotY);
	}

	bool loadFiles(ImageManager& imageManager, SDL_Renderer& renderer){
	//Load the fonts.
	if(!loadFonts())
	return false;

	//Show a loading screen
	{
	int w = 0,h = 0;
	SDL_GetRendererOutputSize(&renderer, &w, &h);
	SDL_Color fg={255,255,255,0};
	TexturePtr loadingTexture = titleTextureFromText(renderer, _("Loading..."), fg, w);
	SDL_Rect loadingRect = rectFromTexture(*loadingTexture);
	loadingRect.x = (w-loadingRect.w)/2;
	loadingRect.y = (h-loadingRect.h)/2;
	SDL_RenderCopy(sdlRenderer, loadingTexture.get(), NULL, &loadingRect);
	SDL_RenderPresent(sdlRenderer);
	SDL_RenderClear(sdlRenderer);
	}

	musicManager.destroy();
	//Load the music and play it.
	if(musicManager.loadMusic((getDataPath()+"music/menu.music")).empty()){
	printf("WARNING: Unable to load background music! \n");
	}
	musicManager.playMusic("menu",false);

	//Load all the music lists from the data and user data path.
	{
	vector<string> musicLists=enumAllFiles((getDataPath()+"music/"),"list",true);
	for(unsigned int i=0;i<musicLists.size();i++)
	getMusicManager()->loadMusicList(musicLists[i]);
	musicLists=enumAllFiles((getUserPath(USER_DATA)+"music/"),"list",true);
	for(unsigned int i=0;i<musicLists.size();i++)
	getMusicManager()->loadMusicList(musicLists[i]);
	}
	//Set the list to the configured one.
	getMusicManager()->setMusicList(getSettings()->getValue("musiclist"));

	//Check if music is enabled.
	if(getSettings()->getBoolValue("music"))
	getMusicManager()->setEnabled();

	//Load the sound effects
	soundManager.loadSound((getDataPath()+"sfx/jump.wav").c_str(),"jump");
	soundManager.loadSound((getDataPath()+"sfx/hit.wav").c_str(),"hit");
	soundManager.loadSound((getDataPath()+"sfx/checkpoint.wav").c_str(),"checkpoint");
	soundManager.loadSound((getDataPath()+"sfx/swap.wav").c_str(),"swap");
	soundManager.loadSound((getDataPath()+"sfx/toggle.ogg").c_str(),"toggle");
	soundManager.loadSound((getDataPath()+"sfx/error.wav").c_str(),"error");
	soundManager.loadSound((getDataPath()+"sfx/collect.wav").c_str(),"collect");
	soundManager.loadSound((getDataPath()+"sfx/achievement.ogg").c_str(),"achievement");

	//Load the cursor images from the Cursor.h file.
	cursors[CURSOR_POINTER]=loadCursor(pointer);
	cursors[CURSOR_CARROT]=loadCursor(ibeam);
	cursors[CURSOR_DRAG]=loadCursor(closedhand);
	cursors[CURSOR_SIZE_HOR]=loadCursor(size_hor);
	cursors[CURSOR_SIZE_VER]=loadCursor(size_ver);
	cursors[CURSOR_SIZE_FDIAG]=loadCursor(size_fdiag);
	cursors[CURSOR_SIZE_BDIAG]=loadCursor(size_bdiag);
	cursors[CURSOR_REMOVE]=loadCursor(remove_cursor);
	cursors[CURSOR_POINTING_HAND] = loadCursor(pointing_hand);
	//Set the default cursor right now.
	SDL_SetCursor(cursors[CURSOR_POINTER]);

	levelPackManager.destroy();
	//Now sum up all the levelpacks.
	vector<string> v=enumAllDirs(getDataPath()+"levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getDataPath()+"levelpacks/"+*i);
	}
	v=enumAllDirs(getUserPath(USER_DATA)+"levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getUserPath(USER_DATA)+"levelpacks/"+*i);
	}
	v=enumAllDirs(getUserPath(USER_DATA)+"custom/levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getUserPath(USER_DATA)+"custom/levelpacks/"+*i);
	}
	//Now we add a special levelpack that will contain the levels not in a levelpack.
	LevelPack* levelsPack=new LevelPack;
	levelsPack->levelpackName="Levels";
	levelsPack->levelpackPath=LEVELS_PATH;
	levelsPack->type=COLLECTION;
	LevelPack* customLevelsPack=new LevelPack;
	customLevelsPack->levelpackName="Custom Levels";
	customLevelsPack->levelpackPath=CUSTOM_LEVELS_PATH;
	customLevelsPack->type=COLLECTION;

	//List the main levels and add them one for one.
	v = enumAllFiles(getDataPath() + "levels/");
	for (vector<string>::iterator i = v.begin(); i != v.end(); ++i){
	levelsPack->addLevel(getDataPath() + "levels/" + *i);
	levelsPack->setLocked(levelsPack->getLevelCount() - 1);
	}
	//List the addon levels and add them one for one.
	v=enumAllFiles(getUserPath(USER_DATA)+"levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelsPack->addLevel(getUserPath(USER_DATA)+"levels/"+*i);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);
	}
	//List the custom levels and add them one for one.
	v=enumAllFiles(getUserPath(USER_DATA)+"custom/levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelsPack->addLevel(getUserPath(USER_DATA)+"custom/levels/"+*i);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);

	customLevelsPack->addLevel(getUserPath(USER_DATA)+"custom/levels/"+*i);
	customLevelsPack->setLocked(customLevelsPack->getLevelCount()-1);
	}

	//Add them to the manager.
	levelPackManager.addLevelPack(levelsPack);
	levelPackManager.addLevelPack(customLevelsPack);

	//Load statistics
	statsMgr.loadPicture(renderer, imageManager);
	statsMgr.registerAchievements(imageManager);
	statsMgr.loadFile(getUserPath(USER_CONFIG)+"statistics");

	//Do something ugly and slow
	statsMgr.reloadCompletedLevelsAndAchievements();
	statsMgr.reloadOtherAchievements();

	//Load the theme, both menu and default.
	//NOTE: Loading theme may fail and returning false would stop everything, default theme will be used instead.
	if (!loadTheme(imageManager,renderer,getSettings()->getValue("theme"))){
	getSettings()->setValue("theme","%DATA%/themes/Cloudscape");
	saveSettings();
	}

	//Nothing failed so return true.
	return true;
	}

	bool loadSettings(){
	//Check the version of config file.
	int version = 0;
	std::string cfgV05 = getUserPath(USER_CONFIG) + "meandmyshadow_V0.5.cfg";
	std::string cfgV04 = getUserPath(USER_CONFIG) + "meandmyshadow.cfg";

	if (fileExists(cfgV05.c_str())) {
	//We find a config file of current version.
	version = 0x000500;
	} else if (fileExists(cfgV04.c_str())) {
	//We find a config file of V0.4 version or earlier.
	copyFile(cfgV04.c_str(), cfgV05.c_str());
	version = 0x000400;
	} else {
	//No config file found, just create a new one.
	version = 0x000500;
	}
	settings=new Settings(cfgV05);
	settings->parseFile(version);

	//Now apply settings changed through command line arguments, if any.
	map<string,string>::iterator it;
	for(it=tmpSettings.begin();it!=tmpSettings.end();++it){
	settings->setValue(it->first,it->second);
	}
	tmpSettings.clear();

	//Always return true?
	return true;
	}

	bool saveSettings(){
	return settings->save();
	}

	Settings* getSettings(){
	return settings;
	}

	MusicManager* getMusicManager(){
	return &musicManager;
	}

	SoundManager* getSoundManager(){
	return &soundManager;
	}

	LevelPackManager* getLevelPackManager(){
	return &levelPackManager;
	}

	void flipScreen(SDL_Renderer& renderer){
	// Render the data from the back buffer.
	SDL_RenderPresent(&renderer);
	}

	void clean(){
	//Save statistics
	statsMgr.saveFile(getUserPath(USER_CONFIG)+"statistics");

	//We delete the settings.
	if(settings){
	delete settings;
	settings=NULL;
	}

	//Delete dictionaryManager.
	delete dictionaryManager;

	//Get rid of the currentstate.
	//NOTE: The state is probably already deleted by the changeState function.
	if(currentState)
	delete currentState;

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

	//These calls to destroy makes sure stuff is
	//deleted before SDL is uninitialised (as these managers are stack allocated
	//globals.)

	//Destroy the musicManager.
	musicManager.destroy();

	//Destroy all sounds
	soundManager.destroy();

	//Destroy the cursors.
	for(int i=0;i<CURSOR_MAX;i++){
	SDL_FreeCursor(cursors[i]);
	cursors[i]=NULL;
	}

	//Destroy the levelPackManager.
	levelPackManager.destroy();
	levels=NULL;

	//Close all joysticks.
	inputMgr.closeAllJoysticks();

	//Close the fonts and quit SDL_ttf.
	- TTF_CloseFont(fontTitle);
	- TTF_CloseFont(fontGUI);
	- TTF_CloseFont(fontGUISmall);
	- TTF_CloseFont(fontText);
	- TTF_CloseFont(fontMono);
	+ delete fontMgr;
	+ fontMgr = NULL;
	TTF_Quit();

	//Remove the temp surface.
	SDL_DestroyRenderer(sdlRenderer);
	SDL_DestroyWindow(sdlWindow);
	arrowLeft1.reset(nullptr);
	arrowLeft2.reset(nullptr);
	arrowRight1.reset(nullptr);
	arrowRight2.reset(nullptr);

	//Stop audio.and quit
	Mix_CloseAudio();
	//SDL2 porting note. Not sure why this was only done on apple.
	//#ifndef __APPLE__
	Mix_Quit();
	//#endif
	//And finally quit SDL.
	SDL_Quit();
	}

	void setNextState(int newstate){
	//Only change the state when we aren't already exiting.
	if(nextState!=STATE_EXIT){
	nextState=newstate;
	}
	}

	void changeState(ImageManager& imageManager, SDL_Renderer& renderer, int fade){

	//Check if there's a nextState.
	if(nextState!=STATE_NULL){
	//Fade out, if fading is enabled.
	if (currentState && settings->getBoolValue("fading")) {
	for (; fade >= 0; fade -= 17) {
	currentState->render(imageManager, renderer);
	//TODO: Shouldn't the gamestate take care of rendering the GUI?
	if (GUIObjectRoot) GUIObjectRoot->render(renderer);

	dimScreen(renderer, static_cast<Uint8>(255 - fade));

	//draw new achievements (if any) as overlay
	statsMgr.render(imageManager, renderer);

	flipScreen(renderer);

	SDL_Delay(1000/FPS);
	}
	}

	//Delete the currentState.
	delete currentState;
	currentState=NULL;

	//Set the currentState to the nextState.
	stateID=nextState;
	nextState=STATE_NULL;

	//Init the state.
	switch(stateID){
	case STATE_GAME:
	{
	currentState=NULL;
	Game* game=new Game(renderer, imageManager);
	currentState=game;
	//Check if we should load record file or a level.
	if(!Game::recordFile.empty()){
	game->loadRecord(imageManager,renderer,Game::recordFile.c_str());
	Game::recordFile.clear();
	}else{
	game->loadLevel(imageManager,renderer,levels->getLevelFile());
	levels->saveLevelProgress();
	}
	}
	break;
	case STATE_MENU:
	currentState=new Menu(imageManager, renderer);
	break;
	case STATE_LEVEL_SELECT:
	currentState=new LevelPlaySelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDIT_SELECT:
	currentState=new LevelEditSelect(imageManager, renderer);
	break;
	case STATE_LEVEL_EDITOR:
	{
	currentState=NULL;
	LevelEditor* levelEditor=new LevelEditor(renderer, imageManager);
	currentState=levelEditor;
	//Load the selected level.
	levelEditor->loadLevel(imageManager,renderer,levels->getLevelFile());
	}
	break;
	case STATE_OPTIONS:
	currentState=new Options(imageManager, renderer);
	break;
	case STATE_ADDONS:
	currentState=new Addons(renderer, imageManager);
	break;
	case STATE_CREDITS:
	currentState=new Credits(imageManager,renderer);
	break;
	case STATE_STATISTICS:
	currentState=new StatisticsScreen(imageManager,renderer);
	break;
	}
	//NOTE: STATE_EXIT isn't mentioned, meaning that currentState is null.
	//This way the game loop will break and the program will exit.
	}
	}

	void musicStoppedHook(){
	//We just call the musicStopped method of the MusicManager.
	musicManager.musicStopped();
	}

	void channelFinishedHook(int channel){
	soundManager.channelFinished(channel);
	}

	bool checkCollision(const SDL_Rect& a,const SDL_Rect& b){
	//Check if the left side of box a isn't past the right side of b.
	if(a.x>=b.x+b.w){
	return false;
	}
	//Check if the right side of box a isn't left of the left side of b.
	if(a.x+a.w<=b.x){
	return false;
	}
	//Check if the top side of box a isn't under the bottom side of b.
	if(a.y>=b.y+b.h){
	return false;
	}
	//Check if the bottom side of box a isn't above the top side of b.
	if(a.y+a.h<=b.y){
	return false;
	}

	//We have collision.
	return true;
	}

	bool pointOnRect(const SDL_Rect& point, const SDL_Rect& rect) {
	if(point.x >= rect.x && point.x < rect.x + rect.w
	&& point.y >= rect.y && point.y < rect.y + rect.h) {
	return true;
	}
	return false;
	}

	int parseArguments(int argc, char** argv){
	//Loop through all arguments.
	//We start at one since 0 is the command itself.
	for(int i=1;i<argc;i++){
	string argument=argv[i];

	//Check if the argument is the data-dir.
	if(argument=="--data-dir"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Configure the dataPath with the given path.
	dataPath=argv[i];
	if(!getDataPath().empty()){
	char c=dataPath[dataPath.size()-1];
	if(c!='/'&&c!='\\') dataPath+="/";
	}
	}else if(argument=="--user-dir"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Configure the userPath with the given path.
	userPath=argv[i];
	if(!userPath.empty()){
	char c=userPath[userPath.size()-1];
	if(c!='/'&&c!='\\') userPath+="/";
	}
	}else if(argument=="-f" \|\| argument=="-fullscreen" \|\| argument=="--fullscreen"){
	tmpSettings["fullscreen"]="1";
	}else if(argument=="-w" \|\| argument=="-windowed" \|\| argument=="--windowed"){
	tmpSettings["fullscreen"]="0";
	}else if(argument=="-mv" \|\| argument=="-music" \|\| argument=="--music"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Now set the music volume.
	tmpSettings["music"]=argv[i];
	}else if(argument=="-sv" \|\| argument=="-sound" \|\| argument=="--sound"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//Now set sound volume.
	tmpSettings["sound"]=argv[i];
	}else if(argument=="-set" \|\| argument=="--set"){
	//We need a second and a third argument so we increase i.
	i+=2;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//And set the setting.
	tmpSettings[argv[i-1]]=argv[i];
	}else if(argument=="-v" \|\| argument=="-version" \|\| argument=="--version"){
	//Print the version.
	printf("%s\n",version.c_str());
	return 0;
	}else if(argument=="-h" \|\| argument=="-help" \|\| argument=="--help"){
	//If the help is requested we'll return false without printing an error.
	//This way the usage/help text will be printed.
	return -1;
	}else{
	//Any other argument is unknow so we return false.
	printf("ERROR: Unknown argument %s\n\n",argument.c_str());
	return -1;
	}
	}

	//If everything went well we can return true.
	return 1;
	}

	//Special structure that will recieve the GUIEventCallbacks of the messagebox.
	struct msgBoxHandler:public GUIEventCallback{
	public:
	//Integer containing the ret(urn) value of the messageBox.
	int ret;
	public:
	//Constructor.
	msgBoxHandler():ret(0){}

	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Make sure it's a click event.
	if(eventType==GUIEventClick){
	//Set the return value.
	ret=obj->value;

	//After a click event we can delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}
	};

	msgBoxResult msgBox(ImageManager& imageManager,SDL_Renderer& renderer, const string& prompt,msgBoxButtons buttons,const string& title){
	//Create the event handler.
	msgBoxHandler objHandler;

	//Create the GUIObjectRoot, the height and y location is temp.
	//It depends on the content what it will be.
	GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,200,600,200,title.c_str());

	//Integer containing the current y location used to grow dynamic depending on the content.
	int y=50;

	//Now process the prompt.
	{
	//NOTE: We shouldn't modify the cotents in the c_str() of a string,
	//since it's said that at least in g++ the std::string is copy-on-write
	//hence if we modify the content it may break

	//The copy of the prompt.
	std::vector<char> copyOfPrompt(prompt.begin(), prompt.end());

	//Append another '\0' to it.
	copyOfPrompt.push_back(0);

	//Pointer to the string.
	char* lps = &(copyOfPrompt[0]);
	//Pointer to a character.
	char* lp=NULL;

	//The list of labels.
	std::vector<GUIObject*> labels;

	//We keep looping forever.
	//The only way out is with the break statement.
	for(;;){
	//As long as it's still the same sentence we continue.
	//It will stop when there's a newline or end of line.
	for(lp=lps;lp!='\n'&&lp!='\r'&&*lp!=0;lp++);

	//Store the character we stopped on. (End or newline)
	char c=*lp;
	//Set the character in the string to 0, making lps a string containing one sentence.
	*lp=0;

	//Add a GUIObjectLabel with the sentence.
	GUIObject *label = new GUILabel(imageManager, renderer, 0, y, root->width, 25, lps, 0, true, true, GUIGravityCenter);
	labels.push_back(label);
	root->addChild(label);

	//Calculate the width of the text.
	int w = 0;
	TTF_SizeUTF8(fontText, lps, &w, NULL);
	w += 20;
	if (w > root->width) root->width = w;

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

	//Check the stored character if it was a stop.
	if(c==0){
	//It was so break out of the for loop.
	lps=lp;
	break;
	}
	//It wasn't meaning more will follow.
	//We set lps to point after the "newline" forming a new string.
	lps=lp+1;
	}

	//Shrink the dialog if it's too big.
	if (root->width > SCREEN_WIDTH - 20) root->width = SCREEN_WIDTH - 20;
	root->left = (SCREEN_WIDTH - root->width) / 2;

	//Move labels to their correct locations.
	for (auto label : labels) {
	label->width = root->width;
	}
	}

	//Add 70 to y to leave some space between the content and the buttons.
	y+=70;
	//Recalc the size of the message box.
	root->top=(SCREEN_HEIGHT-y)/2;
	root->height=y;

	//Now we need to add the buttons.
	//Integer containing the number of buttons to add.
	int count=0;
	//Array with the return codes for the buttons.
	int value[3]={0};
	//Array containing the captation for the buttons.
	string button[3]={"","",""};
	switch(buttons){
	case MsgBoxOKCancel:
	count=2;
	button[0]=_("OK");value[0]=MsgBoxOK;
	button[1]=_("Cancel");value[1]=MsgBoxCancel;
	break;
	case MsgBoxAbortRetryIgnore:
	count=3;
	button[0]=_("Abort");value[0]=MsgBoxAbort;
	button[1]=_("Retry");value[1]=MsgBoxRetry;
	button[2]=_("Ignore");value[2]=MsgBoxIgnore;
	break;
	case MsgBoxYesNoCancel:
	count=3;
	button[0]=_("Yes");value[0]=MsgBoxYes;
	button[1]=_("No");value[1]=MsgBoxNo;
	button[2]=_("Cancel");value[2]=MsgBoxCancel;
	break;
	case MsgBoxYesNo:
	count=2;
	button[0]=_("Yes");value[0]=MsgBoxYes;
	button[1]=_("No");value[1]=MsgBoxNo;
	break;
	case MsgBoxRetryCancel:
	count=2;
	button[0]=_("Retry");value[0]=MsgBoxRetry;
	button[1]=_("Cancel");value[1]=MsgBoxCancel;
	break;
	default:
	count=1;
	button[0]=_("OK");value[0]=MsgBoxOK;
	break;
	}

	//Now we start making the buttons.
	{
	//Reduce y so that the buttons fit inside the frame.
	y-=40;

	double places[3]={0.0};
	if(count==1){
	places[0]=0.5;
	}else if(count==2){
	places[0]=0.35;
	places[1]=0.65;
	}else if(count==3){
	places[0]=0.25;
	places[1]=0.5;
	places[2]=0.75;
	}

	std::vector<GUIButton*> buttons;

	//Loop to add the buttons.
	for(int i=0;i<count;i++){
	GUIButton* obj = new GUIButton(imageManager, renderer, root->width*places[i], y, -1, 36, button[i].c_str(), value[i], true, true, GUIGravityCenter);
	obj->eventCallback=&objHandler;
	buttons.push_back(obj);
	root->addChild(obj);
	}

	//Update widgets
	for (int i = 0; i < count; i++) {
	buttons[i]->render(renderer, 0, 0, false);
	}

	bool overlap = false;

	//Check if they overlap
	if (buttons[0]->left - buttons[0]->gravityX < 5 \|\|
	buttons[count - 1]->left - buttons[count - 1]->gravityX + buttons[count - 1]->width > root->width - 5)
	{
	overlap = true;
	} else {
	for (int i = 0; i < count - 1; i++) {
	if (buttons[i]->left - buttons[i]->gravityX + buttons[i]->width >= buttons[i + 1]->left - buttons[i + 1]->gravityX) {
	overlap = true;
	break;
	}
	}
	}

	//Shrink the font size if any buttons are overlap
	if (overlap) {
	for (int i = 0; i < count; i++) {
	buttons[i]->smallFont = true;
	buttons[i]->width = -1;
	}
	}
	}

	//Now we dim the screen and keep the GUI rendering/updating.
	GUIOverlay* overlay=new GUIOverlay(renderer,root);
	overlay->keyboardNavigationMode = LeftRightFocus \| UpDownFocus \| TabFocus \| ((count == 1) ? 0 : ReturnControls);
	overlay->enterLoop(imageManager, renderer, true, count == 1);

	//And return the result.
	return (msgBoxResult)objHandler.ret;
	}

	// A helper function to read a character from utf8 string
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadForward(const char* s, int& p) {
	int ch = (unsigned char)s[p];
	if (ch < 0x80){
	if (ch) p++;
	return ch;
	} else if (ch < 0xC0){
	// skip invalid characters
	while (((unsigned char)s[p] & 0xC0) == 0x80) p++;
	return -1;
	} else if (ch < 0xE0){
	int c2 = (unsigned char)s[++p];
	if ((c2 & 0xC0) != 0x80) return -1;

	ch = ((ch & 0x1F) << 6) \| (c2 & 0x3F);
	p++;
	return ch;
	} else if (ch < 0xF0){
	int c2 = (unsigned char)s[++p];
	if ((c2 & 0xC0) != 0x80) return -1;
	int c3 = (unsigned char)s[++p];
	if ((c3 & 0xC0) != 0x80) return -1;

	ch = ((ch & 0xF) << 12) \| ((c2 & 0x3F) << 6) \| (c3 & 0x3F);
	p++;
	return ch;
	} else if (ch < 0xF8){
	int c2 = (unsigned char)s[++p];
	if ((c2 & 0xC0) != 0x80) return -1;
	int c3 = (unsigned char)s[++p];
	if ((c3 & 0xC0) != 0x80) return -1;
	int c4 = (unsigned char)s[++p];
	if ((c4 & 0xC0) != 0x80) return -1;

	ch = ((ch & 0x7) << 18) \| ((c2 & 0x3F) << 12) \| ((c3 & 0x3F) << 6) \| (c4 & 0x3F);
	if (ch >= 0x110000) ch = -1;
	p++;
	return ch;
	} else {
	p++;
	return -1;
	}
	}

	// A helper function to read a character backward from utf8 string (experimental)
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadBackward(const char* s, int& p) {
	if (p <= 0) return 0;

	do {
	p--;
	} while (p > 0 && ((unsigned char)s[p] & 0xC0) == 0x80);

	int tmp = p;
	return utf8ReadForward(s, tmp);
	}

	#ifndef WIN32

	// ad-hoc function to check if a program is installed
	static bool programExists(const std::string& program) {
	std::string p = tfm::format("which \"%s\" 2>&1", program);

	const int BUFSIZE = 128;

	char buf[BUFSIZE];
	FILE *fp;

	if ((fp = popen(p.c_str(), "r")) == NULL) {
	return false;
	}

	while (fgets(buf, BUFSIZE, fp) != NULL) {
	// Drop all outputs since 'which' returns -1 when the program is not found
	}

	if (pclose(fp)) {
	return false;
	}

	return true;
	}

	#endif

	void openWebsite(const std::string& url) {
	#ifdef WIN32
	wchar_t ws[4096];
	TO_UTF16(url.c_str(), ws);
	SDL_SysWMinfo info = {};
	SDL_VERSION(&info.version);
	SDL_GetWindowWMInfo(sdlWindow, &info);
	ShellExecuteW(info.info.win.window, L"open", ws, NULL, NULL, SW_SHOW);
	#else
	static int method = -1;

	// Some of these methods are copied from https://stackoverflow.com/questions/5116473/

	const char* methods[] = {
	"xdg-open", "xdg-open \"%s\"",
	"gnome-open", "gnome-open \"%s\"",
	"kde-open", "kde-open \"%s\"",
	"open", "open \"%s\"",
	"python", "python -m webbrowser \"%s\"",
	"sensible-browser", "sensible-browser \"%s\"",
	"x-www-browser", "x-www-browser \"%s\"",
	NULL,
	};

	if (method < 0) {
	for (method = 0; methods[method]; method += 2) {
	if (programExists(methods[method])) break;
	}
	}

	if (methods[method]) {
	std::string p = tfm::format(methods[method + 1], url);
	system(p.c_str());
	} else {
	fprintf(stderr, "TODO: openWebsite is not implemented on your system\n");
	}
	#endif
	}

	std::string appendURLToLicense(const std::string& license) {
	// if the license doesn't include url, try to detect it from a predefined list
	if (license.find("://") == std::string::npos) {
	std::string normalized;
	for (char c : license) {
	if ((c >= '0' && c <= '9') \|\| (c >= 'A' && c <= 'Z')) {
	normalized.push_back(c);
	} else if (c >= 'a' && c <= 'z') {
	normalized.push_back(c + ('A' - 'a'));
	}
	}

	const char* licenses[] = {
	// AGPL
	"AGPL1", "AGPLV1", NULL, "http://www.affero.org/oagpl.html",
	"AGPL2", "AGPLV2", NULL, "http://www.affero.org/agpl2.html",
	"AGPL", NULL, "https://gnu.org/licenses/agpl.html",
	// LGPL
	"LGPL21", "LGPLV21", NULL, "https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html",
	"LGPL2", "LGPLV2", NULL, "https://www.gnu.org/licenses/old-licenses/lgpl-2.0.html",
	"LGPL", NULL, "https://www.gnu.org/copyleft/lesser.html",
	// GPL
	"GPL1", "GPLV1", NULL, "https://www.gnu.org/licenses/old-licenses/gpl-1.0.html",
	"GPL2", "GPLV2", NULL, "https://www.gnu.org/licenses/old-licenses/gpl-2.0.html",
	"GPL", NULL, "https://gnu.org/licenses/gpl.html",
	// CC BY-NC-ND
	"CCBYNCND1", "CCBYNDNC1", NULL, "https://creativecommons.org/licenses/by-nd-nc/1.0",
	"CCBYNCND25", "CCBYNDNC25", NULL, "https://creativecommons.org/licenses/by-nc-nd/2.5",
	"CCBYNCND2", "CCBYNDNC2", NULL, "https://creativecommons.org/licenses/by-nc-nd/2.0",
	"CCBYNCND3", "CCBYNDNC3", NULL, "https://creativecommons.org/licenses/by-nc-nd/3.0",
	"CCBYNCND", "CCBYNDNC", NULL, "https://creativecommons.org/licenses/by-nc-nd/4.0",
	// CC BY-NC-SA
	"CCBYNCSA1", NULL, "https://creativecommons.org/licenses/by-nc-sa/1.0",
	"CCBYNCSA25", NULL, "https://creativecommons.org/licenses/by-nc-sa/2.5",
	"CCBYNCSA2", NULL, "https://creativecommons.org/licenses/by-nc-sa/2.0",
	"CCBYNCSA3", NULL, "https://creativecommons.org/licenses/by-nc-sa/3.0",
	"CCBYNCSA", NULL, "https://creativecommons.org/licenses/by-nc-sa/4.0",
	// CC BY-ND
	"CCBYND1", NULL, "https://creativecommons.org/licenses/by-nd/1.0",
	"CCBYND25", NULL, "https://creativecommons.org/licenses/by-nd/2.5",
	"CCBYND2", NULL, "https://creativecommons.org/licenses/by-nd/2.0",
	"CCBYND3", NULL, "https://creativecommons.org/licenses/by-nd/3.0",
	"CCBYND", NULL, "https://creativecommons.org/licenses/by-nd/4.0",
	// CC BY-NC
	"CCBYNC1", NULL, "https://creativecommons.org/licenses/by-nc/1.0",
	"CCBYNC25", NULL, "https://creativecommons.org/licenses/by-nc/2.5",
	"CCBYNC2", NULL, "https://creativecommons.org/licenses/by-nc/2.0",
	"CCBYNC3", NULL, "https://creativecommons.org/licenses/by-nc/3.0",
	"CCBYNC", NULL, "https://creativecommons.org/licenses/by-nc/4.0",
	// CC BY-SA
	"CCBYSA1", NULL, "https://creativecommons.org/licenses/by-sa/1.0",
	"CCBYSA25", NULL, "https://creativecommons.org/licenses/by-sa/2.5",
	"CCBYSA2", NULL, "https://creativecommons.org/licenses/by-sa/2.0",
	"CCBYSA3", NULL, "https://creativecommons.org/licenses/by-sa/3.0",
	"CCBYSA", NULL, "https://creativecommons.org/licenses/by-sa/4.0",
	// CC BY
	"CCBY1", NULL, "https://creativecommons.org/licenses/by/1.0",
	"CCBY25", NULL, "https://creativecommons.org/licenses/by/2.5",
	"CCBY2", NULL, "https://creativecommons.org/licenses/by/2.0",
	"CCBY3", NULL, "https://creativecommons.org/licenses/by/3.0",
	"CCBY", NULL, "https://creativecommons.org/licenses/by/4.0",
	// CC0
	"CC0", NULL, "https://creativecommons.org/publicdomain/zero/1.0",
	// WTFPL
	"WTFPL", NULL, "http://www.wtfpl.net/",
	// end
	NULL,
	};

	for (int i = 0; licenses[i]; i++) {
	bool found = false;
	for (; licenses[i]; i++) {
	if (normalized.find(licenses[i]) != std::string::npos) found = true;
	}
	i++;
	if (found) {
	return license + tfm::format(" <%s>", licenses[i]);
	}
	}
	}

	return license;
	}

	int getKeyboardRepeatDelay() {
	static int ret = -1;

	if (ret < 0) {
	#ifdef WIN32
	int i = 0;
	SystemParametersInfoW(SPI_GETKEYBOARDDELAY, 0, &i, 0);
	// NOTE: these weird numbers are derived from Microsoft's documentation explaining the return value of SystemParametersInfo.
	i = clamp(i, 0, 3);
	ret = (i + 1) * 10;
	#else
	// TODO: platform-dependent code
	// Assume it's 250ms, i.e. 10 frames
	ret = 10;
	#endif
	// Debug
	#ifdef _DEBUG
	printf("getKeyboardRepeatDelay() = %d\n", ret);
	#endif
	}

	return ret;
	}

	int getKeyboardRepeatInterval() {
	static int ret = -1;

	if (ret < 0) {
	#ifdef WIN32
	int i = 0;
	SystemParametersInfoW(SPI_GETKEYBOARDSPEED, 0, &i, 0);
	// NOTE: these weird numbers are derived from Microsoft's documentation explaining the return value of SystemParametersInfo.
	i = clamp(i, 0, 31);
	ret = (int)floor(40.0f / (2.5f + 0.887097f * (float)i) + 0.5f);
	#else
	// TODO: platform-dependent code
	// Assume it's 25ms, i.e. 1 frame
	ret = 1;
	#endif
	// Debug
	#ifdef _DEBUG
	printf("getKeyboardRepeatInterval() = %d\n", ret);
	#endif
	}

	return ret;
	}
	diff --git a/src/Functions.h b/src/Functions.h
	index d86784b..2319404 100644
	--- a/src/Functions.h
	+++ b/src/Functions.h
	@@ -1,294 +1,300 @@
	/*
	* 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 FUNCTIONS_H
	#define FUNCTIONS_H

	#include "Settings.h"

	#include "Globals.h"

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

	class MusicManager;
	class SoundManager;

	//gettext function
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _(message) (dictionaryManager!=NULL?dictionaryManager->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//gettext function
	//NOTE: "_C" is conflict to some Android macros so we change its name.
	//dictionaryManager: Pointer to the dictionaryManager to use for the translation.
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _CC(dictionaryManager, message) ((dictionaryManager)!=NULL?(dictionaryManager)->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//dummy function for xgettext
	//message: The message to translate.
	//Returns: message parameter
	#define __(message) (message)

	class ImageManager;
	struct SDL_Texture;
	class LevelPackManager;

	+//gettext function for contexts
	+//context: The context of the message.
	+//message: The message to translate.
	+//Returns: The translated string or the original string if there are no translations available.
	+std::string pgettext(const std::string& context, const std::string& message);
	+
	//gettext function for plural forms
	//message: The singular version of the message to translate.
	//messageplural: The plural version of the message to translate.
	//num: The number to fetch the plural form for
	//Returns: The translated string or the original string if there are no translations available.
	std::string ngettext(const std::string& message, const std::string& messageplural, int num);

	//Method for drawing an SDL_Surface onto another.
	//x: The x location to draw the source on the desination.
	//y: The y location to draw the source on the desination.
	//source: The SDL_Surface to draw.
	//dest: The SDL_Surface to draw on.
	//clip: Rectangle which part of the source should be drawn.
	void applySurface(int x,int y,SDL_Surface* source,SDL_Surface* dest,SDL_Rect* clip);

	//Method used to draw an rectangle.
	//x: The top left x location of the rectangle.
	//y: The top left y location of the rectangle.
	//w: The width of the rectangle,
	//h: The height of the rectangle.
	//dest: The SDL_Surface to draw on.
	//color: The color of the rectangle border to draw.
	void drawRect(int x, int y, int w, int h, SDL_Renderer &renderer, Uint32 color=0);

	//Method used to draw filled boxes with an anti-alliased border.
	//Mostly used for GUI components.
	//x: The top left x location of the box.
	//y: The top left y location of the box.
	//w: The width of the box,
	//h: The height of the box.
	//renderer: The SDL_Renderer to render on..
	//color: The color of the rectangle background to draw.
	void drawGUIBox(int x,int y,int w,int h,SDL_Renderer& renderer,Uint32 color);

	//Method used to draw a line.
	//x1: The x location of the start point.
	//y1: The y location of the start point.
	//x2: The x location of the end point.
	//y2: The y location of the end point.
	//dest: The SDL_Surface to draw on.
	//color: The color of the line to draw.
	void drawLine(int x1,int y1,int x2,int y2,SDL_Renderer &renderer,Uint32 color=0);

	//Method used to draw a line with some arrows on it.
	//x1: The x location of the start point.
	//y1: The y location of the start point.
	//x2: The x location of the end point.
	//y2: The y location of the end point.
	//dest: The SDL_Surface to draw on.
	//color: The color of the line to draw.
	//spacing: The spacing between arrows.
	//offset: Offset of first arrow relative to the start point.
	//xize, ysize: The size of arrow.
	void drawLineWithArrow(int x1, int y1, int x2, int y2, SDL_Renderer &renderer, Uint32 color=0, int spacing=16, int offset=0, int xsize=5, int ysize=5);

	//Method that will load the fonts needed for the game.
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing the language.
	bool loadFonts();
	//Method that will load the default theme again.
	//name: name of the theme to load or empty for scaling background
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing resolution.
	bool loadTheme(ImageManager& imageManager, SDL_Renderer& renderer, std::string name);

	struct ScreenData{
	SDL_Renderer* renderer;
	explicit operator bool() const {
	return renderer!=nullptr;
	}
	};

	//This method will attempt to create the screen/window.
	//NOTE: It's separate from init(), since it might get called separatly from the code when changing resolution.
	ScreenData createScreen();

	//Method for retrieving a list of resolutions.
	std::vector<SDL_Point> getResolutionList();
	//Method that is called when a fullscreen window is created.
	//It will choose the resolution that is closest to the configured one.
	void pickFullscreenResolution();

	//This method is used to configure the window that is created by createScreen.
	//NOTE: It will do it in a WM specific way, so if the wm is unkown it will do nothing.
	void configureWindow();

	//Call this method when receive SDL_VIDEORESIZE event.
	void onVideoResize(ImageManager &imageManager, SDL_Renderer& renderer);

	//Initialises the game. This is done almost at the beginning of the program.
	//It initialises: SDL, SDL_Mixer, SDL_ttf, the screen and the block types.
	//Returns: True if everything goes well.
	ScreenData init();
	//Loads some important files, like the background music and the default theme.
	//Returns: True if everything goes well.
	bool loadFiles(ImageManager &imageManager, SDL_Renderer &renderer);

	//This method will load the settings from the settings file.
	//Returns: False if there's an error while loading.
	bool loadSettings();
	//This method will save the settings to the settings file.
	//Returns: False if there's an error while saving.
	bool saveSettings();
	//Method used to get a pointer to the settings object.
	//Returns: A pointer to the settings object.
	Settings* getSettings();

	//Method used to get a pointer to the MusicManager object.
	//Returns: A pointer to the MusicManager object.
	MusicManager* getMusicManager();

	//Method used to get a pointer to the SoundManager object.
	//Returns: A pointer to the SoundManager object.
	SoundManager* getSoundManager();

	//Method used to get a pointer to the LevelPackManager object.
	//Returns: A pointer to the LevelPackManager object.
	LevelPackManager* getLevelPackManager();

	//Method that will, depending on the rendering backend, draw the screen surface to the screen.
	void flipScreen(SDL_Renderer& renderer);

	//Method used to clean up before quiting meandmyshadow.
	void clean();

	//Sets what the nextState will be.
	//newstate: Integer containing the id of the newstate.
	void setNextState(int newstate);
	//Method that will perform the state change.
	//It will fade out (but not fade in).
	void changeState(ImageManager &imageManager, SDL_Renderer &renderer, int fade = 255);

	//This method is called when music is stopped.
	//NOTE: This method is outside the MusicManager because it can't be called otherwise by SDL_Mixer.
	//Do not call this method anywhere in the code!
	void musicStoppedHook();

	//This method is called when a sfx finished playing.
	//NOTE: This method is outside the SoundManager because it can't be called otherwise by SDL_Mixer.
	//Do not call this method anywhere in the code!
	//channel: The number of the channel that is finished.
	void channelFinishedHook(int channel);

	//Checks collision between two SDL_Rects.
	//a: The first rectangle.
	//b: The second rectangle.
	//Returns: True if the two rectangles collide.
	bool checkCollision(const SDL_Rect& a,const SDL_Rect& b);

	//Checks if a given point lays on an SDL_Rect
	//point: The point to check.
	//rect: The rectangle to check.
	//Returns: True if the point is on the rectangle.
	bool pointOnRect(const SDL_Rect& a,const SDL_Rect& b);

	//Parse the commandline arguments.
	//argc: Integer containing the number of aruguments there are.
	//argv: The arguments.
	//Returns: -1 if something goes wrong while parsing,
	// 0 if version is shown,
	// 1 if everything is alright
	int parseArguments(int argc, char** argv);

	//From http://en.wikipedia.org/wiki/Clamping_(graphics)
	//x: The value to clamp.
	//min: The minimum x can be.
	//max: The maximum x can be.
	//Returns: Integer containing the clamped value.
	int inline clamp(int x,int min,int max){
	return (x>max)?max:(x<min)?min:x;
	}

	//Enumeration containing the different messagebox button combinations.
	enum msgBoxButtons{
	//Only one button with the text OK.
	MsgBoxOKOnly=0,
	//Two buttons, one saying OK, the other Cancel.
	MsgBoxOKCancel=1,
	//Three buttons, Abort, Retry, Ignore.
	MsgBoxAbortRetryIgnore=2,
	//Three buttons, Yes, No or Cancel.
	MsgBoxYesNoCancel=3,
	//Two buttons, one saying Yes, the other No.
	MsgBoxYesNo=4,
	//Two buttons, one saying Retry, the other Cancel.
	MsgBoxRetryCancel=5,
	};

	//Enumeration containing the different result that can be retrieved from a messagebox.
	//It represents the button that has been pressed.
	enum msgBoxResult{
	//The OK button.
	MsgBoxOK=1,
	//The cancel button.
	MsgBoxCancel=2,
	//The abort button.
	MsgBoxAbort=3,
	//The retry button.
	MsgBoxRetry=4,
	//The ignore button.
	MsgBoxIgnore=5,
	//The yes button.
	MsgBoxYes=6,
	//The no button.
	MsgBoxNo=7,
	};

	//Method that prompts the user with a notification and/or question.
	//prompt: The message the user is prompted with.
	//buttons: Which buttons the messagebox should have.
	//title: The title of the message box.
	//Returns: A msgBoxResult which button has been pressed.
	msgBoxResult msgBox(ImageManager& imageManager,SDL_Renderer& renderer, const std::string& prompt,msgBoxButtons buttons,const std::string& title);

	// A helper function to read a character from utf8 string
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadForward(const char* s, int& p);

	// A helper function to read a character backward from utf8 string (experimental)
	// s: the string
	// p [in,out]: the position
	// return value: the character readed, in utf32 format, 0 means end of string, -1 means error
	int utf8ReadBackward(const char* s, int& p);

	// Open the website using default web browser.
	// url: The url of the website. Currently only http and https are supported.
	// Also we assume that the url only contains ASCII characters.
	// WARNING: Passing other url may result in arbitrary behavior (esp. passing '*.exe' on Windows).
	void openWebsite(const std::string& url);

	// Append a URL to a license if the license doesn't include URL (try to detect it from a predefined list).
	// license: The license.
	// Return value: The license appended with a URL if we detect the license successfully.
	std::string appendURLToLicense(const std::string& license);

	// Retrieves the (approximate) keyboard repeat delay time, in frames (NOTE: frame rate is hardcoded as 40).
	int getKeyboardRepeatDelay();

	// Retrieves the (approximate) keyboard repeat interval time, in frames (NOTE: frame rate is hardcoded as 40).
	int getKeyboardRepeatInterval();

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

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

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

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

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

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

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

	+//An internal function.
	+static void copyLevelObjects(const std::vector<Block>& src, std::vector<Block>& dest, bool setActive) {
	+ //Clear the existing objects.
	+ for (auto o : dest) delete o;
	+ dest.clear();
	+
	+ //Copy the source to the destination.
	+ for (auto o : src) {
	+ if (o == NULL \|\| o->isDelete) continue;
	+ Block* o2 = new Block(*o);
	+ dest.push_back(o2);
	+ if (setActive) o2->setActive();
	+ }
	+}
	+
	Game::Game(SDL_Renderer &renderer, ImageManager &imageManager):isReset(false)
	, scriptExecutor(new ScriptExecutor())
	,currentLevelNode(NULL)
	,customTheme(NULL)
	,background(NULL)
	+ , levelRect(SDL_Rect{ 0, 0, 0, 0 }), levelRectSaved(SDL_Rect{ 0, 0, 0, 0 }), levelRectInitial(SDL_Rect{ 0, 0, 0, 0 })
	+ , arcade(false)
	,won(false)
	,interlevel(false)
	,gameTipIndex(0)
	,time(0),timeSaved(0)
	,recordings(0),recordingsSaved(0)
	,cameraMode(CAMERA_PLAYER),cameraModeSaved(CAMERA_PLAYER)
	,player(this),shadow(this),objLastCheckPoint(NULL)
	- ,currentCollectables(0),totalCollectables(0),currentCollectablesSaved(0){
	+ , currentCollectables(0), currentCollectablesSaved(0), currentCollectablesInitial(0)
	+ , totalCollectables(0), totalCollectablesSaved(0), totalCollectablesInitial(0)
	+{

	saveStateNextTime=false;
	loadStateNextTime=false;

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

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

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

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

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

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

	- //Loop through the levelObjects and delete them.
	- for(unsigned int i=0;i<levelObjects.size();i++)
	- delete levelObjects[i];
	- //Done now clear the levelObjects vector.
	+ //Loop through the levelObjects, etc. and delete them.
	+ for (auto o : levelObjects) delete o;
	levelObjects.clear();
	-
	+
	+ for (auto o : levelObjectsSave) delete o;
	+ levelObjectsSave.clear();
	+
	+ for (auto o : levelObjectsInitial) delete o;
	+ levelObjectsInitial.clear();
	+
	//Loop through the sceneryLayers and delete them.
	for(auto it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	delete it->second;
	}
	sceneryLayers.clear();

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

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

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

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

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

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

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

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

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

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

	//Set the level dimensions to the default, it will probably be changed by the editorData,
	//but 800x600 is a fallback.
	- LEVEL_WIDTH=800;
	- LEVEL_HEIGHT=600;
	+ levelRect = levelRectSaved = levelRectInitial = SDL_Rect{ 0, 0, 800, 600 };

	- currentCollectables=0;
	- totalCollectables=0;
	- currentCollectablesSaved=0;
	+ currentCollectables = currentCollectablesSaved = currentCollectablesInitial = 0;
	+ totalCollectables = totalCollectablesSaved = totalCollectablesInitial = 0;

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

	+ //Get the arcade property.
	+ {
	+ string &s = editorData["arcade"];
	+ arcade = atoi(s.c_str()) != 0;
	+ }
	+
	//Get the theme.
	{
	//NOTE: level themes are always enabled.

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

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

	//Set the Appearance of the player and the shadow.
	- objThemes.getCharacter(false)->createInstance(&player.appearance);
	- objThemes.getCharacter(true)->createInstance(&shadow.appearance);
	+ objThemes.getCharacter(false)->createInstance(&player.appearance, "standright");
	+ player.appearanceInitial = player.appearanceSave = player.appearance;
	+ objThemes.getCharacter(true)->createInstance(&shadow.appearance, "standright");
	+ shadow.appearanceInitial = shadow.appearanceSave = shadow.appearance;
	}

	//Get the music.
	reloadMusic();

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

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

	//Add the block to the levelObjects vector.
	levelObjects.push_back(block);
	}else if(obj1->name=="scenerylayer" && obj1->value.size()==1){
	//Check if the layer exists.
	if (sceneryLayers[obj1->value[0]] == NULL) {
	sceneryLayers[obj1->value[0]] = new SceneryLayer();
	}

	//Load contents from node.
	sceneryLayers[obj1->value[0]]->loadFromNode(this, imageManager, renderer, obj1);
	}else if(obj1->name=="script" && !obj1->value.empty()){
	map<string,int>::iterator it=Game::levelEventNameMap.find(obj1->value[0]);
	if(it!=Game::levelEventNameMap.end()){
	int eventType=it->second;
	const std::string& script=obj1->attributes["script"][0];
	if(!script.empty()) scripts[eventType]=script;
	}
	}
	}

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

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

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

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

	//Now the loading is finished, we reset all objects to their initial states.
	+ //Before doing that we swap the levelObjects to levelObjectsInitial.
	+ std::swap(levelObjects, levelObjectsInitial);
	reset(true, stateID == STATE_LEVEL_EDITOR);
	}

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

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

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

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

	TreeStorageNode obj;
	POASerializer objSerializer;

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

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

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

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

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

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

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

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

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

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

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

	+ //Load the seed of psuedo-random number generator.
	+ prngSeed.clear();
	+ {
	+ auto it = obj.attributes.find("seed");
	+ if (it != obj.attributes.end() && !it->second.empty()) {
	+ prngSeed = it->second[0];
	+ }
	+ }
	+
	//find the node named 'map'.
	bool loaded=false;
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	if(obj.subNodes[i]->name=="map"){
	//load the level. (fileName=???)
	- loadLevelFromNode(imageManager,renderer,obj.subNodes[i],"???");
	+ loadLevelFromNode(imageManager,renderer,obj.subNodes[i],"?record?");
	//remove this node to prevent delete it.
	obj.subNodes[i]=NULL;
	//over
	loaded=true;
	break;
	}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	//NOTE: This code reverts some changes in commit 5f03ae5.
	//This is part of old prepareFrame() code.
	//This is needed since otherwise the script function block:setLocation() and block:moveTo() are completely broken.
	//Later we should rewrite collision system completely which will remove this piece of code.
	//NOTE: In new collision system the effect of dx/dy/xVel/yVel should only be restricted in one frame.
	for (auto obj : levelObjects) {
	switch (obj->type) {
	default:
	obj->dx = obj->dy = obj->xVel = obj->yVel = 0;
	break;
	case TYPE_PUSHABLE:
	//NOTE: Currently the dx/dy/etc. of pushable blocks are still carry across frames, in order to make the collision system work correct.
	break;
	case TYPE_CONVEYOR_BELT: case TYPE_SHADOW_CONVEYOR_BELT:
	//NOTE: We let the conveyor belt itself to reset its xVel/yVel.
	obj->dx = obj->dy = 0;
	break;
	}
	}

	//NOTE2: The above code breaks pushable block with moving block in most cases,
	//more precisely, if the pushable block is processed before the moving block then things may be broken.
	+ //Therefore later we must process other blocks before moving pushable block.

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

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

	//Check if the it has an id attached to it.
	if(e.target){
	//NOTE: Should we check if the target still exists???
	e.target->onEvent(e.eventType);
	}else if(e.flags&1){
	//Loop through the levelObjects and give them the event if they have the right id.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	if(levelObjects[i]->id==e.id){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}else{
	//Loop through the levelObjects and give them the event.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}
	//Done processing the events so clear the queue.
	eventQueue.clear();
	-
	+
	+ //Remove levelObjects whose isDelete is true.
	+ {
	+ int j = 0;
	+ for (int i = 0; i < (int)levelObjects.size(); i++) {
	+ if (levelObjects[i] == NULL) {
	+ j++;
	+ } else if (levelObjects[i]->isDelete) {
	+ delete levelObjects[i];
	+ levelObjects[i] = NULL;
	+ j++;
	+ } else if (j > 0) {
	+ levelObjects[i - j] = levelObjects[i];
	+ }
	+ }
	+ if (j > 0) levelObjects.resize(levelObjects.size() - j);
	+ }
	+
	//Check if we should save/load state.
	//NOTE: This happens after event handling so no eventQueue has to be saved/restored.
	if(saveStateNextTime){
	saveState();
	}else if(loadStateNextTime){
	loadState();
	}
	saveStateNextTime=false;
	loadStateNextTime=false;

	//Loop through the gameobjects to update them.
	for(unsigned int i=0;i<levelObjects.size();i++){
	//Send GameObjectEvent_OnEnterFrame event to the script
	levelObjects[i]->onEvent(GameObjectEvent_OnEnterFrame);
	}
	//Let the gameobject handle movement.
	{
	std::vector<Block*> pushableBlocks;

	//First we process blocks which are not pushable blocks.
	for (auto o : levelObjects) {
	if (o->type == TYPE_PUSHABLE) {
	pushableBlocks.push_back(o);
	} else {
	o->move();
	}
	}

	//Sort pushable blocks by their position, which is an ad-hoc workaround for
	//<https://forum.freegamedev.net/viewtopic.php?f=48&t=8047#p77692>.
	std::stable_sort(pushableBlocks.begin(), pushableBlocks.end(),
	[](const Block* obj1, const Block* obj2)->bool
	{
	SDL_Rect r1 = const_cast<Block>(obj1)->getBox(), r2 = const_cast<Block>(obj2)->getBox();
	if (r1.y > r2.y) return true;
	else if (r1.y < r2.y) return false;
	else return r1.x < r2.x;
	});

	//Now we process pushable blocks.
	for (auto o : pushableBlocks) {
	o->move();
	}
	}
	//Also update the scenery.
	for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it){
	it->second->updateAnimation();
	}

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

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

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

	//NOTE: The following is ad-hoc code to fix shadow on blocked player on conveyor belt bug
	if (shadow.holdingOther) {
	//We need to process shadow collision first if shadow is holding player.

	//Let the shadow decide his move, if he's playing a recording.
	shadow.moveLogic();

	//Check collision for shadow.
	shadow.collision(levelObjects, NULL);

	//Get the new position of it.
	const SDL_Rect r = shadow.getBox();

	//Check collision for player. Transfer the velocity of shadow to it only if the shadow moves its position.
	player.collision(levelObjects, (r.x != shadowLastPosition.x \|\| r.y != shadowLastPosition.y) ? &shadow : NULL);
	} else {
	//Otherwise we process player first.

	//Check collision for player.
	player.collision(levelObjects, NULL);

	//Get the new position of it.
	const SDL_Rect r = player.getBox();

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

	//Check collision for shadow. Transfer the velocity of player to it only if the player moves its position.
	shadow.collision(levelObjects, (r.x != playerLastPosition.x \|\| r.y != playerLastPosition.y) ? &player : NULL);
	}

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

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

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

	//Check if we won.
	if(won){
	//Check if it's playing from record
	if(player.isPlayFromRecord() && !interlevel){
	recordingEnded(imageManager,renderer);
	}else{
	- //the string to store auto-save record path.
	- string bestTimeFilePath,bestRecordingFilePath;
	- //and if we can't get test path.
	- bool filePathError=false;
	+ //Local copy of interlevel property since the replayPlay() will change it later.
	+ const bool previousInterlevel = interlevel;

	- //Get current level
	- LevelPack::Level *level=levels->getLevel();
	+ //We only update the level statistics when the previous state is not interlevel mode.
	+ if (!previousInterlevel) {
	+ //the string to store auto-save record path.
	+ string bestTimeFilePath, bestRecordingFilePath;
	+ //and if we can't get test path.
	+ bool filePathError = false;

	- //Now check if we should update statistics
	- {
	- //Get previous and current medal
	- int oldMedal=level->won?1:0,newMedal=1;
	-
	- int bestTime=level->time;
	- int targetTime=level->targetTime;
	- int bestRecordings=level->recordings;
	- int targetRecordings=level->targetRecordings;
	-
	- if(oldMedal){
	- if(bestTime>=0 && (targetTime<0 \|\| bestTime<=targetTime))
	- oldMedal++;
	- if(bestRecordings>=0 && (targetRecordings<0 \|\| bestRecordings<=targetRecordings))
	- oldMedal++;
	- }else{
	- bestTime=time;
	- bestRecordings=recordings;
	- }
	+ //Get current level
	+ LevelPack::Level *level = levels->getLevel();

	- if(bestTime<0 \|\| bestTime>time) bestTime=time;
	- if(bestRecordings<0 \|\| bestRecordings>recordings) bestRecordings=recordings;
	+ //Get previous medal
	+ const int oldMedal = level->getMedal();

	- if(targetTime<0 \|\| bestTime<=targetTime)
	- newMedal++;
	- if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	- newMedal++;
	+ const int betterTime = level->getBetterTime(time);
	+ const int betterRecordings = level->getBetterRecordings(level->arcade ? currentCollectables : recordings);
	+
	+ //Get new medal
	+ const int newMedal = level->getMedal(betterTime, betterRecordings);

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

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

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

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

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

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

	- //Update achievements
	- if(levels->levelpackName=="tutorial") statsMgr.updateTutorialAchievements();
	- statsMgr.updateLevelAchievements();
	+ //Update achievements (only when the previous state is not interlevel mode)
	+ if (!previousInterlevel) {
	+ if (levels->levelpackName == "tutorial") statsMgr.updateTutorialAchievements();
	+ statsMgr.updateLevelAchievements();
	+ }

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

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

	-// ad-hoc function which only works for ASC characters (but it doesn't ruin UTF-8 characters)
	-static inline char myToupper(char c) {
	- if (c >= 'a' && c <= 'z') {
	- return c + ('A' - 'a');
	- } else {
	- return c;
	- }
	-}
	-
	/////////////////RENDER//////////////////
	void Game::render(ImageManager&,SDL_Renderer &renderer){
	//First of all render the background.
	{
	//Get a pointer to the background.
	ThemeBackground* bg=background;

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

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

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

	//Now draw the blackground layers.
	auto it = sceneryLayers.begin();
	for (; it != sceneryLayers.end(); ++it){
	if (it->first >= "f") break; // now we meet a foreground layer
	it->second->show(renderer);
	}

	//Now we draw the levelObjects.
	{
	//NEW: always render the pushable blocks in front of other blocks
	std::vector<Block*> pushableBlocks;

	for (auto o : levelObjects) {
	if (o->type == TYPE_PUSHABLE) {
	pushableBlocks.push_back(o);
	} else {
	o->show(renderer);
	}
	}

	for (auto o : pushableBlocks) {
	o->show(renderer);
	}
	}

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

	//Now draw the foreground layers.
	for (; it != sceneryLayers.end(); ++it){
	it->second->show(renderer);
	}

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

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

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

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

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

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

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

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

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

	//Show the number of collectables the user has collected if there are collectables in the level.
	//We hide this when interlevel.
	- if(currentCollectables<=totalCollectables && totalCollectables!=0 && !interlevel && time>0){
	- if(collectablesTexture.needsUpdate(currentCollectables)) {
	- collectablesTexture.update(currentCollectables,
	- textureFromText(renderer,
	- *fontText,
	- tfm::format("%d/%d", currentCollectables, totalCollectables).c_str(),
	- objThemes.getTextColor(true)));
	- }
	+ if ((currentCollectables \|\| totalCollectables) && !interlevel && time>0){
	+ if (arcade) {
	+ //Only show the current collectibles in arcade mode.
	+ if (collectablesTexture.needsUpdate(currentCollectables)) {
	+ collectablesTexture.update(currentCollectables,
	+ textureFromText(renderer,
	+ *fontText,
	+ tfm::format("%d", currentCollectables).c_str(),
	+ objThemes.getTextColor(true)));
	+ }
	+ } else {
	+ if (collectablesTexture.needsUpdate(currentCollectables ^ (totalCollectables << 16))) {
	+ collectablesTexture.update(currentCollectables ^ (totalCollectables << 16),
	+ textureFromText(renderer,
	+ *fontText,
	+ tfm::format("%d/%d", currentCollectables, totalCollectables).c_str(),
	+ objThemes.getTextColor(true)));
	+ }
	+ }
	SDL_Rect bmSize = rectFromTexture(*collectablesTexture.get());

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

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

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

	- //show time and records used in level editor or during replay.
	- if((stateID==STATE_LEVEL_EDITOR \|\| (!interlevel && player.isPlayFromRecord())) && time>0){
	+ //show time and records used in level editor or during replay or in arcade mode.
	+ if ((stateID == STATE_LEVEL_EDITOR \|\| (!interlevel && (player.isPlayFromRecord() \|\| arcade))) && time>0){
	const SDL_Color fg=objThemes.getTextColor(true),bg={255,255,255,255};
	const int alpha = 160;
	- if (recordingsTexture.needsUpdate(recordings)) {
	+
	+ //don't show number of records in arcade mode
	+ if (!arcade && recordingsTexture.needsUpdate(recordings)) {
	recordingsTexture.update(recordings,
	textureFromTextShaded(
	renderer,
	*fontText,
	tfm::format(ngettext("%d recording","%d recordings",recordings).c_str(),recordings).c_str(),
	fg,
	bg
	));
	SDL_SetTextureAlphaMod(recordingsTexture.get(),alpha);
	}

	- int y=SCREEN_HEIGHT - textureHeight(*recordingsTexture.get());
	+ int y = SCREEN_HEIGHT - (arcade ? 0 : textureHeight(*recordingsTexture.get()));
	if (stateID != STATE_LEVEL_EDITOR && bmTips[0] != NULL && !interlevel) {
	y -= textureHeight(bmTips[0]) + 4;
	}

	- applyTexture(0,y,*recordingsTexture.get(), renderer);
	+ if (!arcade) applyTexture(0,y,*recordingsTexture.get(), renderer);

	if(timeTexture.needsUpdate(time)) {
	- const size_t len = 32;
	timeTexture.update(time,
	textureFromTextShaded(
	renderer,
	*fontText,
	tfm::format("%-.2fs", time / 40.0).c_str(),
	fg,
	bg
	));
	- }
	+ SDL_SetTextureAlphaMod(timeTexture.get(), alpha);
	+ }

	y -= textureHeight(*timeTexture.get());

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

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

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

	+ //Expand the variables.
	+ std::map<std::string, std::string> cachedVariables;
	+ for (;;) {
	+ size_t lps = message.find("{{{");
	+ if (lps == std::string::npos) break;
	+ size_t lpe = message.find("}}}", lps);
	+ if (lpe == std::string::npos) break;
	+
	+ std::string varName = message.substr(lps + 3, lpe - lps - 3), varValue;
	+ auto it = cachedVariables.find(varName);
	+
	+ if (it != cachedVariables.end()) {
	+ varValue = it->second;
	+ } else {
	+ bool isUnknown = true;
	+
	+ if (varName.size() >= 4 && varName.substr(0, 4) == "key_") {
	+ //Probably a key name.
	+ InputManagerKeys key = InputManager::getKeyFromName(varName);
	+ if (key != INPUTMGR_MAX) {
	+ varValue = InputManagerKeyCode::describeTwo(inputMgr.getKeyCode(key, false), inputMgr.getKeyCode(key, true));
	+ isUnknown = false;
	+ }
	+ }
	+
	+ if (isUnknown) {
	+ //Unknown variable
	+ cerr << "Warning: Unknown variable '{{{" << varName << "}}}' in notification block message!" << endl;
	+ }
	+
	+ cachedVariables[varName] = varValue;
	+ }
	+
	+ //Substitute.
	+ message.replace(message.begin() + lps, message.begin() + (lpe + 3), varValue);
	+ }
	+
	std::vector<std::string> string_data;

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

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

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

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

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

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

	vector<SurfacePtr> lines;

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

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

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

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

	maxWidth+=SCREEN_WIDTH*0.15;

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

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

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

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

	//Make a copy of the playerButtons.
	vector<int> recordCopy=player.recordButton;
	+
	+ //Backup of time and recordings, etc. before we reset the level.
	+ //We choose the same variable names so that we don't need to modify the existing code.
	+ const int time = this->time, recordings = this->recordings, currentCollectables = this->currentCollectables;

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

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

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

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

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

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

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

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

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

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

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

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

	- int medal=1;
	- if(bestTime>=0 && (targetTime<0 \|\| bestTime<=targetTime))
	- medal++;
	- if(bestRecordings>=0 && (targetRecordings<0 \|\| bestRecordings<=targetRecordings))
	- medal++;
	+ int medal = levels->getLevel()->getMedal();
	+ assert(medal > 0);

	int maxWidth=0;
	int x=20;

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

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

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

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

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

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

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

	x+=maxWidth+20;

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

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

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

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

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

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

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

	x+=maxWidth;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	+ //Save the PRNG and seed.
	+ prngSaved = prng;
	+ prngSeedSaved = prngSeed;
	+
	+ //Save the level size.
	+ levelRectSaved = levelRect;
	+
	//Save the camera mode and target.
	cameraModeSaved=cameraMode;
	cameraTargetSaved=cameraTarget;

	//Save the current collectables
	- currentCollectablesSaved=currentCollectables;
	+ currentCollectablesSaved = currentCollectables;
	+ totalCollectablesSaved = totalCollectables;

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

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

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

	//Also save the background animation, if any.
	if(background)
	background->saveAnimation();

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

	//Update statistics.
	statsMgr.saveTimes++;

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

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

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

	//Return true.
	return true;
	}

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

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

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

	+ //Load the PRNG and seed.
	+ prng = prngSaved;
	+ prngSeed = prngSeedSaved;
	+
	+ //Load the level size.
	+ levelRect = levelRectSaved;
	+
	//Load the camera mode and target.
	cameraMode=cameraModeSaved;
	cameraTarget=cameraTargetSaved;

	//Load the current collactbles
	- currentCollectables=currentCollectablesSaved;
	+ currentCollectables = currentCollectablesSaved;
	+ totalCollectables = totalCollectablesSaved;

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

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

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

	//Also load the background animation, if any.
	if(background)
	background->loadAnimation();

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

	//Update statistics.
	statsMgr.loadTimes++;

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

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

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

	//Return true.
	return true;
	}

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

	+static std::string createNewSeed() {
	+ static int createSeedTime = 0;
	+
	+ struct Buffer {
	+ time_t systemTime;
	+ Uint32 sdlTicks;
	+ int x;
	+ int y;
	+ int createSeedTime;
	+ } buffer;
	+
	+ buffer.systemTime = time(NULL);
	+ buffer.sdlTicks = SDL_GetTicks();
	+ SDL_GetMouseState(&buffer.x, &buffer.y);
	+ buffer.createSeedTime = ++createSeedTime;
	+
	+ return Md5::toString(Md5::calc(&buffer, sizeof(buffer), NULL));
	+}
	+
	void Game::reset(bool save,bool noScript){
	+ //Some sanity check, i.e. if we switch from no-script mode to script mode, we should always reset the save
	+ assert(noScript \|\| getScriptExecutor() \|\| save);
	+
	//We need to reset the game so we also reset the player and the shadow.
	player.reset(save);
	shadow.reset(save);

	saveStateNextTime=false;
	loadStateNextTime=false;

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

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

	+ //Reset the pseudo-random number generator by creating a new seed, unless we are playing from record.
	+ if (levelFile == "?record?" \|\| interlevel) {
	+ if (prngSeed.empty()) {
	+ cout << "WARNING: The record file doesn't provide a random seed! Will create a new random seed!"
	+ "This may breaks the behavior pseudo-random number generator in script!" << endl;
	+ prngSeed = createNewSeed();
	+ } else {
	+#ifdef _DEBUG
	+ cout << "Use existing PRNG seed: " << prngSeed << endl;
	+#endif
	+ }
	+ } else {
	+ prngSeed = createNewSeed();
	+#ifdef _DEBUG
	+ cout << "Create new PRNG seed: " << prngSeed << endl;
	+#endif
	+ }
	+ prng.seed(std::seed_seq(prngSeed.begin(), prngSeed.end()));
	+ if (save) {
	+ prngSaved = prng;
	+ prngSeedSaved = prngSeed;
	+ }
	+
	+ //Reset the level size.
	+ levelRect = levelRectInitial;
	+ if (save) levelRectSaved = levelRectInitial;
	+
	//Reset the camera.
	cameraMode=CAMERA_PLAYER;
	if(save) cameraModeSaved=CAMERA_PLAYER;
	- cameraTarget.x=cameraTarget.y=cameraTarget.w=cameraTarget.h=0;
	- if(save) cameraTargetSaved.x=cameraTargetSaved.y=cameraTargetSaved.w=cameraTargetSaved.h=0;
	+ cameraTarget = SDL_Rect{ 0, 0, 0, 0 };
	+ if (save) cameraTargetSaved = SDL_Rect{ 0, 0, 0, 0 };

	//Reset the number of collectables
	- currentCollectables=0;
	- if(save)
	- currentCollectablesSaved=0;
	-
	- //There is no last checkpoint so set it to NULL.
	- if(save)
	- objLastCheckPoint=NULL;
	+ currentCollectables = currentCollectablesInitial;
	+ totalCollectables = totalCollectablesInitial;
	+ if (save) {
	+ currentCollectablesSaved = currentCollectablesInitial;
	+ totalCollectablesSaved = totalCollectablesInitial;
	+ }

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

	- //Reset other state, for example moving blocks.
	- for(unsigned int i=0;i<levelObjects.size();i++){
	- levelObjects[i]->reset(save);
	- }
	-
	- //Also reset states of scenery layers.
	+ //Reset states of scenery layers.
	for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it) {
	it->second->resetAnimation(save);
	}

	//Also reset the background animation, if any.
	if(background)
	background->resetAnimation(save);

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

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

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

	//Clear the block script.
	for (auto block : levelObjects){
	block->compiledScripts.clear();
	- block->savedCompiledScripts.clear();
	- block->initialCompiledScripts.clear();
	}
	- } else {
	- if (save \|\| getScriptExecutor()->getLuaState() == NULL) {
	- //Create a new script environment.
	- getScriptExecutor()->reset(true);
	-
	- //Recompile the level script.
	- compiledScripts.clear();
	- savedCompiledScripts.clear();
	- initialCompiledScripts.clear();
	- for (auto it = scripts.begin(); it != scripts.end(); ++it){
	+ for (auto block : levelObjectsSave){
	+ block->compiledScripts.clear();
	+ }
	+ for (auto block : levelObjectsInitial){
	+ block->compiledScripts.clear();
	+ }
	+ } else if (save) {
	+ //Create a new script environment.
	+ getScriptExecutor()->reset(true);
	+
	+ //Recompile the level script.
	+ compiledScripts.clear();
	+ savedCompiledScripts.clear();
	+ initialCompiledScripts.clear();
	+ for (auto it = scripts.begin(); it != scripts.end(); ++it){
	+ int index = getScriptExecutor()->compileScript(it->second);
	+ compiledScripts[it->first] = index;
	+ lua_rawgeti(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX, index);
	+ savedCompiledScripts[it->first] = luaL_ref(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX);
	+ lua_rawgeti(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX, index);
	+ initialCompiledScripts[it->first] = luaL_ref(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX);
	+ }
	+
	+ //Recompile the block script.
	+ for (auto block : levelObjects){
	+ block->compiledScripts.clear();
	+ }
	+ for (auto block : levelObjectsSave){
	+ block->compiledScripts.clear();
	+ }
	+ for (auto block : levelObjectsInitial) {
	+ block->compiledScripts.clear();
	+ for (auto it = block->scripts.begin(); it != block->scripts.end(); ++it){
	int index = getScriptExecutor()->compileScript(it->second);
	- compiledScripts[it->first] = index;
	- lua_rawgeti(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX, index);
	- initialCompiledScripts[it->first] = luaL_ref(getScriptExecutor()->getLuaState(), LUA_REGISTRYINDEX);
	+ block->compiledScripts[it->first] = index;
	}
	+ }
	+ } else {
	+ assert(getScriptExecutor());

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

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

	- //Restore the block script to initial state.
	- for (auto block : levelObjects) {
	- copyCompiledScripts(getScriptExecutor()->getLuaState(), block->initialCompiledScripts, block->compiledScripts);
	- }
	- }
	+ //NOTE: We don't need to restore the block script since it will be restored automatically when the block array is copied.
	+ }
	+
	+ //We reset levelObjects here since we need to wait the compiledScripts being initialized.
	+ copyLevelObjects(levelObjectsInitial, levelObjects, true);
	+ if (save) {
	+ copyLevelObjects(levelObjectsInitial, levelObjectsSave, false);
	}

	+ //Also reset the last checkpoint so set it to NULL.
	+ if (save)
	+ objLastCheckPoint = NULL;
	+
	//Call the level's onCreate event.
	executeScript(LevelEvent_OnCreate);

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

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

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

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

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

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

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

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

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

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

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

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

	interlevel=false;

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

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

	#ifndef GAME_H
	#define GAME_H

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

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

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

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

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

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

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

	//The script executor.
	ScriptExecutor *scriptExecutor;

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

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

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

	//ThemeBlockInstance containing the collectable image.
	ThemeBlockInstance collectable;

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

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

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

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

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

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

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

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

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

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

	+ //The level rect.
	+ //NOTE: the x,y of these rects can only be changed by script.
	+ //If not changed by script, they are always 0,0.
	+ SDL_Rect levelRect, levelRectSaved, levelRectInitial;
	+
	+ //The pseudo-random number generator which is mainly used in script.
	+ std::mt19937 prng, prngSaved;
	+
	+ //The seed of the pseudo-random number generator, which will be saved to and load from replay.
	+ std::string prngSeed, prngSeedSaved;
	+
	+ //Boolean that is set to true if the level is arcade mode.
	+ bool arcade;
	+
	//Boolean that is set to true when a game is won.
	bool won;

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

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

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

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

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

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

	//Integer keeping track of currently obtained collectables
	- int currentCollectables;
	+ int currentCollectables, currentCollectablesSaved, currentCollectablesInitial;
	//Integer keeping track of total colletables in the level
	- int totalCollectables;
	- //Integer containing the stored value of current collectables
	- int currentCollectablesSaved;
	+ int totalCollectables, totalCollectablesSaved, totalCollectablesInitial;

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

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

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

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

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

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

	//Vector containing all the levelObjects in the current game.
	- std::vector<Block*> levelObjects;
	+ std::vector<Block*> levelObjects, levelObjectsSave, levelObjectsInitial;

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

	//Get the script executor.
	ScriptExecutor* getScriptExecutor() {
	return scriptExecutor;
	}
	+
	+ //Invalidates the notification texture.
	+ //block: The block which is updated. The cached texture won't be invalidated if it's not for this block.
	+ //NULL means invalidates the texture no matter which block is updated.
	+ void invalidateNotificationTexture(Block *block = NULL);
	};

	#endif
	diff --git a/src/GameObjects.cpp b/src/GameObjects.cpp
	index ea69406..3e54419 100644
	--- a/src/GameObjects.cpp
	+++ b/src/GameObjects.cpp
	@@ -1,82 +1,79 @@
	/*
	* 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 "GameObjects.h"
	#include "Functions.h"
	#include "Globals.h"

	-GameObject::GameObject(Game* parent):type(0),parent(parent){}
	+GameObject::GameObject(Game* parent) : box(SDL_Rect{ 0, 0, 0, 0 }), boxBase(SDL_Rect{ 0, 0, 0, 0 }), type(0), parent(parent) {}
	+GameObject::GameObject(const GameObject& other) : box(other.box), boxBase(other.boxBase), type(other.type), parent(other.parent) {}
	GameObject::~GameObject(){}

	SDL_Rect GameObject::getBox(int boxType){
	//This is the default implementation of getBox(int) method.
	switch(boxType){
	case BoxType_Current:
	case BoxType_Previous:
	return box;
	case BoxType_Base:
	return boxBase;
	}

	//Return an empty SDL_Rect.
	SDL_Rect tmp={0,0,0,0};
	return tmp;
	}

	void GameObject::setLocation(int x,int y){
	box.x=x;
	box.y=y;
	}
	void GameObject::setBaseLocation(int x,int y){
	box.x=x;
	box.y=y;
	boxBase.x=x;
	boxBase.y=y;
	}

	void GameObject::setSize(int w,int h){
	box.w=w;
	box.h=h;
	}
	void GameObject::setBaseSize(int w,int h){
	box.w=w;
	box.h=h;
	boxBase.w=w;
	boxBase.h=h;
	}

	-void GameObject::saveState(){}
	-void GameObject::loadState(){}
	-void GameObject::reset(bool save){}
	-
	void GameObject::playAnimation(){}
	void GameObject::onEvent(int eventType){}

	int GameObject::queryProperties(int propertyType,Player* obj){
	return 0;
	}

	void GameObject::getEditorData(std::vector<std::pair<std::string,std::string> >& obj){}
	void GameObject::setEditorData(std::map<std::string,std::string>& obj){}
	std::string GameObject::getEditorProperty(const std::string& property){return "";}
	void GameObject::setEditorProperty(const std::string& property, const std::string& value){}

	bool GameObject::loadFromNode(ImageManager&, SDL_Renderer&, TreeStorageNode*){return true;}

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

	#ifndef GAME_OBJECTS_H
	#define GAME_OBJECTS_H

	#include "Globals.h"
	#include "TreeStorageNode.h"
	-#include "Player.h"
	#include <SDL.h>
	#include <string>
	#include <vector>
	#include <utility>
	#include <map>

	class Game;
	class Player;

	//The different gameObject events.
	enum GameObjectEventType{
	//Event called when the player walks on the gameObject.
	GameObjectEvent_PlayerWalkOn=1,
	//Event called when the player is on the gameObject.
	GameObjectEvent_PlayerIsOn,
	//Event called when the player leaves the gameObject.
	GameObjectEvent_PlayerLeave,
	//Event called when the gameObject is created.
	//Only used for scripting purpose.
	GameObjectEvent_OnCreate,
	//Event called every frame.
	//Only used for scripting purpose.
	GameObjectEvent_OnEnterFrame,
	//Event called when the player press DOWN key.
	//Currently this event only fires when the block type is TYPE_SWITCH.
	GameObjectEvent_OnPlayerInteraction,

	//Event called when the block receives "toggle" from a switch/button.
	GameObjectEvent_OnToggle=0x10000,
	//Event called when the block receives "switch on" from a switch/button.
	GameObjectEvent_OnSwitchOn=0x10001,
	//Event called when the block receives "switch off" from a switch/button.
	GameObjectEvent_OnSwitchOff=0x10002,
	};

	//The different gameObject properties.
	enum GameObjectPropertyType{
	//If the player can walk on the gameObject.
	GameObjectProperty_PlayerCanWalkOn=1,
	//If the object is spiked.
	GameObjectProperty_IsSpikes,
	//If the gameObject has some flags.
	GameObjectProperty_Flags,
	};

	//The different box types that can be requested using the getBox(int boxType) method.
	enum GameObjectBoxType{
	//Box of the current position.
	BoxType_Current=0,
	//Box of the base/start position.
	BoxType_Base,
	//Box of the previous position.
	BoxType_Previous,
	//The movement of the block since last position.
	BoxType_Delta,
	//The velocity for when the player is standing on it.
	BoxType_Velocity,
	};

	//The GameObject class.
	class GameObject{
	protected:
	//The box of the gameObject.
	//It's used for the current location of the gameObject and its size.
	SDL_Rect box;
	//The base location of the game object.
	SDL_Rect boxBase;
	public:
	//The type of the GameObject.
	int type;
	//Pointer to the Game state.
	Game* parent;

	//Constructor.
	//parent: Pointer to the Game state.
	GameObject(Game* parent);
	+
	+ //Copy constuctor (only used in save/load support).
	+ GameObject(const GameObject& other);
	+
	//Destructor.
	virtual ~GameObject();

	//Method used to retrieve a certain box from the GameObject.
	//boxType: The type of box that is requested. (default=0)
	//Returns: An SDL_Rect.
	virtual SDL_Rect getBox(int boxType=0);

	//This method is used to place the location on a given location.
	//x: The x location to place the gameObject.
	//y: The y location to place the gameObject.
	virtual void setLocation(int x,int y);
	//This method is used to set the base of an object to a given location.
	//x: The x location to place the gameObject.
	//y: The y location to place the gameObject.
	virtual void setBaseLocation(int x,int y);

	//This method sets the size of the object to a given size.
	//w: The new width of the gameObject.
	//h: The new height the gameObject.
	virtual void setSize(int w,int h);
	//This method sets the size of the base of the object to a given size.
	//w: The new width of the gameObject.
	//h: The new height of the gameObject.
	virtual void setBaseSize(int w,int h);

	//Method used to draw the GameObject.
	virtual void show(SDL_Renderer& renderer)=0;
	- //Save the state of the GameObject, used for moving blocks, etc.
	- virtual void saveState();
	- //Load the state of the GameObject, used for moving blocks, etc.
	- virtual void loadState();
	- //Reset the state of the GameObject, used for moving blocks, etc.
	- //save: Boolean if the saved state should also be reset.
	- virtual void reset(bool save);

	//Play an animation.
	virtual void playAnimation();
	//Invoke an event of the GameObject.
	//eventType: The event type.
	virtual void onEvent(int eventType);
	//Method used to request certain properties of the GameObject.
	//propertyType: The property that is requested.
	//obj: Pointer to the player.
	virtual int queryProperties(int propertyType,Player* obj);

	//Method used to retrieve the additional editor data for the GameObject.
	//Used for messages, moving positions, etc...
	//obj: Vector containing the editorData pairs. (key, value)
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editorData.
	//obj: Map containing the key/value for the 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(const 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(const std::string& property, const std::string& value);

	//Method for loading the GameObject 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*);

	//Update method for GameObjects, used for moving blocks.
	virtual void move();
	};

	#endif
	diff --git a/src/Globals.cpp b/src/Globals.cpp
	index 0e57ef4..f8ba70d 100644
	--- a/src/Globals.cpp
	+++ b/src/Globals.cpp
	@@ -1,84 +1,82 @@
	/*
	* 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 "Globals.h"
	#include "libs/tinygettext/tinygettext.hpp"

	+#include <vector>
	+
	//Set the defautl value for the screen width and height.
	int SCREEN_WIDTH=800;
	int SCREEN_HEIGHT=600;

	-//Set the default value for the level width and height.
	-int LEVEL_HEIGHT=0;
	-int LEVEL_WIDTH=0;
	-
	//The language that in which the game should be translated.
	std::string language;
	//The DictionaryManager that is used to translate the game itself.
	tinygettext::DictionaryManager* dictionaryManager=NULL;

	//SDL Window and renderer
	SDL_Window* sdlWindow=NULL;

	//Font that is used for titles.
	//Knewave large.
	TTF_Font* fontTitle=NULL;
	//Font that is used for captions of buttons and other GUI elements.
	//Knewave small.
	TTF_Font* fontGUI=NULL;
	//Font that is used for long captions of buttons and other GUI elements.
	//Knewave small.
	TTF_Font* fontGUISmall=NULL;
	//Font that is used for (long) text.
	//Blokletter-Viltstift small.
	TTF_Font* fontText=NULL;
	//Font used for scripting editor.
	//Monospace.
	TTF_Font* fontMono=NULL;

	//Small arrows used for GUI widgets.
	//2 directions and 2 different/same colors depending on theme.
	TexturePtr arrowLeft1=nullptr;
	TexturePtr arrowRight1=nullptr;
	TexturePtr arrowLeft2=nullptr;
	TexturePtr arrowRight2=nullptr;

	//Set the current stateID and the nextState.
	int stateID=STATE_NULL;
	int nextState=STATE_NULL;
	GameState* currentState=NULL;

	LevelPack* levels=NULL;
	//The name of the current level.
	std::string levelName;

	//Initialise the camera.
	//Start location is 0, size is the same as the screen size.
	SDL_Rect camera={0,0,SCREEN_WIDTH,SCREEN_HEIGHT};

	//The SDL_Event object.
	SDL_Event event;

	//The current cursor type.
	CursorType currentCursor=CURSOR_POINTER;
	//Array containing the SDL_Cursors.
	SDL_Cursor* cursors[CURSOR_MAX];

	//Keyboard only mode. This is set to true if the last menu navigation is performed by keyboard.
	bool isKeyboardOnly = false;
	diff --git a/src/Globals.h b/src/Globals.h
	index d412ccb..12ac045 100644
	--- a/src/Globals.h
	+++ b/src/Globals.h
	@@ -1,263 +1,262 @@
	/*
	* 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 GLOBALS_H
	#define GLOBALS_H

	#include <SDL.h>
	#include <string>
	#include "libs/tinygettext/tinygettext.hpp"
	#include "LevelPack.h"
	#include "Render.h"

	#if defined (WIN32) \|\| defined (__APPLE__)
	//#define DATA_PATH
	#else
	#include "config.h"
	#endif

	#define TITLE_FONT_RAISE 19
	#define GUI_FONT_RAISE 5

	class GameState;

	//Global constants
	//The width of the screen.
	extern int SCREEN_WIDTH;
	//The height of the screen.
	extern int SCREEN_HEIGHT;
	//The depth of the screen.
	#if defined(ANDROID)
	//TODO: change other surface creating code to make the game runs faster
	const int SCREEN_BPP=16; //??? 24?? 32??
	//const int SCREEN_FLAGS=SDL_HWSURFACE;
	#else
	const int SCREEN_BPP=32;
	//const int SCREEN_FLAGS=SDL_HWSURFACE;
	#endif
	const int SCREEN_FLAGS = 0;

	//SDL interprets each pixel as a 32-bit number,
	// so our masks must depend on the endianness (byte order) of the machine.
	//NOTE: We define them here so we only have to do it once.
	/*#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	const Uint32 BMASK=0xFF000000;
	const Uint32 GMASK=0x00FF0000;
	const Uint32 RMASK=0x0000FF00;
	const Uint32 AMASK=0x000000FF;
	#else*/
	// NOTE: Changed to ARGB for SDL2.
	const Uint32 BMASK=0x000000FF;
	const Uint32 GMASK=0x0000FF00;
	const Uint32 RMASK=0x00FF0000;
	const Uint32 AMASK=0xFF000000;
	/#endif/

	//String containing the version, used in the titelbar.
	//NOTE: for development version please write something like "V0.5 Development version"
	//which can trigger the corresponding achievement.
	-const std::string version = "V0.5a";
	-
	-//The height of the current level.
	-extern int LEVEL_HEIGHT;
	-//The width of the current level.
	-extern int LEVEL_WIDTH;
	+const std::string version = "V0.5.1 Development version";

	//The target frames per seconds.
	const int FPS=40;

	//The language that in which the game should be translated.
	extern std::string language;
	//The DictionaryManager that is used to translate the game itself.
	extern tinygettext::DictionaryManager* dictionaryManager;

	//SDL Window and renderer
	extern SDL_Window* sdlWindow;

	//Font that is used for titles.
	//Knewave large.
	extern TTF_Font* fontTitle;
	//Font that is used for captions of buttons and other GUI elements.
	//Knewave small.
	extern TTF_Font* fontGUI;
	//Font that is used for long captions of buttons and other GUI elements.
	//Knewave smaller.
	extern TTF_Font* fontGUISmall;
	//Font that is used for (long) text.
	//Blokletter-Viltstift small.
	extern TTF_Font* fontText;
	//Font used for scripting editor.
	//Monospace.
	extern TTF_Font* fontMono;

	//Small arrows used for GUI widgets.
	//2 directions and 2 different/same colors depending on theme.
	extern TexturePtr arrowLeft1;
	extern TexturePtr arrowRight1;
	extern TexturePtr arrowLeft2;
	extern TexturePtr arrowRight2;

	//Event, used for event handling.
	extern SDL_Event event;

	//GUI
	class GUIObject;
	extern GUIObject *GUIObjectRoot;

	//The state id of the current state.
	extern int stateID;
	//Integer containing what the next state will be.
	extern int nextState;
	//The currentState.
	extern GameState* currentState;

	//Pointer to the current levelpack.
	extern LevelPack* levels;
	//String containing the name of the current level.
	extern std::string levelName;

	//SDL rectangle used to store the camera.
	//x is the x location of the camera.
	//y is the y location of the camera.
	//w is the width of the camera. (equal to SCREEN_WIDTH)
	//h is the height of the camera. (equal to SCREEN_HEIGHT)
	extern SDL_Rect camera;

	//Themable colors
	const SDL_Color BLACK = SDL_Color{0,0,0,255};

	//Enumeration containing the different cursor types there are.
	enum CursorType{
	//The default pointer.
	CURSOR_POINTER,

	//The vertical ibeam, used to indicate text input.
	CURSOR_CARROT,

	//A closed hand, used for indicating a drag action.
	CURSOR_DRAG,

	//The different (window) size cursor icons.
	CURSOR_SIZE_HOR,
	CURSOR_SIZE_VER,
	CURSOR_SIZE_FDIAG,
	CURSOR_SIZE_BDIAG,

	//Remove cursor used in level editor
	CURSOR_REMOVE,

	//Pointing hand cursor, for hyperlinks.
	CURSOR_POINTING_HAND,

	//The number of cursor types there are.
	CURSOR_MAX
	};
	//Currently used cursor type.
	extern CursorType currentCursor;
	//Array containing the SDL_Cursors.
	extern SDL_Cursor* cursors[CURSOR_MAX];

	//Enumeration containing the ids of the game states.
	enum GameStates{
	//State null is a special state used to indicate no state.
	//This is used when no next state is defined.
	STATE_NULL,

	//This state is before the actual leveleditor used to make levelpacks.
	STATE_LEVEL_EDIT_SELECT,
	//This state is for the level editor.
	STATE_LEVEL_EDITOR,
	//This state is for the main menu.
	STATE_MENU,
	//This state is for the actual game.
	STATE_GAME,
	//Special state used when exiting meandmyshadow.

	STATE_EXIT,
	//This state is for the help screen.

	STATE_LEVEL_SELECT,
	//This state is for the options screen.
	STATE_OPTIONS,
	//This state is for the addon screen.
	STATE_ADDONS,
	//This state is for credits screen
	STATE_CREDITS,
	//This state is for statistics screen
	STATE_STATISTICS,
	};

	//Enumeration containing the ids of the different block types.
	enum GameTileType{
	//The normal solid block.
	TYPE_BLOCK=0,
	//Block representing the start location of the player.
	TYPE_START_PLAYER,
	//Block representing the start location of the shadow.
	TYPE_START_SHADOW,
	//The exit of the level.
	TYPE_EXIT,
	//The shadow block which is only solid for the shadow.
	TYPE_SHADOW_BLOCK,
	//Block that can kill both the player and the shadow.
	TYPE_SPIKES,

	//Special point where the player can save.
	TYPE_CHECKPOINT,
	//Block that will switch the location of the player and the shadow when invoked.
	TYPE_SWAP,
	//Block that will crumble to dust when stepped on it for the third time.
	TYPE_FRAGILE,

	//Normal block that moves along a path.
	TYPE_MOVING_BLOCK,
	//Shadow block that moves along a path.
	TYPE_MOVING_SHADOW_BLOCK,
	//A spike block that moves along a path.
	TYPE_MOVING_SPIKES,

	//Special block which, once entered, moves the player/shadow to a different portal.
	TYPE_PORTAL,
	//A block with a button which can activate or stop moving blocks, converyor belts
	TYPE_BUTTON,
	//A switch which can activate or stop moving blocks, converyor belts
	TYPE_SWITCH,

	//Solid block which works like
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,

	//Block that contains a message that can be read.
	TYPE_NOTIFICATION_BLOCK,

	//A collectable that is able to open locked doors
	TYPE_COLLECTABLE,

	//Block that can be pushed by the player and the shadow.
	//Pushable blocks can push other pushable blocks.
	TYPE_PUSHABLE,

	//The (max) number of tiles.
	TYPE_MAX
	};

	//Keyboard only mode. This is set to true if the last menu navigation is performed by keyboard.
	extern bool isKeyboardOnly;

	+ImageManager& getImageManager();
	+
	+SDL_Renderer& getRenderer();
	+
	#endif
	diff --git a/src/InputManager.cpp b/src/InputManager.cpp
	index 337c2a8..9de37bd 100644
	--- a/src/InputManager.cpp
	+++ b/src/InputManager.cpp
	@@ -1,593 +1,610 @@
	/*
	* 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/>.
	*/

	#include "InputManager.h"
	#include "Globals.h"
	#include "Settings.h"
	#include "Functions.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include <stdlib.h>
	#include <stdio.h>
	#include <string>
	#include <iostream>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	InputManager inputMgr;

	//the order must be the same as InputManagerKeys
	static const char* keySettingNames[INPUTMGR_MAX]={
	"key_up","key_down","key_left","key_right","key_jump","key_action","key_space","key_cancelRecording",
	"key_escape","key_restart","key_tab","key_save","key_load","key_swap",
	"key_teleport","key_suicide","key_shift","key_next","key_previous","key_select"
	};

	//the order must be the same as InputManagerKeys
	static const char* keySettingDescription[INPUTMGR_MAX]={
	__("Up (in menu)"),__("Down (in menu)"),__("Left"),__("Right"),__("Jump"),__("Action"),__("Space (Record)"),__("Cancel recording"),
	__("Escape"),__("Restart"),__("Tab (View shadow/Level prop.)"),__("Save game (in editor)"),__("Load game"),__("Swap (in editor)"),
	__("Teleport (in editor)"),__("Suicide (in editor)"),__("Shift (in editor)"),__("Next block type (in Editor)"),
	__("Previous block type (in editor)"), __("Select (in menu)")
	};

	InputManagerKeyCode::InputManagerKeyCode(int sym_, int mod_)
	: type(KEYBOARD), sym(sym_), mod(mod_)
	{
	// normalize a bit
	if (sym == 0) {
	mod = 0;
	} else {
	mod = ((mod & KMOD_CTRL) ? KMOD_CTRL : 0)
	\| ((mod & KMOD_ALT) ? KMOD_ALT : 0)
	\| ((mod & KMOD_SHIFT) ? KMOD_SHIFT : 0);

	if (sym == SDLK_LCTRL \|\| sym == SDLK_RCTRL) mod &= ~KMOD_CTRL;
	if (sym == SDLK_LALT \|\| sym == SDLK_RALT) mod &= ~KMOD_ALT;
	if (sym == SDLK_LSHIFT \|\| sym == SDLK_RSHIFT) mod &= ~KMOD_SHIFT;
	}
	}


	InputManagerKeyCode::InputManagerKeyCode(InputType type_, int buttonIndex_, int buttonValue_)
	: type(type_), buttonIndex(buttonIndex_), buttonValue(buttonValue_)
	{
	}

	InputManagerKeyCode InputManagerKeyCode::createFromString(const std::string& s) {
	int i, j, lp;

	if (s.find("JoystickAxis;") == 0) {
	lp = s.find(';');
	if (sscanf(s.c_str() + (lp + 1), "%d;%d", &i, &j) == 2) {
	return InputManagerKeyCode(JOYSTICK_AXIS, i, j);
	}
	} else if (s.find("JoystickButton;") == 0) {
	lp = s.find(';');
	if (sscanf(s.c_str() + (lp + 1), "%d", &i) == 1) {
	return InputManagerKeyCode(JOYSTICK_BUTTON, i, 0);
	}
	} else if (s.find("JoystickHat;") == 0) {
	lp = s.find(';');
	if (sscanf(s.c_str() + (lp + 1), "%d;%d", &i, &j) == 2) {
	return InputManagerKeyCode(JOYSTICK_HAT, i, j);
	}
	} else {
	i = atoi(s.c_str());
	j = 0;
	if (i) {
	if (s.find(";Ctrl") != std::string::npos) j \|= KMOD_CTRL;
	if (s.find(";Alt") != std::string::npos) j \|= KMOD_ALT;
	if (s.find(";Shift") != std::string::npos) j \|= KMOD_SHIFT;
	}
	return InputManagerKeyCode(i, j);
	}

	fprintf(stderr, "ERROR: Can't parse '%s' as InputManagerKeyCode\n", s.c_str());

	return InputManagerKeyCode();
	}

	std::string InputManagerKeyCode::toString() const {
	std::ostringstream str;

	switch (type) {
	default:
	if (sym == 0) {
	return std::string();
	} else {
	str << sym;
	if (mod & KMOD_CTRL) str << ";Ctrl";
	if (mod & KMOD_ALT) str << ";Alt";
	if (mod & KMOD_SHIFT) str << ";Shift";
	return str.str();
	}
	break;
	case JOYSTICK_AXIS:
	str << "JoystickAxis;" << buttonIndex << ";" << buttonValue;
	return str.str();
	break;
	case JOYSTICK_BUTTON:
	str << "JoystickButton;" << buttonIndex;
	return str.str();
	break;
	case JOYSTICK_HAT:
	str << "JoystickHat;" << buttonIndex << ";" << buttonValue;
	return str.str();
	break;
	}
	}

	std::string InputManagerKeyCode::describe() const {
	switch (type) {
	default:
	if (sym == 0) {
	return std::string();
	} else {
	std::ostringstream str;

	- if (mod & KMOD_CTRL) str << "Ctrl+";
	- if (mod & KMOD_ALT) str << "Alt+";
	- if (mod & KMOD_SHIFT) str << "Shift+";
	+ if (mod & KMOD_CTRL) str << "CTRL+";
	+ if (mod & KMOD_ALT) str << "ALT+";
	+ if (mod & KMOD_SHIFT) str << "SHIFT+";

	const char* s = SDL_GetKeyName(sym);
	- if (s != NULL){
	- str << (dictionaryManager != NULL ? dictionaryManager->get_dictionary().translate_ctxt("keys", s).c_str() : s);
	+ if (s != NULL && s[0] != '\0'){
	+ std::string keyCode = s;
	+ std::transform(keyCode.begin(), keyCode.end(), keyCode.begin(), [](char c)->char {
	+ if (c >= 'a' && c <= 'z') {
	+ return c + ('A' - 'a');
	+ } else {
	+ return c;
	+ }
	+ });
	+ str << (dictionaryManager != NULL ? dictionaryManager->get_dictionary().translate_ctxt("keys", keyCode) : keyCode);
	} else{
	/// TRANSLAOTRS: This is used when the name of the key code is not found.
	- str << tfm::format(_("(Key %d)"), sym);
	+ str << tfm::format(_("(KEY %d)"), sym);
	}

	return str.str();
	}
	break;
	case JOYSTICK_AXIS:
	- return tfm::format(_("Joystick axis %d %s"), buttonIndex, buttonValue > 0 ? "+" : "-");
	+ return tfm::format(_("JOYSTICK AXIS %d %s"), buttonIndex, buttonValue > 0 ? "+" : "-");
	break;
	case JOYSTICK_BUTTON:
	- return tfm::format(_("Joystick button %d"), buttonIndex);
	+ return tfm::format(_("JOYSTICK BUTTON %d"), buttonIndex);
	break;
	case JOYSTICK_HAT:
	switch (buttonValue){
	case SDL_HAT_LEFT:
	- return tfm::format(_("Joystick hat %d left"), buttonIndex);
	+ return tfm::format(_("JOYSTICK HAT %d LEFT"), buttonIndex);
	break;
	case SDL_HAT_RIGHT:
	- return tfm::format(_("Joystick hat %d right"), buttonIndex);
	+ return tfm::format(_("JOYSTICK HAT %d RIGHT"), buttonIndex);
	break;
	case SDL_HAT_UP:
	- return tfm::format(_("Joystick hat %d up"), buttonIndex);
	+ return tfm::format(_("JOYSTICK HAT %d UP"), buttonIndex);
	break;
	case SDL_HAT_DOWN:
	- return tfm::format(_("Joystick hat %d down"), buttonIndex);
	+ return tfm::format(_("JOYSTICK HAT %d DOWN"), buttonIndex);
	break;
	default:
	fprintf(stderr, "ERROR: Invalid joystick hat value %d\n", buttonValue);
	/// TRANSLAOTRS: This is used when the JOYSTICK_HAT value is invalid.
	- return tfm::format(_("Joystick hat %d %d"), buttonIndex, buttonValue);
	+ return tfm::format(_("JOYSTICK HAT %d %d"), buttonIndex, buttonValue);
	break;
	}
	break;
	}
	}

	bool InputManagerKeyCode::empty() const {
	return type == KEYBOARD && sym == 0;
	}

	std::string InputManagerKeyCode::describeTwo(const InputManagerKeyCode& keyCode, const InputManagerKeyCode& keyCodeAlt) {
	std::string s = keyCode.describe();

	if (!keyCodeAlt.empty()) {
	if (!keyCode.empty()) {
	s += " ";
	s += _("OR");
	s += " ";
	}
	s += keyCodeAlt.describe();
	}

	return s;
	}

	bool InputManagerKeyCode::operator == (const InputManagerKeyCode& rhs) const {
	return type == rhs.type && sym == rhs.sym && ((type == KEYBOARD && sym == 0) \|\| mod == rhs.mod);
	}

	bool InputManagerKeyCode::contains(const InputManagerKeyCode& rhs) const {
	if (type == KEYBOARD && rhs.type == KEYBOARD) {
	if ((mod & KMOD_CTRL) == 0 && (rhs.mod & KMOD_CTRL) != 0) return false;
	if ((mod & KMOD_ALT) == 0 && (rhs.mod & KMOD_ALT) != 0) return false;
	if ((mod & KMOD_SHIFT) == 0 && (rhs.mod & KMOD_SHIFT) != 0) return false;

	if ((mod & KMOD_CTRL) != 0 && (rhs.mod & KMOD_CTRL) == 0) {
	if (rhs.sym == SDLK_LCTRL \|\| rhs.sym == SDLK_RCTRL) return true;
	}
	if ((mod & KMOD_ALT) != 0 && (rhs.mod & KMOD_ALT) == 0) {
	if (rhs.sym == SDLK_LALT \|\| rhs.sym == SDLK_RALT) return true;
	}
	if ((mod & KMOD_SHIFT) != 0 && (rhs.mod & KMOD_SHIFT) == 0) {
	if (rhs.sym == SDLK_LSHIFT \|\| rhs.sym == SDLK_RSHIFT) return true;
	}
	}

	return false;
	}

	//A class that handles the gui events of the inputDialog.
	class InputDialogHandler:public GUIEventCallback{
	private:
	//the list box which contains keys.
	GUIListBox* listBox;
	//the parent object.
	InputManager* parent;

	//update specified key config item
	void updateConfigItem(SDL_Renderer& renderer,int index){
	//Get the description of the key.
	std::string s=_(keySettingDescription[index]);
	s+=": ";

	//Get the key code name.
	s += InputManagerKeyCode::describeTwo(
	parent->getKeyCode((InputManagerKeys)index, false),
	parent->getKeyCode((InputManagerKeys)index, true)
	);

	//Update item.
	listBox->updateItem(renderer, index, s);
	}
	public:
	//Constructor.
	InputDialogHandler(SDL_Renderer& renderer,GUIListBox* listBox,InputManager* parent):listBox(listBox),parent(parent){
	//load the available keys to the list box.
	for(int i=0;i<INPUTMGR_MAX;i++){
	//Get the description of the key.
	std::string s=_(keySettingDescription[i]);
	s+=": ";

	//Get key code name.
	s += InputManagerKeyCode::describeTwo(
	parent->getKeyCode((InputManagerKeys)i, false),
	parent->getKeyCode((InputManagerKeys)i, true)
	);

	//Add item.
	listBox->addItem(renderer, s);
	}
	}

	virtual ~InputDialogHandler(){}

	//When a key is pressed call this to set the key to currently-selected item.
	void onKeyDown(SDL_Renderer& renderer,const InputManagerKeyCode& keyCode){
	//Check if an item is selected.
	int index=listBox->value;
	if(index<0 \|\| index>=INPUTMGR_MAX) return;

	//Get the existing keys.
	auto key = parent->getKeyCode((InputManagerKeys)index, false);
	auto altKey = parent->getKeyCode((InputManagerKeys)index, true);

	//SDLK_BACKSPACE will erase the last key if there are keys.
	if (keyCode == InputManagerKeyCode(SDLK_BACKSPACE) && (!key.empty() \|\| !altKey.empty())) {
	if (!altKey.empty()) {
	parent->setKeyCode((InputManagerKeys)index, InputManagerKeyCode(), true);
	} else {
	parent->setKeyCode((InputManagerKeys)index, InputManagerKeyCode(), false);
	}
	updateConfigItem(renderer, index);
	} else if (keyCode == key \|\| keyCode == altKey) {
	//Do nothing if keyCode is equal to one of the existing keys.
	} else if (key.empty() \|\| (altKey.empty() && keyCode.contains(key))) {
	//Update the main key if there isn't one.
	parent->setKeyCode((InputManagerKeys)index, keyCode, false);
	updateConfigItem(renderer, index);
	} else if (altKey.empty() \|\| keyCode.contains(altKey)) {
	//Otherwise update the alternative key if there isn't one.
	parent->setKeyCode((InputManagerKeys)index, keyCode, true);
	updateConfigItem(renderer, index);
	}
	}

	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Do nothing...
	}
	};

	//Event handler.
	static InputDialogHandler* handler;

	//A GUIObject that is used to create events for key presses.
	class GUIKeyListener:public GUIObject{
	public:

	GUIKeyListener(ImageManager& imageManager, SDL_Renderer& renderer)
	:GUIObject(imageManager,renderer){}
	private:
	//Leave empty.
	~GUIKeyListener(){}

	bool handleEvents(SDL_Renderer& renderer,int x,int y,bool enabled,bool visible,bool processed){
	if(enabled && handler){
	if(event.type==SDL_KEYDOWN){
	handler->onKeyDown(renderer, InputManagerKeyCode(event.key.keysym.sym, event.key.keysym.mod));
	}
	//Joystick
	else if(event.type==SDL_JOYAXISMOTION){
	if(event.jaxis.value>3200){
	handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_AXIS, event.jaxis.axis, 1));
	}else if(event.jaxis.value<-3200){
	handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_AXIS, event.jaxis.axis, -1));
	}
	}
	else if(event.type==SDL_JOYBUTTONDOWN){
	handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_BUTTON, event.jbutton.button, 0));
	}
	else if(event.type==SDL_JOYHATMOTION){
	if (event.jhat.value & SDL_HAT_LEFT){
	handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_LEFT));
	} else if (event.jhat.value & SDL_HAT_RIGHT){
	handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_RIGHT));
	} else if (event.jhat.value & SDL_HAT_UP){
	handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_UP));
	} else if (event.jhat.value & SDL_HAT_DOWN){
	handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_DOWN));
	}
	}
	}
	return false;
	}

	//Nothing to do.
	void render(){}
	};

	+InputManagerKeys InputManager::getKeyFromName(const std::string& name) {
	+ for (int i = 0; i < INPUTMGR_MAX; i++) {
	+ if (name == keySettingNames[i]) {
	+ return (InputManagerKeys)i;
	+ }
	+ }
	+ return INPUTMGR_MAX;
	+}
	+
	InputManagerKeyCode InputManager::getKeyCode(InputManagerKeys key, bool isAlternativeKey){
	if(isAlternativeKey) return alternativeKeys[key];
	else return keys[key];
	}

	void InputManager::setKeyCode(InputManagerKeys key, const InputManagerKeyCode& keyCode, bool isAlternativeKey){
	if(isAlternativeKey) alternativeKeys[key]=keyCode;
	else keys[key]=keyCode;
	}

	void InputManager::loadConfig(){
	for(int i=0;i<INPUTMGR_MAX;i++){
	string s=keySettingNames[i];

	keys[i] = InputManagerKeyCode::createFromString(getSettings()->getValue(s));

	s+="2";
	alternativeKeys[i] = InputManagerKeyCode::createFromString(getSettings()->getValue(s));

	//Move the alternative key to main key if the main key is empty.
	if(keys[i].empty() && !alternativeKeys[i].empty()){
	keys[i]=alternativeKeys[i];
	alternativeKeys[i] = InputManagerKeyCode();
	}

	//Remove duplicate.
	if(keys[i]==alternativeKeys[i])
	alternativeKeys[i] = InputManagerKeyCode();
	}
	}

	void InputManager::saveConfig(){
	int i;
	for(i=0;i<INPUTMGR_MAX;i++){
	string s=keySettingNames[i];

	//Remove duplicate.
	if(keys[i]==alternativeKeys[i])
	alternativeKeys[i] = InputManagerKeyCode();

	getSettings()->setValue(s, keys[i].toString());

	s+="2";
	getSettings()->setValue(s, alternativeKeys[i].toString());
	}
	}

	GUIObject* InputManager::showConfig(ImageManager& imageManager, SDL_Renderer& renderer,int height){
	//Create the new GUI.
	GUIObject* root=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,height);

	//Instruction label.
	GUIObject* obj=new GUILabel(imageManager,renderer,0,6,root->width,36,_("Select an item and press a key to change it."),0,true,true,GUIGravityCenter);
	root->addChild(obj);

	obj=new GUILabel(imageManager,renderer,0,30,root->width,36,_("Press backspace to clear the selected item."),0,true,true,GUIGravityCenter);
	root->addChild(obj);

	//The listbox for keys.
	GUIListBox listBox=new GUIListBox(imageManager,renderer,SCREEN_WIDTH0.15,72,SCREEN_WIDTH*0.7,height-72-8);
	root->addChild(listBox);

	//Create the event handler.
	if(handler)
	delete handler;
	handler=new InputDialogHandler(renderer,listBox,this);

	obj=new GUIKeyListener(imageManager,renderer);
	root->addChild(obj);

	//Return final widget.
	return root;
	}

	InputManager::InputManager(){
	//Clear the arrays.
	for(int i=0;i<INPUTMGR_MAX;i++){
	keyFlags[i]=0;
	}
	}

	InputManager::~InputManager(){
	closeAllJoysticks();
	}

	int InputManagerKeyCode::getKeyState(int oldState, bool hasEvent, std::vector<SDL_Joystick*>& joysticks, int deadZone) const {
	int state = 0;

	switch (type) {
	default: {
	//Keyboard.
	if (sym == 0) return 0;
	const bool isPrintable = (mod & ~KMOD_SHIFT) == 0 && sym >= 32 && sym <= 126;
	if (hasEvent && (event.type == SDL_KEYDOWN \|\| event.type == SDL_KEYUP)) {
	const bool isModCorrect = (mod == 0) ? true :
	(mod == InputManagerKeyCode(event.key.keysym.sym, event.key.keysym.mod).mod);

	if (event.type == SDL_KEYDOWN && event.key.keysym.sym == sym && isModCorrect) {
	state \|= 0x3;
	if (!isPrintable) state \|= 0x30;
	} else if (event.type == SDL_KEYUP && event.key.keysym.sym == sym && isModCorrect) {
	state \|= 0x4;
	if (!isPrintable) state \|= 0x40;
	}
	}
	{
	//Get keyboard state for key code
	//SDL_GetKeyboardState needs a scankey rather than keycode, so we convert
	int numKeys = 0;
	const Uint8* keyStates = SDL_GetKeyboardState(&numKeys);
	SDL_Scancode scanCode = SDL_GetScancodeFromKey(sym);
	if (scanCode < numKeys && keyStates[scanCode]) {
	const int m = SDL_GetModState();
	const bool isModCorrect = (mod == 0) ? true :
	(mod == InputManagerKeyCode(sym, m).mod);
	if (isModCorrect) {
	state \|= 0x1;
	if (!isPrintable) state \|= 0x10;
	}
	}
	}
	break;
	}
	case JOYSTICK_AXIS:
	//Axis.
	if (hasEvent && event.type == SDL_JOYAXISMOTION && event.jaxis.axis == buttonIndex) {
	if ((buttonValue > 0 && event.jaxis.value > deadZone) \|\| (buttonValue < 0 && event.jaxis.value < -deadZone)) {
	if ((oldState & 0x1) == 0) state \|= 0x3;
	if ((oldState & 0x10) == 0) state \|= 0x30;
	} else {
	if (oldState & 0x1) state \|= 0x4;
	if (oldState & 0x10) state \|= 0x40;
	}
	}
	for (auto j : joysticks) {
	Sint16 v = SDL_JoystickGetAxis(j, buttonIndex);
	if ((buttonValue > 0 && v > deadZone) \|\| (buttonValue < 0 && v < -deadZone)){
	state \|= 0x11;
	break;
	}
	}
	break;
	case JOYSTICK_BUTTON:
	//Button.
	if (hasEvent) {
	if (event.type == SDL_JOYBUTTONDOWN && event.jbutton.button == buttonIndex){
	state \|= 0x33;
	} else if (event.type == SDL_JOYBUTTONUP && event.jbutton.button == buttonIndex){
	state \|= 0x44;
	}
	}
	for (auto j : joysticks) {
	Uint8 v = SDL_JoystickGetButton(j, buttonIndex);
	if (v) {
	state \|= 0x11;
	break;
	}
	}
	break;
	case JOYSTICK_HAT:
	//Hat.
	if (hasEvent && event.type == SDL_JOYHATMOTION && event.jhat.hat == buttonIndex) {
	if (event.jhat.value & buttonValue){
	if ((oldState & 0x1) == 0) state \|= 0x3;
	if ((oldState & 0x10) == 0) state \|= 0x30;
	} else{
	if (oldState & 0x1) state \|= 0x4;
	if (oldState & 0x10) state \|= 0x40;
	}
	}
	for (auto j : joysticks) {
	Uint8 v = SDL_JoystickGetHat(j, buttonIndex);
	if (v & buttonValue) {
	state \|= 0x11;
	break;
	}
	}
	break;
	}

	return state;
	}

	//Update the key state, according to current SDL event, etc.
	void InputManager::updateState(bool hasEvent){
	for(int i=0;i<INPUTMGR_MAX;i++){
	keyFlags[i] = keys[i].getKeyState(keyFlags[i], hasEvent, joysticks) \| alternativeKeys[i].getKeyState(keyFlags[i], hasEvent, joysticks);
	}
	}

	//Check if there is KeyDown event.
	bool InputManager::isKeyDownEvent(InputManagerKeys key, bool excludePrintable) {
	return (keyFlags[key] & (excludePrintable ? 0x20 : 0x2)) != 0;
	}

	//Check if there is KeyUp event.
	bool InputManager::isKeyUpEvent(InputManagerKeys key, bool excludePrintable) {
	return (keyFlags[key] & (excludePrintable ? 0x40 : 0x4)) != 0;
	}

	//Check if specified key is down.
	bool InputManager::isKeyDown(InputManagerKeys key, bool excludePrintable) {
	return (keyFlags[key] & (excludePrintable ? 0x10 : 0x1)) != 0;
	}

	//Open all joysticks.
	void InputManager::openAllJoysitcks(){
	int i,m;
	//First close previous joysticks.
	closeAllJoysticks();

	//Open all joysticks.
	m=SDL_NumJoysticks();
	for(i=0;i<m;i++){
	SDL_Joystick *j=SDL_JoystickOpen(i);
	if(j==NULL){
	printf("ERROR: Couldn't open Joystick %d\n",i);
	}else{
	joysticks.push_back(j);
	}
	}
	}

	//Close all joysticks.
	void InputManager::closeAllJoysticks(){
	for(int i=0;i<(int)joysticks.size();i++){
	SDL_JoystickClose(joysticks[i]);
	}
	joysticks.clear();
	}
	diff --git a/src/InputManager.h b/src/InputManager.h
	index 049d7fb..9a2747b 100644
	--- a/src/InputManager.h
	+++ b/src/InputManager.h
	@@ -1,171 +1,174 @@
	/*
	* 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 INPUTMANAGER_H
	#define INPUTMANAGER_H

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

	#include "GUIObject.h"

	enum InputManagerKeys{
	INPUTMGR_UP,
	INPUTMGR_DOWN,
	INPUTMGR_LEFT,
	INPUTMGR_RIGHT,
	INPUTMGR_JUMP,
	INPUTMGR_ACTION,
	INPUTMGR_SPACE,
	INPUTMGR_CANCELRECORDING,
	INPUTMGR_ESCAPE,
	INPUTMGR_RESTART,
	INPUTMGR_TAB,
	INPUTMGR_SAVE,
	INPUTMGR_LOAD,
	INPUTMGR_SWAP,
	INPUTMGR_TELEPORT,
	INPUTMGR_SUICIDE,
	INPUTMGR_SHIFT,
	INPUTMGR_NEXT,
	INPUTMGR_PREVIOUS,
	INPUTMGR_SELECT,
	INPUTMGR_MAX
	};

	// Represents a key code or a joystick input code.
	struct InputManagerKeyCode {
	// The input type. Currently joystick ball is unsupported.
	enum InputType {
	KEYBOARD,
	JOYSTICK_AXIS,
	JOYSTICK_BUTTON,
	JOYSTICK_HAT,
	};

	// The input type.
	InputType type;

	union {
	struct {
	// The keycode if the input type is KEYBOARD.
	// NOTE: if type == KEYBOARD and sym == 0 then this key is disabled at all.
	int sym;

	// The modifier if the input type is KEYBOARD.
	// NOTE: if modifier == 0 then we don't check the modifier at all.
	int mod;
	};

	struct {
	// Joystick button index.
	int buttonIndex;

	// Joystick button value.
	// If type == JOYSTICK_AXIS then value should be 1 or -1.
	// If type == JOYSTICK_BUTTON then it's unused.
	// If type == JOYSTICK_HAT then it's SDL_HAT_LEFT, SDL_HAT_RIGHT, SDL_HAT_UP or SDL_HAT_DOWN.
	int buttonValue;
	};
	};

	// Constructor for a keyboard input.
	explicit InputManagerKeyCode(int sym_ = 0, int mod_ = 0);

	// Constructor for a joystick input.
	explicit InputManagerKeyCode(InputType type_, int buttonIndex_, int buttonValue_);

	// Create a key code from string.
	static InputManagerKeyCode createFromString(const std::string& s);

	// Convert a key code to a machine-readable string.
	std::string toString() const;

	// Convert a key code to a human-readable string.
	std::string describe() const;

	// Convert two key codes to a human-readable string.
	static std::string describeTwo(const InputManagerKeyCode& keyCode, const InputManagerKeyCode& keyCodeAlt);

	// Check if the key code is empty.
	bool empty() const;

	// Internal function to check if the key corresponding to this key code is pressed.
	// oldState: The bit-field flag saves the key states. 0x1=key is down, 0x2=KeyDown event,0x4=KeyUp event.
	// hasEvent: current SDL event is present.
	// joysticks: List of joystick to detect.
	// deadZone: Joystick dead zone for JOYSTICK_AXIS detection.
	// Return value: The bit-field flag with the same meaning as oldState.
	int getKeyState(int oldState, bool hasEvent, std::vector<SDL_Joystick*>& joysticks, int deadZone = 3200) const;

	bool operator==(const InputManagerKeyCode& rhs) const;
	bool operator!=(const InputManagerKeyCode& rhs) const { return !(*this == rhs); }

	// Check if a keyboard input contains another keyboard input (for example, Ctrl+A contains Ctrl but doesn't contain A).
	bool contains(const InputManagerKeyCode& rhs) const;
	};

	class InputManager{
	public:
	InputManager();
	~InputManager();

	+ //Get the key from its setting name. Returns INPUTMGR_MAX if the name is unknown.
	+ static InputManagerKeys getKeyFromName(const std::string& name);
	+
	//Get and set key code of each key.
	InputManagerKeyCode getKeyCode(InputManagerKeys key, bool isAlternativeKey);
	void setKeyCode(InputManagerKeys key, const InputManagerKeyCode& keyCode, bool isAlternativeKey);

	//Load and save key settings from config file.
	void loadConfig();
	void saveConfig();

	//Show the config screen.
	GUIObject* showConfig(ImageManager& imageManager, SDL_Renderer& renderer, int height);

	//Update the key state, according to current SDL event, etc.
	void updateState(bool hasEvent);

	//Check if there is KeyDown event.
	bool isKeyDownEvent(InputManagerKeys key, bool excludePrintable = false);
	//Check if there is KeyUp event.
	bool isKeyUpEvent(InputManagerKeys key, bool excludePrintable = false);
	//Check if specified key is down.
	bool isKeyDown(InputManagerKeys key, bool excludePrintable = false);

	//Open all joysticks.
	void openAllJoysitcks();
	//Close all joysticks.
	void closeAllJoysticks();
	private:
	//The key code of each key.
	InputManagerKeyCode keys[INPUTMGR_MAX], alternativeKeys[INPUTMGR_MAX];

	//The bit-field flag array saves the key states.
	// 0x1 means the key is down.
	// 0x2 means KeyDown event.
	// 0x4 means KeyUp event.
	int keyFlags[INPUTMGR_MAX];

	//Contains all joysticks.
	std::vector<SDL_Joystick*> joysticks;
	};

	extern InputManager inputMgr;

	#endif //INPUTMANAGER_H
	diff --git a/src/LevelEditSelect.cpp b/src/LevelEditSelect.cpp
	index d22fcc5..e79a0c6 100644
	--- a/src/LevelEditSelect.cpp
	+++ b/src/LevelEditSelect.cpp
	@@ -1,892 +1,892 @@
	/*
	* 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 "LevelEditSelect.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "GUISpinBox.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include "Game.h"
	#include "GUIOverlay.h"
	#include <algorithm>
	#include <string>
	#include <iostream>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	LevelEditSelect::LevelEditSelect(ImageManager& imageManager, SDL_Renderer& renderer):LevelSelect(imageManager,renderer,_("Map Editor"),LevelPackManager::CUSTOM_PACKS){
	//Create the gui.
	createGUI(imageManager,renderer, true);

	//Set the levelEditGUIObjectRoot.
	levelEditGUIObjectRoot=GUIObjectRoot;

	//show level list
	changePack();
	refresh(imageManager, renderer);
	}

	LevelEditSelect::~LevelEditSelect(){
	selectedNumber=NULL;
	}

	void LevelEditSelect::createGUI(ImageManager& imageManager,SDL_Renderer &renderer, bool initial){
	if(initial){
	//The levelpack name text field.
	levelpackName=new GUITextBox(imageManager,renderer,280,104,240,32);
	levelpackName->eventCallback=this;
	levelpackName->visible=false;
	GUIObjectRoot->addChild(levelpackName);

	//Create the six buttons at the bottom of the screen.
	newPack = new GUIButton(imageManager, renderer, 0, 0, -1, 32, _("New Levelpack"));
	newPack->name = "cmdNewLvlpack";
	newPack->eventCallback = this;
	GUIObjectRoot->addChild(newPack);

	propertiesPack = new GUIButton(imageManager, renderer, 0, 0, -1, 32, _("Pack Properties"), 0, true, true, GUIGravityCenter);
	propertiesPack->name = "cmdLvlpackProp";
	propertiesPack->eventCallback = this;
	GUIObjectRoot->addChild(propertiesPack);

	removePack = new GUIButton(imageManager, renderer, 0, 0, -1, 32, _("Remove Pack"), 0, true, true, GUIGravityRight);
	removePack->name = "cmdRmLvlpack";
	removePack->eventCallback = this;
	GUIObjectRoot->addChild(removePack);

	move = new GUIButton(imageManager, renderer, 0, 0, -1, 32, _("Move Map"));
	move->name = "cmdMoveMap";
	move->eventCallback = this;
	//NOTE: Set enabled equal to the inverse of initial.
	//When resizing the window initial will be false and therefor the move button can stay enabled.
	move->enabled = false;
	GUIObjectRoot->addChild(move);

	remove = new GUIButton(imageManager, renderer, 0, 0, -1, 32, _("Remove Map"), 0, false, true, GUIGravityCenter);
	remove->name = "cmdRmMap";
	remove->eventCallback = this;
	GUIObjectRoot->addChild(remove);

	edit = new GUIButton(imageManager, renderer, 0, 0, -1, 32, _("Edit Map"), 0, false, true, GUIGravityRight);
	edit->name = "cmdEdit";
	edit->eventCallback = this;
	GUIObjectRoot->addChild(edit);
	}

	//Move buttons to default position
	const int x1 = int(SCREEN_WIDTH0.02), x2 = int(SCREEN_WIDTH0.5), x3 = int(SCREEN_WIDTH*0.98);
	const int y1 = SCREEN_HEIGHT - 120, y2 = SCREEN_HEIGHT - 60;
	newPack->left = x1; newPack->top = y1; newPack->gravity = GUIGravityLeft;
	propertiesPack->left = x2; propertiesPack->top = y1; propertiesPack->gravity = GUIGravityCenter;
	removePack->left = x3; removePack->top = y1; removePack->gravity = GUIGravityRight;
	move->left = x1; move->top = y2; move->gravity = GUIGravityLeft;
	remove->left = x2; remove->top = y2; remove->gravity = GUIGravityCenter;
	edit->left = x3; edit->top = y2; edit->gravity = GUIGravityRight;

	isVertical = false;

	//Reset the font size
	newPack->smallFont = false; newPack->width = -1;
	propertiesPack->smallFont = false; propertiesPack->width = -1;
	removePack->smallFont = false; removePack->width = -1;
	move->smallFont = false; move->width = -1;
	remove->smallFont = false; remove->width = -1;
	edit->smallFont = false; edit->width = -1;

	//Now update widgets and then check if they overlap
	GUIObjectRoot->render(renderer, 0, 0, false);
	if (propertiesPack->left - propertiesPack->gravityX < newPack->left + newPack->width \|\|
	propertiesPack->left - propertiesPack->gravityX + propertiesPack->width > removePack->left - removePack->gravityX)
	{
	newPack->smallFont = true; newPack->width = -1;
	propertiesPack->smallFont = true; propertiesPack->width = -1;
	removePack->smallFont = true; removePack->width = -1;
	move->smallFont = true; move->width = -1;
	remove->smallFont = true; remove->width = -1;
	edit->smallFont = true; edit->width = -1;
	}

	// NOTE: the following code is necessary (e.g. for Germany)

	//Check again
	GUIObjectRoot->render(renderer, 0, 0, false);
	if (propertiesPack->left - propertiesPack->gravityX < newPack->left + newPack->width \|\|
	propertiesPack->left - propertiesPack->gravityX + propertiesPack->width > removePack->left - removePack->gravityX)
	{
	newPack->left = SCREEN_WIDTH*0.02;
	newPack->top = SCREEN_HEIGHT - 140;
	newPack->smallFont = false;
	newPack->width = -1;
	newPack->gravity = GUIGravityLeft;

	propertiesPack->left = SCREEN_WIDTH*0.02;
	propertiesPack->top = SCREEN_HEIGHT - 100;
	propertiesPack->smallFont = false;
	propertiesPack->width = -1;
	propertiesPack->gravity = GUIGravityLeft;

	removePack->left = SCREEN_WIDTH*0.02;
	removePack->top = SCREEN_HEIGHT - 60;
	removePack->smallFont = false;
	removePack->width = -1;
	removePack->gravity = GUIGravityLeft;

	move->left = SCREEN_WIDTH*0.98;
	move->top = SCREEN_HEIGHT - 140;
	move->smallFont = false;
	move->width = -1;
	move->gravity = GUIGravityRight;

	remove->left = SCREEN_WIDTH*0.98;
	remove->top = SCREEN_HEIGHT - 100;
	remove->smallFont = false;
	remove->width = -1;
	remove->gravity = GUIGravityRight;

	edit->left = SCREEN_WIDTH*0.98;
	edit->top = SCREEN_HEIGHT - 60;
	edit->smallFont = false;
	edit->width = -1;
	edit->gravity = GUIGravityRight;

	isVertical = true;
	}
	}

	void LevelEditSelect::changePack(){
	packPath = levelpacks->item[levelpacks->value].first;
	packName = levelpacks->item[levelpacks->value].second;
	if(packPath==CUSTOM_LEVELS_PATH){
	//Disable some levelpack buttons.
	propertiesPack->enabled=false;
	removePack->enabled=false;
	}else{
	//Enable some levelpack buttons.
	propertiesPack->enabled=true;
	removePack->enabled=true;
	}

	//Set last levelpack.
	getSettings()->setValue("lastlevelpack",levelpacks->getName());

	//Now let levels point to the right pack.
	levels=getLevelPackManager()->getLevelPack(levelpacks->getName());

	//invalidate the tooltip
	toolTip.number = -1;
	}

	void LevelEditSelect::packProperties(ImageManager& imageManager,SDL_Renderer& renderer, bool newPack){
	//Open a message popup.
	GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-390)/2,600,390,_("Properties"));
	GUIObject* obj;

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

	obj=new GUITextBox(imageManager,renderer,60,80,480,36,packName.c_str());
	if(newPack)
	obj->caption="";
	obj->name="LvlpackName";
	root->addChild(obj);

	obj=new GUILabel(imageManager,renderer,40,120,240,36,_("Description:"));
	root->addChild(obj);

	obj=new GUITextBox(imageManager,renderer,60,150,480,36,levels->levelpackDescription.c_str());
	if(newPack)
	obj->caption="";
	obj->name="LvlpackDescription";
	root->addChild(obj);

	obj=new GUILabel(imageManager,renderer,40,190,240,36,_("Congratulation text:"));
	root->addChild(obj);

	obj=new GUITextBox(imageManager,renderer,60,220,480,36,levels->congratulationText.c_str());
	if(newPack)
	obj->caption="";
	obj->name="LvlpackCongratulation";
	root->addChild(obj);

	obj = new GUILabel(imageManager, renderer, 40, 260, 240, 36, _("Music list:"));
	root->addChild(obj);

	obj = new GUITextBox(imageManager, renderer, 60, 290, 480, 36, levels->levelpackMusicList.c_str());
	if (newPack)
	obj->caption = "";
	obj->name = "LvlpackMusic";
	root->addChild(obj);

	obj=new GUIButton(imageManager,renderer,root->width*0.3,390-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgOK";
	obj->eventCallback=this;
	root->addChild(obj);
	GUIButton cancelButton = new GUIButton(imageManager, renderer, root->width0.7, 390 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	cancelButton->name = "cfgCancel";
	cancelButton->eventCallback = this;
	root->addChild(cancelButton);

	//Create the gui overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new AddonOverlay(renderer, root, cancelButton, NULL, UpDownFocus \| TabFocus \| ReturnControls \| LeftRightControls);

	if(newPack){
	packPath.clear();
	packName.clear();
	}
	}

	void LevelEditSelect::addLevel(ImageManager& imageManager,SDL_Renderer& renderer){
	//Open a message popup.
	GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,_("Add level"));
	GUIObject* obj;

	obj=new GUILabel(imageManager,renderer,40,80,240,36,_("File name:"));
	root->addChild(obj);

	char s[64];
	SDL_snprintf(s,64,"map%02d.map",levels->getLevelCount()+1);
	obj=new GUITextBox(imageManager,renderer,300,80,240,36,s);
	obj->name="LvlFile";
	root->addChild(obj);

	obj=new GUIButton(imageManager,renderer,root->width*0.3,200-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgAddOK";
	obj->eventCallback=this;
	root->addChild(obj);
	GUIButton cancelButton = new GUIButton(imageManager, renderer, root->width0.7, 200 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	cancelButton->name = "cfgAddCancel";
	cancelButton->eventCallback = this;
	root->addChild(cancelButton);

	//Dim the screen using the tempSurface.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new AddonOverlay(renderer, root, cancelButton, NULL, UpDownFocus \| TabFocus \| ReturnControls \| LeftRightControls);
	}

	void LevelEditSelect::moveLevel(ImageManager& imageManager,SDL_Renderer& renderer){
	//Open a message popup.
	GUIObject* root=new GUIFrame(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-200)/2,600,200,_("Move level"));
	GUIObject* obj;

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

	GUISpinBox *spinBox = new GUISpinBox(imageManager, renderer, 300, 60, 240, 36);
	spinBox->caption = tfm::format("%d", selectedNumber->getNumber() + 1);
	spinBox->format = "%1.0f";
	spinBox->limitMin = 1.0f;
	spinBox->limitMax = float(levels->getLevelCount());
	spinBox->name = "MoveLevel";
	root->addChild(spinBox);

	obj=new GUISingleLineListBox(imageManager,renderer,root->width*0.5,110,240,36,true,true,GUIGravityCenter);
	obj->name="lstPlacement";
	vector<string> v;
	v.push_back(_("Before"));
	v.push_back(_("After"));
	v.push_back(_("Swap"));
	(dynamic_cast<GUISingleLineListBox*>(obj))->addItems(v);
	obj->value=0;
	root->addChild(obj);

	obj=new GUIButton(imageManager,renderer,root->width*0.3,200-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->name="cfgMoveOK";
	obj->eventCallback=this;
	root->addChild(obj);
	GUIButton cancelButton = new GUIButton(imageManager, renderer, root->width0.7, 200 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	cancelButton->name = "cfgMoveCancel";
	cancelButton->eventCallback = this;
	root->addChild(cancelButton);

	//Create the gui overlay.
	//NOTE: We don't need to store a pointer since it will auto cleanup itself.
	new AddonOverlay(renderer, root, cancelButton, NULL, TabFocus \| ReturnControls \| LeftRightControls);
	}

	void LevelEditSelect::refresh(ImageManager& imageManager, SDL_Renderer& renderer, bool change){
	int m=levels->getLevelCount();

	if(change){
	numbers.clear();

	//clear the selected level
	if(selectedNumber!=NULL){
	selectedNumber=NULL;
	}

	//Disable the level specific buttons.
	move->enabled=false;
	remove->enabled=false;
	edit->enabled=false;

	for(int n=0;n<=m;n++){
	numbers.emplace_back(imageManager, renderer);
	}
	}

	for(int n=0;n<m;n++){
	SDL_Rect box={(n%LEVELS_PER_ROW)64+80,(n/LEVELS_PER_ROW)64+184,0,0};
	numbers[n].init(renderer,n,box);
	}
	SDL_Rect box={(m%LEVELS_PER_ROW)64+80,(m/LEVELS_PER_ROW)64+184,0,0};
	numbers[m].init(renderer,"+",box,m);

	m++; //including the "+" button
	if(m>LEVELS_DISPLAYED_IN_SCREEN){
	levelScrollBar->maxValue=(m-LEVELS_DISPLAYED_IN_SCREEN+LEVELS_PER_ROW-1)/LEVELS_PER_ROW;
	levelScrollBar->visible=true;
	}else{
	levelScrollBar->maxValue=0;
	levelScrollBar->visible=false;
	}
	if (levels->levelpackPath == LEVELS_PATH \|\| levels->levelpackPath == CUSTOM_LEVELS_PATH)
	levelpackDescription->caption = _("Individual levels which are not contained in any level packs");
	else if (!levels->levelpackDescription.empty())
	levelpackDescription->caption = _CC(levels->getDictionaryManager(), levels->levelpackDescription);
	else
	levelpackDescription->caption = "";

	//invalidate the tooltip
	toolTip.number = -1;
	}

	void LevelEditSelect::selectNumber(ImageManager& imageManager, SDL_Renderer& renderer, unsigned int number, bool selected){
	if (selected) {
	if (number >= 0 && number < levels->getLevelCount()) {
	levels->setCurrentLevel(number);
	setNextState(STATE_LEVEL_EDITOR);
	} else {
	addLevel(imageManager, renderer);
	}
	}else{
	move->enabled = false;
	remove->enabled = false;
	edit->enabled = false;
	selectedNumber = NULL;
	if (number == numbers.size() - 1){
	if (isKeyboardOnly) {
	selectedNumber = &numbers[number];
	} else {
	addLevel(imageManager, renderer);
	}
	} else if (number >= 0 && number < levels->getLevelCount()) {
	selectedNumber=&numbers[number];

	//Enable the level specific buttons.
	//NOTE: We check if 'remove levelpack' is enabled, if not then it's the Levels levelpack.
	if(removePack->enabled)
	move->enabled=true;
	remove->enabled=true;
	edit->enabled=true;
	}
	}
	}

	void LevelEditSelect::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Call handleEvents() of base class.
	LevelSelect::handleEvents(imageManager, renderer);

	if (section == 3) {
	//Check focus movement
	if (inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)){
	isKeyboardOnly = true;
	section2 += isVertical ? 3 : 1;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_LEFT)){
	isKeyboardOnly = true;
	section2 -= isVertical ? 3 : 1;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	isKeyboardOnly = true;
	section2 -= isVertical ? 1 : 3;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	isKeyboardOnly = true;
	section2 += isVertical ? 1 : 3;
	}
	if (section2 > 6) section2 -= 6;
	else if (section2 < 1) section2 += 6;

	//Check if enter is pressed
	if (isKeyboardOnly && inputMgr.isKeyDownEvent(INPUTMGR_SELECT) && section2 >= 1 && section2 <= 6) {
	GUIButton *buttons[6] = {
	newPack, propertiesPack, removePack, move, remove, edit
	};
	GUIEventCallback_OnEvent(imageManager, renderer, buttons[section2 - 1]->name, buttons[section2 - 1], GUIEventClick);
	}
	}
	}

	void LevelEditSelect::render(ImageManager& imageManager,SDL_Renderer &renderer){
	//Let the levelselect render.
	LevelSelect::render(imageManager,renderer);

	//Draw highlight in keyboard only mode.
	if (isKeyboardOnly) {
	GUIButton *buttons[6] = {
	newPack, propertiesPack, removePack, move, remove, edit
	};
	for (int i = 0; i < 6; i++) {
	buttons[i]->state = (section == 3 && section2 - 1 == i) ? 1 : 0;
	}
	}
	}

	void LevelEditSelect::resize(ImageManager& imageManager, SDL_Renderer &renderer){
	//Let the levelselect resize.
	LevelSelect::resize(imageManager, renderer);

	//Create the GUI.
	createGUI(imageManager,renderer, false);

	//NOTE: This is a workaround for buttons failing when resizing.
	if(packPath==CUSTOM_LEVELS_PATH){
	removePack->enabled=false;
	propertiesPack->enabled=false;
	}
	if(selectedNumber)
	selectNumber(imageManager, renderer, selectedNumber->getNumber(),false);

	}

	void LevelEditSelect::renderTooltip(SDL_Renderer& renderer,unsigned int number,int dy){

	if (!toolTip.name \|\| toolTip.number != number) {
	SDL_Color fg = objThemes.getTextColor(true);
	toolTip.number = number;

	if (number < (unsigned int)levels->getLevelCount()){
	//Render the name of the level.
	toolTip.name = textureFromText(renderer, *fontText, _CC(levels->getDictionaryManager(), levels->getLevelName(number)), fg);
	} else {
	//Add level button
	toolTip.name = textureFromText(renderer, *fontText, _("Add level"), fg);
	}
	}

	//Check if name isn't null.
	if(!toolTip.name)
	return;

	//Now draw a square the size of the three texts combined.
	SDL_Rect r=numbers[number].box;
	r.y-=dy*64;
	const SDL_Rect nameSize = rectFromTexture(*toolTip.name);
	r.w=nameSize.w;
	r.h=nameSize.h;

	//Make sure the tooltip doesn't go outside the window.
	if(r.y>SCREEN_HEIGHT-200){
	r.y-=nameSize.h+4;
	}else{
	r.y+=numbers[number].box.h+2;
	}
	if(r.x+r.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-r.w;

	//Draw a rectange
	Uint32 color=0xFFFFFFFF;
	drawGUIBox(r.x-5,r.y-5,r.w+10,r.h+10,renderer,color);

	//Calc the position to draw.
	SDL_Rect r2=r;

	//Now we render the name if the surface isn't null.
	if(toolTip.name){
	//Draw the name.
	applyTexture(r2.x, r2.y, toolTip.name, renderer);
	}
	}

	//Escape invalid characters in a file name (mainly for Windows).
	static std::string escapeFileName(const std::string& fileName) {
	std::string ret;

	for (int i = 0, m = fileName.size(); i < m; i++) {
	bool escape = false;
	char c = fileName[i];

	switch (c) {
	case '\"': case '*': case '/': case ':': case '<':
	case '>': case '?': case '\\': case '\|': case '%':
	escape = true;
	break;
	}
	if (c <= 0x1F \|\| c >= 0x7F) escape = true;
	if (i == 0 \|\| i == m - 1) {
	switch (c) {
	case ' ': case '.':
	escape = true;
	break;
	}
	}

	if (escape) {
	ret += "%" + tfm::format("%02X", (int)(unsigned char)c);
	} else {
	ret.push_back(c);
	}
	}

	return ret;
	}

	void LevelEditSelect::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//NOTE: We check for the levelpack change to enable/disable some levelpack buttons.
	if(name=="cmdLvlPack"){
	//We call changepack and return to prevent the LevelSelect to undo what we did.
	changePack();
	refresh(imageManager, renderer);
	return;
	}

	//Let the level select handle his GUI events.
	LevelSelect::GUIEventCallback_OnEvent(imageManager,renderer,name,obj,eventType);

	//Check for the edit button.
	if(name=="cmdNewLvlpack"){
	//Create a new pack.
	packProperties(imageManager,renderer, true);
	}else if(name=="cmdLvlpackProp"){
	//Show the pack properties.
	packProperties(imageManager,renderer, false);
	}else if(name=="cmdRmLvlpack"){
	//Show an "are you sure" message.
	if(msgBox(imageManager,renderer,tfm::format(_("Are you sure remove the level pack '%s'?"),packName),MsgBoxYesNo,_("Remove prompt"))==MsgBoxYes){
	//Remove the directory.
	if(!removeDirectory(levels->levelpackPath.c_str())){
	cerr<<"ERROR: Unable to remove levelpack directory "<<levels->levelpackPath<<endl;
	}

	//Remove it from the vector (levelpack list).
	for (auto it = levelpacks->item.begin(); it != levelpacks->item.end(); ++it){
	if (it->first == levels->levelpackPath) {
	levelpacks->item.erase(it);
	break;
	}
	}

	//Remove it from the levelpackManager.
	getLevelPackManager()->removeLevelPack(levels->levelpackPath, true);
	levels = NULL;

	//And call changePack.
	levelpacks->value=levelpacks->item.size()-1;
	changePack();
	refresh(imageManager, renderer);
	}
	}else if(name=="cmdMoveMap"){
	if(selectedNumber!=NULL){
	moveLevel(imageManager,renderer);
	}
	}else if(name=="cmdRmMap"){
	if(selectedNumber!=NULL){
	//Show an "are you sure" message.
	if (msgBox(imageManager, renderer, tfm::format(_("Are you sure remove the map '%s'?"), levels->getLevel(selectedNumber->getNumber())->name), MsgBoxYesNo, _("Remove prompt")) != MsgBoxYes) {
	return;
	}
	if(packPath!=CUSTOM_LEVELS_PATH){
	if(!removeFile((levels->levelpackPath+"/"+levels->getLevel(selectedNumber->getNumber())->file).c_str())){
	cerr<<"ERROR: Unable to remove level "<<(levels->levelpackPath+"/"+levels->getLevel(selectedNumber->getNumber())->file).c_str()<<endl;
	}
	levels->removeLevel(selectedNumber->getNumber());
	levels->saveLevels(levels->levelpackPath+"/levels.lst");
	}else{
	//This is the levels levelpack so we just remove the file.
	if(!removeFile(levels->getLevel(selectedNumber->getNumber())->file.c_str())){
	cerr<<"ERROR: Unable to remove level "<<levels->getLevel(selectedNumber->getNumber())->file<<endl;
	}
	levels->removeLevel(selectedNumber->getNumber());
	}

	//And refresh the selection screen.
	refresh(imageManager, renderer);
	}
	}else if(name=="cmdEdit"){
	if(selectedNumber!=NULL){
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_LEVEL_EDITOR);
	}
	}

	//Check for levelpack properties events.
	if(name=="cfgOK"){
	GUIObject *lvlpackName = GUIObjectRoot->getChild("LvlpackName");
	GUIObject *lvlpackDescription = GUIObjectRoot->getChild("LvlpackDescription");
	GUIObject *lvlpackCongratulation = GUIObjectRoot->getChild("LvlpackCongratulation");
	GUIObject *lvlpackMusic = GUIObjectRoot->getChild("LvlpackMusic");

	assert(lvlpackName && lvlpackDescription && lvlpackCongratulation && lvlpackMusic);

	if (lvlpackName->caption.empty()) {
	msgBox(imageManager, renderer, _("Levelpack name cannot be empty."), MsgBoxOKOnly, _("Error"));
	} else {
	//Check if the name changed.
	if (packName != lvlpackName->caption) {
	std::string newPackPathMinusSlash = getUserPath(USER_DATA) + "custom/levelpacks/" + escapeFileName(lvlpackName->caption);

	//Delete the old one.
	if (!packName.empty()){
	std::string oldPackPathMinusSlash = levels->levelpackPath;
	if (!oldPackPathMinusSlash.empty()) {
	if (oldPackPathMinusSlash[oldPackPathMinusSlash.size() - 1] == '/'
	\|\| oldPackPathMinusSlash[oldPackPathMinusSlash.size() - 1] == '\\')
	{
	oldPackPathMinusSlash.pop_back();
	}
	}

	if (!renameDirectory(oldPackPathMinusSlash.c_str(), newPackPathMinusSlash.c_str())) {
	cerr << "ERROR: Unable to move levelpack directory '" << oldPackPathMinusSlash << "' to '"
	<< newPackPathMinusSlash << "'! The levelpack directory will be kept unchanged." << endl;

	//If we failed to rename the directory, we just keep the old directory name.
	newPackPathMinusSlash = oldPackPathMinusSlash;
	}

	//Remove the old one from the levelpack manager.
	getLevelPackManager()->removeLevelPack(levels->levelpackPath, false);

	//And the levelpack list.
	for (auto it = levelpacks->item.begin(); it != levelpacks->item.end(); ++it){
	if (it->first == levels->levelpackPath) {
	levelpacks->item.erase(it);
	break;
	}
	}
	} else {
	//It's a new levelpack. First we try to create the dirs and the levels.lst.
	if (dirExists(newPackPathMinusSlash.c_str())) {
	cerr << "ERROR: The levelpack directory " << newPackPathMinusSlash << " already exists!" << endl;
	msgBox(imageManager, renderer, tfm::format(_("The levelpack directory '%s' already exists!"), newPackPathMinusSlash), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (!createDirectory(newPackPathMinusSlash.c_str())) {
	cerr << "ERROR: Unable to create levelpack directory " << newPackPathMinusSlash << endl;
	msgBox(imageManager, renderer, tfm::format(_("Unable to create levelpack directory '%s'!"), newPackPathMinusSlash), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (fileExists((newPackPathMinusSlash + "/levels.lst").c_str())) {
	cerr << "ERROR: The levelpack file " << (newPackPathMinusSlash + "/levels.lst") << " already exists!" << endl;
	msgBox(imageManager, renderer, tfm::format(_("The levelpack file '%s' already exists!"), newPackPathMinusSlash + "/levels.lst"), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (!createFile((newPackPathMinusSlash + "/levels.lst").c_str())) {
	cerr << "ERROR: Unable to create levelpack file " << (newPackPathMinusSlash + "/levels.lst") << endl;
	msgBox(imageManager, renderer, tfm::format(_("Unable to create levelpack file '%s'!"), newPackPathMinusSlash + "/levels.lst"), MsgBoxOKOnly, _("Error"));
	return;
	}

	//If it's successful we create a new levelpack.
	levels = new LevelPack;
	}

	//And set the new name.
	packName = levels->levelpackName = lvlpackName->caption;
	packPath = levels->levelpackPath = newPackPathMinusSlash + "/";

	//Also add the levelpack location
	getLevelPackManager()->addLevelPack(levels);
	levelpacks->addItem(packPath, packName);
	levelpacks->value = levelpacks->item.size() - 1;

	//And call changePack.
	changePack();
	}

	levels->levelpackDescription = lvlpackDescription->caption;
	levels->congratulationText = lvlpackCongratulation->caption;
	levels->levelpackMusicList = lvlpackMusic->caption;

	//Refresh the leveleditselect to show the correct information.
	refresh(imageManager, renderer);

	//Save the configuration.
	levels->saveLevels(levels->levelpackPath + "levels.lst");
	getSettings()->setValue("lastlevelpack", levels->levelpackPath);

	//Clear the gui.
	if (GUIObjectRoot) {
	delete GUIObjectRoot;
	GUIObjectRoot = NULL;
	}
	}
	}else if(name=="cfgCancel"){
	//Check if packName is empty, if so it was a new levelpack and we need to revert to an existing one.
	if(packName.empty()){
	packPath = levelpacks->item[levelpacks->value].first;
	packName = levelpacks->item[levelpacks->value].second;
	changePack();
	}

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//Check for add level events.
	if(name=="cfgAddOK"){
	//Check if the file name isn't null.
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="LvlFile"){
	if(GUIObjectRoot->childControls[i]->caption.empty()){
	msgBox(imageManager,renderer,_("No file name given for the new level."),MsgBoxOKOnly,_("Missing file name"));
	return;
	}else{
	string tmp_caption = GUIObjectRoot->childControls[i]->caption;

	//Replace all spaces with a underline.
	size_t j;
	for(;(j=tmp_caption.find(" "))!=string::npos;){
	tmp_caption.replace(j,1,"_");
	}

	//If there isn't ".map" extension add it.
	size_t found=tmp_caption.find_first_of(".");
	if(found!=string::npos)
	tmp_caption.replace(tmp_caption.begin()+found+1,tmp_caption.end(),"map");
	else if (tmp_caption.substr(found+1)!="map")
	tmp_caption.append(".map");

	/* Create path and file in it */
	string path=(levels->levelpackPath+"/"+tmp_caption);
	if(packPath==CUSTOM_LEVELS_PATH){
	path=(getUserPath(USER_DATA)+"/custom/levels/"+tmp_caption);
	}

	//First check if the file doesn't exist already.
	FILE* f;
	f=fopen(path.c_str(),"rb");

	//Check if it exists.
	if(f){
	//Close the file.
	fclose(f);

	//Let the currentState render once to prevent multiple GUI overlapping and prevent the screen from going black.
	currentState->render(imageManager,renderer);
	levelEditGUIObjectRoot->render(renderer);

	//Notify the user.
	msgBox(imageManager, renderer, tfm::format(_("The file %s already exists."), tmp_caption), MsgBoxOKOnly, _("Error"));
	return;
	}

	if(!createFile(path.c_str())){
	cerr<<"ERROR: Unable to create level file "<<path<<endl;
	}else{
	//Update statistics.
	statsMgr.newAchievement("create1");
	- if((++statsMgr.createdLevels)>=50) statsMgr.newAchievement("create50");
	+ if((++statsMgr.createdLevels)>=10) statsMgr.newAchievement("create10");
	}
	levels->addLevel(path);
	//NOTE: Also add the level to the levels levelpack in case of custom levels.
	if(packPath==CUSTOM_LEVELS_PATH){
	LevelPack* levelsPack=getLevelPackManager()->getLevelPack(LEVELS_PATH);
	if(levelsPack){
	levelsPack->addLevel(path);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);
	}else{
	cerr<<"ERROR: Unable to add level to Levels levelpack"<<endl;
	}
	}
	if(packPath!=CUSTOM_LEVELS_PATH)
	levels->saveLevels(levels->levelpackPath+"levels.lst");
	refresh(imageManager, renderer);

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	return;
	}
	}
	}
	}
	}else if(name=="cfgAddCancel"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//Check for move level events.
	if(name=="cfgMoveOK"){
	//Check if the entered level number is valid.
	//Now loop throught the children of the GUIObjectRoot in search of the fields.
	int level=0;
	int placement=0;
	for(unsigned int i=0;i<GUIObjectRoot->childControls.size();i++){
	if(GUIObjectRoot->childControls[i]->name=="MoveLevel"){
	level=atoi(GUIObjectRoot->childControls[i]->caption.c_str());
	if(level<=0 \|\| level>levels->getLevelCount()){
	msgBox(imageManager,renderer,_("The entered level number isn't valid!"),MsgBoxOKOnly,_("Illegal number"));
	return;
	}
	}
	if(GUIObjectRoot->childControls[i]->name=="lstPlacement"){
	placement=GUIObjectRoot->childControls[i]->value;
	}
	}

	//Now we execute the swap/move.
	//Check for the place before.
	if(placement==0){
	//We place the selected level before the entered level.
	levels->moveLevel(selectedNumber->getNumber(),level-1);
	}else if(placement==1){
	//We place the selected level after the entered level.
	if(level<selectedNumber->getNumber())
	levels->moveLevel(selectedNumber->getNumber(),level);
	else
	levels->moveLevel(selectedNumber->getNumber(),level+1);
	}else if(placement==2){
	//We swap the selected level with the entered level.
	levels->swapLevel(selectedNumber->getNumber(),level-1);
	}

	//And save the change.
	if(packPath!=CUSTOM_LEVELS_PATH)
	levels->saveLevels(levels->levelpackPath+"/levels.lst");

	refresh(imageManager, renderer);

	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="cfgMoveCancel"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}
	diff --git a/src/LevelEditor.cpp b/src/LevelEditor.cpp
	index 8fc570b..0aafb00 100644
	--- a/src/LevelEditor.cpp
	+++ b/src/LevelEditor.cpp
	@@ -1,4928 +1,4972 @@
	/*
	* 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 "LevelPackManager.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;

	+//The time and recordings of the current editing level.
	+//FIXME: Should move these variables to the member variable of LevelEditor?
	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"),
	__("Select"), __("Delete"), __("Configure")
	};

	static const std::array<const char*, static_cast<size_t>(ToolTips::TooltipMax)> tooltipHotkey = {
	"F2", "F3", "F4", "F5", "", "", "", "Ctrl+S", "",
	"", "", ""
	};

	static const std::array<int, static_cast<size_t>(ToolTips::TooltipMax)> tooltipHotkey2 = {
	-1, -1, -1, -1, -1, -1, INPUTMGR_TAB, -1, INPUTMGR_ESCAPE,
	-1, -1, -1
	};

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

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

	return name;
	}

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

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

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

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

	//GUI image.
	SDL_Surface* bmGUI;

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

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

	//The separator texture.
	//NOTE: It's created only when it's used. So don't access it directly!
	SharedTexture separatorTexture;

	//Get or create a new separator texture.
	SharedTexture getOrCreateSeparatorTexture(SDL_Renderer& renderer) {
	if (!separatorTexture) {
	//NOTE: we use an arbitrart width since it will be updated soon.
	createSeparatorTexture(renderer, 16);
	}

	return separatorTexture;
	}

	void createSeparatorTexture(SDL_Renderer& renderer, int width) {
	//create surface
	SurfacePtr surface = createSurface(width, 5);

	//draw horizontal separator
	const SDL_Rect r0 = { 4, 1, width - 8, 1 };
	const SDL_Rect r1 = { 4, 3, width - 8, 1 };
	const SDL_Rect r2 = { 4, 2, width - 8, 1 };
	Uint32 c0 = SDL_MapRGB(surface->format, 192, 192, 192);
	Uint32 c2 = SDL_MapRGB(surface->format, 64, 64, 64);
	SDL_FillRect(surface.get(), &r0, c0);
	SDL_FillRect(surface.get(), &r1, c0);
	SDL_FillRect(surface.get(), &r2, c2);

	//over
	separatorTexture = textureFromSurface(renderer, std::move(surface));
	}

	void updateSeparators(SDL_Renderer& renderer) {
	createSeparatorTexture(renderer, rect.w);

	for (unsigned int i = 0; i < actions->item.size(); i++) {
	if (actions->item[i] == "-") {
	actions->updateItem(renderer, i, "-", separatorTexture);
	}
	}
	}

	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,bool grayed=false){
	//FIXME: Add some sort of caching?
	//We draw using surfaces and convert to a texture in the end for now.
	SDL_Color color = objThemes.getTextColor(true);
	if (grayed) {
	color.r = 128 + color.r / 2;
	color.g = 128 + color.g / 2;
	color.b = 128 + color.b / 2;
	}
	SurfacePtr tip(TTF_RenderUTF8_Blended(fontText,caption,color));
	SDL_SetSurfaceBlendMode(tip.get(), SDL_BLENDMODE_NONE);

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

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

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

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

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

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

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

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

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

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

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

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

	//Update the size of the GUIListBox.
	updateListBoxSize();
	}
	void addSeparator(SDL_Renderer& renderer) {
	actions->addItem(renderer, "-", getOrCreateSeparatorTexture(renderer), false);

	//Update the height.
	rect.h += 5;
	}
	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);

	addSeparator(renderer);

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

	if (scenery->sceneryName_.empty()) {
	addSeparator(renderer);
	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 * 2 + 8);
	addItem(renderer, "Remove Links", _("Remove Links"), 8 * 2 + 7);

	//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", tfm::format(_("Behavior: %s"), behaviour[currentBehaviour]).c_str());
	}
	}else{
	addItem(renderer, "Path", _("Path"), 8 + 5);
	addItem(renderer, "Remove Path", _("Remove Path"), 8 * 4 + 2);

	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", tfm::format(_("State: %s"), states[currentState]).c_str());
	}
	//Check if it's a notification block.
	if(type==TYPE_NOTIFICATION_BLOCK)
	addItem(renderer,"Message",_("Message"));
	//Add the custom appearance menu item.
	addItem(renderer, "Appearance", _("Appearance"), 8 + 4);

	addSeparator(renderer);

	//Finally add scripting to the bottom.
	addItem(renderer,"Scripting",_("Scripting"),8*2+1);
	}

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

	addSeparator(renderer);

	addItem(renderer, "AddLayer", _("Add new layer"), 8 * 3 + 6);
	addItem(renderer, "DeleteLayer", _("Delete selected layer"), 8 * 3 + 7, parent->selectedLayer.empty());
	addItem(renderer, "LayerSettings", _("Configure selected layer"), 8 * 3 + 8, parent->selectedLayer.empty());
	addItem(renderer, "MoveToLayer", _("Move selected object to layer"), 0, parent->selectedLayer.empty() \|\| parent->selection.empty());

	addSeparator(renderer);

	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){
	//Check if we need to resize the separator.
	//NOTE: if separatorTexture is NULL then it means that we didn't use the separator at all, so we don't need to update it.
	if (separatorTexture && textureWidth(*separatorTexture) < rect.w) {
	updateSeparators(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 && !pointOnRect(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){
	//Skip next mouse up event since we're clicking a list box and possibly showing a new window.
	GUISkipNextMouseUpEvent = true;

	//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->minWidth = root->width; root->minHeight = root->height;
	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);
	textarea->gravityRight = textarea->gravityBottom = GUIGravityRight;
	//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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name="cfgCancel";
	obj->eventCallback=root;
	root->addChild(obj);

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

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

	//Switch the state.
	enabled=!enabled;

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

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

	//Switch the state.
	visible = !visible;

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

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

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

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

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

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

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

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

	//And update the item.
	updateItem(renderer, actions->value, "Behaviour", tfm::format(_("Behavior: %s"), 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", tfm::format(_("State: %s"), 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->minWidth = root->width; root->minHeight = root->height;
	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);
	obj2->gravityRight = GUIGravityRight;
	//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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->minWidth = root->width; root->minHeight = root->height;
	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->gravityRight = GUIGravityRight;
	obj->name="id";
	root->addChild(obj);

	GUISingleLineListBox* list=new GUISingleLineListBox(imageManager,renderer,50,100,500,36);
	list->gravityRight = GUIGravityRight;
	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->gravityRight = text->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->minWidth = root->width; root->minHeight = root->height;
	root->name="levelScriptingWindow";
	root->eventCallback=parent;
	GUIObject* obj;

	GUISingleLineListBox* list=new GUISingleLineListBox(imageManager,renderer,50,60,500,36);
	list->gravityRight = GUIGravityRight;
	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->gravityRight = text->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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 \|= 36 << 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 ? 3 : 36) << 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);

	// update some other menu items according to selection/visibility changes
	for (unsigned int i = 0; i < actions->item.size(); i++) {
	if (actions->item[i] == "DeleteLayer") {
	updateItem(renderer, i, "DeleteLayer", _("Delete selected layer"), 8 * 3 + 7, parent->selectedLayer.empty());
	} else if (actions->item[i] == "LayerSettings") {
	updateItem(renderer, i, "LayerSettings", _("Configure selected layer"), 8 * 3 + 8, parent->selectedLayer.empty());
	} else if (actions->item[i] == "MoveToLayer") {
	updateItem(renderer, i, "MoveToLayer", _("Move selected object to layer"), 0, parent->selectedLayer.empty() \|\| parent->selection.empty());
	}
	}
	}
	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 - 400) / 2, 600, 400, true, true, _("Add layer"));
	root->minWidth = root->width; root->minHeight = root->height;
	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);
	obj2->gravityRight = GUIGravityRight;
	//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, 400 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name = "cfgAddLayerOK";
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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 == "LayerSettings") {
	// 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 - 500) / 2, 600, 500, true, true, _("Layer settings"));
	root->minWidth = root->width; root->minHeight = root->height;
	root->name = "layerSettingsWindow";
	root->eventCallback = parent;
	GUIObject* obj;

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

	// 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 GUILabel(imageManager, renderer, 40, 284, 520, 36, _("Layer moving speed (1 speed = 0.8 block/s):"));
	root->addChild(obj);
	obj = new GUILabel(imageManager, renderer, 40, 320, 40, 36, "X");
	root->addChild(obj);
	obj = new GUILabel(imageManager, renderer, 320, 320, 40, 36, "Y");
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	root->addChild(obj);

	char s[128];

	GUISpinBox *spinBox = new GUISpinBox(imageManager, renderer, 80, 320, 200, 36);
	spinBox->gravityRight = GUIGravityCenter;
	spinBox->name = "speedX";
	sprintf(s, "%g", it->second->speedX);
	spinBox->caption = s;
	spinBox->format = "%g";
	root->addChild(spinBox);
	spinBox = new GUISpinBox(imageManager, renderer, 360, 320, 200, 36);
	spinBox->gravityLeft = GUIGravityCenter; spinBox->gravityRight = GUIGravityRight;
	spinBox->name = "speedY";
	sprintf(s, "%g", it->second->speedY);
	spinBox->caption = s;
	spinBox->format = "%g";
	root->addChild(spinBox);

	obj = new GUILabel(imageManager, renderer, 40, 364, 520, 36, _("Speed of following camera:"));
	root->addChild(obj);
	obj = new GUILabel(imageManager, renderer, 40, 400, 40, 36, "X");
	root->addChild(obj);
	obj = new GUILabel(imageManager, renderer, 320, 400, 40, 36, "Y");
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	root->addChild(obj);

	spinBox = new GUISpinBox(imageManager, renderer, 80, 400, 200, 36);
	spinBox->gravityRight = GUIGravityCenter;
	spinBox->name = "cameraX";
	sprintf(s, "%g", it->second->cameraX);
	spinBox->caption = s;
	spinBox->format = "%g";
	spinBox->change = 0.1f;
	root->addChild(spinBox);
	spinBox = new GUISpinBox(imageManager, renderer, 360, 400, 200, 36);
	spinBox->gravityLeft = GUIGravityCenter; spinBox->gravityRight = GUIGravityRight;
	spinBox->name = "cameraY";
	sprintf(s, "%g", it->second->cameraY);
	spinBox->caption = s;
	spinBox->format = "%g";
	spinBox->change = 0.1f;
	root->addChild(spinBox);

	obj = new GUIButton(imageManager, renderer, root->width*0.3, 500 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name = "cfgLayerSettingsOK";
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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, 400, true, true, _("Move to layer"));
	root->minWidth = root->width; root->minHeight = root->height;
	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());
	obj2->gravityRight = GUIGravityRight;
	//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, 400 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name = "cfgMoveToLayerOK";
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->minWidth = root->width; root->minHeight = root->height;
	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->gravityRight = text->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name = "cfgCancel";
	obj->eventCallback = root;
	root->addChild(obj);

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

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

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

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

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

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

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

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

	obj = new GUIButton(imageManager, renderer, root->width*0.3, 400 - 44, -1, 36, _("OK"), 0, true, true, GUIGravityCenter);
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name = "cfgAppearanceOK";
	obj->eventCallback = root;
	root->addChild(obj);
	obj = new GUIButton(imageManager, renderer, root->width*0.7, 400 - 44, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	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;

	int maxWidth = 0;

	//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(pointOnRect(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()
	/// TRANSLATORS: Block name
	? std::string(_("Custom scenery block")) : describeSceneryName(scenery->sceneryName_)))
	: parent->typeTextTextures.at(type);
	if (tex) {
	const int w = textureWidth(tex) + 160;
	if (w > maxWidth) maxWidth = w;
	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(pointOnRect(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Select");
	highlightedBtn=1;
	toolTip=ToolTips::Select_UsedInSelectionPopup;
	}
	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(pointOnRect(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Delete");
	highlightedBtn=2;
	toolTip=ToolTips::Delete_UsedInSelectionPopup;
	}
	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(pointOnRect(mouse,r2)){
	drawGUIBox(r2.x,r2.y,r2.w,r2.h,renderer,0x999999FFU);
	tooltipRect=r2;
	//tooltip=_("Configure");
	toolTip=ToolTips::Configure_UsedInSelectionPopup;
	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);
	}
	}

	//Resize the selection popup if necessary
	if (maxWidth > rect.w) {
	rect.w = maxWidth;
	move(rect.x, rect.y);
	}
	}
	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(!pointOnRect(mouse,rect)){
	dismiss();
	return;
	}

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

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

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

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

	MovingPosition::~MovingPosition(){}

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

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

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

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

	selectionPopup=NULL;
	actionsPopup=NULL;

	movingSpeedWidth=-1;

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

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

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

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

	for(size_t i = 0;i < tooltipTextures.size();++i) {
	if (tooltipNames[i][0]) {
	std::string s = _(tooltipNames[i]);
	if (tooltipHotkey[i][0]) {
	s += " (" + std::string(tooltipHotkey[i]) + ")";
	} else if (tooltipHotkey2[i] >= 0) {
	std::string s2 = InputManagerKeyCode::describeTwo(
	inputMgr.getKeyCode((InputManagerKeys)tooltipHotkey2[i], false),
	inputMgr.getKeyCode((InputManagerKeys)tooltipHotkey2[i], true));
	if (!s2.empty()) s += " (" + s2 + ")";
	}
	tooltipTextures[i] = textureFromText(renderer, *fontText, s.c_str(), objThemes.getTextColor(true));
	}
	}

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

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

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

	// 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() ?
	/// TRANSLATORS: Context: Add/Remove ...
	_("Custom scenery block")
	: describeSceneryName(scenery->sceneryName_).c_str())
	: _(blockNames[objects[0]->type]));
	} else {
	const size_t number_of_objects = objects.size();
	/// TRANSLATORS: Context: Undo/Redo ...
	return tfm::format(isAdd ? ngettext("Add %d object", "Add %d objects", number_of_objects).c_str() :
	/// TRANSLATORS: Context: Undo/Redo ...
	ngettext("Remove %d object", "Remove %d objects", number_of_objects).c_str(), number_of_objects);
	}
	}

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

	// FIXME: I have to write this function here since we need to access the static blockNames[]
	std::string RemovePathCommand::describe() {
	/// TRANSLATORS: Context: Undo/Redo ...
	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() {
	/// TRANSLATORS: Context: Undo/Redo ...
	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() {
	/// TRANSLATORS: Context: Undo/Redo ...
	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);
	/// TRANSLATORS: Context: Undo/Redo ...
	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() ?
	/// TRANSLATORS: Context: Undo/Redo ...
	_("Custom scenery block")
	: describeSceneryName(scenery->sceneryName_).c_str())
	: _(blockNames[target->type]);
	s = s.substr(0, lp) + s1 + s.substr(lp + 2);
	}
	lp = s.find("%2");
	if (lp != string::npos) {
	s = s.substr(0, lp) + desc + s.substr(lp + 2);
	}
	return s;
	}

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

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

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

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

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

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

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

	// Clear selection
	selection.clear();

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

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

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

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

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

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

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

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

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

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

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

	+ //We swap the levelObjects and levelObjectsInitial again.
	+ std::swap(levelObjects, levelObjectsInitial);
	+
	//now do our own stuff.
	string s=editorData["time"];
	if(s.empty() \|\| !(s[0]>='0' && s[0]<='9')){
	levelTime=-1;
	}else{
	levelTime=atoi(s.c_str());
	}

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

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

	//NOTE: We set the camera here since we know the dimensions of the level.
	- if(LEVEL_WIDTH<SCREEN_WIDTH)
	- camera.x=-(SCREEN_WIDTH-LEVEL_WIDTH)/2;
	+ if(levelRect.w<SCREEN_WIDTH)
	+ camera.x=-(SCREEN_WIDTH-levelRect.w)/2;
	else
	camera.x=0;
	- if(LEVEL_HEIGHT<SCREEN_HEIGHT)
	- camera.y=-(SCREEN_HEIGHT-LEVEL_HEIGHT)/2;
	+ if(levelRect.h<SCREEN_HEIGHT)
	+ camera.y=-(SCREEN_HEIGHT-levelRect.h)/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 current level.
	LevelPack::Level currentLevel = levels->getLevel(), currentLevel2 = NULL;

	//Check if the current level is individual level,
	//in this case the level are both in "Levels" and "Custom Levels" level packs.
	if (levels->type == COLLECTION) {
	assert(levels->levelpackPath == CUSTOM_LEVELS_PATH);
	if (auto levels2 = getLevelPackManager()->getLevelPack(LEVELS_PATH)) {
	for (int i = 0, m = levels2->getLevelCount(); i < m; i++) {
	if (levels2->getLevel(i)->file == currentLevel->file) {
	currentLevel2 = levels2->getLevel(i);
	break;
	}
	}
	if (currentLevel2 == NULL) {
	fprintf(stderr, "BUG: The custom level '%s' is not conatined in 'Levels' pack!\n", currentLevel->file.c_str());
	}
	}
	}

	//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.
	currentLevel->name = levelName;
	if (currentLevel2) currentLevel2->name = levelName;
	}

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

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

	+ //The arcade mode property.
	+ node.attributes["arcade"].push_back(arcade ? "1" : "0");
	+
	//target time and recordings.
	{
	char c[32];

	sprintf(c, "%d", std::max(levelTime, -1));
	node.attributes["time"].push_back(c);

	//Update the target time the levelpack.
	currentLevel->targetTime = std::max(levelTime, -1);
	if (currentLevel2) currentLevel2->targetTime = std::max(levelTime, -1);

	sprintf(c, "%d", std::max(levelRecordings, -1));
	node.attributes["recordings"].push_back(c);

	//Update the target recordings the levelpack.
	currentLevel->targetRecordings = std::max(levelRecordings, -1);
	if (currentLevel2) currentLevel2->targetRecordings = std::max(levelRecordings, -1);
	}

	//The width of the level.
	- sprintf(s, "%d", LEVEL_WIDTH);
	+ sprintf(s, "%d", levelRect.w);
	node.attributes["size"].push_back(s);

	//The height of the level.
	- sprintf(s, "%d", LEVEL_HEIGHT);
	+ sprintf(s, "%d", levelRect.h);
	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 (const auto& o : obj) {
	//Skip the data whose key or value is empty.
	if (o.first.empty()) continue;
	if (o.second.empty()) continue;

	//Skip SOME data whose value is the default value. Currently only some boolean values are skipped.
	//WARNING: When the default values are changed, these codes MUST be modified accordingly!!!

	//NOTE: Currently we skip the "visible" property since it is used for every block and usually it's the default value.
	if (o.first == "visible" && o.second == "1") continue;

	#if 0
	//NOTE: The following codes are more aggressive!!!
	//if (o.first == "activated" && o.second == "1") continue; //moving blocks and conveyor belt // Don't use this because there was a "disabled" property
	if (o.first == "loop" && o.second == "1") continue; //moving blocks and conveyor belt
	if (o.first == "automatic" && o.second == "0") continue; //portal
	#endif

	//Save the data.
	obj1->attributes[o.first].push_back(o.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);

	it->second->saveToNode(layer);
	}

	//Create a POASerializer and write away the level node.
	POASerializer objSerializer;
	objSerializer.writeNode(&node,save,true,true);
	+
	+ //Invalidates the calculated MD5 for the level since the level is updated.
	+ memset(currentLevel->md5Digest, 0, sizeof(currentLevel->md5Digest));
	+ if (currentLevel2)
	+ memset(currentLevel2->md5Digest, 0, sizeof(currentLevel2->md5Digest));
	}

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

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

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

	//Also check if we should exit the playMode.
	if(inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	//Reset the game and disable playMode, disable script.
	Game::reset(true, true);
	+
	+ //We swap the levelObjects and levelObjectsInitial again.
	+ std::swap(levelObjects, levelObjectsInitial);
	+
	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(pointOnRect(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){
	//Show/hide toolbox if the current mode is ADD and the user clicked ADD again.
	if (tool == ADD && t == ADD) {
	toolboxVisible = !toolboxVisible;
	}

	tool=(Tools)t;

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

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

	return;
	}

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

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

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

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

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

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

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

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

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

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

	//Check for copy (Ctrl+c) or cut (Ctrl+x).
	if(event.type==SDL_KEYDOWN && (event.key.keysym.sym==SDLK_c \|\| event.key.keysym.sym==SDLK_x) && (event.key.keysym.mod & KMOD_CTRL)){
	//Check if the selection isn't empty.
	if(!selection.empty()){
	//Clear the current clipboard.
	clipboard.clear();

	//Loop through the selection to find the left-top block.
	int x=selection[0]->getBox().x;
	int y=selection[0]->getBox().y;
	for(unsigned int o=1; o<selection.size(); o++){
	if(selection[o]->getBox().x<x \|\| selection[o]->getBox().y<y){
	x=selection[o]->getBox().x;
	y=selection[o]->getBox().y;
	}
	}

	//Loop through the selection for the actual copying.
	for(unsigned int o=0; o<selection.size(); o++){
	//Get the editor data of the object.
	vector<pair<string,string> > obj;
	selection[o]->getEditorData(obj);

	//Loop through the editor data and convert it.
	map<string,string> objMap;
	for(unsigned int i=0;i<obj.size();i++){
	objMap[obj[i].first]=obj[i].second;
	}
	//Add some entries to the map.
	char s[64];
	SDL_Rect r = selection[o]->getBox();
	sprintf(s, "%d", r.x - x);
	objMap["x"]=s;
	sprintf(s, "%d", r.y - y);
	objMap["y"]=s;
	sprintf(s, "%d", selection[o]->getBox().w);
	objMap["w"] = s;
	sprintf(s, "%d", selection[o]->getBox().h);
	objMap["h"] = s;

	if (Scenery scenery = dynamic_cast<Scenery>(selection[o])) {
	objMap["sceneryName"] = scenery->sceneryName_;
	objMap["customScenery"] = scenery->customScenery_;
	} else {
	sprintf(s, "%d", selection[o]->type);
	objMap["type"] = s;

	//Save scripts for block.
	if (Block block = dynamic_cast<Block>(selection[o])) {
	for (auto it = block->scripts.begin(); it != block->scripts.end(); ++it) {
	sprintf(s, "_script.%d", it->first);
	objMap[s] = it->second;
	}
	}
	}

	//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;
	Block *block = new Block(this, 0, 0, 50, 50, atoi(clipboard[o]["type"].c_str()));
	obj = block;

	// load the script for the block
	for (auto it = clipboard[o].begin(); it != clipboard[o].end(); ++it) {
	if (it->first.find("_script.") == 0) {
	int eventType = atoi(it->first.c_str() + 8);
	block->scripts[eventType] = it->second;
	}
	}
	} else {
	// a scenery block
	if (selectedLayer.empty()) continue;
	Scenery *scenery = new Scenery(this, 0, 0, 50, 50, clipboard[o]["sceneryName"]);
	if (clipboard[o]["sceneryName"].empty()) {
	scenery->customScenery_ = clipboard[o]["customScenery"];
	scenery->updateCustomScenery(imageManager, renderer);
	}
	obj = scenery;
	}

	obj->setBaseLocation(atoi(clipboard[o]["x"].c_str())+x,atoi(clipboard[o]["y"].c_str())+y);
	obj->setBaseSize(atoi(clipboard[o]["w"].c_str()), atoi(clipboard[o]["h"].c_str()));
	obj->setEditorData(clipboard[o]);

	//add the object.
	newObjects.push_back(obj);

	//Also add the block to the selection.
	selection.push_back(obj);
	}

	// Do the actual object insertion
	if (!newObjects.empty()) {
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, newObjects, true));
	}
	}
	}

	//Check for the arrow keys, used for moving the camera when playMode=false.
	if (inputMgr.isKeyDown(INPUTMGR_RIGHT)) {
	if (cameraXvel < 5) cameraXvel = 5;
	} else if (inputMgr.isKeyDown(INPUTMGR_LEFT)) {
	if (cameraXvel > -5) cameraXvel = -5;
	} else {
	cameraXvel = 0;
	}
	if(inputMgr.isKeyDown(INPUTMGR_DOWN)){
	if (cameraYvel < 5) cameraYvel = 5;
	} else if (inputMgr.isKeyDown(INPUTMGR_UP)){
	if (cameraYvel > -5) cameraYvel = -5;
	} else {
	cameraYvel = 0;
	}

	//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) {
	//Check if this is the start of the dragging.
	if(!dragging){
	//The mouse is moved enough so let's set dragging true.
	dragging=true;
	// NOTE: We start drag from previous mouse position to prevent resize area hit test bug
	onDragStart(event.motion.x - event.motion.xrel + camera.x, event.motion.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 = clamp(camera.x - 200, -1000 - SCREEN_WIDTH, LEVEL_WIDTH + 1000);
	- else camera.y = clamp(camera.y - 200, -1000 - SCREEN_HEIGHT, LEVEL_HEIGHT + 1000);
	+ if (pressedShift) camera.x = clamp(camera.x - 200, -1000 - SCREEN_WIDTH, levelRect.w + 1000);
	+ else camera.y = clamp(camera.y - 200, -1000 - SCREEN_HEIGHT, levelRect.h + 1000);
	break;
	}
	}
	//Check if we scroll down, meaning the currentType--;
	if((event.type==SDL_MOUSEWHEEL && event.wheel.y < 0) \|\| inputMgr.isKeyDownEvent(INPUTMGR_PREVIOUS)){
	switch(tool){
	case ADD:
	//Check if mouse is in tool box.
	if(toolboxVisible && toolboxRect.w>0){
	int x,y;
	SDL_GetMouseState(&x,&y);
	if(y<64){
	const int m = getEditorOrderMax() - (SCREEN_WIDTH - 48) / 64;
	toolboxIndex+=2;
	if(toolboxIndex>m) toolboxIndex=m;
	if(toolboxIndex<0) toolboxIndex=0;
	break;
	}
	}
	//Only change the current type when using the add tool.
	currentType--;
	if(currentType<0){
	currentType = getEditorOrderMax() - 1;
	}
	break;
	case SELECT:
	//When configuring moving blocks.
	if(moving){
	if (pauseMode) {
	//Here we have to use Ctrl because Shift means snap
	pauseTime -= (SDL_GetModState() & KMOD_CTRL) ? 10 : 1;
	if (pauseTime < -1){
	pauseTime = -1;
	}
	} else {
	//Here we have to use Ctrl because Shift means snap
	movingSpeed -= (SDL_GetModState() & KMOD_CTRL) ? 10 : 1;
	if (movingSpeed <= 0){
	movingSpeed = 1;
	}
	}
	break;
	}
	//Fall through.
	default:
	//When in other mode, just scrolling the map
	- if (pressedShift) camera.x = clamp(camera.x + 200, -1000 - SCREEN_WIDTH, LEVEL_WIDTH + 1000);
	- else camera.y = clamp(camera.y + 200, -1000 - SCREEN_HEIGHT, LEVEL_HEIGHT + 1000);
	+ if (pressedShift) camera.x = clamp(camera.x + 200, -1000 - SCREEN_WIDTH, levelRect.w + 1000);
	+ else camera.y = clamp(camera.y + 200, -1000 - SCREEN_HEIGHT, levelRect.h + 1000);
	break;
	}
	}

	if (event.type == SDL_KEYDOWN) {
	bool unlink = false;

	//Check if we should enter playMode.
	if (event.key.keysym.sym == SDLK_F5){
	enterPlayMode();
	}
	//Check for tool shortcuts.
	if (event.key.keysym.sym == SDLK_F2){
	tool = SELECT;
	}
	if (event.key.keysym.sym == SDLK_F3){
	//Show/hide toolbox if the current mode is ADD and the user clicked ADD again.
	if (tool == ADD) {
	toolboxVisible = !toolboxVisible;
	}
	tool = ADD;
	unlink = true;
	}
	if (event.key.keysym.sym == SDLK_F4){
	tool = REMOVE;
	unlink = true;
	}

	//Stop linking or moving if the mode is not SELECT.
	if (unlink) {
	if (linking) {
	linking = false;
	linkingTrigger = NULL;
	}
	if (moving) {
	moving = false;
	movingBlock = NULL;
	}
	}
	}

	//Check for certain events.

	//First make sure the mouse isn't above the toolbar.
	if(!pointOnRect(mouse,toolbarRect) && !pointOnRect(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){
	//Right click in path or link mode means return to normal mode.
	if (event.button.button == SDL_BUTTON_RIGHT && (linking \|\| moving)) {
	//Stop linking.
	linking = false;
	linkingTrigger = NULL;

	//Stop moving.
	moving = false;
	movingBlock = NULL;

	//Stop processing further.
	return;
	}

	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 (pointOnRect(mouse, levelObjects[o]->getBox()) == true){
	clickObjects.push_back(levelObjects[o]);
	}
	}
	}
	} else {
	auto it = sceneryLayers.find(selectedLayer);
	if (it != sceneryLayers.end() && layerVisibility[selectedLayer]) {
	for (auto o : it->second->objects){
	if (pointOnRect(mouse, o->getBox()) == true){
	clickObjects.push_back(o);
	}
	}
	}
	}

	//Check if there are multiple objects above eachother or just one.
	if(clickObjects.size()==1){
	//We have collision meaning that the mouse is above an object.
	std::vector<GameObject*>::iterator it;
	it=find(selection.begin(),selection.end(),clickObjects[0]);

	//Set event true since there's a click event.
	clickEvent=true;

	//Check if the clicked object is in the selection or not.
	bool isSelected=(it!=selection.end());
	if(event.button.button==SDL_BUTTON_LEFT){
	onClickObject(clickObjects[0],isSelected);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	onRightClickObject(imageManager,renderer,clickObjects[0],isSelected);
	}
	}else if(clickObjects.size()>=1){
	//There are more than one object under the mouse
	//SDL2 port (never managed to trigger this without changing the parameters.
	std::vector<GameObject*>::iterator it;
	it=find(selection.begin(),selection.end(),clickObjects[0]);

	//Set event true since there's a click event.
	clickEvent=true;

	//Check if the clicked object is in the selection or not.
	bool isSelected=(it!=selection.end());

	//Only show the selection popup when right clicking.
	if(event.button.button==SDL_BUTTON_LEFT){
	onClickObject(clickObjects[0],isSelected);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	//Remove the selection popup if there's one.
	if(selectionPopup!=NULL)
	delete selectionPopup;

	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	selectionPopup=new LevelEditorSelectionPopup(this,imageManager,renderer,clickObjects,x,y);
	}
	}
	}

	//If event is false then we clicked on void.
	if(!clickEvent){
	if(event.type==SDL_MOUSEBUTTONDOWN){
	if(event.button.button==SDL_BUTTON_LEFT){
	//Left mouse button on void.
	onClickVoid(mouse.x,mouse.y);
	}else if(event.button.button==SDL_BUTTON_RIGHT){
	onRightClickVoid(imageManager,renderer,mouse.x,mouse.y);
	}
	}
	}
	}

	//Check for backspace when moving to remove a movingposition.
	if(moving && event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_BACKSPACE){
	if(movingBlocks[movingBlock].size()>0){
	commandManager->doCommand(new AddRemovePathCommand(this, movingBlock, MovingPosition(0, 0, 0), false));
	}
	}

	//Check for the tab key, level settings.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	//Show the levelSettings.
	levelSettings(imageManager,renderer);
	}

	//Check if we should save the level (Ctrl+s).
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_s && (event.key.keysym.mod & KMOD_CTRL)){
	saveCurrentLevel(imageManager, renderer);
	}

	//Undo ctrl+z
	if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_z && (event.key.keysym.mod & KMOD_CTRL)){
	undo();
	}

	//Redo ctrl+y
	if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_y && (event.key.keysym.mod & KMOD_CTRL)){
	redo();
	}
	}
	}

	void LevelEditor::saveCurrentLevel(ImageManager& imageManager, SDL_Renderer& renderer) {
	saveLevel(levelFile);

	//Clear the dirty flag
	commandManager->resetChange();

	//And give feedback to the user.
	if (levelName.empty())
	msgBox(imageManager, renderer, tfm::format(_("Level \"%s\" saved"), fileNameFromPath(levelFile)), MsgBoxOKOnly, _("Saved"));
	else
	msgBox(imageManager, renderer, tfm::format(_("Level \"%s\" saved"), levelName), MsgBoxOKOnly, _("Saved"));
	}

	void LevelEditor::enterPlayMode(){
	//Check if we are already in play mode.
	if(playMode) return;

	//Stop linking or moving.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	}

	if(moving){
	moving=false;
	movingBlock=NULL;
	}

	+ //Recalculate the number of collectibles.
	+ totalCollectables = totalCollectablesSaved = totalCollectablesInitial = 0;
	+
	//We need to reposition player and shadow here, since the related code is removed from object placement.
	for (auto obj : levelObjects) {
	//If the object is a player or shadow start then change the start position of the player or shadow.
	if (obj->type == TYPE_START_PLAYER){
	//Center the player horizontally.
	player.fx = obj->getBox().x + (obj->getBox().w - player.getBox().w) / 2;
	player.fy = obj->getBox().y;
	}
	if (obj->type == TYPE_START_SHADOW){
	//Center the shadow horizontally.
	shadow.fx = obj->getBox().x + (obj->getBox().w - shadow.getBox().w) / 2;
	shadow.fy = obj->getBox().y;
	}
	+ if (obj->type == TYPE_COLLECTABLE) {
	+ totalCollectablesSaved = totalCollectablesInitial = ++totalCollectables;
	+ }
	}

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

	+ //We swap the levelObjects and levelObjectsInitial again.
	+ std::swap(levelObjects, levelObjectsInitial);
	+
	//Restart the game with scripting enabled.
	Game::reset(true, false);
	}

	void LevelEditor::undo(){
	commandManager->undo();
	}

	void LevelEditor::redo(){
	commandManager->redo();
	}

	void LevelEditor::levelSettings(ImageManager& imageManager,SDL_Renderer& renderer){
	//It isn't so open a popup asking for a name.
	- GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-450)/2,600,450,true,true,_("Level settings"));
	+ GUIWindow* root=new GUIWindow(imageManager,renderer,(SCREEN_WIDTH-600)/2,(SCREEN_HEIGHT-500)/2,600,500,true,true,_("Level settings"));
	root->minWidth = root->width; root->minHeight = root->height;
	root->name="lvlSettingsWindow";
	root->eventCallback=this;
	GUIObject* obj;

	//Create the two textboxes with a label.
	obj=new GUILabel(imageManager,renderer,40,60,240,36,_("Name:"));
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,60,410,36,levelName.c_str());
	obj->gravityRight = GUIGravityRight;
	obj->name="name";
	root->addChild(obj);

	obj = new GUILabel(imageManager, renderer, 40, 110, 240, 36, (std::string("* ") + _("Theme:")).c_str());
	root->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,140,110,410,36,levelTheme.c_str());
	obj->gravityRight = GUIGravityRight;
	obj->name="theme";
	root->addChild(obj);

	obj = new GUILabel(imageManager, renderer, 40, 150, 510, 36, _("Examples: %DATA%/themes/classic"));
	root->addChild(obj);
	obj = new GUILabel(imageManager, renderer, 40, 174, 510, 36, _("or %USER%/themes/Orange"));
	root->addChild(obj);

	obj = new GUILabel(imageManager, renderer, 40, 210, 240, 36, _("Music:"));
	root->addChild(obj);
	obj = new GUITextBox(imageManager, renderer, 140, 210, 410, 36, levelMusic.c_str());
	obj->gravityRight = GUIGravityRight;
	obj->name = "music";
	root->addChild(obj);

	+ //arcade mode check box.
	+ obj = new GUICheckBox(imageManager, renderer, 40, 260, 240, 36, _("Arcade mode"));
	+ obj->name = "chkArcadeMode";
	+ obj->value = arcade ? 1 : 0;
	+ obj->eventCallback = root;
	+ root->addChild(obj);
	+
	//target time and recordings.
	{
	- obj=new GUICheckBox(imageManager,renderer,40,260,240,36,_("Target time (s):"));
	+ obj=new GUICheckBox(imageManager,renderer,40,310,240,36,_("Target time (s):"));
	obj->name = "chkTime";
	obj->value = levelTime >= 0 ? 1 : 0;
	obj->eventCallback = root;
	root->addChild(obj);
	- GUISpinBox* obj2=new GUISpinBox(imageManager,renderer,290,260,260,36);
	+ GUISpinBox* obj2=new GUISpinBox(imageManager,renderer,290,310,260,36);
	obj2->gravityRight = GUIGravityRight;
	obj2->name="time";

	char ss[128];
	sprintf(ss, "%0.2f", double(levelTime >= 0 ? levelTime : ~levelTime) / 40.0);
	obj2->caption=ss;

	obj2->visible = levelTime >= 0;
	obj2->limitMin=0.0f;
	obj2->limitMax = 1E+6f;
	obj2->format = "%0.2f";
	obj2->change=0.1f;
	obj2->update();
	root->addChild(obj2);

	- obj=new GUICheckBox(imageManager,renderer,40,310,240,36,_("Target recordings:"));
	+ obj=new GUICheckBox(imageManager,renderer,40,360,240,36,arcade?_("Target collectibles:"):_("Target recordings:"));
	obj->name = "chkRecordings";
	obj->value = levelRecordings >= 0 ? 1 : 0;
	obj->eventCallback = root;
	root->addChild(obj);
	- obj2=new GUISpinBox(imageManager,renderer,290,310,260,36);
	+ obj2=new GUISpinBox(imageManager,renderer,290,360,260,36);
	obj2->gravityRight = GUIGravityRight;

	sprintf(ss, "%d", levelRecordings >= 0 ? levelRecordings : ~levelRecordings);
	obj2->caption=ss;

	obj2->visible = levelRecordings >= 0;
	obj2->limitMin=0.0f;
	obj2->limitMax = 1E+6f;
	obj2->format="%1.0f";
	obj2->name="recordings";
	obj2->update();
	root->addChild(obj2);
	}

	- obj = new GUILabel(imageManager, renderer, 40, 350, 510, 36, (std::string("* ") + _("Restart level editor is required")).c_str());
	+ obj = new GUILabel(imageManager, renderer, 40, 400, 510, 36, (std::string("* ") + _("Restart level editor is required")).c_str());
	root->addChild(obj);

	//Ok and cancel buttons.
	- obj=new GUIButton(imageManager,renderer,root->width*0.3,450-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.3,500-44,-1,36,_("OK"),0,true,true,GUIGravityCenter);
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name="lvlSettingsOK";
	obj->eventCallback=root;
	root->addChild(obj);
	- obj=new GUIButton(imageManager,renderer,root->width*0.7,450-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	+ obj=new GUIButton(imageManager,renderer,root->width*0.7,500-44,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	obj->gravityLeft = obj->gravityRight = GUIGravityCenter;
	obj->gravityTop = obj->gravityBottom = GUIGravityRight;
	obj->name="lvlSettingsCancel";
	obj->eventCallback=root;
	root->addChild(obj);

	GUIObjectRoot->addChild(root);
	}

	void LevelEditor::postLoad(){
	//We need to find the triggers.
	for(unsigned int o=0;o<levelObjects.size();o++){
	//Check for the highest id.
	unsigned int id=atoi(levelObjects[o]->getEditorProperty("id").c_str());
	if(id>=currentId)
	currentId=id+1;

	switch(levelObjects[o]->type){
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	//Add the object to the triggers vector.
	vector<GameObject*> linked;
	triggers[levelObjects[o]]=linked;
	//Now loop through the levelObjects in search for objects with the same id.
	for(unsigned int oo=0;oo<levelObjects.size();oo++){
	//Check if it isn't the same object but has the same id.
	if(o!=oo && (dynamic_cast<Block>(levelObjects[o]))->id==(dynamic_cast<Block>(levelObjects[oo]))->id){
	//Add the object to the link vector of the trigger.
	triggers[levelObjects[o]].push_back(levelObjects[oo]);
	}
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Add the object to the triggers vector.
	vector<GameObject*> linked;
	triggers[levelObjects[o]]=linked;

	//If the destination is empty we return.
	if((dynamic_cast<Block*>(levelObjects[o]))->destination.empty()){
	break;
	}

	//Now loop through the levelObjects in search for objects with the same id as destination.
	for(unsigned int oo=0;oo<levelObjects.size();oo++){
	//Check if it isn't the same object but has the same id.
	if(o!=oo && (dynamic_cast<Block>(levelObjects[o]))->destination==(dynamic_cast<Block>(levelObjects[oo]))->id){
	//Add the object to the link vector of the trigger.
	triggers[levelObjects[o]].push_back(levelObjects[oo]);
	}
	}
	break;
	}
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//Get the moving position.
	const vector<SDL_Rect> &movingPos = levelObjects[o]->movingPos;

	//Add the object to the movingBlocks vector.
	movingBlocks[levelObjects[o]].clear();

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

	break;
	}
	default:
	break;
	}
	}

	// Set the visibility of all layers to true
	layerVisibility.clear();
	for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it) {
	layerVisibility[it->first] = true;
	}
	layerVisibility[std::string()] = true;

	// Also set the current layer to the Block layer
	selectedLayer.clear();

	// Get all available scenery blocks
	std::set<std::string> tmpset;
	objThemes.getSceneryBlockNames(tmpset);
	sceneryBlockNames.clear();
	sceneryBlockNames.insert(sceneryBlockNames.end(), tmpset.begin(), tmpset.end());
	}

	void LevelEditor::snapToGrid(int* x,int* y){
	//Check if the x location is negative.
	if(*x<0){
	x=-((abs(x-50)/50)*50);
	}else{
	x=(x/50)*50;
	}

	//Now the y location.
	if(*y<0){
	y=-((abs(y-50)/50)*50);
	}else{
	y=(y/50)*50;
	}
	}

	void LevelEditor::setCamera(const SDL_Rect* r,int count){
	//SetCamera only works in the Level editor and when mouse is inside window.
	if(stateID==STATE_LEVEL_EDITOR&&(SDL_GetMouseFocus() == sdlWindow)){
	//Get the mouse coordinates.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//Don't continue here if mouse is inside one of the boxes given as parameter.
	for(int i=0;i<count;i++){
	if(pointOnRect(mouse,r[i]))
	return;
	}

	//FIXME: two ad-hoc camera speed variables similar to cameraXvel and cameraYvel
	static int cameraXvelB = 0, cameraYvelB = 0;

	//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.
	if (cameraXvelB > -5) cameraXvelB = -5;
	if (pressedShift) cameraXvelB--;
	} else if (x > SCREEN_WIDTH - 50) {
	//We're near the right edge so move the camera.
	if (cameraXvelB < 5) cameraXvelB = 5;
	if (pressedShift) cameraXvelB++;
	} else {
	cameraXvelB = 0;
	}

	//Check if the tool box is visible and we need to calc screen size correctly.
	int y0=50;
	if (toolboxVisible && toolboxRect.w > 0) y0 += toolbarRect.h;

	//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.
	if (cameraYvelB > -5) cameraYvelB = -5;
	if (pressedShift) cameraYvelB--;
	} else if (y > SCREEN_HEIGHT - 50) {
	//We're near the bottom edge so move the camera.
	if (cameraYvelB < 5) cameraYvelB = 5;
	if (pressedShift) cameraYvelB++;
	} else {
	cameraYvelB = 0;
	}

	- camera.x = clamp(camera.x + cameraXvelB, -1000 - SCREEN_WIDTH, LEVEL_WIDTH + 1000);
	- camera.y = clamp(camera.y + cameraYvelB, -1000 - SCREEN_HEIGHT, LEVEL_HEIGHT + 1000);
	+ camera.x = clamp(camera.x + cameraXvelB, -1000 - SCREEN_WIDTH, levelRect.w + 1000);
	+ camera.y = clamp(camera.y + cameraYvelB, -1000 - SCREEN_HEIGHT, levelRect.h + 1000);
	}
	}

	void LevelEditor::onClickObject(GameObject* obj,bool selected){
	switch(tool){
	case SELECT:
	{
	//Check if we are linking.
	if(linking){
	//Check if the obj is valid to link to.
	switch(obj->type){
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	{
	//It's only valid when not linking a portal.
	if(linkingTrigger->type==TYPE_PORTAL){
	//You can't link a portal to moving blocks, etc.
	//Stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	}
	break;
	}
	case TYPE_PORTAL:
	{
	//Make sure that the linkingTrigger is also a portal.
	if(linkingTrigger->type!=TYPE_PORTAL){
	//The linkingTrigger isn't a portal so stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	}
	break;
	}
	default:
	//It isn't valid so stop linking and return.
	linkingTrigger=NULL;
	linking=false;
	return;
	break;
	}

	AddLinkCommand* pCommand = new AddLinkCommand(this, linkingTrigger, obj);
	commandManager->doCommand(pCommand);

	//We return to prevent configuring stuff like conveyor belts, etc...
	linking=false;
	linkingTrigger=NULL;
	return;
	}

	//If we're moving add a movingposition.
	if(moving){
	//Get the current mouse location.
	int x, y;
	SDL_GetMouseState(&x, &y);
	x += camera.x;
	y += camera.y;

	addMovingPosition(x, y);
	return;
	}
	}
	case ADD:
	{
	//Check if object is already selected.
	if(!selected){
	//First check if shift is pressed or not.
	if(!pressedShift){
	//Clear the selection.
	deselectAll();
	}

	//Add the object to the selection.
	selection.push_back(obj);
	}
	break;
	}
	case REMOVE:
	{
	//Remove the object.
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, obj, false));
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::addMovingPosition(int x,int y) {
	//Apply snap to grid.
	if (!pressedShift){
	snapToGrid(&x, &y);
	} else{
	x -= 25;
	y -= 25;
	}

	x -= movingBlock->getBox().x;
	y -= movingBlock->getBox().y;

	//Calculate the length.
	//First get the delta x and y.
	int dx, dy;
	if (movingBlocks[movingBlock].empty()){
	dx = x;
	dy = y;
	} else{
	dx = x - movingBlocks[movingBlock].back().x;
	dy = y - movingBlocks[movingBlock].back().y;
	}

	AddRemovePathCommand* pCommand = NULL;

	if (dx == 0 && dy == 0) {
	// pause mode
	if (pauseTime != 0) pCommand = new AddRemovePathCommand(this, movingBlock, MovingPosition(x, y, std::max(pauseTime, 0)), true);
	pauseTime = 0;
	} else {
	// add new point mode
	const double length = sqrt(double(dxdx + dydy));
	pCommand = new AddRemovePathCommand(this, movingBlock, MovingPosition(x, y, (int)(length*(10 / (double)movingSpeed))), true);
	}
	if (pCommand) commandManager->doCommand(pCommand);
	}

	void LevelEditor::onRightClickObject(ImageManager& imageManager,SDL_Renderer& renderer,GameObject* obj,bool){
	//Create an actions popup for the game object.
	if(actionsPopup==NULL){
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,this,obj,x,y);
	return;
	}
	}

	void LevelEditor::onClickVoid(int x,int y){
	switch(tool){
	case ADD:
	{
	//We need to clear the selection.
	deselectAll();

	//Now place an object.
	//Apply snap to grid.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}
	if (currentType >= 0 && currentType < getEditorOrderMax()) {
	GameObject *obj;
	if (selectedLayer.empty()) {
	obj = new Block(this, x, y, 50, 50, editorTileOrder[currentType]);
	} else {
	obj = new Scenery(this, x, y, 50, 50,
	currentType < (int)sceneryBlockNames.size() ? sceneryBlockNames[currentType] : std::string());
	}
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, obj, true));
	}
	break;
	}
	case SELECT:
	{
	//We need to clear the selection.
	deselectAll();

	//If we're linking we should stop, user abort.
	if(linking){
	linking=false;
	linkingTrigger=NULL;
	//And return.
	return;
	}

	//If we're moving we should add a point.
	if(moving){
	addMovingPosition(x, y);

	//And return.
	return;
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onRightClickVoid(ImageManager& imageManager,SDL_Renderer& renderer,int,int){
	//Create an actions popup for the game object.
	if(actionsPopup==NULL){
	//Get the mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	actionsPopup=new LevelEditorActionsPopup(imageManager,renderer,this,NULL,x,y);
	return;
	}
	}

	void LevelEditor::onDragStart(int x,int y){
	switch(tool){
	case SELECT:
	case ADD:
	{
	//We can drag the selection so check if the selection isn't empty.
	if(!selection.empty()){
	//The selection isn't empty so search the dragCenter.
	//Create a mouse rectangle.
	SDL_Rect mouse={x,y,0,0};

	// record the drag start position
	dragSrartPosition.x = x;
	dragSrartPosition.y = y;

	//Loop through the objects to check collision.
	for(unsigned int o=0; o<selection.size(); o++){
	SDL_Rect r = selection[o]->getBox();
	if(pointOnRect(mouse, r)){
	//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 (pointOnRect(mouse, levelObjects[o]->getBox()) == true){
	objects.push_back(levelObjects[o]);
	}
	}
	}
	} else {
	auto it = sceneryLayers.find(selectedLayer);
	if (it != sceneryLayers.end() && layerVisibility[selectedLayer]) {
	for (auto o : it->second->objects){
	if (pointOnRect(mouse, o->getBox()) == true){
	objects.push_back(o);
	}
	}
	}
	}

	// Do the actual object deletion.
	if (!objects.empty()) {
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, objects, false));
	}

	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onDrop(int x,int y){
	switch(tool){
	case SELECT:
	case ADD:
	{
	//Check if the drag center isn't null.
	if(dragCenter==NULL)
	return;
	//The location of the dragCenter.
	SDL_Rect r=dragCenter->getBox();

	if (selectionDrag == 4) { // dragging
	//Apply snap to grid.
	determineNewPosition(x, y);

	commandManager->doCommand(new MoveGameObjectCommand(this, selection, x - r.x, y - r.y));
	} else if (selectionDrag >= 0) { // resizing
	determineNewSize(x, y, r);

	commandManager->doCommand(new MoveGameObjectCommand(this, dragCenter, r.x, r.y, r.w, r.h));
	}

	//Make sure the dragCenter is null and set selectionDrag false.
	dragCenter=NULL;
	selectionDrag=-1;
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::onCameraMove(int dx,int dy){
	switch(tool){
	case REMOVE:
	{
	//Only delete when the left mouse button is pressed.
	if(pressedLeftMouse){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	//Create the rectangle.
	SDL_Rect mouse={x+camera.x,y+camera.y,0,0};

	std::vector<GameObject*> objects;

	//Loop through the objects to check collision.
	if (selectedLayer.empty()) {
	if (layerVisibility[selectedLayer]) {
	for (unsigned int o = 0; o<levelObjects.size(); o++){
	if (pointOnRect(mouse, levelObjects[o]->getBox()) == true){
	objects.push_back(levelObjects[o]);
	}
	}
	}
	} else {
	auto it = sceneryLayers.find(selectedLayer);
	if (it != sceneryLayers.end() && layerVisibility[selectedLayer]) {
	for (auto o : it->second->objects){
	if (pointOnRect(mouse, o->getBox()) == true){
	objects.push_back(o);
	}
	}
	}
	}

	// Do the actual object deletion.
	if (!objects.empty()) {
	commandManager->doCommand(new AddRemoveGameObjectCommand(this, objects, false));
	}
	}
	break;
	}
	default:
	break;
	}
	}

	void LevelEditor::selectionDirty() {
	if (selectionPopup != NULL) selectionPopup->dirty = true;
	}

	void LevelEditor::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check if one of the windows is closed.
	if (eventType == GUIEventClick && name.size() >= 6 && name.substr(name.size() - 6) == "Window") {
	destroyWindow(obj);
	return;
	}
	//Resize code for each GUIWindow.
	if (name.size() >= 6 && name.substr(name.size() - 6) == "Window") {
	//Currently we don't need to process custom resize code since they are already processed in GUIWindow::resize().
	return;
	}

	//Check for GUI events.
	//Notification block configure events.
	if(name=="cfgNotificationBlockOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	//Get the message textbox from the GUIWindow.
	GUITextArea* message=(GUITextArea*)obj->getChild("message");

	if(message){
	//Set the message of the notification block.
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	configuredObject, "message", message->getString(), _("Message")));
	}
	}
	}
	//Conveyor belt block configure events.
	else if(name=="cfgConveyorBlockOK"){
	//Get the configuredObject.
	GameObject* configuredObject=objectWindows[obj];
	if(configuredObject){
	//Get the speed textbox from the GUIWindow.
	GUISpinBox* speed=(GUISpinBox*)obj->getChild("speed");

	if(speed){
	//Set the speed of the conveyor belt.
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	configuredObject, "speed10", speed->caption, _("Speed")));
	}
	}
	}
	+ else if (name == "chkArcadeMode") {
	+ obj->getChild("chkRecordings")->caption = obj->getChild("chkArcadeMode")->value ? _("Target collectibles:") : _("Target recordings:");
	+ return;
	+ }
	else if (name == "chkTime") {
	obj->getChild("time")->visible = obj->getChild("chkTime")->value ? 1 : 0;
	return;
	}
	else if (name == "chkRecordings") {
	obj->getChild("recordings")->visible = obj->getChild("chkRecordings")->value ? 1 : 0;
	return;
	}
	//LevelSetting events.
	else if(name=="lvlSettingsOK"){
	SetLevelPropertyCommand::LevelProperty prop;

	prop.levelTime = -1;
	prop.levelRecordings = -1;

	GUIObject* object=obj->getChild("name");
	if(object)
	prop.levelName=object->caption;
	object=obj->getChild("theme");
	if(object)
	prop.levelTheme=object->caption;
	object = obj->getChild("music");
	if (object)
	prop.levelMusic = object->caption;

	+ //arcade mode.
	+ object = obj->getChild("chkArcadeMode");
	+ if (object)
	+ prop.arcade = object->value;
	+
	//target time and recordings.
	object = obj->getChild("chkTime");
	GUISpinBox* object2 = dynamic_cast<GUISpinBox*>(obj->getChild("time"));
	assert(object && object2);

	double number = std::max(atof(object2->caption.c_str()), 0.0);
	prop.levelTime = int(floor(number*40.0 + 0.5));
	if (object->value == 0) prop.levelTime = ~prop.levelTime;

	object = obj->getChild("chkRecordings");
	object2 = dynamic_cast<GUISpinBox*>(obj->getChild("recordings"));
	assert(object && object2);

	prop.levelRecordings = std::max(atoi(object2->caption.c_str()), 0);
	if (object->value == 0) prop.levelRecordings = ~prop.levelRecordings;

	// Perform the level setting modification
	commandManager->doCommand(new SetLevelPropertyCommand(this, prop));
	}
	//Level scripting window events.
	else if(name=="cfgLevelScriptingEventType"){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgLevelScriptingEventType");

	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	GUIObject* script=obj->getChild(list->item[i].first);
	if(script){
	script->visible=(script->name==list->item[list->value].first);
	script->enabled=(script->name==list->item[list->value].first);
	}
	}
	}
	return;
	}
	else if(name=="cfgLevelScriptingOK"){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgLevelScriptingEventType");

	if(list){
	std::map<int, std::string> newScript;

	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	//Get the GUITextArea.
	GUITextArea* script=dynamic_cast<GUITextArea*>(obj->getChild(list->item[i].first));
	if(script){
	//Set the script for the target block.
	string str=script->getString();
	if(!str.empty())
	newScript[levelEventNameMap[script->name]]=str;
	}
	}

	// Check achievement
	if (!newScript.empty()) {
	statsMgr.newAchievement("helloworld");
	}

	// Do the actual changes
	commandManager->doCommand(new SetScriptCommand(this, NULL, newScript));
	}
	}
	//Scripting window events.
	else if (name == "cfgScriptingEventType"){
	//TODO: Save any unsaved scripts? (Or keep track of all scripts and save upon cfgScriptingOK?)
	//Get the configuredObject.
	Block* configuredObject=dynamic_cast<Block*>(objectWindows[obj]);
	if(configuredObject){
	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=dynamic_cast<GUISingleLineListBox*>(obj->getChild("cfgScriptingEventType"));

	if(list){
	//Loop through the scripts.
	for(unsigned int i=0;i<list->item.size();i++){
	GUIObject* script=obj->getChild(list->item[i].first);
	if(script){
	script->visible=script->enabled=(script->name==list->item[list->value].first);
	}
	}
	}
	}
	return;
	}
	else if(name=="cfgScriptingOK"){
	//Get the configuredObject.
	Block* block = dynamic_cast<Block*>(objectWindows[obj]);
	if (block){
	std::map<int, std::string> newScript;
	std::string newId;

	//Get the script textbox from the GUIWindow.
	GUISingleLineListBox* list=(GUISingleLineListBox*)obj->getChild("cfgScriptingEventType");
	GUIObject* id=obj->getChild("id");

	if (list){
	//Loop through the scripts.
	for (unsigned int i = 0; i < list->item.size(); i++){
	//Get the GUITextArea.
	GUITextArea* script = dynamic_cast<GUITextArea*>(obj->getChild(list->item[i].first));
	if (script){
	//Set the script for the target block.
	string str = script->getString();
	if (!str.empty())
	newScript[gameObjectEventNameMap[script->name]] = str;
	}
	}
	}
	newId = block->id;
	if (id){
	newId = id->caption;
	}

	// Check achievement
	if (!newScript.empty()) {
	statsMgr.newAchievement("helloworld");
	}

	// now do the actual changes
	commandManager->doCommand(new SetScriptCommand(this, block, newScript, newId));
	}
	}
	else if (name == "cfgAddLayerOK") {
	GUIObject* object = obj->getChild("layerName");
	if (!object) return;
	if (object->caption.empty()) {
	msgBox(imageManager, renderer, _("Please enter a layer name."), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (sceneryLayers.find(object->caption) != sceneryLayers.end()) {
	msgBox(imageManager, renderer, tfm::format(_("The layer '%s' already exists."), object->caption), MsgBoxOKOnly, _("Error"));
	return;
	}

	// do the actual operation
	commandManager->doCommand(new AddRemoveLayerCommand(this, object->caption, true));
	}
	else if (name == "cfgLayerSettingsOK") {
	SetLayerPropertyCommand::LayerProperty prop;

	GUIObject* object = obj->getChild("layerName");
	if (!object) return;
	prop.name = object->caption;

	object = obj->getChild("speedX");
	if (!object) return;
	prop.speedX = atof(object->caption.c_str());

	object = obj->getChild("speedY");
	if (!object) return;
	prop.speedY = atof(object->caption.c_str());

	object = obj->getChild("cameraX");
	if (!object) return;
	prop.cameraX = atof(object->caption.c_str());

	object = obj->getChild("cameraY");
	if (!object) return;
	prop.cameraY = atof(object->caption.c_str());

	object = obj->getChild("oldName");
	if (!object) return;
	const std::string& oldName = object->caption;

	if (prop.name.empty()) {
	msgBox(imageManager, renderer, _("Please enter a layer name."), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (prop.name != oldName && sceneryLayers.find(prop.name) != sceneryLayers.end()) {
	msgBox(imageManager, renderer, tfm::format(_("The layer '%s' already exists."), prop.name), MsgBoxOKOnly, _("Error"));
	return;
	}

	// do the actual operation
	commandManager->doCommand(new SetLayerPropertyCommand(this, oldName, prop));
	}
	else if (name == "cfgMoveToLayerOK") {
	GUIObject* object = obj->getChild("layerName");
	if (!object) return;
	const std::string& layerName = object->caption;

	object = obj->getChild("oldName");
	if (!object) return;
	const std::string& oldName = object->caption;

	if (layerName.empty()) {
	msgBox(imageManager, renderer, _("Please enter a layer name."), MsgBoxOKOnly, _("Error"));
	return;
	}
	if (oldName == layerName) {
	msgBox(imageManager, renderer, _("Source and destination layers are the same."), MsgBoxOKOnly, _("Error"));
	return;
	}

	// do the actual operation
	commandManager->doCommand(new MoveToLayerCommand(this, selection, oldName, layerName));
	}
	else if (name == "cfgCustomSceneryOK") {
	//Get the configuredObject.
	Scenery* configuredObject = dynamic_cast<Scenery*>(objectWindows[obj]);
	if (configuredObject){
	//Get the custom scenery from the GUIWindow.
	GUITextArea* txt = (GUITextArea*)obj->getChild("cfgCustomScenery");

	if (txt){
	//Set the custom scenery.
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	configuredObject, "customScenery", txt->getString(), _("Scenery")));
	}
	}
	}
	else if (name == "lstAppearance") {
	//Get the configuredObject.
	Block block = dynamic_cast<Block>(objectWindows[obj]);
	GUIListBox list = dynamic_cast<GUIListBox>(obj->getChild("lstAppearance"));
	GUIImage image = dynamic_cast<GUIImage>(obj->getChild("imgAppearance"));
	if (block && list && image) {
	//Reset the image first.
	image->setImage(NULL);
	image->setClipRect(SDL_Rect{ 0, 0, 0, 0 });

	//Get the appearance name.
	std::string appearanceName;
	if (list->value <= 0) {
	//Do nothing since the selected is the default appearance.
	} else if (list->value <= (int)sceneryBlockNames.size()) {
	//A custom appearance is selected.
	appearanceName = sceneryBlockNames[list->value - 1];
	} else {
	//The configured object has an invalid custom appearance name.
	appearanceName = block->customAppearanceName;
	}

	//Try to find the theme block.
	ThemeBlock *themeBlock = NULL;
	if (!appearanceName.empty()) {
	themeBlock = objThemes.getScenery(appearanceName);
	}
	if (themeBlock == NULL) {
	themeBlock = objThemes.getBlock(block->type);
	}
	if (themeBlock) {
	image->setImage(themeBlock->editorPicture.texture);
	const auto& offsetData = themeBlock->editorPicture.offset.offsetData;
	if (offsetData.size() > 0) {
	const auto& r = offsetData[0];
	image->setClipRect(SDL_Rect{ r.x, r.y, r.w, r.h });
	}
	}
	}
	return;
	}
	else if (name == "cfgAppearanceOK") {
	//Get the configuredObject.
	Block block = dynamic_cast<Block>(objectWindows[obj]);
	GUIListBox list = dynamic_cast<GUIListBox>(obj->getChild("lstAppearance"));
	if (block && list) {
	//Get the appearance name.
	std::string appearanceName;
	if (list->value <= 0) {
	//Do nothing since the selected is the default appearance.
	} else if (list->value <= (int)sceneryBlockNames.size()) {
	//A custom appearance is selected.
	appearanceName = sceneryBlockNames[list->value - 1];
	} else {
	//The configured object has an invalid custom appearance name.
	appearanceName = block->customAppearanceName;
	}

	//Update the block property if it's changed.
	if (appearanceName != block->customAppearanceName) {
	commandManager->doCommand(new SetEditorPropertyCommand(this, imageManager, renderer,
	block, "appearance", appearanceName, _("Appearance")));
	}
	}
	}

	//NOTE: We assume every event came from a window
	//and the event is either window closed event or OK/Cancel button click event, so we remove it.
	destroyWindow(obj);
	}

	void LevelEditor::destroyWindow(GUIObject* window){
	//Make sure the given pointer isn't null.
	if(!window)
	return;

	//Remove the window from the GUIObject root.
	if(GUIObjectRoot){
	vector<GUIObject*>::iterator it;
	it=find(GUIObjectRoot->childControls.begin(),GUIObjectRoot->childControls.end(),window);
	if(it!=GUIObjectRoot->childControls.end()){
	GUIObjectRoot->childControls.erase(it);
	}
	}

	//Also remove the window from the objectWindows map.
	map<GUIObject,GameObject>::iterator it;
	it=objectWindows.find(window);
	if(it!=objectWindows.end()){
	objectWindows.erase(it);
	}

	//And delete the GUIWindow.
	delete window;
	}

	////////////////LOGIC////////////////////
	void LevelEditor::logic(ImageManager& imageManager, SDL_Renderer& renderer){
	if(playMode){
	//PlayMode so let the game do it's logic.
	Game::logic(imageManager,renderer);
	}else{
	//Update animation even under edit mode. (There are checks in Block::move() which don't do game logic in edit mode.)
	for (unsigned int i = 0; i<levelObjects.size(); i++){
	//Let the gameobject handle movement.
	levelObjects[i]->move();
	}

	//Also update the scenery.
	for (auto it = sceneryLayers.begin(); it != sceneryLayers.end(); ++it){
	it->second->updateAnimation();
	}

	//In case of a selection or actions popup prevent the camera from moving.
	if(selectionPopup \|\| actionsPopup)
	return;

	//Move the camera.
	if (cameraXvel != 0 \|\| cameraYvel != 0) {
	if (pressedShift) {
	if (cameraXvel > 0) cameraXvel++;
	else if (cameraXvel < 0) cameraXvel--;
	if (cameraYvel > 0) cameraYvel++;
	else if (cameraYvel < 0) cameraYvel--;
	}
	- camera.x = clamp(camera.x + cameraXvel, -1000 - SCREEN_WIDTH, LEVEL_WIDTH + 1000);
	- camera.y = clamp(camera.y + cameraYvel, -1000 - SCREEN_HEIGHT, LEVEL_HEIGHT + 1000);
	+ camera.x = clamp(camera.x + cameraXvel, -1000 - SCREEN_WIDTH, levelRect.w + 1000);
	+ camera.y = clamp(camera.y + cameraYvel, -1000 - SCREEN_HEIGHT, levelRect.h + 1000);
	//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(pointOnRect(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(pointOnRect(mouse,toolRect)==true){
	//Set the tooltip tool.
	tooltip=t;
	}
	}
	}
	}

	/////////////////RENDER//////////////////////
	void LevelEditor::render(ImageManager& imageManager,SDL_Renderer& renderer){
	//Let the game render the game when it is the play mode.
	if (playMode) {
	Game::render(imageManager, renderer);
	} else {
	// The following code are partially copied from Game::render()

	//First of all render the background.
	{
	//Get a pointer to the background.
	ThemeBackground* bg = background;

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

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

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

	//Now draw the background layers.
	auto it = sceneryLayers.begin();
	for (; it != sceneryLayers.end(); ++it){
	if (it->first >= "f") break; // now we meet a foreground layer
	if (layerVisibility[it->first]) {
	it->second->show(renderer);
	}
	}

	//Now we draw the levelObjects.
	if (layerVisibility[std::string()]) {
	//NEW: always render the pushable blocks in front of other blocks
	std::vector<Block*> pushableBlocks;

	for (auto o : levelObjects) {
	if (o->type == TYPE_PUSHABLE) {
	pushableBlocks.push_back(o);
	} else {
	o->show(renderer);
	}
	}

	for (auto o : pushableBlocks) {
	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]) {
	it->second->show(renderer);
	}
	}
	}

	//Only render extra stuff like the toolbar, selection, etc.. when not in playMode.
	if(!playMode){
	//Get the current mouse location.
	int x, y;
	SDL_GetMouseState(&x, &y);
	//Create the rectangle.
	SDL_Rect mouse = { x + camera.x, y + camera.y, 0, 0 };

	//Render the selectionmarks.
	//TODO: Check if block is in sight.
	for(unsigned int o=0; o<selection.size(); o++){
	//Get the location to draw.
	SDL_Rect r=selection[o]->getBox();

	// Change the mouse cursor if necessary
	if (selectionDrag < 0 && tool != REMOVE) {
	int midx = r.x + r.w / 2 - 2;
	int midy = r.y + r.h / 2 - 2;
	if (mouse.x >= r.x && mouse.x < r.x + 5) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	currentCursor = CURSOR_SIZE_FDIAG;
	} else if (mouse.y >= midy && mouse.y < midy + 5) {
	currentCursor = CURSOR_SIZE_HOR;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	currentCursor = CURSOR_SIZE_BDIAG;
	}
	} else if (mouse.x >= midx && mouse.x < midx + 5) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	currentCursor = CURSOR_SIZE_VER;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	currentCursor = CURSOR_SIZE_VER;
	}
	} else if (mouse.x >= r.x + r.w - 5 && mouse.x < r.x + r.w) {
	if (mouse.y >= r.y && mouse.y < r.y + 5) {
	currentCursor = CURSOR_SIZE_BDIAG;
	} else if (mouse.y >= midy && mouse.y < midy + 5) {
	currentCursor = CURSOR_SIZE_HOR;
	} else if (mouse.y >= r.y + r.h - 5 && mouse.y < r.y + r.h) {
	currentCursor = CURSOR_SIZE_FDIAG;
	}
	}
	}

	bool mouseIn = pointOnRect(mouse, r);

	r.x-=camera.x;
	r.y-=camera.y;

	drawGUIBox(r.x,r.y,r.w,r.h,renderer,0xFFFFFF33);

	//Draw the selectionMarks.
	applyTexture(r.x,r.y,selectionMark,renderer);
	applyTexture(r.x+r.w-5,r.y,selectionMark,renderer);
	applyTexture(r.x,r.y+r.h-5,selectionMark,renderer);
	applyTexture(r.x+r.w-5,r.y+r.h-5,selectionMark,renderer);

	// draw additional selection marks
	if (mouseIn && selectionDrag < 0 && tool != REMOVE) {
	applyTexture(r.x + r.w / 2 - 2, r.y, selectionMark, renderer);
	applyTexture(r.x + r.w / 2 - 2, r.y + r.h - 5, selectionMark, renderer);
	applyTexture(r.x, r.y + r.h / 2 - 2, selectionMark, renderer);
	applyTexture(r.x + r.w - 5, r.y + r.h / 2 - 2, selectionMark, renderer);
	}
	}

	//Set the color for the borders.
	{
	SDL_Color c = objThemes.getTextColor(false);
	SDL_SetRenderDrawColor(&renderer, c.r, c.g, c.b, 115);
	}

	int leftWidth=0;
	int rightWidth=0;

	//Draw the dark areas marking the outside of the level.
	SDL_Rect r{0,0,0,0};
	if(camera.x<0){
	//Draw left side.
	r.x=0;
	r.y=0;
	r.w=0-camera.x;
	leftWidth=r.w;
	r.h=SCREEN_HEIGHT;
	SDL_RenderFillRect(&renderer, &r);
	}
	if(camera.y<0){
	//Draw the top.
	r.x=leftWidth;
	r.y=0;
	r.w=SCREEN_WIDTH;
	r.h=0-camera.y;
	SDL_RenderFillRect(&renderer, &r);
	} else {
	r.h=0;
	}
	- if(camera.x>LEVEL_WIDTH-SCREEN_WIDTH){
	+ if(camera.x>levelRect.w-SCREEN_WIDTH){
	//Draw right side.
	- r.x=LEVEL_WIDTH-camera.x;
	+ r.x=levelRect.w-camera.x;
	r.y=std::max(r.y+r.h,0);
	- r.w=SCREEN_WIDTH-(LEVEL_WIDTH-camera.x);
	+ r.w=SCREEN_WIDTH-(levelRect.w-camera.x);
	rightWidth=r.w;
	r.h=SCREEN_HEIGHT;
	SDL_RenderFillRect(&renderer, &r);
	}
	- if(camera.y>LEVEL_HEIGHT-SCREEN_HEIGHT){
	+ if(camera.y>levelRect.h-SCREEN_HEIGHT){
	//Draw the bottom.
	r.x=leftWidth;
	- r.y=LEVEL_HEIGHT-camera.y;
	+ r.y=levelRect.h-camera.y;
	r.w=SCREEN_WIDTH-rightWidth-leftWidth;
	- r.h=SCREEN_HEIGHT-(LEVEL_HEIGHT-camera.y);
	+ r.h=SCREEN_HEIGHT-(levelRect.h-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 (pointOnRect(mouse, rect) == 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 (auto o : it->second->objects){
	SDL_Rect rect = o->getBox();
	if (pointOnRect(mouse, rect) == 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);
	+ drawRect(-camera.x,-camera.y,levelRect.w,levelRect.h,renderer);

	//Render the hud layer.
	renderHUD(renderer);

	//Render selection popup (if any).
	if(selectionPopup!=NULL){
	if(linking \|\| moving){
	//If we switch to linking mode then delete it
	//FIXME: Logic in the render method.
	delete selectionPopup;
	selectionPopup=NULL;
	}else{
	selectionPopup->render(imageManager,renderer);
	}
	}

	//Render actions popup (if any).
	if(actionsPopup!=NULL){
	actionsPopup->render(renderer);
	}
	}
	}

	void LevelEditor::renderHUD(SDL_Renderer& renderer){
	//If moving show the moving speed in the top right corner.
	if(moving){
	//Calculate width of text "Movespeed: 125" to keep the same position with every value
	if (movingSpeedWidth == -1){
	int w;
	TTF_SizeUTF8(fontText, tfm::format(_("Speed: %d = %0.2f block/s"), 125, 10.0f).c_str(), &w, NULL);
	movingSpeedWidth = w + 4;
	}

	SDL_Texture *tex = NULL;

	//Check which text should we use.
	if (pauseMode) {
	//Update the text if necessary.
	if (pauseTimeTexture.needsUpdate(pauseTime)) {
	if (pauseTime < 0) {
	pauseTimeTexture.update(pauseTime,
	textureFromText(renderer, *fontText,
	_("Stop at this point"),
	objThemes.getTextColor(true)));
	} else {
	pauseTimeTexture.update(pauseTime,
	textureFromText(renderer, *fontText,
	tfm::format(_("Pause: %d = %0.3fs"), pauseTime, float(pauseTime)*0.025f).c_str(),
	objThemes.getTextColor(true)));
	}
	}
	tex = pauseTimeTexture.get();
	} else {
	//Update the text if necessary.
	if (movementSpeedTexture.needsUpdate(movingSpeed)) {
	movementSpeedTexture.update(movingSpeed,
	textureFromText(renderer, *fontText,
	tfm::format(_("Speed: %d = %0.2f block/s"), movingSpeed, float(movingSpeed)*0.08f).c_str(),
	objThemes.getTextColor(true)));
	}
	tex = movementSpeedTexture.get();
	}

	//Draw the text in the box.
	drawGUIBox(SCREEN_WIDTH-movingSpeedWidth-2,-2,movingSpeedWidth+8,
	textureHeight(*tex)+6,renderer,0xFFFFFFFF);
	applyTexture(SCREEN_WIDTH-movingSpeedWidth,2,*tex,renderer,NULL);
	}

	//On top of all render the toolbar.
	drawGUIBox(toolbarRect.x,toolbarRect.y,9*50+10,52,renderer,0xEDEDEDFF);
	//Draw the first four options.
	SDL_Rect srcRect={0,0,200,50};
	SDL_Rect dstRect={toolbarRect.x+5, toolbarRect.y, srcRect.w, srcRect.h};
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);

	//Draw the undo/redo button.
	SDL_SetTextureAlphaMod(toolbar.get(), commandManager->canUndo() ? 255 : 128);
	srcRect.x = 200;
	srcRect.w = 50;
	dstRect.x = toolbarRect.x + 205;
	dstRect.w = srcRect.w;
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);
	SDL_SetTextureAlphaMod(toolbar.get(), commandManager->canRedo() ? 255 : 128);
	srcRect.x = 250;
	srcRect.w = 50;
	dstRect.x = toolbarRect.x + 255;
	dstRect.w = srcRect.w;
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);
	SDL_SetTextureAlphaMod(toolbar.get(), 255);

	//And the last three.
	srcRect.x=300;
	srcRect.w=150;
	dstRect.x=toolbarRect.x+305;
	dstRect.w=srcRect.w;
	SDL_RenderCopy(&renderer, toolbar.get(), &srcRect, &dstRect);

	//Now render a tooltip.
	if(tooltip>=0 && static_cast<std::size_t>(tooltip)<tooltipTextures.size()) {
	SDL_Texture *tex = tooltipTextures.at(tooltip).get();

	if (tooltip == (int)ToolTips::UndoNoTooltip) {
	std::string s = commandManager->describeUndo();
	if (undoTooltipTexture.needsUpdate(s)) {
	undoTooltipTexture.update(s, textureFromText(renderer, *fontText, s.c_str(), objThemes.getTextColor(true)));
	}
	tex = undoTooltipTexture.get();
	} else if (tooltip == (int)ToolTips::RedoNoTooltip) {
	std::string s = commandManager->describeRedo();
	if (redoTooltipTexture.needsUpdate(s)) {
	redoTooltipTexture.update(s, textureFromText(renderer, *fontText, s.c_str(), objThemes.getTextColor(true)));
	}
	tex = redoTooltipTexture.get();
	}

	if(tex) {
	const SDL_Rect texSize = rectFromTexture(*tex);
	SDL_Rect r={(SCREEN_WIDTH-440)/2+(tooltip40)+(tooltip10),SCREEN_HEIGHT-45,40,40};
	r.y=SCREEN_HEIGHT-50-texSize.h;
	if(r.x+texSize.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-texSize.w;

	//Draw borders around text
	Uint32 color=0xFFFFFF00\|230;
	drawGUIBox(r.x-2,r.y-2,texSize.w+4,texSize.h+4,renderer,color);
	applyTexture(r.x, r.y, *tex, renderer);
	}
	}

	// for toolbox button animation (0-31)
	static int tick = 8;

	const int mmm = getEditorOrderMax();
	if (currentType >= mmm)currentType = mmm - 1;
	if (currentType < 0) currentType = 0;

	//Render the tool box.
	if(!playMode && !moving && tool==ADD && selectionPopup==NULL && actionsPopup==NULL && objectWindows.empty()){
	// get mouse position
	int x, y;
	SDL_GetMouseState(&x, &y);

	if (toolboxVisible){
	toolboxRect.x=0;
	toolboxRect.y=0;
	toolboxRect.w=SCREEN_WIDTH;
	toolboxRect.h=64;

	drawGUIBox(-2,-2,SCREEN_WIDTH+4,66,renderer,0xFFFFFF00\|230);

	bool isMouseOnSomething = false;

	//Draw the hide icon.
	SDL_Rect r={SCREEN_WIDTH-20,2,16,16};
	SDL_Rect r2={80,0,r.w,r.h};
	if (x >= SCREEN_WIDTH - 24 && x < SCREEN_WIDTH && y < 20) {
	isMouseOnSomething = true;
	tick = (tick + 1) & 31;
	r.y -= (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	}
	SDL_RenderCopy(&renderer, bmGUI.get(), &r2, &r);

	//Calculate the maximal number of blocks can be displayed.
	const int m=(SCREEN_WIDTH-48)/64;
	if(toolboxIndex>=mmm-m){
	toolboxIndex = mmm - m;
	}else{
	//Draw an icon.
	r.x=SCREEN_WIDTH-20;
	r.y=24;
	r2.x=96;
	r2.y=16;
	if (x >= SCREEN_WIDTH - 24 && x < SCREEN_WIDTH && y >= 20 && y < 44) {
	isMouseOnSomething = true;
	tick = (tick + 1) & 31;
	r.x += (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	}
	SDL_RenderCopy(&renderer, bmGUI.get(),&r2,&r);
	}
	if(toolboxIndex<=0){
	toolboxIndex=0;
	}else{
	//Draw an icon.
	r.x=4;
	r.y=24;
	r2.x=80;
	r2.y=16;
	if (x >= 0 && x < 24 && y >= 20 && y < 44) {
	isMouseOnSomething = true;
	tick = (tick + 1) & 31;
	r.x -= (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	}
	SDL_RenderCopy(&renderer, bmGUI.get(), &r2, &r);
	}

	// reset animation timer if there is no animation
	if (!isMouseOnSomething) {
	tick = 8;
	}

	//Draw available blocks.
	for(int i=0;i<m;i++){
	if (i + toolboxIndex >= mmm) break;

	//Draw a rectangle around the current tool.
	if(i+toolboxIndex==currentType){
	drawGUIBox(i*64+24,3,64,58,renderer,0xDDDDDDFF);
	}

	if (selectedLayer.empty()) {
	// show normal blocks
	ThemeBlock* obj = objThemes.getBlock(editorTileOrder[i + toolboxIndex]);
	if (obj){
	obj->editorPicture.draw(renderer, i * 64 + 24 + 7, 7);
	}
	} else {
	// show scenery blocks
	if (i + toolboxIndex < (int)sceneryBlockNames.size()) {
	ThemeBlock* obj = objThemes.getScenery(sceneryBlockNames[i + toolboxIndex]);
	if (obj){
	obj->editorPicture.draw(renderer, i * 64 + 24 + 7, 7);
	}
	} else {
	// it's custom scenery block
	// just draw a stupid icon
	const SDL_Rect r = { 48, 16, 16, 16 };
	const SDL_Rect dstRect = { i * 64 + 24 + 7, 7, 16, 16 };
	SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	}
	}
	}

	//Draw a tool tip.
	if(y<64 && x>=24 && x<24+m*64){
	int i=(x-24)/64;
	if (i + toolboxIndex < getEditorOrderMax()){
	TexturePtr& tip = (!selectedLayer.empty())
	? getCachedTextTexture(renderer, (i + toolboxIndex < (int)sceneryBlockNames.size())
	? describeSceneryName(sceneryBlockNames[i + toolboxIndex]).c_str() : _("Custom scenery block"))
	: typeTextTextures.at(editorTileOrder[i + toolboxIndex]);

	const SDL_Rect tipSize = rectFromTexture(*tip);

	SDL_Rect r = { 24 + i * 64, 64, 40, 40 };
	if (r.x + tipSize.w>SCREEN_WIDTH - 50)
	r.x = SCREEN_WIDTH - 50 - tipSize.w;

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

	//Draw tooltip's text
	applyTexture(r.x, r.y, tip, renderer);
	}
	}
	}else{
	const SDL_Rect tbtSize = rectFromTexture(*toolboxText);

	toolboxRect.x=SCREEN_WIDTH-tbtSize.w-28;
	toolboxRect.y=0;
	toolboxRect.w=tbtSize.w+28;
	toolboxRect.h=tbtSize.h+4;

	SDL_Rect r={SCREEN_WIDTH-tbtSize.w-24,2,16,16};
	drawGUIBox(r.x-4,-2,tbtSize.w+32,tbtSize.h+6,renderer,0xFFFFFFFF);

	//Draw "Toolbox" text.
	applyTexture(r.x, r.y, toolboxText, renderer);

	const SDL_Rect r2={96,0,16,16};
	r.x=SCREEN_WIDTH-20;
	r.w=r2.w;
	r.h=r2.h;

	// check if mouse is hovering on
	if (x >= toolboxRect.x && x < toolboxRect.x + toolboxRect.w && y >= toolboxRect.y && y < toolboxRect.y + toolboxRect.h) {
	tick = (tick + 1) & 31;
	r.y += (tick < 16) ? (tick / 4 - 2) : (6 - tick / 4);
	} else {
	tick = 8;
	}

	//Draw arrow.
	SDL_RenderCopy(&renderer, bmGUI.get(),&r2,&r);
	}
	}else{
	toolboxRect.x=-1;
	toolboxRect.y=-1;
	toolboxRect.w=0;
	toolboxRect.h=0;
	}

	//Draw a rectangle around the current tool.
	Uint32 color=0xFFFFFF00;
	drawGUIBox((SCREEN_WIDTH-440)/2+(tool40)+(tool10),SCREEN_HEIGHT-46,42,42,renderer,color);
	}

	void LevelEditor::showCurrentObject(SDL_Renderer& renderer){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);
	x+=camera.x;
	y+=camera.y;

	//Check if we should snap the block to grid or not.
	if(!pressedShift){
	snapToGrid(&x,&y);
	}else{
	x-=25;
	y-=25;
	}

	//Check if the currentType is a legal type.
	if(currentType>=0 && currentType<getEditorOrderMax()){
	if (selectedLayer.empty()) {
	// show normal blocks
	ThemeBlock* obj = objThemes.getBlock(editorTileOrder[currentType]);
	if (obj){
	obj->editorPicture.draw(renderer, x - camera.x, y - camera.y);
	}
	} else {
	// show scenery blocks
	if (currentType < (int)sceneryBlockNames.size()) {
	ThemeBlock* obj = objThemes.getScenery(sceneryBlockNames[currentType]);
	if (obj){
	obj->editorPicture.draw(renderer, x - camera.x, y - camera.y);
	}
	} else {
	// it's custom scenery block
	// just draw a stupid icon
	const SDL_Rect r = { 48, 16, 16, 16 };
	const SDL_Rect dstRect = { x - camera.x, y - camera.y, 16, 16 };
	SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	}
	}
	}
	}

	void LevelEditor::determineNewPosition(int& x, int& y) {
	if (dragCenter) {
	SDL_Rect r = dragCenter->getBox();
	x -= dragSrartPosition.x - r.x;
	y -= dragSrartPosition.y - r.y;
	} else {
	x -= 25;
	y -= 25;
	}

	// Check if we should snap the block to grid or not.
	if (!pressedShift) {
	x = int(floor(x/50.0f + 0.5f)) * 50;
	y = int(floor(y/50.0f + 0.5f)) * 50;
	}
	}

	void LevelEditor::determineNewSize(int x, int y, SDL_Rect& r) {
	switch (selectionDrag % 3) {
	case 0:
	if (x > r.x + r.w - 15) x = r.x + r.w - 15;
	if (!pressedShift) {
	x = int(floor(x/50.0f + 0.5f)) * 50;
	while (x > r.x + r.w - 15) x -= 50;
	}
	r.w += r.x - x;
	r.x = x;
	break;
	case 2:
	if (x < r.x + 15) x = r.x + 15;
	if (!pressedShift) {
	x = int(floor(x/50.0f + 0.5f)) * 50;
	while (x < r.x + 15) x += 50;
	}
	r.w = x - r.x;
	break;
	}
	switch (selectionDrag / 3) {
	case 0:
	if (y > r.y + r.h - 15) y = r.y + r.h - 15;
	if (!pressedShift) {
	y = int(floor(y/50.0f + 0.5f)) * 50;
	while (y > r.y + r.h - 15) y -= 50;
	}
	r.h += r.y - y;
	r.y = y;
	break;
	case 2:
	if (y < r.y + 15) y = r.y + 15;
	if (!pressedShift) {
	y = int(floor(y/50.0f + 0.5f)) * 50;
	while (y < r.y + 15) y += 50;
	}
	r.h = y - r.y;
	break;
	}
	}

	void LevelEditor::showSelectionDrag(SDL_Renderer& renderer){
	//Check if the drag center isn't null.
	if (dragCenter == NULL) return;

	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Create the rectangle.
	x+=camera.x;
	y+=camera.y;

	//The location of the dragCenter.
	SDL_Rect r = dragCenter->getBox();

	if (selectionDrag == 4) { // dragging
	// Check if we should snap the block to grid or not.
	determineNewPosition(x, y);

	//Loop through the selection.
	//TODO: Check if block is in sight.
	for (unsigned int o = 0; o < selection.size(); o++){
	// FIXME: ad-hoc code which moves blocks temporarily, draw, and moves them back
	const SDL_Rect r1 = selection[o]->getBox();

	selection[o]->setBaseLocation((r1.x - r.x) + x, (r1.y - r.y) + y);
	selection[o]->show(renderer);
	selection[o]->setBaseLocation(r1.x, r1.y);
	}
	} else if (selectionDrag >= 0) { // resizing
	// Check if we should snap the block to grid or not.
	determineNewSize(x, y, r);

	drawGUIBox(r.x - camera.x, r.y - camera.y, r.w, r.h, renderer, 0xFFFFFF33);
	}
	}

	void LevelEditor::showConfigure(SDL_Renderer& renderer){
	//arrow animation value. go through 0-65535 and loops.
	static unsigned short arrowAnimation=0;
	arrowAnimation++;

	// skip if the Blocks layer is invisinble
	if (!layerVisibility[std::string()]) return;

	//Use theme color for arrows.
	Uint32 color;
	{
	SDL_Color c = objThemes.getTextColor(false);
	color = (Uint32(c.r) << 24) \| (Uint32(c.g) << 16) \| (Uint32(c.b) << 8) \| 0xff;
	}

	//Draw the trigger lines.
	{
	map<Block,vector<GameObject> >::iterator it;
	for(it=triggers.begin();it!=triggers.end();++it){
	//Check if the trigger has linked targets.
	if(!(*it).second.empty()){
	//The location of the trigger.
	SDL_Rect r=(*it).first->getBox();

	//Loop through the targets.
	for(unsigned int o=0;o<(*it).second.size();o++){
	//Get the location of the target.
	SDL_Rect r1=(*it).second[o]->getBox();

	//Draw the line from the center of the trigger to the center of the target.
	drawLineWithArrow(r.x-camera.x+25,r.y-camera.y+25,r1.x-camera.x+25,r1.y-camera.y+25,renderer,color,32,arrowAnimation%32);

	//Also draw two selection marks.
	applyTexture(r.x-camera.x+25-2,r.y-camera.y+25-2,selectionMark,renderer);
	applyTexture(r1.x-camera.x+25-2,r1.y-camera.y+25-2,selectionMark,renderer);
	}
	}
	}

	//Draw a line to the mouse from the linkingTrigger when linking.
	if(linking){
	//Get the current mouse location.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Draw the line from the center of the trigger to mouse.
	drawLineWithArrow(linkingTrigger->getBox().x-camera.x+25,linkingTrigger->getBox().y-camera.y+25,x,y,renderer,color,32,arrowAnimation%32);
	}
	}

	//This saves the stacked pause marks on each position.
	std::map<std::pair<int, int>, int> stackedMarks;

	//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_Rect r1 = { 0, 0, 16, 16 }, r2 = { x - 25, y - 25 + 15 * (stackedMarks[std::pair<int, int>(x, y)]++), 16, 16 };
	if (it->second[o].time) {
	char s[64];
	sprintf(s, "%gs", float(it->second[o].time) * 0.025f);

	r1.x = 0; r1.y = 80;
	SDL_RenderCopy(&renderer, bmGUI.get(), &r1, &r2);
	r2.x += 16;

	for (int i = 0; s[i]; i++) {
	if (s[i] >= '0' && s[i] <= '9') {
	r1.x = 16 + (s[i] - '0') * 8;
	r1.w = 8;
	} else if (s[i] == '.') {
	r1.x = 96;
	r1.w = 8;
	} else if (s[i] == 's') {
	r1.x = 104;
	r1.w = 8;
	} else {
	// show some garbage
	r1.x = 0;
	r1.w = 1;
	}
	r2.w = 8;
	SDL_RenderCopy(&renderer, bmGUI.get(), &r1, &r2);
	r2.x += 8;
	}
	} else {
	r1.x = 32; r1.y = 64;
	SDL_RenderCopy(&renderer, bmGUI.get(), &r1, &r2);
	}
	}

	//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/LevelInfoRender.cpp b/src/LevelInfoRender.cpp
	index 39ac1cb..656306e 100644
	--- a/src/LevelInfoRender.cpp
	+++ b/src/LevelInfoRender.cpp
	@@ -1,69 +1,75 @@
	#include "Functions.h"

	#include "LevelInfoRender.h"

	LevelInfoRender::LevelInfoRender(ImageManager &imageManager, SDL_Renderer &renderer, const std::string& dataPath, TTF_Font &font, SDL_Color textColor)
	{
	playButton=imageManager.loadTexture(dataPath+"gfx/playbutton.png",renderer);
	timeIcon=imageManager.loadTexture(dataPath+"gfx/time.png",renderer);
	recordingsIcon=imageManager.loadTexture(dataPath+"gfx/recordings.png",renderer);
	+ objThemes.getBlock(TYPE_COLLECTABLE)->createInstance(&collectable);
	//Skip doing this here as it will be called LevelPlaySelect::refresh which is called by it's constructor anyhow.
	//resetText(renderer, font, textColor);
	}

	void LevelInfoRender::resetText(SDL_Renderer &renderer, TTF_Font &font, SDL_Color textColor) {
	auto tex = [&](const char* text){
	return textureFromText(renderer,font,text,textColor);
	};

	levelDescription=tex(_("Choose a level"));
	timeText=tex(_("Time:"));
	recordingsText=tex(_("Recordings:"));
	+ collectablesText=tex(_("Collectibles:"));
	levelTime=tex("- / -");
	levelRecs=tex("- / -");
	}

	void LevelInfoRender::update(SDL_Renderer &renderer, TTF_Font &font, SDL_Color textColor,
	const std::string &description, const std::string& time, const std::string& recordings) {
	auto tex = [&](const std::string& text){
	return textureFromText(renderer,font,text.c_str(),textColor);
	};
	if(description.empty()) {
	levelDescription=nullptr;
	} else {
	levelDescription=tex(description);
	}
	levelTime=tex(time);
	levelRecs=tex(recordings);
	}

	-void LevelInfoRender::render(SDL_Renderer &renderer) {
	+void LevelInfoRender::render(SDL_Renderer &renderer, bool arcade) {

	//Avoid crashing if this is somehow not initialized.
	if(!timeText) {
	return;
	}
	int w=0,h=0;
	SDL_GetRendererOutputSize(&renderer,&w,&h);
	if(levelDescription) {
	applyTexture(100,h-130+(50-textureHeight(*levelDescription))/2,levelDescription, renderer);
	}

	//Draw time the icon.
	applyTexture(w-405,h-130+6,timeIcon,renderer);

	//Now draw the text (title).
	applyTexture(w-380,h-130+6,timeText,renderer);

	//Now draw the second text (value).
	applyTexture(w-textureWidth(*levelTime)-80,h-130+6,levelTime,renderer);

	//Draw the icon.
	- applyTexture(w-405,h-98+6,recordingsIcon,renderer);
	+ if (arcade) {
	+ collectable.draw(renderer, w - 405 - 16, h - 98 + 6 - 16);
	+ } else {
	+ applyTexture(w - 405, h - 98 + 6, recordingsIcon, renderer);
	+ }

	//Now draw the text (title).
	- applyTexture(w-380,h-98+6,recordingsText,renderer);
	+ applyTexture(w - 380, h - 98 + 6, arcade ? collectablesText : recordingsText, renderer);

	//Now draw the second text (value).
	applyTexture(w-textureWidth(*levelRecs)-80,h-98+6,levelRecs,renderer);
	}
	diff --git a/src/LevelInfoRender.h b/src/LevelInfoRender.h
	index 78bcd29..66664cb 100644
	--- a/src/LevelInfoRender.h
	+++ b/src/LevelInfoRender.h
	@@ -1,33 +1,38 @@
	#ifndef LEVELINFORENDER_H
	#define LEVELINFORENDER_H

	#include "Render.h"
	+#include "ThemeManager.h"
	+
	class LevelPlaySelect;

	class LevelInfoRender
	{
	friend class LevelPlaySelect;
	private:
	//Icons
	SharedTexture playButton;
	SharedTexture timeIcon;
	SharedTexture recordingsIcon;
	- //Texture displaying the level description.
	+ ThemeBlockInstance collectable;
	+ //Texture displaying the level description.
	TexturePtr levelDescription;
	//Texture displaying "Time" (or other language equivalent).
	TexturePtr timeText;
	//Texture displaying "Recordings" (or other language equivalent).
	TexturePtr recordingsText;
	- //Texture displaying the actual level time.
	+ //Texture displaying "Collectibles" (or other language equivalent).
	+ TexturePtr collectablesText;
	+ //Texture displaying the actual level time.
	TexturePtr levelTime;
	TexturePtr levelRecs;
	public:
	LevelInfoRender(ImageManager& imageManager, SDL_Renderer& renderer,
	const std::string &dataPath, TTF_Font& font, SDL_Color textColor);
	void resetText(SDL_Renderer& renderer, TTF_Font& font, SDL_Color textColor);
	void update(SDL_Renderer& renderer,TTF_Font& font, SDL_Color textColor,
	const std::string& description, const std::string& time, const std::string& recordings);
	- void render(SDL_Renderer& renderer);
	+ void render(SDL_Renderer& renderer,bool arcade);
	};

	#endif // LEVELINFORENDER_H
	diff --git a/src/LevelPack.cpp b/src/LevelPack.cpp
	index 2a14c79..c5b5305 100644
	--- a/src/LevelPack.cpp
	+++ b/src/LevelPack.cpp
	@@ -1,637 +1,682 @@
	/*
	* 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/>.
	*/

	#include "LevelPack.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "MD5.h"
	#include <string.h>
	#include <string>
	#include <vector>
	#include <fstream>
	#include <algorithm>
	#include <iostream>
	using namespace std;

	+int LevelPack::Level::getMedal(bool arcade, int time, int targetTime, int recordings, int targetRecordings) {
	+ int medal = 1;
	+ if (arcade) {
	+ if (time >= 0 && time >= targetTime)
	+ medal++;
	+ if (recordings >= 0 && recordings >= targetRecordings)
	+ medal++;
	+ } else {
	+ if (time >= 0 && (targetTime < 0 \|\| time <= targetTime))
	+ medal++;
	+ if (recordings >= 0 && (targetRecordings < 0 \|\| recordings <= targetRecordings))
	+ medal++;
	+ }
	+ return medal;
	+}
	+
	+int LevelPack::Level::getBetterTime(int newTime) const {
	+ if (!won \|\| time < 0) return newTime;
	+ if (arcade) return std::max(time, newTime);
	+ else return std::min(time, newTime);
	+}
	+
	+int LevelPack::Level::getBetterRecordings(int newRecordings) const {
	+ if (!won \|\| recordings < 0) return newRecordings;
	+ if (arcade) return std::max(recordings, newRecordings);
	+ else return std::min(recordings, newRecordings);
	+}
	+
	//This is a special TreeStorageNode which only load node name/value and attributes, early exists when meeting any subnodes.
	//This is used for fast loading of levels during game startup.
	class LoadAttributesOnlyTreeStorageNode : public TreeStorageNode {
	public:
	virtual ITreeStorageBuilder* newNode() override {
	//Early exit.
	return NULL;
	}
	};

	LevelPack::LevelPack():currentLevel(0),loaded(false),levels(),customTheme(false){
	//We need to set the pointer to the dictionaryManager to NULL.
	dictionaryManager=NULL;
	//The type of levelpack is determined in the loadLevels method, but 'fallback' is CUSTOM.
	type=CUSTOM;
	}

	LevelPack::~LevelPack(){
	//We call clear, since that already takes care of the deletion, including the dictionaryManager.
	clear();
	}

	void LevelPack::clear(){
	currentLevel=0;
	loaded=false;
	levels.clear();
	levelpackDescription.clear();
	levelpackPath.clear();
	levelProgressFile.clear();
	congratulationText.clear();
	levelpackMusicList.clear();

	//Also delete the dictionaryManager if it isn't null.
	if(dictionaryManager){
	delete dictionaryManager;
	dictionaryManager=NULL;
	}
	}

	bool LevelPack::loadLevels(const std::string& levelListFile){
	//We're going to load a new levellist so first clean any existing levels.
	clear();

	//If the levelListFile is empty we have nothing to load so we return false.
	if(levelListFile.empty()){
	cerr<<"ERROR: No levellist file given."<<endl;
	return false;
	}

	//Determine the levelpack type.
	if(levelListFile.find(getDataPath())==0){
	type=MAIN;
	}else if(levelListFile.find(getUserPath(USER_DATA)+"levelpacks/")==0){
	type=ADDON;
	}else{
	type=CUSTOM;
	}

	levelpackPath=pathFromFileName(levelListFile);

	//Create input streams for the levellist file.
	ifstream level(levelListFile.c_str());

	if(!level){
	cerr<<"ERROR: Can't load level list "<<levelListFile<<endl;
	return false;
	}

	//Load the level list file.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(level,&obj,true)){
	cerr<<"ERROR: Invalid file format of level list "<<levelListFile<<endl;
	return false;
	}
	}

	//Check for folders inside the levelpack folder.
	{
	//Get all the sub directories.
	vector<string> v;
	v=enumAllDirs(pathFromFileName(levelListFile),false);

	//Check if there's a locale folder containing translations.
	if(std::find(v.begin(),v.end(),"locale")!=v.end()){
	//Folder is present so configure the levelDictionaryManager.
	dictionaryManager=new tinygettext::DictionaryManager();
	dictionaryManager->set_use_fuzzy(false);
	dictionaryManager->add_directory(pathFromFileName(levelListFile)+"locale/");
	dictionaryManager->set_charset("UTF-8");
	dictionaryManager->set_language(tinygettext::Language::from_name(language));
	}else{
	dictionaryManager=NULL;
	}

	//Check for a theme folder.
	if(std::find(v.begin(),v.end(),"theme")!=v.end()){
	customTheme=true;
	}
	}

	//Look for the name.
	{
	vector<string> &v=obj.attributes["name"];
	if(!v.empty()){
	levelpackName=v[0];
	}else{
	//Name is not defined so take the folder name.
	levelpackName=pathFromFileName(levelListFile);
	//Remove the last character '/'
	levelpackName=levelpackName.substr(0,levelpackName.size()-1);
	levelpackName=fileNameFromPath(levelpackName);
	}
	}

	//Look for the description.
	{
	vector<string> &v=obj.attributes["description"];
	if(!v.empty())
	levelpackDescription=v[0];
	}

	//Look for the congratulation text.
	{
	vector<string> &v=obj.attributes["congratulations"];
	if(!v.empty())
	congratulationText=v[0];
	}

	//Look for the music list.
	{
	vector<string> &v=obj.attributes["musiclist"];
	if(!v.empty())
	levelpackMusicList=v[0];
	}

	//Loop through the level list entries.
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	TreeStorageNode* obj1=obj.subNodes[i];
	if(obj1==NULL)
	continue;
	if(!obj1->value.empty() && obj1->name=="levelfile"){
	Level level;
	level.file=obj1->value[0];
	level.targetTime=0;
	level.targetRecordings=0;
	+ level.arcade = false;
	memset(level.md5Digest, 0, sizeof(level.md5Digest));

	//The path to the file to open.
	//NOTE: In this function we are always loading levels from a level pack, so levelpackPath is always used.
	string levelFile=levelpackPath+level.file;

	//Open the level file to retrieve the name and target time/recordings.
	LoadAttributesOnlyTreeStorageNode obj;
	POASerializer objSerializer;
	if(objSerializer.loadNodeFromFile(levelFile.c_str(),&obj,true)){
	//Get the name of the level.
	vector<string>& v=obj.attributes["name"];
	if(!v.empty())
	level.name=v[0];
	//If the name is empty then we set it to the file name.
	if(level.name.empty())
	level.name=fileNameFromPath(level.file);

	//Get the target time of the level.
	v=obj.attributes["time"];
	if(!v.empty())
	level.targetTime=atoi(v[0].c_str());
	else
	level.targetTime=-1;
	+
	//Get the target recordings of the level.
	v=obj.attributes["recordings"];
	if(!v.empty())
	level.targetRecordings=atoi(v[0].c_str());
	else
	level.targetRecordings=-1;
	+
	+ //Get the arcade property of the level.
	+ v = obj.attributes["arcade"];
	+ if (!v.empty())
	+ level.arcade = atoi(v[0].c_str()) != 0;
	+ else
	+ level.arcade = false;
	}

	//The default for locked is true, unless it's the first one.
	level.locked=!levels.empty();
	level.won=false;
	level.time=-1;
	level.recordings=-1;

	//Add the level to the levels.
	levels.push_back(level);
	}
	}

	loaded=true;
	return true;
	}

	void LevelPack::loadProgress(){
	//Make sure that a levelProgressFile is set.
	if(levelProgressFile.empty()){
	levelProgressFile=getLevelProgressPath();
	}

	//Open the file.
	ifstream levelProgress;
	levelProgress.open(processFileName(this->levelProgressFile).c_str());

	//Check if the file exists.
	if(levelProgress){
	//Now load the progress/statistics.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(levelProgress,&obj,true)){
	cerr<<"ERROR: Invalid file format of level progress file."<<endl;
	}
	}

	//Loop through the entries.
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	TreeStorageNode* obj1=obj.subNodes[i];
	if(obj1==NULL)
	continue;
	if(!obj1->value.empty() && obj1->name=="level"){
	//We've found an entry for a level, now search the correct level.
	Level* level=NULL;
	for(unsigned int o=0;o<levels.size();o++){
	if(obj1->value[0]==levels[o].file){
	level=&levels[o];
	break;
	}
	}

	//Check if we found the level.
	if(!level)
	continue;

	//Get the progress/statistics.
	for(map<string,vector<string> >::iterator i=obj1->attributes.begin();i!=obj1->attributes.end();++i){
	if(i->first=="locked"){
	- level->locked=(i->second[0]=="1");
	+ level->locked=(i->second[0]=="1");
	}
	if(i->first=="won"){
	level->won=(i->second[0]=="1");
	}
	if(i->first=="time"){
	level->time=(atoi(i->second[0].c_str()));
	}
	if(i->first=="recordings"){
	level->recordings=(atoi(i->second[0].c_str()));
	}
	}
	}
	}
	+
	+ //NOTE: If the "locked" is true, we recalculate the "locked" property in terms of "won" property,
	+ //fixed the bug that the level locked permanently after reordering in level pack editor
	+ for (unsigned int o = 0; o < levels.size(); o++) {
	+ if (levels[o].locked) {
	+ levels[o].locked = (o == 0 \|\| levels[o - 1].won) ? false : true;
	+ }
	+ }
	}
	}

	void LevelPack::saveLevels(const std::string& levelListFile){
	//Get the fileName.
	string levelListNew=levelListFile;
	//Open an output stream.
	ofstream level(levelListNew.c_str());

	//Check if we can use the file.
	if(!level){
	cerr<<"ERROR: Can't save level list "<<levelListNew<<endl;
	return;
	}

	//Storage node that will contain the data that should be written.
	TreeStorageNode obj;

	//Also store the name of the levelpack.
	if(!levelpackName.empty())
	obj.attributes["name"].push_back(levelpackName);

	//Make sure that there's a description.
	if(!levelpackDescription.empty())
	obj.attributes["description"].push_back(levelpackDescription);

	//Make sure that there's a congratulation text.
	if(!congratulationText.empty())
	obj.attributes["congratulations"].push_back(congratulationText);

	//Make sure that there's a music list.
	if (!levelpackMusicList.empty())
	obj.attributes["musiclist"].push_back(levelpackMusicList);

	//Add the levels to the file.
	for(unsigned int i=0;i<levels.size();i++){
	TreeStorageNode* obj1=new TreeStorageNode;
	obj1->name="levelfile";
	obj1->value.push_back(fileNameFromPath(levels[i].file));
	obj1->value.push_back(levels[i].name);
	obj.subNodes.push_back(obj1);
	}

	//Write the it away.
	POASerializer objSerializer;
	objSerializer.writeNode(&obj,level,false,true);
	}

	void LevelPack::updateLanguage(){
	if(dictionaryManager!=NULL)
	dictionaryManager->set_language(tinygettext::Language::from_name(language));
	}

	void LevelPack::addLevel(const string& levelFileName,int levelno){
	//Fill in the details.
	Level level;
	if(type!=COLLECTION && !levelpackPath.empty() && levelFileName.compare(0,levelpackPath.length(),levelpackPath)==0){
	level.file=fileNameFromPath(levelFileName);
	}else{
	level.file=levelFileName;
	}
	level.targetTime=0;
	level.targetRecordings=0;
	memset(level.md5Digest, 0, sizeof(level.md5Digest));

	//Get the name of the level.
	LoadAttributesOnlyTreeStorageNode obj;
	POASerializer objSerializer;
	if(objSerializer.loadNodeFromFile(levelFileName.c_str(),&obj,true)){
	//Get the name of the level.
	vector<string>& v=obj.attributes["name"];
	if(!v.empty())
	level.name=v[0];
	//If the name is empty then we set it to the file name.
	if(level.name.empty())
	level.name=fileNameFromPath(levelFileName);

	//Get the target time of the level.
	v=obj.attributes["time"];
	if(!v.empty())
	level.targetTime=atoi(v[0].c_str());
	else
	level.targetTime=-1;
	//Get the target recordings of the level.
	v=obj.attributes["recordings"];
	if(!v.empty())
	level.targetRecordings=atoi(v[0].c_str());
	else
	level.targetRecordings=-1;
	}
	//Set if it should be locked or not.
	level.won=false;
	level.time=-1;
	level.recordings=-1;
	level.locked=levels.empty()?false:true;

	//Check if the level should be at the end or somewhere in the middle.
	if(levelno<0 \|\| levelno>=int(levels.size())){
	levels.push_back(level);
	}else{
	levels.insert(levels.begin()+levelno,level);
	}

	//NOTE: We set loaded to true.
	loaded=true;
	}

	void LevelPack::moveLevel(unsigned int level1,unsigned int level2){
	if(level1>=levels.size())
	return;
	if(level2>=levels.size())
	return;
	if(level1==level2)
	return;

	levels.insert(levels.begin()+level2,levels[level1]);
	if(level2<=level1)
	levels.erase(levels.begin()+level1+1);
	else
	levels.erase(levels.begin()+level1);
	}

	void LevelPack::saveLevelProgress(){
	//Check if the levels are loaded and a progress file is given.
	if(!loaded \|\| levelProgressFile.empty())
	return;

	//Open the progress file.
	ofstream levelProgress(processFileName(levelProgressFile).c_str());
	if(!levelProgress)
	return;

	//Open an output stream.
	TreeStorageNode node;

	//Loop through the levels.
	for(unsigned int o=0;o<levels.size();o++){
	TreeStorageNode* obj=new TreeStorageNode;
	node.subNodes.push_back(obj);

	char s[64];

	//Set the name of the node.
	obj->name="level";
	obj->value.push_back(levels[o].file);

	//Set the values.
	obj->attributes["locked"].push_back(levels[o].locked?"1":"0");
	obj->attributes["won"].push_back(levels[o].won?"1":"0");
	sprintf(s,"%d",levels[o].time);
	obj->attributes["time"].push_back(s);
	sprintf(s,"%d",levels[o].recordings);
	obj->attributes["recordings"].push_back(s);
	}


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

	const string& LevelPack::getLevelName(int level){
	if(level<0)
	level=currentLevel;
	return levels[level].name;
	}

	const unsigned char* LevelPack::getLevelMD5(int level){
	if(level<0)
	level=currentLevel;

	//Check if the md5Digest is not initialized.
	bool notInitialized = true;
	for (int i = 0; i < 16; i++) {
	if (levels[level].md5Digest[i]) {
	notInitialized = false;
	break;
	}
	}

	//Calculate md5Digest if needed.
	if (notInitialized) {
	string levelFile = getLevelFile(level);

	TreeStorageNode obj;
	POASerializer objSerializer;
	if (objSerializer.loadNodeFromFile(levelFile.c_str(), &obj, true)) {
	obj.name.clear();
	obj.calcMD5(levels[level].md5Digest);
	} else {
	cerr << "ERROR: Failed to load file '" << levelFile << "' for calculating MD5" << endl;

	//Fill in a fake MD5
	for (int i = 0; i < 16; i++) {
	levels[level].md5Digest[i] = 0xCC;
	}
	}
	}

	return levels[level].md5Digest;
	}

	void LevelPack::getLevelAutoSaveRecordPath(int level,std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath){
	if(level<0)
	level=currentLevel;

	bestTimeFilePath.clear();
	bestRecordingFilePath.clear();

	//get level pack path.
	string levelpackPath = (type == COLLECTION ? std::string() : LevelPack::levelpackPath);
	string s=levels[level].file;

	//process level pack name
	for(;;){
	string::size_type lps=levelpackPath.find_last_of("/\\");
	if(lps==string::npos){
	break;
	}else if(lps==levelpackPath.size()-1){
	levelpackPath.resize(lps);
	}else{
	levelpackPath=levelpackPath.substr(lps+1);
	break;
	}
	}

	//profess file name
	{
	string::size_type lps=s.find_last_of("/\\");
	if(lps!=string::npos) s=s.substr(lps+1);
	}

	//check if it's custom level
	{
	string path="%USER%/records/autosave/";
	if(!levelpackPath.empty()){
	path+=levelpackPath;
	path+='/';
	}
	path=processFileName(path);
	if(createPath) createDirectory(path.c_str());
	s=path+s;
	}

	//calculate MD5
	s+='-';
	s += Md5::toString(getLevelMD5(level));

	//over
	bestTimeFilePath=s+"-best-time.mnmsrec";
	bestRecordingFilePath=s+"-best-recordings.mnmsrec";
	}

	string LevelPack::getLevelProgressPath(){
	if(levelProgressFile.empty()){
	levelProgressFile="%USER%/progress/";

	//Use the levelpack folder name instead of the levelpack name.
	//NOTE: Remove the trailing slash.
	string folderName=levelpackPath.substr(0,levelpackPath.size()-1);
	folderName=fileNameFromPath(folderName);

	//Depending on the levelpack type add a folder.
	switch(type){
	case MAIN:
	levelProgressFile+="main/";
	levelProgressFile+=folderName+".progress";
	break;
	case ADDON:
	levelProgressFile+="addon/";
	levelProgressFile+=folderName+".progress";
	break;
	case CUSTOM:
	levelProgressFile+="custom/";
	levelProgressFile+=folderName+".progress";
	break;
	case COLLECTION:
	//NOTE: For collections we use their name since they don't have a folder.
	//FIXME: Make sure the name contains legal characters.
	levelProgressFile+=levelpackName+".progress";
	break;
	}
	}

	return levelProgressFile;
	}

	void LevelPack::setLevelName(unsigned int level,const std::string& name){
	if(level<levels.size())
	levels[level].name=name;
	}

	const string LevelPack::getLevelFile(int level){
	if(level<0)
	level=currentLevel;

	string levelFile;
	if(type!=COLLECTION)
	levelFile=levelpackPath+levels[level].file;
	else
	levelFile=levels[level].file;

	return levelFile;
	}

	const string& LevelPack::getLevelpackPath(){
	return levelpackPath;
	}

	struct LevelPack::Level* LevelPack::getLevel(int level){
	if(level<0)
	return &levels[currentLevel];
	return &levels[level];
	}

	void LevelPack::resetLevel(int level){
	if(level<0)
	level=currentLevel;

	//Set back to default.
	levels[level].locked=(level!=0);
	levels[level].won=false;
	levels[level].time=-1;
	levels[level].recordings=-1;
	}

	void LevelPack::nextLevel(){
	currentLevel++;
	}

	bool LevelPack::getLocked(unsigned int level){
	return levels[level].locked;
	}

	void LevelPack::setCurrentLevel(unsigned int level){
	currentLevel=level;
	}

	void LevelPack::setLocked(unsigned int level,bool locked){
	levels[level].locked=locked;
	}

	void LevelPack::swapLevel(unsigned int level1,unsigned int level2){
	if(level1<levels.size()&&level2<levels.size()){
	swap(levels[level1],levels[level2]);
	}
	}

	void LevelPack::removeLevel(unsigned int level){
	if(level<levels.size()){
	levels.erase(levels.begin()+level);
	}
	}
	diff --git a/src/LevelPack.h b/src/LevelPack.h
	index e257150..3fc9742 100644
	--- a/src/LevelPack.h
	+++ b/src/LevelPack.h
	@@ -1,206 +1,233 @@
	/*
	* 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 LEVELPACK_H
	#define LEVELPACK_H

	#include <vector>
	#include <string>

	#include "libs/tinygettext/tinygettext.hpp"

	enum LevelPackType{
	//Main levelpacks are distibuted along with the game and located in the data path.
	MAIN,
	//Addon levelpacks are downloaded/added packs which reside in the user data path.
	ADDON,
	//Custom levelpacks are user made and are located in the
	CUSTOM,

	//Collection levelpacks can contain levels from different locations.
	//This type is used for the Levels and Custom Levels levelpacks.
	//NOTE: The levelpackPath is ignored for these type of levelpacks since levels can be anywhere.
	COLLECTION
	};

	class LevelPack{
	public:
	//A level entry structure.
	struct Level{
	//The name of the level.
	std::string name;
	//The filename of the level.
	std::string file;

	//Boolean if the level is locked.
	bool locked;
	//Boolean if the level is won.
	bool won;
	+ //Boolean if the level is arcade.
	+ bool arcade;

	//Integer containing the number of ticks (40 = 1s) it took to finish the level.
	//If there's no time the value will be -1.
	int time;
	//Integer containing the target time to get a medal.
	int targetTime;

	//Integer containing the number of recordings used to finish the level.
	+ //If the arcade mode is true, this means the number of collectibles instead.
	//When not won the value is -1.
	int recordings;
	//Integer containing the target recordings to get a medal.
	+ //If the arcade mode is true, this means the target number of collectibles instead.
	int targetRecordings;

	//MD5 of level node. :/
	unsigned char md5Digest[16];
	+
	+ //Get the medal of current level based on the time/targetTime/recordings/targetRecordings etc of this level.
	+ //Return value: 0=no medal, 1=bronze medal, 2=silver medal, 3=gold medal
	+ int getMedal() const {
	+ if (won) return getMedal(arcade, time, targetTime, recordings, targetRecordings);
	+ else return 0;
	+ }
	+
	+ //Get the medal of current level, providing own time/recordings and assuming "won" is true.
	+ //Return value: 1=bronze medal, 2=silver medal, 3=gold medal
	+ int getMedal(int time, int recordings) const {
	+ return getMedal(arcade, time, targetTime, recordings, targetRecordings);
	+ }
	+
	+ //A generic function to get the modal of current level, assuming "won" is true.
	+ //Return value: 1=bronze medal, 2=silver medal, 3=gold medal
	+ static int getMedal(bool arcade, int time, int targetTime, int recordings, int targetRecordings);
	+
	+ //Get the better time selected from existing best time and the new time.
	+ int getBetterTime(int newTime) const;
	+
	+ //Get the better recordings selected from existing best recordings and the new recordings.
	+ int getBetterRecordings(int newRecordings) const;
	};
	private:
	//Index of the current level.
	int currentLevel;

	//Boolean if the levels are loaded.
	bool loaded;

	//Vector containing the filenames of the levels.
	std::vector<Level> levels;

	//The file name of the level progress.
	std::string levelProgressFile;

	public:
	//The name of the levelpack.
	std::string levelpackName;
	//The location the levelpack is stored.
	std::string levelpackPath;
	//A description of the levelpack.
	std::string levelpackDescription;

	//The type of levelpack.
	LevelPackType type;

	//The text that will be displayed when the levels are finished.
	std::string congratulationText;

	//The preferred music list to be used with this levelpack.
	std::string levelpackMusicList;

	//The dictionaryManager of the levelpack, used to translate strings.
	tinygettext::DictionaryManager* dictionaryManager;

	//Boolean if the levelpack has a custom theme/partial theme bundled with it.
	//NOTE: Themes can't be preloaded since they would be destroyed by the ThemeStack.
	bool customTheme;

	//Constructor.
	LevelPack();
	//Destructor.
	~LevelPack();

	//gettext function
	inline tinygettext::DictionaryManager* getDictionaryManager() const{
	return dictionaryManager;
	}

	//Method for updating the language to the configured one.
	//NOTE: This is called when changing the translation in the Options menu.
	void updateLanguage();

	//Adds a level to the levels.
	//levelFileName: The filename of the level to add.
	//level: The index of the level to add.
	void addLevel(const std::string& levelFileName,int levelno=-1);
	//Removes a level from the levels.
	//level: The index of the level to remove.
	void removeLevel(unsigned int level);
	//Moves the level to a given index.
	//level1: The level to move.
	//level2: The destination.
	void moveLevel(unsigned int level1,unsigned int level2);
	//Swaps two level.
	//level1: The first level to swap.
	//level2: The second level to swap.
	void swapLevel(unsigned int level1,unsigned int level2);

	//Get the levelFile for a given level.
	//level: The level index to get the levelFile from.
	//Returns: String containing the levelFileName (full path to the file).
	const std::string getLevelFile(int level=-1);
	//Get the levelpackPath of the levels.
	//Returns: String containing the levelpackPath.
	const std::string& getLevelpackPath();
	//Get the levelName for a given level.
	//level: The level index to get the levelName from.
	//Returns: String containing the levelName.
	const std::string& getLevelName(int level=-1);
	//Sets the levelName for a given level.
	//level: The level index to get the levelName from.
	//name: The new name of the level.
	void setLevelName(unsigned int level,const std::string& name);
	//Get the MD5 for a given level.
	//level: The level index.
	//Returns: const unsigned char[16] containing the digest.
	const unsigned char* getLevelMD5(int level=-1);

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

	//Method for getting the path to the progress file.
	//Returns: The path + filename to the progress file.
	std::string getLevelProgressPath();

	//Set the currentLevel.
	//level: The new current level.
	void setCurrentLevel(unsigned int level);
	//Get the currentLevel.
	//Returns: The currentLevel.
	inline int getCurrentLevel(){return currentLevel;}
	//Get the levelCount.
	//Returns: The level count.
	inline int getLevelCount(){return levels.size();}

	//Method that will return the requested level.
	//level: The index of the level, default is the current level.
	//Returns: Pointer to the requested level structure.
	struct Level* getLevel(int level=-1);

	//Method that will reset any progress/statistics for a given level.
	//level: The index of the level to reset, default is currentLevel.
	void resetLevel(int level=-1);

	//Check if a certain level is locked.
	//level: The index of the level to check.
	//Returns: True if the level is locked.
	bool getLocked(unsigned int level);
	//Set a level locked or not.
	//level: The level to (un)lock.
	//locked: The new status of the level, default is unlocked (false).
	void setLocked(unsigned int level,bool locked=false);

	//Empties the levels.
	void clear();


	bool loadLevels(const std::string& levelListFile);
	void loadProgress();
	void saveLevels(const std::string& levelListFile);
	void saveLevelProgress();

	void nextLevel();

	};
	#endif
	diff --git a/src/LevelPlaySelect.cpp b/src/LevelPlaySelect.cpp
	index 81fb401..a3acb65 100644
	--- a/src/LevelPlaySelect.cpp
	+++ b/src/LevelPlaySelect.cpp
	@@ -1,500 +1,493 @@
	/*
	* 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 "LevelPlaySelect.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "LevelSelect.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "InputManager.h"
	#include "ThemeManager.h"
	#include "SoundManager.h"
	#include "StatisticsManager.h"
	#include "Game.h"
	#include <stdio.h>
	#include <string>
	#include <sstream>
	#include <iostream>

	#include "libs/tinyformat/tinyformat.h"

	/////////////////////LEVEL SELECT/////////////////////
	LevelPlaySelect::LevelPlaySelect(ImageManager& imageManager, SDL_Renderer& renderer)
	:LevelSelect(imageManager,renderer,_("Select Level")),
	levelInfoRender(imageManager,renderer,getDataPath(),*fontText,objThemes.getTextColor(false)){
	//Load the play button if needed.
	playButtonImage=imageManager.loadTexture(getDataPath()+"gfx/playbutton.png", renderer);

	//Create the gui.
	createGUI(imageManager,renderer, true);

	//Show level list
	refresh(imageManager,renderer);
	}

	LevelPlaySelect::~LevelPlaySelect(){
	play=NULL;

	//Clear the selected level.
	if(selectedNumber!=NULL){
	delete selectedNumber;
	selectedNumber=NULL;
	}
	}

	void LevelPlaySelect::createGUI(ImageManager& imageManager,SDL_Renderer &renderer, bool initial){
	//Create the play button.
	if(initial){
	play=new GUIButton(imageManager,renderer,SCREEN_WIDTH-240,SCREEN_HEIGHT-60,240,32,_("Play"));
	}else{
	play->left=SCREEN_WIDTH-240;
	play->top=SCREEN_HEIGHT-60;
	}
	play->name="cmdPlay";
	play->eventCallback=this;
	play->enabled=false;
	if(initial)
	GUIObjectRoot->addChild(play);
	}

	void LevelPlaySelect::refresh(ImageManager& imageManager, SDL_Renderer& renderer, bool /change/){
	const int m=levels->getLevelCount();
	numbers.clear();
	levelInfoRender.resetText(renderer, *fontText, objThemes.getTextColor(false));

	//Create the non selected number.
	if (selectedNumber == NULL){
	selectedNumber = new Number(imageManager, renderer);
	}
	SDL_Rect box={40,SCREEN_HEIGHT-130,50,50};
	selectedNumber->init(renderer," ",box);
	selectedNumber->setLocked(true);
	selectedNumber->setMedal(0);

	bestTimeFilePath.clear();
	bestRecordingFilePath.clear();

	//Disable the play button.
	play->enabled=false;

	for(int n=0; n<m; n++){
	numbers.emplace_back(imageManager, renderer);
	}

	for(int n=0; n<m; n++){
	SDL_Rect box={(n%LEVELS_PER_ROW)64+static_cast<int>(SCREEN_WIDTH0.2)/2,(n/LEVELS_PER_ROW)*64+184,0,0};
	numbers[n].init(renderer,n,box);
	numbers[n].setLocked(n>0 && levels->getLocked(n));
	- int medal=levels->getLevel(n)->won?1:0;
	- if(medal){
	- const int targetTime = levels->getLevel(n)->targetTime;
	- const int targetRecordings = levels->getLevel(n)->targetRecordings;
	- const int time = levels->getLevel(n)->time;
	- const int recordings = levels->getLevel(n)->recordings;
	- if (time >= 0 && (targetTime < 0 \|\| time <= targetTime))
	- medal++;
	- if (recordings >= 0 && (targetRecordings < 0 \|\| recordings <= targetRecordings))
	- medal++;
	- }
	+ int medal = levels->getLevel(n)->getMedal();
	numbers[n].setMedal(medal);
	}

	if(m>LEVELS_DISPLAYED_IN_SCREEN){
	levelScrollBar->maxValue=(m-LEVELS_DISPLAYED_IN_SCREEN+(LEVELS_PER_ROW-1))/LEVELS_PER_ROW;
	levelScrollBar->visible=true;
	}else{
	levelScrollBar->maxValue=0;
	levelScrollBar->visible=false;
	}
	if (levels->levelpackPath == LEVELS_PATH \|\| levels->levelpackPath == CUSTOM_LEVELS_PATH)
	levelpackDescription->caption = _("Individual levels which are not contained in any level packs");
	else if (!levels->levelpackDescription.empty())
	levelpackDescription->caption = _CC(levels->getDictionaryManager(), levels->levelpackDescription);
	else
	levelpackDescription->caption = "";
	}

	void LevelPlaySelect::selectNumber(ImageManager& imageManager, SDL_Renderer& renderer, unsigned int number,bool selected){
	if (selected) {
	if (number >= 0 && number < levels->getLevelCount()) {
	levels->setCurrentLevel(number);
	setNextState(STATE_GAME);
	}
	}else{
	displayLevelInfo(imageManager, renderer,number);
	}
	}

	void LevelPlaySelect::checkMouse(ImageManager &imageManager, SDL_Renderer &renderer){
	int x,y;

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	//Check if we should replay the record.
	if(selectedNumber!=NULL){
	SDL_Rect mouse={x,y,0,0};
	if(!bestTimeFilePath.empty()){
	SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-130,372,32};
	if(pointOnRect(mouse, box)){
	Game::recordFile=bestTimeFilePath;
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_GAME);
	return;
	}
	}
	if(!bestRecordingFilePath.empty()){
	SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-98,372,32};
	if(pointOnRect(mouse, box)){
	Game::recordFile=bestRecordingFilePath;
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_GAME);
	return;
	}
	}
	}

	//Call the base method from the super class.
	LevelSelect::checkMouse(imageManager, renderer);
	}

	void LevelPlaySelect::displayLevelInfo(ImageManager& imageManager, SDL_Renderer& renderer, int number){
	//Update currently selected level
	if(selectedNumber==NULL){
	selectedNumber=new Number(imageManager, renderer);
	}
	SDL_Rect box={40,SCREEN_HEIGHT-130,50,50};

	if (number >= 0 && number < levels->getLevelCount()) {
	selectedNumber->init(renderer, number, box);
	selectedNumber->setLocked(false);

	//Show level medal
	- int medal = levels->getLevel(number)->won ? 1 : 0;
	+ int medal = levels->getLevel(number)->getMedal();
	int time = levels->getLevel(number)->time;
	int targetTime = levels->getLevel(number)->targetTime;
	int recordings = levels->getLevel(number)->recordings;
	int targetRecordings = levels->getLevel(number)->targetRecordings;

	- if (medal){
	- if (time >= 0 && (targetTime < 0 \|\| time <= targetTime))
	- medal++;
	- if (recordings >= 0 && (targetRecordings < 0 \|\| recordings <= targetRecordings))
	- medal++;
	- }
	selectedNumber->setMedal(medal);
	std::string levelTime;
	std::string levelRecs;

	//Show best time and recordings
	if (medal){
	if (time >= 0)
	if (targetTime >= 0)
	levelTime = tfm::format("%-.2fs / %-.2fs", time / 40.0, targetTime / 40.0);
	else
	levelTime = tfm::format("%-.2fs / -", time / 40.0);
	else
	levelTime.clear();

	if (recordings >= 0)
	if (targetRecordings >= 0)
	levelRecs = tfm::format("%5d / %d", recordings, targetRecordings);
	else
	levelRecs = tfm::format("%5d / -", recordings);
	else
	levelRecs.clear();
	} else{
	levelTime = "- / -";
	levelRecs = "- / -";
	}

	//Show the play button.
	play->enabled = true;

	//Check if there is auto record file
	levels->getLevelAutoSaveRecordPath(number, bestTimeFilePath, bestRecordingFilePath, false);
	if (!bestTimeFilePath.empty()){
	FILE *f;
	f = fopen(bestTimeFilePath.c_str(), "rb");
	if (f == NULL){
	bestTimeFilePath.clear();
	} else{
	fclose(f);
	}
	}
	if (!bestRecordingFilePath.empty()){
	FILE *f;
	f = fopen(bestRecordingFilePath.c_str(), "rb");
	if (f == NULL){
	bestRecordingFilePath.clear();
	} else{
	fclose(f);
	}
	}

	//Show level description
	levelInfoRender.update(renderer, *fontText, objThemes.getTextColor(false),
	_CC(levels->getDictionaryManager(), levels->getLevelName(number)), levelTime, levelRecs);
	} else {
	levelInfoRender.resetText(renderer, *fontText, objThemes.getTextColor(false));

	selectedNumber->init(renderer, " ", box);
	selectedNumber->setLocked(true);
	selectedNumber->setMedal(0);

	bestTimeFilePath.clear();
	bestRecordingFilePath.clear();

	//Disable the play button.
	play->enabled = false;
	}
	}

	void LevelPlaySelect::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Call handleEvents() of base class.
	LevelSelect::handleEvents(imageManager, renderer);

	//Check if the cheat code is input which is used to skip locked level.
	//NOTE: The cheat code is NOT in plain text, since we don't want you to find it out immediately.
	//NOTE: If you type it wrong, please press a key which is NOT a-z before retype it (as the code suggests).
	if (event.type == SDL_KEYDOWN) {
	static Uint32 hash = 0;
	if (event.key.keysym.sym >= SDLK_a && event.key.keysym.sym <= SDLK_z) {
	Uint32 c = event.key.keysym.sym - SDLK_a + 1;
	hash = hash * 1296096U + c;
	if (hash == 498506457U) {
	if (selectedNumber) {
	int n = selectedNumber->getNumber();
	if (n >= 0 && n < (int)numbers.size() - 1 && numbers[n + 1].getLocked()) {
	//unlock the level temporarily
	numbers[n + 1].setLocked(false);

	//play a sound effect
	getSoundManager()->playSound("hit");

	//new achievement
	statsMgr.newAchievement("cheat");
	}
	}
	hash = 0;
	}
	} else {
	hash = 0;
	}
	}

	if (section == 3) {
	//Check focus movement
	if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN) \|\| inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)){
	isKeyboardOnly = true;
	section2++;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_UP) \|\| inputMgr.isKeyDownEvent(INPUTMGR_LEFT)){
	isKeyboardOnly = true;
	section2--;
	}
	if (section2 > 3) section2 = 1;
	else if (section2 < 1) section2 = 3;

	//Check if enter is pressed
	if (isKeyboardOnly && inputMgr.isKeyDownEvent(INPUTMGR_SELECT) && selectedNumber) {
	int n = selectedNumber->getNumber();
	if (n >= 0) {
	switch (section2) {
	case 1:
	if (!bestTimeFilePath.empty()) {
	Game::recordFile = bestTimeFilePath;
	levels->setCurrentLevel(n);
	setNextState(STATE_GAME);
	}
	break;
	case 2:
	if (!bestRecordingFilePath.empty()) {
	Game::recordFile = bestRecordingFilePath;
	levels->setCurrentLevel(n);
	setNextState(STATE_GAME);
	}
	break;
	case 3:
	selectNumber(imageManager, renderer, n, true);
	break;
	}
	}
	}
	}
	}

	void LevelPlaySelect::render(ImageManager& imageManager, SDL_Renderer &renderer){
	//First let the levelselect render.
	LevelSelect::render(imageManager,renderer);

	int x,y,dy=0;

	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);

	if(levelScrollBar)
	dy=levelScrollBar->value;
	//Upper bound of levels we'd like to display.
	y+=dy*64;

	SDL_Rect mouse={x,y,0,0};

	//Show currently selected level (if any)
	if(selectedNumber!=NULL){
	selectedNumber->show(renderer, 0);
	+
	+ const int num = selectedNumber->getNumber();
	+ bool arcade = false;

	//Only show the replay button if the level is completed (won).
	- if(selectedNumber->getNumber()>=0 && selectedNumber->getNumber()<levels->getLevelCount()) {
	- if(levels->getLevel(selectedNumber->getNumber())->won){
	+ if(num>=0 && num<levels->getLevelCount()) {
	+ auto lev = levels->getLevel(num);
	+ arcade = lev->arcade;
	+ if(lev->won){
	if(!bestTimeFilePath.empty()){

	SDL_Rect r={0,0,32,32};
	const SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-130,372,32};

	if (isKeyboardOnly ? (section == 3 && section2 == 1) : pointOnRect(mouse, box)){
	r.x = 32;
	drawGUIBox(box.x, box.y, box.w, box.h, renderer, 0xFFFFFF40);
	}
	const SDL_Rect dstRect = {SCREEN_WIDTH-80,SCREEN_HEIGHT-130,r.w,r.h};
	SDL_RenderCopy(&renderer,playButtonImage.get(),&r, &dstRect);
	}

	if(!bestRecordingFilePath.empty()){
	SDL_Rect r={0,0,32,32};
	const SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-98,372,32};

	if (isKeyboardOnly ? (section == 3 && section2 == 2) : pointOnRect(mouse, box)){
	r.x = 32;
	drawGUIBox(box.x, box.y, box.w, box.h, renderer, 0xFFFFFF40);
	}

	const SDL_Rect dstRect = {SCREEN_WIDTH-80,SCREEN_HEIGHT-98,r.w,r.h};
	SDL_RenderCopy(&renderer,playButtonImage.get(),&r, &dstRect);
	}
	}
	}

	- levelInfoRender.render(renderer);
	+ levelInfoRender.render(renderer, arcade);
	}

	//Draw highlight for play button.
	if (isKeyboardOnly && play && play->enabled) {
	play->state = (section == 3 && section2 == 3) ? 1 : 0;
	}
	}

	void LevelPlaySelect::renderTooltip(SDL_Renderer &renderer, unsigned int number, int dy){
	if (!toolTip.name \|\| toolTip.number != number) {
	//Render the name of the level.
	toolTip.name = textureFromText(renderer, *fontText, _CC(levels->getDictionaryManager(), levels->getLevelName(number)), objThemes.getTextColor(true));
	toolTip.time=nullptr;
	toolTip.recordings=nullptr;
	toolTip.number=number;

	//The time it took.
	if(levels->getLevel(number)->time>0){
	toolTip.time = textureFromText(renderer, *fontText,
	tfm::format("%-.2fs", levels->getLevel(number)->time / 40.0).c_str(),
	objThemes.getTextColor(true));
	}

	//The number of recordings it took.
	if(levels->getLevel(number)->recordings>=0){
	toolTip.recordings = textureFromText(renderer, *fontText,
	tfm::format("%d", levels->getLevel(number)->recordings).c_str(),
	objThemes.getTextColor(true));
	}
	}

	const SDL_Rect nameSize = rectFromTexture(*toolTip.name);
	//Now draw a square the size of the three texts combined.
	SDL_Rect r=numbers[number].box;
	r.y-=dy*64;
	if(toolTip.time && toolTip.recordings){
	const int recW = textureWidth(*toolTip.recordings);
	const int timeW = textureWidth(*toolTip.time);
	r.w=(nameSize.w)>(25+timeW+40+recW)?(nameSize.w):(25+timeW+40+recW);
	r.h=nameSize.h+5+20;
	}else{
	r.w=nameSize.w;
	r.h=nameSize.h;
	}

	//Make sure the tooltip doesn't go outside the window.
	if(r.y>SCREEN_HEIGHT-200){
	r.y-=nameSize.h+4;
	}else{
	r.y+=numbers[number].box.h+2;
	}
	if(r.x+r.w>SCREEN_WIDTH-50)
	r.x=SCREEN_WIDTH-50-r.w;

	//Draw a rectange
	Uint32 color=0xFFFFFFFF;
	drawGUIBox(r.x-5,r.y-5,r.w+10,r.h+10,renderer,color);

	//Calc the position to draw.
	SDL_Rect r2=r;

	//Now we render the name if the surface isn't null.
	if(toolTip.name){
	//Draw the name.
	applyTexture(r2.x, r2.y, toolTip.name, renderer);
	}
	//Increase the height to leave a gap between name and stats.
	r2.y+=30;
	if(toolTip.time){
	//Now draw the time.
	applyTexture(r2.x,r2.y,levelInfoRender.timeIcon,renderer);
	r2.x+=25;
	applyTexture(r2.x, r2.y, toolTip.time, renderer);
	r2.x+=textureWidth(*toolTip.time)+15;
	}
	if(toolTip.recordings){
	//Now draw the recordings.
	- applyTexture(r2.x,r2.y,levelInfoRender.recordingsIcon,renderer);
	+ if (levels->getLevel(number)->arcade) {
	+ levelInfoRender.collectable.draw(renderer, r2.x - 16, r2.y - 16);
	+ } else {
	+ applyTexture(r2.x, r2.y, levelInfoRender.recordingsIcon, renderer);
	+ }
	r2.x+=25;
	applyTexture(r2.x, r2.y, toolTip.recordings, renderer);
	}
	}

	void LevelPlaySelect::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Let the LevelSelect do his stuff.
	LevelSelect::resize(imageManager, renderer);

	//Now create our gui again.
	createGUI(imageManager,renderer, false);
	}

	void LevelPlaySelect::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Let the level select handle his GUI events.
	LevelSelect::GUIEventCallback_OnEvent(imageManager,renderer,name,obj,eventType);

	//Check for the play button.
	if(name=="cmdPlay"){
	if(selectedNumber!=NULL){
	levels->setCurrentLevel(selectedNumber->getNumber());
	setNextState(STATE_GAME);
	}
	}
	}
	diff --git a/src/LevelSelect.h b/src/LevelSelect.h
	index 1d81b29..66ff069 100644
	--- a/src/LevelSelect.h
	+++ b/src/LevelSelect.h
	@@ -1,177 +1,178 @@
	/*
	* 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 LEVELSELECT_H
	#define LEVELSELECT_H

	#include "GameState.h"
	#include "GameObjects.h"
	#include "GUIObject.h"
	#include "LevelPackManager.h"
	+#include "ThemeManager.h"
	#include <vector>
	#include <string>

	class GUIScrollBar;
	class GUISingleLineListBox;

	//Class that represents a level in the levelselect menu.
	class Number{
	private:
	//The background image of the number.
	ThemeBlockInstance block;
	//The background image of the number when it's locked.
	ThemeBlockInstance blockLocked;
	//The (text) image of the number.
	SharedTexture image;

	//Image containing the three stars a player can earn.
	SharedTexture medals;

	//The number (or text).
	int number;
	//Integer containing the medal the player got.
	//0 = none, 1 = bronze, 2 = silver, 3 = gold
	int medal;

	//Boolean if the number is locked or not.
	bool locked;
	public:
	//The location and size of the number.
	SDL_Rect box;

	//If the Number is selected then we draw something indicates it.
	bool selected;

	//Constructor.
	Number(ImageManager &imageManager, SDL_Renderer &renderer);

	//Method used for initialising the number.
	//number: The number.
	//box: The location and size of the number.
	void init(SDL_Renderer &renderer, int number, SDL_Rect box);

	//Method used for initialising the number.
	//text: The caption of the number.
	//box: The location and size of the number.
	//number: The number. Default is -1 (i.e. the caption doesn't represents a number).
	void init(SDL_Renderer& renderer, const std::string& text, SDL_Rect box, int number = -1);

	//get current number.
	inline int getNumber(){return number;}

	//Method used to set the locked status of the number.
	//locked: Boolean if it should be locked or not.
	void setLocked(bool locked=true);
	//Method used to retrieve the locked status of the number.
	//Returns: True if the number is locked.
	inline bool getLocked(){return locked;}

	//Method used to set the medal for this number.
	//medal: The new medal for this number.
	void setMedal(int medal);

	//Method that is used to draw the number.
	//dy: The y offset.
	void show(SDL_Renderer &renderer, int dy);
	};

	struct ToolTip {
	TexturePtr name;
	TexturePtr time;
	TexturePtr recordings;
	size_t number;
	};

	//This is the LevelSelect state, here you can select levelpacks and levels.
	class LevelSelect : public GameState,public GUIEventCallback{
	protected:
	//Surface containing the title.
	TexturePtr title;

	ToolTip toolTip;

	//Vector containing the numbers.
	std::vector<Number> numbers;

	//Contains selected level number (displayed at bottom left corner).
	//If it's NULL then nothing selected.
	Number* selectedNumber;

	//Pointer to the scrollbar.
	GUIScrollBar* levelScrollBar;
	//Pointer to the description.
	GUIObject* levelpackDescription;

	//Pointer to the levelpack list.
	GUISingleLineListBox* levelpacks;

	//Check where and if the mouse clicked on a number.
	//If so select that number.
	virtual void checkMouse(ImageManager& imageManager, SDL_Renderer& renderer);

	//Selected section for keyboard/gamepad control
	//1=level pack selection 2=level selection 3=LevelPlaySelect/LevelEditSelect specific
	int section;

	//LevelPlaySelect/LevelEditSelect specific selected section. Only used when section==3.
	int section2;

	//The number of blocks in a row.
	int LEVELS_PER_ROW;
	//The number of levels displayed on screen at once.
	int LEVELS_DISPLAYED_IN_SCREEN;
	public:
	//Constructor.
	//titleText: The title that is shown at the top of the screen.
	//packType: The type of levelpacks that should be listed (See LevelPackManager.h).
	LevelSelect(ImageManager& imageManager, SDL_Renderer &renderer, const char* titleText, LevelPackManager::LevelPackLists packType=LevelPackManager::ALL_PACKS);
	//Destructor.
	virtual ~LevelSelect();

	//Method that will calculate the number of rows and the number of levels per row.
	void calcRows();

	//Method used to update the numbers and the scrollbar.
	//change: Boolean if the levelpack changed, if not only the numbers need to be replaced.
	virtual void refresh(ImageManager& imageManager, SDL_Renderer& renderer, bool change=true)=0;

	//Method that is called when a number is selected.
	//number: The selected number.
	//selected: Boolean if the number was already selected.
	virtual void selectNumber(ImageManager &imageManager, SDL_Renderer &renderer, unsigned int number,bool selected)=0;

	//Used for keyboard/gamepad navigation
	void selectNumberKeyboard(ImageManager &imageManager, SDL_Renderer &renderer, int x, int y);

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

	//Method that is called to render the tooltip.
	//number: The number that the tooltip should be drawn for.
	//dy: The y offset of the number, used to draw the tooltip in the right place.
	virtual void renderTooltip(SDL_Renderer& renderer,unsigned int number,int dy)=0;

	//GUI events will be handled here.
	virtual void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType)=0;
	};

	#endif
	diff --git a/src/Main.cpp b/src/Main.cpp
	index 6c8db3a..c36269b 100644
	--- a/src/Main.cpp
	+++ b/src/Main.cpp
	@@ -1,249 +1,262 @@
	/*
	* 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 "Functions.h"
	#include "Globals.h"
	#include "TitleMenu.h"
	#include "GUIObject.h"
	#include "InputManager.h"
	#include "StatisticsManager.h"
	#include "Timer.h"
	#include <SDL.h>
	#include <stdlib.h>
	#include <time.h>
	#include <stdio.h>
	#include <string.h>

	// the following piece of code fixes the combination of VC2015 with official SDL1.2 binary
	#if defined(_MSC_VER) && (_MSC_VER >= 1900)

	#pragma comment(lib, "legacy_stdio_definitions.lib")

	FILE _iob[] = {stdin, stdout, *stderr};

	extern "C" FILE * __cdecl __iob_func(void)
	{
	return _iob;
	}

	#endif

	+static ImageManager *_imageManager = NULL;
	+static SDL_Renderer *_renderer = NULL;
	+
	+ImageManager& getImageManager() {
	+ return *_imageManager;
	+}
	+
	+SDL_Renderer& getRenderer() {
	+ return *_renderer;
	+}
	+
	int main(int argc, char** argv) {
	#ifdef _MSC_VER
	//Fix the non-latin file name bug under Visual Studio
	setlocale(LC_ALL,"");
	setlocale(LC_NUMERIC, "C");
	#endif

	//Relocate the standard output for debug purpose (?)
	#if defined(ANDROID)
	freopen("stdout.txt","w",stdout);
	freopen("stderr.txt","w",stderr);
	#endif
	//First parse the comand line arguments.
	int s=parseArguments(argc,argv);
	if(s==-1){
	printf("Usage: %s [OPTIONS] ...\n",argv[0]);
	printf("%s","Available options:\n");
	printf(" %-5s%-30s %s\n","","--data-dir <dir>","Specifies the data directory.");
	printf(" %-5s%-30s %s\n","","--user-dir <dir>","Specifies the user preferences directory.");
	printf(" %-5s%-30s %s\n","-f,","--fullscreen","Run the game fullscreen.");
	printf(" %-5s%-30s %s\n","-w,","--windowed","Run the game windowed.");
	printf(" %-5s%-30s %s\n","-mv,","--music <volume>","Set the music volume.");
	printf(" %-5s%-30s %s\n","-sv,","--sound <volume>","Set the sound volume.");
	printf(" %-5s%-30s %s\n","-s,","--set <setting> <value>","Change a setting to a given value.");
	printf(" %-5s%-30s %s\n","-v,","--version","Display the version and quit.");
	printf(" %-5s%-30s %s\n","-h,","--help","Display this help message.");
	return 0;
	}else if(s==0){
	return 0;
	}

	//Try to configure the dataPath, userPath, etc...
	if(configurePaths()==false){
	fprintf(stderr,"FATAL ERROR: Failed to configure paths.\n");
	return 1;
	}
	//Load the settings.
	if(loadSettings()==false){
	fprintf(stderr,"ERROR: Unable to load config file, default values will be used.\n");
	}
	ScreenData screenData = init();
	//Initialise some stuff like SDL, the window, SDL_Mixer.
	if(!screenData) {
	fprintf(stderr,"FATAL ERROR: Failed to initialize game.\n");
	return 1;
	}

	SDL_Renderer& renderer = *screenData.renderer;
	+ _renderer = screenData.renderer;
	//Initialise the imagemanager.
	//The ImageManager is used to prevent loading images multiple times.
	ImageManager imageManager;
	+ _imageManager = &imageManager;

	//Load some important files like the background music, default theme.
	if(loadFiles(imageManager,renderer)==false){
	fprintf(stderr,"FATAL ERROR: Failed to load necessary files.\n");
	return 1;
	}

	//Seed random.
	srand((unsigned)time(NULL));

	//Set the currentState id to the main menu and create it.
	stateID=STATE_MENU;
	currentState=new Menu(imageManager,renderer);

	//Set the fadeIn value to zero.
	int fadeIn=255;

	//Keep the last resize event, this is to only process one.
	SDL_Event lastResize={};
	Timer timer;

	//Start the game loop.
	while(stateID!=STATE_EXIT){
	//We start the timer.
	timer.start();

	//Loop the SDL events.
	while(SDL_PollEvent(&event)){
	//Check if user resizes the window.
	if(event.type==SDL_WINDOWEVENT){
	if(event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
	{
	lastResize=event;

	//Don't let other objects process this event (?)
	continue;
	}
	}

	//Check if it's mouse event. If it's true then we quit the keyboard-only mode.
	if (event.type == SDL_MOUSEMOTION \|\| event.type == SDL_MOUSEBUTTONDOWN \|\| event.type == SDL_MOUSEBUTTONUP) {
	isKeyboardOnly = false;
	}

	//Check if the fullscreen toggle shortcut is pressed (Alt+Enter).
	if(event.type==SDL_KEYDOWN && event.key.keysym.sym==SDLK_RETURN && (event.key.keysym.mod & KMOD_ALT)){
	getSettings()->setValue("fullscreen",getSettings()->getBoolValue("fullscreen")?"0":"1");

	//We need to create a new screen.
	if(!createScreen()){
	//Screen creation failed so set to safe settings.
	getSettings()->setValue("fullscreen","0");
	getSettings()->setValue("width","800");
	getSettings()->setValue("height","600");

	//Try it with the safe settings.
	if(!createScreen()){
	//Everything fails so quit.
	setNextState(STATE_EXIT);
	std::cerr<<"ERROR: Unable to create screen."<<std::endl;
	}
	}

	//The screen is created, now load the (menu) theme.
	if(!loadTheme(imageManager,renderer,"")){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	std::cerr<<"ERROR: Unable to load theme after toggling fullscreen."<<std::endl;
	}

	//Don't let other objects process this event.
	continue;
	}

	//Set the cursor type to the default one, the GUI can change that if needed.
	currentCursor=CURSOR_POINTER;

	//Let the input manager handle the events.
	inputMgr.updateState(true);
	//Let the currentState handle the events.
	currentState->handleEvents(imageManager,renderer);
	//Also pass the events to the GUI.
	GUIObjectHandleEvents(imageManager,renderer);
	}

	//Process the resize event.
	if(lastResize.type==SDL_WINDOWEVENT){
	//TODO - used to be SDL_VIDEORESIZE
	// so this may trigger on more events than intended
	event=lastResize;
	onVideoResize(imageManager,renderer);

	//After resize we erase the event type
	//TODO - used to be SDL_NOEVENT
	lastResize.type=SDL_FIRSTEVENT;
	}

	//maybe we should add a check here (??) to fix some bugs (ticket #47)
	if(nextState!=STATE_NULL){
	changeState(imageManager, renderer, fadeIn);

	//Check if fading is enabled.
	if(getSettings()->getBoolValue("fading"))
	fadeIn=17;
	else
	fadeIn=255;
	}
	if(stateID==STATE_EXIT) break;

	//update input state (??)
	inputMgr.updateState(false);
	//Now it's time for the state to do his logic.
	currentState->logic(imageManager,renderer);

	currentState->render(imageManager,renderer);
	//TODO: Shouldn't the gamestate take care of rendering the GUI?
	if(GUIObjectRoot) GUIObjectRoot->render(renderer);

	//draw fading effect
	if(fadeIn>0&&fadeIn<255){
	dimScreen(renderer, static_cast<Uint8>(255-fadeIn));
	fadeIn+=17;
	}

	//draw new achievements (if any) as overlay
	statsMgr.render(imageManager, renderer);

	//Before flipping the screen set the cursor.
	SDL_SetCursor(cursors[currentCursor]);

	//And draw the screen surface to the actual screen.
	flipScreen(renderer);

	//Now calcualte how long we need to wait to keep a constant framerate.
	int t=timer.getTicks();
	t=(1000/FPS)-t;
	if(t>0){
	SDL_Delay(t);
	}
	}

	//The game has ended, save the settings just to be sure.
	if(!saveSettings()){
	fprintf(stderr,"ERROR: Unable to save settings in config file.\n");
	}

	//Clean everything up.
	clean();

	//End of program.
	return 0;
	}
	diff --git a/src/OptionsMenu.cpp b/src/OptionsMenu.cpp
	index bf834c8..ad92d86 100644
	--- a/src/OptionsMenu.cpp
	+++ b/src/OptionsMenu.cpp
	@@ -1,610 +1,615 @@
	/*
	* 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 "Functions.h"
	#include "GameState.h"
	#include "OptionsMenu.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUISlider.h"
	#include "InputManager.h"
	#include "LevelPackManager.h"
	#include "StatisticsManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include <iostream>
	#include <sstream>

	#include "libs/tinyformat/tinyformat.h"
	#include "libs/tinygettext/tinygettext.hpp"
	#include "libs/findlocale/findlocale.h"

	using namespace std;

	/////////////////////////OPTIONS_MENU//////////////////////////////////

	//Some variables for the options.
	static bool fullscreen,internet,fade,quickrec;
	static string themeName,languageName;
	static int lastLang,lastRes;

	static bool useProxy;
	static string internetProxy;

	static bool restartFlag;

	static SDL_Point currentRes;
	static vector<SDL_Point> resolutionList;

	Options::Options(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	title = titleTextureFromText(renderer, _("Settings"), objThemes.getTextColor(false), SCREEN_WIDTH);

	//Initialize variables.
	lastJumpSound=0;
	clearIconHower=false;
	section = 2;
	section2 = 1;

	//Load icon image and tooltip text.
	clearIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/clear-progress.png",renderer);
	/// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	clearTooltip=textureFromText(renderer, *fontText, _("Clear Progress"), objThemes.getTextColor(true));

	//Set some default settings.
	fullscreen=getSettings()->getBoolValue("fullscreen");
	languageName=getSettings()->getValue("lang");
	themeName=processFileName(getSettings()->getValue("theme"));
	internet=getSettings()->getBoolValue("internet");
	internetProxy=getSettings()->getValue("internet-proxy");
	useProxy=!internetProxy.empty();
	fade=getSettings()->getBoolValue("fading");
	quickrec=getSettings()->getBoolValue("quickrecord");

	//Set the restartFlag false.
	restartFlag=false;

	//Now create the gui.
	createGUI(imageManager,renderer);
	}

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

	void Options::createGUI(ImageManager& imageManager,SDL_Renderer& renderer){
	//Variables for positioning
	const int columnW=SCREEN_WIDTH*0.3;
	const int column1X=SCREEN_WIDTH*0.15;
	const int column2X=SCREEN_WIDTH*0.55;
	const int lineHeight=40;

	//Create the root element of the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Single line list for different tabs.
	GUISingleLineListBox* listBox=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	listBox->addItem(_("General"));
	listBox->addItem(_("Controls"));
	listBox->value=0;
	listBox->name="lstTabs";
	listBox->eventCallback=this;
	GUIObjectRoot->addChild(listBox);

	//Create general tab.
	tabGeneral=new GUIObject(imageManager,renderer,0,150,SCREEN_WIDTH,SCREEN_HEIGHT);
	GUIObjectRoot->addChild(tabGeneral);

	//Now we create GUIObjects for every option.
	GUIObject* obj=new GUILabel(imageManager,renderer,column1X,0,columnW,36,_("Music"));
	tabGeneral->addChild(obj);

	musicSlider=new GUISlider(imageManager,renderer,column2X,0,columnW,36,atoi(getSettings()->getValue("music").c_str()),0,128,15);
	musicSlider->name="sldMusic";
	musicSlider->eventCallback=this;
	tabGeneral->addChild(musicSlider);

	obj=new GUILabel(imageManager,renderer,column1X,lineHeight,columnW,36,_("Sound"));
	tabGeneral->addChild(obj);

	soundSlider=new GUISlider(imageManager,renderer,column2X,lineHeight,columnW,36,atoi(getSettings()->getValue("sound").c_str()),0,128,15);
	soundSlider->name="sldSound";
	soundSlider->eventCallback=this;
	tabGeneral->addChild(soundSlider);

	obj=new GUILabel(imageManager,renderer,column1X,2*lineHeight,columnW,36,_("Resolution"));
	obj->name="lstResolution";
	tabGeneral->addChild(obj);

	//Create list with many different resolutions.
	resolutions = new GUISingleLineListBox(imageManager,renderer,column2X,2*lineHeight,columnW,36);
	resolutions->value=-1;

	//Only get the resolution list if it hasn't been done before.
	if(resolutionList.empty()){
	resolutionList=getResolutionList();
	}

	//Get current resolution from config file. Thus it can be user defined.
	currentRes.x=atoi(getSettings()->getValue("width").c_str());
	currentRes.y=atoi(getSettings()->getValue("height").c_str());

	for(int i=0; i<(int)resolutionList.size();i++){
	//Create a string from width and height and then add it to list.
	ostringstream out;
	out << resolutionList[i].x << "x" << resolutionList[i].y;
	resolutions->addItem(out.str());

	//Check if current resolution matches, select it.
	if(resolutionList[i].x==currentRes.x && resolutionList[i].y==currentRes.y){
	resolutions->value=i;
	}
	}

	//Add current resolution if it isn't already in the list.
	if(resolutions->value==-1){
	ostringstream out;
	out << currentRes.x << "x" << currentRes.y;
	resolutions->addItem(out.str());
	resolutions->value=resolutions->item.size()-1;
	}
	lastRes=resolutions->value;

	tabGeneral->addChild(resolutions);

	obj=new GUILabel(imageManager,renderer,column1X,3*lineHeight,columnW,36,_("Language"));
	tabGeneral->addChild(obj);

	//Create GUI list with available languages.
	langs = new GUISingleLineListBox(imageManager,renderer,column2X,3*lineHeight,columnW,36);
	langs->name="lstLanguages";

	/// TRANSLATORS: as detect user's language automatically
	langs->addItem("",_("Auto-Detect"));
	langs->addItem("en","English");

	//Get a list of every available language.
	set<tinygettext::Language> languages = dictionaryManager->get_languages();
	for (set<tinygettext::Language>::iterator s0 = languages.begin(); s0 != languages.end(); ++s0){
	//If language in loop is the same in config file, then select it
	if(getSettings()->getValue("lang")==s0->str()){
	lastLang=distance(languages.begin(),s0)+2;
	}
	//Add language in loop to list and listbox.
	- langs->addItem(s0->str(),s0->get_name());
	+ langs->addItem(s0->str(),s0->get_localized_name());
	}

	//If Auto or English are selected.
	if(getSettings()->getValue("lang")==""){
	lastLang=0;
	}else if(getSettings()->getValue("lang")=="en"){
	lastLang=1;
	}

	langs->value=lastLang;
	tabGeneral->addChild(langs);

	obj=new GUILabel(imageManager,renderer,column1X,4*lineHeight,columnW,36,_("Theme"));
	obj->name="theme";
	tabGeneral->addChild(obj);

	//Create the theme option gui element.
	theme=new GUISingleLineListBox(imageManager,renderer,column2X,4*lineHeight,columnW,36);
	theme->name="lstTheme";

	//Vector containing the theme locations and names.
	vector<pair<string,string> > themes;
	vector<string> v=enumAllDirs(getUserPath(USER_DATA)+"themes/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	string location=getUserPath(USER_DATA)+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}
	vector<string> v2=enumAllDirs(getDataPath()+"themes/");
	for(vector<string>::iterator i=v2.begin(); i!=v2.end(); ++i){
	string location=getDataPath()+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}

	//Try to find the configured theme so we can display it.
	int value=-1;
	for(vector<pair<string,string> >::iterator i=themes.begin(); i!=themes.end(); ++i){
	if(i->first==themeName) {
	value=i-themes.begin();
	}
	}
	theme->addItems(themes);
	if(value==-1)
	value=theme->item.size()-1;
	theme->value=value;
	//NOTE: We call the event handling method to correctly set the themename.
	GUIEventCallback_OnEvent(imageManager,renderer,"lstTheme",theme,GUIEventChange);
	theme->eventCallback=this;
	tabGeneral->addChild(theme);

	//Proxy settings.
	obj=new GUILabel(imageManager,renderer,column1X,5*lineHeight,columnW,36,_("Internet proxy"));
	obj->name="chkProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,column2X,5*lineHeight,columnW,36,internetProxy.c_str());
	obj->name="txtProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column1X,6*lineHeight,columnW,36,_("Fullscreen"),fullscreen?1:0);
	obj->name="chkFullscreen";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj = new GUICheckBox(imageManager, renderer, column1X, 7 * lineHeight, columnW, 36, _("Quick record"), quickrec ? 1 : 0);
	obj->name = "chkQuickRec";
	obj->eventCallback = this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,6*lineHeight,columnW,36,_("Internet"),internet?1:0);
	obj->name="chkInternet";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,7*lineHeight,columnW,36,_("Fade transition"),fade?1:0);
	obj->name="chkFade";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	//Create the controls tab.
	tabControls=inputMgr.showConfig(imageManager,renderer,SCREEN_HEIGHT-210);
	tabControls->top=140;
	tabControls->visible=false;
	GUIObjectRoot->addChild(tabControls);

	//Save original keys.
	for(int i=0;i<INPUTMGR_MAX;i++){
	tmpKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,false);
	tmpAlternativeKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,true);
	}

	//Create buttons.
	cmdBack = new GUIButton(imageManager, renderer, SCREEN_WIDTH*0.3, SCREEN_HEIGHT - 60, -1, 36, _("Cancel"), 0, true, true, GUIGravityCenter);
	cmdBack->name = "cmdBack";
	cmdBack->eventCallback = this;
	GUIObjectRoot->addChild(cmdBack);

	cmdSave = new GUIButton(imageManager, renderer, SCREEN_WIDTH*0.7, SCREEN_HEIGHT - 60, -1, 36, _("Save Changes"), 0, true, true, GUIGravityCenter);
	cmdSave->name = "cmdSave";
	cmdSave->eventCallback = this;
	GUIObjectRoot->addChild(cmdSave);
	}

	static string convertInt(int i){
	stringstream ss;
	ss << i;
	return ss.str();
	}

	void Options::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Reset the key changes.
	for(int i=0;i<INPUTMGR_MAX;i++){
	inputMgr.setKeyCode((InputManagerKeys)i,tmpKeys[i],false);
	inputMgr.setKeyCode((InputManagerKeys)i,tmpAlternativeKeys[i],true);
	}

	//Reset the music volume.
	getMusicManager()->setVolume(atoi(getSettings()->getValue("music").c_str()));
	Mix_Volume(-1,atoi(getSettings()->getValue("sound").c_str()));

	//And goto the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdSave"){
	//Save is pressed thus save
	char s[64];
	sprintf(s,"%d",soundSlider->value);
	getSettings()->setValue("sound",s);
	sprintf(s,"%d",musicSlider->value);
	getSettings()->setValue("music",s);
	getMusicManager()->setEnabled(musicSlider->value>0);
	Mix_Volume(-1,soundSlider->value);
	getSettings()->setValue("fullscreen",fullscreen?"1":"0");
	getSettings()->setValue("internet",internet?"1":"0");
	getSettings()->setValue("theme",themeName);
	getSettings()->setValue("fading",fade?"1":"0");
	getSettings()->setValue("quickrecord",quickrec?"1":"0");
	//Before loading the theme remove the previous one from the stack.
	objThemes.removeTheme();
	loadTheme(imageManager,renderer,themeName);
	if(!useProxy)
	internetProxy.clear();
	getSettings()->setValue("internet-proxy",internetProxy);
	getSettings()->setValue("lang",langs->getName());

	//Is resolution from the list or is it user defined in config file
	if(resolutions->value<(int)resolutionList.size()){
	getSettings()->setValue("width",convertInt(resolutionList[resolutions->value].x));
	getSettings()->setValue("height",convertInt(resolutionList[resolutions->value].y));
	}else{
	getSettings()->setValue("width",convertInt(currentRes.x));
	getSettings()->setValue("height",convertInt(currentRes.y));
	}

	//Save the key configuration.
	inputMgr.saveConfig();

	//Save the settings.
	saveSettings();

	//Before we return check if some .
	if(restartFlag \|\| resolutions->value!=lastRes){
	//The resolution changed so we need to recreate the screen.
	if(!createScreen()){
	//Screen creation failed so set to safe settings.
	getSettings()->setValue("fullscreen","0");
	getSettings()->setValue("width",convertInt(resolutionList[lastRes].x));
	getSettings()->setValue("height",convertInt(resolutionList[lastRes].y));

	if(!createScreen()){
	//Everything fails so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	//The screen is created, now load the (menu) theme.
	if(!loadTheme(imageManager,renderer,"")){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	if(langs->value!=lastLang){
	//We set the language.
	language=langs->getName();

	if (language.empty()) {
	// The language is set to auto-detect.
	FL_Locale *locale;
	FL_FindLocale(&locale, FL_MESSAGES);

	language = locale->lang;
	if (locale->country != NULL){
	language += string("_") + string(locale->country);
	}
	if (locale->variant != NULL){
	language += string("@") + string(locale->variant);
	}

	FL_FreeLocale(&locale);
	}

	dictionaryManager->set_language(tinygettext::Language::from_name(language));

	#ifdef WIN32
	//Some ad-hoc fix for Windows since it accepts "zh-CN" but not "zh_CN"
	std::string language2;
	for (auto c : language) {
	if (isalnum(c)) language2.push_back(c);
	else if (c == '_') language2.push_back('-');
	else break;
	}
	const char* languagePtr = language2.c_str();
	#else
	const char* languagePtr = language.c_str();
	#endif

	- tfm::setLocale(languagePtr);
	setlocale(LC_TIME, languagePtr);

	+ tfm::setNumericFormat(
	+ pgettext("numeric", "."),
	+ pgettext("numeric", ","),
	+ pgettext("numeric", "3")
	+ );
	+
	getLevelPackManager()->updateLanguage();

	//And reload the font.
	if(!loadFonts()){
	//Loading failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	//Now return to the main menu.
	setNextState(STATE_MENU);
	}else if(name=="chkFullscreen"){
	fullscreen=obj->value?true:false;

	//Check if fullscreen changed.
	if(fullscreen==getSettings()->getBoolValue("fullscreen")){
	//We disable the restart message flag.
	restartFlag=false;
	}else{
	//We set the restart message flag.
	restartFlag=true;
	}

	}else if(name=="chkInternet"){
	internet=obj->value?true:false;
	}else if(name=="chkProxy"){
	useProxy=obj->value?true:false;
	}else if(name=="chkFade"){
	fade=obj->value?true:false;
	}else if(name=="chkQuickRec"){
	quickrec=obj->value?true:false;
	}
	}
	if(name=="lstTheme"){
	if(theme!=NULL && theme->value>=0 && theme->value<(int)theme->item.size()){
	//Convert the themeName to contain %DATA%, etc...
	themeName=compressFileName(theme->item[theme->value].first);
	}
	}else if(name=="txtProxy"){
	internetProxy=obj->caption;

	//Check if the internetProxy field is empty.
	useProxy=!internetProxy.empty();
	}else if(name=="sldMusic"){
	getMusicManager()->setEnabled(musicSlider->value>0);
	getMusicManager()->setVolume(musicSlider->value);
	}else if(name=="sldSound"){
	Mix_Volume(-1,soundSlider->value);
	if(lastJumpSound==0){
	getSoundManager()->playSound("jump");
	lastJumpSound=15;
	}
	}
	if(name=="lstTabs"){
	if(obj->value==0){
	tabGeneral->visible=true;
	tabControls->visible=false;
	}else{
	tabGeneral->visible=false;
	tabControls->visible=true;
	}
	}
	}

	void Options::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check keyboard navigation.
	if (tabGeneral && tabGeneral->visible) {
	if (inputMgr.isKeyDownEvent(INPUTMGR_TAB)) {
	isKeyboardOnly = true;
	section = (section == 2) ? 3 : 2;

	//Update selection.
	if (section == 2) {
	tabGeneral->selectNextControl(1, -1);
	} else {
	tabGeneral->setSelectedControl(-1);
	}
	}
	if (section == 2) {
	tabGeneral->handleKeyboardNavigationEvents(imageManager, renderer, UpDownFocus \| ReturnControls \| LeftRightControls);
	} else if (section == 3) {
	if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN) \|\| inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)) {
	isKeyboardOnly = true;
	section2++;
	if (section2 > 3) section2 = 1;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_UP) \|\| inputMgr.isKeyDownEvent(INPUTMGR_LEFT)) {
	isKeyboardOnly = true;
	section2--;
	if (section2 < 1) section2 = 3;
	}
	if (isKeyboardOnly && inputMgr.isKeyDownEvent(INPUTMGR_SELECT) && section == 3) {
	if (section2 == 1) {
	GUIEventCallback_OnEvent(imageManager, renderer, cmdBack->name, cmdBack, GUIEventClick);
	} else if (section2 == 2) {
	GUIEventCallback_OnEvent(imageManager, renderer, cmdSave->name, cmdSave, GUIEventClick);
	}
	}
	}
	}

	//Process mouse event only when it's not keyboard only mode.
	if (!isKeyboardOnly) {
	//Get the x and y location of the mouse.
	int x, y;
	SDL_GetMouseState(&x, &y);

	//Check icon.
	if (event.type == SDL_MOUSEMOTION \|\| event.type == SDL_MOUSEBUTTONDOWN){
	if (y >= SCREEN_HEIGHT - 56 && y < SCREEN_HEIGHT - 8 && x >= SCREEN_WIDTH - 56)
	clearIconHower = true;
	else
	clearIconHower = false;
	}
	}

	//Update highlight on keyboard only mode.
	if (isKeyboardOnly) {
	cmdBack->state = (section == 3 && section2 == 1) ? 1 : 0;
	cmdSave->state = (section == 3 && section2 == 2) ? 1 : 0;
	clearIconHower = (section == 3 && section2 == 3);
	}

	if ((isKeyboardOnly ? inputMgr.isKeyDownEvent(INPUTMGR_SELECT) :
	(event.type == SDL_MOUSEBUTTONUP && event.button.button == SDL_BUTTON_LEFT)) && clearIconHower)
	{
	if(msgBox(imageManager,renderer,_("Do you really want to reset level progress?"),MsgBoxYesNo,_("Warning"))==MsgBoxYes){
	//We delete the progress folder.
	#ifdef WIN32
	removeDirectory((getUserPath()+"progress").c_str());
	createDirectory((getUserPath()+"progress").c_str());
	#else
	removeDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	createDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	#endif
	//Reset statistics.
	statsMgr.reloadCompletedLevelsAndAchievements();
	}
	}

	//Check if we need to quit, if so enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//Check if the escape button is pressed, if so go back to the main menu.
	if (inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE) && (tabControls == NULL \|\| !tabControls->visible)) {
	setNextState(STATE_MENU);
	}
	}

	void Options::logic(ImageManager&, SDL_Renderer&){
	//Increase the lastJumpSound variable if needed.
	if(lastJumpSound!=0){
	lastJumpSound--;
	}
	}

	void Options::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Now render the title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

	//Check if an icon is selected/highlighted and draw tooltip
	if(clearIconHower){
	const SDL_Rect texSize = rectFromTexture(*clearTooltip);
	drawGUIBox(-2,SCREEN_HEIGHT-texSize.h-2,texSize.w+4,texSize.h+4,renderer,0xFFFFFFFF);
	applyTexture(0,SCREEN_HEIGHT-texSize.h,clearTooltip,renderer);
	}

	//Draw border of icon if it's keyboard only mode.
	if (isKeyboardOnly && clearIconHower) {
	drawGUIBox(SCREEN_WIDTH - 52, SCREEN_HEIGHT - 52, 40, 40, renderer, 0xFFFFFF40);
	}

	//Draw icon.
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*clearIcon,renderer);

	//NOTE: The rendering of the GUI is done in Main.
	}

	void Options::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager,renderer);
	}
	diff --git a/src/Player.cpp b/src/Player.cpp
	index 3103e9f..7c3d884 100644
	--- a/src/Player.cpp
	+++ b/src/Player.cpp
	@@ -1,1697 +1,1710 @@
	/*
	* 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 <stdio.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 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;

	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;
	+ objCurrentStand = objLastStand = objLastTeleport = objNotificationBlock = objShadowBlock = NULL;
	+ objCurrentStandSave = objLastStandSave = objLastTeleportSave = objNotificationBlockSave = objShadowBlockSave = 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->player.isPlayFromRecord() && !objParent->interlevel)
	objParent->saveStateNextTime=true;
	}
	}else if(inputMgr.isKeyDownEvent(INPUTMGR_LOAD) && (!readFromRecord \|\| objParent->interlevel)){
	//F3 is used to load the last state.
	if (objParent && canLoadState()) {
	recordIndex = -1;
	objParent->loadStateNextTime = true;

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

	//And set interlevel to false.
	objParent->interlevel = false;
	}
	}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 visible.
	if (levelObjects[o]->queryProperties(GameObjectProperty_Flags, this) & 0x80000000) 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){
	+ if(downKeyPressed \|\| levelObjects[o]!=objLastTeleport.get()){
	//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. We play the error sound only when the down key pressed.
	if (downKeyPressed) {
	getSoundManager()->playSound("error");
	}
	break;
	}

	//Check if the second (oo) object is a portal and is visible.
	if (levelObjects[oo]->type == TYPE_PORTAL && (levelObjects[oo]->queryProperties(GameObjectProperty_Flags, this) & 0x80000000) == 0){
	//Check the id against the destination of the first portal.
	if(levelObjects[o]->destination==levelObjects[oo]->id){
	//Get the destination location.
	SDL_Rect r = levelObjects[oo]->getBox();
	r.x += 5;
	r.y += 2;
	r.w = box.w;
	r.h = box.h;

	//Check if the destination location is blocked.
	bool blocked = false;
	for (auto ooo : levelObjects){
	//Make sure to only check visible blocks.
	if (ooo->queryProperties(GameObjectProperty_Flags, this) & 0x80000000)
	continue;
	//Make sure the object is solid for the player.
	if (!ooo->queryProperties(GameObjectProperty_PlayerCanWalkOn, this))
	continue;

	//Check for collision.
	if (checkCollision(r, ooo->getBox())) {
	blocked = true;
	break;
	}
	}

	//Teleport only if the destination is not blocked.
	if (!blocked) {
	//Call the event.
	objParent->broadcastObjectEvent(GameObjectEvent_OnToggle, -1, NULL, levelObjects[o]);
	objLastTeleport = levelObjects[oo];

	//Teleport the player.
	box.x = r.x;
	box.y = r.y;

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

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

	//Increase oo.
	oo++;
	}

	//Reset the down key pressed.
	downKeyPressed = false;
	}
	}
	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;
	}
	}

	levelObjects[o]->onEvent(GameObjectEvent_OnPlayerInteraction);
	}
	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) & 0x1) == 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 && !objParent->player.isPlayFromRecord() && !objParent->interlevel){
	//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){
	+ if(!objParent->player.objShadowBlock.get()){
	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){
	+ if(!objShadowBlock.get()){
	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");
	- }
	+ appearance.changeState("walkright",true,true);
	}else if(xVel<0){
	- if(appearance.currentStateName!="walkleft"){
	- appearance.changeState("walkleft");
	- }
	+ appearance.changeState("walkleft",true,true);
	}else if(xVel==0){
	if(direction==1){
	- appearance.changeState("standleft");
	+ appearance.changeState("standleft",true,true);
	}else{
	- appearance.changeState("standright");
	+ appearance.changeState("standright",true,true);
	}
	}
	}else{
	//Check for jump appearance (inAir).
	if(direction==1){
	if(yVel>0){
	- if(appearance.currentStateName!="fallleft")
	- appearance.changeState("fallleft");
	+ appearance.changeState("fallleft",true,true);
	}else{
	- if(appearance.currentStateName!="jumpleft")
	- appearance.changeState("jumpleft");
	+ appearance.changeState("jumpleft",true,true);
	}
	}else{
	if(yVel>0){
	- if(appearance.currentStateName!="fallright")
	- appearance.changeState("fallright");
	+ appearance.changeState("fallright",true,true);
	}else{
	- if(appearance.currentStateName!="jumpright")
	- appearance.changeState("jumpright");
	+ appearance.changeState("jumpright",true,true);
	}
	}
	}
	}


	//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, Player other){
	//Only move when the player isn't dead.
	if(dead)
	return;

	//First sort out the velocity.

	//NOTE: This is the temporary xVel which takes canMove into consideration.
	//This shadows Player::xVel.
	const int xVel = canMove ? this->xVel : 0;

	//Add gravity acceleration to the vertical velocity.
	if(isJump)
	jump();
	if(inAir==true){
	yVel+=1;

	//Cap fall speed to 13.
	if(yVel>13)
	yVel=13;
	}

	Block* baseBlock=NULL;
	- if(objCurrentStand != NULL) {
	- baseBlock=objCurrentStand;
	+ if(auto tmp = objCurrentStand.get()) {
	+ baseBlock=tmp;
	} else if(other && other->holdingOther) {
	//NOTE: this actually CAN happen, e.g. when player is holding shadow and the player is going to jump
	//assert(other->objCurrentStand != NULL);
	- baseBlock=other->objCurrentStand;
	+ baseBlock=other->objCurrentStand.get();
	}
	if(baseBlock!=NULL){
	//Now get the velocity and delta of the object the player is standing on.
	SDL_Rect v=baseBlock->getBox(BoxType_Velocity);
	SDL_Rect delta=baseBlock->getBox(BoxType_Delta);

	switch(baseBlock->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.
	//NEW FIX: the squash bug. The following line of code is commented and change 'v' to 'delta'.
	//box.y+=delta.y;
	yVelBase=delta.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 visible blocks.
	if (levelObjects[o]->queryProperties(GameObjectProperty_Flags, this) & 0x80000000)
	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){
	//Move the player right if necessary.
	if((r.x+r.w)-box.x<=delta.x && box.x<r.x+r.w)
	box.x=r.x+r.w;
	}else{
	//Move the player left if necessary.
	if((box.x+box.w)-r.x<=-delta.x && box.x>r.x-box.w)
	box.x=r.x-box.w;
	}
	}
	if(delta.y!=0){
	if(delta.y>0){
	//Move the player down if necessary.
	if((r.y+r.h)-box.y<=delta.y && box.y<r.y+r.h)
	box.y=r.y+r.h;
	}else{
	//Move the player up if necessary.
	if((box.y+box.h)-r.y<=-delta.y && box.y>r.y-box.h)
	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 visible.
	if (levelObjects[o]->queryProperties(GameObjectProperty_Flags, this) & 0x80000000)
	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 is visible.
	if (levelObjects[o]->queryProperties(GameObjectProperty_Flags, this) & 0x80000000)
	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 right so the left edge of the player must be greater 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 greater 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)
	+ if(box.y>objParent->levelRect.y+objParent->levelRect.h)
	die(false);

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

	//Set the new lastStand.
	objLastStand=lastStand;
	if(lastStand){
	//NOTE: We partially revert this piece of code to that in commit 0072762,
	//i.e. change the event GameObjectEvent_PlayerWalkOn from asynchronous back to synchronous,
	//to fix the fragile block hit test bug when it is breaking.
	//Hopefully it will not introduce bugs (e.g. bugs regarding dynamic add/delete of objects).

	if (lastStand->type == TYPE_FRAGILE) {
	//Call the walk on event of the laststand in a synchronous way.
	lastStand->onEvent(GameObjectEvent_PlayerWalkOn);

	//Bugfix for Fragile blocks.
	if (!lastStand->queryProperties(GameObjectProperty_PlayerCanWalkOn, this)) {
	inAir = true;
	isJump = false;
	}
	} else {
	//Call the walk on event of the laststand in an asynchronous way.
	objParent->broadcastObjectEvent(GameObjectEvent_PlayerWalkOn, -1, NULL, lastStand);
	}
	}
	}
	//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);
	+ if(lastStand)
	+ objParent->broadcastObjectEvent(GameObjectEvent_PlayerIsOn,-1,NULL,lastStand);

	//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");
	+ int tmp = statsMgr.playerJumps + statsMgr.shadowJumps;
	+
	+ switch (tmp) {
	+ case 100:
	+ statsMgr.newAchievement("jump100");
	+ break;
	+ case 1000:
	+ statsMgr.newAchievement("jump1k");
	+ break;
	+ }
	}

	//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){
	//If the player is going to stand on the shadow for the first time, check if there are enough spaces for it.
	if (!other->holdingOther) {
	const SDL_Rect r = { box.x, boxShadow.y - box.h, box.w, box.h };
	for (auto ooo : objParent->levelObjects){
	//Make sure to only check visible blocks.
	if (ooo->queryProperties(GameObjectProperty_Flags, this) & 0x80000000)
	continue;
	//Make sure the object is solid for the player.
	if (!ooo->queryProperties(GameObjectProperty_PlayerCanWalkOn, this))
	continue;

	//Check for collision.
	if (checkCollision(r, ooo->getBox())) {
	//We are blocked hence we can't stand on it.
	return;
	}
	}
	}

	box.y=boxShadow.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;
	}
	}else if(boxShadow.y+boxShadow.h<=box.y+13 && !inAir){
	//Shadow is on player.
	int yVelocity=other->yVel-1;
	if(yVelocity>0){
	//If the shadow is going to stand on the player for the first time, check if there are enough spaces for it.
	if (!holdingOther) {
	const SDL_Rect r = { boxShadow.x, box.y - boxShadow.h, boxShadow.w, boxShadow.h };
	for (auto ooo : objParent->levelObjects){
	//Make sure to only check visible blocks.
	if (ooo->queryProperties(GameObjectProperty_Flags, other) & 0x80000000)
	continue;
	//Make sure the object is solid for the shadow.
	if (!ooo->queryProperties(GameObjectProperty_PlayerCanWalkOn, other))
	continue;

	//Check for collision.
	if (checkCollision(r, ooo->getBox())) {
	//We are blocked hence we can't stand on it.
	return;
	}
	}
	}

	other->box.y=box.y-boxShadow.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;
	}
	}
	}else{
	holdingOther=false;
	other->holdingOther=false;
	}
	}
	}

	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;
	+ if(camera.w>objParent->levelRect.w){
	+ camera.x=objParent->levelRect.x-(camera.w-objParent->levelRect.w)/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(camera.x<objParent->levelRect.x){
	+ camera.x=objParent->levelRect.x;
	}
	//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;
	+ if(camera.x+camera.w>objParent->levelRect.x+objParent->levelRect.w){
	+ camera.x=objParent->levelRect.x+objParent->levelRect.w-camera.w;
	}
	}

	//Check if the level fit's vertically inside the camera.
	- if(camera.h>LEVEL_HEIGHT){
	+ if(camera.h>objParent->levelRect.h){
	//We don't centre vertical because the bottom line of the level (deadly) will be mid air.
	- camera.y=-(camera.h-LEVEL_HEIGHT);
	+ camera.y=objParent->levelRect.y-(camera.h-objParent->levelRect.h);
	}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(camera.y<objParent->levelRect.y){
	+ camera.y=objParent->levelRect.y;
	}
	//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;
	+ if(camera.y+camera.h>objParent->levelRect.y+objParent->levelRect.h){
	+ camera.y=objParent->levelRect.y+objParent->levelRect.h-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");
	+ appearance = appearanceInitial;
	+ if (save) appearanceSave = appearanceInitial;
	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;
	+ objCurrentStandSave=objLastStandSave=objLastTeleportSave=objNotificationBlockSave=objShadowBlockSave=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();
	+ appearanceSave = appearance;

	//Save the lastStand and currentStand pointers.
	objCurrentStandSave=objCurrentStand;
	objLastStandSave=objLastStand;
	+ objLastTeleportSave = objLastTeleport;
	+ objNotificationBlockSave = objNotificationBlock;
	+ objShadowBlockSave = objShadowBlock;

	//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;
	+ objLastTeleport = objLastTeleportSave;
	+ objNotificationBlock = objNotificationBlockSave;
	+ objShadowBlock = objShadowBlockSave;

	//Restore the appearance.
	- appearance.loadAnimation();
	+ appearance = appearanceSave;

	//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);
	+ objCurrentStand.swap(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;
	-
	+
	+ //In the arcade mode, the game finishes when the player (not the shadow) dies
	+ if (objParent->arcade && !shadow && stateID != STATE_LEVEL_EDITOR) {
	+ objParent->won = 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");
	}
	+ } else {
	+ appearance.changeState("dead");
	}

	//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/Player.h b/src/Player.h
	index 208cb89..69111ac 100644
	--- a/src/Player.h
	+++ b/src/Player.h
	@@ -1,265 +1,268 @@
	/*
	* 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 PLAYER_H
	#define PLAYER_H

	#include "ThemeManager.h"
	+#include "Block.h"
	#include <vector>
	#include <string>
	#include <SDL.h>

	//Debug the game record file.
	//#define RECORD_FILE_DEBUG

	-class Block;
	class Game;
	class PlayerScriptAPI;

	//The different player buttons.
	//The right arrow.
	const int PlayerButtonRight=0x01;
	//The left arrow.
	const int PlayerButtonLeft=0x02;
	//The up arrow for jumping.
	const int PlayerButtonJump=0x04;
	//The down arrow for actions.
	const int PlayerButtonDown=0x08;
	//space bar for recording. (Only in recordButton)
	const int PlayerButtonSpace=0x10;

	class Player{
	friend class PlayerScriptAPI;
	protected:
	//Vector used to store the player actions in when recording.
	//These can be given to the shadow so he can execute them.
	std::vector<int> playerButton;
	//Vector used to store the playerButton vector when saving the player's state (checkpoint).
	std::vector<int> playerButtonSaved;

	private:
	//Vector used to record the whole game play.
	//And saved record in checkpoint.
	std::vector<int> recordButton,savedRecordButton;

	//record index. -1 means read input from keyboard,
	//otherwise read input from recordings (recordButton[recordIndex]).
	int recordIndex;

	//Vector containing squares along the path the player takes when recording.
	//It will be drawn as a trail of squares.
	std::vector<SDL_Rect> line;
	//Vector that will hold the line vector when saving the player's state (checkpoint).
	std::vector<SDL_Rect> lineSaved;

	//Boolean if the player called the shadow to copy his moves.
	bool shadowCall;
	//Boolean if the player is recording his moves.
	bool record,recordSaved;

	//The following variables are to store a state.
	//Rectangle containing the players location.
	SDL_Rect boxSaved;
	//Boolean if the player is in the air.
	bool inAirSaved;
	//Boolean if the player is (going to) jump(ing).
	bool isJumpSaved;
	//Boolean if the player can move.
	bool canMoveSaved;
	//Boolean if the player is holding the other (shadow).
	bool holdingOtherSaved;
	//The x velocity.
	//NOTE: The x velocity is used to indicate that there's a state saved.
	int xVelSaved;
	//The y velocity.
	int yVelSaved;
	//The state.
	int stateSaved;

	protected:
	//Rectangle containing the player's location.
	SDL_Rect box;

	//The x and y velocity.
	int xVel, yVel;
	//The base x and y velocity, used for standing on moving blocks.
	int xVelBase, yVelBase;

	//Boolean if the player is in the air.
	bool inAir;
	//Boolean if the player is (going to) jump(ing).
	bool isJump;
	//Boolean if the player can move.
	bool canMove;
	//Boolean if the player is dead.
	bool dead;

	//The direction the player is walking, 0=right, 1=left.
	int direction;
	//Integer containing the state of the player.
	int state;
	//The time the player is in the air (jumping).
	int jumpTime;
	//Boolean if the player is in fact the shadow.
	bool shadow;

	//Pointer to the Game state.
	friend class Game;
	Game* objParent;

	//Boolean if the downkey is pressed.
	bool downKeyPressed;
	//Boolean if the space keu is pressed.
	bool spaceKeyPressed;
	//Pointer to the object that is currently been stand on by the player.
	//This is always a valid pointer.
	- Block* objCurrentStand;
	+ Block::ObservePointer objCurrentStand;
	//Pointer to the object the player stood last on.
	//NOTE: This is a weak reference only.
	- Block* objLastStand;
	+ Block::ObservePointer objLastStand;
	//Pointer to the teleporter the player last took.
	//NOTE: This is a weak reference only.
	- Block* objLastTeleport;
	+ Block::ObservePointer objLastTeleport;
	//Pointer to the notification block the player is in front of.
	//This is always a valid pointer.
	- Block* objNotificationBlock;
	+ Block::ObservePointer objNotificationBlock;
	//Pointer to the shadow block the player is in front of.
	//This is always a valid pointer.
	- Block* objShadowBlock;
	+ Block::ObservePointer objShadowBlock;

	//The save variable for the GameObject pointers.
	//FIXME: Also save the other game object pointers?
	- Block* objCurrentStandSave;
	- Block* objLastStandSave;
	+ Block::ObservePointer objCurrentStandSave;
	+ Block::ObservePointer objLastStandSave;
	+ Block::ObservePointer objLastTeleportSave;
	+ Block::ObservePointer objNotificationBlockSave;
	+ Block::ObservePointer objShadowBlockSave;

	public:

	//X and y location where the player starts and gets when reseted.
	int fx, fy;
	//The appearance of the player.
	- ThemeBlockInstance appearance;
	+ ThemeBlockInstance appearance, appearanceSave, appearanceInitial;
	//Boolean if the player is holding the other.
	bool holdingOther;

	//Constructor.
	//objParent: Pointer to the Game state.
	Player(Game* objParent);
	//Destructor.
	~Player();

	//Method used to set the position of the player.
	//x: The new x location of the player.
	//y: The new y location of the player.
	void setLocation(int x,int y);

	//Method used to handle (key) input.
	//shadow: Pointer to the shadow used for recording/calling.
	void handleInput(class Shadow* shadow);
	//Method used to do the movement of the player.
	//NOTE: should call collision() for both player/shadow before call move().
	//levelObjects: Array containing the levelObjects, used to check collision.
	//lastX, lastY: the position of player before calling collision().
	void move(std::vector<Block*> &levelObjects, int lastX, int lastY);
	//Method used to check if the player can jump and executes the jump.
	//strength: The strength of the jump.
	void jump(int strength=13);

	//This method will render the player to the screen.
	void show(SDL_Renderer &renderer);
	//Method that stores the actions if the player is recording.
	void shadowSetState();

	//Method that will reset the state to 0.
	virtual void stateReset();

	//This method checks the player against the other to see if they stand on eachother.
	//other: The shadow or the player.
	void otherCheck(class Player* other);

	//Method that will ease the camera so that the player is in the center.
	void setMyCamera();
	//This method will reset the player to it's initial position.
	//save: Boolean if the saved state should also be deleted.
	void reset(bool save);
	//Method used to retrieve the current location of the player.
	//Returns: SDL_Rect containing the player's location.
	SDL_Rect getBox();

	//This method will
	void shadowGiveState(class Shadow* shadow);

	//Method that will save the current state.
	//NOTE: The special <name>Saved variables will be used.
	virtual void saveState();
	//Method that will retrieve the last saved state.
	//If there is none it will reset the player.
	virtual void loadState();
	//Method that checks if the player can save the state.
	//Returns: True if the player can save his state.
	virtual bool canSaveState();
	//Method that checks if the player can load a state.
	//Returns: True if the player can load a state.
	virtual bool canLoadState();
	//Method that will swap the state of the player with the other.
	//other: The player or the shadow.
	void swapState(Player* other);

	//Check if this player is in fact the shadow.
	//Returns: True if this is the shadow.
	inline bool isShadow(){
	return shadow;
	}

	//Method for returning the objCurrentStand pointer.
	//Returns: Pointer to the gameobject the player is standing on.
	inline Block* getObjCurrentStand(){
	- return objCurrentStand;
	+ return objCurrentStand.get();
	}

	//Let the player die when he falls of or hits spikes.
	//animation: Boolean if the death animation should be played, default is true.
	void die(bool animation=true);

	//Check if currently it's play from record file.
	bool isPlayFromRecord();

	//get the game record object.
	std::vector<int>* getRecord();

	#ifdef RECORD_FILE_DEBUG
	std::string& keyPressLog();
	std::vector<SDL_Rect>& playerPosition();
	#endif

	//play the record.
	void playRecord();

	private:
	//The space key is down. call this function from handleInput and another function.
	void spaceKeyDown(class Shadow* shadow);

	public:
	//Method that will handle the actual movement.
	//NOTE: partially internal function. Should call collision() for both player/shadow before call move().
	//levelObjects: Array containing the levelObjects, used to check collision.
	void collision(std::vector<Block> &levelObjects, Player other);

	};

	#endif
	diff --git a/src/Scenery.cpp b/src/Scenery.cpp
	index dc74470..cf9afad 100644
	--- a/src/Scenery.cpp
	+++ b/src/Scenery.cpp
	@@ -1,396 +1,398 @@
	/*
	* Copyright (C) 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 "GameObjects.h"
	#include "Scenery.h"
	#include "Functions.h"
	#include "LevelEditor.h"
	#include "POASerializer.h"
	#include <iostream>
	#include <sstream>
	#include <stdlib.h>
	#include <stdio.h>
	using namespace std;

	#include "libs/tinyformat/tinyformat.h"

	Scenery::Scenery(Game* objParent) :
	GameObject(objParent),
	xSave(0),
	ySave(0),
	dx(0),
	dy(0),
	themeBlock(NULL),
	repeatMode(0)
	{}

	Scenery::Scenery(Game* objParent, int x, int y, int w, int h, const std::string& sceneryName) :
	GameObject(objParent),
	xSave(0),
	ySave(0),
	dx(0),
	dy(0),
	themeBlock(NULL),
	repeatMode(0)
	{
	box.x = boxBase.x = x;
	box.y = boxBase.y = y;
	box.w = boxBase.w = w;
	box.h = boxBase.h = h;

	if (sceneryName.empty()) {
	themeBlock = &internalThemeBlock;
	} else {
	// Load the appearance.
	themeBlock = objThemes.getScenery(sceneryName);
	if (themeBlock) {
	sceneryName_ = sceneryName;
	} else {
	fprintf(stderr, "ERROR: Can't find scenery with name '%s'.\n", sceneryName.c_str());
	themeBlock = &internalThemeBlock;
	}
	}
	themeBlock->createInstance(&appearance);
	+ appearanceInitial = appearanceSave = appearance;
	}

	Scenery::~Scenery(){
	//Destroy the themeBlock since it isn't needed anymore.
	internalThemeBlock.destroy();
	}

	-static inline int getNewCoord(unsigned char rm, int default_, int cameraX, int cameraW, int levelW, int offset) {
	+static inline int getNewCoord(unsigned char rm, int default_, int cameraX, int cameraW, int levelX, int levelW, int offset) {
	switch (rm) {
	case Scenery::NEGATIVE_INFINITY:
	return cameraX;
	case Scenery::ZERO:
	- return std::max(cameraX, offset);
	+ return std::max(cameraX, levelX + offset);
	case Scenery::LEVEL_SIZE:
	- return std::min(cameraX + cameraW, levelW + offset);
	+ return std::min(cameraX + cameraW, levelX + levelW + offset);
	case Scenery::POSITIVE_INFINITY:
	return cameraX + cameraW;
	default:
	return default_;
	}
	}

	void Scenery::show(SDL_Renderer& renderer) {
	showScenery(renderer, 0, 0);
	}

	void Scenery::showScenery(SDL_Renderer& renderer, int offsetX, int offsetY) {
	//The box which is offset by the input.
	const SDL_Rect box = {
	this->box.x + offsetX,
	this->box.y + offsetY,
	this->box.w,
	this->box.h,
	};

	//The real box according to repeat mode.
	SDL_Rect theBox = {
	- getNewCoord(repeatMode, box.x, camera.x, camera.w, LEVEL_WIDTH, offsetX),
	- getNewCoord(repeatMode >> 16, box.y, camera.y, camera.h, LEVEL_HEIGHT, offsetX),
	- getNewCoord(repeatMode >> 8, box.x + box.w, camera.x, camera.w, LEVEL_WIDTH, offsetY),
	- getNewCoord(repeatMode >> 24, box.y + box.h, camera.y, camera.h, LEVEL_HEIGHT, offsetY),
	+ getNewCoord(repeatMode, box.x, camera.x, camera.w, parent->levelRect.x, parent->levelRect.w, offsetX),
	+ getNewCoord(repeatMode >> 16, box.y, camera.y, camera.h, parent->levelRect.x, parent->levelRect.w, offsetX),
	+ getNewCoord(repeatMode >> 8, box.x + box.w, camera.x, camera.w, parent->levelRect.y, parent->levelRect.h, offsetY),
	+ getNewCoord(repeatMode >> 24, box.y + box.h, camera.y, camera.h, parent->levelRect.y, parent->levelRect.h, offsetY),
	};
	theBox.w -= theBox.x;
	theBox.h -= theBox.y;

	//Check if the scenery is visible.
	if (theBox.w > 0 && theBox.h > 0 && checkCollision(camera, theBox)) {
	//Snap the size to integral multiple of box.w and box.h
	if (box.w > 1) {
	theBox.w += theBox.x;
	if (repeatMode & 0xFFu) {
	theBox.x = box.x + int(floor(float(theBox.x - box.x) / float(box.w))) * box.w;
	}
	if (repeatMode & 0xFF00u) {
	theBox.w = box.x + int(ceil(float(theBox.w - box.x) / float(box.w))) * box.w;
	}
	theBox.w -= theBox.x;
	}
	if (box.h > 1) {
	theBox.h += theBox.y;
	if (repeatMode & 0xFF0000u) {
	theBox.y = box.y + int(floor(float(theBox.y - box.y) / float(box.h))) * box.h;
	}
	if (repeatMode & 0xFF000000u) {
	theBox.h = box.y + int(ceil(float(theBox.h - box.y) / float(box.h))) * box.h;
	}
	theBox.h -= theBox.y;
	}

	//Now draw normal.
	if (theBox.w > 0 && theBox.h > 0) {
	appearance.draw(renderer, theBox.x - camera.x, theBox.y - camera.y, theBox.w, theBox.h);
	}
	}

	//Draw some stupid icons in edit mode.
	if (stateID == STATE_LEVEL_EDITOR && checkCollision(camera, box)) {
	auto bmGUI = static_cast<LevelEditor*>(parent)->getGuiTexture();
	if (!bmGUI) {
	return;
	}

	int x = box.x - camera.x + 2;

	//Draw a stupid icon for custom scenery.
	if (themeBlock == &internalThemeBlock) {
	const SDL_Rect r = { 48, 16, 16, 16 };
	const SDL_Rect dstRect = { x, box.y - camera.y + 2, 16, 16 };
	SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	x += 16;
	}

	//Draw a stupid icon for horizonal repeat.
	if (repeatMode & 0x0000FFFFu) {
	const SDL_Rect r = { 64, 32, 16, 16 };
	const SDL_Rect dstRect = { x, box.y - camera.y + 2, 16, 16 };
	SDL_RenderCopy(&renderer, bmGUI.get(), &r, &dstRect);
	x += 16;
	}

	//Draw a stupid icon for vertical repeat.
	if (repeatMode & 0xFFFF0000u) {
	const SDL_Rect r = { 64, 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 Scenery::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:
	return r;
	case BoxType_Current:
	return box;
	}
	return r;
	}

	void Scenery::setLocation(int x,int y){
	//The scenery has moved so calculate the delta.
	dx=x-box.x;
	dy=y-box.y;

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

	void Scenery::saveState(){
	//Store the location.
	xSave=box.x-boxBase.x;
	ySave=box.y-boxBase.y;

	//And any animations.
	- appearance.saveAnimation();
	+ appearanceSave = appearance;
	}

	void Scenery::loadState(){
	//Restore the location.
	box.x=boxBase.x+xSave;
	box.y=boxBase.y+ySave;

	//And load the animation.
	- appearance.loadAnimation();
	+ appearance = appearanceSave;
	}

	void Scenery::reset(bool save){
	//Reset the scenery to its original location.
	box.x=boxBase.x;
	box.y=boxBase.y;

	if(save)
	xSave=ySave=0;

	//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();
	+ appearance = appearanceInitial;
	+ if (save)
	+ appearanceSave = appearanceInitial;
	}


	void Scenery::playAnimation(){}

	void Scenery::onEvent(int eventType){
	//NOTE: Scenery should not interact with the player or vice versa.
	}

	int Scenery::queryProperties(int propertyType,Player* obj){
	//NOTE: Scenery doesn't have any properties.
	return 0;
	}

	void Scenery::getEditorData(std::vector<std::pair<std::string,std::string> >& obj){
	obj.push_back(pair<string, string>("sceneryName", sceneryName_));
	obj.push_back(pair<string, string>("customScenery", customScenery_));
	obj.push_back(pair<string, string>("repeatMode", tfm::format("%d", repeatMode)));
	}

	void Scenery::setEditorData(std::map<std::string,std::string>& obj){
	// NOTE: currently the sceneryName cannot be changed by this method.

	auto it = obj.find("customScenery");
	if (it != obj.end()) {
	customScenery_ = it->second;
	}

	it = obj.find("repeatMode");
	if (it != obj.end()) {
	repeatMode = atoi(it->second.c_str());
	}
	}

	std::string Scenery::getEditorProperty(const 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 Scenery::setEditorProperty(const std::string& property, const 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 Scenery::loadFromNode(ImageManager& imageManager, SDL_Renderer& renderer, TreeStorageNode* objNode){
	sceneryName_.clear();
	customScenery_.clear();
	repeatMode = 0;

	if (objNode->name == "object") {
	//Make sure there are enough arguments.
	if (objNode->value.size() < 2)
	return false;

	//Load position and size.
	box.x = boxBase.x = atoi(objNode->value[0].c_str());
	box.y = boxBase.y = atoi(objNode->value[1].c_str());
	box.w = boxBase.w = (objNode->value.size() >= 3) ? atoi(objNode->value[2].c_str()) : 50;
	box.h = boxBase.h = (objNode->value.size() >= 4) ? atoi(objNode->value[3].c_str()) : 50;

	//Dump the current TreeStorageNode.
	//NOTE: we temporarily remove all attributes since they are not related to theme.
	std::map<std::string, std::vector<std::string> > tmpAttributes;
	std::swap(objNode->attributes, tmpAttributes);

	std::ostringstream o;
	POASerializer().writeNode(objNode, o, false, true);
	customScenery_ = o.str();

	//restore old attributes
	std::swap(objNode->attributes, tmpAttributes);

	//Load the appearance.
	if (!internalThemeBlock.loadFromNode(objNode, levels->levelpackPath, imageManager, renderer)) return false;
	themeBlock = &internalThemeBlock;
	themeBlock->createInstance(&appearance);
	+ appearanceInitial = appearanceSave = appearance;
	} else if (objNode->name == "scenery") {
	//Make sure there are enough arguments.
	if (objNode->value.size() < 3)
	return false;

	//Load position and size.
	box.x = boxBase.x = atoi(objNode->value[1].c_str());
	box.y = boxBase.y = atoi(objNode->value[2].c_str());
	box.w = boxBase.w = (objNode->value.size() >= 4) ? atoi(objNode->value[3].c_str()) : 50;
	box.h = boxBase.h = (objNode->value.size() >= 5) ? atoi(objNode->value[4].c_str()) : 50;

	//Load the appearance.
	themeBlock = objThemes.getScenery(objNode->value[0]);
	if (!themeBlock) {
	fprintf(stderr, "ERROR: Can't find scenery with name '%s'.\n", objNode->value[0].c_str());
	return false;
	}
	themeBlock->createInstance(&appearance);
	+ appearanceInitial = appearanceSave = appearance;

	//Save the scenery name.
	sceneryName_ = objNode->value[0];
	} else {
	//Unsupported node name for scenery block
	fprintf(stderr, "ERROR: Unsupported node name '%s' for scenery block.\n", objNode->name.c_str());
	return false;
	}

	auto it = objNode->attributes.find("repeatMode");
	if (it != objNode->attributes.end() && it->second.size() >= 4) {
	repeatMode = atoi(it->second[0].c_str())
	\| (atoi(it->second[1].c_str()) << 8)
	\| (atoi(it->second[2].c_str()) << 16)
	\| (atoi(it->second[3].c_str()) << 24);
	}

	return true;
	}

	bool Scenery::updateCustomScenery(ImageManager& imageManager, SDL_Renderer& renderer) {
	POASerializer serializer;
	std::istringstream i(customScenery_);
	TreeStorageNode objNode;

	//Load the node from text dump
	if (!serializer.readNode(i, &objNode, true)) return false;

	//Load the appearance.
	if (!internalThemeBlock.loadFromNode(&objNode, levels->levelpackPath, imageManager, renderer)) return false;
	themeBlock = &internalThemeBlock;
	themeBlock->createInstance(&appearance);
	+ appearanceInitial = appearanceSave = appearance;

	// Clear the scenery name since we are using custom scenery
	sceneryName_.clear();

	return true;
	}

	void Scenery::move(){
	//Update our appearance.
	appearance.updateAnimation();
	}
	diff --git a/src/Scenery.h b/src/Scenery.h
	index c0d6161..6cfd448 100644
	--- a/src/Scenery.h
	+++ b/src/Scenery.h
	@@ -1,152 +1,152 @@
	/*
	* Copyright (C) 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 SCENERY_H
	#define SCENERY_H

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

	class Scenery: public GameObject{
	private:
	//Save variables for the current location of the scenery.
	int xSave,ySave;

	//Delta variables, if the scenery moves these must be set to the delta movement.
	int dx,dy;
	public:
	//The ThemeBlock, kept so it can be deleted later on.
	ThemeBlock internalThemeBlock;
	// The pointer points to the real ThemeBlock, either point to internalThemeBlock, or a ThemeBlock in ThemeManager, or NULL.
	ThemeBlock* themeBlock;
	//The Appearance of the scenery.
	//NOTE: We use a ThemeBlockInstance since it allows for all sorts of things like animations.
	- ThemeBlockInstance appearance;
	+ ThemeBlockInstance appearance, appearanceSave, appearanceInitial;

	// The scenery name. "" means custom scenery, in this case themeBlock is pointing to internalThemeBlock
	std::string sceneryName_;

	// The custom scenery description, which is the text dump of the TreeStorageNode.
	std::string customScenery_;

	// The repeat mode.
	enum RepeatMode {
	DEFAULT, // Starts or ends at the position of this block (default)
	NEGATIVE_INFINITY, // Starts at negative infinity
	ZERO, // Starts or ends at 0
	LEVEL_SIZE, // Starts or ends at level size
	POSITIVE_INFINITY, // Ends at positive infinity
	REPEAT_MODE_MAX,
	};

	// The repeat mode of this block. The value is Scenery::RepeatMode left shifted by appropriate value
	// bit 0-7: x start
	// bit 8-15: x end
	// bit 16-23: y start
	// bit 24-31: y end
	unsigned int repeatMode;

	//Constructor.
	//objParent: Pointer to the Game object.
	Scenery(Game* objParent);
	//Constructor.
	//objParent: Pointer to the Game object.
	//x: the x coordinate
	//y: the y coordinate
	//w: the width
	//h: the height
	//sceneryName: the scenery name, "" means custom scenery block
	Scenery(Game* objParent, int x, int y, int w, int h, const std::string& sceneryName);
	//Desturctor.
	~Scenery();

	//Method to load custom scenery from customScenery_ member variable.
	bool updateCustomScenery(ImageManager& imageManager, SDL_Renderer& renderer);

	//Method used to draw the scenery.
	//NOTE: To enable parallax scrolling, etc. use showScenery() instead.
	void show(SDL_Renderer& renderer) override;

	//Method used to draw the scenery.
	//offsetX/Y: the offset apply to the scenery block before considering camera position.
	void showScenery(SDL_Renderer& renderer, int offsetX, int offsetY);

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

	//Method used to set the location of the scenery.
	//NOTE: The new location isn't stored as base location.
	//x: The new x location.
	//y: The new y location.
	virtual void setLocation(int x,int y) override;

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

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

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

	//Method used to retrieve a property from the scenery.
	//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) override;

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

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

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

	//Method used for updating any animations.
	virtual void move() override;
	};

	#endif
	diff --git a/src/ScriptAPI.cpp b/src/ScriptAPI.cpp
	index d220a33..64e8994 100644
	--- a/src/ScriptAPI.cpp
	+++ b/src/ScriptAPI.cpp
	@@ -1,1911 +1,3284 @@
	/*
	* 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 "Block.h"
	#include "Game.h"
	#include "MusicManager.h"
	#include "ScriptDelayExecution.h"
	+#include "Globals.h"
	+#include "TreeStorageNode.h"
	+#include "POASerializer.h"
	#include <iostream>
	+#include <sstream>
	#include <algorithm>
	using namespace std;

	/////////////////////////// HELPER MACRO ///////////////////////////

	#define HELPER_GET_AND_CHECK_ARGS(ARGS) \
	- int args = lua_gettop(state); \
	+ const int args = lua_gettop(state); \
	if(args != ARGS) { \
	return luaL_error(state, "Incorrect number of arguments for %s, expected %d.", __FUNCTION__, ARGS); \
	}

	#define HELPER_GET_AND_CHECK_ARGS_RANGE(ARGS1, ARGS2) \
	- int args = lua_gettop(state); \
	+ const int args = lua_gettop(state); \
	if(args < ARGS1 \|\| args > ARGS2) { \
	return luaL_error(state, "Incorrect number of arguments for %s, expected %d-%d.", __FUNCTION__, ARGS1, ARGS2); \
	}

	#define HELPER_GET_AND_CHECK_ARGS_2(ARGS1, ARGS2) \
	- int args = lua_gettop(state); \
	+ const int args = lua_gettop(state); \
	if(args != ARGS1 && args != ARGS2) { \
	return luaL_error(state, "Incorrect number of arguments for %s, expected %d or %d.", __FUNCTION__, ARGS1, ARGS2); \
	}

	#define HELPER_GET_AND_CHECK_ARGS_AT_LEAST(ARGS) \
	- int args = lua_gettop(state); \
	+ const int args = lua_gettop(state); \
	if(args < ARGS) { \
	return luaL_error(state, "Incorrect number of arguments for %s, expected at least %d.", __FUNCTION__, ARGS); \
	}

	#define HELPER_GET_AND_CHECK_ARGS_AT_MOST(ARGS) \
	- int args = lua_gettop(state); \
	+ const int args = lua_gettop(state); \
	if(args > ARGS) { \
	return luaL_error(state, "Incorrect number of arguments for %s, expected at most %d.", __FUNCTION__, ARGS); \
	}

	//================================================================

	#define HELPER_CHECK_ARGS_TYPE(INDEX, TYPE) \
	if(!lua_is##TYPE(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s, should be %s.", INDEX, __FUNCTION__, #TYPE); \
	}

	#define HELPER_CHECK_ARGS_TYPE_NO_HINT(INDEX, TYPE) \
	if(!lua_is##TYPE(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s.", INDEX, __FUNCTION__); \
	}

	#define HELPER_CHECK_ARGS_TYPE_2(INDEX, TYPE1, TYPE2) \
	if(!lua_is##TYPE1(state,INDEX) && !lua_is##TYPE2(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s, should be %s or %s.", INDEX, __FUNCTION__, #TYPE1, #TYPE2); \
	}

	#define HELPER_CHECK_ARGS_TYPE_2_NO_HINT(INDEX, TYPE1, TYPE2) \
	if(!lua_is##TYPE1(state,INDEX) && !lua_is##TYPE2(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s.", INDEX, __FUNCTION__); \
	}

	#define HELPER_CHECK_ARGS_TYPE_OR_NIL(INDEX, TYPE) \
	HELPER_CHECK_ARGS_TYPE_2(INDEX, TYPE, nil)

	#define HELPER_CHECK_ARGS_TYPE_OR_NIL_NO_HINT(INDEX, TYPE) \
	HELPER_CHECK_ARGS_TYPE_2_NO_HINT(INDEX, TYPE, nil)

	//================================================================

	#define HELPER_CHECK_OPTIONAL_ARGS_TYPE(INDEX, TYPE) \
	if(args>=INDEX && !lua_is##TYPE(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s, should be %s.", INDEX, __FUNCTION__, #TYPE); \
	}

	#define HELPER_CHECK_OPTIONAL_ARGS_TYPE_NO_HINT(INDEX, TYPE) \
	if(args>=INDEX && !lua_is##TYPE(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s.", INDEX, __FUNCTION__); \
	}

	#define HELPER_CHECK_OPTIONAL_ARGS_TYPE_2(INDEX, TYPE1, TYPE2) \
	if(args>=INDEX && !lua_is##TYPE1(state,INDEX) && !lua_is##TYPE2(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s, should be %s or %s.", INDEX, __FUNCTION__, #TYPE1, #TYPE2); \
	}

	#define HELPER_CHECK_OPTIONAL_ARGS_TYPE_2_NO_HINT(INDEX, TYPE1, TYPE2) \
	if(args>=INDEX && !lua_is##TYPE1(state,INDEX) && !lua_is##TYPE2(state,INDEX)) { \
	return luaL_error(state, "Invalid type for argument %d of %s.", INDEX, __FUNCTION__); \
	}

	#define HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(INDEX, TYPE) \
	HELPER_CHECK_OPTIONAL_ARGS_TYPE_2(INDEX, TYPE, nil)

	#define HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL_NO_HINT(INDEX, TYPE) \
	HELPER_CHECK_OPTIONAL_ARGS_TYPE_2_NO_HINT(INDEX, TYPE, nil)

	//================================================================

	#define HELPER_REGISTER_IS_VALID_FUNCTION(CLASS) \
	int isValid(lua_State* state){ \
	HELPER_GET_AND_CHECK_ARGS(1); \
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata); \
	CLASS* object = CLASS::getObjectFromUserData(state, 1); \
	lua_pushboolean(state, object ? 1 : 0); \
	return 1; \
	}

	//================================================================

	#define _F(FUNC) { #FUNC, _L::FUNC }
	#define _FG(FUNC) _F(get##FUNC)
	#define _FI(FUNC) _F(is##FUNC)
	#define _FS(FUNC) _F(set##FUNC)
	#define _FGS(FUNC) _F(get##FUNC), _F(set##FUNC)
	#define _FIS(FUNC) _F(is##FUNC), _F(set##FUNC)

	///////////////////////////BLOCK SPECIFIC///////////////////////////

	class BlockScriptAPI {
	public:
	static int getFlags(const Block* block) {
	return block->flags;
	}
	static void setFlags(Block* block, int flags) {
	block->flags = flags;
	}
	static void fragileUpdateState(Block* block, int state) {
	state &= 0x3;
	block->flags = (block->flags & ~0x3) \| state;
	const char* s = (state == 0) ? "default" : ((state == 1) ? "fragile1" : ((state == 2) ? "fragile2" : "fragile3"));
	block->appearance.changeState(s);
	}
	static int getTemp(const Block* block) {
	return block->temp;
	}
	static void setTemp(Block* block, int value) {
	block->temp = value;
	}
	static int getSpeed(const Block* block) {
	return block->speed;
	}
	static void setSpeed(Block* block, int value) {
	block->speed = value;
	}
	+ static void invalidatePathMaxTime(Block* block) {
	+ block->movingPosTime = -1;
	+ }
	+ static std::vector<SDL_Rect>& getMovingPos(Block* block) {
	+ return block->movingPos;
	+ }
	};

	namespace block {

	HELPER_REGISTER_IS_VALID_FUNCTION(Block);

	int getBlockById(lua_State* state){
	//Get the number of args, this MUST be one.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Make sure the given argument is an id (string).
	HELPER_CHECK_ARGS_TYPE(1, string);

	//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.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Make sure the given argument is an id (string).
	HELPER_CHECK_ARGS_TYPE(1, string);

	//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 moveTo(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(3);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	- HELPER_CHECK_ARGS_TYPE(3, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);

	//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 getLocation(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	//Get the object.
	SDL_Rect r = object->getBox();
	- lua_pushnumber(state, r.x);
	- lua_pushnumber(state, r.y);
	+ lua_pushinteger(state, r.x);
	+ lua_pushinteger(state, r.y);
	return 2;
	}

	int getBaseLocation(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	//Get the object.
	SDL_Rect r = object->getBox(BoxType_Base);
	- lua_pushnumber(state, r.x);
	- lua_pushnumber(state, r.y);
	+ lua_pushinteger(state, r.x);
	+ lua_pushinteger(state, r.y);
	return 2;
	}

	int setLocation(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(3);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	- HELPER_CHECK_ARGS_TYPE(3, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);

	//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 setBaseLocation(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(3);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);
	+
	+ //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->setBaseLocation(x, y);
	+
	+ return 0;
	+ }
	+
	int growTo(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(3);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	- HELPER_CHECK_ARGS_TYPE(3, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);

	//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 getSize(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	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);
	+ lua_pushinteger(state, object->getBox().w);
	+ lua_pushinteger(state, object->getBox().h);
	return 2;
	}

	int getBaseSize(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

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

	int setSize(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(3);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	- HELPER_CHECK_ARGS_TYPE(3, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);

	//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 setBaseSize(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(3);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);
	+
	+ //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->setBaseSize(w, h);
	+
	+ return 0;
	+ }
	+
	int getType(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	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 changeThemeState(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, string);

	Block* object = Block::getObjectFromUserData(state, 1);
	object->appearance.changeState(lua_tostring(state, 2));

	return 0;
	}

	int setVisible(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, boolean);

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

	BlockScriptAPI::setFlags(object,
	(BlockScriptAPI::getFlags(object) & ~0x80000000) \| (lua_toboolean(state, 2) ? 0 : 0x80000000)
	);

	return 0;
	}

	int isVisible(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	lua_pushboolean(state, (BlockScriptAPI::getFlags(object) & 0x80000000) ? 0 : 1);
	return 1;
	}

	int getEventHandler(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, string);

	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 setEventHandler(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(3);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, string);
	HELPER_CHECK_ARGS_TYPE_OR_NIL(3, function);

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

	if (scriptIndex == LUA_REFNIL) return 0;

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

	int onEvent(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, string);

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

	object->onEvent(it->second);

	return 0;
	}

	int isActivated(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	switch (object->type) {
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	lua_pushboolean(state, (BlockScriptAPI::getFlags(object) & 0x1) ? 0 : 1);
	return 1;
	default:
	return 0;
	}
	}

	int setActivated(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, boolean);

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

	switch (object->type) {
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	case TYPE_CONVEYOR_BELT:
	case TYPE_SHADOW_CONVEYOR_BELT:
	BlockScriptAPI::setFlags(object,
	(BlockScriptAPI::getFlags(object) & ~1) \| (lua_toboolean(state, 2) ? 0 : 1)
	);
	break;
	}

	return 0;
	}

	int isAutomatic(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	switch (object->type) {
	case TYPE_PORTAL:
	lua_pushboolean(state, (BlockScriptAPI::getFlags(object) & 0x1) ? 1 : 0);
	return 1;
	default:
	return 0;
	}
	}

	int setAutomatic(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, boolean);

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

	switch (object->type) {
	case TYPE_PORTAL:
	BlockScriptAPI::setFlags(object,
	(BlockScriptAPI::getFlags(object) & ~1) \| (lua_toboolean(state, 2) ? 1 : 0)
	);
	break;
	}

	return 0;
	}

	int getBehavior(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	switch (object->type) {
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	switch (BlockScriptAPI::getFlags(object) & 0x3) {
	default:
	lua_pushstring(state, "toggle");
	break;
	case 1:
	lua_pushstring(state, "on");
	break;
	case 2:
	lua_pushstring(state, "off");
	break;
	}
	return 1;
	default:
	return 0;
	}
	}

	int setBehavior(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, string);

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

	switch (object->type) {
	case TYPE_BUTTON:
	case TYPE_SWITCH:
	{
	int newFlags = BlockScriptAPI::getFlags(object) & ~3;
	std::string s = lua_tostring(state, 2);
	if (s == "on") newFlags \|= 1;
	else if (s == "off") newFlags \|= 2;
	BlockScriptAPI::setFlags(object, newFlags);
	}
	break;
	}

	return 0;
	}

	int getState(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	switch (object->type) {
	case TYPE_FRAGILE:
	- lua_pushnumber(state, BlockScriptAPI::getFlags(object) & 0x3);
	+ lua_pushinteger(state, BlockScriptAPI::getFlags(object) & 0x3);
	return 1;
	default:
	return 0;
	}
	}

	int setState(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);

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

	switch (object->type) {
	case TYPE_FRAGILE:
	{
	int oldState = BlockScriptAPI::getFlags(object) & 0x3;
	int newState = (int)lua_tonumber(state, 2);
	if (newState < 0) newState = 0;
	else if (newState > 3) newState = 3;
	if (newState != oldState) {
	BlockScriptAPI::fragileUpdateState(object, newState);
	}
	}
	break;
	}

	return 0;
	}

	int isPlayerOn(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	switch (object->type) {
	case TYPE_BUTTON:
	lua_pushboolean(state, (BlockScriptAPI::getFlags(object) & 0x4) ? 1 : 0);
	return 1;
	default:
	return 0;
	}
	}

	int getPathMaxTime(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	switch (object->type) {
	case TYPE_MOVING_BLOCK:
	case TYPE_MOVING_SHADOW_BLOCK:
	case TYPE_MOVING_SPIKES:
	- lua_pushnumber(state, object->getPathMaxTime());
	+ lua_pushinteger(state, object->getPathMaxTime());
	+ return 1;
	+ default:
	+ return 0;
	+ }
	+ }
	+
	+ int getPathTime(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ lua_pushinteger(state, BlockScriptAPI::getTemp(object));
	+ return 1;
	+ default:
	+ return 0;
	+ }
	+ }
	+
	+ int setPathTime(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ BlockScriptAPI::setTemp(object, (int)lua_tonumber(state, 2));
	+ break;
	+ }
	+
	+ return 0;
	+ }
	+
	+ int isLooping(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ lua_pushboolean(state, (BlockScriptAPI::getFlags(object) & 0x2) ? 0 : 1);
	+ return 1;
	+ default:
	+ return 0;
	+ }
	+ }
	+
	+ int setLooping(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE(2, boolean);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ BlockScriptAPI::setFlags(object,
	+ (BlockScriptAPI::getFlags(object) & ~2) \| (lua_toboolean(state, 2) ? 0 : 2)
	+ );
	+ break;
	+ }
	+
	+ return 0;
	+ }
	+
	+ int getSpeed(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_CONVEYOR_BELT:
	+ case TYPE_SHADOW_CONVEYOR_BELT:
	+ lua_pushinteger(state, BlockScriptAPI::getSpeed(object));
	+ return 1;
	+ default:
	+ return 0;
	+ }
	+ }
	+
	+ int setSpeed(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_CONVEYOR_BELT:
	+ case TYPE_SHADOW_CONVEYOR_BELT:
	+ BlockScriptAPI::setSpeed(object, (int)lua_tonumber(state, 2));
	+ break;
	+ }
	+
	+ return 0;
	+ }
	+
	+ int getAppearance(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ lua_pushstring(state, object->customAppearanceName.c_str());
	+
	+ return 1;
	+ }
	+
	+ int setAppearance(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE_OR_NIL(2, string);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ if (lua_isnil(state, 2)) {
	+ object->setEditorProperty("appearance", "");
	+ } else {
	+ object->setEditorProperty("appearance", lua_tostring(state, 2));
	+ }
	+
	+ return 0;
	+ }
	+
	+ int getId(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ lua_pushstring(state, object->id.c_str());
	+
	+ return 1;
	+ }
	+
	+ int setId(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE_OR_NIL(2, string);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ if (lua_isnil(state, 2)) {
	+ object->id.clear();
	+ } else {
	+ object->id = lua_tostring(state, 2);
	+ }
	+
	+ return 0;
	+ }
	+
	+ int getDestination(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_PORTAL:
	+ lua_pushstring(state, object->destination.c_str());
	return 1;
	default:
	return 0;
	}
	+
	+ return 1;
	+ }
	+
	+ int setDestination(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE_OR_NIL(2, string);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_PORTAL:
	+ if (lua_isnil(state, 2)) {
	+ object->destination.clear();
	+ } else {
	+ object->destination = lua_tostring(state, 2);
	+ }
	+ break;
	+ }
	+
	+ return 0;
	}

	- int getPathTime(lua_State* state) {
	- //Check the number of arguments.
	- HELPER_GET_AND_CHECK_ARGS(1);
	+ int getMessage(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_NOTIFICATION_BLOCK:
	+ lua_pushstring(state, object->message.c_str());
	+ return 1;
	+ default:
	+ return 0;
	+ }
	+
	+ return 1;
	+ }
	+
	+ int setMessage(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_ARGS_TYPE_OR_NIL(2, string);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ std::string newMessage;
	+
	+ switch (object->type) {
	+ case TYPE_NOTIFICATION_BLOCK:
	+ if (!lua_isnil(state, 2)) {
	+ newMessage = lua_tostring(state, 2);
	+ }
	+ if (newMessage != object->message) {
	+ object->message = newMessage;
	+
	+ //Invalidate the notification texture
	+ if (Game* game = dynamic_cast<Game*>(currentState)) {
	+ game->invalidateNotificationTexture(object);
	+ }
	+ }
	+ break;
	+ }
	+
	+ return 0;
	+ }
	+
	+ int getMovingPosCount(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ lua_pushinteger(state, BlockScriptAPI::getMovingPos(object).size());
	+ return 1;
	+ default:
	+ return 0;
	+ }
	+ }
	+
	+ void _pushAMovingPos(lua_State* state, const SDL_Rect& r) {
	+ lua_createtable(state, 3, 0);
	+
	+ lua_pushinteger(state, r.x);
	+ lua_rawseti(state, -2, 1);
	+ lua_pushinteger(state, r.y);
	+ lua_rawseti(state, -2, 2);
	+ lua_pushinteger(state, r.w);
	+ lua_rawseti(state, -2, 3);
	+ }
	+
	+ int getMovingPos(lua_State* state) {
	+ //Available overloads:
	+ //getMovingPos()
	+ //getMovingPos(index)
	+ //getMovingPos(start, length)
	+
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(1, 3);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ HELPER_CHECK_OPTIONAL_ARGS_TYPE(2, number);
	+ HELPER_CHECK_OPTIONAL_ARGS_TYPE(3, number);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ break;
	+ default:
	+ return 0;
	+ }
	+
	+ const std::vector<SDL_Rect> &movingPos = BlockScriptAPI::getMovingPos(object);
	+ const int m = movingPos.size();
	+ int start = 0, length = -1;
	+
	+ if (args >= 2) start = lua_tonumber(state, 2) - 1;
	+ if (args >= 3) length = lua_tonumber(state, 3);
	+
	+ //Length<0 means get all of remaining points
	+ if (length < 0) length = m - start;
	+
	+ //Some sanity check
	+ if (start < 0) return 0;
	+ if (start + length > m) length = m - start;
	+ if (length < 0) length = 0;
	+
	+ if (args == 2) {
	+ //Get single point
	+
	+ //Sanity check
	+ if (start >= m) return 0;
	+
	+ _pushAMovingPos(state, movingPos[start]);
	+ } else {
	+ //Get array of points
	+
	+ lua_createtable(state, length, 0);
	+
	+ for (int i = 0; i < length; i++) {
	+ _pushAMovingPos(state, movingPos[start + i]);
	+ lua_rawseti(state, -2, i + 1);
	+ }
	+ }
	+
	+ return 1;
	+ }
	+
	+ SDL_Rect _getAMovingPos(lua_State* state, int index) {
	+ SDL_Rect ret = { 0, 0, 0, 0 };
	+
	+ if (lua_istable(state, index) && lua_rawlen(state, index) >= 3) {
	+ lua_rawgeti(state, index, 1);
	+ ret.x = lua_tonumber(state, -1);
	+ lua_pop(state, 1);
	+ lua_rawgeti(state, index, 2);
	+ ret.y = lua_tonumber(state, -1);
	+ lua_pop(state, 1);
	+ lua_rawgeti(state, index, 3);
	+ ret.w = lua_tonumber(state, -1);
	+ lua_pop(state, 1);
	+ }
	+
	+ return ret;
	+ }
	+
	+ void _getArrayOfMovingPos(lua_State* state, int index, std::vector<SDL_Rect>& ret, int maxLength = -1) {
	+ if (lua_istable(state, index)) {
	+ int m = lua_rawlen(state, index);
	+ if (maxLength >= 0 && m > maxLength) m = maxLength;
	+ for (int i = 0; i < m; i++) {
	+ lua_rawgeti(state, index, i + 1);
	+ ret.push_back(_getAMovingPos(state, -1));
	+ lua_pop(state, 1);
	+ }
	+ }
	+ }
	+
	+ int setMovingPos(lua_State* state) {
	+ //Available overloads:
	+ //setMovingPos(array)
	+ //setMovingPos(index, point)
	+ //setMovingPos(start, length, array)
	+
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(2, 4);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ for (int i = 2; i < args; i++) {
	+ HELPER_CHECK_ARGS_TYPE(i, number);
	+ }
	+ HELPER_CHECK_ARGS_TYPE(args, table);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ break;
	+ default:
	+ return 0;
	+ }
	+
	+ std::vector<SDL_Rect> &movingPos = BlockScriptAPI::getMovingPos(object);
	+
	+ if (args == 2) {
	+ //Overwrite the whole array
	+
	+ movingPos.clear();
	+ _getArrayOfMovingPos(state, args, movingPos);
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+ return 0;
	+ }
	+
	+ const int m = movingPos.size();
	+ int start = 0, length = -1;
	+
	+ if (args >= 3) start = lua_tonumber(state, 2) - 1;
	+ if (args >= 4) length = lua_tonumber(state, 3);
	+
	+ //Length<0 means set all of remaining points
	+ if (length < 0) length = m - start;
	+
	+ //Some sanity check
	+ if (start < 0) return 0;
	+ if (start + length > m) length = m - start;
	+ if (length < 0) length = 0;
	+
	+ if (args == 3) {
	+ //Set single point
	+
	+ //Sanity check
	+ if (start >= m) return 0;
	+
	+ movingPos[start] = _getAMovingPos(state, args);
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+ } else if (length > 0) {
	+ //Set array of points
	+
	+ std::vector<SDL_Rect> newPos;
	+ _getArrayOfMovingPos(state, args, newPos, length);
	+
	+ length = newPos.size();
	+
	+ for (int i = 0; i < length; i++) {
	+ movingPos[start + i] = newPos[i];
	+ }
	+
	+ if (length > 0) {
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+ }
	+ }
	+
	+ return 0;
	+ }
	+
	+ int addMovingPos(lua_State* state) {
	+ //Available overloads:
	+ //addMovingPos(p)
	+ //addMovingPos(index, p)
	+
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(2, 3);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ for (int i = 2; i < args; i++) {
	+ HELPER_CHECK_ARGS_TYPE(i, number);
	+ }
	+ HELPER_CHECK_ARGS_TYPE(args, table);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ break;
	+ default:
	+ return 0;
	+ }
	+
	+ std::vector<SDL_Rect> &movingPos = BlockScriptAPI::getMovingPos(object);
	+
	+ const int m = movingPos.size();
	+ int start = m;
	+
	+ if (args >= 3) start = lua_tonumber(state, 2) - 1;
	+
	+ //Some sanity check
	+ if (start < 0) start = 0;
	+ if (start > m) start = m;
	+
	+ //Get the list of points
	+ std::vector<SDL_Rect> newPos;
	+ bool singlePoint = false;
	+
	+ if (lua_istable(state, args) && lua_rawlen(state, args) >= 3) {
	+ lua_rawgeti(state, args, 1);
	+ lua_rawgeti(state, args, 2);
	+ lua_rawgeti(state, args, 3);
	+ if (lua_isnumber(state, -3) && lua_isnumber(state, -2) && lua_isnumber(state, -1)) {
	+ newPos.push_back(SDL_Rect{
	+ lua_tonumber(state, -3),
	+ lua_tonumber(state, -2),
	+ lua_tonumber(state, -1),
	+ 0
	+ });
	+ singlePoint = true;
	+ }
	+ lua_pop(state, 3);
	+ }
	+
	+ if (!singlePoint) {
	+ _getArrayOfMovingPos(state, args, newPos);
	+ }
	+
	+ if (!newPos.empty()) {
	+ movingPos.insert(movingPos.begin() + start, newPos.begin(), newPos.end());
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+ }
	+
	+ return 0;
	+ }
	+
	+ void _getArrayOfInteger(lua_State* state, int index, std::vector<int>& ret) {
	+ if (lua_istable(state, index)) {
	+ int m = lua_rawlen(state, index);
	+ for (int i = 0; i < m; i++) {
	+ lua_rawgeti(state, index, i + 1);
	+ if (lua_isnumber(state, -1)) {
	+ ret.push_back(lua_tonumber(state, -1));
	+ }
	+ lua_pop(state, 1);
	+ }
	+ }
	+ }
	+
	+ int removeMovingPos(lua_State* state) {
	+ //Available overloads:
	+ //removeMovingPos()
	+ //removeMovingPos(index)
	+ //removeMovingPos(listOfIndices)
	+ //removeMovingPos(start, length)
	+
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(1, 3);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ switch (args) {
	+ case 2:
	+ HELPER_CHECK_ARGS_TYPE_2(2, number, table);
	+ break;
	+ case 3:
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);
	+ break;
	+ }
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ switch (object->type) {
	+ case TYPE_MOVING_BLOCK:
	+ case TYPE_MOVING_SHADOW_BLOCK:
	+ case TYPE_MOVING_SPIKES:
	+ break;
	+ default:
	+ return 0;
	+ }
	+
	+ std::vector<SDL_Rect> &movingPos = BlockScriptAPI::getMovingPos(object);
	+
	+ if (args == 1) {
	+ movingPos.clear();
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+ return 0;
	+ }
	+
	+ const int m = movingPos.size();
	+
	+ if (args == 3) {
	+ int start = lua_tonumber(state, 2) - 1;
	+ int length = lua_tonumber(state, 3);
	+
	+ //Length<0 means remove all of remaining points
	+ if (length < 0) length = m - start;
	+
	+ //Some sanity check
	+ if (start < 0 \|\| start >= m) return 0;
	+ if (start + length > m) length = m - start;
	+ if (length < 0) length = 0;
	+
	+ if (length > 0) {
	+ movingPos.erase(movingPos.begin() + start, movingPos.begin() + (start + length));
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+ }
	+
	+ return 0;
	+ }
	+
	+ if (lua_isnumber(state, 2)) {
	+ int start = lua_tonumber(state, 2) - 1;
	+
	+ //Some sanity check
	+ if (start < 0 \|\| start >= m) return 0;
	+
	+ movingPos.erase(movingPos.begin() + start);
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+
	+ return 0;
	+ }
	+
	+ std::vector<int> indices;
	+
	+ _getArrayOfInteger(state, 2, indices);
	+
	+ std::sort(indices.begin(), indices.end());
	+
	+ int i2 = 0, j = 0;
	+ const int m2 = indices.size();
	+ for (int i = 0; i < m; i++) {
	+ // find the first index which is >= current
	+ while (i2 < m2 && indices[i2] < i + 1) i2++;
	+
	+ if (i2 < m2 && indices[i2] == i + 1) {
	+ // this point will be removed
	+ j++;
	+ } else {
	+ // this point is preserved
	+ if (j > 0) {
	+ movingPos[i - j] = movingPos[i];
	+ }
	+ }
	+ }
	+
	+ if (j > 0) {
	+ movingPos.resize(m - j);
	+ BlockScriptAPI::invalidatePathMaxTime(object);
	+ }
	+
	+ return 0;
	+ }
	+
	+ int remove(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+
	+ Block* object = Block::getObjectFromUserData(state, 1);
	+ if (object == NULL) return 0;
	+
	+ object->deleteMe();
	+
	+ return 0;
	+ }
	+
	+ int removeAll(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(0);
	+
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;
	+
	+ for (auto o : game->levelObjects) {
	+ if (o) o->deleteMe();
	+ }
	+
	+ return 0;
	+ }
	+
	+ int addBlock(lua_State* state) {
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(1, 5);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE(1, string);
	+ for (int i = 2; i <= args; i++) {
	+ HELPER_CHECK_ARGS_TYPE(i, number);
	+ }
	+
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;
	+
	+ TreeStorageNode root;
	+
	+ //Load from the string.
	+ {
	+ POASerializer objSerializer;
	+ istringstream stream(lua_tostring(state, 1));
	+ if (!objSerializer.readNode(stream, &root, true)) {
	+ return luaL_error(state, "Failed to load node from string in %s", __FUNCTION__);
	+ }
	+ }
	+
	+ //Load the first valid block in the subnodes.
	+ for (auto obj1 : root.subNodes) {
	+ if (obj1 == NULL) continue;
	+ if (obj1->name == "tile"){
	+ Block* block = new Block(game);
	+ if (!block->loadFromNode(getImageManager(), getRenderer(), obj1)) {
	+ delete block;
	+ continue;
	+ }
	+
	+ //Reposition the block if necessary
	+ SDL_Rect r = block->getBox(BoxType_Base);
	+ if (args >= 2) {
	+ r.x = lua_tonumber(state, 2);
	+ if (args >= 3) r.y = lua_tonumber(state, 3);
	+ block->setBaseLocation(r.x, r.y);
	+ }
	+ if (args >= 4) {
	+ r.w = lua_tonumber(state, 4);
	+ if (args >= 5) r.h = lua_tonumber(state, 5);
	+ block->setBaseSize(r.w, r.h);
	+ }
	+
	+ //If the type is collectable, increase the number of totalCollectables
	+ if (block->type == TYPE_COLLECTABLE) {
	+ game->totalCollectables++;
	+ if (BlockScriptAPI::getFlags(block) & 0x1) game->currentCollectables++;
	+ }
	+
	+ //Add the block to the levelObjects vector.
	+ game->levelObjects.push_back(block);
	+
	+ //Enable the access to this block from script.
	+ block->setActive();
	+
	+ //Compile the block script.
	+ for (auto it = block->scripts.begin(); it != block->scripts.end(); ++it){
	+ int index = game->getScriptExecutor()->compileScript(it->second);
	+ block->compiledScripts[it->first] = index;
	+ }
	+
	+ //Trigger the onCreate event.
	+ block->onEvent(GameObjectEvent_OnCreate);
	+
	+ //Return the newly created block.
	+ block->createUserData(state, "block");
	+ return 1;
	+ }
	+ }
	+
	+ return 0;
	+ }
	+
	+ SDL_Rect _getAnSDLRect(lua_State* state, int index) {
	+ SDL_Rect ret = { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
	+
	+ if (lua_istable(state, index)) {
	+ const int m = lua_rawlen(state, index);
	+ if (m >= 1) {
	+ lua_rawgeti(state, index, 1);
	+ int n, b; n = lua_tonumberx(state, -1, &b);
	+ if (b) ret.x = n;
	+ lua_pop(state, 1);
	+ }
	+ if (m >= 2) {
	+ lua_rawgeti(state, index, 2);
	+ int n, b; n = lua_tonumberx(state, -1, &b);
	+ if (b) ret.y = n;
	+ lua_pop(state, 1);
	+ }
	+ if (m >= 3) {
	+ lua_rawgeti(state, index, 3);
	+ int n, b; n = lua_tonumberx(state, -1, &b);
	+ if (b) ret.w = n;
	+ lua_pop(state, 1);
	+ }
	+ if (m >= 4) {
	+ lua_rawgeti(state, index, 4);
	+ int n, b; n = lua_tonumberx(state, -1, &b);
	+ if (b) ret.h = n;
	+ lua_pop(state, 1);
	+ }
	+ }
	+
	+ return ret;
	+ }
	+
	+ void _getArrayOfSDLRect(lua_State* state, int index, std::vector<SDL_Rect>& ret) {
	+ if (lua_istable(state, index)) {
	+ int m = lua_rawlen(state, index);
	+ for (int i = 0; i < m; i++) {
	+ lua_rawgeti(state, index, i + 1);
	+ ret.push_back(_getAnSDLRect(state, -1));
	+ lua_pop(state, 1);
	+ }
	+ }
	+ }
	+
	+ int addBlocks(lua_State* state) {
	+ //Available overloads:
	+ //addBlocks(string)
	+ //addBlocks(string,positions)
	+ //addBlocks(string,offsetX,offsetY)
	+
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(1, 3);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE(1, string);
	+ switch (args) {
	+ case 2:
	+ HELPER_CHECK_ARGS_TYPE(2, table);
	+ break;
	+ case 3:
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);
	+ break;
	+ }
	+
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;
	+
	+ TreeStorageNode root;
	+
	+ //Load from the string.
	+ {
	+ POASerializer objSerializer;
	+ istringstream stream(lua_tostring(state, 1));
	+ if (!objSerializer.readNode(stream, &root, true)) {
	+ return luaL_error(state, "Failed to load node from string in %s", __FUNCTION__);
	+ }
	+ }
	+
	+ std::vector<TreeStorageNode*> blockNodes;
	+
	+ //Get available blocks.
	+ for (auto obj1 : root.subNodes) {
	+ if (obj1 == NULL) continue;
	+ if (obj1->name == "tile") blockNodes.push_back(obj1);
	+ }
	+
	+ std::vector<SDL_Rect> positions;
	+ std::vector<Block*> blocks;
	+ int offsetX = 0, offsetY = 0;
	+
	+ //Check if we should get positions.
	+ if (args == 2) {
	+ _getArrayOfSDLRect(state, 2, positions);
	+
	+ //Check if we should load block repeatedly.
	+ if (blockNodes.size() == 1 && positions.size() >= 1) {
	+ Block* blockTemplate = new Block(game);
	+ if (!blockTemplate->loadFromNode(getImageManager(), getRenderer(), blockNodes[0])) {
	+ delete blockTemplate;
	+
	+ //Just return an empty array.
	+ lua_createtable(state, 0, 0);
	+ return 1;
	+ }
	+
	+ //Compile the block script.
	+ for (auto it = blockTemplate->scripts.begin(); it != blockTemplate->scripts.end(); ++it){
	+ int index = game->getScriptExecutor()->compileScript(it->second);
	+ blockTemplate->compiledScripts[it->first] = index;
	+ }
	+
	+ for (int i = 0, m = positions.size(); i < m; i++) {
	+ Block *block;
	+ if (i < m - 1) {
	+ block = new Block(*blockTemplate);
	+ //Ad-hoc code to make the block proxy unique
	+ block->proxy.reset(new Block::Proxy);
	+ } else {
	+ block = blockTemplate;
	+ }
	+
	+ //Reposition the block if necessary
	+ SDL_Rect r = block->getBox(BoxType_Base);
	+ SDL_Rect r1 = positions[i];
	+ if (r1.x != 0x80000000 \|\| r1.y != 0x80000000) {
	+ if (r1.x != 0x80000000) r.x = r1.x;
	+ if (r1.y != 0x80000000) r.y = r1.y;
	+ block->setBaseLocation(r.x, r.y);
	+ }
	+ if (r1.w != 0x80000000 \|\| r1.h != 0x80000000) {
	+ if (r1.w != 0x80000000) r.w = r1.w;
	+ if (r1.h != 0x80000000) r.h = r1.h;
	+ block->setBaseSize(r.w, r.h);
	+ }
	+
	+ //Add it to the temp array
	+ blocks.push_back(block);
	+ }
	+ }
	+ }
	+
	+ //Check if we should use offsets.
	+ if (args == 3) {
	+ offsetX = lua_tonumber(state, 2);
	+ offsetY = lua_tonumber(state, 3);
	+ }
	+
	+ //Check if we should load block in a regular way.
	+ if (blocks.empty()) {
	+ for (int i = 0, m = blockNodes.size(); i < m; i++) {
	+ Block* block = new Block(game);
	+ if (!block->loadFromNode(getImageManager(), getRenderer(), blockNodes[i])) {
	+ delete block;
	+ continue;
	+ }
	+
	+ //Reposition the block if necessary
	+ SDL_Rect r = block->getBox(BoxType_Base);
	+ SDL_Rect r1 = (args == 3) ? SDL_Rect{ r.x + offsetX, r.y + offsetY, 0x80000000, 0x80000000 } :
	+ (i < (int)positions.size()) ? positions[i] : SDL_Rect{ 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
	+ if (r1.x != 0x80000000 \|\| r1.y != 0x80000000) {
	+ if (r1.x != 0x80000000) r.x = r1.x;
	+ if (r1.y != 0x80000000) r.y = r1.y;
	+ block->setBaseLocation(r.x, r.y);
	+ }
	+ if (r1.w != 0x80000000 \|\| r1.h != 0x80000000) {
	+ if (r1.w != 0x80000000) r.w = r1.w;
	+ if (r1.h != 0x80000000) r.h = r1.h;
	+ block->setBaseSize(r.w, r.h);
	+ }
	+
	+ //Compile the block script.
	+ for (auto it = block->scripts.begin(); it != block->scripts.end(); ++it){
	+ int index = game->getScriptExecutor()->compileScript(it->second);
	+ block->compiledScripts[it->first] = index;
	+ }
	+
	+ //Add it to the temp array
	+ blocks.push_back(block);
	+ }
	+ }
	+
	+ for (auto block : blocks) {
	+ //If the type is collectable, increase the number of totalCollectables
	+ if (block->type == TYPE_COLLECTABLE) {
	+ game->totalCollectables++;
	+ if (BlockScriptAPI::getFlags(block) & 0x1) game->currentCollectables++;
	+ }
	+
	+ //Add the block to the levelObjects vector.
	+ game->levelObjects.push_back(block);

	- //Check if the arguments are of the right type.
	- HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ //Enable the access to this block from script.
	+ block->setActive();

	- Block* object = Block::getObjectFromUserData(state, 1);
	- if (object == NULL) return 0;
	+ //Trigger the onCreate event.
	+ block->onEvent(GameObjectEvent_OnCreate);
	+ }

	- switch (object->type) {
	- case TYPE_MOVING_BLOCK:
	- case TYPE_MOVING_SHADOW_BLOCK:
	- case TYPE_MOVING_SPIKES:
	- lua_pushnumber(state, BlockScriptAPI::getTemp(object));
	- return 1;
	- default:
	- return 0;
	+ lua_createtable(state, blocks.size(), 0);
	+
	+ for (int i = 0, m = blocks.size(); i < m; i++) {
	+ blocks[i]->createUserData(state, "block");
	+ lua_rawseti(state, -2, i + 1);
	}
	+
	+ return 1;
	}

	- int setPathTime(lua_State* state) {
	+ int clone(lua_State* state) {
	//Check the number of arguments.
	- HELPER_GET_AND_CHECK_ARGS(2);
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(1, 5);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ for (int i = 2; i <= args; i++) {
	+ HELPER_CHECK_ARGS_TYPE(i, number);
	+ }

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

	- switch (object->type) {
	- case TYPE_MOVING_BLOCK:
	- case TYPE_MOVING_SHADOW_BLOCK:
	- case TYPE_MOVING_SPIKES:
	- BlockScriptAPI::setTemp(object, (int)lua_tonumber(state, 2));
	- break;
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;
	+
	+ Block* block = new Block(*object);
	+
	+ //Ad-hoc code to make the block proxy unique
	+ block->proxy.reset(new Block::Proxy);
	+
	+ //Reposition the block if necessary
	+ SDL_Rect r = block->getBox(BoxType_Base);
	+ if (args >= 2) {
	+ r.x = lua_tonumber(state, 2);
	+ if (args >= 3) r.y = lua_tonumber(state, 3);
	+ block->setBaseLocation(r.x, r.y);
	+ }
	+ if (args >= 4) {
	+ r.w = lua_tonumber(state, 4);
	+ if (args >= 5) r.h = lua_tonumber(state, 5);
	+ block->setBaseSize(r.w, r.h);
	}

	- return 0;
	- }
	+ //If the type is collectable, increase the number of totalCollectables
	+ if (block->type == TYPE_COLLECTABLE) {
	+ game->totalCollectables++;
	+ if (BlockScriptAPI::getFlags(block) & 0x1) game->currentCollectables++;
	+ }

	- int isLooping(lua_State* state) {
	- //Check the number of arguments.
	- HELPER_GET_AND_CHECK_ARGS(1);
	+ //Add the block to the levelObjects vector.
	+ game->levelObjects.push_back(block);

	- //Check if the arguments are of the right type.
	- HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ //Enable the access to this block from script.
	+ block->setActive();

	- Block* object = Block::getObjectFromUserData(state, 1);
	- if (object == NULL) return 0;
	+ //Trigger the onCreate event.
	+ block->onEvent(GameObjectEvent_OnCreate);

	- switch (object->type) {
	- case TYPE_MOVING_BLOCK:
	- case TYPE_MOVING_SHADOW_BLOCK:
	- case TYPE_MOVING_SPIKES:
	- lua_pushboolean(state, (BlockScriptAPI::getFlags(object) & 0x2) ? 0 : 1);
	- return 1;
	- default:
	- return 0;
	- }
	+ //Return the newly created block.
	+ block->createUserData(state, "block");
	+ return 1;
	}

	- int setLooping(lua_State* state) {
	+ int cloneMultiple(lua_State* state) {
	+ //Available overloads:
	+ //cloneMultiple(number)
	+ //cloneMultiple(positions)
	+
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, boolean);
	+ HELPER_CHECK_ARGS_TYPE_2(2, number, table);

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

	- switch (object->type) {
	- case TYPE_MOVING_BLOCK:
	- case TYPE_MOVING_SHADOW_BLOCK:
	- case TYPE_MOVING_SPIKES:
	- BlockScriptAPI::setFlags(object,
	- (BlockScriptAPI::getFlags(object) & ~2) \| (lua_toboolean(state, 2) ? 0 : 2)
	- );
	- break;
	- }
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;

	- return 0;
	- }
	+ std::vector<SDL_Rect> positions;
	+ std::vector<Block*> blocks;

	- int getSpeed(lua_State* state) {
	- //Check the number of arguments.
	- HELPER_GET_AND_CHECK_ARGS(1);
	+ if (lua_isnumber(state, 2)) {
	+ int m = lua_tonumber(state, 2);
	+ if (m > 0) positions.resize(m, SDL_Rect{ 0x80000000, 0x80000000, 0x80000000, 0x80000000 });
	+ } else {
	+ _getArrayOfSDLRect(state, 2, positions);
	+ }

	- //Check if the arguments are of the right type.
	- HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	+ for (int i = 0, m = positions.size(); i < m; i++) {
	+ Block block = new Block(object);

	- Block* object = Block::getObjectFromUserData(state, 1);
	- if (object == NULL) return 0;
	+ //Ad-hoc code to make the block proxy unique
	+ block->proxy.reset(new Block::Proxy);

	- switch (object->type) {
	- case TYPE_CONVEYOR_BELT:
	- case TYPE_SHADOW_CONVEYOR_BELT:
	- lua_pushnumber(state, BlockScriptAPI::getSpeed(object));
	- return 1;
	- default:
	- return 0;
	+ //Reposition the block if necessary
	+ SDL_Rect r = block->getBox(BoxType_Base);
	+ SDL_Rect r1 = positions[i];
	+ if (r1.x != 0x80000000 \|\| r1.y != 0x80000000) {
	+ if (r1.x != 0x80000000) r.x = r1.x;
	+ if (r1.y != 0x80000000) r.y = r1.y;
	+ block->setBaseLocation(r.x, r.y);
	+ }
	+ if (r1.w != 0x80000000 \|\| r1.h != 0x80000000) {
	+ if (r1.w != 0x80000000) r.w = r1.w;
	+ if (r1.h != 0x80000000) r.h = r1.h;
	+ block->setBaseSize(r.w, r.h);
	+ }
	+
	+ //Add it to the temp array
	+ blocks.push_back(block);
	}
	- }

	- int setSpeed(lua_State* state) {
	- //Check the number of arguments.
	- HELPER_GET_AND_CHECK_ARGS(2);
	+ for (auto block : blocks) {
	+ //If the type is collectable, increase the number of totalCollectables
	+ if (block->type == TYPE_COLLECTABLE) {
	+ game->totalCollectables++;
	+ if (BlockScriptAPI::getFlags(block) & 0x1) game->currentCollectables++;
	+ }

	- //Check if the arguments are of the right type.
	- HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ //Add the block to the levelObjects vector.
	+ game->levelObjects.push_back(block);

	- Block* object = Block::getObjectFromUserData(state, 1);
	- if (object == NULL) return 0;
	+ //Enable the access to this block from script.
	+ block->setActive();

	- switch (object->type) {
	- case TYPE_CONVEYOR_BELT:
	- case TYPE_SHADOW_CONVEYOR_BELT:
	- BlockScriptAPI::setSpeed(object, (int)lua_tonumber(state, 2));
	- break;
	+ //Trigger the onCreate event.
	+ block->onEvent(GameObjectEvent_OnCreate);
	}

	- return 0;
	+ lua_createtable(state, blocks.size(), 0);
	+
	+ for (int i = 0, m = blocks.size(); i < m; i++) {
	+ blocks[i]->createUserData(state, "block");
	+ lua_rawseti(state, -2, i + 1);
	+ }
	+
	+ return 1;
	}

	}

	#define _L block
	//Array with the methods for the block library.
	-static const struct luaL_Reg blocklib_m[]={
	+static const luaL_Reg blocklib_m[]={
	_FI(Valid),
	_FG(BlockById),
	_FG(BlocksById),
	_F(moveTo),
	_FGS(Location),
	- _FG(BaseLocation),
	+ _FGS(BaseLocation),
	_F(growTo),
	_FGS(Size),
	- _FG(BaseSize),
	+ _FGS(BaseSize),
	_FG(Type),
	_F(changeThemeState),
	_FIS(Visible),
	_FGS(EventHandler),
	_F(onEvent),
	_FIS(Activated),
	_FIS(Automatic),
	_FGS(Behavior),
	_FGS(State),
	_FI(PlayerOn),
	_FG(PathMaxTime),
	_FGS(PathTime),
	_FIS(Looping),
	_FGS(Speed),
	+ _FGS(Appearance),
	+ _FGS(Id),
	+ _FGS(Destination),
	+ _FGS(Message),
	+ _FG(MovingPosCount),
	+ _FGS(MovingPos),
	+ _F(addMovingPos),
	+ _F(removeMovingPos),
	+ _F(remove),
	+ _F(removeAll),
	+ _F(addBlock),
	+ _F(addBlocks),
	+ _F(clone),
	+ _F(cloneMultiple),
	{ NULL, NULL }
	};
	#undef _L

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

	class PlayerScriptAPI {
	public:
	static bool isInAir(Player* player) {
	return player->inAir;
	}
	static bool canMode(Player* player) {
	return player->canMove;
	}
	static bool isDead(Player* player) {
	return player->dead;
	}
	static bool isHoldingOther(Player* player) {
	return player->holdingOther;
	}
	};

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

	namespace playershadow {

	int getLocation(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	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);
	+ lua_pushinteger(state, player->getBox().x);
	+ lua_pushinteger(state, player->getBox().y);
	return 2;
	}

	int setLocation(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(3);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	- HELPER_CHECK_ARGS_TYPE(3, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_ARGS_TYPE(3, number);

	//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 jump(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS_2(1, 2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_OPTIONAL_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_OPTIONAL_ARGS_TYPE(2, number);

	//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 isShadow(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

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

	int getCurrentStand(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	int isInAir(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	lua_pushboolean(state, PlayerScriptAPI::isInAir(player));
	return 1;
	}

	int canMove(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	lua_pushboolean(state, PlayerScriptAPI::canMode(player));
	return 1;
	}

	int isDead(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	lua_pushboolean(state, PlayerScriptAPI::isDead(player));
	return 1;
	}

	int isHoldingOther(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

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

	lua_pushboolean(state, PlayerScriptAPI::isHoldingOther(player));
	return 1;
	}
	}

	#define _L playershadow
	//Array with the methods for the player and shadow library.
	-static const struct luaL_Reg playerlib_m[]={
	+static const luaL_Reg playerlib_m[]={
	_FGS(Location),
	_F(jump),
	_FI(Shadow),
	_FG(CurrentStand),
	_FI(InAir),
	_F(canMove),
	_FI(Dead),
	_FI(HoldingOther),
	{ NULL, NULL }
	};
	#undef _L

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

	namespace level {

	int getSize(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, LEVEL_WIDTH);
	- lua_pushinteger(state, LEVEL_HEIGHT);
	+ lua_pushinteger(state, game->levelRect.w);
	+ lua_pushinteger(state, game->levelRect.h);
	return 2;
	}

	+ int getRect(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->levelRect.x);
	+ lua_pushinteger(state, game->levelRect.y);
	+ lua_pushinteger(state, game->levelRect.w);
	+ lua_pushinteger(state, game->levelRect.h);
	+ return 4;
	+ }
	+
	+ int setRect(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(4);
	+
	+ //Check if the arguments are of the right type.
	+ for (int i = 1; i <= args; i++) {
	+ HELPER_CHECK_ARGS_TYPE(i, number);
	+ }
	+
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;
	+
	+ //Set the level size.
	+ game->levelRect = SDL_Rect {
	+ (int)lua_tonumber(state, 1),
	+ (int)lua_tonumber(state, 2),
	+ (int)lua_tonumber(state, 3),
	+ (int)lua_tonumber(state, 4)
	+ };
	+
	+ return 0;
	+ }
	+
	int getWidth(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, LEVEL_WIDTH);
	+ lua_pushinteger(state, game->levelRect.w);
	return 1;
	}

	int getHeight(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, LEVEL_HEIGHT);
	+ lua_pushinteger(state, game->levelRect.h);
	return 1;
	}

	int getName(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 getEventHandler(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE(1, string);

	//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 setEventHandler(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE(1, string);
	HELPER_CHECK_ARGS_TYPE_OR_NIL(2, function);

	//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());
	return 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);

	if (scriptIndex == LUA_REFNIL) return 0;

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

	int win(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 getTime(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 getRecordings(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;
	}

	int broadcastObjectEvent(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS_RANGE(1, 4);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE(1, string);
	HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(2, string);
	HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(3, string);
	HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL_NO_HINT(4, userdata);

	//Check event type
	int eventType = 0;
	{
	string s = lua_tostring(state, 1);
	auto it = Game::gameObjectEventNameMap.find(s);
	if (it == Game::gameObjectEventNameMap.end()){
	lua_pushfstring(state, "Unknown block event type: '%s'.", s.c_str());
	return lua_error(state);
	} else {
	eventType = it->second;
	}
	}

	//Check object type
	int objType = -1;
	if (args >= 2 && lua_isstring(state, 2)) {
	string s = lua_tostring(state, 2);
	auto it = Game::blockNameMap.find(s);
	if (it == Game::blockNameMap.end()){
	lua_pushfstring(state, "Unknown object type: '%s'.", s.c_str());
	return lua_error(state);
	} else {
	objType = it->second;
	}
	}

	//Check id
	const char* id = NULL;
	if (args >= 3 && lua_isstring(state, 3)) {
	id = lua_tostring(state, 3);
	}

	//Check target
	Block *target = NULL;
	if (args >= 4) {
	target = Block::getObjectFromUserData(state, 4);
	}

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

	game->broadcastObjectEvent(eventType, objType, id, target);

	return 0;
	}

	}

	#define _L level
	//Array with the methods for the level library.
	-static const struct luaL_Reg levellib_m[]={
	+static const luaL_Reg levellib_m[]={
	_FG(Size),
	+ _FGS(Rect),
	_FG(Width),
	_FG(Height),
	_FG(Name),
	_FGS(EventHandler),
	_F(win),
	_FG(Time),
	_FG(Recordings),
	_F(broadcastObjectEvent),
	{NULL,NULL}
	};
	#undef _L

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

	//FIXME: I can't define namespace camera since there is already a global variable named camera.
	//Therefore I use struct camera for a workaround.

	struct camera {

	static int setMode(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE(1, string);

	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{
	//Unknown OR invalid camera mode.
	return luaL_error(state, "Unknown or invalid camera mode for %s: '%s'.", __FUNCTION__, mode.c_str());
	}

	//Returns nothing.
	return 0;
	}

	static int lookAt(lua_State* state){
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS(2);

	//Check if the arguments are of the right type.
	- HELPER_CHECK_ARGS_TYPE(1, number); // integer
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(1, number);
	+ HELPER_CHECK_ARGS_TYPE(2, number);

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

	};

	#define _L camera
	//Array with the methods for the camera library.
	-static const struct luaL_Reg cameralib_m[]={
	+static const luaL_Reg cameralib_m[]={
	_FS(Mode),
	_F(lookAt),
	{NULL,NULL}
	};
	#undef _L

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

	namespace audio {

	int playSound(lua_State* state){
	//Get the number of args, this can be anything from one to three.
	HELPER_GET_AND_CHECK_ARGS_RANGE(1, 4);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE(1, string);
	- HELPER_CHECK_OPTIONAL_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_OPTIONAL_ARGS_TYPE(2, number);
	HELPER_CHECK_OPTIONAL_ARGS_TYPE(3, boolean);
	- HELPER_CHECK_OPTIONAL_ARGS_TYPE(4, number); // integer
	+ HELPER_CHECK_OPTIONAL_ARGS_TYPE(4, number);

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

	//If there's a second one it should be an integer.
	if (args > 1){
	concurrent = lua_tonumber(state, 2);
	}
	//If there's a third one it should be a boolean.
	if (args > 2){
	force = lua_toboolean(state, 3);
	}

	if (args > 3){
	fadeMusic = lua_tonumber(state, 4);
	}

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

	//Returns whether the operation is successful.
	lua_pushboolean(state, channel >= 0 ? 1 : 0);
	return 1;
	}

	int playMusic(lua_State* state){
	//Get the number of args, this can be either one or two.
	HELPER_GET_AND_CHECK_ARGS_2(1, 2);

	//Make sure the first argument is a string.
	HELPER_CHECK_ARGS_TYPE(1, string);
	HELPER_CHECK_OPTIONAL_ARGS_TYPE(2, boolean);

	//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){
	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.
	HELPER_GET_AND_CHECK_ARGS(1);

	//Make sure the given argument is a string.
	HELPER_CHECK_ARGS_TYPE(1, string);

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

	}

	#define _L audio
	//Array with the methods for the audio library.
	-static const struct luaL_Reg audiolib_m[]={
	+static const luaL_Reg audiolib_m[]={
	_F(playSound),
	_F(playMusic),
	_F(pickMusic),
	_FGS(MusicList),
	_F(currentMusic),
	{NULL,NULL}
	};
	#undef _L

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

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

	/////////////////////////DELAY EXECUTION SPECIFIC///////////////////////////

	namespace delayExecution {

	HELPER_REGISTER_IS_VALID_FUNCTION(ScriptDelayExecution);

	int schedule(lua_State* state) {
	//Check the number of arguments.
	HELPER_GET_AND_CHECK_ARGS_AT_LEAST(2);

	//Check if the arguments are of the right type.
	HELPER_CHECK_ARGS_TYPE_OR_NIL(1, function);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	- HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(3, number); // integer
	- HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(4, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);
	+ HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(3, number);
	+ HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(4, number);
	HELPER_CHECK_OPTIONAL_ARGS_TYPE_OR_NIL(5, boolean);

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

	//Create the delay execution object.
	ScriptDelayExecution *obj = new ScriptDelayExecution(game->getScriptExecutor()->getDelayExecutionList());
	obj->setActive();

	obj->time = (int)lua_tonumber(state, 2);
	obj->repeatCount = (args >= 3 && lua_isnumber(state, 3)) ? (int)lua_tonumber(state, 3) : 1;
	obj->repeatInterval = (args >= 4 && lua_isnumber(state, 4)) ? (int)lua_tonumber(state, 4) : obj->time;
	obj->enabled = ((args >= 5 && lua_isboolean(state, 5)) ? lua_toboolean(state, 5) : 1) != 0;

	//Get arguments.
	for (int i = 6; i <= args; i++) {
	obj->arguments.push_back(luaL_ref(state, LUA_REGISTRYINDEX));
	}
	std::reverse(obj->arguments.begin(), obj->arguments.end());

	//Get the function.
	lua_settop(state, 1);
	obj->func = luaL_ref(state, LUA_REGISTRYINDEX);

	//Create the userdatum.
	obj->createUserData(state, "delayExecution");

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

	int cancel(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	//Delete the object.
	delete object;
	return 0;
	}

	int isEnabled(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	lua_pushboolean(state, object->enabled ? 1 : 0);
	return 1;
	}

	int setEnabled(lua_State* state) {
	HELPER_GET_AND_CHECK_ARGS(2);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE(2, boolean);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	object->enabled = lua_toboolean(state, 2) != 0;
	return 0;
	}

	int getTime(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	- lua_pushnumber(state, object->time);
	+ lua_pushinteger(state, object->time);
	return 1;
	}

	int setTime(lua_State* state) {
	HELPER_GET_AND_CHECK_ARGS(2);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	object->time = (int)lua_tonumber(state, 2);
	return 0;
	}

	int getRepeatCount(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	- lua_pushnumber(state, object->repeatCount);
	+ lua_pushinteger(state, object->repeatCount);
	return 1;
	}

	int setRepeatCount(lua_State* state) {
	HELPER_GET_AND_CHECK_ARGS(2);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	object->repeatCount = (int)lua_tonumber(state, 2);
	return 0;
	}

	int getRepeatInterval(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	- lua_pushnumber(state, object->repeatInterval);
	+ lua_pushinteger(state, object->repeatInterval);
	return 1;
	}

	int setRepeatInterval(lua_State* state) {
	HELPER_GET_AND_CHECK_ARGS(2);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	//Set the repeat interval (should >=1).
	int i = (int)lua_tonumber(state, 2);
	if (i > 0) object->repeatInterval = i;
	return 0;
	}

	int getFunc(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;
	if (object->func == LUA_REFNIL) return 0;

	lua_rawgeti(state, LUA_REGISTRYINDEX, object->func);
	return 1;
	}

	int setFunc(lua_State* state) {
	HELPER_GET_AND_CHECK_ARGS(2);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	HELPER_CHECK_ARGS_TYPE_OR_NIL(2, function);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	int oldFunc = object->func;
	object->func = luaL_ref(state, LUA_REGISTRYINDEX);

	if (oldFunc == LUA_REFNIL) return 0;

	lua_rawgeti(state, LUA_REGISTRYINDEX, oldFunc);
	luaL_unref(state, LUA_REGISTRYINDEX, oldFunc);
	return 1;
	}

	int getArguments(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	for (int a : object->arguments) {
	lua_rawgeti(state, LUA_REGISTRYINDEX, a);
	}

	return object->arguments.size();
	}

	int setArguments(lua_State* state) {
	HELPER_GET_AND_CHECK_ARGS_AT_LEAST(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	//Remove old arguments.
	for (int a : object->arguments) {
	luaL_unref(state, LUA_REGISTRYINDEX, a);
	}
	object->arguments.clear();

	//Get arguments.
	for (int i = 2; i <= args; i++) {
	object->arguments.push_back(luaL_ref(state, LUA_REGISTRYINDEX));
	}
	std::reverse(object->arguments.begin(), object->arguments.end());

	return 0;
	}

	int getExecutionTime(lua_State* state){
	HELPER_GET_AND_CHECK_ARGS(1);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	- lua_pushnumber(state, object->executionTime);
	+ lua_pushinteger(state, object->executionTime);
	return 1;
	}

	int setExecutionTime(lua_State* state) {
	HELPER_GET_AND_CHECK_ARGS(2);

	HELPER_CHECK_ARGS_TYPE_NO_HINT(1, userdata);
	- HELPER_CHECK_ARGS_TYPE(2, number); // integer
	+ HELPER_CHECK_ARGS_TYPE(2, number);

	auto object = ScriptDelayExecution::getObjectFromUserData(state, 1);
	if (object == NULL) return 0;

	object->executionTime = (int)lua_tonumber(state, 2);
	return 0;
	}
	}


	#define _L delayExecution
	//Array with the methods for the block library.
	-static const struct luaL_Reg delayExecutionLib_m[] = {
	+static const luaL_Reg delayExecutionLib_m[] = {
	_FI(Valid),
	_F(schedule),
	_F(cancel),
	_FIS(Enabled),
	_FGS(Time),
	_FGS(RepeatCount),
	_FGS(RepeatInterval),
	_FGS(Func),
	_FGS(Arguments),
	_FGS(ExecutionTime),
	{ NULL, NULL }
	};
	#undef _L

	int luaopen_delayExecution(lua_State* state){
	luaL_newlib(state, delayExecutionLib_m);

	//Create the metatable for the delay execution userdata.
	luaL_newmetatable(state, "delayExecution");

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

	ScriptDelayExecution::registerMetatableFunctions(state, -3);

	//Register the functions and methods.
	luaL_setfuncs(state, delayExecutionLib_m, 0);
	return 1;
	}
	+
	+/////////////////////////GETTEXT SPECIFIC///////////////////////////
	+
	+namespace gettext {
	+
	+ int gettext(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE(1, string); //msgid
	+
	+ if (levels) {
	+ auto dm = levels->getDictionaryManager();
	+ if (dm) {
	+ lua_pushstring(state, dm->get_dictionary().translate(lua_tostring(state, 1)).c_str());
	+ return 1;
	+ }
	+ }
	+
	+ //If we failed to find dictionay manager, we just return the original string.
	+ lua_pushvalue(state, 1);
	+ return 1;
	+ }
	+
	+ int pgettext(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(2);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE(1, string); //msgctxt
	+ HELPER_CHECK_ARGS_TYPE(2, string); //msgid
	+
	+ if (levels) {
	+ auto dm = levels->getDictionaryManager();
	+ if (dm) {
	+ lua_pushstring(state, dm->get_dictionary().translate_ctxt(lua_tostring(state, 1), lua_tostring(state, 2)).c_str());
	+ return 1;
	+ }
	+ }
	+
	+ //If we failed to find dictionay manager, we just return the original string.
	+ lua_pushvalue(state, 2);
	+ return 1;
	+ }
	+
	+ int ngettext(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(3);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE(1, string); //msgid
	+ HELPER_CHECK_ARGS_TYPE(2, string); //msgid_plural
	+ HELPER_CHECK_ARGS_TYPE(3, number);
	+
	+ if (levels) {
	+ auto dm = levels->getDictionaryManager();
	+ if (dm) {
	+ lua_pushstring(state, dm->get_dictionary().translate_plural(
	+ lua_tostring(state, 1),
	+ lua_tostring(state, 2),
	+ lua_tonumber(state, 3)
	+ ).c_str());
	+ return 1;
	+ }
	+ }
	+
	+ //If we failed to find dictionay manager, we just return the original string.
	+ if (lua_tonumber(state, 3) == 1) {
	+ lua_pushvalue(state, 1);
	+ } else {
	+ lua_pushvalue(state, 2);
	+ }
	+ return 1;
	+ }
	+
	+ int npgettext(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(4);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE(1, string); //msgctxt
	+ HELPER_CHECK_ARGS_TYPE(2, string); //msgid
	+ HELPER_CHECK_ARGS_TYPE(3, string); //msgid_plural
	+ HELPER_CHECK_ARGS_TYPE(4, number);
	+
	+ if (levels) {
	+ auto dm = levels->getDictionaryManager();
	+ if (dm) {
	+ lua_pushstring(state, dm->get_dictionary().translate_ctxt_plural(
	+ lua_tostring(state, 1),
	+ lua_tostring(state, 2),
	+ lua_tostring(state, 3),
	+ lua_tonumber(state, 4)
	+ ).c_str());
	+ return 1;
	+ }
	+ }
	+
	+ //If we failed to find dictionay manager, we just return the original string.
	+ if (lua_tonumber(state, 4) == 1) {
	+ lua_pushvalue(state, 2);
	+ } else {
	+ lua_pushvalue(state, 3);
	+ }
	+ return 1;
	+ }
	+
	+}
	+
	+#define _L gettext
	+static const luaL_Reg gettextlib_m[] = {
	+ _F(gettext),
	+ _F(pgettext),
	+ _F(ngettext),
	+ _F(npgettext),
	+ { NULL, NULL }
	+};
	+#undef _L
	+
	+int luaopen_gettext(lua_State* state){
	+ //Register the global shortcut function _() and __().
	+ luaL_loadstring(state,
	+ "function _(s)\n"
	+ " return gettext.gettext(s)\n"
	+ "end\n"
	+ "function __(s)\n"
	+ " return s\n"
	+ "end\n"
	+ );
	+ lua_pcall(state, 0, 0, 0);
	+
	+ luaL_newlib(state, gettextlib_m);
	+
	+ //Register the functions and methods.
	+ luaL_setfuncs(state, gettextlib_m, 0);
	+ return 1;
	+}
	+
	+//////////////////////////PRNG SPECIFIC///////////////////////////
	+
	+namespace prng {
	+
	+ int random(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS_RANGE(0, 2);
	+
	+ //Check if the arguments are of the right type.
	+ for (int i = 1; i <= args; i++) {
	+ HELPER_CHECK_ARGS_TYPE(i, number);
	+ }
	+
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;
	+
	+ if (args == 0) {
	+ // float with uniform distribution in the range [0,1)
	+ std::uniform_real_distribution<lua_Number> distribution;
	+ lua_pushnumber(state, distribution(game->prng));
	+ } else {
	+ lua_Integer min = 1, max = 1;
	+
	+ if (args == 2) {
	+ if (lua_isinteger(state, 1)) min = lua_tointeger(state, 1);
	+ else min = (lua_Integer)lua_tonumber(state, 1);
	+ }
	+ if (lua_isinteger(state, args)) max = lua_tointeger(state, args);
	+ else max = (lua_Integer)lua_tonumber(state, args);
	+
	+ unsigned long long size = max - min + 1;
	+
	+ if (size == 0) {
	+ // this means 2^64
	+ unsigned long long result = (((unsigned long long)game->prng()) << 32) \| ((unsigned long long)game->prng());
	+ lua_pushinteger(state, (lua_Integer)result);
	+ } else if (size == 1) {
	+ // no random at all
	+ lua_pushinteger(state, min);
	+ } else {
	+ std::uniform_int_distribution<unsigned long long> distribution(0, size - 1);
	+ unsigned long long result = distribution(game->prng);
	+ lua_pushinteger(state, (lua_Integer)(min + result));
	+ }
	+ }
	+
	+ return 1;
	+ }
	+
	+ int getSeed(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 random seed.
	+ lua_pushstring(state, game->prngSeed.c_str());
	+ return 1;
	+ }
	+
	+ int setSeed(lua_State* state){
	+ //Check the number of arguments.
	+ HELPER_GET_AND_CHECK_ARGS(1);
	+
	+ //Check if the arguments are of the right type.
	+ HELPER_CHECK_ARGS_TYPE(1, string);
	+
	+ //Check if the currentState is the game state.
	+ Game* game = dynamic_cast<Game*>(currentState);
	+ if (game == NULL) return 0;
	+
	+ game->prngSeed = lua_tostring(state, 1);
	+#ifdef _DEBUG
	+ cout << "New PRNG seed by script: " << game->prngSeed << endl;
	+#endif
	+ game->prng.seed(std::seed_seq(game->prngSeed.begin(), game->prngSeed.end()));
	+
	+ return 0;
	+ }
	+
	+}
	+
	+#define _L prng
	+//Array with the methods for the level library.
	+static const luaL_Reg prnglib_m[] = {
	+ _F(random),
	+ _FGS(Seed),
	+ { NULL, NULL }
	+};
	+#undef _L
	+
	+int luaopen_prng(lua_State* state){
	+ luaL_newlib(state, prnglib_m);
	+
	+ //Register the functions and methods.
	+ luaL_setfuncs(state, prnglib_m, 0);
	+ return 1;
	+}
	diff --git a/src/ScriptAPI.h b/src/ScriptAPI.h
	index 79d483c..bf5a357 100644
	--- a/src/ScriptAPI.h
	+++ b/src/ScriptAPI.h
	@@ -1,44 +1,48 @@
	/*
	* 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/>.
	*/

	#ifndef SCRIPTAPI_H
	#define SCRIPTAPI_H

	extern "C" {
	#include <lua.h>
	#include <lualib.h>
	#include <lauxlib.h>
	}

	class ScriptExecutor;

	//Method for loading the block library.
	int luaopen_block(lua_State* state);
	//Method for loading the player and shadow library.
	int luaopen_player(lua_State* state);
	//Method for loading the level library.
	int luaopen_level(lua_State* state);
	//Method for loading the camera library.
	int luaopen_camera(lua_State* state);
	//Method for loading the audio library.
	int luaopen_audio(lua_State* state);
	//Method for loading the delayExecution library.
	int luaopen_delayExecution(lua_State* state);
	+//Method for loading the gettext library.
	+int luaopen_gettext(lua_State* state);
	+//Method for loading the prng library.
	+int luaopen_prng(lua_State* state);

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

	#include "ScriptDelayExecution.h"

	#include <assert.h>
	#include <iostream>

	ScriptDelayExecution::ScriptDelayExecution(ScriptDelayExecutionList *parent)
	: parent(parent)
	, func(LUA_REFNIL), time(0), repeatCount(0), repeatInterval(0)
	, executionTime(0)
	, enabled(true)
	{
	assert(parent != NULL);

	//Link ourself to the parent.
	parent->objects.push_back(this);
	index = parent->objects.size() - 1;
	}

	ScriptDelayExecution::ScriptDelayExecution(ScriptDelayExecutionList *parent, const ScriptDelayExecution& other)
	: ScriptProxyUserClass(other), parent(parent)
	, func(LUA_REFNIL), time(other.time), repeatCount(other.repeatCount), repeatInterval(other.repeatInterval)
	, executionTime(other.executionTime)
	, enabled(other.enabled)
	{
	assert(parent != NULL);

	lua_State *state = parent->state;

	assert(other.parent != NULL && state == other.parent->state && state != NULL);

	//Make a copy of Lua references.
	if (other.func != LUA_REFNIL) {
	lua_rawgeti(state, LUA_REGISTRYINDEX, other.func);
	func = luaL_ref(state, LUA_REGISTRYINDEX);
	}
	for (int a : other.arguments) {
	lua_rawgeti(state, LUA_REGISTRYINDEX, a);
	arguments.push_back(luaL_ref(state, LUA_REGISTRYINDEX));
	}

	//Link ourself to the parent.
	parent->objects.push_back(this);
	index = parent->objects.size() - 1;
	}

	ScriptDelayExecution::~ScriptDelayExecution() {
	//Remove Lua references.
	if (parent->state) {
	if (func != LUA_REFNIL) {
	luaL_unref(parent->state, LUA_REGISTRYINDEX, func);
	}
	for (int a : arguments) {
	if (a != LUA_REFNIL) {
	luaL_unref(parent->state, LUA_REGISTRYINDEX, a);
	}
	}
	}

	func = LUA_REFNIL;
	arguments.clear();

	//Unlink from parent.
	if (index >= 0 && index < (int)parent->objects.size()) {
	assert(parent->objects[index] == this);
	parent->objects[index] = NULL;
	}
	}

	void ScriptDelayExecution::execute() {
	lua_State *state = parent->state;

	assert(state != NULL);

	//Check if reference is empty.
	if (func == LUA_REFNIL) return;

	//Get the function
	lua_rawgeti(state, LUA_REGISTRYINDEX, func);

	//Check if it's function.
	if (!lua_isfunction(state, -1)) {
	return;
	}

	//Backup the old "this"
	lua_getglobal(state, "this");
	int oldThisIndex = luaL_ref(state, LUA_REGISTRYINDEX);

	//Set the new "this" to ourself.
	createUserData(state, "delayExecution");
	lua_setglobal(state, "this");

	//Push arguments to stack.
	for (int a : arguments) {
	lua_rawgeti(state, LUA_REGISTRYINDEX, a);
	}

	//Now execute the script on the top of Lua stack.
	//WARNING: After this point we may get deleted, so don't use any member variables.
	int ret = lua_pcall(state, arguments.size(), 0, 0);

	//Restore "this" back to oringinal value.
	lua_rawgeti(state, LUA_REGISTRYINDEX, oldThisIndex);
	luaL_unref(state, LUA_REGISTRYINDEX, oldThisIndex);
	lua_setglobal(state, "this");

	//Check if there's an error.
	if (ret != LUA_OK){
	std::cerr << "LUA ERROR: " << lua_tostring(state, -1) << std::endl;
	return;
	}
	}

	void ScriptDelayExecution::updateTimer() {
	//Check if we are enabled.
	if (!enabled) return;

	//Sanity check for repeat interval.
	if (repeatInterval <= 0) {
	if (repeatCount != 0) repeatCount = 1;
	}

	//Check if we should delete ourself.
	if (repeatCount == 0) {
	delete this;
	return;
	}

	bool shouldExecute = (--time) <= 0;

	if (shouldExecute) {
	//Decrease the repeat count if it's not infinity.
	if (repeatCount > 0) repeatCount--;

	//Reset the timer, if repeat interval is invalid we set it to a big enough number.
	time = (repeatInterval <= 0) ? 0x40000000 : repeatInterval;

	//Increase the execution time.
	executionTime++;

	//Now execute the script on the top of Lua stack.
	//WARNING: After this point we may get deleted, so don't use any member variables.
	execute();
	}
	}

	ScriptDelayExecutionList::ScriptDelayExecutionList()
	: state(NULL)
	{
	}

	ScriptDelayExecutionList::ScriptDelayExecutionList(const ScriptDelayExecutionList& other)
	: state(other.state)
	{
	assert(state != NULL);

	for (auto obj : other.objects) {
	if (obj) {
	//Create new object, which will be inserted in the object list automatically.
	new ScriptDelayExecution(this, *obj);
	}
	}
	}

	ScriptDelayExecutionList::~ScriptDelayExecutionList() {
	destroy();
	}

	void ScriptDelayExecutionList::destroy() {
	//This will make the code in ScriptDelayExecution::~ScriptDelayExecution() runs faster.
	decltype(objects) tmp;
	std::swap(tmp, objects);

	for (auto obj : tmp) {
	delete obj;
	}
	}

	void ScriptDelayExecutionList::updateTimer() {
	assert(state != NULL);

	//Get the number of objects we are going to process.
	//NOTE: We get this number at the beginning, since during execution new objects may come in, and we don't process newly added objects.
	int m = objects.size();

	for (int i = 0; i < m; i++) {
	if (objects[i]) objects[i]->updateTimer();
	}

	//Now remove the deleted objects in the list.
	int j = 0;
	- m = objects.size();
	+ m = objects.size(); //Get the number of objects again since there may be newly added objects.
	for (int i = 0; i < m; i++) {
	if (objects[i] == NULL) {
	//We found an empty slot.
	j++;
	} else if (j > 0) {
	//We move the object to the empty slot and update the index of it.
	(objects[i - j] = objects[i])->index = i - j;
	}
	}

	//Resize the list if necessary.
	if (j > 0) {
	objects.resize(m - j);
	}
	}
	diff --git a/src/ScriptExecutor.cpp b/src/ScriptExecutor.cpp
	index 4e22457..6837e0e 100644
	--- a/src/ScriptExecutor.cpp
	+++ b/src/ScriptExecutor.cpp
	@@ -1,216 +1,216 @@
	/*
	* Copyright (C) 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/>.
	*/

	#include "ScriptExecutor.h"
	#include "ScriptDelayExecution.h"
	#include "ScriptAPI.h"
	#include "Block.h"
	#include <iostream>
	using namespace std;

	ScriptExecutor::ScriptExecutor()
	: state(NULL)
	, delayExecutionObjects(NULL), savedDelayExecutionObjects(NULL)
	{
	//NOTE: If a state is going to use the scriptExecutor it is his task to reset it.
	}

	ScriptExecutor::~ScriptExecutor(){
	destroy();
	}

	void ScriptExecutor::destroy() {
	//Make sure there is a state to close.
	if (state) {
	lua_close(state);
	state = NULL;
	}

	//Delete all delay execution objects.
	if (delayExecutionObjects) {
	// Set the state to NULL since the state is already destroyed. This prevents the destructor to call luaL_unref.
	delayExecutionObjects->state = NULL;
	delete delayExecutionObjects;
	delayExecutionObjects = NULL;
	}
	if (savedDelayExecutionObjects) {
	// Set the state to NULL since the state is already destroyed. This prevents the destructor to call luaL_unref.
	savedDelayExecutionObjects->state = NULL;
	delete savedDelayExecutionObjects;
	savedDelayExecutionObjects = NULL;
	}
	}

	void ScriptExecutor::reset(bool save){
	//Check if we only need to restore from saved state.
	if (!save && state) {
	//Delete delay execution objects.
	if (delayExecutionObjects) {
	delete delayExecutionObjects;
	delayExecutionObjects = new ScriptDelayExecutionList();
	delayExecutionObjects->state = state;
	}

	return;
	}

	//Close the lua_state, if any.
	destroy();

	//Create a new state.
	state=luaL_newstate();

	//Now load the lua libraries.
	//FIXME: Only allow safe libraries/functions.
	luaopen_base(state);
	luaL_requiref(state,"table",luaopen_table,1);
	- //SDL2 porting note. This library seems to have been deprecated.
	- //If this is used, it's possible to compile lua 5.3 in compatability mode
	- //that includes it.
	- //luaL_requiref(state,"bit32",luaopen_bit32,1);
	+ luaL_requiref(state,"coroutine",luaopen_coroutine,1);
	luaL_requiref(state,"string",luaopen_string,1);
	+ luaL_requiref(state,"utf8",luaopen_utf8,1);
	luaL_requiref(state,"math",luaopen_math,1);

	//Load our own libraries.
	luaL_requiref(state,"block",luaopen_block,1);
	luaL_requiref(state,"playershadow",luaopen_player,1);
	luaL_requiref(state,"level",luaopen_level,1);
	luaL_requiref(state,"camera",luaopen_camera,1);
	luaL_requiref(state,"audio",luaopen_audio,1);
	- luaL_requiref(state, "delayExecution", luaopen_delayExecution, 1);
	+ luaL_requiref(state,"delayExecution",luaopen_delayExecution,1);
	+ luaL_requiref(state,"gettext",luaopen_gettext,1);
	+ luaL_requiref(state,"prng",luaopen_prng,1);

	//Create a new delay execution list.
	delayExecutionObjects = new ScriptDelayExecutionList();
	delayExecutionObjects->state = state;
	}

	void ScriptExecutor::registerFunction(std::string name,lua_CFunction function){
	lua_register(state,name.c_str(),function);
	}

	int ScriptExecutor::compileScript(std::string script){
	//First make sure the stack is empty.
	lua_settop(state,0);

	//Compile the script.
	if(luaL_loadstring(state,script.c_str())!=LUA_OK){
	cerr<<"LUA ERROR: "<<lua_tostring(state,-1)<<endl;
	lua_pushnil(state);
	}

	//Save it to LUA_REGISTRYINDEX and return values.
	return luaL_ref(state,LUA_REGISTRYINDEX);
	}

	int ScriptExecutor::executeScript(std::string script,Block* origin){
	//First make sure the stack is empty.
	lua_settop(state,0);

	//Compile the script.
	if(luaL_loadstring(state,script.c_str())!=LUA_OK){
	cerr<<"LUA ERROR: "<<lua_tostring(state,-1)<<endl;
	return 0;
	}

	//Now execute the script.
	return executeScriptInternal(origin);
	}

	int ScriptExecutor::executeScript(int scriptIndex,Block* origin){
	//Check if reference is empty.
	if(scriptIndex==LUA_REFNIL) return 0;

	//Make sure the stack is empty.
	lua_settop(state,0);

	//Get the function
	lua_rawgeti(state,LUA_REGISTRYINDEX,scriptIndex);

	//Check if it's function and run.
	if(lua_isfunction(state,-1)){
	return executeScriptInternal(origin);
	}

	return 0;
	}

	int ScriptExecutor::executeScriptInternal(Block* origin){
	int oldThisIndex = LUA_REFNIL;

	//If the origin isn't null set it in the global scope.
	if(origin){
	//Backup the old "this"
	lua_getglobal(state, "this");
	oldThisIndex = luaL_ref(state, LUA_REGISTRYINDEX);

	origin->createUserData(state,"block");
	lua_setglobal(state,"this");
	}

	//Now execute the script on the top of Lua stack.
	int ret=lua_pcall(state,0,1,0);

	//If we set an origin set it back to oringinal value.
	if(origin){
	lua_rawgeti(state, LUA_REGISTRYINDEX, oldThisIndex);
	luaL_unref(state, LUA_REGISTRYINDEX, oldThisIndex);
	lua_setglobal(state,"this");
	}

	//Check if there's an error.
	if(ret!=LUA_OK){
	cerr<<"LUA ERROR: "<<lua_tostring(state,-1)<<endl;
	return 0;
	}

	//Get the return value.
	- return lua_tonumber(state,-1);
	+ return lua_tointeger(state,-1);
	}

	ScriptDelayExecutionList* ScriptExecutor::getDelayExecutionList() {
	return delayExecutionObjects;
	}

	void ScriptExecutor::processDelayExecution() {
	if (delayExecutionObjects) delayExecutionObjects->updateTimer();
	}

	void ScriptExecutor::saveState() {
	if (savedDelayExecutionObjects) {
	delete savedDelayExecutionObjects;
	savedDelayExecutionObjects = NULL;
	}
	savedDelayExecutionObjects = new ScriptDelayExecutionList(*delayExecutionObjects);
	}

	void ScriptExecutor::loadState() {
	if (delayExecutionObjects) {
	delete delayExecutionObjects;
	delayExecutionObjects = NULL;
	}
	if (savedDelayExecutionObjects) {
	delayExecutionObjects = new ScriptDelayExecutionList(*savedDelayExecutionObjects);
	for (auto obj : delayExecutionObjects->objects) {
	obj->setActive();
	}
	} else {
	delayExecutionObjects = new ScriptDelayExecutionList();
	delayExecutionObjects->state = state;
	}
	}
	diff --git a/src/ScriptUserData.cpp b/src/ScriptUserData.cpp
	index 79ccfbd..8d85bdf 100644
	--- a/src/ScriptUserData.cpp
	+++ b/src/ScriptUserData.cpp
	@@ -1,25 +1,24 @@
	#include "ScriptUserData.h"
	#include <stdio.h>

	//Some debug functions
	void scriptUserClassDebugCreate(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2) {
	#if defined(DISABLED_DEBUG_STUFF)
	printf("ScriptUserClass '%c%c%c%c' (%p) created userdata: %p\n",
	sig1,sig2,sig3,sig4,p1,p2);
	#endif
	}

	void scriptUserClassDebugInvalidate(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2) {
	#if defined(DISABLED_DEBUG_STUFF)
	printf("ScriptUserClass '%c%c%c%c' (%p) invalidated userdata: %p\n",
	sig1,sig2,sig3,sig4,p1,p2);
	#endif
	}

	void scriptUserClassDebugUnlink(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2) {
	#if defined(DISABLED_DEBUG_STUFF)
	printf("ScriptUserClass '%c%c%c%c' (%p) unlinked userdata: %p\n",
	sig1,sig2,sig3,sig4,p1,p2);
	#endif
	}
	-
	diff --git a/src/ScriptUserData.h b/src/ScriptUserData.h
	index 0d490cc..4287b8b 100644
	--- a/src/ScriptUserData.h
	+++ b/src/ScriptUserData.h
	@@ -1,262 +1,366 @@
	/*
	* Copyright (C) 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 SCRIPTUSERDATA_H
	#define SCRIPTUSERDATA_H

	extern "C" {
	#include "lua.h"
	#include "lualib.h"
	#include "lauxlib.h"
	}
	#include <string>
	#include <memory>

	#include <assert.h>

	//NOTE: Enable this you'll see a lot of annoying script debug messages which will lag the game.
	//#define DISABLED_DEBUG_STUFF

	#if defined(DISABLED_DEBUG_STUFF)
	//Some debug functions
	void scriptUserClassDebugCreate(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2);
	void scriptUserClassDebugInvalidate(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2);
	void scriptUserClassDebugUnlink(char sig1,char sig2,char sig3,char sig4,const void* p1,const void* p2);
	#endif

	//A struct represents the Lua user data.
	struct ScriptUserData{
	char sig1,sig2,sig3,sig4;
	void* data;
	ScriptUserData* prev;
	ScriptUserData* next;
	};

	//A helper class to bind C++ class to Lua user data.
	template<char sig1,char sig2,char sig3,char sig4,class T>
	class ScriptUserClass{
	public:
	ScriptUserClass():scriptUserDataHead(NULL){
	}

	ScriptUserClass(const ScriptUserClass& other) = delete;

	ScriptUserClass& operator=(const ScriptUserClass& other) = delete;

	//Create a Lua user data pointed to this object. (-0,+1,e)
	//state: Lua state.
	//metatableName: Metatable name.
	void createUserData(lua_State* state,const char* metatableName){
	- //Convert this object to T.
	- //NOTE: we omit the runtime safety check, only leave the compile time check (by static_cast).
	- T* obj=static_cast<T*>(this);
	-
	//Create user data.
	ScriptUserData* ud=(ScriptUserData*)lua_newuserdata(state,sizeof(ScriptUserData));

	- ud->sig1=sig1;
	- ud->sig2=sig2;
	- ud->sig3=sig3;
	- ud->sig4=sig4;
	- ud->data=obj;
	-
	//Add it to the linked list.
	- ud->next=scriptUserDataHead;
	- ud->prev=NULL;
	- if(scriptUserDataHead) scriptUserDataHead->prev=ud;
	- scriptUserDataHead=ud;
	+ linkUserData(ud);

	//Set matatable and we are done.
	luaL_getmetatable(state,metatableName);
	lua_setmetatable(state,-2);
	-
	-#if defined(DISABLED_DEBUG_STUFF)
	- scriptUserClassDebugCreate(sig1,sig2,sig3,sig4,this,ud);
	-#endif
	}

	//Destroys all Lua user data associated to this object.
	void destroyUserData(){
	while(scriptUserDataHead){
	#if defined(DISABLED_DEBUG_STUFF)
	scriptUserClassDebugInvalidate(sig1,sig2,sig3,sig4,this,scriptUserDataHead);
	#endif
	scriptUserDataHead->data=NULL;
	scriptUserDataHead=scriptUserDataHead->next;
	}
	}

	//Convert a Lua user data in Lua stack to object. (-0,+0,e)
	//state: Lua state.
	//idx: Index.
	//Returns: The object. NULL if this user data is invalid.
	//NOTE: This data should be a user data.
	static T* getObjectFromUserData(lua_State* state,int idx){
	ScriptUserData* ud=(ScriptUserData*)lua_touserdata(state,idx);

	- if(ud && ud->sig1==sig1 && ud->sig2==sig2 && ud->sig3==sig3 && ud->sig4==sig4)
	+ return getObjectFromUserData(ud);
	+ }
	+
	+ //Convert a ScriptUserData to object.
	+ static T* getObjectFromUserData(ScriptUserData* ud) {
	+ if (ud && ud->sig1 == sig1 && ud->sig2 == sig2 && ud->sig3 == sig3 && ud->sig4 == sig4)
	return reinterpret_cast<T*>(ud->data);
	return NULL;
	}

	//Register __gc, __eq to given table. (-0,+0,e)
	//state: Lua state.
	//idx: Index.
	static void registerMetatableFunctions(lua_State *state,int idx){
	lua_pushstring(state,"__gc");
	lua_pushcfunction(state,&garbageCollectorFunction);
	lua_rawset(state,idx);
	lua_pushstring(state,"__eq");
	lua_pushcfunction(state,&checkEqualFunction);
	lua_rawset(state,idx);
	}

	virtual ~ScriptUserClass(){
	destroyUserData();
	}
	+
	+ class ObservePointer;
	+ friend class ObservePointer;
	+
	+ //Reinventing the wheel of std::weak_ptr.
	+ class ObservePointer {
	+ private:
	+ ScriptUserData* ud;
	+ public:
	+ ObservePointer() : ud(NULL) {}
	+ ObservePointer(const ObservePointer& other) : ud(NULL) {
	+ (*this) = other;
	+ }
	+ ObservePointer(const T* obj) : ud(NULL) {
	+ (*this) = obj;
	+ }
	+ ~ObservePointer() {
	+ ScriptUserClass::unlinkUserData(ud);
	+ if (ud) delete ud;
	+ }
	+ ObservePointer& operator=(const T* obj) {
	+ if (ScriptUserClass::getObjectFromUserData(ud) == obj) return *this;
	+
	+ //Unlink old one
	+ ScriptUserClass::unlinkUserData(ud);
	+
	+ //Sanity check
	+ assert(ud == NULL \|\| ud->data == NULL);
	+
	+ //Link new one
	+ if (obj) {
	+ if (ud == NULL) ud = new ScriptUserData;
	+ const_cast<T*>(obj)->linkUserData(ud);
	+ } else if (ud) {
	+ ud->data = NULL;
	+ }
	+
	+ return *this;
	+ }
	+ ObservePointer& operator=(const ObservePointer& other) {
	+ if (this == &other) return *this;
	+ (*this) = const_cast<ObservePointer&>(other).get();
	+ return *this;
	+ }
	+ T* get() const {
	+ return ScriptUserClass::getObjectFromUserData(const_cast<ScriptUserData*>(ud));
	+ }
	+ void swap(ObservePointer& other) {
	+ std::swap(ud, other.ud);
	+ }
	+ };
	private:
	ScriptUserData* scriptUserDataHead;

	- //The garbage collector (__gc) function.
	- static int garbageCollectorFunction(lua_State* state){
	- //Check if it's a user data. It can be a table (the library itself)
	- if(!lua_isuserdata(state,1)) return 0;
	+ //Fill the user data and add it to the linked list.
	+ void linkUserData(ScriptUserData* ud) {
	+ //Convert this object to T.
	+ //NOTE: we omit the runtime safety check, only leave the compile time check (by static_cast).
	+ T* obj = static_cast<T*>(this);

	- ScriptUserData* ud=(ScriptUserData*)lua_touserdata(state,1);
	+ ud->sig1 = sig1;
	+ ud->sig2 = sig2;
	+ ud->sig3 = sig3;
	+ ud->sig4 = sig4;
	+ ud->data = obj;
	+
	+ //Add it to the linked list.
	+ ud->next = scriptUserDataHead;
	+ ud->prev = NULL;
	+ if (scriptUserDataHead) scriptUserDataHead->prev = ud;
	+ scriptUserDataHead = ud;
	+
	+#if defined(DISABLED_DEBUG_STUFF)
	+ scriptUserClassDebugCreate(sig1, sig2, sig3, sig4, this, ud);
	+#endif
	+ }

	- if(ud){
	- if(ud->data){
	+ //Unlink the user data from the linked list.
	+ static void unlinkUserData(ScriptUserData* ud) {
	+ if (ud) {
	+ if (ud->data) {
	//It should be impossible unless there is a bug in code
	- assert(ud->sig1==sig1 && ud->sig2==sig2 && ud->sig3==sig3 && ud->sig4==sig4);
	+ assert(ud->sig1 == sig1 && ud->sig2 == sig2 && ud->sig3 == sig3 && ud->sig4 == sig4);

	//Unlink it
	- if(ud->next) ud->next->prev=ud->prev;
	- if(ud->prev) ud->prev->next=ud->next;
	- else{
	- ScriptUserClass* owner=static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data));
	- owner->scriptUserDataHead=ud->next;
	+ if (ud->next) ud->next->prev = ud->prev;
	+ if (ud->prev) ud->prev->next = ud->next;
	+ else {
	+ ScriptUserClass* owner = static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data));
	+ owner->scriptUserDataHead = ud->next;
	}
	#if defined(DISABLED_DEBUG_STUFF)
	- scriptUserClassDebugUnlink(sig1,sig2,sig3,sig4,
	- static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data)),ud);
	+ scriptUserClassDebugUnlink(sig1, sig2, sig3, sig4,
	+ static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data)), ud);
	#endif
	}

	- ud->data=NULL;
	- ud->next=NULL;
	- ud->prev=NULL;
	+ ud->data = NULL;
	+ ud->next = NULL;
	+ ud->prev = NULL;
	}
	+ }
	+
	+ //The garbage collector (__gc) function.
	+ static int garbageCollectorFunction(lua_State* state){
	+ //Check if it's a user data. It can be a table (the library itself)
	+ if(!lua_isuserdata(state,1)) return 0;
	+
	+ ScriptUserData* ud=(ScriptUserData*)lua_touserdata(state,1);
	+
	+ unlinkUserData(ud);

	return 0;
	}

	//The 'operator==' (__eq) function.
	static int checkEqualFunction(lua_State* state){
	//Check if it's a user data. It can be a table (the library itself)
	if(!lua_isuserdata(state,1) \|\| !lua_isuserdata(state,2)) return 0;

	ScriptUserData* ud1=(ScriptUserData*)lua_touserdata(state,1);
	ScriptUserData* ud2=(ScriptUserData*)lua_touserdata(state,2);

	if(ud1!=NULL && ud2!=NULL){
	//It should be impossible unless there is a bug in code
	assert(ud1->sig1==sig1 && ud1->sig2==sig2 && ud1->sig3==sig3 && ud1->sig4==sig4);
	assert(ud2->sig1==sig1 && ud2->sig2==sig2 && ud2->sig3==sig3 && ud2->sig4==sig4);

	lua_pushboolean(state,ud1->data==ud2->data);
	return 1;
	}

	return 0;
	}
	};

	//Another helper class to bind C++ class to Lua user data.
	//This allows dynamic changes of the pointer which pointing to the actual C++ class.
	//Typical use case is a class which can dynamically create/delete during game running and has save/load feature.
	template<char sig1, char sig2, char sig3, char sig4, class T>
	class ScriptProxyUserClass {
	public:
	//The default constructor, which creates a new proxy object.
	ScriptProxyUserClass() : proxy(new Proxy()) {
	}

	//The copy constructor, which reuses proxy object from existing one.
	//NOTE: You must call this function in your copy constructor!!!
	ScriptProxyUserClass(const ScriptProxyUserClass& other) : proxy(other.proxy) {
	}

	ScriptProxyUserClass& operator=(const ScriptProxyUserClass& other) = delete;

	virtual ~ScriptProxyUserClass() {
	if (proxy->object == static_cast<T*>(this)) {
	proxy->object = NULL;
	}
	}

	//Set current object as active object, i.e. accessible from Lua.
	//Usually called when the object is created at the first time, or when the game is loaded.
	void setActive() {
	proxy->object = static_cast<T*>(this);
	}

	//Create a Lua user data pointed to this object. (-0,+1,e)
	//state: Lua state.
	//metatableName: Metatable name.
	void createUserData(lua_State* state, const char* metatableName) {
	- assert(proxy->object == static_cast<T*>(this));
	+ assert(proxy->object == NULL \|\| proxy->object == static_cast<T*>(this));
	proxy->createUserData(state, metatableName);
	}

	//Convert a Lua user data in Lua stack to object. (-0,+0,e)
	//state: Lua state.
	//idx: Index.
	//Returns: The object. NULL if this user data is invalid.
	//NOTE: This data should be a user data.
	static T* getObjectFromUserData(lua_State* state, int idx) {
	Proxy *p = Proxy::getObjectFromUserData(state, idx);
	if (p == NULL) return NULL;
	return p->object;
	}

	//Register __gc, __eq to given table. (-0,+0,e)
	//state: Lua state.
	//idx: Index.
	static void registerMetatableFunctions(lua_State *state, int idx) {
	Proxy::registerMetatableFunctions(state, idx);
	}

	-private:
	class Proxy : public ScriptUserClass<sig1, sig2, sig3, sig4, Proxy> {
	friend class ScriptProxyUserClass;
	public:
	- Proxy() : object(NULL) {
	- }
	+ Proxy() : object(NULL) {}

	- virtual ~Proxy() {
	+ virtual ~Proxy() {}
	+
	+ T *get() {
	+ return object;
	}

	- private:
	+ public:
	T *object;
	};

	std::shared_ptr<Proxy> proxy;
	+
	+ class ObservePointer;
	+ friend class ObservePointer;
	+
	+ //Reinventing the wheel of std::weak_ptr.
	+ class ObservePointer {
	+ private:
	+ typename Proxy::ObservePointer proxy;
	+ public:
	+ ObservePointer() {}
	+ ObservePointer(const ObservePointer& other) : proxy(other.proxy) {}
	+ ObservePointer(const T* obj) : proxy(obj ? obj->proxy.get() : NULL) {}
	+ ~ObservePointer() {}
	+ ObservePointer& operator=(const T* obj) {
	+ if (obj) {
	+ proxy = obj->proxy.get();
	+ } else {
	+ proxy = NULL;
	+ }
	+
	+ return *this;
	+ }
	+ ObservePointer& operator=(const ObservePointer& other) {
	+ if (this == &other) return *this;
	+ proxy = other.proxy;
	+ return *this;
	+ }
	+ T* get() const {
	+ Proxy *p = proxy.get();
	+ if (p) return p->get();
	+ return NULL;
	+ }
	+ void swap(ObservePointer& other) {
	+ proxy.swap(other.proxy);
	+ }
	+ };
	};

	#endif
	diff --git a/src/Shadow.h b/src/Shadow.h
	index 6776fce..7bfd9f9 100644
	--- a/src/Shadow.h
	+++ b/src/Shadow.h
	@@ -1,53 +1,53 @@
	/*
	* 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 SHADOW_H
	#define SHADOW_H

	#include "Player.h"

	//The shadow class, it extends the player class since their almost the same.
	class Shadow : public Player{
	protected:
	//Boolean if the shadow is called by the player.
	//If so the shadow will copy the moves the player made.
	bool called,calledSaved;

	friend class Player;
	public:
	//Constructor, it sets a few variables and calls the Player's constructor.
	//objParent: Pointer to the game instance.
	Shadow(Game* objParent);

	//Method that's called before the move function.
	//It's used to let the shadow do his logic, moving and jumping.
	void moveLogic();

	//Method used to notify the shadow that he is called.
	//He then must copy the moves that are given to him.
	void meCall();

	//Method used to reset the state.
	- virtual void stateReset();
	+ virtual void stateReset() override;
	//Method used to save the state.
	- virtual void saveState();
	+ virtual void saveState() override;
	//Method used to load the state.
	- virtual void loadState();
	+ virtual void loadState() override;
	};
	#endif
	diff --git a/src/StatisticsManager.cpp b/src/StatisticsManager.cpp
	index 4dd015c..5b0a7e9 100644
	--- a/src/StatisticsManager.cpp
	+++ b/src/StatisticsManager.cpp
	@@ -1,804 +1,804 @@
	/*
	* Copyright (C) 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/>.
	*/

	#include "StatisticsManager.h"
	#include "FileManager.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "Functions.h"
	#include "LevelPackManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include "ThemeManager.h"
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include <iostream>
	#include <fstream>
	#include <sstream>
	#include <vector>
	#include <map>
	#include "libs/tinyformat/tinyformat.h"
	#include <SDL_ttf.h>
	#if defined(WIN32)
	#define PRINTF_LONGLONG "%I64d"
	#else
	#define PRINTF_LONGLONG "%lld"
	#endif

	using namespace std;

	StatisticsManager statsMgr;

	static const int achievementDisplayTime=(FPS*4500)/1000;
	static const int achievementIntervalTime=achievementDisplayTime+(FPS*500)/1000;

	static map<string,AchievementInfo*> avaliableAchievements;

	//================================================================

	StatisticsManager::StatisticsManager(){
	bmDropShadow=NULL;
	bmQuestionMark=NULL;
	bmAchievement=NULL;

	startTime=time(NULL);

	tutorialLevels=0;

	clear();
	}

	void StatisticsManager::clear(){
	playerTravelingDistance=shadowTravelingDistance=0.0f;
	playerJumps=shadowJumps
	=playerDies=shadowDies
	=playerSquashed=shadowSquashed
	=completedLevels=silverLevels=goldLevels
	=recordTimes=switchTimes=swapTimes=saveTimes=loadTimes
	=playTime=levelEditTime
	=createdLevels=tutorialCompleted=tutorialGold=0;

	achievements.clear();
	queuedAchievements.clear();

	achievementTime=0;
	currentAchievement=0;
	if(bmAchievement){
	bmAchievement.reset();
	}
	}

	#define LOAD_STATS(var,func) { \
	vector<string> &v=node.attributes[ #var ]; \
	if(!v.empty() && !v[0].empty()) \
	var=func(v[0].c_str()); \
	}

	void StatisticsManager::loadFile(const std::string& fileName){
	clear();

	ifstream file(fileName.c_str());
	if(!file) return;

	TreeStorageNode node;
	POASerializer serializer;
	if(!serializer.readNode(file,&node,true)) return;

	//load statistics
	LOAD_STATS(playerTravelingDistance,atof);
	LOAD_STATS(shadowTravelingDistance,atof);
	LOAD_STATS(playerJumps,atoi);
	LOAD_STATS(shadowJumps,atoi);
	LOAD_STATS(playerDies,atoi);
	LOAD_STATS(shadowDies,atoi);
	LOAD_STATS(playerSquashed,atoi);
	LOAD_STATS(shadowSquashed,atoi);
	LOAD_STATS(recordTimes,atoi);
	LOAD_STATS(switchTimes,atoi);
	LOAD_STATS(swapTimes,atoi);
	LOAD_STATS(saveTimes,atoi);
	LOAD_STATS(loadTimes,atoi);
	LOAD_STATS(playTime,atoi);
	LOAD_STATS(levelEditTime,atoi);
	LOAD_STATS(createdLevels,atoi);

	//load achievements.
	//format is: name;time,name;time,...
	{
	vector<string> &v=node.attributes["achievements"];
	for(unsigned int i=0;i<v.size();i++){
	string s=v[i];
	time_t t=0;

	string::size_type lps=s.find(';');
	if(lps!=string::npos){
	string s1=s.substr(lps+1);
	s=s.substr(0,lps);

	long long n;
	sscanf(s1.c_str(),PRINTF_LONGLONG,&n);

	t=(time_t)n;
	}

	map<string,AchievementInfo*>::iterator it=avaliableAchievements.find(s);
	if(it!=avaliableAchievements.end()){
	OwnedAchievement ach={t,it->second};
	achievements[it->first]=ach;
	}
	}
	}
	}

	//Call when level edit is start
	void StatisticsManager::startLevelEdit(){
	levelEditStartTime=time(NULL);
	}

	//Call when level edit is end
	void StatisticsManager::endLevelEdit(){
	levelEditTime+=time(NULL)-levelEditStartTime;
	}

	//update in-game time
	void StatisticsManager::updatePlayTime(){
	time_t endTime=time(NULL);
	playTime+=endTime-startTime;
	startTime=endTime;
	}

	#define SAVE_STATS(var,pattern) { \
	sprintf(s,pattern,var); \
	node.attributes[ #var ].push_back(s); \
	}

	void StatisticsManager::saveFile(const std::string& fileName){
	char s[64];

	//update in-game time
	updatePlayTime();

	ofstream file(fileName.c_str());
	if(!file) return;

	TreeStorageNode node;

	//save statistics
	SAVE_STATS(playerTravelingDistance,"%.2f");
	SAVE_STATS(shadowTravelingDistance,"%.2f");
	SAVE_STATS(playerJumps,"%d");
	SAVE_STATS(shadowJumps,"%d");
	SAVE_STATS(playerDies,"%d");
	SAVE_STATS(shadowDies,"%d");
	SAVE_STATS(playerSquashed,"%d");
	SAVE_STATS(shadowSquashed,"%d");
	SAVE_STATS(recordTimes,"%d");
	SAVE_STATS(switchTimes,"%d");
	SAVE_STATS(swapTimes,"%d");
	SAVE_STATS(saveTimes,"%d");
	SAVE_STATS(loadTimes,"%d");
	SAVE_STATS(playTime,"%d");
	SAVE_STATS(levelEditTime,"%d");
	SAVE_STATS(createdLevels,"%d");

	//save achievements.
	//format is: name;time,name;time,...
	{
	vector<string>& v=node.attributes["achievements"];

	for(map<string,OwnedAchievement>::iterator it=achievements.begin();it!=achievements.end();++it){
	stringstream strm;
	char s[32];

	long long n=it->second.achievedTime;
	sprintf(s,PRINTF_LONGLONG,n);
	strm<<it->first<<";"<<s;

	v.push_back(strm.str());
	}
	}

	POASerializer serializer;
	serializer.writeNode(&node,file,true,true);
	}

	void StatisticsManager::loadPicture(SDL_Renderer& renderer, ImageManager& imageManager){
	//Load drop shadow picture
	bmDropShadow=imageManager.loadTexture(getDataPath()+"gfx/dropshadow.png", renderer);
	bmQuestionMark=imageManager.loadImage(getDataPath()+"gfx/menu/questionmark.png");
	}

	void StatisticsManager::registerAchievements(ImageManager& imageManager){
	if(!avaliableAchievements.empty()) return;

	for(int i=0;achievementList[i].id!=NULL;i++){
	avaliableAchievements[achievementList[i].id]=&achievementList[i];
	if(achievementList[i].imageFile!=NULL){
	achievementList[i].imageSurface = imageManager.loadImage(getDataPath()+achievementList[i].imageFile);
	}
	}
	}

	void StatisticsManager::render(ImageManager&,SDL_Renderer &renderer){
	if(achievementTime==0 && !bmAchievement && currentAchievement<(int)queuedAchievements.size()){
	//create surface
	bmAchievement=createAchievementSurface(renderer, queuedAchievements[currentAchievement++]);
	//FIXME: Draw the box.
	//drawGUIBox(0,0,bmAchievement->w,bmAchievement->h,bmAchievement,0xFFFFFF00);

	//check if queue is empty
	if(currentAchievement>=(int)queuedAchievements.size()){
	queuedAchievements.clear();
	currentAchievement=0;
	}

	//play a sound
	getSoundManager()->playSound("achievement", 1, false, 32);
	}

	//check if we need to display achievements
	if(bmAchievement){
	achievementTime++;
	if(achievementTime<=0){
	return;
	}else if(achievementTime<=5){
	drawAchievement(renderer,achievementTime);
	}else if(achievementTime<=achievementDisplayTime-5){
	drawAchievement(renderer,5);
	}else if(achievementTime<achievementDisplayTime){
	drawAchievement(renderer,achievementDisplayTime-achievementTime);
	}else if(achievementTime>=achievementIntervalTime){
	if(bmAchievement){
	bmAchievement.reset();
	}
	achievementTime=0;
	}
	}
	}

	void StatisticsManager::newAchievement(const std::string& id,bool save){
	//check avaliable achievements
	map<string,AchievementInfo*>::iterator it=avaliableAchievements.find(id);
	if(it==avaliableAchievements.end()) return;

	//check if already have this achievement
	if(save){
	map<string,OwnedAchievement>::iterator it2=achievements.find(id);
	if(it2!=achievements.end()) return;

	OwnedAchievement ach={time(NULL),it->second};
	achievements[id]=ach;
	}

	//add it to queue
	queuedAchievements.push_back(it->second);
	}

	time_t StatisticsManager::achievedTime(const std::string& id) {
	auto it = achievements.find(id);

	if (it == achievements.end()) return 0;
	else return it->second.achievedTime;
	}

	float StatisticsManager::getAchievementProgress(AchievementInfo* info){
	if(!strcmp(info->id,"experienced")){
	return float(completedLevels)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"expert")){
	return float(goldLevels)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"tutorial")){
	if(tutorialLevels>0)
	return float(tutorialCompleted)/float(tutorialLevels)*100.0f;
	else
	return 0.0f;
	}
	if(!strcmp(info->id,"tutorialGold")){
	if(tutorialLevels>0)
	return float(tutorialGold)/float(tutorialLevels)*100.0f;
	else
	return 0.0f;
	}
	- if(!strcmp(info->id,"create50")){
	- return float(createdLevels)/50.0f*100.0f;
	+ if(!strcmp(info->id,"create10")){
	+ return float(createdLevels)/10.0f*100.0f;
	}
	- if(!strcmp(info->id,"frog")){
	- return float(playerJumps+shadowJumps)/1000.0f*100.0f;
	+ if (!strcmp(info->id, "jump100")){
	+ return float(playerJumps + shadowJumps) / 100.0f*100.0f;
	+ }
	+ if (!strcmp(info->id, "jump1k")){
	+ return float(playerJumps + shadowJumps) / 1000.0f*100.0f;
	}
	if(!strcmp(info->id,"die50")){
	return float(playerDies+shadowDies)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"die1000")){
	return float(playerDies+shadowDies)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"suqash50")){
	return float(playerSquashed+shadowSquashed)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"travel100")){
	return (playerTravelingDistance+shadowTravelingDistance)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"travel1k")){
	return (playerTravelingDistance+shadowTravelingDistance)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"travel10k")){
	return (playerTravelingDistance+shadowTravelingDistance)/10000.0f*100.0f;
	}
	if(!strcmp(info->id,"travel42k")){
	return (playerTravelingDistance+shadowTravelingDistance)/42195.0f*100.0f;
	}
	if(!strcmp(info->id,"record100")){
	return float(recordTimes)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"record1k")){
	return float(recordTimes)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"switch100")){
	return float(switchTimes)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"switch1k")){
	return float(switchTimes)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"swap100")){
	return float(swapTimes)/100.0f*100.0f;
	}
	- if(!strcmp(info->id,"swap1k")){
	- return float(swapTimes)/1000.0f*100.0f;
	- }

	//not found
	return 0.0f;
	}

	SharedTexture StatisticsManager::createAchievementSurface(SDL_Renderer& renderer, AchievementInfo* info,SDL_Rect* rect,bool showTip,const time_t *achievedTime){
	if(info==NULL \|\| info->id==NULL) return NULL;

	//prepare text
	SurfacePtr title0(nullptr);
	SurfacePtr title1(nullptr);
	vector<SDL_Surface*> descSurfaces;
	SDL_Color fg = objThemes.getTextColor(true);
	int fontHeight=TTF_FontLineSkip(fontText);

	bool showDescription=false;
	bool showImage=false;
	float achievementProgress=0.0f;

	if(showTip){
	title0.reset(TTF_RenderUTF8_Blended(fontText,_("New achievement:"),fg));
	title1.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));
	showDescription=showImage=true;
	}else if(achievedTime){
	char s[256];
	strftime(s,sizeof(s),"%c",localtime(achievedTime));

	title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));
	title1.reset(TTF_RenderUTF8_Blended(fontText, tfm::format(_("Achieved on %s"), (char*)s).c_str(), fg));
	showDescription=showImage=true;
	}else if(info->displayStyle==ACHIEVEMENT_HIDDEN){
	title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_("Unknown achievement"),fg));
	}else{
	if(info->displayStyle==ACHIEVEMENT_PROGRESS){
	achievementProgress=getAchievementProgress(info);

	title1.reset(TTF_RenderUTF8_Blended(fontText, tfm::format(_("Achieved %1.0f%%"), achievementProgress).c_str(), fg));
	}else{
	title1.reset(TTF_RenderUTF8_Blended(fontText,_("Not achieved"),fg));
	}

	title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));

	showDescription= info->displayStyle==ACHIEVEMENT_ALL \|\| info->displayStyle==ACHIEVEMENT_PROGRESS;
	showImage=true;
	}

	if(info->description!=NULL && showDescription){
	string description=_(info->description);
	string::size_type lps=0,lpe;
	for(;;){
	lpe=description.find('\n',lps);
	if(lpe==string::npos){
	descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText,(description.substr(lps)+' ').c_str(),fg));
	break;
	}else{
	descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText,(description.substr(lps,lpe-lps)+' ').c_str(),fg));
	lps=lpe+1;
	}
	}
	}

	//calculate the size
	int w=0,h=0,w1=8,h1=0;

	if(title0!=NULL){
	if(title0->w>w) w=title0->w;
	h1+=title0->h;
	}
	if(title1!=NULL){
	if(title1->w>w) w=title1->w;
	h1+=title1->h;
	/*//calc progress bar size
	if(!showTip && !achievedTime && info->displayStyle==ACHIEVEMENT_PROGRESS){
	h1+=4;
	}*/
	}

	const int preferredImageWidth = 50;
	const int preferredImageHeight = 50;

	if(showImage){
	if(info->imageSurface!=NULL){
	// NEW: we have the preferred image size
	const int width = std::max(info->r.w, preferredImageWidth);
	const int height = std::max(info->r.h, preferredImageHeight);
	w1+=width+8;
	w+=width+8;
	if(height>h1) h1=height;
	}
	}else{
	w1+=bmQuestionMark->w+8;
	w+=bmQuestionMark->w+8;
	if(bmQuestionMark->h>h1) h1=bmQuestionMark->h;
	}

	h=h1+8;
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	if(descSurfaces[i]->w>w) w=descSurfaces[i]->w;
	}
	}
	h+=descSurfaces.size()*fontHeight;
	w+=16;
	h+=16;

	//check if size is specified
	int left=0,top=0;
	if(rect!=NULL){
	//NOTE: SDL2 port. This was never used.
	/* if(surface!=NULL){
	left=rect->x;
	top=rect->y;
	}*/
	if(rect->w>0) w=rect->w;
	else rect->w=w;
	rect->h=h;
	}

	//create surface if necessary
	SurfacePtr surface = createSurface(w, h);
	std::unique_ptr<SDL_Renderer,decltype(&SDL_DestroyRenderer)> surfaceRenderer(
	SDL_CreateSoftwareRenderer(surface.get()), &SDL_DestroyRenderer);

	//draw background
	const SDL_Rect r={left,top,w,h};
	if(showTip \|\| achievedTime){
	SDL_FillRect(surface.get(),&r,SDL_MapRGB(surface->format,255,255,255));
	}else{
	SDL_FillRect(surface.get(),&r,SDL_MapRGB(surface->format,192,192,192));
	}

	//draw horizontal separator
	//FIXME: this is moved from StatisticsScreen::createGUI
	if (!showTip) {
	const SDL_Rect r0 = { left, top, w, 1 };
	const SDL_Rect r1 = { left, top + h - 2, w, 1 };
	const SDL_Rect r2 = { left, top + h - 1, w, 1 };
	Uint32 c0 = achievedTime ? SDL_MapRGB(surface->format, 224, 224, 224) : SDL_MapRGB(surface->format, 168, 168, 168);
	Uint32 c2 = achievedTime ? SDL_MapRGB(surface->format, 128, 128, 128) : SDL_MapRGB(surface->format, 96, 96, 96);
	SDL_FillRect(surface.get(), &r0, c0);
	SDL_FillRect(surface.get(), &r1, c0);
	SDL_FillRect(surface.get(), &r2, c2);
	}

	//draw picture
	if(showImage){
	if(info->imageSurface){
	// NEW: we have the preferred image size
	SDL_Rect r={left+8,top+8+(h1-info->r.h)/2,0,0};
	if (info->r.w < preferredImageWidth) r.x += (preferredImageWidth - info->r.w) / 2;
	SDL_BlitSurface(info->imageSurface,&info->r,surface.get(),&r);
	}
	}else{
	SDL_Rect r={left+8,top+8+(h1-bmQuestionMark->h)/2,0,0};
	SDL_BlitSurface(bmQuestionMark,NULL,surface.get(),&r);
	}

	//draw text
	h=8;
	if(title0){
	SDL_Rect r={left+w1,top+h,0,0};
	SDL_BlitSurface(title0.get(),NULL,surface.get(),&r);
	h+=title0->h;
	}
	if(title1){
	SDL_Rect r={left+w1,top+h,0,0};

	//Draw progress bar.
	if(!showTip && !achievedTime && info->displayStyle==ACHIEVEMENT_PROGRESS){
	//Draw borders.
	SDL_Rect r1={r.x,r.y,w-8-r.x,title1->h};
	drawGUIBox(r1.x,r1.y,r1.w,r1.h,*surfaceRenderer,0x1D);

	//Draw progress.
	r1.x++;
	r1.y++;
	r1.w=int(achievementProgress/100.0f*float(r1.w-2)+0.5f);
	r1.h-=2;

	SDL_SetRenderDrawColor(surfaceRenderer.get(),0,0,0,100);
	SDL_RenderFillRect(surfaceRenderer.get(),&r1);

	//shift the text a little bit (???)
	r.x+=2;
	r.y+=2;
	}

	//Draw text.
	SDL_BlitSurface(title1.get(),NULL,surface.get(),&r);
	}
	h=h1+16;
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	SDL_Rect r={left+8,top+h+static_cast<int>(i)*fontHeight,0,0};
	SDL_BlitSurface(descSurfaces[i],NULL,surface.get(),&r);
	}
	}

	//clean up
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	SDL_FreeSurface(descSurfaces[i]);
	}
	}
	//FIXME: Should we clear the vector here?



	//over
	return textureFromSurface(renderer, std::move(surface));
	}

	void StatisticsManager::drawAchievement(SDL_Renderer& renderer,int alpha){
	if(!bmAchievement \|\| alpha<=0) {
	return;
	}
	if(alpha>5) alpha=5;

	SDL_Rect r = rectFromTexture(*bmAchievement);
	int w=0,h=0;
	SDL_GetRendererOutputSize(&renderer, &w, &h);
	r.x = w-32-r.w;
	r.y = 32;

	SDL_SetTextureAlphaMod(bmAchievement.get(), alpha*40);
	applyTexture(r.x, r.y,bmAchievement, renderer);

	if(!bmDropShadow) {
	return;
	}

	//draw drop shadow - corner
	{
	int w1=r.w/2,w2=r.w-w1,h1=r.h/2,h2=r.h-h1;
	if(w1>16) w1=16;
	if(w2>16) w2=16;
	if(h1>16) h1=16;
	if(h2>16) h2=16;

	const int x=(5-alpha)*64;

	//top-left
	SDL_Rect r1={x,0,w1+16,h1+16};//),r2={r.x-16,r.y-16,0,0};
	SDL_Rect r2 ={r.x-16, r.y-16, r1.w, r1.h};
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//top-right
	r1.x=x+48-w2;r2.w=r1.w =w2+16;r2.x=r.x+r.w-w2;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom-right
	r1.y=48-h2;r2.h=r1.h=h2+16;r2.y=r.y+r.h-h2;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom-left
	r1.x=x;r2.w=r1.w=w1+16;r2.x=r.x-16;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	}
	//draw drop shadow - border
	int i=r.w-32;
	while(i>0){
	const int ii=i>128?128:i;

	//top
	SDL_Rect r1={0,256-alpha*16,ii,16};
	SDL_Rect r2={r.x+r.w-16-i,r.y-16,r1.w,r1.h};
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom
	r1.x=128;r2.y=r.y+r.h;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);

	i-=ii;
	}
	i=r.h-32;
	while(i>0){
	const int ii=i>128?128:i;

	//top
	SDL_Rect r1={512-alpha*16,0,16,ii};
	SDL_Rect r2={r.x-16,r.y+r.h-16-i, r1.w, r1.h};
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom
	r1.y=128;r2.x=r.x+r.w;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);

	i-=ii;
	}
	}

	void StatisticsManager::reloadCompletedLevelsAndAchievements(){
	completedLevels=silverLevels=goldLevels=0;

	LevelPackManager *lpm=getLevelPackManager();
	vector<pair<string,string> > v=lpm->enumLevelPacks();

	bool tutorial=false,tutorialIsGold=false;

	for(unsigned int i=0;i<v.size();i++){
	string& s=v[i].first;
	LevelPack *levels=lpm->getLevelPack(s);
	levels->loadProgress();

	bool b=false;
	if(s==lpm->tutorialLevelPackPath){
	tutorialLevels=levels->getLevelCount();
	tutorialCompleted=tutorialGold=0;
	b=tutorial=tutorialIsGold=true;
	}

	for(int n=0,m=levels->getLevelCount();n<m;n++){
	LevelPack::Level *lv=levels->getLevel(n);
	int medal=lv->won;
	if(medal){
	if(lv->targetTime<0 \|\| lv->time<=lv->targetTime)
	medal++;
	if(lv->targetRecordings<0 \|\| lv->recordings<=lv->targetRecordings)
	medal++;

	completedLevels++;
	if(b) tutorialCompleted++;
	if(medal==2) silverLevels++;
	if(medal==3){
	goldLevels++;
	if(b) tutorialGold++;
	}

	if(medal!=3 && b) tutorialIsGold=false;
	}else if(b){
	tutorial=tutorialIsGold=false;
	}
	}
	}

	//upadte achievements
	updateLevelAchievements();
	updateTutorialAchievementsInternal((tutorial?1:0)\|(tutorialIsGold?2:0));
	}

	void StatisticsManager::reloadOtherAchievements(){
	int i;

	if(playTime>=7200) newAchievement("addicted");
	if(playTime>=86400) newAchievement("loyalFan");

	if(levelEditTime>=7200) newAchievement("constructor");
	- if(levelEditTime>=86400) newAchievement("constructor2");
	+ if(levelEditTime>=28800) newAchievement("constructor2");

	if(createdLevels>=1) newAchievement("create1");
	- if(createdLevels>=50) newAchievement("create50");
	+ if(createdLevels>=10) newAchievement("create10");

	i=playerJumps+shadowJumps;
	- if(i>=1000) newAchievement("frog");
	+ if (i >= 100) newAchievement("jump100");
	+ if (i >= 1000) newAchievement("jump1k");

	i=playerDies+shadowDies;
	if(i>=1) newAchievement("die1");
	if(i>=50) newAchievement("die50");
	if(i>=1000) newAchievement("die1000");

	i=playerSquashed+shadowSquashed;
	if(i>=1) newAchievement("squash1");
	if(i>=50) newAchievement("squash50");

	float d=playerTravelingDistance+shadowTravelingDistance;
	if(d>=100.0f) newAchievement("travel100");
	if(d>=1000.0f) newAchievement("travel1k");
	if(d>=10000.0f) newAchievement("travel10k");
	if(d>=42195.0f) newAchievement("travel42k");

	if(recordTimes>=100) newAchievement("record100");
	if(recordTimes>=1000) newAchievement("record1k");

	if(switchTimes>=100) newAchievement("switch100");
	if(switchTimes>=1000) newAchievement("switch1k");

	if(swapTimes>=100) newAchievement("swap100");
	- if(swapTimes>=1000) newAchievement("swap1k");

	- if(saveTimes>=1000) newAchievement("save1k");
	+ if(saveTimes>=100) newAchievement("save100");

	- if(loadTimes>=1000) newAchievement("load1k");
	+ if(loadTimes>=100) newAchievement("load100");

	if (version.find("Development") != string::npos
	\|\| version.find("Alpha") != string::npos
	\|\| version.find("Beta") != string::npos
	\|\| version.find("RC") != string::npos
	\|\| version.find("Candidate") != string::npos)
	{
	newAchievement("programmer");
	}
	}

	//Update level specified achievements.
	//Make sure the completed level count is correct.
	void StatisticsManager::updateLevelAchievements(){
	if(completedLevels>=1) newAchievement("newbie");
	if(goldLevels>=1) newAchievement("goodjob");
	if(completedLevels>=50) newAchievement("experienced");
	if(goldLevels>=50) newAchievement("expert");
	}

	//Update tutorial specified achievements.
	//Make sure the level progress of tutorial is correct.
	void StatisticsManager::updateTutorialAchievements(){
	//find tutorial level pack
	LevelPackManager *lpm=getLevelPackManager();
	LevelPack *levels=lpm->getTutorialLevelPack();
	if(levels==NULL) return;

	bool tutorial=true,tutorialIsGold=true;
	tutorialLevels=levels->getLevelCount();
	tutorialCompleted=tutorialGold=0;

	for(int n=0,m=levels->getLevelCount();n<m;n++){
	LevelPack::Level *lv=levels->getLevel(n);
	int medal=lv->won;
	if(medal){
	if(lv->targetTime<0 \|\| lv->time<=lv->targetTime)
	medal++;
	if(lv->targetRecordings<0 \|\| lv->recordings<=lv->targetRecordings)
	medal++;

	tutorialCompleted++;

	if(medal!=3) tutorialIsGold=false;
	else tutorialGold++;
	}else{
	tutorial=tutorialIsGold=false;
	break;
	}
	}

	//upadte achievements
	updateTutorialAchievementsInternal((tutorial?1:0)\|(tutorialIsGold?2:0));
	}

	//internal function
	//flags: a bit-field value indicates which achievements we have.
	void StatisticsManager::updateTutorialAchievementsInternal(int flags){
	if(flags&1) newAchievement("tutorial");
	if(flags&2) newAchievement("tutorialGold");
	}
	diff --git a/src/ThemeManager.cpp b/src/ThemeManager.cpp
	index d0f0006..dcdcc91 100644
	--- a/src/ThemeManager.cpp
	+++ b/src/ThemeManager.cpp
	@@ -1,1620 +1,1581 @@
	/*
	* 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/>.
	*/

	#include "ThemeManager.h"
	#include "POASerializer.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Game.h"
	#include "ImageManager.h"

	#include <iostream>
	using namespace std;

	//The ThemeStack that is be used by the GameState.
	ThemeStack objThemes;

	ThemeObjectInstance::ThemeObjectInstance()
	- : picture(NULL), parent(NULL), animation(0), savedAnimation(0)
	+ : picture(NULL), parent(NULL), animation(0)
	{
	}

	-void ThemeObjectInstance::resetAnimation(bool save){
	- animation = 0;
	- if (save){
	- savedAnimation = 0;
	- }
	-}
	-
	-void ThemeObjectInstance::saveAnimation(){
	- savedAnimation = animation;
	-}
	-
	-void ThemeObjectInstance::loadAnimation(){
	- animation = savedAnimation;
	-}
	-
	ThemeBlockStateInstance::ThemeBlockStateInstance()
	- : parent(NULL), animation(0), savedAnimation(0)
	+ : parent(NULL), animation(0)
	{
	}

	void ThemeBlockStateInstance::draw(SDL_Renderer& renderer, int x, int y, int w, int h, const SDL_Rect *clipRect){
	for (unsigned int i = 0; i<objects.size(); i++){
	objects[i].draw(renderer, x, y, w, h, clipRect);
	}
	}

	void ThemeBlockStateInstance::updateAnimation(){
	for (unsigned int i = 0; i<objects.size(); i++){
	objects[i].updateAnimation();
	}
	animation++;
	}

	-void ThemeBlockStateInstance::resetAnimation(bool save){
	- for (unsigned int i = 0; i<objects.size(); i++){
	- objects[i].resetAnimation(save);
	- }
	- animation = 0;
	- if (save){
	- savedAnimation = 0;
	- }
	-}
	-
	-void ThemeBlockStateInstance::saveAnimation(){
	- for (unsigned int i = 0; i<objects.size(); i++){
	- objects[i].saveAnimation();
	- }
	- savedAnimation = animation;
	-}
	-
	-void ThemeBlockStateInstance::loadAnimation(){
	- for (unsigned int i = 0; i<objects.size(); i++){
	- objects[i].loadAnimation();
	- }
	- animation = savedAnimation;
	-}
	-
	ThemeBlockInstance::ThemeBlockInstance()
	- : currentState(NULL)
	+ : currentState(-1)
	{
	}

	bool ThemeBlockInstance::draw(SDL_Renderer& renderer, int x, int y, int w, int h, const SDL_Rect *clipRect){
	- if (currentState != NULL){
	- currentState->draw(renderer, x, y, w, h, clipRect);
	+ if (currentState >= 0 && currentState < (int)states.size()) {
	+ states[currentState].draw(renderer, x, y, w, h, clipRect);
	return true;
	}
	return false;
	}

	bool ThemeBlockInstance::drawState(const string& s, SDL_Renderer& renderer, int x, int y, int w, int h, SDL_Rect *clipRect){
	- map<string, ThemeBlockStateInstance>::iterator it = blockStates.find(s);
	- if (it != blockStates.end()){
	- it->second.draw(renderer, x, y, w, h, clipRect);
	+ auto it = blockStates.find(s);
	+ if (it != blockStates.end() && it->second >= 0 && it->second < (int)states.size()) {
	+ states[it->second].draw(renderer, x, y, w, h, clipRect);
	return true;
	}
	return false;
	}

	-bool ThemeBlockInstance::changeState(const string& s, bool reset){
	+bool ThemeBlockInstance::changeState(const string& s, bool reset, bool onlyIfStateChanged) {
	+ //Check if we don't need to change state at all.
	+ if (onlyIfStateChanged && s == currentStateName) {
	+ return true;
	+ }
	+
	bool newState = false;

	//First check if there's a transition.
	{
	- pair<string, string> s1 = pair<string, string>(currentStateName, s);
	- map<pair<string, string>, ThemeBlockStateInstance>::iterator it = transitions.find(s1);
	- if (it != transitions.end()){
	- currentState = &it->second;
	+ auto it = transitions.find(pair<string, string>(currentStateName, s));
	+ if (it != transitions.end() && it->second >= 0 && it->second < (int)states.size()) {
	+ currentState = it->second;
	//NOTE: We set the currentState name to target state name.
	//Worst case senario is that the animation is skipped when saving/loading at a checkpoint.
	currentStateName = s;
	newState = true;
	}
	}

	//If there isn't a transition go directly to the state.
	if (!newState){
	//Get the new state.
	- map<string, ThemeBlockStateInstance>::iterator it = blockStates.find(s);
	+ auto it = blockStates.find(s);
	//Check if it exists.
	- if (it != blockStates.end()){
	- currentState = &it->second;
	+ if (it != blockStates.end() && it->second >= 0 && it->second < (int)states.size()) {
	+ currentState = it->second;
	currentStateName = it->first;
	newState = true;
	}
	}

	//Check if a state has been found.
	if (newState){
	- //FIXME: Is it needed to set the savedStateName here?
	- if (savedStateName.empty())
	- savedStateName = currentStateName;
	-
	//If reset then reset the animation.
	- if (reset)
	- currentState->resetAnimation(true);
	+ if (reset) {
	+ ThemeBlockStateInstance &current = states[currentState];
	+ current.animation = 0;
	+ for (auto& obj : current.objects) {
	+ obj.animation = 0;
	+ }
	+ }
	return true;
	}

	//It doesn't so return false.
	return false;
	}

	-void ThemeBlockInstance::resetAnimation(bool save){
	- for (map<string, ThemeBlockStateInstance>::iterator it = blockStates.begin(); it != blockStates.end(); ++it){
	- it->second.resetAnimation(save);
	- }
	- if (save){
	- savedStateName.clear();
	- }
	-}
	-
	-void ThemeBlockInstance::saveAnimation(){
	- for (map<string, ThemeBlockStateInstance>::iterator it = blockStates.begin(); it != blockStates.end(); ++it){
	- it->second.saveAnimation();
	- }
	- savedStateName = currentStateName;
	-}
	-
	-void ThemeBlockInstance::loadAnimation(){
	- for (map<string, ThemeBlockStateInstance>::iterator it = blockStates.begin(); it != blockStates.end(); ++it){
	- it->second.loadAnimation();
	- }
	- changeState(savedStateName, false);
	-}
	-
	ThemeOffsetData::ThemeOffsetData()
	: length(0)
	{
	}

	void ThemeOffsetData::destroy(){
	//Set length to zero.
	length = 0;
	//And clear the offsetData vector.
	offsetData.clear();
	}

	//Constructor.
	ThemePositioningData::ThemePositioningData()
	: horizontalAlign(REPEAT), verticalAlign(REPEAT)
	{
	}

	//Method used to destroy the positioningData.
	void ThemePositioningData::destroy(){
	horizontalAlign = REPEAT;
	verticalAlign = REPEAT;
	}

	ThemePicture::ThemePicture()
	:texture(NULL)//, x(0), y(0)
	{
	}

	void ThemePicture::destroy(){
	//Freeing handled by ImageManager.
	//TODO: Unload unused images
	texture = NULL;
	//Destroy the offset data.
	offset.destroy();
	}

	ThemeObject::ThemeObject()
	:animationLength(0), animationLoopPoint(0), invisibleAtRunTime(false), invisibleAtDesignTime(false)
	{
	}

	ThemeObject::~ThemeObject(){
	//Loop through the optionalPicture and delete them.
	for (unsigned int i = 0; i<optionalPicture.size(); i++){
	delete optionalPicture[i].second;
	}
	}

	void ThemeObject::destroy(){
	//Loop through the optionalPicture and delete them.
	for (unsigned int i = 0; i<optionalPicture.size(); i++){
	delete optionalPicture[i].second;
	}
	optionalPicture.clear();
	animationLength = 0;
	animationLoopPoint = 0;
	invisibleAtRunTime = false;
	invisibleAtDesignTime = false;
	picture.destroy();
	editorPicture.destroy();
	offset.destroy();
	positioning.destroy();
	}

	ThemeBlockState::ThemeBlockState()
	:oneTimeAnimationLength(0)
	{
	}

	ThemeBlockState::~ThemeBlockState(){
	//Loop through the ThemeObjects and delete them.
	for (unsigned int i = 0; i<themeObjects.size(); i++){
	delete themeObjects[i];
	}
	}

	void ThemeBlockState::destroy(){
	//Loop through the ThemeObjects and delete them.
	for (unsigned int i = 0; i<themeObjects.size(); i++){
	delete themeObjects[i];
	}
	//Clear the themeObjects vector.
	themeObjects.clear();
	//Set the length to 0.
	oneTimeAnimationLength = 0;
	//Clear the nextState string.
	nextState.clear();
	}

	ThemeBlock::ThemeBlock()
	{
	}

	ThemeBlock::~ThemeBlock(){
	//Loop through the ThemeBlockStates and delete them,
	for (map<string, ThemeBlockState*>::iterator i = blockStates.begin(); i != blockStates.end(); ++i){
	delete i->second;
	}
	//Loop through the ThemeBlockStates and delete them,
	for (map<pair<string, string>, ThemeBlockState*>::iterator i = transitions.begin(); i != transitions.end(); ++i){
	delete i->second;
	}
	}

	void ThemeBlock::destroy(){
	//Loop through the ThemeBlockStates and delete them,
	for (map<string, ThemeBlockState*>::iterator i = blockStates.begin(); i != blockStates.end(); ++i){
	delete i->second;
	}
	//Loop through the ThemeBlockStates transitions and delete them,
	for (map<pair<string, string>, ThemeBlockState*>::iterator i = transitions.begin(); i != transitions.end(); ++i){
	delete i->second;
	}
	//Clear the blockStates map.
	blockStates.clear();
	transitions.clear();
	editorPicture.destroy();
	}

	ThemeBackgroundPicture::ThemeBackgroundPicture(){
	//Set some default values.
	texture = NULL;
	memset(&srcSize, 0, sizeof(srcSize));
	memset(&destSize, 0, sizeof(destSize));
	memset(&cachedSrcSize, 0, sizeof(cachedSrcSize));
	memset(&cachedDestSize, 0, sizeof(cachedDestSize));
	scale = true;
	repeatX = true;
	repeatY = true;
	speedX = 0.0f;
	speedY = 0.0f;
	cameraX = 0.0f;
	cameraY = 0.0f;
	currentX = 0.0f;
	currentY = 0.0f;
	savedX = 0.0f;
	savedY = 0.0f;
	}

	void ThemeBackgroundPicture::updateAnimation(){
	//Move the picture along the x-axis.
	currentX += speedX;
	if (repeatX && destSize.w>0){
	float f = (float)destSize.w;
	if (currentX>f \|\| currentX<-f) currentX -= f*floor(currentX / f);
	}

	//Move the picture along the y-axis.
	currentY += speedY;
	if (repeatY && destSize.h>0){
	float f = (float)destSize.h;
	if (currentY>f \|\| currentY<-f) currentY -= f*floor(currentY / f);
	}
	}

	void ThemeBackgroundPicture::resetAnimation(bool save){
	currentX = 0.0f;
	currentY = 0.0f;
	if (save){
	savedX = 0.0f;
	savedY = 0.0f;
	}
	}

	void ThemeBackgroundPicture::saveAnimation(){
	savedX = currentX;
	savedY = currentY;
	}

	void ThemeBackgroundPicture::loadAnimation(){
	currentX = savedX;
	currentY = savedY;
	}

	void ThemeBackground::updateAnimation(){
	for (unsigned int i = 0; i<picture.size(); i++){
	picture[i].updateAnimation();
	}
	}

	void ThemeBackground::resetAnimation(bool save){
	for (unsigned int i = 0; i<picture.size(); i++){
	picture[i].resetAnimation(save);
	}
	}

	void ThemeBackground::saveAnimation(){
	for (unsigned int i = 0; i<picture.size(); i++){
	picture[i].saveAnimation();
	}
	}

	void ThemeBackground::loadAnimation(){
	for (unsigned int i = 0; i<picture.size(); i++){
	picture[i].loadAnimation();
	}
	}

	void ThemeBackground::scaleToScreen(){
	for (unsigned int i = 0; i<picture.size(); i++){
	picture[i].scaleToScreen();
	}
	}

	void ThemeBackground::draw(SDL_Renderer& renderer){
	for (unsigned int i = 0; i<picture.size(); i++){
	picture[i].draw(renderer);
	}
	}

	bool ThemeBackground::addPictureFromNode(TreeStorageNode* objNode, string themePath, ImageManager& imageManager, SDL_Renderer& renderer){
	picture.push_back(ThemeBackgroundPicture());
	return picture.back().loadFromNode(objNode, themePath, imageManager, renderer);
	}

	ThemeManager::ThemeManager(){
	//Make sure the pointers are set to NULL.
	objBackground = NULL;
	//Reserve enough memory for the ThemeBlocks.
	memset(objBlocks, 0, sizeof(objBlocks));
	shadow = NULL;
	player = NULL;
	menuBackground = NULL;
	menuBlock = NULL;
	menuShadowBlock = NULL;
	hasThemeTextColor = hasThemeTextColorDialog = false;
	}

	ThemeManager::~ThemeManager(){
	//Just call destroy().
	destroy();
	}

	void ThemeManager::destroy(){
	//Delete the ThemeBlock of the shadow.
	if (shadow) {
	delete shadow;
	shadow = NULL;
	}
	//Delete the ThemeBlock of the player.
	if (player) {
	delete player;
	player = NULL;
	}
	//Loop through the ThemeBlocks and delete them.
	for (int i = 0; i<TYPE_MAX; i++){
	if (objBlocks[i]) {
	delete objBlocks[i];
	objBlocks[i] = NULL;
	}
	}
	//Delete all scenery blocks
	for (auto it = objScenery.begin(); it != objScenery.end(); ++it) {
	delete it->second;
	}
	objScenery.clear();
	//Delete the ThemeBackgrounds, etc.
	if (objBackground) {
	delete objBackground;
	objBackground = NULL;
	}
	if (menuBackground) {
	delete menuBackground;
	menuBackground = NULL;
	}
	if (menuBlock) {
	delete menuBlock;
	menuBlock = NULL;
	}
	if (menuShadowBlock) {
	delete menuShadowBlock;
	menuShadowBlock = NULL;
	}

	//And clear the themeName, etc.
	themeName.clear();
	themePath.clear();
	}

	bool ThemeManager::loadFile(const string& fileName, ImageManager &imageManager, SDL_Renderer &renderer){
	POASerializer objSerializer;
	TreeStorageNode objNode;

	//First we destroy the current ThemeManager.
	destroy();

	//Now we try to load the file, if it fails we return false.
	if(!objSerializer.loadNodeFromFile(fileName.c_str(),&objNode,true)){
	cerr<<"ERROR: Unable to open theme file: "<<fileName<<endl;
	return false;
	}

	//Set the themePath.
	themePath=pathFromFileName(fileName);

	//Retrieve the name of the theme from the file.
	{
	vector<string> &v=objNode.attributes["name"];
	if(!v.empty()) themeName=v[0];
	}

	//Reset themeable colors to default
	hasThemeTextColor = hasThemeTextColorDialog = false;
	themeTextColor.r=themeTextColor.g=themeTextColor.b=0;
	themeTextColorDialog.r=themeTextColorDialog.g=themeTextColorDialog.b=0;

	//Read themeable colors if any
	vector<string> &ct=objNode.attributes["textColor"];
	if(!ct.empty()){
	hasThemeTextColor = true;
	themeTextColor.r=atoi(ct[0].c_str());
	themeTextColor.g=atoi(ct[1].c_str());
	themeTextColor.b=atoi(ct[2].c_str());
	}

	vector<string> &ct2=objNode.attributes["textColorDialog"];
	if(!ct2.empty()){
	hasThemeTextColorDialog = true;
	themeTextColorDialog.r=atoi(ct2[0].c_str());
	themeTextColorDialog.g=atoi(ct2[1].c_str());
	themeTextColorDialog.b=atoi(ct2[2].c_str());
	}

	//Loop the subnodes of the theme.
	for(unsigned int i=0;i<objNode.subNodes.size();i++){
	TreeStorageNode *obj=objNode.subNodes[i];

	//Check if it's a block or a background.
	if (obj->name == "block" && !obj->value.empty()){
	map<string, int>::iterator it = Game::blockNameMap.find(obj->value[0]);
	if (it != Game::blockNameMap.end()){
	int idx = it->second;
	if (!objBlocks[idx]) objBlocks[idx] = new ThemeBlock;
	if (!objBlocks[idx]->loadFromNode(obj, themePath, imageManager, renderer)){
	cerr << "ERROR: Unable to load " << Game::blockName[idx] << " for theme " << fileName << endl;
	delete objBlocks[idx];
	objBlocks[idx] = NULL;
	return false;
	}
	}
	} else if (obj->name == "scenery" && !obj->value.empty()){
	std::string& name = obj->value[0];
	if (!objScenery[name]) objScenery[name] = new ThemeBlock;
	if (!objScenery[name]->loadFromNode(obj, themePath, imageManager, renderer)){
	cerr << "ERROR: Unable to load scenery '" << name << "' for theme " << fileName << endl;
	delete objScenery[name];
	objScenery[name] = NULL;
	return false;
	}
	}else if(obj->name=="background" && !obj->value.empty()){
	if(!objBackground) objBackground=new ThemeBackground();
	if(!objBackground->addPictureFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load background for theme "<<fileName<<endl;
	delete objBackground;
	objBackground=NULL;
	return false;
	}
	}else if(obj->name=="character" && !obj->value.empty()){
	if(obj->value[0]=="Shadow"){
	if(!shadow) shadow=new ThemeBlock();
	if(!shadow->loadFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load shadow for theme "<<fileName<<endl;
	delete shadow;
	shadow=NULL;
	return false;
	}
	}else if(obj->value[0]=="Player"){
	if(!player) player=new ThemeBlock();
	if(!player->loadFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load player for theme "<<fileName<<endl;
	delete player;
	player=NULL;
	return false;
	}
	}
	}else if(obj->name=="menuBackground" && !obj->value.empty()){
	if(!menuBackground) menuBackground=new ThemeBackground();
	if(!menuBackground->addPictureFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load background for theme "<<fileName<<endl;
	delete menuBackground;
	menuBackground=NULL;
	return false;
	}
	}else if(obj->name=="menu" && obj->value[0]=="Block"){
	if(!menuBlock) menuBlock=new ThemeBlock;
	if(!menuBlock->loadFromNode(obj,themePath, imageManager, renderer)){
	cerr<<"ERROR: Unable to load menu block for theme "<<fileName<<endl;
	delete menuBlock;
	menuBlock=NULL;
	return false;
	}
	} else if (obj->name == "menu" && obj->value[0] == "ShadowBlock"){
	if (!menuShadowBlock) menuShadowBlock = new ThemeBlock;
	if (!menuShadowBlock->loadFromNode(obj, themePath, imageManager, renderer)){
	cerr << "ERROR: Unable to load menu shadow block for theme " << fileName << endl;
	delete menuShadowBlock;
	menuShadowBlock = NULL;
	return false;
	}
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	void ThemeManager::scaleToScreen(){
	//We only need to scale the background.
	if (objBackground)
	objBackground->scaleToScreen();
	}

	ThemeBlock* ThemeManager::getBlock(int index, bool menu){
	if (!menu)
	return objBlocks[index];
	else
	if (index == TYPE_BLOCK)
	if (menuBlock)
	return menuBlock;
	else
	return objBlocks[TYPE_BLOCK];
	else if (index == TYPE_SHADOW_BLOCK)
	if (menuShadowBlock)
	return menuShadowBlock;
	else if (menuBlock)
	return menuBlock;
	else
	return objBlocks[TYPE_SHADOW_BLOCK];
	else
	return objBlocks[index];
	}

	ThemeBlock* ThemeManager::getScenery(const std::string& name){
	auto it = objScenery.find(name);
	if (it == objScenery.end())
	return NULL;
	else
	return it->second;
	}

	void ThemeManager::getSceneryBlockNames(std::set<std::string> &s) {
	for (auto it = objScenery.begin(); it != objScenery.end(); ++it) {
	s.insert(it->first);
	}
	}

	ThemeBlock* ThemeManager::getCharacter(bool isShadow){
	if (isShadow)
	return shadow;
	return player;
	}

	ThemeBackground* ThemeManager::getBackground(bool menu){
	if (menu&&menuBackground)
	return menuBackground;
	else
	return objBackground;
	}

	bool ThemeManager::getTextColor(bool isDialog, SDL_Color& color) {
	if (isDialog) {
	if (hasThemeTextColorDialog) color = themeTextColorDialog;
	return hasThemeTextColorDialog;
	} else {
	if (hasThemeTextColor) color = themeTextColor;
	return hasThemeTextColor;
	}
	}

	bool ThemeBlock::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager &imageManager, SDL_Renderer &renderer){
	destroy();

	//Loop the subNodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode *obj=objNode->subNodes[i];

	//Check if the subnode is an editorPicture or a blockState.
	if(obj->name=="editorPicture"){
	if(!editorPicture.loadFromNode(obj,themePath, imageManager, renderer)) return false;
	//NOTE: blockState and characterState are for backwards compatability, use state instead.
	}else if((obj->name=="blockState" \|\| obj->name=="characterState" \|\| obj->name=="state") && !obj->value.empty()){
	string& s=obj->value[0];
	map<string,ThemeBlockState*>::iterator it=blockStates.find(s);
	if(it==blockStates.end()) blockStates[s]=new ThemeBlockState;
	if(!blockStates[s]->loadFromNode(obj,themePath, imageManager, renderer)) return false;
	}else if(obj->name=="transitionState" && obj->value.size()==2){
	pair<string,string> s=pair<string,string>(obj->value[0],obj->value[1]);
	map<pair<string,string>,ThemeBlockState*>::iterator it=transitions.find(s);
	if(it==transitions.end()) transitions[s]=new ThemeBlockState;
	if(!transitions[s]->loadFromNode(obj,themePath, imageManager, renderer)) return false;
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	bool ThemeBlockState::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager& imageManager, SDL_Renderer& renderer){
	destroy();

	//Retrieve the oneTimeAnimation attribute.
	{
	vector<string> &v=objNode->attributes["oneTimeAnimation"];

	//Check if there are enough values for the oneTimeAnimation attribute.
	if(v.size()>=2 && !v[0].empty()){
	oneTimeAnimationLength=atoi(v[0].c_str());
	nextState=v[1];
	}
	}

	//Loop the subNodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode *obj=objNode->subNodes[i];
	if(obj->name=="object"){
	ThemeObject *obj1=new ThemeObject();
	if(!obj1->loadFromNode(obj,themePath, imageManager, renderer)){
	delete obj1;
	return false;
	}
	themeObjects.push_back(obj1);
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	bool ThemeObject::loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer){
	destroy();

	//Retrieve the animation attribute.
	{
	vector<string> &v=objNode->attributes["animation"];
	if(v.size()>=2){
	animationLength=atoi(v[0].c_str());
	animationLoopPoint=atoi(v[1].c_str());
	}
	}
	//Retrieve the oneTimeAnimation attribute.
	{
	vector<string> &v=objNode->attributes["oneTimeAnimation"];
	if(v.size()>=2){
	animationLength=atoi(v[0].c_str());
	animationLoopPoint=atoi(v[1].c_str())\|0x80000000;
	}
	}
	//Retrieve the invisibleAtRunTime attribute.
	{
	vector<string> &v=objNode->attributes["invisibleAtRunTime"];
	if(!v.empty() && !v[0].empty()){
	invisibleAtRunTime=atoi(v[0].c_str())?true:false;
	}
	}
	//Retrieve the invisibleAtDesignTime attribute.
	{
	vector<string> &v=objNode->attributes["invisibleAtDesignTime"];
	if(!v.empty() && !v[0].empty()){
	invisibleAtDesignTime=atoi(v[0].c_str())?true:false;
	}
	}

	//Loop the subnodes.
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode *obj=objNode->subNodes[i];
	if(obj->name=="picture" \|\| obj->name=="pictureAnimation"){
	if(!picture.loadFromNode(obj,themePath, imageManager, renderer)){
	return false;
	}
	}else if(obj->name=="editorPicture"){
	if(!editorPicture.loadFromNode(obj,themePath, imageManager, renderer)){
	return false;
	}
	}else if(obj->name=="optionalPicture" && obj->value.size()>=6){
	ThemePicture *objPic=new ThemePicture();
	double f=atof(obj->value[5].c_str());
	if(!objPic->loadFromNode(obj,themePath, imageManager, renderer)){
	delete objPic;
	return false;
	}
	optionalPicture.push_back(pair<double,ThemePicture*>(f,objPic));
	}else if(obj->name=="offset" \|\| obj->name=="offsetAnimation"){
	if(!offset.loadFromNode(obj)) return false;
	}else if(obj->name=="positioning"){
	if(!positioning.loadFromNode(obj)) return false;
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	bool ThemePicture::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager &imageManager, SDL_Renderer &renderer){
	destroy();

	//Check if the node has enough values.
	if(!objNode->value.empty()){
	//Load the texture.
	texture=imageManager.loadTexture(themePath+objNode->value[0], renderer);
	if(!texture) {
	return false;
	}

	//Check if it's an animation.
	if(objNode->name=="pictureAnimation"){
	if(!offset.loadFromNode(objNode)) return false;
	return true;
	}else if(objNode->value.size()>=5){
	ThemeOffsetPoint r={atoi(objNode->value[1].c_str()),
	atoi(objNode->value[2].c_str()),
	atoi(objNode->value[3].c_str()),
	atoi(objNode->value[4].c_str()),0,0};
	offset.offsetData.push_back(r);
	offset.length=0;
	return true;
	}
	}

	cerr << "ERROR: The structure of theme picture node '" << objNode->name << "' is incorrect" << endl;

	return false;
	}

	bool ThemeOffsetData::loadFromNode(TreeStorageNode* objNode){
	destroy();

	//Check what kind of offset it is.
	if(objNode->name=="pictureAnimation"){
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode* obj=objNode->subNodes[i];
	if(obj->name=="point" && obj->value.size()>=4){
	ThemeOffsetPoint r={atoi(obj->value[0].c_str()),
	atoi(obj->value[1].c_str()),
	atoi(obj->value[2].c_str()),
	atoi(obj->value[3].c_str()),1,1};
	if(obj->value.size()>=5) r.frameCount=atoi(obj->value[4].c_str());
	if(obj->value.size()>=6) r.frameDisplayTime=atoi(obj->value[5].c_str());
	offsetData.push_back(r);
	length+=r.frameCount*r.frameDisplayTime;
	}
	}
	return true;
	}else if(objNode->name=="offsetAnimation"){
	for(unsigned int i=0;i<objNode->subNodes.size();i++){
	TreeStorageNode* obj=objNode->subNodes[i];
	if(obj->name=="point" && obj->value.size()>=2){
	ThemeOffsetPoint r={atoi(obj->value[0].c_str()),
	atoi(obj->value[1].c_str()),0,0,1,1};
	if(obj->value.size()>=3) r.frameCount=atoi(obj->value[2].c_str());
	if(obj->value.size()>=4) r.frameDisplayTime=atoi(obj->value[3].c_str());
	if(obj->value.size()>=5) r.w=atoi(obj->value[4].c_str());
	if(obj->value.size()>=6) r.h=atoi(obj->value[5].c_str());
	offsetData.push_back(r);
	length+=r.frameCount*r.frameDisplayTime;
	}
	}
	return true;
	}else if(objNode->name=="offset" && objNode->value.size()>=2){
	ThemeOffsetPoint r={atoi(objNode->value[0].c_str()),
	atoi(objNode->value[1].c_str()),0,0,0,0};
	if(objNode->value.size()>2)
	r.w=atoi(objNode->value[2].c_str());
	if(objNode->value.size()>3)
	r.h=atoi(objNode->value[3].c_str());
	offsetData.push_back(r);
	length=0;
	return true;
	}

	cerr << "ERROR: The structure of theme offset data node '" << objNode->name << "' is incorrect" << endl;

	return false;
	}

	bool ThemePositioningData::loadFromNode(TreeStorageNode* objNode){
	destroy();

	//Check if enough values are set.
	if(objNode->value.size()>=2){
	//Check horizontal alignment.
	if(objNode->value[0]=="left"){
	horizontalAlign=LEFT;
	}else if(objNode->value[0]=="centre" \|\| objNode->value[0]=="center"){
	horizontalAlign=CENTRE;
	}else if(objNode->value[0]=="right"){
	horizontalAlign=RIGHT;
	}else if(objNode->value[0]=="repeat"){
	horizontalAlign=REPEAT;
	} else if (objNode->value[0] == "stretch") {
	horizontalAlign = STRETCH;
	} else {
	cerr << "ERROR: Unknown horizontal align mode: " << objNode->value[0] << endl;
	return false;
	}
	//Check vertical alignment.
	if(objNode->value[1]=="top"){
	verticalAlign=TOP;
	}else if(objNode->value[1]=="middle"){
	verticalAlign=MIDDLE;
	}else if(objNode->value[1]=="bottom"){
	verticalAlign=BOTTOM;
	}else if(objNode->value[1]=="repeat"){
	verticalAlign=REPEAT;
	} else if (objNode->value[1] == "stretch") {
	verticalAlign = STRETCH;
	} else {
	cerr << "ERROR: Unknown vertical align mode: " << objNode->value[1] << endl;
	return false;
	}
	//Done and nothing went wrong so return true.
	return true;
	}

	cerr << "ERROR: The structure of theme positioning data node '" << objNode->name << "' is incorrect" << endl;

	return false;
	}

	void ThemeObjectInstance::draw(SDL_Renderer& renderer,int x,int y,int w,int h,const SDL_Rect *clipRect){
	//Get the picture.
	//SDL_Surface *src=picture->picture;
	SDL_Texture* src = picture->texture.get();
	if(src==NULL) return;

	//The offset to the left and top of the destination rectangle.
	int ex = 0, ey = 0;

	//The offset to the right and bottom of the destination rectangle. Only used when the position mode is REPEAT or STRETCH.
	int ew = 0, eh = 0;

	//The x,y,width,height of the source rectangle.
	int xx=0,yy=0,ww=0,hh=0;

	int animationNew=animation&0x7FFFFFFF;

	//Get the source rectangle.
	{
	const vector<ThemeOffsetPoint> &v=picture->offset.offsetData;
	if(picture->offset.length==0 \|\| animationNew<v[0].frameDisplayTime){
	xx=v[0].x;
	yy=v[0].y;
	ww=v[0].w;
	hh=v[0].h;
	}else if(animationNew>=picture->offset.length){
	int i=v.size()-1;
	xx=v[i].x;
	yy=v[i].y;
	ww=v[i].w;
	hh=v[i].h;
	}else{
	int t=animationNew-v[0].frameDisplayTime;
	for(unsigned int i=1;i<v.size();i++){
	int tt=t/v[i].frameDisplayTime;
	if(tt>=0 && tt<v[i].frameCount){
	xx=(int)((float)v[i-1].x+(float)(v[i].x-v[i-1].x)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	yy=(int)((float)v[i-1].y+(float)(v[i].y-v[i-1].y)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ww=(int)((float)v[i-1].w+(float)(v[i].w-v[i-1].w)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	hh=(int)((float)v[i-1].h+(float)(v[i].h-v[i-1].h)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	break;
	}else{
	t-=v[i].frameCount*v[i].frameDisplayTime;
	}
	}
	}
	}

	//Get the offset.
	{
	vector<ThemeOffsetPoint> &v=parent->offset.offsetData;
	if(v.empty()){
	ex=0;
	ey=0;
	}else if(parent->offset.length==0 \|\| animationNew<v[0].frameDisplayTime){
	ex=v[0].x;
	ey=v[0].y;
	ew=v[0].w;
	eh=v[0].h;
	}else if(animationNew>=parent->offset.length){
	int i=v.size()-1;
	ex=v[i].x;
	ey=v[i].y;
	ew=v[i].w;
	eh=v[i].h;
	}else{
	int t=animationNew-v[0].frameDisplayTime;
	for(unsigned int i=1;i<v.size();i++){
	int tt=t/v[i].frameDisplayTime;
	if(tt>=0 && tt<v[i].frameCount){
	ex=(int)((float)v[i-1].x+(float)(v[i].x-v[i-1].x)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ey=(int)((float)v[i-1].y+(float)(v[i].y-v[i-1].y)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ew=(int)((float)v[i-1].w+(float)(v[i].w-v[i-1].w)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	eh=(int)((float)v[i-1].h+(float)(v[i].h-v[i-1].h)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	break;
	}else{
	t-=v[i].frameCount*v[i].frameDisplayTime;
	}
	}
	}
	}

	//And finally draw the ThemeObjectInstance.
	if(ww>0&&hh>0){
	Alignment hAlign = parent->positioning.horizontalAlign;
	Alignment vAlign = parent->positioning.verticalAlign;

	//If the destination size is not set then assume it's the same as the source size.
	//In this case we also disable the align.
	if (w <= 0) {
	w = ww;
	hAlign = LEFT;
	}
	if (h <= 0) {
	h = hh;
	vAlign = TOP;
	}

	//The destination rectangle (NOTE: the w,h are actually the right and bottom)
	SDL_Rect r2={x+ex,y+ey,0,0};

	//Align horizontally.
	switch (hAlign){
	case CENTRE:
	r2.x += (w - ww) / 2;
	break;
	case RIGHT:
	r2.x += w - ww;
	break;
	}

	//Align vertically.
	switch (vAlign){
	case MIDDLE:
	r2.y += (h - hh) / 2;
	break;
	case BOTTOM:
	r2.y += h - hh;
	break;
	}

	//Calculate the correct right and bottom of the destination rectangle (esp. in REPEAT and STRETCH mode)
	r2.w = (hAlign == REPEAT \|\| hAlign == STRETCH) ? (x + w - ew) : r2.x + ww;
	r2.h = (vAlign == REPEAT \|\| vAlign == STRETCH) ? (y + h - eh) : r2.y + hh;

	//For STRETCH mode we have to use SDL builtin clip rect function
	//otherwise the texture coordinate is hard to calculate
	bool useSDLClipRect = false;

	if (clipRect) {
	//Clip the right and bottom
	if (r2.w > clipRect->x + clipRect->w) {
	if (hAlign == STRETCH) useSDLClipRect = true;
	else r2.w = clipRect->x + clipRect->w;
	}
	if (r2.h > clipRect->y + clipRect->h) {
	if (vAlign == STRETCH) useSDLClipRect = true;
	else r2.h = clipRect->y + clipRect->h;
	}

	//Clip the left and top (ad-hoc code)
	if (r2.x < clipRect->x) {
	if (hAlign == STRETCH) useSDLClipRect = true;
	else r2.x += ((clipRect->x - r2.x) / ww) * ww;
	}
	if (r2.y < clipRect->y) {
	if (vAlign == STRETCH) useSDLClipRect = true;
	else r2.y += ((clipRect->y - r2.y) / hh) * hh;
	}
	}

	//Set the SDL clip rect if necessary
	if (useSDLClipRect) {
	SDL_RenderSetClipRect(&renderer, clipRect);
	}

	//As long as we haven't exceeded the horizontal target keep drawing.
	while (r2.x < r2.w){
	//Store the y position for when more than one column has to be drawn.
	const int y2 = r2.y;
	//As long as we haven't exceeded the vertical target keep drawing.
	while (r2.y < r2.h){
	//The source rectangle which will be modified by clipping.
	SDL_Rect srcrect = { xx, yy, ww, hh };

	//Check if we should clip the right and bottom.
	if (r2.x + ww > r2.w && hAlign != STRETCH) srcrect.w = r2.w - r2.x;
	if (r2.y + hh > r2.h && vAlign != STRETCH) srcrect.h = r2.h - r2.y;

	//The destination rectangle which will be modified by clipping.
	SDL_Rect dstrect = { r2.x, r2.y, 0, 0 };

	//Clip the left and top
	if (clipRect) {
	int d = clipRect->x - dstrect.x;
	if (d > 0 && hAlign != STRETCH) {
	srcrect.x += d; srcrect.w -= d; dstrect.x += d;
	}
	d = clipRect->y - dstrect.y;
	if (d > 0 && vAlign != STRETCH) {
	srcrect.y += d; srcrect.h -= d; dstrect.y += d;
	}
	}

	if (srcrect.w > 0 && srcrect.h > 0) {
	dstrect.w = (hAlign == STRETCH) ? (r2.w - r2.x) : srcrect.w;
	dstrect.h = (vAlign == STRETCH) ? (r2.h - r2.y) : srcrect.h;
	SDL_RenderCopy(&renderer, src, &srcrect, &dstrect);
	}
	if (vAlign == STRETCH) break; //For STRETCH mode draw once is enough
	r2.y += hh;
	}
	if (hAlign == STRETCH) break; //For STRETCH mode draw once is enough
	r2.x += ww;

	//Reset the y position before drawing a new column.
	r2.y = y2;
	}

	//Reset the SDL clip rect if necessary
	if (useSDLClipRect) {
	SDL_RenderSetClipRect(&renderer, NULL);
	}
	}
	}

	void ThemeObjectInstance::updateAnimation(){
	//First get the animation length.
	int m;
	m=parent->animationLength;

	//If it's higher than 0 then we have an animation.
	if(m>0 && animation>=0){
	//Increase the animation frame.
	animation++;
	//Check if the animation is beyond the length, if so set it to the looppoint.
	if(animation>=m)
	animation=parent->animationLoopPoint;
	}
	}

	void ThemeBlockInstance::updateAnimation(){
	//Make sure the currentState isn't null.
	- if(currentState!=NULL){
	+ if (currentState >= 0 && currentState < (int)states.size()) {
	+ ThemeBlockStateInstance &current = states[currentState];
	+
	//Call the updateAnimation method of the currentState.
	- currentState->updateAnimation();
	-
	+ current.updateAnimation();
	+
	//Get the length of the animation.
	- int m=currentState->parent->oneTimeAnimationLength;
	-
	+ int m = current.parent->oneTimeAnimationLength;
	+
	//If it's higher than 0 then we have an animation.
	//Also check if it's past the lenght, meaning done.
	- if(m>0 && currentState->animation>=m){
	+ if (m > 0 && current.animation >= m){
	//Now we can change the state to the nextState.
	- changeState(currentState->parent->nextState);
	+ changeState(current.parent->nextState);
	}
	}
	}

	-void ThemeBlock::createInstance(ThemeBlockInstance* obj){
	+void ThemeBlockInstance::clear() {
	+ currentState = -1;
	+ currentStateName.clear();
	+ blockStates.clear();
	+ transitions.clear();
	+ states.clear();
	+}
	+
	+void ThemeBlock::createInstance(ThemeBlockInstance* obj, const std::string& initialState) {
	//Make sure the given ThemeBlockInstance is ready.
	- obj->blockStates.clear();
	- obj->transitions.clear();
	- obj->currentState=NULL;
	-
	+ obj->clear();
	+
	//Loop through the blockstates.
	- for(map<string,ThemeBlockState*>::iterator it=blockStates.begin();it!=blockStates.end();++it){
	- //Get the themeBlockStateInstance of the given ThemeBlockInstance.
	- ThemeBlockStateInstance &obj1=obj->blockStates[it->first];
	+ for (auto it = blockStates.begin(); it != blockStates.end(); ++it) {
	+ //Create a new themeBlockStateInstance.
	+ obj->states.emplace_back();
	+ ThemeBlockStateInstance &obj1 = obj->states.back();
	+
	+ //Register it with given name.
	+ obj->blockStates[it->first] = obj->states.size() - 1;
	+
	//Set the parent of the state instance.
	- obj1.parent=it->second;
	+ obj1.parent = it->second;

	//Create the state instance.
	createStateInstance(&obj1);
	}

	//Loop through the transitions.
	- for(map<pair<string,string>,ThemeBlockState*>::iterator it=transitions.begin();it!=transitions.end();++it){
	- //Get the themeBlockStateInstance of the given ThemeBlockInstance.
	- ThemeBlockStateInstance &obj1=obj->transitions[it->first];
	+ for (auto it = transitions.begin(); it != transitions.end(); ++it) {
	+ //Create a new themeBlockStateInstance.
	+ obj->states.emplace_back();
	+ ThemeBlockStateInstance &obj1 = obj->states.back();
	+
	+ //Register it with given name.
	+ obj->transitions[it->first] = obj->states.size() - 1;
	+
	//Set the parent of the state instance.
	- obj1.parent=it->second;
	+ obj1.parent = it->second;

	//Create the state instance.
	createStateInstance(&obj1);
	}

	//Change the state to the default one.
	//FIXME: Is that needed?
	- obj->changeState("default");
	+ obj->changeState(initialState);
	}

	void ThemeBlock::createStateInstance(ThemeBlockStateInstance* obj){
	//Get the vector with themeObjects.
	vector<ThemeObject*> &v=obj->parent->themeObjects;

	//Loop through them.
	for(unsigned int i=0;i<v.size();i++){
	//Create an instance for every one.
	ThemeObjectInstance p;
	//Set the parent.
	p.parent=v[i];

	//Choose the picture.
	if(stateID==STATE_LEVEL_EDITOR){
	if(p.parent->invisibleAtDesignTime)
	continue;
	if(p.parent->editorPicture.texture!=NULL)
	p.picture=&p.parent->editorPicture;
	}else{
	if(p.parent->invisibleAtRunTime)
	continue;
	}

	//Get the number of optional Pictures.
	int m=p.parent->optionalPicture.size();
	//If p.picture is null, not an editor picture, and there are optional pictures then give one random.
	if(p.picture==NULL && m>0){
	double f=0.0,f1=1.0/256.0;
	for(int j=0;j<8;j++){
	f+=f1*(double)(rand()&0xff);
	f1*=(1.0/256.0);
	}
	for(int j=0;j<m;j++){
	f-=p.parent->optionalPicture[j].first;
	if(f<0.0){
	p.picture=p.parent->optionalPicture[j].second;
	break;
	}
	}
	}

	//If random turned out to give nothing then give the non optional picture.
	if(p.picture==NULL && p.parent->picture.texture!=NULL)
	p.picture=&p.parent->picture;
	//If the picture isn't null then can we give it to the ThemeBlockStateInstance.
	if(p.picture!=NULL)
	obj->objects.push_back(p);
	}
	}

	void ThemePicture::draw(SDL_Renderer& renderer,int x,int y,int animation,SDL_Rect *clipRect){
	//Get the Picture.
	if(texture==NULL) return;
	int ex=0,ey=0,xx,yy,ww,hh;
	{
	const vector<ThemeOffsetPoint> &v=offset.offsetData;
	if(offset.length==0 \|\| animation<v[0].frameDisplayTime){
	xx=v[0].x;
	yy=v[0].y;
	ww=v[0].w;
	hh=v[0].h;
	}else if(animation>=offset.length){
	int i=v.size()-1;
	xx=v[i].x;
	yy=v[i].y;
	ww=v[i].w;
	hh=v[i].h;
	}else{
	int t=animation-v[0].frameDisplayTime;
	for(unsigned int i=1;i<v.size();i++){
	int tt=t/v[i].frameDisplayTime;
	if(tt>=0 && tt<v[i].frameCount){
	xx=(int)((float)v[i-1].x+(float)(v[i].x-v[i-1].x)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	yy=(int)((float)v[i-1].y+(float)(v[i].y-v[i-1].y)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	ww=(int)((float)v[i-1].w+(float)(v[i].w-v[i-1].w)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	hh=(int)((float)v[i-1].h+(float)(v[i].h-v[i-1].h)*(float)(tt+1)/(float)v[i].frameCount+0.5f);
	break;
	}else{
	t-=v[i].frameCount*v[i].frameDisplayTime;
	}
	}
	}
	}

	//Draw the Picture.
	if(clipRect){
	int d;
	d=clipRect->x-ex;
	if(d>0){
	ex+=d;
	xx+=d;
	ww-=d;
	}
	d=clipRect->y-ey;
	if(d>0){
	ey+=d;
	yy+=d;
	hh-=d;
	}
	if(ww>clipRect->w) ww=clipRect->w;
	if(hh>clipRect->h) hh=clipRect->h;
	}
	if(ww>0&&hh>0){
	SDL_Rect r1={xx,yy,ww,hh};
	SDL_Rect r2={x+ex,y+ey,ww,hh};
	SDL_RenderCopy(&renderer, texture.get(), &r1, &r2);
	}
	}

	//This method will scale the background picture (if needed and configured) to the current SCREEN_WIDTH and SCREEN_HEIGHT.
	void ThemeBackgroundPicture::scaleToScreen(){
	//Only scale if needed.
	if(scale){
	// SDL2 allows us to scale the texture when rendering, so
	// we only need to adjust the size of the destination rect.
	destSize.w = SCREEN_WIDTH;
	destSize.h = SCREEN_HEIGHT;
	}
	}

	void ThemeBackgroundPicture::draw(SDL_Renderer &dest){
	//Check if the picture is visible.
	if(!(texture&&srcSize.w>0&&srcSize.h>0&&destSize.w>0&&destSize.h>0))
	return;

	//Calculate the draw area.
	int sx=(int)((float)destSize.x+currentX-cameraX*(float)camera.x+0.5f);
	int sy=(int)((float)destSize.y+currentY-cameraY*(float)camera.y+0.5f);
	int ex,ey;

	//Include repeating.
	if(repeatX){
	sx%=destSize.w;
	if(sx>0) sx-=destSize.w;
	ex=SCREEN_WIDTH;
	}else{
	if(sx<=-(int)destSize.w \|\| sx>=SCREEN_WIDTH) return;
	ex=sx+1;
	}
	if(repeatY){
	sy%=destSize.h;
	if(sy>0) sy-=destSize.h;
	ey=SCREEN_HEIGHT;
	}else{
	if(sy<=-(int)destSize.h \|\| sy>=SCREEN_HEIGHT) return;
	ey=sy+1;
	}

	//And finally draw the ThemeBackgroundPicture.
	for(int x=sx;x<ex;x+=destSize.w){
	for(int y=sy;y<ey;y+=destSize.h){
	// NOTE: Rendercopy cares about w/h here
	// so had to add it for SDL2 port.
	SDL_Rect r={x,y,destSize.w,destSize.h};
	//SDL_BlitSurface(picture,&srcSize,dest,&r);
	SDL_RenderCopy(&dest, texture.get(), &srcSize, &r);
	}
	}
	}

	bool ThemeBackgroundPicture::loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager &imageManager, SDL_Renderer& renderer){
	//Load the picture directly into a texture.
	texture = imageManager.loadTexture(themePath+objNode->value[0], renderer);
	if (!texture) {
	return false;
	}

	//Retrieve the source size.
	{
	vector<string> &v=objNode->attributes["srcSize"];
	if(v.size()>=4){
	srcSize.x=atoi(v[0].c_str());
	srcSize.y=atoi(v[1].c_str());
	srcSize.w=atoi(v[2].c_str());
	srcSize.h=atoi(v[3].c_str());
	}else{
	srcSize.x=0;
	srcSize.y=0;
	// This gets the width and height of the texture.
	SDL_QueryTexture(texture.get(), NULL, NULL, &srcSize.w, &srcSize.h);
	}

	//Cache the sourcesize.
	cachedSrcSize=srcSize;
	}

	//Retrieve the destination size.
	{
	vector<string> &v=objNode->attributes["destSize"];
	if(v.size()>=4){
	destSize.x=atoi(v[0].c_str());
	destSize.y=atoi(v[1].c_str());
	destSize.w=atoi(v[2].c_str());
	destSize.h=atoi(v[3].c_str());
	}else{
	destSize.x=0;
	destSize.y=0;
	destSize.w=SCREEN_WIDTH;
	destSize.h=SCREEN_HEIGHT;
	}

	//Cache the destsize.
	cachedDestSize=destSize;
	}

	//Retrieve if we should scale to screen.
	{
	//Get scaleToScreen.
	vector<string> &v=objNode->attributes["scaleToScreen"];
	//Boolean if the image should be scaled, default is true.
	scale=true;
	if(!v.empty()){
	scale=atoi(v[0].c_str())?true:false;
	}

	//Now scaleToScreen.
	//NOTE: We don't check if scaleToScreen is true or false since that is done in scaleToScreen();
	scaleToScreen();
	}

	//Retrieve if it should be repeated.
	{
	vector<string> &v=objNode->attributes["repeat"];
	if(v.size()>=2){
	repeatX=atoi(v[0].c_str())?true:false;
	repeatY=atoi(v[1].c_str())?true:false;
	}else{
	repeatX=true;
	repeatY=true;
	}
	}

	//Retrieve the speed.
	{
	vector<string> &v=objNode->attributes["speed"];
	if(v.size()>=2){
	speedX=atof(v[0].c_str());
	speedY=atof(v[1].c_str());
	}else{
	speedX=0.0f;
	speedY=0.0f;
	}
	}

	//Retrieve the camera speed.
	{
	vector<string> &v=objNode->attributes["cameraSpeed"];
	if(v.size()>=2){
	cameraX=atof(v[0].c_str());
	cameraY=atof(v[1].c_str());
	}else{
	cameraX=0.0f;
	cameraY=0.0f;
	}
	}

	//Done and nothing went wrong so return true.
	return true;
	}

	//Constructor.
	ThemeStack::ThemeStack(){
	hasThemeTextColor = hasThemeTextColorDialog = false;
	}

	//Destructor.
	ThemeStack::~ThemeStack(){
	//Loop through the themes and delete them.
	for(unsigned int i=0;i<objThemes.size();i++)
	delete objThemes[i];
	}

	//Method that will destroy the ThemeStack.
	void ThemeStack::destroy(){
	//Loop through the themes and delete them.
	for(unsigned int i=0;i<objThemes.size();i++)
	delete objThemes[i];
	//Clear the vector to prevent dangling pointers.
	objThemes.clear();

	//Invalidates the cache.
	hasThemeTextColor = hasThemeTextColorDialog = false;
	}

	//Method that will append a theme to the stack.
	//obj: The ThemeManager to add.
	void ThemeStack::appendTheme(ThemeManager* obj){
	objThemes.push_back(obj);
	//debug
	#if defined(DEBUG) \|\| defined(_DEBUG)
	cout<<"ThemeStack::appendTheme(): theme count="<<objThemes.size()<<endl;
	#endif
	//Invalidates the cache.
	hasThemeTextColor = hasThemeTextColorDialog = false;
	}
	//Method that will remove the last theme added to the stack.
	void ThemeStack::removeTheme(){
	//Make sure that the stack isn't empty.
	if(!objThemes.empty()){
	delete objThemes.back();
	objThemes.pop_back();
	}
	//Invalidates the cache.
	hasThemeTextColor = hasThemeTextColorDialog = false;
	}

	//Method that will append a theme that will be loaded from file.
	//fileName: The file to load the theme from.
	//Returns: Pointer to the newly added theme, NULL if failed.
	ThemeManager* ThemeStack::appendThemeFromFile(const string& fileName, ImageManager &imageManager, SDL_Renderer &renderer){
	//Invalidates the cache.
	hasThemeTextColor = hasThemeTextColorDialog = false;

	//Create a new themeManager.
	ThemeManager* obj=new ThemeManager();

	//Let it load from the given file.
	if(!obj->loadFile(fileName, imageManager, renderer)){
	//Failed thus delete the theme and return null.
	cerr<<"ERROR: Failed loading theme "<<fileName<<endl;
	delete obj;
	return NULL;
	}else{
	//Succeeded, add it to the stack and return it.
	objThemes.push_back(obj);
	return obj;
	}
	}

	//Method that is used to let the themes scale.
	void ThemeStack::scaleToScreen(){
	//Loop through the themes and call their scaleToScreen method.
	for(unsigned int i=0;i<objThemes.size();i++)
	objThemes[i]->scaleToScreen();
	}

	//Get a pointer to the ThemeBlock of a given block type.
	//index: The type of block.
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* ThemeStack::getBlock(int index,bool menu){
	//Loop through the themes from top to bottom.
	for(int i=objThemes.size()-1;i>=0;i--){
	//Get the block from the theme.
	ThemeBlock* obj=objThemes[i]->getBlock(index,menu);
	//Check if it isn't null.
	if(obj)
	return obj;
	}

	//Nothing found.
	return NULL;
	}
	ThemeBlock* ThemeStack::getScenery(const std::string& name) {
	//Loop through the themes from top to bottom.
	for (int i = objThemes.size() - 1; i >= 0; i--){
	//Get the block from the theme.
	ThemeBlock* obj = objThemes[i]->getScenery(name);
	//Check if it isn't null.
	if (obj)
	return obj;
	}

	//Check if the input is a valid block name.
	if (name.size() > 8 && name.substr(name.size() - 8) == "_Scenery") {
	auto it = Game::blockNameMap.find(name.substr(0, name.size() - 8));
	if (it != Game::blockNameMap.end()){
	return getBlock(it->second);
	}
	}

	//Nothing found.
	return NULL;
	}
	void ThemeStack::getSceneryBlockNames(std::set<std::string> &s) {
	//Loop through the themes from top to bottom.
	for (int i = objThemes.size() - 1; i >= 0; i--){
	objThemes[i]->getSceneryBlockNames(s);
	}

	//Also add all block names to it.
	for (auto it = Game::blockNameMap.begin(); it != Game::blockNameMap.end(); ++it) {
	s.insert(it->first + "_Scenery");
	}
	}
	//Get a pointer to the ThemeBlock of the shadow or the player.
	//isShadow: Boolean if it's the shadow
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* ThemeStack::getCharacter(bool isShadow){
	//Loop through the themes from top to bottom.
	for(int i=objThemes.size()-1;i>=0;i--){
	//Get the ThemeBlock from the theme.
	ThemeBlock* obj=objThemes[i]->getCharacter(isShadow);
	//Check if it isn't null.
	if(obj)
	return obj;
	}

	//Nothing found.
	return NULL;
	}
	//Get a pointer to the ThemeBackground of the theme.
	//Returns: Pointer to the ThemeBackground.
	ThemeBackground* ThemeStack::getBackground(bool menu){
	//Loop through the themes from top to bottom.
	for(int i=objThemes.size()-1;i>=0;i--){
	//Get the ThemeBackground from the theme.
	ThemeBackground* obj=objThemes[i]->getBackground(menu);
	//Check if it isn't null.
	if(obj)
	return obj;
	}

	//Nothing found.
	return NULL;
	}

	SDL_Color ThemeStack::getTextColor(bool isDialog) {
	if (isDialog) {
	if (hasThemeTextColorDialog) return themeTextColorDialog;

	//Loop through the themes from top to bottom.
	for (int i = objThemes.size() - 1; i >= 0; i--) {
	if (objThemes[i]->getTextColor(isDialog, themeTextColorDialog)) {
	hasThemeTextColorDialog = true;
	return themeTextColorDialog;
	}
	}

	hasThemeTextColorDialog = true;
	themeTextColorDialog = BLACK;
	return themeTextColorDialog;
	} else {
	if (hasThemeTextColor) return themeTextColor;

	//Loop through the themes from top to bottom.
	for (int i = objThemes.size() - 1; i >= 0; i--) {
	if (objThemes[i]->getTextColor(isDialog, themeTextColor)) {
	hasThemeTextColor = true;
	return themeTextColor;
	}
	}

	hasThemeTextColor = true;
	themeTextColor = BLACK;
	return themeTextColor;
	}
	}
	diff --git a/src/ThemeManager.h b/src/ThemeManager.h
	index 2ca9c1c..32026b8 100644
	--- a/src/ThemeManager.h
	+++ b/src/ThemeManager.h
	@@ -1,641 +1,635 @@
	/*
	* 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 THEMEMANAGER_H
	#define THEMEMANAGER_H

	#include "Globals.h"
	#include <string>
	#include <vector>
	#include <utility>
	#include <iostream>
	using namespace std;

	class ImageManager;
	class TreeStorageNode;

	//Structure containing offset data for one frame.
	struct ThemeOffsetPoint{
	//The location (x,y) and size (w,h).
	int x,y,w,h;
	//The frame to which this offset applies.
	int frameCount;
	//The number of frames this offset is shown.
	int frameDisplayTime;
	};

	//We already need the classes so declare them here.
	class ThemeOffsetData;
	class ThemePicture;
	class ThemeObject;
	class ThemeBlockState;
	class ThemeBlock;

	+class Block;
	+class ThemeBlockInstance;
	+
	//Instance class of a ThemeObject, this is used by the other Instance classes.
	class ThemeObjectInstance{
	-public:
	+ friend class ThemeBlockInstance;
	+ friend class ThemeBlock;
	+private:
	//Pointer to the picture.
	ThemePicture* picture;
	//Pointer to the parent the object an instance os is.
	ThemeObject* parent;

	//Integer containing the current animation frame.
	int animation;
	- //Integer containing the saved animation frame.
	- int savedAnimation;
	public:
	//Constructor.
	ThemeObjectInstance();
	-
	+
	+ //We use the system default copy constructor and operator=.
	+
	//Method used to draw the ThemeObject.
	//dest: The destination surface to draw the ThemeObject on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	void draw(SDL_Renderer& renderer,int x,int y,int w=0,int h=0,const SDL_Rect* clipRect=NULL);

	//Method that will update the animation.
	void updateAnimation();
	-
	- //Method that will reset the animation.
	- //save: Boolean if the saved animation should be deleted.
	- void resetAnimation(bool save);

	- //Method that will save the animation.
	- void saveAnimation();
	-
	- //Method that will load a saved animation.
	- void loadAnimation();
	+ //NOTE: save/load/reset code is removed in favor of copy constructor based approach.
	};

	//Instance class of a ThemeBlockState, this is used by the ThemeBlockInstance.
	class ThemeBlockStateInstance{
	-public:
	+ friend class ThemeBlockInstance;
	+ friend class ThemeBlock;
	+private:
	//Pointer to the parent the state an instance of is.
	ThemeBlockState *parent;
	//Vector containing the ThemeObjectInstances.
	vector<ThemeObjectInstance> objects;

	//Integer containing the current animation frame.
	int animation;
	- //Integer containing the saved animation frame.
	- int savedAnimation;
	public:
	//Constructor.
	ThemeBlockStateInstance();
	-
	+
	+ //We use the system default copy constructor and operator=.
	+
	//Method used to draw the ThemeBlockState.
	//dest: The destination surface to draw the ThemeBlockState on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	void draw(SDL_Renderer& renderer, int x, int y, int w = 0, int h = 0, const SDL_Rect *clipRect = NULL);

	//Method that will update the animation.
	void updateAnimation();

	- //Method that will reset the animation.
	- //save: Boolean if the saved state should be deleted.
	- void resetAnimation(bool save);
	-
	- //Method that will save the animation.
	- void saveAnimation();
	-
	- //Method that will load a saved animation.
	- void loadAnimation();
	+ //NOTE: save/load/reset code is removed in favor of copy constructor based approach.
	};

	//Instance of a ThemeBlock, this is used by blocks in the game to prevent changing the theme in game.
	//It also allows animation to run independently.
	class ThemeBlockInstance{
	-public:
	- //Pointer to the current state.
	- ThemeBlockStateInstance* currentState;
	+ friend class Block;
	+ friend class ThemeBlock;
	+private:
	+ //Index to the current state. -1 means invalid.
	+ //NOTE: We use the index instead of the pointer because it will make copy constructor works easier.
	+ int currentState;
	//The name of the current state.
	string currentStateName;

	- //Map containing the blockStates.
	- map<string,ThemeBlockStateInstance> blockStates;
	- //Map containing the blockTransitionStates.
	- map<pair<string,string>,ThemeBlockStateInstance> transitions;
	- //String containing the name of the saved state.
	- string savedStateName;
	+ //Map containing the index of blockStates.
	+ map<string,int> blockStates;
	+ //Map containing the index of blockTransitionStates.
	+ map<pair<string,string>,int> transitions;
	+
	+ //The array which contains actual ThemeBlockStateInstance.
	+ vector<ThemeBlockStateInstance> states;
	public:
	//Constructor.
	ThemeBlockInstance();
	-
	+
	+ //We use the system default copy constructor and operator=.
	+
	+ //Clear the instance.
	+ void clear();
	+
	//Method used to draw the ThemeBlock.
	//renderer: The destination renderer to draw the ThemeBlock on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	//Returns: True if it succeeds.
	bool draw(SDL_Renderer& renderer, int x, int y, int w = 0, int h = 0, const SDL_Rect *clipRect = NULL);

	//Method that will draw a specific state.
	//s: The name of the state to draw.
	//dest: The destination surface to draw the ThemeBlock on.
	//x: The x location of the area to draw in.
	//y: The y location of the area to draw in.
	//w: The width of the area to draw in.
	//h: The height of the area to draw in.
	//clipRect: Rectangle used to clip.
	//Returns: True if it succeeds.
	bool drawState(const string& s, SDL_Renderer& renderer, int x, int y, int w = 0, int h = 0, SDL_Rect *clipRect = NULL);

	//Method that will change the current state.
	//s: The name of the state to change to.
	//reset: Boolean if the animation should reset.
	+ //onlyIfStateChanged: Boolean if the animation should be played only when the new state is not equal to the current state.
	//Returns: True if it succeeds (exists).
	- bool changeState(const string& s, bool reset = true);
	+ bool changeState(const string& s, bool reset = true, bool onlyIfStateChanged = false);

	//Method that will update the animation.
	void updateAnimation();

	- //Method that will reset the animation.
	- //save: Boolean if the saved state should be deleted.
	- void resetAnimation(bool save);
	-
	- //Method that will save the animation.
	- void saveAnimation();
	-
	- //Method that will restore a saved animation.
	- void loadAnimation();
	+ //NOTE: save/load/reset code is removed in favor of copy constructor based approach.
	};

	//Class containing the offset data.
	class ThemeOffsetData{
	public:
	//Vector containing the offsetDatas.
	vector<ThemeOffsetPoint> offsetData;
	//The length of the "animation" in frames.
	int length;
	public:
	//Constructor.
	ThemeOffsetData();

	//Method used to destroy the offsetData.
	void destroy();

	//Method that will load the offsetData from a node.
	//objNode: Pointer to the TreeStorageNode to read the data from.
	//Returns: True if it succeeds without errors.
	bool loadFromNode(TreeStorageNode* objNode);
	};

	enum Alignment{
	//Horizontal alignments
	LEFT,
	CENTRE,
	RIGHT,

	//Vertical alignments
	TOP,
	MIDDLE,
	BOTTOM,

	//NOTE: Repeat can be used for both horizontal and vertical alignments.
	REPEAT,

	//NOTE: Stretch can be used for both horizontal and vertical alignments.
	STRETCH,
	};

	//Class containing the positioning and repeat data.
	class ThemePositioningData{
	public:
	//Horizontal and vertical alignment data.
	Alignment horizontalAlign,verticalAlign;
	public:
	//Constructor.
	ThemePositioningData();

	//Method used to destroy the positioningData.
	void destroy();

	//Method that will load the positioningData from a node.
	//objNode: Pointer to the TreeStorageNode to read the data from.
	//Returns: True if it succeeds without errors.
	bool loadFromNode(TreeStorageNode* objNode);
	};

	//This is the lowest level of the theme system.
	//It's a picture with offset data.
	class ThemePicture{
	public:
	//Pointer to actual texture. Handled by ImageManager.
	SharedTexture texture;
	//Offset data for the picture.
	ThemeOffsetData offset;
	//int x;
	//int y;
	public:
	//Constructor.
	ThemePicture();

	//Method used to destroy the picture.
	void destroy();

	bool loadFromNode(TreeStorageNode* objNode, string themePath, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that will draw the ThemePicture.
	//dest: The destination surface.
	//x: The x location on the dest to draw the picture.
	//y: The y location on the dest to draw the picture.
	//animation: The frame of the animation to draw.
	//clipRect: Rectangle to clip the picture.
	void draw(SDL_Renderer& renderer,int x,int y,int animation=0, SDL_Rect* clipRect=NULL);
	};

	//The ThemeObject class is used to contain a basic theme element.
	//Contains the picture, animation information, etc...
	class ThemeObject{
	public:
	//Integer containing the length of the animation.
	int animationLength;
	//Integer containing the frame from where the animation is going to loop.
	int animationLoopPoint;

	//Boolean if the animation is invisible at run time (Game state).
	bool invisibleAtRunTime;
	//Boolean if the animation is invisible at design time (Level editor).
	bool invisibleAtDesignTime;

	//Picture of the ThemeObject.
	ThemePicture picture;
	//Picture of the ThemeObject shown when in the level editor.
	ThemePicture editorPicture;

	//Vector containing optionalPicture for the ThemeObject.
	vector<pair<double,ThemePicture*> > optionalPicture;

	//ThemeOffsetData for the ThemeObject.
	ThemeOffsetData offset;
	//ThemePositionData for the ThemeObject.
	ThemePositioningData positioning;
	public:
	//Constructor.
	ThemeObject();

	//Destructor.
	~ThemeObject();

	//Method that will destroy the ThemeObject.
	void destroy();

	//Method that will load a ThemeObject from a node.
	//objNode: The TreeStorageNode to read the object from.
	//themePath: Path to the theme.
	//Returns: True if it succeeds.
	bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);
	};

	//Class containing a single state of a themed block.
	class ThemeBlockState{
	public:
	//The length in frames of the oneTimeAnimation.
	int oneTimeAnimationLength;
	//String containing the name of the next state.
	string nextState;
	//Vector containing the themeObjects that make up this state.
	vector<ThemeObject*> themeObjects;
	public:
	//Constructor.
	ThemeBlockState();

	//Destructor.
	~ThemeBlockState();

	//Method that will destroy the ThemeBlockState.
	void destroy();

	//Method that will load a ThemeBlockState from a node.
	//objNode: The TreeStorageNode to read the state from.
	//themePath: Path to the theme.
	//Returns: True if it succeeds.
	bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);
	};

	//Class containing the needed things for a themed block.
	class ThemeBlock{
	public:
	//Picture that is shown only in the level editor.
	ThemePicture editorPicture;

	//Map containing ThemeBlockStates for the different states of a block.
	map<string,ThemeBlockState*> blockStates;
	//Map containing the transition states between blocks states.
	map<pair<string,string>,ThemeBlockState*> transitions;
	public:
	//Constructor.
	ThemeBlock();

	//Destructor.
	~ThemeBlock();

	//Method that will destroy the ThemeBlock.
	void destroy();

	//Method that will load a ThemeBlock from a node.
	//objNode: The TreeStorageNode to load the ThemeBlock from.
	//themePath: The path to the theme.
	//Returns: True if it succeeds.
	bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that will create a ThemeBlockInstance.
	//obj: Pointer that will be filled with the instance.
	- void createInstance(ThemeBlockInstance* obj);
	+ //initialState: The name of the initial state.
	+ void createInstance(ThemeBlockInstance* obj, const std::string& initialState = "default");
	private:
	//Method that will create a ThemeBlockStateInstance.
	//obj: Pointer that will be filled with the instance.
	void createStateInstance(ThemeBlockStateInstance* obj);
	};

	//ThemeBackgroundPicture is a class containing the picture for the background.
	class ThemeBackgroundPicture{
	private:
	//Rectangle that should be taken from the picture.
	//NOTE The size is pixels of the image.
	SDL_Rect cachedSrcSize;
	//Rectangle with the size it will have on the destination (screen).
	//NOTE The size is in pixels or in precentages (if scaleToScreen is true).
	SDL_Rect cachedDestSize;

	//Pointer to the SDL_Texture containing the picture. (Creation/destruction handled by ImageManager)
	SharedTexture texture;
	//Rectangle that should be taken from the picture.
	//NOTE The size is pixels of the image.
	SDL_Rect srcSize;
	//Rectangle with the size it will have on the destination (screen).
	//NOTE The size is in pixels even though the loaded value from the theme description file can be in precentages (if scaleToScreen is true).
	SDL_Rect destSize;

	//Boolean if the background picture should be scaled to screen.
	bool scale;

	//Boolean if the image should be repeated over the x-axis.
	bool repeatX;
	//Boolean if the image should be repeated over the y-axis.
	bool repeatY;

	//Float containing the speed the background picture moves along the x-axis.
	float speedX;
	//Float containing the speed the background picture moves along the y-axis.
	float speedY;

	//Float containing the horizontal speed the picture will have when moving the camera (horizontally).
	float cameraX;
	//Float containing the vertical speed the picture will have when moving the camera (vertically).
	float cameraY;
	private:
	//Float with the current x position.
	float currentX;
	//Float with the current y position.
	float currentY;

	//Stored x location for when loading a state.
	float savedX;
	//Stored y location for when loading a state.
	float savedY;
	public:
	//Constructor.
	ThemeBackgroundPicture();

	//Method that will update the animation.
	void updateAnimation();

	//Method that will reset the animation.
	//save: Boolean if the saved state should be deleted.
	void resetAnimation(bool save);

	//Method that will save the animation.
	void saveAnimation();

	//Method that will load the animation.
	void loadAnimation();

	//Method used to draw the ThemeBackgroundPicture.
	//dest: Pointer to the SDL_Renderer the picture should be drawn on.
	void draw(SDL_Renderer& dest);


	//Method used to load the ThemeBackgroundPicture from a node.
	//objNode: The TreeStorageNode to load the picture from.
	//themePath: The path to the theme.
	bool loadFromNode(TreeStorageNode* objNode,string themePath, ImageManager& imageManager, SDL_Renderer& renderer);

	//This method will scale the background picture (if needed and configured) to the current SCREEN_WIDTH and SCREEN_HEIGHT.
	void scaleToScreen();
	};

	//Class that forms the complete background of a theme.
	//It is in fact nothing more than a vector containing multiple ThemeBackgroundPictures.
	class ThemeBackground{
	private:
	//Vector containing the ThemeBackgroundPictures.
	vector<ThemeBackgroundPicture> picture;
	public:
	//Method that will update the animation of all the background pictures.
	void updateAnimation();

	//Method that will reset the animation of all the background pictures.
	//save: Boolean if the saved state should be deleted.
	void resetAnimation(bool save);

	//Method that will save the animation of all the background pictures.
	void saveAnimation();

	//Method that will load the animation of all the background pictures.
	void loadAnimation();

	//Method that will scale the background pictures (if set) to the current screen resolution.
	void scaleToScreen();

	//This method will draw all the background pictures.
	//dest: Pointer to the SDL_Renderer to draw them on.
	void draw(SDL_Renderer& renderer);

	//Method that will add a ThemeBackgroundPicture to the ThemeBackground.
	//objNode: The treeStorageNode to read from.
	//themePath: The path to the theme.
	//Returns: True if it succeeds.
	bool addPictureFromNode(TreeStorageNode* objNode, string themePath, ImageManager& imageManager, SDL_Renderer& renderer);
	};

	//The ThemeManager is actually a whole theme, filled with ThemeBlocks and ThemeBackground.
	class ThemeManager{
	private:
	//The ThemeBlock of the shadow.
	ThemeBlock* shadow;
	//The ThemeBlock of the player.
	ThemeBlock* player;

	//Array containing a ThemeBlock for every block type.
	ThemeBlock* objBlocks[TYPE_MAX];

	//Map containing all scenery blocks.
	std::map<std::string, ThemeBlock*> objScenery;

	//The ThemeBackground.
	ThemeBackground* objBackground;

	//ThemeBackground for menu.
	ThemeBackground* menuBackground;
	//Level selection background block.
	ThemeBlock* menuBlock;
	//Level selection background block for locked level.
	ThemeBlock* menuShadowBlock;

	//Boolean indicates if we have theme text colors.
	bool hasThemeTextColor, hasThemeTextColorDialog;

	//Theme text colors.
	SDL_Color themeTextColor, themeTextColorDialog;
	public:
	//String containing the path to the string.
	string themePath;
	//String containing the theme name.
	string themeName;
	public:
	//Constructor.
	ThemeManager();

	//Destructor.
	~ThemeManager();

	//Method used to destroy the ThemeManager.
	void destroy();

	//Method that will load the theme from a file.
	//fileName: The file to load the theme from.
	//Returns: True if it succeeds.
	bool loadFile(const string& fileName, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that will scale the theme to the current SCREEN_WIDTH and SCREEN_HEIGHT.
	void scaleToScreen();

	//Get a pointer to the ThemeBlock of a given block type.
	//index: The type of block.
	//menu: Boolean if get spefial blocks for menu
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getBlock(int index, bool menu);

	//Get a pointer to the ThemeBlock of a given scenery type.
	//name: The name of scenery block.
	ThemeBlock* getScenery(const std::string& name);

	// Add all names of available scenery blocks to a given set.
	void getSceneryBlockNames(std::set<std::string> &s);

	//Get a pointer to the ThemeBlock of the shadow or the player.
	//isShadow: Boolean if it's the shadow
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getCharacter(bool isShadow);

	//Get a pointer to the ThemeBackground of the theme.
	//menu: Boolean if get menu background
	//Returns: Pointer to the ThemeBackground.
	ThemeBackground* getBackground(bool menu);

	//Get theme text color.
	//isDialog: Boolean if get theme text color for dialog.
	//color [out]: The color.
	//Returns: if the color is specified in the theme file.
	bool getTextColor(bool isDialog, SDL_Color& color);
	};

	//Class that combines multiple ThemeManager into one stack.
	//If a file is not in a certain theme it will use one of a lower theme.
	class ThemeStack{
	private:
	//Vector containing the themes in the stack.
	vector<ThemeManager*> objThemes;

	//Boolean indicates if we have already cached the theme text colors.
	bool hasThemeTextColor, hasThemeTextColorDialog;

	//The cached theme text colors.
	SDL_Color themeTextColor, themeTextColorDialog;
	public:
	//Constructor.
	ThemeStack();
	//Destructor.
	~ThemeStack();

	//Method that will destroy the ThemeStack.
	void destroy();

	//Method that will append a theme to the stack.
	//obj: The ThemeManager to add.
	void appendTheme(ThemeManager* obj);
	//Method that will remove the last theme added to the stack.
	void removeTheme();

	//Method that will append a theme that will be loaded from file.
	//fileName: The file to load the theme from.
	//Returns: Pointer to the newly added theme, NULL if failed.
	ThemeManager* appendThemeFromFile(const string& fileName, ImageManager& imageManager, SDL_Renderer& renderer);

	//Method that is used to let the themes scale.
	void scaleToScreen();

	//Get the number of themes in the stack.
	//Returns: The theme count.
	int themeCount(){
	return (int)objThemes.size();
	}

	//Operator overloading so that the themes can be accesed using the [] operator.
	//i: The index.
	ThemeManager* operator[](int i){
	return objThemes[i];
	}
	//Get a pointer to the ThemeBlock of a given block type.
	//index: The type of block.
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getBlock(int index,bool menu=false);
	//Get a pointer to the ThemeBlock of a given scenery type.
	//name: The name of scenery block.
	ThemeBlock* getScenery(const std::string& name);
	// Add all names of available scenery blocks to a given set.
	void getSceneryBlockNames(std::set<std::string> &s);
	//Get a pointer to the ThemeBlock of the shadow or the player.
	//isShadow: Boolean if it's the shadow
	//Returns: Pointer to the ThemeBlock.
	ThemeBlock* getCharacter(bool isShadow);
	//Get a pointer to the ThemeBackground of the theme.
	//Returns: Pointer to the ThemeBackground.
	ThemeBackground* getBackground(bool menu);

	//Get theme text color.
	//isDialog: Boolean if get theme text color for dialog.
	//Returns: The color (default: black).
	SDL_Color getTextColor(bool isDialog);
	};

	//The ThemeStack that is be used by the GameState.
	extern ThemeStack objThemes;

	#endif
	diff --git a/src/libs/SDL2_ttf/CHANGES.txt b/src/libs/SDL2_ttf/CHANGES.txt
	new file mode 100644
	index 0000000..d490554
	--- /dev/null
	+++ b/src/libs/SDL2_ttf/CHANGES.txt
	@@ -0,0 +1,37 @@
	+2.0.15:
	+Sam Lantinga - Sun Sep 10 00:18:45 PDT 2017
	+ * Text rendering functions now use the alpha component of the text colors
	+Sam Lantinga - Sat Sep 9 22:21:55 PDT 2017
	+ * Added support for characters greater than 0xFFFF (e.g. emoji) in the UTF-8 APIs
	+
	+2.0.14:
	+Ryan Gordon - Fri Jan 29 12:53:29 PST 2016
	+ * Deprecated TTF_GetFontKerningSize() which takes font glyph indices and added TTF_GetFontKerningSizeGlyphs() which takes characters
	+
	+2.0.13:
	+Sylvain - Sat Jun 28 11:42:42 2014
	+ * Fixed bug rendering text starting with a glyph with negative starting offset
	+beuc - Sun Jun 15 18:27:28 2014
	+ * Fixed regression loading non-scalable fonts
	+Sam Lantinga - Sun Jun 15 18:21:04 PDT 2014
	+ * TTF_GetFontKerningSize() gets kerning between two characters, not two glyph indices
	+David Ludwig - Sun Apr 13 22:28:26 2014
	+ * Added support for building for Windows RT and Windows Phone
	+
	+2.0.12:
	+Sam Lantinga - Sat Jun 1 19:11:26 PDT 2013
	+ * Updated for SDL 2.0 release
	+
	+2.0.11:
	+Sam Lantinga - Sat Dec 31 10:49:42 EST 2011
	+ * SDL_ttf is now under the zlib license
	+Peter Kosyh - Mon Feb 28 14:57:03 PST 2011
	+ * Improved font glyph caching for non-latin languages
	+Erik Snoek - Wed Jan 12 09:10:15 PST 2011
	+ * Added API to get kerning info: TTF_GetFontKerningSize()
	+Sam Lantinga - Mon Jan 10 10:58:34 2011 -0800
	+ * Added Android.mk to build on the Android platform
	+
	+2.0.10:
	+Adam Strzelecki - Wed Oct 21 21:02:37 PDT 2009
	+ * Find the Unicode or symbol character map if it's available in the font
	diff --git a/src/libs/SDL2_ttf/COPYING.txt b/src/libs/SDL2_ttf/COPYING.txt
	new file mode 100644
	index 0000000..4a4e814
	--- /dev/null
	+++ b/src/libs/SDL2_ttf/COPYING.txt
	@@ -0,0 +1,20 @@
	+/*
	+ SDL_ttf: A companion library to SDL for working with TrueType (tm) fonts
	+ Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
	+
	+ This software is provided 'as-is', without any express or implied
	+ warranty. In no event will the authors be held liable for any damages
	+ arising from the use of this software.
	+
	+ Permission is granted to anyone to use this software for any purpose,
	+ including commercial applications, and to alter it and redistribute it
	+ freely, subject to the following restrictions:
	+
	+ 1. The origin of this software must not be misrepresented; you must not
	+ claim that you wrote the original software. If you use this software
	+ in a product, an acknowledgment in the product documentation would be
	+ appreciated but is not required.
	+ 2. Altered source versions must be plainly marked as such, and must not be
	+ misrepresented as being the original software.
	+ 3. This notice may not be removed or altered from any source distribution.
	+*/
	diff --git a/src/libs/SDL2_ttf/README.txt b/src/libs/SDL2_ttf/README.txt
	new file mode 100644
	index 0000000..b75b3d7
	--- /dev/null
	+++ b/src/libs/SDL2_ttf/README.txt
	@@ -0,0 +1,25 @@
	+
	+This library is a wrapper around the excellent FreeType 2.0 library,
	+available at:
	+ http://www.freetype.org/
	+
	+This library allows you to use TrueType fonts to render text in SDL
	+applications.
	+
	+To make the library, first install the FreeType library, then type
	+'./configure' then 'make' to build the SDL truetype library and the
	+showfont and glfont example applications.
	+
	+Be careful when including fonts with your application, as many of them
	+are copyrighted. The Microsoft fonts, for example, are not freely
	+redistributable and even the free "web" fonts they provide are only
	+redistributable in their special executable installer form (May 1998).
	+There are plenty of freeware and shareware fonts available on the Internet
	+though, and may suit your purposes.
	+
	+This library is under the zlib license, see the file "COPYING.txt" for details.
	+
	+Portions of this software are copyright © 2013 The FreeType Project (www.freetype.org). All rights reserved.
	+
	+Enjoy!
	+ -Sam Lantinga <slouken@libsdl.org> (6/20/2001)
	diff --git a/src/libs/SDL2_ttf/SDL_ttf.c b/src/libs/SDL2_ttf/SDL_ttf.c
	new file mode 100644
	index 0000000..529721d
	--- /dev/null
	+++ b/src/libs/SDL2_ttf/SDL_ttf.c
	@@ -0,0 +1,2482 @@
	+/*
	+ SDL_ttf: A companion library to SDL for working with TrueType (tm) fonts
	+ Copyright (C) 2001-2018 Sam Lantinga <slouken@libsdl.org>
	+
	+ This software is provided 'as-is', without any express or implied
	+ warranty. In no event will the authors be held liable for any damages
	+ arising from the use of this software.
	+
	+ Permission is granted to anyone to use this software for any purpose,
	+ including commercial applications, and to alter it and redistribute it
	+ freely, subject to the following restrictions:
	+
	+ 1. The origin of this software must not be misrepresented; you must not
	+ claim that you wrote the original software. If you use this software
	+ in a product, an acknowledgment in the product documentation would be
	+ appreciated but is not required.
	+ 2. Altered source versions must be plainly marked as such, and must not be
	+ misrepresented as being the original software.
	+ 3. This notice may not be removed or altered from any source distribution.
	+*/
	+
	+#include <math.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include <ft2build.h>
	+#include FT_FREETYPE_H
	+#include FT_OUTLINE_H
	+#include FT_STROKER_H
	+#include FT_GLYPH_H
	+#include FT_TRUETYPE_IDS_H
	+
	+#include "SDL.h"
	+#include "SDL_endian.h"
	+#include "SDL_ttf.h"
	+
	+/* FIXME: Right now we assume the gray-scale renderer Freetype is using
	+ supports 256 shades of gray, but we should instead key off of num_grays
	+ in the result FT_Bitmap after the FT_Render_Glyph() call. */
	+#define NUM_GRAYS 256
	+
	+/* Handy routines for converting from fixed point */
	+#define FT_FLOOR(X) ((X & -64) / 64)
	+#define FT_CEIL(X) (((X + 63) & -64) / 64)
	+
	+#define CACHED_METRICS 0x10
	+#define CACHED_BITMAP 0x01
	+#define CACHED_PIXMAP 0x02
	+
	+/* Cached glyph information */
	+typedef struct cached_glyph {
	+ int stored;
	+ FT_Face face; /* for font fallback support */
	+ FT_UInt index;
	+ FT_Bitmap bitmap;
	+ FT_Bitmap pixmap;
	+ int minx;
	+ int maxx;
	+ int miny;
	+ int maxy;
	+ int yoffset;
	+ int advance;
	+ Uint32 cached;
	+} c_glyph;
	+
	+/* The structure used to hold internal font information */
	+struct _TTF_Font {
	+ /* Freetype2 maintains all sorts of useful info itself */
	+ FT_Face face;
	+
	+ int num_of_fallbacks;
	+ TTF_Font **fallbacks;
	+
	+ /* We'll cache these ourselves */
	+ int height;
	+ int ascent;
	+ int descent;
	+ int lineskip;
	+
	+ /* The font style */
	+ int face_style;
	+ int style;
	+ int outline;
	+
	+ /* Whether kerning is desired */
	+ int kerning;
	+
	+ /* Extra width in glyph bounds for text styles */
	+ int glyph_overhang;
	+ float glyph_italics;
	+
	+ /* Information in the font for underlining */
	+ int underline_offset;
	+ int underline_height;
	+
	+ /* Cache for style-transformed glyphs */
	+ c_glyph *current;
	+ c_glyph cache[257]; /* 257 is a prime */
	+
	+ /* We are responsible for closing the font stream */
	+ SDL_RWops *src;
	+ int freesrc;
	+ FT_Open_Args args;
	+
	+ /* For non-scalable formats, we must remember which font index size */
	+ int font_size_family;
	+
	+ /* really just flags passed into FT_Load_Glyph */
	+ int hinting;
	+};
	+
	+/* Handle a style only if the font does not already handle it */
	+#define TTF_HANDLE_STYLE_BOLD(font) (((font)->style & TTF_STYLE_BOLD) && \
	+ !((font)->face_style & TTF_STYLE_BOLD))
	+#define TTF_HANDLE_STYLE_ITALIC(font) (((font)->style & TTF_STYLE_ITALIC) && \
	+ !((font)->face_style & TTF_STYLE_ITALIC))
	+#define TTF_HANDLE_STYLE_UNDERLINE(font) ((font)->style & TTF_STYLE_UNDERLINE)
	+#define TTF_HANDLE_STYLE_STRIKETHROUGH(font) ((font)->style & TTF_STYLE_STRIKETHROUGH)
	+
	+/* Font styles that does not impact glyph drawing */
	+#define TTF_STYLE_NO_GLYPH_CHANGE (TTF_STYLE_UNDERLINE \| TTF_STYLE_STRIKETHROUGH)
	+
	+/* The FreeType font engine/library */
	+static FT_Library library;
	+static int TTF_initialized = 0;
	+static int TTF_byteswapped = 0;
	+
	+#define TTF_CHECKPOINTER(p, errval) \
	+ if (!TTF_initialized) { \
	+ TTF_SetError("Library not initialized"); \
	+ return errval; \
	+ } \
	+ if (!p) { \
	+ TTF_SetError("Passed a NULL pointer"); \
	+ return errval; \
	+ }
	+
	+/* Gets the top row of the underline. The outline
	+ is taken into account.
	+*/
	+static int TTF_underline_top_row(TTF_Font *font)
	+{
	+ /* With outline, the underline_offset is underline_offset+outline. */
	+ /* So, we don't have to remove the top part of the outline height. */
	+ return font->ascent - font->underline_offset - 1;
	+}
	+
	+/* Gets the top row of the underline. for a given glyph. The outline
	+ is taken into account.
	+ Need to update row according to height difference between font and glyph:
	+ font_value - font->ascent + glyph->maxy
	+*/
	+static int TTF_Glyph_underline_top_row(TTF_Font font, c_glyph glyph)
	+{
	+ return glyph->maxy - font->underline_offset - 1;
	+}
	+
	+/* Gets the bottom row of the underline. The outline
	+ is taken into account.
	+*/
	+static int TTF_underline_bottom_row(TTF_Font *font)
	+{
	+ int row = TTF_underline_top_row(font) + font->underline_height;
	+ if (font->outline > 0) {
	+ /* Add underline_offset outline offset and */
	+ /* the bottom part of the outline. */
	+ row += font->outline * 2;
	+ }
	+ return row;
	+}
	+
	+/* Gets the bottom row of the underline. for a given glyph. The outline
	+ is taken into account.
	+ Need to update row according to height difference between font and glyph:
	+ font_value - font->ascent + glyph->maxy
	+*/
	+static int TTF_Glyph_underline_bottom_row(TTF_Font font, c_glyph glyph)
	+{
	+ return TTF_underline_bottom_row(font) - font->ascent + glyph->maxy;
	+}
	+
	+/* Gets the top row of the strikethrough. The outline
	+ is taken into account.
	+*/
	+static int TTF_strikethrough_top_row(TTF_Font *font)
	+{
	+ /* With outline, the first text row is 'outline'. */
	+ /* So, we don't have to remove the top part of the outline height. */
	+ return font->height / 2;
	+}
	+
	+/* Gets the top row of the strikethrough for a given glyph. The outline
	+ is taken into account.
	+ Need to update row according to height difference between font and glyph:
	+ font_value - font->ascent + glyph->maxy
	+*/
	+static int TTF_Glyph_strikethrough_top_row(TTF_Font font, c_glyph glyph)
	+{
	+ return TTF_strikethrough_top_row(font) - font->ascent + glyph->maxy;
	+}
	+
	+static void TTF_initLineMectrics(const TTF_Font font, const SDL_Surface textbuf, const int row, Uint8 *pdst, int pheight)
	+{
	+ Uint8 *dst;
	+ int height;
	+
	+ dst = (Uint8 *)textbuf->pixels;
	+ if (row > 0) {
	+ dst += row * textbuf->pitch;
	+ }
	+
	+ height = font->underline_height;
	+ /* Take outline into account */
	+ if (font->outline > 0) {
	+ height += font->outline * 2;
	+ }
	+ *pdst = dst;
	+ *pheight = height;
	+}
	+
	+/* Draw a solid line of underline_height (+ optional outline)
	+ at the given row. The row value must take the
	+ outline into account.
	+*/
	+static void TTF_drawLine_Solid(const TTF_Font font, const SDL_Surface textbuf, const int row)
	+{
	+ int line;
	+ Uint8 dst_check = (Uint8)textbuf->pixels + textbuf->pitch * textbuf->h;
	+ Uint8 *dst;
	+ int height;
	+
	+ TTF_initLineMectrics(font, textbuf, row, &dst, &height);
	+
	+ /* Draw line */
	+ for (line=height; line>0 && dst < dst_check; --line) {
	+ /* 1 because 0 is the bg color */
	+ SDL_memset(dst, 1, textbuf->w);
	+ dst += textbuf->pitch;
	+ }
	+}
	+
	+/* Draw a shaded line of underline_height (+ optional outline)
	+ at the given row. The row value must take the
	+ outline into account.
	+*/
	+static void TTF_drawLine_Shaded(const TTF_Font font, const SDL_Surface textbuf, const int row)
	+{
	+ int line;
	+ Uint8 dst_check = (Uint8)textbuf->pixels + textbuf->pitch * textbuf->h;
	+ Uint8 *dst;
	+ int height;
	+
	+ TTF_initLineMectrics(font, textbuf, row, &dst, &height);
	+
	+ /* Draw line */
	+ for (line=height; line>0 && dst < dst_check; --line) {
	+ SDL_memset(dst, NUM_GRAYS - 1, textbuf->w);
	+ dst += textbuf->pitch;
	+ }
	+}
	+
	+/* Draw a blended line of underline_height (+ optional outline)
	+ at the given row. The row value must take the
	+ outline into account.
	+*/
	+static void TTF_drawLine_Blended(const TTF_Font font, const SDL_Surface textbuf, const int row, const Uint32 color)
	+{
	+ int line;
	+ Uint32 dst_check = (Uint32)textbuf->pixels + textbuf->pitch/4 * textbuf->h;
	+ Uint8 dst8; / destination, byte version */
	+ Uint32 *dst;
	+ int height;
	+ int col;
	+ Uint32 pixel = color \| 0xFF000000; /* Amask */
	+
	+ TTF_initLineMectrics(font, textbuf, row, &dst8, &height);
	+ dst = (Uint32 *) dst8;
	+
	+ /* Draw line */
	+ for (line=height; line>0 && dst < dst_check; --line) {
	+ for (col=0; col < textbuf->w; ++col) {
	+ dst[col] = pixel;
	+ }
	+ dst += textbuf->pitch/4;
	+ }
	+}
	+
	+/* rcg06192001 get linked library's version. */
	+const SDL_version *TTF_Linked_Version(void)
	+{
	+ static SDL_version linked_version;
	+ SDL_TTF_VERSION(&linked_version);
	+ return(&linked_version);
	+}
	+
	+/* This function tells the library whether UNICODE text is generally
	+ byteswapped. A UNICODE BOM character at the beginning of a string
	+ will override this setting for that string.
	+ */
	+void TTF_ByteSwappedUNICODE(int swapped)
	+{
	+ TTF_byteswapped = swapped;
	+}
	+
	+static void TTF_SetFTError(const char *msg, FT_Error error)
	+{
	+#ifdef USE_FREETYPE_ERRORS
	+#undef FTERRORS_H
	+#define FT_ERRORDEF(e, v, s) { e, s },
	+ static const struct
	+ {
	+ int err_code;
	+ const char* err_msg;
	+ } ft_errors[] = {
	+#include <freetype/fterrors.h>
	+ };
	+ int i;
	+ const char *err_msg;
	+ char buffer[1024];
	+
	+ err_msg = NULL;
	+ for (i=0; i<((sizeof ft_errors)/(sizeof ft_errors[0])); ++i) {
	+ if (error == ft_errors[i].err_code) {
	+ err_msg = ft_errors[i].err_msg;
	+ break;
	+ }
	+ }
	+ if (!err_msg) {
	+ err_msg = "unknown FreeType error";
	+ }
	+ TTF_SetError("%s: %s", msg, err_msg);
	+#else
	+ TTF_SetError("%s", msg);
	+#endif /* USE_FREETYPE_ERRORS */
	+}
	+
	+int TTF_Init(void)
	+{
	+ int status = 0;
	+
	+ if (!TTF_initialized) {
	+ FT_Error error = FT_Init_FreeType(&library);
	+ if (error) {
	+ TTF_SetFTError("Couldn't init FreeType engine", error);
	+ status = -1;
	+ }
	+ }
	+ if (status == 0) {
	+ ++TTF_initialized;
	+ }
	+ return status;
	+}
	+
	+static unsigned long RWread(
	+ FT_Stream stream,
	+ unsigned long offset,
	+ unsigned char* buffer,
	+ unsigned long count
	+)
	+{
	+ SDL_RWops *src;
	+
	+ src = (SDL_RWops *)stream->descriptor.pointer;
	+ SDL_RWseek(src, (int)offset, RW_SEEK_SET);
	+ if (count == 0) {
	+ return 0;
	+ }
	+ return (unsigned long)SDL_RWread(src, buffer, 1, (int)count);
	+}
	+
	+TTF_Font* TTF_OpenFontIndexRW(SDL_RWops *src, int freesrc, int ptsize, long index)
	+{
	+ TTF_Font* font;
	+ FT_Error error;
	+ FT_Face face;
	+ FT_Fixed scale;
	+ FT_Stream stream;
	+ FT_CharMap found;
	+ Sint64 position;
	+ int i;
	+
	+ if (!TTF_initialized) {
	+ TTF_SetError("Library not initialized");
	+ if (src && freesrc) {
	+ SDL_RWclose(src);
	+ }
	+ return NULL;
	+ }
	+
	+ if (!src) {
	+ TTF_SetError("Passed a NULL font source");
	+ return NULL;
	+ }
	+
	+ /* Check to make sure we can seek in this stream */
	+ position = SDL_RWtell(src);
	+ if (position < 0) {
	+ TTF_SetError("Can't seek in stream");
	+ if (freesrc) {
	+ SDL_RWclose(src);
	+ }
	+ return NULL;
	+ }
	+
	+ font = (TTF_Font)SDL_malloc(sizeof font);
	+ if (font == NULL) {
	+ TTF_SetError("Out of memory");
	+ if (freesrc) {
	+ SDL_RWclose(src);
	+ }
	+ return NULL;
	+ }
	+ SDL_memset(font, 0, sizeof(*font));
	+
	+ font->src = src;
	+ font->freesrc = freesrc;
	+
	+ stream = (FT_Stream)SDL_malloc(sizeof(*stream));
	+ if (stream == NULL) {
	+ TTF_SetError("Out of memory");
	+ TTF_CloseFont(font);
	+ return NULL;
	+ }
	+ SDL_memset(stream, 0, sizeof(*stream));
	+
	+ stream->read = RWread;
	+ stream->descriptor.pointer = src;
	+ stream->pos = (unsigned long)position;
	+ stream->size = (unsigned long)(SDL_RWsize(src) - position);
	+
	+ font->args.flags = FT_OPEN_STREAM;
	+ font->args.stream = stream;
	+
	+ error = FT_Open_Face(library, &font->args, index, &font->face);
	+ if (error) {
	+ TTF_SetFTError("Couldn't load font file", error);
	+ TTF_CloseFont(font);
	+ return NULL;
	+ }
	+ face = font->face;
	+
	+ /* Set charmap for loaded font */
	+ found = 0;
	+#if 0 /* Font debug code */
	+ for (i = 0; i < face->num_charmaps; i++) {
	+ FT_CharMap charmap = face->charmaps[i];
	+ printf("Found charmap: platform id %d, encoding id %d\n", charmap->platform_id, charmap->encoding_id);
	+ }
	+#endif
	+ if (!found) {
	+ for (i = 0; i < face->num_charmaps; i++) {
	+ FT_CharMap charmap = face->charmaps[i];
	+ if (charmap->platform_id == 3 && charmap->encoding_id == 10) { /* UCS-4 Unicode */
	+ found = charmap;
	+ break;
	+ }
	+ }
	+ }
	+ if (!found) {
	+ for (i = 0; i < face->num_charmaps; i++) {
	+ FT_CharMap charmap = face->charmaps[i];
	+ if ((charmap->platform_id == 3 && charmap->encoding_id == 1) /* Windows Unicode */
	+ \|\| (charmap->platform_id == 3 && charmap->encoding_id == 0) /* Windows Symbol */
	+ \|\| (charmap->platform_id == 2 && charmap->encoding_id == 1) /* ISO Unicode */
	+ \|\| (charmap->platform_id == 0)) { /* Apple Unicode */
	+ found = charmap;
	+ break;
	+ }
	+ }
	+ }
	+ if (found) {
	+ /* If this fails, continue using the default charmap */
	+ FT_Set_Charmap(face, found);
	+ }
	+
	+ /* Make sure that our font face is scalable (global metrics) */
	+ if (FT_IS_SCALABLE(face)) {
	+ /* Set the character size and use default DPI (72) */
	+ error = FT_Set_Char_Size(font->face, 0, ptsize * 64, 0, 0);
	+ if (error) {
	+ TTF_SetFTError("Couldn't set font size", error);
	+ TTF_CloseFont(font);
	+ return NULL;
	+ }
	+
	+ /* Get the scalable font metrics for this font */
	+ scale = face->size->metrics.y_scale;
	+ font->ascent = FT_CEIL(FT_MulFix(face->ascender, scale));
	+ font->descent = FT_CEIL(FT_MulFix(face->descender, scale));
	+ font->height = font->ascent - font->descent + /* baseline */ 1;
	+ font->lineskip = FT_CEIL(FT_MulFix(face->height, scale));
	+ font->underline_offset = FT_FLOOR(FT_MulFix(face->underline_position, scale));
	+ font->underline_height = FT_FLOOR(FT_MulFix(face->underline_thickness, scale));
	+
	+ } else {
	+ /* Non-scalable font case. ptsize determines which family
	+ * or series of fonts to grab from the non-scalable format.
	+ * It is not the point size of the font.
	+ * */
	+ if (ptsize >= font->face->num_fixed_sizes)
	+ ptsize = font->face->num_fixed_sizes - 1;
	+ font->font_size_family = ptsize;
	+ error = FT_Set_Pixel_Sizes(face,
	+ face->available_sizes[ptsize].width,
	+ face->available_sizes[ptsize].height);
	+
	+ /* With non-scalale fonts, Freetype2 likes to fill many of the
	+ * font metrics with the value of 0. The size of the
	+ * non-scalable fonts must be determined differently
	+ * or sometimes cannot be determined.
	+ * */
	+ font->ascent = face->available_sizes[ptsize].height;
	+ font->descent = 0;
	+ font->height = face->available_sizes[ptsize].height;
	+ font->lineskip = FT_CEIL(font->ascent);
	+ font->underline_offset = FT_FLOOR(face->underline_position);
	+ font->underline_height = FT_FLOOR(face->underline_thickness);
	+ }
	+
	+ if (font->underline_height < 1) {
	+ font->underline_height = 1;
	+ }
	+
	+#ifdef DEBUG_FONTS
	+ printf("Font metrics:\n");
	+ printf("\tascent = %d, descent = %d\n",
	+ font->ascent, font->descent);
	+ printf("\theight = %d, lineskip = %d\n",
	+ font->height, font->lineskip);
	+ printf("\tunderline_offset = %d, underline_height = %d\n",
	+ font->underline_offset, font->underline_height);
	+ printf("\tunderline_top_row = %d, strikethrough_top_row = %d\n",
	+ TTF_underline_top_row(font), TTF_strikethrough_top_row(font));
	+#endif
	+
	+ /* Initialize the font face style */
	+ font->face_style = TTF_STYLE_NORMAL;
	+ if (font->face->style_flags & FT_STYLE_FLAG_BOLD) {
	+ font->face_style \|= TTF_STYLE_BOLD;
	+ }
	+ if (font->face->style_flags & FT_STYLE_FLAG_ITALIC) {
	+ font->face_style \|= TTF_STYLE_ITALIC;
	+ }
	+
	+ /* Set the default font style */
	+ font->style = font->face_style;
	+ font->outline = 0;
	+ font->kerning = 1;
	+ font->glyph_overhang = face->size->metrics.y_ppem / 10;
	+ /* x offset = cos(((90.0-12)/360)2M_PI), or 12 degree angle */
	+ font->glyph_italics = 0.207f;
	+ font->glyph_italics *= font->height;
	+
	+ return font;
	+}
	+
	+TTF_Font* TTF_OpenFontRW(SDL_RWops *src, int freesrc, int ptsize)
	+{
	+ return TTF_OpenFontIndexRW(src, freesrc, ptsize, 0);
	+}
	+
	+TTF_Font* TTF_OpenFontIndex(const char *file, int ptsize, long index)
	+{
	+ SDL_RWops *rw = SDL_RWFromFile(file, "rb");
	+ if (rw == NULL) {
	+ return NULL;
	+ }
	+ return TTF_OpenFontIndexRW(rw, 1, ptsize, index);
	+}
	+
	+TTF_Font* TTF_OpenFont(const char *file, int ptsize)
	+{
	+ return TTF_OpenFontIndex(file, ptsize, 0);
	+}
	+
	+static void Flush_Glyph(c_glyph* glyph)
	+{
	+ glyph->face = 0;
	+ glyph->stored = 0;
	+ glyph->index = 0;
	+ if (glyph->bitmap.buffer) {
	+ SDL_free(glyph->bitmap.buffer);
	+ glyph->bitmap.buffer = 0;
	+ }
	+ if (glyph->pixmap.buffer) {
	+ SDL_free(glyph->pixmap.buffer);
	+ glyph->pixmap.buffer = 0;
	+ }
	+ glyph->cached = 0;
	+}
	+
	+static void Flush_Cache(TTF_Font* font)
	+{
	+ int i;
	+ int size = sizeof(font->cache) / sizeof(font->cache[0]);
	+
	+ for (i = 0; i < size; ++i) {
	+ if (font->cache[i].cached) {
	+ Flush_Glyph(&font->cache[i]);
	+ }
	+
	+ }
	+}
	+
	+static int Get_Char_Index_Using_Font_Fallback(TTF_Font* font, Uint32 ch, c_glyph* cached)
	+{
	+ int i;
	+
	+ /* Check if the glyph can be found in current face */
	+ cached->index = FT_Get_Char_Index(font->face, ch);
	+ if (cached->index > 0) {
	+ /* Found it */
	+ cached->face = font->face;
	+ return 1;
	+ }
	+
	+ /* Find the glyph in font fallbacks */
	+ for (i = 0; i < font->num_of_fallbacks; i++) {
	+ if (font->fallbacks[i] && font->fallbacks[i]->face) {
	+ if (Get_Char_Index_Using_Font_Fallback(font->fallbacks[i], ch, cached)) {
	+ return 1;
	+ }
	+ }
	+ }
	+
	+ /* Not found */
	+ return 0;
	+}
	+
	+static FT_Error Load_Glyph(TTF_Font* font, Uint32 ch, c_glyph* cached, int want)
	+{
	+ FT_Face face;
	+ FT_Error error;
	+ FT_GlyphSlot glyph;
	+ FT_Glyph_Metrics* metrics;
	+ FT_Outline* outline;
	+
	+ if (!font \|\| !font->face) {
	+ return FT_Err_Invalid_Handle;
	+ }
	+
	+ /* Load the glyph */
	+ if (!cached->index) {
	+ if (!Get_Char_Index_Using_Font_Fallback(font, ch, cached)) {
	+ /* Glyph is not found in all of fallbacks */
	+ cached->index = 0;
	+ cached->face = font->face;
	+ }
	+ }
	+
	+ face = cached->face;
	+
	+ error = FT_Load_Glyph(face, cached->index, FT_LOAD_DEFAULT \| font->hinting);
	+ if (error) {
	+ return error;
	+ }
	+
	+ /* Get our glyph shortcuts */
	+ glyph = face->glyph;
	+ metrics = &glyph->metrics;
	+ outline = &glyph->outline;
	+
	+ /* Get the glyph metrics if desired */
	+ if ((want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS)) {
	+ if (FT_IS_SCALABLE(face)) {
	+ /* Get the bounding box */
	+ cached->minx = FT_FLOOR(metrics->horiBearingX);
	+ cached->maxx = FT_CEIL(metrics->horiBearingX + metrics->width);
	+ cached->maxy = FT_FLOOR(metrics->horiBearingY);
	+ cached->miny = cached->maxy - FT_CEIL(metrics->height);
	+ cached->yoffset = font->ascent - cached->maxy;
	+ cached->advance = FT_CEIL(metrics->horiAdvance);
	+ } else {
	+ /* Get the bounding box for non-scalable format.
	+ * Again, freetype2 fills in many of the font metrics
	+ * with the value of 0, so some of the values we
	+ * need must be calculated differently with certain
	+ * assumptions about non-scalable formats.
	+ * */
	+ cached->minx = FT_FLOOR(metrics->horiBearingX);
	+ cached->maxx = FT_CEIL(metrics->horiBearingX + metrics->width);
	+ cached->maxy = FT_FLOOR(metrics->horiBearingY);
	+ cached->miny = cached->maxy - FT_CEIL(face->available_sizes[font->font_size_family].height);
	+ cached->yoffset = 0;
	+ cached->advance = FT_CEIL(metrics->horiAdvance);
	+ }
	+
	+ /* Adjust for bold and italic text */
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ cached->maxx += font->glyph_overhang;
	+ }
	+ if (TTF_HANDLE_STYLE_ITALIC(font)) {
	+ cached->maxx += (int)SDL_ceil(font->glyph_italics);
	+ }
	+ cached->stored \|= CACHED_METRICS;
	+ }
	+
	+ if (((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP)) \|\|
	+ ((want & CACHED_PIXMAP) && !(cached->stored & CACHED_PIXMAP))) {
	+ int mono = (want & CACHED_BITMAP);
	+ int i;
	+ FT_Bitmap* src;
	+ FT_Bitmap* dst;
	+ FT_Glyph bitmap_glyph = NULL;
	+
	+ /* Handle the italic style */
	+ if (TTF_HANDLE_STYLE_ITALIC(font)) {
	+ FT_Matrix shear;
	+
	+ shear.xx = 1 << 16;
	+ shear.xy = (int) (font->glyph_italics * (1 << 16)) / font->height;
	+ shear.yx = 0;
	+ shear.yy = 1 << 16;
	+
	+ FT_Outline_Transform(outline, &shear);
	+ }
	+
	+ /* Render as outline */
	+ if ((font->outline > 0) && glyph->format != FT_GLYPH_FORMAT_BITMAP) {
	+ FT_Stroker stroker;
	+ FT_Get_Glyph(glyph, &bitmap_glyph);
	+ error = FT_Stroker_New(library, &stroker);
	+ if (error) {
	+ return error;
	+ }
	+ FT_Stroker_Set(stroker, font->outline * 64, FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0);
	+ FT_Glyph_Stroke(&bitmap_glyph, stroker, 1 /* delete the original glyph */);
	+ FT_Stroker_Done(stroker);
	+ /* Render the glyph */
	+ error = FT_Glyph_To_Bitmap(&bitmap_glyph, mono ? ft_render_mode_mono : ft_render_mode_normal, 0, 1);
	+ if (error) {
	+ FT_Done_Glyph(bitmap_glyph);
	+ return error;
	+ }
	+ src = &((FT_BitmapGlyph)bitmap_glyph)->bitmap;
	+ } else {
	+ /* Render the glyph */
	+ error = FT_Render_Glyph(glyph, mono ? ft_render_mode_mono : ft_render_mode_normal);
	+ if (error) {
	+ return error;
	+ }
	+ src = &glyph->bitmap;
	+ }
	+ /* Copy over information to cache */
	+ if (mono) {
	+ dst = &cached->bitmap;
	+ } else {
	+ dst = &cached->pixmap;
	+ }
	+ SDL_memcpy(dst, src, sizeof(*dst));
	+
	+ /* FT_Render_Glyph() and .fon fonts always generate a
	+ * two-color (black and white) glyphslot surface, even
	+ * when rendered in ft_render_mode_normal. */
	+ /* FT_IS_SCALABLE() means that the font is in outline format,
	+ * but does not imply that outline is rendered as 8-bit
	+ * grayscale, because embedded bitmap/graymap is preferred
	+ * (see FT_LOAD_DEFAULT section of FreeType2 API Reference).
	+ * FT_Render_Glyph() canreturn two-color bitmap or 4/16/256-
	+ * color graymap according to the format of embedded bitmap/
	+ * graymap. */
	+ if (src->pixel_mode == FT_PIXEL_MODE_MONO) {
	+ dst->pitch *= 8;
	+ } else if (src->pixel_mode == FT_PIXEL_MODE_GRAY2) {
	+ dst->pitch *= 4;
	+ } else if (src->pixel_mode == FT_PIXEL_MODE_GRAY4) {
	+ dst->pitch *= 2;
	+ }
	+
	+ /* Adjust for bold and italic text */
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ int bump = font->glyph_overhang;
	+ dst->pitch += bump;
	+ dst->width += bump;
	+ }
	+ if (TTF_HANDLE_STYLE_ITALIC(font)) {
	+ int bump = (int)SDL_ceil(font->glyph_italics);
	+ dst->pitch += bump;
	+ dst->width += bump;
	+ }
	+
	+ if (dst->rows != 0) {
	+ dst->buffer = (unsigned char )SDL_malloc(dst->pitch dst->rows);
	+ if (!dst->buffer) {
	+ return FT_Err_Out_Of_Memory;
	+ }
	+ SDL_memset(dst->buffer, 0, dst->pitch * dst->rows);
	+
	+ for (i = 0; i < src->rows; i++) {
	+ int soffset = i * src->pitch;
	+ int doffset = i * dst->pitch;
	+ if (mono) {
	+ unsigned char *srcp = src->buffer + soffset;
	+ unsigned char *dstp = dst->buffer + doffset;
	+ int j;
	+ if (src->pixel_mode == FT_PIXEL_MODE_MONO) {
	+ for (j = 0; j < src->width; j += 8) {
	+ unsigned char c = *srcp++;
	+ *dstp++ = (c&0x80) >> 7;
	+ c <<= 1;
	+ *dstp++ = (c&0x80) >> 7;
	+ c <<= 1;
	+ *dstp++ = (c&0x80) >> 7;
	+ c <<= 1;
	+ *dstp++ = (c&0x80) >> 7;
	+ c <<= 1;
	+ *dstp++ = (c&0x80) >> 7;
	+ c <<= 1;
	+ *dstp++ = (c&0x80) >> 7;
	+ c <<= 1;
	+ *dstp++ = (c&0x80) >> 7;
	+ c <<= 1;
	+ *dstp++ = (c&0x80) >> 7;
	+ }
	+ } else if (src->pixel_mode == FT_PIXEL_MODE_GRAY2) {
	+ for (j = 0; j < src->width; j += 4) {
	+ unsigned char c = *srcp++;
	+ *dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
	+ c <<= 2;
	+ *dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
	+ c <<= 2;
	+ *dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
	+ c <<= 2;
	+ *dstp++ = (((c&0xA0) >> 6) >= 0x2) ? 1 : 0;
	+ }
	+ } else if (src->pixel_mode == FT_PIXEL_MODE_GRAY4) {
	+ for (j = 0; j < src->width; j += 2) {
	+ unsigned char c = *srcp++;
	+ *dstp++ = (((c&0xF0) >> 4) >= 0x8) ? 1 : 0;
	+ c <<= 4;
	+ *dstp++ = (((c&0xF0) >> 4) >= 0x8) ? 1 : 0;
	+ }
	+ } else {
	+ for (j = 0; j < src->width; j++) {
	+ unsigned char c = *srcp++;
	+ *dstp++ = (c >= 0x80) ? 1 : 0;
	+ }
	+ }
	+ } else if (src->pixel_mode == FT_PIXEL_MODE_MONO) {
	+ /* This special case wouldn't
	+ * be here if the FT_Render_Glyph()
	+ * function wasn't buggy when it tried
	+ * to render a .fon font with 256
	+ * shades of gray. Instead, it
	+ * returns a black and white surface
	+ * and we have to translate it back
	+ * to a 256 gray shaded surface.
	+ * */
	+ unsigned char *srcp = src->buffer + soffset;
	+ unsigned char *dstp = dst->buffer + doffset;
	+ unsigned char c;
	+ int j, k;
	+ for (j = 0; j < src->width; j += 8) {
	+ c = *srcp++;
	+ for (k = 0; k < 8; ++k) {
	+ if ((c&0x80) >> 7) {
	+ *dstp++ = NUM_GRAYS - 1;
	+ } else {
	+ *dstp++ = 0x00;
	+ }
	+ c <<= 1;
	+ }
	+ }
	+ } else if (src->pixel_mode == FT_PIXEL_MODE_GRAY2) {
	+ unsigned char *srcp = src->buffer + soffset;
	+ unsigned char *dstp = dst->buffer + doffset;
	+ unsigned char c;
	+ int j, k;
	+ for (j = 0; j < src->width; j += 4) {
	+ c = *srcp++;
	+ for (k = 0; k < 4; ++k) {
	+ if ((c&0xA0) >> 6) {
	+ dstp++ = NUM_GRAYS ((c&0xA0) >> 6) / 3 - 1;
	+ } else {
	+ *dstp++ = 0x00;
	+ }
	+ c <<= 2;
	+ }
	+ }
	+ } else if (src->pixel_mode == FT_PIXEL_MODE_GRAY4) {
	+ unsigned char *srcp = src->buffer + soffset;
	+ unsigned char *dstp = dst->buffer + doffset;
	+ unsigned char c;
	+ int j, k;
	+ for (j = 0; j < src->width; j += 2) {
	+ c = *srcp++;
	+ for (k = 0; k < 2; ++k) {
	+ if ((c&0xF0) >> 4) {
	+ dstp++ = NUM_GRAYS ((c&0xF0) >> 4) / 15 - 1;
	+ } else {
	+ *dstp++ = 0x00;
	+ }
	+ c <<= 4;
	+ }
	+ }
	+ } else {
	+ SDL_memcpy(dst->buffer+doffset,
	+ src->buffer+soffset, src->pitch);
	+ }
	+ }
	+ }
	+
	+ /* Handle the bold style */
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ int row;
	+ int col;
	+ int offset;
	+ int pixel;
	+ Uint8* pixmap;
	+
	+ /* The pixmap is a little hard, we have to add and clamp */
	+ for (row = dst->rows - 1; row >= 0; --row) {
	+ pixmap = (Uint8) dst->buffer + row dst->pitch;
	+ for (offset=1; offset <= font->glyph_overhang; ++offset) {
	+ for (col = dst->width - 1; col > 0; --col) {
	+ if (mono) {
	+ pixmap[col] \|= pixmap[col-1];
	+ } else {
	+ pixel = (pixmap[col] + pixmap[col-1]);
	+ if (pixel > NUM_GRAYS - 1) {
	+ pixel = NUM_GRAYS - 1;
	+ }
	+ pixmap[col] = (Uint8) pixel;
	+ }
	+ }
	+ }
	+ }
	+ }
	+
	+ /* Mark that we rendered this format */
	+ if (mono) {
	+ cached->stored \|= CACHED_BITMAP;
	+ } else {
	+ cached->stored \|= CACHED_PIXMAP;
	+ }
	+
	+ /* Free outlined glyph */
	+ if (bitmap_glyph) {
	+ FT_Done_Glyph(bitmap_glyph);
	+ }
	+ }
	+
	+ /* We're done, mark this glyph cached */
	+ cached->cached = ch;
	+
	+ return 0;
	+}
	+
	+static FT_Error Find_Glyph(TTF_Font* font, Uint32 ch, int want)
	+{
	+ int retval = 0;
	+ int hsize = sizeof(font->cache) / sizeof(font->cache[0]);
	+
	+ int h = ch % hsize;
	+ font->current = &font->cache[h];
	+
	+ if (font->current->cached != ch)
	+ Flush_Glyph(font->current);
	+
	+ if ((font->current->stored & want) != want) {
	+ retval = Load_Glyph(font, ch, font->current, want);
	+ }
	+ return retval;
	+}
	+
	+void TTF_CloseFont(TTF_Font* font)
	+{
	+ if (font) {
	+ Flush_Cache(font);
	+ if (font->face) {
	+ FT_Done_Face(font->face);
	+ }
	+ if (font->args.stream) {
	+ SDL_free(font->args.stream);
	+ }
	+ if (font->freesrc) {
	+ SDL_RWclose(font->src);
	+ }
	+ if (font->fallbacks) {
	+ SDL_free(font->fallbacks);
	+ }
	+ SDL_free(font);
	+ }
	+}
	+
	+int TTF_SetFontFallback(TTF_Font font, int number_of_fallbacks, TTF_Font *fallbacks)
	+{
	+ /* Flush the cache */
	+ Flush_Cache(font);
	+
	+ /* Clear old font fallbacks */
	+ if (font->fallbacks) {
	+ SDL_free(font->fallbacks);
	+ }
	+ font->num_of_fallbacks = 0;
	+ font->fallbacks = 0;
	+
	+ /* Set new font fallbacks */
	+ if (number_of_fallbacks > 0 && fallbacks) {
	+ TTF_Font new_fallbacks = (TTF_Font )SDL_malloc(sizeof(TTF_Font) number_of_fallbacks);
	+ if (new_fallbacks == NULL) {
	+ TTF_SetError("Out of memory");
	+ return 0;
	+ }
	+ memcpy(new_fallbacks, fallbacks, sizeof(TTF_Font) number_of_fallbacks);
	+ font->num_of_fallbacks = number_of_fallbacks;
	+ font->fallbacks = new_fallbacks;
	+ }
	+
	+ return 1;
	+}
	+
	+/* Gets the number of bytes needed to convert a Latin-1 string to UTF-8 */
	+static size_t LATIN1_to_UTF8_len(const char *text)
	+{
	+ size_t bytes = 1;
	+ while (*text) {
	+ Uint8 ch = (Uint8)text++;
	+ if (ch <= 0x7F) {
	+ bytes += 1;
	+ } else {
	+ bytes += 2;
	+ }
	+ }
	+ return bytes;
	+}
	+
	+/* Gets the number of bytes needed to convert a UTF-16 string to UTF-8 */
	+static size_t UTF16_to_UTF8_len(const Uint16 *text)
	+{
	+ size_t bytes = 1;
	+ int swapped = TTF_byteswapped;
	+
	+ while (*text) {
	+ Uint16 ch = *text++;
	+ if (ch == UNICODE_BOM_NATIVE) {
	+ swapped = 0;
	+ continue;
	+ }
	+ if (ch == UNICODE_BOM_SWAPPED) {
	+ swapped = 1;
	+ continue;
	+ }
	+ if (swapped) {
	+ ch = SDL_Swap16(ch);
	+ }
	+ if (ch <= 0x7F) {
	+ bytes += 1;
	+ } else if (ch <= 0x7FF) {
	+ bytes += 2;
	+ } else if (ch >= 0xD800 && ch <= 0xDBFF) { /* high surrogate */
	+ bytes += 4;
	+ if (text) text++; / skip next character unless it is '\0' */
	+ } else {
	+ bytes += 3;
	+ }
	+ }
	+ return bytes;
	+}
	+
	+/* Gets the number of bytes needed to convert a UTF-32 string to UTF-8 */
	+static size_t UTF32_to_UTF8_len(const Uint32 *text)
	+{
	+ size_t bytes = 1;
	+
	+ while (*text) {
	+ Uint32 ch = *text++;
	+ if (ch <= 0x7F) {
	+ bytes += 1;
	+ } else if (ch <= 0x7FF) {
	+ bytes += 2;
	+ } else if (ch <= 0xFFFF) {
	+ bytes += 3;
	+ } else {
	+ bytes += 4;
	+ }
	+ }
	+ return bytes;
	+}
	+
	+/* Convert a Latin-1 string to a UTF-8 string */
	+static void LATIN1_to_UTF8(const char src, Uint8 dst)
	+{
	+ while (*src) {
	+ Uint8 ch = (Uint8)src++;
	+ if (ch <= 0x7F) {
	+ *dst++ = ch;
	+ } else {
	+ *dst++ = 0xC0 \| ((ch >> 6) & 0x1F);
	+ *dst++ = 0x80 \| (ch & 0x3F);
	+ }
	+ }
	+ *dst = '\0';
	+}
	+
	+/* Convert a UTF-16 string to a UTF-8 string */
	+static void UTF16_to_UTF8(const Uint16 src, Uint8 dst)
	+{
	+ int swapped = TTF_byteswapped;
	+
	+ while (*src) {
	+ Uint16 ch = *src++;
	+ if (ch == UNICODE_BOM_NATIVE) {
	+ swapped = 0;
	+ continue;
	+ }
	+ if (ch == UNICODE_BOM_SWAPPED) {
	+ swapped = 1;
	+ continue;
	+ }
	+ if (swapped) {
	+ ch = SDL_Swap16(ch);
	+ }
	+ if (ch <= 0x7F) {
	+ *dst++ = (Uint8) ch;
	+ } else if (ch <= 0x7FF) {
	+ *dst++ = 0xC0 \| (Uint8) ((ch >> 6) & 0x1F);
	+ *dst++ = 0x80 \| (Uint8) (ch & 0x3F);
	+ } else if (ch >= 0xD800 && ch <= 0xDBFF) { /* high surrogate */
	+ Uint32 ch2 = 0x10000 + ((ch - 0xD800) << 10);
	+ ch = src; / get next character */
	+ if (ch) src++; /* and advance to next character unless current character is '\0' */
	+ if (ch >= 0xDC00 && ch <= 0xDFFF) { /* low surrogate */
	+ ch2 += ch - 0xDC00;
	+ *dst++ = 0xF0 \| (Uint8) ((ch2 >> 18) & 0x07);
	+ *dst++ = 0x80 \| (Uint8) ((ch2 >> 12) & 0x3F);
	+ *dst++ = 0x80 \| (Uint8) ((ch2 >> 6) & 0x3F);
	+ *dst++ = 0x80 \| (Uint8) (ch2 & 0x3F);
	+ } else { /* invalid */
	+ dst++ = 0xEF; dst++ = 0xBF; dst++ = 0xBD; / UTF-8 EF BF BD == 0xFFFD == replacement character */
	+ }
	+ } else {
	+ if (ch >= 0xDC00 && ch <= 0xDFFF) { /* low surrogate, which is invalid alone */
	+ dst++ = 0xEF; dst++ = 0xBF; dst++ = 0xBD; / UTF-8 EF BF BD == 0xFFFD == replacement character */
	+ } else {
	+ *dst++ = 0xE0 \| (Uint8) ((ch >> 12) & 0x0F);
	+ *dst++ = 0x80 \| (Uint8) ((ch >> 6) & 0x3F);
	+ *dst++ = 0x80 \| (Uint8) (ch & 0x3F);
	+ }
	+ }
	+ }
	+ *dst = '\0';
	+}
	+
	+/* Convert a UTF-32 string to a UTF-8 string */
	+static void UTF32_to_UTF8(const Uint32 src, Uint8 dst)
	+{
	+ while (*src) {
	+ Uint32 ch = *src++;
	+ if (ch <= 0x7F) {
	+ *dst++ = (Uint8) ch;
	+ } else if (ch <= 0x7FF) {
	+ *dst++ = 0xC0 \| (Uint8) ((ch >> 6) & 0x1F);
	+ *dst++ = 0x80 \| (Uint8) (ch & 0x3F);
	+ } else if ((ch >= 0xD800 && ch <= 0xDFFF) \|\| ch >= 0x10FFFF) { /* surrogate or out of Unicode range */
	+ dst++ = 0xEF; dst++ = 0xBF; dst++ = 0xBD; / UTF-8 EF BF BD == 0xFFFD == replacement character */
	+ } else if (ch <= 0xFFFF) {
	+ *dst++ = 0xE0 \| (Uint8) ((ch >> 12) & 0x0F);
	+ *dst++ = 0x80 \| (Uint8) ((ch >> 6) & 0x3F);
	+ *dst++ = 0x80 \| (Uint8) (ch & 0x3F);
	+ } else {
	+ *dst++ = 0xF0 \| (Uint8) ((ch >> 18) & 0x07);
	+ *dst++ = 0x80 \| (Uint8) ((ch >> 12) & 0x3F);
	+ *dst++ = 0x80 \| (Uint8) ((ch >> 6) & 0x3F);
	+ *dst++ = 0x80 \| (Uint8) (ch & 0x3F);
	+ }
	+ }
	+ *dst = '\0';
	+}
	+
	+/* Gets a unicode value from a UTF-8 encoded string and advance the string */
	+#define UNKNOWN_UNICODE 0xFFFD
	+static Uint32 UTF8_getch(const char *src, size_t srclen)
	+{
	+ const Uint8 p = (const Uint8**)src;
	+ size_t left = 0;
	+ SDL_bool overlong = SDL_FALSE;
	+ SDL_bool underflow = SDL_FALSE;
	+ Uint32 ch = UNKNOWN_UNICODE;
	+
	+ if (*srclen == 0) {
	+ return UNKNOWN_UNICODE;
	+ }
	+ if (p[0] >= 0xFC) {
	+ if ((p[0] & 0xFE) == 0xFC) {
	+ if (p[0] == 0xFC && (p[1] & 0xFC) == 0x80) {
	+ overlong = SDL_TRUE;
	+ }
	+ ch = (Uint32) (p[0] & 0x01);
	+ left = 5;
	+ }
	+ } else if (p[0] >= 0xF8) {
	+ if ((p[0] & 0xFC) == 0xF8) {
	+ if (p[0] == 0xF8 && (p[1] & 0xF8) == 0x80) {
	+ overlong = SDL_TRUE;
	+ }
	+ ch = (Uint32) (p[0] & 0x03);
	+ left = 4;
	+ }
	+ } else if (p[0] >= 0xF0) {
	+ if ((p[0] & 0xF8) == 0xF0) {
	+ if (p[0] == 0xF0 && (p[1] & 0xF0) == 0x80) {
	+ overlong = SDL_TRUE;
	+ }
	+ ch = (Uint32) (p[0] & 0x07);
	+ left = 3;
	+ }
	+ } else if (p[0] >= 0xE0) {
	+ if ((p[0] & 0xF0) == 0xE0) {
	+ if (p[0] == 0xE0 && (p[1] & 0xE0) == 0x80) {
	+ overlong = SDL_TRUE;
	+ }
	+ ch = (Uint32) (p[0] & 0x0F);
	+ left = 2;
	+ }
	+ } else if (p[0] >= 0xC0) {
	+ if ((p[0] & 0xE0) == 0xC0) {
	+ if ((p[0] & 0xDE) == 0xC0) {
	+ overlong = SDL_TRUE;
	+ }
	+ ch = (Uint32) (p[0] & 0x1F);
	+ left = 1;
	+ }
	+ } else {
	+ if ((p[0] & 0x80) == 0x00) {
	+ ch = (Uint32) p[0];
	+ }
	+ }
	+ ++*src;
	+ --*srclen;
	+ while (left > 0 && *srclen > 0) {
	+ ++p;
	+ if ((p[0] & 0xC0) != 0x80) {
	+ ch = UNKNOWN_UNICODE;
	+ break;
	+ }
	+ ch <<= 6;
	+ ch \|= (p[0] & 0x3F);
	+ ++*src;
	+ --*srclen;
	+ --left;
	+ }
	+ if (left > 0) {
	+ underflow = SDL_TRUE;
	+ }
	+ /* Technically overlong sequences are invalid and should not be interpreted.
	+ However, it doesn't cause a security risk here and I don't see any harm in
	+ displaying them. The application is responsible for any other side effects
	+ of allowing overlong sequences (e.g. string compares failing, etc.)
	+ See bug 1931 for sample input that triggers this.
	+ */
	+ /if (overlong) return UNKNOWN_UNICODE;/
	+ if (underflow \|\|
	+ (ch >= 0xD800 && ch <= 0xDFFF) \|\|
	+ (ch == 0xFFFE \|\| ch == 0xFFFF) \|\| ch > 0x10FFFF) {
	+ ch = UNKNOWN_UNICODE;
	+ }
	+ return ch;
	+}
	+
	+int TTF_FontHeight(const TTF_Font *font)
	+{
	+ return(font->height);
	+}
	+
	+int TTF_FontAscent(const TTF_Font *font)
	+{
	+ return(font->ascent);
	+}
	+
	+int TTF_FontDescent(const TTF_Font *font)
	+{
	+ return(font->descent);
	+}
	+
	+int TTF_FontLineSkip(const TTF_Font *font)
	+{
	+ return(font->lineskip);
	+}
	+
	+int TTF_GetFontKerning(const TTF_Font *font)
	+{
	+ return(font->kerning);
	+}
	+
	+void TTF_SetFontKerning(TTF_Font *font, int allowed)
	+{
	+ font->kerning = allowed;
	+}
	+
	+long TTF_FontFaces(const TTF_Font *font)
	+{
	+ return(font->face->num_faces);
	+}
	+
	+int TTF_FontFaceIsFixedWidth(const TTF_Font *font)
	+{
	+ return(FT_IS_FIXED_WIDTH(font->face));
	+}
	+
	+char TTF_FontFaceFamilyName(const TTF_Font font)
	+{
	+ return(font->face->family_name);
	+}
	+
	+char TTF_FontFaceStyleName(const TTF_Font font)
	+{
	+ return(font->face->style_name);
	+}
	+
	+int TTF_GlyphIsProvided(const TTF_Font *font, Uint32 ch)
	+{
	+ return(FT_Get_Char_Index(font->face, ch));
	+}
	+
	+int TTF_GlyphMetrics(TTF_Font *font, Uint32 ch,
	+ int* minx, int* maxx, int* miny, int* maxy, int* advance)
	+{
	+ FT_Error error;
	+
	+ error = Find_Glyph(font, ch, CACHED_METRICS);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ return -1;
	+ }
	+
	+ if (minx) {
	+ *minx = font->current->minx;
	+ }
	+ if (maxx) {
	+ *maxx = font->current->maxx;
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ *maxx += font->glyph_overhang;
	+ }
	+ }
	+ if (miny) {
	+ *miny = font->current->miny;
	+ }
	+ if (maxy) {
	+ *maxy = font->current->maxy;
	+ }
	+ if (advance) {
	+ *advance = font->current->advance;
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ *advance += font->glyph_overhang;
	+ }
	+ }
	+ return 0;
	+}
	+
	+int TTF_SizeText(TTF_Font font, const char text, int w, int h)
	+{
	+ int status = -1;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, -1);
	+
	+ utf8 = SDL_stack_alloc(Uint8, LATIN1_to_UTF8_len(text));
	+ if (utf8) {
	+ LATIN1_to_UTF8(text, utf8);
	+ status = TTF_SizeUTF8(font, (char *)utf8, w, h);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return status;
	+}
	+
	+int TTF_SizeUTF8(TTF_Font font, const char text, int w, int h)
	+{
	+ int status;
	+ int x, z;
	+ int minx, maxx;
	+ int miny, maxy;
	+ c_glyph *glyph;
	+ FT_Error error;
	+ FT_Long use_kerning;
	+ FT_Face prev_face = 0;
	+ FT_UInt prev_index = 0;
	+ int outline_delta = 0;
	+ size_t textlen;
	+
	+ TTF_CHECKPOINTER(text, -1);
	+
	+ /* Initialize everything to 0 */
	+ status = 0;
	+ minx = maxx = 0;
	+ miny = maxy = 0;
	+
	+ /* check kerning */
	+ use_kerning = FT_HAS_KERNING(font->face) && font->kerning;
	+
	+ /* Init outline handling */
	+ if (font->outline > 0) {
	+ outline_delta = font->outline * 2;
	+ }
	+
	+ /* Load each character and sum it's bounding box */
	+ textlen = SDL_strlen(text);
	+ x= 0;
	+ while (textlen > 0) {
	+ Uint32 c = UTF8_getch(&text, &textlen);
	+ if (c == UNICODE_BOM_NATIVE \|\| c == UNICODE_BOM_SWAPPED) {
	+ continue;
	+ }
	+
	+ error = Find_Glyph(font, c, CACHED_METRICS);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ return -1;
	+ }
	+ glyph = font->current;
	+
	+ /* handle kerning */
	+ if (use_kerning && prev_index && glyph->index && prev_face == glyph->face) {
	+ FT_Vector delta;
	+ FT_Get_Kerning(glyph->face, prev_index, glyph->index, ft_kerning_default, &delta);
	+ x += delta.x >> 6;
	+ }
	+
	+#if 0
	+ if ((ch == text) && (glyph->minx < 0)) {
	+ /* Fixes the texture wrapping bug when the first letter
	+ * has a negative minx value or horibearing value. The entire
	+ * bounding box must be adjusted to be bigger so the entire
	+ * letter can fit without any texture corruption or wrapping.
	+ *
	+ * Effects: First enlarges bounding box.
	+ * Second, xstart has to start ahead of its normal spot in the
	+ * negative direction of the negative minx value.
	+ * (pushes everything to the right).
	+ *
	+ * This will make the memory copy of the glyph bitmap data
	+ * work out correctly.
	+ * */
	+ z -= glyph->minx;
	+ }
	+#endif
	+
	+ z = x + glyph->minx;
	+ if (minx > z) {
	+ minx = z;
	+ }
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ x += font->glyph_overhang;
	+ }
	+ if (glyph->advance > glyph->maxx) {
	+ z = x + glyph->advance;
	+ } else {
	+ z = x + glyph->maxx;
	+ }
	+ if (maxx < z) {
	+ maxx = z;
	+ }
	+ x += glyph->advance;
	+
	+ if (glyph->miny < miny) {
	+ miny = glyph->miny;
	+ }
	+ if (glyph->maxy > maxy) {
	+ maxy = glyph->maxy;
	+ }
	+ prev_face = glyph->face;
	+ prev_index = glyph->index;
	+ }
	+
	+ /* Fill the bounds rectangle */
	+ if (w) {
	+ /* Add outline extra width */
	+ *w = (maxx - minx) + outline_delta;
	+ }
	+ if (h) {
	+ /* Some fonts descend below font height (FletcherGothicFLF) */
	+ /* Add outline extra height */
	+ *h = (font->ascent - miny) + outline_delta;
	+ if (*h < font->height) {
	+ *h = font->height;
	+ }
	+ /* Update height according to the needs of the underline style */
	+ if (TTF_HANDLE_STYLE_UNDERLINE(font)) {
	+ int bottom_row = TTF_underline_bottom_row(font);
	+ if (*h < bottom_row) {
	+ *h = bottom_row;
	+ }
	+ }
	+ }
	+ return status;
	+}
	+
	+int TTF_SizeUNICODE(TTF_Font font, const Uint16 text, int w, int h)
	+{
	+ int status = -1;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, -1);
	+
	+ utf8 = SDL_stack_alloc(Uint8, UTF16_to_UTF8_len(text));
	+ if (utf8) {
	+ UTF16_to_UTF8(text, utf8);
	+ status = TTF_SizeUTF8(font, (char *)utf8, w, h);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return status;
	+}
	+
	+SDL_Surface TTF_RenderText_Solid(TTF_Font font,
	+ const char *text, SDL_Color fg)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, LATIN1_to_UTF8_len(text));
	+ if (utf8) {
	+ LATIN1_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Solid(font, (char *)utf8, fg);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+SDL_Surface TTF_RenderUTF8_Solid(TTF_Font font,
	+ const char *text, SDL_Color fg)
	+{
	+ int xstart;
	+ int width;
	+ int height;
	+ SDL_Surface* textbuf;
	+ SDL_Palette* palette;
	+ Uint8* src;
	+ Uint8* dst;
	+ Uint8 *dst_check;
	+ int row, col;
	+ c_glyph *glyph;
	+
	+ FT_Bitmap *current;
	+ FT_Error error;
	+ FT_Long use_kerning;
	+ FT_Face prev_face = 0;
	+ FT_UInt prev_index = 0;
	+ size_t textlen;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ /* Get the dimensions of the text surface */
	+ if ((TTF_SizeUTF8(font, text, &width, &height) < 0) \|\| !width) {
	+ TTF_SetError("Text has zero width");
	+ return NULL;
	+ }
	+
	+ /* Create the target surface */
	+ textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 8, 0, 0, 0, 0);
	+ if (textbuf == NULL) {
	+ return NULL;
	+ }
	+
	+ /* Adding bound checking to avoid all kinds of memory corruption errors
	+ that may occur. */
	+ dst_check = (Uint8)textbuf->pixels + textbuf->pitch textbuf->h;
	+
	+ /* Fill the palette with the foreground color */
	+ palette = textbuf->format->palette;
	+ palette->colors[0].r = 255 - fg.r;
	+ palette->colors[0].g = 255 - fg.g;
	+ palette->colors[0].b = 255 - fg.b;
	+ palette->colors[1].r = fg.r;
	+ palette->colors[1].g = fg.g;
	+ palette->colors[1].b = fg.b;
	+ palette->colors[1].a = fg.a ? fg.a : SDL_ALPHA_OPAQUE;
	+ SDL_SetColorKey(textbuf, SDL_TRUE, 0);
	+
	+ /* check kerning */
	+ use_kerning = FT_HAS_KERNING(font->face) && font->kerning;
	+
	+ /* Load and render each character */
	+ textlen = SDL_strlen(text);
	+ xstart = 0;
	+ while (textlen > 0) {
	+ Uint32 c = UTF8_getch(&text, &textlen);
	+ if (c == UNICODE_BOM_NATIVE \|\| c == UNICODE_BOM_SWAPPED) {
	+ continue;
	+ }
	+
	+ error = Find_Glyph(font, c, CACHED_METRICS\|CACHED_BITMAP);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ SDL_FreeSurface(textbuf);
	+ return NULL;
	+ }
	+ glyph = font->current;
	+ current = &glyph->bitmap;
	+ /* Ensure the width of the pixmap is correct. On some cases,
	+ * freetype may report a larger pixmap than possible.*/
	+ width = current->width;
	+ if (font->outline <= 0 && width > glyph->maxx - glyph->minx) {
	+ width = glyph->maxx - glyph->minx;
	+ }
	+ /* do kerning, if possible AC-Patch */
	+ if (use_kerning && prev_index && glyph->index && prev_face == glyph->face) {
	+ FT_Vector delta;
	+ FT_Get_Kerning(glyph->face, prev_index, glyph->index, ft_kerning_default, &delta);
	+ xstart += delta.x >> 6;
	+ }
	+
	+ for (row = 0; row < current->rows; ++row) {
	+ /* Make sure we don't go either over, or under the limit */
	+ if ((xstart + glyph->minx) < 0) {
	+ xstart -= (xstart + glyph->minx);
	+ }
	+ if ((row + glyph->yoffset) < 0) {
	+ continue;
	+ }
	+ if ((row + glyph->yoffset) >= textbuf->h) {
	+ continue;
	+ }
	+ dst = (Uint8 *)textbuf->pixels +
	+ (row+glyph->yoffset) * textbuf->pitch +
	+ xstart + glyph->minx;
	+ src = current->buffer + row * current->pitch;
	+ for (col = width; col > 0 && dst < dst_check; --col) {
	+ dst++ \|= src++;
	+ }
	+ }
	+
	+ xstart += glyph->advance;
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ xstart += font->glyph_overhang;
	+ }
	+ prev_face = glyph->face;
	+ prev_index = glyph->index;
	+ }
	+
	+ /* Handle the underline style */
	+ if (TTF_HANDLE_STYLE_UNDERLINE(font)) {
	+ row = TTF_underline_top_row(font);
	+ TTF_drawLine_Solid(font, textbuf, row);
	+ }
	+
	+ /* Handle the strikethrough style */
	+ if (TTF_HANDLE_STYLE_STRIKETHROUGH(font)) {
	+ row = TTF_strikethrough_top_row(font);
	+ TTF_drawLine_Solid(font, textbuf, row);
	+ }
	+ return textbuf;
	+}
	+
	+SDL_Surface TTF_RenderUNICODE_Solid(TTF_Font font,
	+ const Uint16 *text, SDL_Color fg)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, UTF16_to_UTF8_len(text));
	+ if (utf8) {
	+ UTF16_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Solid(font, (char *)utf8, fg);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+SDL_Surface TTF_RenderGlyph_Solid(TTF_Font font, Uint32 ch, SDL_Color fg)
	+{
	+ Uint32 utf32[2] = { ch, 0 };
	+ Uint8 utf8[8];
	+
	+ UTF32_to_UTF8(utf32, utf8);
	+ return TTF_RenderUTF8_Solid(font, (char *)utf8, fg);
	+}
	+
	+SDL_Surface TTF_RenderText_Shaded(TTF_Font font,
	+ const char *text, SDL_Color fg, SDL_Color bg)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, LATIN1_to_UTF8_len(text));
	+ if (utf8) {
	+ LATIN1_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Shaded(font, (char *)utf8, fg, bg);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+/* Convert the UTF-8 text to UNICODE and render it
	+*/
	+SDL_Surface TTF_RenderUTF8_Shaded(TTF_Font font,
	+ const char *text, SDL_Color fg, SDL_Color bg)
	+{
	+ int xstart;
	+ int width;
	+ int height;
	+ SDL_Surface* textbuf;
	+ SDL_Palette* palette;
	+ int index;
	+ int rdiff;
	+ int gdiff;
	+ int bdiff;
	+ int adiff;
	+ Uint8* src;
	+ Uint8* dst;
	+ Uint8* dst_check;
	+ int row, col;
	+ FT_Bitmap* current;
	+ c_glyph *glyph;
	+ FT_Error error;
	+ FT_Long use_kerning;
	+ FT_Face prev_face = 0;
	+ FT_UInt prev_index = 0;
	+ size_t textlen;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ /* Get the dimensions of the text surface */
	+ if ((TTF_SizeUTF8(font, text, &width, &height) < 0) \|\| !width) {
	+ TTF_SetError("Text has zero width");
	+ return NULL;
	+ }
	+
	+ /* Create the target surface */
	+ textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 8, 0, 0, 0, 0);
	+ if (textbuf == NULL) {
	+ return NULL;
	+ }
	+
	+ /* Adding bound checking to avoid all kinds of memory corruption errors
	+ that may occur. */
	+ dst_check = (Uint8)textbuf->pixels + textbuf->pitch textbuf->h;
	+
	+ /* Support alpha blending */
	+ if (!fg.a) {
	+ fg.a = SDL_ALPHA_OPAQUE;
	+ }
	+ if (!bg.a) {
	+ bg.a = SDL_ALPHA_OPAQUE;
	+ }
	+ if (fg.a != SDL_ALPHA_OPAQUE \|\| bg.a != SDL_ALPHA_OPAQUE) {
	+ SDL_SetSurfaceBlendMode(textbuf, SDL_BLENDMODE_BLEND);
	+ }
	+
	+ /* Fill the palette with NUM_GRAYS levels of shading from bg to fg */
	+ palette = textbuf->format->palette;
	+ rdiff = fg.r - bg.r;
	+ gdiff = fg.g - bg.g;
	+ bdiff = fg.b - bg.b;
	+ adiff = fg.a - bg.a;
	+
	+ for (index = 0; index < NUM_GRAYS; ++index) {
	+ palette->colors[index].r = bg.r + (index*rdiff) / (NUM_GRAYS-1);
	+ palette->colors[index].g = bg.g + (index*gdiff) / (NUM_GRAYS-1);
	+ palette->colors[index].b = bg.b + (index*bdiff) / (NUM_GRAYS-1);
	+ palette->colors[index].a = bg.a + (index*adiff) / (NUM_GRAYS-1);
	+ }
	+
	+ /* check kerning */
	+ use_kerning = FT_HAS_KERNING(font->face) && font->kerning;
	+
	+ /* Load and render each character */
	+ textlen = SDL_strlen(text);
	+ xstart = 0;
	+ while (textlen > 0) {
	+ Uint32 c = UTF8_getch(&text, &textlen);
	+ if (c == UNICODE_BOM_NATIVE \|\| c == UNICODE_BOM_SWAPPED) {
	+ continue;
	+ }
	+
	+ error = Find_Glyph(font, c, CACHED_METRICS\|CACHED_PIXMAP);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ SDL_FreeSurface(textbuf);
	+ return NULL;
	+ }
	+ glyph = font->current;
	+ /* Ensure the width of the pixmap is correct. On some cases,
	+ * freetype may report a larger pixmap than possible.*/
	+ width = glyph->pixmap.width;
	+ if (font->outline <= 0 && width > glyph->maxx - glyph->minx) {
	+ width = glyph->maxx - glyph->minx;
	+ }
	+ /* do kerning, if possible AC-Patch */
	+ if (use_kerning && prev_index && glyph->index && prev_face == glyph->face) {
	+ FT_Vector delta;
	+ FT_Get_Kerning(glyph->face, prev_index, glyph->index, ft_kerning_default, &delta);
	+ xstart += delta.x >> 6;
	+ }
	+
	+ current = &glyph->pixmap;
	+ for (row = 0; row < current->rows; ++row) {
	+ /* Make sure we don't go either over, or under the limit */
	+ if ((xstart + glyph->minx) < 0) {
	+ xstart -= (xstart + glyph->minx);
	+ }
	+ if ((row + glyph->yoffset) < 0) {
	+ continue;
	+ }
	+ if ((row + glyph->yoffset) >= textbuf->h) {
	+ continue;
	+ }
	+ dst = (Uint8 *)textbuf->pixels +
	+ (row+glyph->yoffset) * textbuf->pitch +
	+ xstart + glyph->minx;
	+ src = current->buffer + row * current->pitch;
	+ for (col = width; col > 0 && dst < dst_check; --col) {
	+ dst++ \|= src++;
	+ }
	+ }
	+
	+ xstart += glyph->advance;
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ xstart += font->glyph_overhang;
	+ }
	+ prev_face = glyph->face;
	+ prev_index = glyph->index;
	+ }
	+
	+ /* Handle the underline style */
	+ if (TTF_HANDLE_STYLE_UNDERLINE(font)) {
	+ row = TTF_underline_top_row(font);
	+ TTF_drawLine_Shaded(font, textbuf, row);
	+ }
	+
	+ /* Handle the strikethrough style */
	+ if (TTF_HANDLE_STYLE_STRIKETHROUGH(font)) {
	+ row = TTF_strikethrough_top_row(font);
	+ TTF_drawLine_Shaded(font, textbuf, row);
	+ }
	+ return textbuf;
	+}
	+
	+SDL_Surface* TTF_RenderUNICODE_Shaded(TTF_Font* font,
	+ const Uint16* text,
	+ SDL_Color fg,
	+ SDL_Color bg)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, UTF16_to_UTF8_len(text));
	+ if (utf8) {
	+ UTF16_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Shaded(font, (char *)utf8, fg, bg);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+SDL_Surface* TTF_RenderGlyph_Shaded(TTF_Font* font,
	+ Uint32 ch,
	+ SDL_Color fg,
	+ SDL_Color bg)
	+{
	+ Uint32 utf32[2] = { ch, 0 };
	+ Uint8 utf8[8];
	+
	+ UTF32_to_UTF8(utf32, utf8);
	+ return TTF_RenderUTF8_Shaded(font, (char *)utf8, fg, bg);
	+}
	+
	+SDL_Surface TTF_RenderText_Blended(TTF_Font font,
	+ const char *text, SDL_Color fg)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, LATIN1_to_UTF8_len(text));
	+ if (utf8) {
	+ LATIN1_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Blended(font, (char *)utf8, fg);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+SDL_Surface TTF_RenderUTF8_Blended(TTF_Font font,
	+ const char *text, SDL_Color fg)
	+{
	+ int i;
	+ int xstart;
	+ int width, height;
	+ SDL_Surface *textbuf;
	+ Uint8 alpha;
	+ Uint8 alpha_table[256];
	+ Uint32 pixel;
	+ Uint8 *src;
	+ Uint32 *dst;
	+ Uint32 *dst_check;
	+ int row, col;
	+ c_glyph *glyph;
	+ FT_Error error;
	+ FT_Long use_kerning;
	+ FT_Face prev_face = 0;
	+ FT_UInt prev_index = 0;
	+ size_t textlen;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ /* Get the dimensions of the text surface */
	+ if ((TTF_SizeUTF8(font, text, &width, &height) < 0) \|\| !width) {
	+ TTF_SetError("Text has zero width");
	+ return(NULL);
	+ }
	+
	+ /* Create the target surface */
	+ textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32,
	+ 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
	+ if (textbuf == NULL) {
	+ return(NULL);
	+ }
	+
	+ /* Adding bound checking to avoid all kinds of memory corruption errors
	+ that may occur. */
	+ dst_check = (Uint32)textbuf->pixels + textbuf->pitch/4 textbuf->h;
	+
	+ /* check kerning */
	+ use_kerning = FT_HAS_KERNING(font->face) && font->kerning;
	+
	+ /* Support alpha blending */
	+ if (!fg.a) {
	+ fg.a = SDL_ALPHA_OPAQUE;
	+ }
	+ if (fg.a == SDL_ALPHA_OPAQUE) {
	+ for (i = 0; i < SDL_arraysize(alpha_table); ++i) {
	+ alpha_table[i] = (Uint8)i;
	+ }
	+ } else {
	+ for (i = 0; i < SDL_arraysize(alpha_table); ++i) {
	+ alpha_table[i] = (Uint8)(i * fg.a / 255);
	+ }
	+ SDL_SetSurfaceBlendMode(textbuf, SDL_BLENDMODE_BLEND);
	+ }
	+
	+ /* Load and render each character */
	+ textlen = SDL_strlen(text);
	+ xstart = 0;
	+ pixel = (fg.r<<16)\|(fg.g<<8)\|fg.b;
	+ SDL_FillRect(textbuf, NULL, pixel); /* Initialize with fg and 0 alpha */
	+ while (textlen > 0) {
	+ Uint32 c = UTF8_getch(&text, &textlen);
	+ if (c == UNICODE_BOM_NATIVE \|\| c == UNICODE_BOM_SWAPPED) {
	+ continue;
	+ }
	+
	+ error = Find_Glyph(font, c, CACHED_METRICS\|CACHED_PIXMAP);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ SDL_FreeSurface(textbuf);
	+ return NULL;
	+ }
	+ glyph = font->current;
	+ /* Ensure the width of the pixmap is correct. On some cases,
	+ * freetype may report a larger pixmap than possible.*/
	+ width = glyph->pixmap.width;
	+ if (font->outline <= 0 && width > glyph->maxx - glyph->minx) {
	+ width = glyph->maxx - glyph->minx;
	+ }
	+ /* do kerning, if possible AC-Patch */
	+ if (use_kerning && prev_index && glyph->index && prev_face == glyph->face) {
	+ FT_Vector delta;
	+ FT_Get_Kerning(glyph->face, prev_index, glyph->index, ft_kerning_default, &delta);
	+ xstart += delta.x >> 6;
	+ }
	+
	+ for (row = 0; row < glyph->pixmap.rows; ++row) {
	+ /* Make sure we don't go either over, or under the limit */
	+ if ((xstart + glyph->minx) < 0) {
	+ xstart -= (xstart + glyph->minx);
	+ }
	+ if ((row + glyph->yoffset) < 0) {
	+ continue;
	+ }
	+ if ((row + glyph->yoffset) >= textbuf->h) {
	+ continue;
	+ }
	+ dst = (Uint32 *)textbuf->pixels +
	+ (row+glyph->yoffset) * textbuf->pitch/4 +
	+ xstart + glyph->minx;
	+ src = (Uint8)glyph->pixmap.buffer + row glyph->pixmap.pitch;
	+ for (col = width; col > 0 && dst < dst_check; --col) {
	+ alpha = *src++;
	+ *dst++ \|= pixel \| ((Uint32)alpha_table[alpha] << 24);
	+ }
	+ }
	+
	+ xstart += glyph->advance;
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ xstart += font->glyph_overhang;
	+ }
	+ prev_face = glyph->face;
	+ prev_index = glyph->index;
	+ }
	+
	+ /* Handle the underline style */
	+ if (TTF_HANDLE_STYLE_UNDERLINE(font)) {
	+ row = TTF_underline_top_row(font);
	+ TTF_drawLine_Blended(font, textbuf, row, pixel \| (Uint32)fg.a << 24);
	+ }
	+
	+ /* Handle the strikethrough style */
	+ if (TTF_HANDLE_STYLE_STRIKETHROUGH(font)) {
	+ row = TTF_strikethrough_top_row(font);
	+ TTF_drawLine_Blended(font, textbuf, row, pixel \| (Uint32)fg.a << 24);
	+ }
	+ return(textbuf);
	+}
	+
	+SDL_Surface TTF_RenderUNICODE_Blended(TTF_Font font,
	+ const Uint16 *text, SDL_Color fg)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, UTF16_to_UTF8_len(text));
	+ if (utf8) {
	+ UTF16_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Blended(font, (char *)utf8, fg);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+
	+SDL_Surface TTF_RenderText_Blended_Wrapped(TTF_Font font, const char *text, SDL_Color fg, Uint32 wrapLength)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, LATIN1_to_UTF8_len(text));
	+ if (utf8) {
	+ LATIN1_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Blended_Wrapped(font, (char *)utf8, fg, wrapLength);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+static SDL_bool CharacterIsDelimiter(char c, const char *delimiters)
	+{
	+ while (*delimiters) {
	+ if (c == *delimiters) {
	+ return SDL_TRUE;
	+ }
	+ ++delimiters;
	+ }
	+ return SDL_FALSE;
	+}
	+
	+/* Don't define this until we have a release where we can change font rendering
	+#define TTF_USE_LINESKIP
	+ */
	+SDL_Surface TTF_RenderUTF8_Blended_Wrapped(TTF_Font font,
	+ const char *text, SDL_Color fg, Uint32 wrapLength)
	+{
	+ int i;
	+ int xstart;
	+ int width, height;
	+ SDL_Surface *textbuf;
	+ Uint8 alpha;
	+ Uint8 alpha_table[256];
	+ Uint32 pixel;
	+ Uint8 *src;
	+ Uint32 *dst;
	+ Uint32 *dst_check;
	+ int row, col;
	+ c_glyph *glyph;
	+ FT_Error error;
	+ FT_Long use_kerning;
	+ FT_Face prev_face = 0;
	+ FT_UInt prev_index = 0;
	+#ifndef TTF_USE_LINESKIP
	+ const int lineSpace = 2;
	+#endif
	+ int line, numLines, rowSize;
	+ char str, strLines, *newLines;
	+ size_t textlen;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ /* Get the dimensions of the text surface */
	+ if ((TTF_SizeUTF8(font, text, &width, &height) < 0) \|\| !width) {
	+ TTF_SetError("Text has zero width");
	+ return(NULL);
	+ }
	+
	+ numLines = 1;
	+ str = NULL;
	+ strLines = NULL;
	+ if (wrapLength > 0 && *text) {
	+ const char *wrapDelims = " \t\r\n";
	+ int w, h;
	+ char spot, tok, next_tok, end;
	+ char delim;
	+ size_t str_len = SDL_strlen(text);
	+
	+ numLines = 0;
	+
	+ str = SDL_stack_alloc(char, str_len+1);
	+ if (str == NULL) {
	+ TTF_SetError("Out of memory");
	+ return(NULL);
	+ }
	+
	+ SDL_strlcpy(str, text, str_len+1);
	+ tok = str;
	+ end = str + str_len;
	+ do {
	+ newLines = (char *)SDL_realloc(strLines, (numLines+1)sizeof(*strLines));
	+ if (!newLines) {
	+ TTF_SetError("Out of memory");
	+ SDL_free(strLines);
	+ SDL_stack_free(str);
	+ return(NULL);
	+ }
	+ strLines = newLines;
	+ strLines[numLines++] = tok;
	+
	+ /* Look for the end of the line */
	+ if ((spot = SDL_strchr(tok, '\r')) != NULL \|\|
	+ (spot = SDL_strchr(tok, '\n')) != NULL) {
	+ if (*spot == '\r') {
	+ ++spot;
	+ }
	+ if (*spot == '\n') {
	+ ++spot;
	+ }
	+ } else {
	+ spot = end;
	+ }
	+ next_tok = spot;
	+
	+ /* Get the longest string that will fit in the desired space */
	+ for (; ;) {
	+ /* Strip trailing whitespace */
	+ while (spot > tok &&
	+ CharacterIsDelimiter(spot[-1], wrapDelims)) {
	+ --spot;
	+ }
	+ if (spot == tok) {
	+ if (CharacterIsDelimiter(*spot, wrapDelims)) {
	+ *spot = '\0';
	+ }
	+ break;
	+ }
	+ delim = *spot;
	+ *spot = '\0';
	+
	+ TTF_SizeUTF8(font, tok, &w, &h);
	+ if ((Uint32)w <= wrapLength) {
	+ break;
	+ } else {
	+ /* Back up and try again... */
	+ *spot = delim;
	+ }
	+
	+ while (spot > tok &&
	+ !CharacterIsDelimiter(spot[-1], wrapDelims)) {
	+ --spot;
	+ }
	+ if (spot > tok) {
	+ next_tok = spot;
	+ }
	+ }
	+ tok = next_tok;
	+ } while (tok < end);
	+ }
	+
	+ /* Create the target surface */
	+ textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE,
	+ (numLines > 1) ? wrapLength : width,
	+#ifdef TTF_USE_LINESKIP
	+ numLines * TTF_FontLineSkip(font),
	+#else
	+ height * numLines + (lineSpace * (numLines - 1)),
	+#endif
	+ 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
	+ if (textbuf == NULL) {
	+ if (strLines) {
	+ SDL_free(strLines);
	+ SDL_stack_free(str);
	+ }
	+ return(NULL);
	+ }
	+
	+#ifdef TTF_USE_LINESKIP
	+ rowSize = textbuf->pitch/4 * TTF_FontLineSkip(font);
	+#else
	+ rowSize = textbuf->pitch/4 * height;
	+#endif
	+
	+ /* Adding bound checking to avoid all kinds of memory corruption errors
	+ that may occur. */
	+ dst_check = (Uint32)textbuf->pixels + textbuf->pitch/4 textbuf->h;
	+
	+ /* check kerning */
	+ use_kerning = FT_HAS_KERNING(font->face) && font->kerning;
	+
	+ /* Support alpha blending */
	+ if (!fg.a) {
	+ fg.a = SDL_ALPHA_OPAQUE;
	+ }
	+ if (fg.a == SDL_ALPHA_OPAQUE) {
	+ for (i = 0; i < SDL_arraysize(alpha_table); ++i) {
	+ alpha_table[i] = (Uint8)i;
	+ }
	+ } else {
	+ for (i = 0; i < SDL_arraysize(alpha_table); ++i) {
	+ alpha_table[i] = (Uint8)(i * fg.a / 255);
	+ }
	+ SDL_SetSurfaceBlendMode(textbuf, SDL_BLENDMODE_BLEND);
	+ }
	+
	+ /* Load and render each character */
	+ pixel = (fg.r<<16)\|(fg.g<<8)\|fg.b;
	+ SDL_FillRect(textbuf, NULL, pixel); /* Initialize with fg and 0 alpha */
	+
	+ for (line = 0; line < numLines; line++) {
	+ if (strLines) {
	+ text = strLines[line];
	+ }
	+ textlen = SDL_strlen(text);
	+ prev_face = 0;
	+ prev_index = 0;
	+ xstart = 0;
	+ while (textlen > 0) {
	+ Uint32 c = UTF8_getch(&text, &textlen);
	+ if (c == UNICODE_BOM_NATIVE \|\| c == UNICODE_BOM_SWAPPED) {
	+ continue;
	+ }
	+
	+ error = Find_Glyph(font, c, CACHED_METRICS\|CACHED_PIXMAP);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ SDL_FreeSurface(textbuf);
	+ if (strLines) {
	+ SDL_free(strLines);
	+ SDL_stack_free(str);
	+ }
	+ return NULL;
	+ }
	+ glyph = font->current;
	+ /* Ensure the width of the pixmap is correct. On some cases,
	+ * freetype may report a larger pixmap than possible.*/
	+ width = glyph->pixmap.width;
	+ if (font->outline <= 0 && width > glyph->maxx - glyph->minx) {
	+ width = glyph->maxx - glyph->minx;
	+ }
	+ /* do kerning, if possible AC-Patch */
	+ if (use_kerning && prev_index && glyph->index && prev_face == glyph->face) {
	+ FT_Vector delta;
	+ FT_Get_Kerning(glyph->face, prev_index, glyph->index, ft_kerning_default, &delta);
	+ xstart += delta.x >> 6;
	+ }
	+
	+ for (row = 0; row < glyph->pixmap.rows; ++row) {
	+ /* Make sure we don't go either over, or under the limit */
	+ if ((xstart + glyph->minx) < 0) {
	+ xstart -= (xstart + glyph->minx);
	+ }
	+ if ((row + glyph->yoffset) < 0) {
	+ continue;
	+ }
	+ if ((row + glyph->yoffset) >= textbuf->h) {
	+ continue;
	+ }
	+ dst = ((Uint32)textbuf->pixels + rowSize line) +
	+ (row+glyph->yoffset) * textbuf->pitch/4 +
	+ xstart + glyph->minx;
	+ src = (Uint8)glyph->pixmap.buffer + row glyph->pixmap.pitch;
	+ for (col = width; col > 0 && dst < dst_check; --col) {
	+ alpha = *src++;
	+ *dst++ \|= pixel \| ((Uint32)alpha_table[alpha] << 24);
	+ }
	+ }
	+
	+ xstart += glyph->advance;
	+ if (TTF_HANDLE_STYLE_BOLD(font)) {
	+ xstart += font->glyph_overhang;
	+ }
	+ prev_face = glyph->face;
	+ prev_index = glyph->index;
	+ }
	+
	+ /* Handle the underline style *
	+ if (TTF_HANDLE_STYLE_UNDERLINE(font)) {
	+ row = TTF_underline_top_row(font);
	+ TTF_drawLine_Blended(font, textbuf, row, pixel \| (Uint32)fg.a << 24);
	+ }
	+ */
	+
	+ /* Handle the strikethrough style *
	+ if (TTF_HANDLE_STYLE_STRIKETHROUGH(font)) {
	+ row = TTF_strikethrough_top_row(font);
	+ TTF_drawLine_Blended(font, textbuf, row, pixel \| (Uint32)fg.a << 24);
	+ }
	+ */
	+ }
	+
	+ if (strLines) {
	+ SDL_free(strLines);
	+ SDL_stack_free(str);
	+ }
	+ return(textbuf);
	+}
	+
	+SDL_Surface TTF_RenderUNICODE_Blended_Wrapped(TTF_Font font, const Uint16* text,
	+ SDL_Color fg, Uint32 wrapLength)
	+{
	+ SDL_Surface *surface = NULL;
	+ Uint8 *utf8;
	+
	+ TTF_CHECKPOINTER(text, NULL);
	+
	+ utf8 = SDL_stack_alloc(Uint8, UTF16_to_UTF8_len(text));
	+ if (utf8) {
	+ UTF16_to_UTF8(text, utf8);
	+ surface = TTF_RenderUTF8_Blended_Wrapped(font, (char *)utf8, fg, wrapLength);
	+ SDL_stack_free(utf8);
	+ } else {
	+ SDL_OutOfMemory();
	+ }
	+ return surface;
	+}
	+
	+SDL_Surface TTF_RenderGlyph_Blended(TTF_Font font, Uint32 ch, SDL_Color fg)
	+{
	+ Uint32 utf32[2] = { ch, 0 };
	+ Uint8 utf8[8];
	+
	+ UTF32_to_UTF8(utf32, utf8);
	+ return TTF_RenderUTF8_Blended(font, (char *)utf8, fg);
	+}
	+
	+void TTF_SetFontStyle(TTF_Font* font, int style)
	+{
	+ int prev_style = font->style;
	+ font->style = style \| font->face_style;
	+
	+ /* Flush the cache if the style has changed.
	+ * Ignore UNDERLINE which does not impact glyph drawning.
	+ * */
	+ if ((font->style \| TTF_STYLE_NO_GLYPH_CHANGE) != (prev_style \| TTF_STYLE_NO_GLYPH_CHANGE)) {
	+ Flush_Cache(font);
	+ }
	+}
	+
	+int TTF_GetFontStyle(const TTF_Font* font)
	+{
	+ return font->style;
	+}
	+
	+void TTF_SetFontOutline(TTF_Font* font, int outline)
	+{
	+ font->outline = outline;
	+ Flush_Cache(font);
	+}
	+
	+int TTF_GetFontOutline(const TTF_Font* font)
	+{
	+ return font->outline;
	+}
	+
	+void TTF_SetFontHinting(TTF_Font* font, int hinting)
	+{
	+ if (hinting == TTF_HINTING_LIGHT)
	+ font->hinting = FT_LOAD_TARGET_LIGHT;
	+ else if (hinting == TTF_HINTING_MONO)
	+ font->hinting = FT_LOAD_TARGET_MONO;
	+ else if (hinting == TTF_HINTING_NONE)
	+ font->hinting = FT_LOAD_NO_HINTING;
	+ else
	+ font->hinting = 0;
	+
	+ Flush_Cache(font);
	+}
	+
	+int TTF_GetFontHinting(const TTF_Font* font)
	+{
	+ if (font->hinting == FT_LOAD_TARGET_LIGHT)
	+ return TTF_HINTING_LIGHT;
	+ else if (font->hinting == FT_LOAD_TARGET_MONO)
	+ return TTF_HINTING_MONO;
	+ else if (font->hinting == FT_LOAD_NO_HINTING)
	+ return TTF_HINTING_NONE;
	+ return 0;
	+}
	+
	+void TTF_Quit(void)
	+{
	+ if (TTF_initialized) {
	+ if (--TTF_initialized == 0) {
	+ FT_Done_FreeType(library);
	+ }
	+ }
	+}
	+
	+int TTF_WasInit(void)
	+{
	+ return TTF_initialized;
	+}
	+
	+/* don't use this function. It's just here for binary compatibility. */
	+int TTF_GetFontKerningSize(TTF_Font* font, int prev_index, int index)
	+{
	+ FT_Vector delta;
	+ FT_Get_Kerning(font->face, prev_index, index, ft_kerning_default, &delta);
	+ return (delta.x >> 6);
	+}
	+
	+int TTF_GetFontKerningSizeGlyphs(TTF_Font *font, Uint32 previous_ch, Uint32 ch)
	+{
	+ int error;
	+ FT_Face glyph_face, prev_face;
	+ int glyph_index, prev_index;
	+ FT_Vector delta;
	+
	+ if (ch == UNICODE_BOM_NATIVE \|\| ch == UNICODE_BOM_SWAPPED) {
	+ return 0;
	+ }
	+
	+ if (previous_ch == UNICODE_BOM_NATIVE \|\| previous_ch == UNICODE_BOM_SWAPPED) {
	+ return 0;
	+ }
	+
	+ error = Find_Glyph(font, ch, CACHED_METRICS);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ return -1;
	+ }
	+ glyph_face = font->current->face;
	+ glyph_index = font->current->index;
	+
	+ error = Find_Glyph(font, previous_ch, CACHED_METRICS);
	+ if (error) {
	+ TTF_SetFTError("Couldn't find glyph", error);
	+ return -1;
	+ }
	+ prev_face = font->current->face;
	+ prev_index = font->current->index;
	+
	+ if (glyph_face != prev_face) {
	+ return 0;
	+ }
	+
	+ error = FT_Get_Kerning(glyph_face, prev_index, glyph_index, ft_kerning_default, &delta);
	+ if (error) {
	+ TTF_SetFTError("Couldn't get glyph kerning", error);
	+ return -1;
	+ }
	+ return (delta.x >> 6);
	+}
	+
	+/* vi: set ts=4 sw=4 expandtab: */
	diff --git a/src/libs/SDL2_ttf/SDL_ttf.h b/src/libs/SDL2_ttf/SDL_ttf.h
	new file mode 100644
	index 0000000..3229f7a
	--- /dev/null
	+++ b/src/libs/SDL2_ttf/SDL_ttf.h
	@@ -0,0 +1,302 @@
	+/*
	+ SDL_ttf: A companion library to SDL for working with TrueType (tm) fonts
	+ Copyright (C) 2001-2018 Sam Lantinga <slouken@libsdl.org>
	+
	+ This software is provided 'as-is', without any express or implied
	+ warranty. In no event will the authors be held liable for any damages
	+ arising from the use of this software.
	+
	+ Permission is granted to anyone to use this software for any purpose,
	+ including commercial applications, and to alter it and redistribute it
	+ freely, subject to the following restrictions:
	+
	+ 1. The origin of this software must not be misrepresented; you must not
	+ claim that you wrote the original software. If you use this software
	+ in a product, an acknowledgment in the product documentation would be
	+ appreciated but is not required.
	+ 2. Altered source versions must be plainly marked as such, and must not be
	+ misrepresented as being the original software.
	+ 3. This notice may not be removed or altered from any source distribution.
	+*/
	+
	+/* This library is a wrapper around the excellent FreeType 2.0 library,
	+ available at:
	+ http://www.freetype.org/
	+*/
	+
	+/* Note: In many places, SDL_ttf will say "glyph" when it means "code point."
	+ Unicode is hard, we learn as we go, and we apologize for adding to the
	+ confusion. */
	+
	+#ifndef SDL_TTF_H_
	+#define SDL_TTF_H_
	+
	+#include "SDL.h"
	+#include "begin_code.h"
	+
	+/* Set up for C function definitions, even when using C++ */
	+#ifdef __cplusplus
	+extern "C" {
	+#endif
	+
	+/* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
	+*/
	+#define SDL_TTF_MAJOR_VERSION 2
	+#define SDL_TTF_MINOR_VERSION 0
	+#define SDL_TTF_PATCHLEVEL 14
	+
	+/* This macro can be used to fill a version structure with the compile-time
	+ * version of the SDL_ttf library.
	+ */
	+#define SDL_TTF_VERSION(X) \
	+{ \
	+ (X)->major = SDL_TTF_MAJOR_VERSION; \
	+ (X)->minor = SDL_TTF_MINOR_VERSION; \
	+ (X)->patch = SDL_TTF_PATCHLEVEL; \
	+}
	+
	+/* Backwards compatibility */
	+#define TTF_MAJOR_VERSION SDL_TTF_MAJOR_VERSION
	+#define TTF_MINOR_VERSION SDL_TTF_MINOR_VERSION
	+#define TTF_PATCHLEVEL SDL_TTF_PATCHLEVEL
	+#define TTF_VERSION(X) SDL_TTF_VERSION(X)
	+
	+/**
	+ * This is the version number macro for the current SDL_net version.
	+ */
	+#define SDL_TTF_COMPILEDVERSION \
	+ SDL_VERSIONNUM(SDL_TTF_MAJOR_VERSION, SDL_TTF_MINOR_VERSION, SDL_TTF_PATCHLEVEL)
	+
	+/**
	+ * This macro will evaluate to true if compiled with SDL_net at least X.Y.Z.
	+ */
	+#define SDL_TTF_VERSION_ATLEAST(X, Y, Z) \
	+ (SDL_TTF_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
	+
	+/* Make sure this is defined (only available in newer SDL versions) */
	+#ifndef SDL_DEPRECATED
	+#define SDL_DEPRECATED
	+#endif
	+
	+/* This function gets the version of the dynamically linked SDL_ttf library.
	+ it should NOT be used to fill a version structure, instead you should
	+ use the SDL_TTF_VERSION() macro.
	+ */
	+extern DECLSPEC const SDL_version * SDLCALL TTF_Linked_Version(void);
	+
	+/* ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark) */
	+#define UNICODE_BOM_NATIVE 0xFEFF
	+#define UNICODE_BOM_SWAPPED 0xFFFE
	+
	+/* This function tells the library whether UNICODE text is generally
	+ byteswapped. A UNICODE BOM character in a string will override
	+ this setting for the remainder of that string.
	+*/
	+extern DECLSPEC void SDLCALL TTF_ByteSwappedUNICODE(int swapped);
	+
	+/* The internal structure containing font information */
	+typedef struct _TTF_Font TTF_Font;
	+
	+/* Initialize the TTF engine - returns 0 if successful, -1 on error */
	+extern DECLSPEC int SDLCALL TTF_Init(void);
	+
	+/* Open a font file and create a font of the specified point size.
	+ * Some .fon fonts will have several sizes embedded in the file, so the
	+ * point size becomes the index of choosing which size. If the value
	+ * is too high, the last indexed size will be the default. */
	+extern DECLSPEC TTF_Font * SDLCALL TTF_OpenFont(const char *file, int ptsize);
	+extern DECLSPEC TTF_Font * SDLCALL TTF_OpenFontIndex(const char *file, int ptsize, long index);
	+extern DECLSPEC TTF_Font * SDLCALL TTF_OpenFontRW(SDL_RWops *src, int freesrc, int ptsize);
	+extern DECLSPEC TTF_Font * SDLCALL TTF_OpenFontIndexRW(SDL_RWops *src, int freesrc, int ptsize, long index);
	+
	+/* Set and retrieve the font style */
	+#define TTF_STYLE_NORMAL 0x00
	+#define TTF_STYLE_BOLD 0x01
	+#define TTF_STYLE_ITALIC 0x02
	+#define TTF_STYLE_UNDERLINE 0x04
	+#define TTF_STYLE_STRIKETHROUGH 0x08
	+extern DECLSPEC int SDLCALL TTF_GetFontStyle(const TTF_Font *font);
	+extern DECLSPEC void SDLCALL TTF_SetFontStyle(TTF_Font *font, int style);
	+extern DECLSPEC int SDLCALL TTF_GetFontOutline(const TTF_Font *font);
	+extern DECLSPEC void SDLCALL TTF_SetFontOutline(TTF_Font *font, int outline);
	+
	+/* Set and retrieve FreeType hinter settings */
	+#define TTF_HINTING_NORMAL 0
	+#define TTF_HINTING_LIGHT 1
	+#define TTF_HINTING_MONO 2
	+#define TTF_HINTING_NONE 3
	+extern DECLSPEC int SDLCALL TTF_GetFontHinting(const TTF_Font *font);
	+extern DECLSPEC void SDLCALL TTF_SetFontHinting(TTF_Font *font, int hinting);
	+
	+/* Get the total height of the font - usually equal to point size */
	+extern DECLSPEC int SDLCALL TTF_FontHeight(const TTF_Font *font);
	+
	+/* Get the offset from the baseline to the top of the font
	+ This is a positive value, relative to the baseline.
	+ */
	+extern DECLSPEC int SDLCALL TTF_FontAscent(const TTF_Font *font);
	+
	+/* Get the offset from the baseline to the bottom of the font
	+ This is a negative value, relative to the baseline.
	+ */
	+extern DECLSPEC int SDLCALL TTF_FontDescent(const TTF_Font *font);
	+
	+/* Get the recommended spacing between lines of text for this font */
	+extern DECLSPEC int SDLCALL TTF_FontLineSkip(const TTF_Font *font);
	+
	+/* Get/Set whether or not kerning is allowed for this font */
	+extern DECLSPEC int SDLCALL TTF_GetFontKerning(const TTF_Font *font);
	+extern DECLSPEC void SDLCALL TTF_SetFontKerning(TTF_Font *font, int allowed);
	+
	+/* Get the number of faces of the font */
	+extern DECLSPEC long SDLCALL TTF_FontFaces(const TTF_Font *font);
	+
	+/* Get the font face attributes, if any */
	+extern DECLSPEC int SDLCALL TTF_FontFaceIsFixedWidth(const TTF_Font *font);
	+extern DECLSPEC char * SDLCALL TTF_FontFaceFamilyName(const TTF_Font *font);
	+extern DECLSPEC char * SDLCALL TTF_FontFaceStyleName(const TTF_Font *font);
	+
	+/* Check wether a glyph is provided by the font or not */
	+extern DECLSPEC int SDLCALL TTF_GlyphIsProvided(const TTF_Font *font, Uint32 ch);
	+
	+/* Get the metrics (dimensions) of a glyph
	+ To understand what these metrics mean, here is a useful link:
	+ http://freetype.sourceforge.net/freetype2/docs/tutorial/step2.html
	+ */
	+extern DECLSPEC int SDLCALL TTF_GlyphMetrics(TTF_Font *font, Uint32 ch,
	+ int minx, int maxx,
	+ int miny, int maxy, int *advance);
	+
	+/* Get the dimensions of a rendered string of text */
	+extern DECLSPEC int SDLCALL TTF_SizeText(TTF_Font font, const char text, int w, int h);
	+extern DECLSPEC int SDLCALL TTF_SizeUTF8(TTF_Font font, const char text, int w, int h);
	+extern DECLSPEC int SDLCALL TTF_SizeUNICODE(TTF_Font font, const Uint16 text, int w, int h);
	+
	+/* Create an 8-bit palettized surface and render the given text at
	+ fast quality with the given font and color. The 0 pixel is the
	+ colorkey, giving a transparent background, and the 1 pixel is set
	+ to the text color.
	+ This function returns the new surface, or NULL if there was an error.
	+*/
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderText_Solid(TTF_Font *font,
	+ const char *text, SDL_Color fg);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUTF8_Solid(TTF_Font *font,
	+ const char *text, SDL_Color fg);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUNICODE_Solid(TTF_Font *font,
	+ const Uint16 *text, SDL_Color fg);
	+
	+/* Create an 8-bit palettized surface and render the given glyph at
	+ fast quality with the given font and color. The 0 pixel is the
	+ colorkey, giving a transparent background, and the 1 pixel is set
	+ to the text color. The glyph is rendered without any padding or
	+ centering in the X direction, and aligned normally in the Y direction.
	+ This function returns the new surface, or NULL if there was an error.
	+*/
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderGlyph_Solid(TTF_Font *font,
	+ Uint32 ch, SDL_Color fg);
	+
	+/* Create an 8-bit palettized surface and render the given text at
	+ high quality with the given font and colors. The 0 pixel is background,
	+ while other pixels have varying degrees of the foreground color.
	+ This function returns the new surface, or NULL if there was an error.
	+*/
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderText_Shaded(TTF_Font *font,
	+ const char *text, SDL_Color fg, SDL_Color bg);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUTF8_Shaded(TTF_Font *font,
	+ const char *text, SDL_Color fg, SDL_Color bg);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUNICODE_Shaded(TTF_Font *font,
	+ const Uint16 *text, SDL_Color fg, SDL_Color bg);
	+
	+/* Create an 8-bit palettized surface and render the given glyph at
	+ high quality with the given font and colors. The 0 pixel is background,
	+ while other pixels have varying degrees of the foreground color.
	+ The glyph is rendered without any padding or centering in the X
	+ direction, and aligned normally in the Y direction.
	+ This function returns the new surface, or NULL if there was an error.
	+*/
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderGlyph_Shaded(TTF_Font *font,
	+ Uint32 ch, SDL_Color fg, SDL_Color bg);
	+
	+/* Create a 32-bit ARGB surface and render the given text at high quality,
	+ using alpha blending to dither the font with the given color.
	+ This function returns the new surface, or NULL if there was an error.
	+*/
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderText_Blended(TTF_Font *font,
	+ const char *text, SDL_Color fg);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUTF8_Blended(TTF_Font *font,
	+ const char *text, SDL_Color fg);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUNICODE_Blended(TTF_Font *font,
	+ const Uint16 *text, SDL_Color fg);
	+
	+
	+/* Create a 32-bit ARGB surface and render the given text at high quality,
	+ using alpha blending to dither the font with the given color.
	+ Text is wrapped to multiple lines on line endings and on word boundaries
	+ if it extends beyond wrapLength in pixels.
	+ This function returns the new surface, or NULL if there was an error.
	+*/
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderText_Blended_Wrapped(TTF_Font *font,
	+ const char *text, SDL_Color fg, Uint32 wrapLength);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUTF8_Blended_Wrapped(TTF_Font *font,
	+ const char *text, SDL_Color fg, Uint32 wrapLength);
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderUNICODE_Blended_Wrapped(TTF_Font *font,
	+ const Uint16 *text, SDL_Color fg, Uint32 wrapLength);
	+
	+/* Create a 32-bit ARGB surface and render the given glyph at high quality,
	+ using alpha blending to dither the font with the given color.
	+ The glyph is rendered without any padding or centering in the X
	+ direction, and aligned normally in the Y direction.
	+ This function returns the new surface, or NULL if there was an error.
	+*/
	+extern DECLSPEC SDL_Surface * SDLCALL TTF_RenderGlyph_Blended(TTF_Font *font,
	+ Uint32 ch, SDL_Color fg);
	+
	+/* For compatibility with previous versions, here are the old functions */
	+#define TTF_RenderText(font, text, fg, bg) \
	+ TTF_RenderText_Shaded(font, text, fg, bg)
	+#define TTF_RenderUTF8(font, text, fg, bg) \
	+ TTF_RenderUTF8_Shaded(font, text, fg, bg)
	+#define TTF_RenderUNICODE(font, text, fg, bg) \
	+ TTF_RenderUNICODE_Shaded(font, text, fg, bg)
	+
	+/* Close an opened font file */
	+extern DECLSPEC void SDLCALL TTF_CloseFont(TTF_Font *font);
	+
	+/* De-initialize the TTF engine */
	+extern DECLSPEC void SDLCALL TTF_Quit(void);
	+
	+/* Check if the TTF engine is initialized */
	+extern DECLSPEC int SDLCALL TTF_WasInit(void);
	+
	+/* Get the kerning size of two glyphs indices */
	+/* DEPRECATED: this function requires FreeType font indexes, not glyphs,
	+ by accident, which we don't expose through this API, so it could give
	+ wildly incorrect results, especially with non-ASCII values.
	+ Going forward, please use TTF_GetFontKerningSizeGlyphs() instead, which
	+ does what you probably expected this function to do. */
	+extern DECLSPEC int TTF_GetFontKerningSize(TTF_Font *font, int prev_index, int index) SDL_DEPRECATED;
	+
	+/* Get the kerning size of two glyphs */
	+extern DECLSPEC int TTF_GetFontKerningSizeGlyphs(TTF_Font *font, Uint32 previous_ch, Uint32 ch);
	+
	+/* We'll use SDL for reporting errors */
	+#define TTF_SetError SDL_SetError
	+#define TTF_GetError SDL_GetError
	+
	+/* Set the font fallback.
	+ NOTE: The fallback fonts are still owned by caller, i.e. will not be
	+ freed automatically. */
	+extern DECLSPEC int TTF_SetFontFallback(TTF_Font font, int number_of_fallbacks, TTF_Font *fallbacks);
	+
	+#define TTF_ClearFontFallback(font) \
	+ TTF_SetFontFallback(font, 0, 0)
	+
	+/* Ends C function definitions when using C++ */
	+#ifdef __cplusplus
	+}
	+#endif
	+#include "close_code.h"
	+
	+#endif /* SDL_TTF_H_ */
	+
	+/* vi: set ts=4 sw=4 expandtab: */
	diff --git a/src/libs/tinyformat/tinyformat.cpp b/src/libs/tinyformat/tinyformat.cpp
	index 6392833..30a2341 100644
	--- a/src/libs/tinyformat/tinyformat.cpp
	+++ b/src/libs/tinyformat/tinyformat.cpp
	@@ -1,21 +1,89 @@
	#include "tinyformat.h"
	#include <locale>

	+namespace {
	+
	+char decimal_point_1 = '.';
	+char thousands_sep_1 = ',';
	+std::string decimal_point_2;
	+std::string thousands_sep_2;
	+std::string grouping_1;
	+
	+struct my_numpunct : std::numpunct<char> {
	+ char do_decimal_point() const override {
	+ return decimal_point_1;
	+ }
	+ char do_thousands_sep() const override {
	+ return thousands_sep_1;
	+ }
	+ std::string do_grouping() const override {
	+ return grouping_1;
	+ }
	+};
	+
	+std::locale locale_1(std::locale::classic(), new my_numpunct);
	+
	+}
	+
	namespace tinyformat {

	-std::locale locale = std::locale::classic();
	+void setNumericFormat(const std::string& decimal_point, const std::string& thousands_sep, const std::string& grouping) {
	+ if (decimal_point.size() == 1) {
	+ decimal_point_1 = decimal_point[0];
	+ decimal_point_2.clear();
	+ } else {
	+ decimal_point_1 = 1; // ad-hoc
	+ decimal_point_2 = decimal_point;
	+ }
	+
	+ std::string grouping_0;

	-void setLocale(const char* std_name) {
	- try {
	- tfm::locale = std::locale(std_name);
	- } catch (...) {
	- std::cerr << "ERROR: Failed to create std::locale for '" << std_name << "'!" << std::endl;
	- tfm::locale = std::locale::classic();
	+ for (auto c : grouping) {
	+ if (c == 0 \|\| c == '0') {
	+ grouping_0.clear();
	+ break;
	+ }
	+ grouping_0.push_back((c >= '1' && c <= '9') ? (c - '0') : c);
	+ }
	+
	+ if (thousands_sep.empty() \|\| grouping_0.empty()) {
	+ thousands_sep_1 = ',';
	+ thousands_sep_2.clear();
	+ grouping_1.clear();
	+ } else {
	+ if (thousands_sep.size() == 1) {
	+ thousands_sep_1 = thousands_sep[0];
	+ thousands_sep_2.clear();
	+ } else {
	+ thousands_sep_1 = 2; // ad-hoc
	+ thousands_sep_2 = thousands_sep;
	+ }
	+ grouping_1 = grouping_0;
	}
	}

	+namespace detail {
	+
	void imbue(std::ostream& o) {
	- o.imbue(tfm::locale);
	+ o.imbue(locale_1);
	+}
	+
	+bool needReplace() {
	+ return !decimal_point_2.empty() \|\| !thousands_sep_2.empty();
	+}
	+
	+std::string doReplace(const std::string& src) {
	+ std::string ret;
	+
	+ for (auto c : src) {
	+ if (c == 1) ret += decimal_point_2; // ad-hoc
	+ else if (c == 2) ret += thousands_sep_2; // ad-hoc
	+ else ret.push_back(c);
	+ }
	+
	+ return ret;
	+}
	+
	}

	}
	diff --git a/src/libs/tinyformat/tinyformat.h b/src/libs/tinyformat/tinyformat.h
	index aa95a01..0868056 100644
	--- a/src/libs/tinyformat/tinyformat.h
	+++ b/src/libs/tinyformat/tinyformat.h
	@@ -1,1050 +1,1061 @@
	// tinyformat.h
	// Copyright (C) 2011, Chris Foster [chris42f (at) gmail (d0t) com]
	//
	// Boost Software License - Version 1.0
	//
	// Permission is hereby granted, free of charge, to any person or organization
	// obtaining a copy of the software and accompanying documentation covered by
	// this license (the "Software") to use, reproduce, display, distribute,
	// execute, and transmit the Software, and to prepare derivative works of the
	// Software, and to permit third-parties to whom the Software is furnished to
	// do so, all subject to the following:
	//
	// The copyright notices in the Software and this entire statement, including
	// the above license grant, this restriction and the following disclaimer,
	// must be included in all copies of the Software, in whole or in part, and
	// all derivative works of the Software, unless such copies or derivative
	// works are solely in the form of machine-executable object code generated by
	// a source language processor.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
	// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
	// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
	// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	// DEALINGS IN THE SOFTWARE.

	//------------------------------------------------------------------------------
	// Tinyformat: A minimal type safe printf replacement
	//
	// tinyformat.h is a type safe printf replacement library in a single C++
	// header file. Design goals include:
	//
	// * Type safety and extensibility for user defined types.
	// * C99 printf() compatibility, to the extent possible using std::ostream
	// * Simplicity and minimalism. A single header file to include and distribute
	// with your projects.
	// * Augment rather than replace the standard stream formatting mechanism
	// * C++98 support, with optional C++11 niceties
	//
	//
	// Main interface example usage
	// ----------------------------
	//
	// To print a date to std::cout:
	//
	// std::string weekday = "Wednesday";
	// const char* month = "July";
	// size_t day = 27;
	// long hour = 14;
	// int min = 44;
	//
	// tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min);
	//
	// The strange types here emphasize the type safety of the interface; it is
	// possible to print a std::string using the "%s" conversion, and a
	// size_t using the "%d" conversion. A similar result could be achieved
	// using either of the tfm::format() functions. One prints on a user provided
	// stream:
	//
	// tfm::format(std::cerr, "%s, %s %d, %.2d:%.2d\n",
	// weekday, month, day, hour, min);
	//
	// The other returns a std::string:
	//
	// std::string date = tfm::format("%s, %s %d, %.2d:%.2d\n",
	// weekday, month, day, hour, min);
	// std::cout << date;
	//
	// These are the three primary interface functions. There is also a
	// convenience function printfln() which appends a newline to the usual result
	// of printf() for super simple logging.
	//
	//
	// User defined format functions
	// -----------------------------
	//
	// Simulating variadic templates in C++98 is pretty painful since it requires
	// writing out the same function for each desired number of arguments. To make
	// this bearable tinyformat comes with a set of macros which are used
	// internally to generate the API, but which may also be used in user code.
	//
	// The three macros TINYFORMAT_ARGTYPES(n), TINYFORMAT_VARARGS(n) and
	// TINYFORMAT_PASSARGS(n) will generate a list of n argument types,
	// type/name pairs and argument names respectively when called with an integer
	// n between 1 and 16. We can use these to define a macro which generates the
	// desired user defined function with n arguments. To generate all 16 user
	// defined function bodies, use the macro TINYFORMAT_FOREACH_ARGNUM. For an
	// example, see the implementation of printf() at the end of the source file.
	//
	// Sometimes it's useful to be able to pass a list of format arguments through
	// to a non-template function. The FormatList class is provided as a way to do
	// this by storing the argument list in a type-opaque way. Continuing the
	// example from above, we construct a FormatList using makeFormatList():
	//
	// FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour, min);
	//
	// The format list can now be passed into any non-template function and used
	// via a call to the vformat() function:
	//
	// tfm::vformat(std::cout, "%s, %s %d, %.2d:%.2d\n", formatList);
	//
	//
	// Additional API information
	// --------------------------
	//
	// Error handling: Define TINYFORMAT_ERROR to customize the error handling for
	// format strings which are unsupported or have the wrong number of format
	// specifiers (calls assert() by default).
	//
	// User defined types: Uses operator<< for user defined types by default.
	// Overload formatValue() for more control.


	#ifndef TINYFORMAT_H_INCLUDED
	#define TINYFORMAT_H_INCLUDED

	namespace tinyformat {}
	//------------------------------------------------------------------------------
	// Config section. Customize to your liking!

	// Namespace alias to encourage brevity
	namespace tfm = tinyformat;

	// Error handling; calls assert() by default.
	// #define TINYFORMAT_ERROR(reasonString) your_error_handler(reasonString)

	// Define for C++11 variadic templates which make the code shorter & more
	// general. If you don't define this, C++11 support is autodetected below.
	// #define TINYFORMAT_USE_VARIADIC_TEMPLATES


	//------------------------------------------------------------------------------
	// Implementation details.
	#include <algorithm>
	#include <cassert>
	#include <iostream>
	#include <sstream>

	#ifndef TINYFORMAT_ERROR
	# define TINYFORMAT_ERROR(reason) assert(0 && reason)
	#endif

	#if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) && !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES)
	# ifdef __GXX_EXPERIMENTAL_CXX0X__
	# define TINYFORMAT_USE_VARIADIC_TEMPLATES
	# endif
	#endif

	#if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201
	// std::showpos is broken on old libstdc++ as provided with OSX. See
	// http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html
	# define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
	#endif

	#ifdef __APPLE__
	// Workaround OSX linker warning: xcode uses different default symbol
	// visibilities for static libs vs executables (see issue #25)
	# define TINYFORMAT_HIDDEN __attribute__((visibility("hidden")))
	#else
	# define TINYFORMAT_HIDDEN
	#endif

	namespace tinyformat {

	-// Set the locale for tinyformat which is mainly used to format float numbers.
	-void setLocale(const char* std_name);
	+// Set the numeric format.
	+// decimal_point: The decimal point character.
	+// thousands_sep: The thousands separator character.
	+// grouping: The grouping of digits, see <http://www.cplusplus.com/reference/locale/numpunct/grouping/> for more information.
	+// However, we also accept string containing "123..." instead of "\x01\x02\x03...", also, "0" is the same as "".
	+void setNumericFormat(const std::string& decimal_point, const std::string& thousands_sep, const std::string& grouping);
	+
	+//------------------------------------------------------------------------------
	+namespace detail {

	// Internal function.
	void imbue(std::ostream& o);

	-//------------------------------------------------------------------------------
	-namespace detail {
	+// Internal function.
	+bool needReplace();
	+
	+// Internal function.
	+std::string doReplace(const std::string& src);

	// Test whether type T1 is convertible to type T2
	template <typename T1, typename T2>
	struct is_convertible
	{
	private:
	// two types of different size
	struct fail { char dummy[2]; };
	struct succeed { char dummy; };
	// Try to convert a T1 to a T2 by plugging into tryConvert
	static fail tryConvert(...);
	static succeed tryConvert(const T2&);
	static const T1& makeT1();
	public:
	# ifdef _MSC_VER
	// Disable spurious loss of precision warnings in tryConvert(makeT1())
	# pragma warning(push)
	# pragma warning(disable:4244)
	# pragma warning(disable:4267)
	# endif
	// Standard trick: the (...) version of tryConvert will be chosen from
	// the overload set only if the version taking a T2 doesn't match.
	// Then we compare the sizes of the return types to check which
	// function matched. Very neat, in a disgusting kind of way :)
	static const bool value =
	sizeof(tryConvert(makeT1())) == sizeof(succeed);
	# ifdef _MSC_VER
	# pragma warning(pop)
	# endif
	};


	// Detect when a type is not a wchar_t string
	template<typename T> struct is_wchar { typedef int tinyformat_wchar_is_not_supported; };
	template<> struct is_wchar<wchar_t*> {};
	template<> struct is_wchar<const wchar_t*> {};
	template<int n> struct is_wchar<const wchar_t[n]> {};
	template<int n> struct is_wchar<wchar_t[n]> {};


	// Format the value by casting to type fmtT. This default implementation
	// should never be called.
	template<typename T, typename fmtT, bool convertible = is_convertible<T, fmtT>::value>
	struct formatValueAsType
	{
	static void invoke(std::ostream& /out/, const T& /value/) { assert(0); }
	};
	// Specialized version for types that can actually be converted to fmtT, as
	// indicated by the "convertible" template parameter.
	template<typename T, typename fmtT>
	struct formatValueAsType<T,fmtT,true>
	{
	static void invoke(std::ostream& out, const T& value)
	{ out << static_cast<fmtT>(value); }
	};

	#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
	template<typename T, bool convertible = is_convertible<T, int>::value>
	struct formatZeroIntegerWorkaround
	{
	static bool invoke(std::ostream& //, const T& //) { return false; }
	};
	template<typename T>
	struct formatZeroIntegerWorkaround<T,true>
	{
	static bool invoke(std::ostream& out, const T& value)
	{
	if (static_cast<int>(value) == 0 && out.flags() & std::ios::showpos)
	{
	out << "+0";
	return true;
	}
	return false;
	}
	};
	#endif // TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND

	// Convert an arbitrary type to integer. The version with convertible=false
	// throws an error.
	template<typename T, bool convertible = is_convertible<T,int>::value>
	struct convertToInt
	{
	static int invoke(const T& /value/)
	{
	TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to "
	"integer for use as variable width or precision");
	return 0;
	}
	};
	// Specialization for convertToInt when conversion is possible
	template<typename T>
	struct convertToInt<T,true>
	{
	static int invoke(const T& value) { return static_cast<int>(value); }
	};

	// Format at most ntrunc characters to the given stream.
	template<typename T>
	inline void formatTruncated(std::ostream& out, const T& value, int ntrunc)
	{
	std::ostringstream tmp;
	- tfm::imbue(tmp);
	+ tfm::detail::imbue(tmp);
	tmp << value;
	- std::string result = tmp.str();
	+ std::string result = tfm::detail::needReplace() ? tfm::detail::doReplace(tmp.str()) : tmp.str();
	out.write(result.c_str(), (std::min)(ntrunc, static_cast<int>(result.size())));
	}
	#define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type) \
	inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \
	{ \
	std::streamsize len = 0; \
	while(len < ntrunc && value[len] != 0) \
	++len; \
	out.write(value, len); \
	}
	// Overload for const char* and char*. Could overload for signed & unsigned
	// char too, but these are technically unneeded for printf compatibility.
	TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(const char)
	TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char)
	#undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR

	} // namespace detail


	//------------------------------------------------------------------------------
	// Variable formatting functions. May be overridden for user-defined types if
	// desired.


	/// Format a value into a stream, delegating to operator<< by default.
	///
	/// Users may override this for their own types. When this function is called,
	/// the stream flags will have been modified according to the format string.
	/// The format specification is provided in the range [fmtBegin, fmtEnd). For
	/// truncating conversions, ntrunc is set to the desired maximum number of
	/// characters, for example "%.7s" calls formatValue with ntrunc = 7.
	///
	/// By default, formatValue() uses the usual stream insertion operator
	/// operator<< to format the type T, with special cases for the %c and %p
	/// conversions.
	template<typename T>
	inline void formatValue(std::ostream& out, const char* /fmtBegin/,
	const char* fmtEnd, int ntrunc, const T& value)
	{
	#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
	// Since we don't support printing of wchar_t using "%ls", make it fail at
	// compile time in preference to printing as a void* at runtime.
	typedef typename detail::is_wchar<T>::tinyformat_wchar_is_not_supported DummyType;
	(void) DummyType(); // avoid unused type warning with gcc-4.8
	#endif
	// The mess here is to support the %c and %p conversions: if these
	// conversions are active we try to convert the type to a char or const
	// void* respectively and format that instead of the value itself. For the
	// %p conversion it's important to avoid dereferencing the pointer, which
	// could otherwise lead to a crash when printing a dangling (const char*).
	const bool canConvertToChar = detail::is_convertible<T,char>::value;
	const bool canConvertToVoidPtr = detail::is_convertible<T, const void*>::value;
	if(canConvertToChar && *(fmtEnd-1) == 'c')
	detail::formatValueAsType<T, char>::invoke(out, value);
	else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p')
	detail::formatValueAsType<T, const void*>::invoke(out, value);
	#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND
	else if(detail::formatZeroIntegerWorkaround<T>::invoke(out, value)) /**/;
	#endif
	else if(ntrunc >= 0)
	{
	// Take care not to overread C strings in truncating conversions like
	// "%.4s" where at most 4 characters may be read.
	detail::formatTruncated(out, value, ntrunc);
	}
	else
	out << value;
	}


	// Overloaded version for char types to support printing as an integer
	#define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType) \
	inline void formatValue(std::ostream& out, const char* /fmtBegin/, \
	const char* fmtEnd, int /**/, charType value) \
	{ \
	switch(*(fmtEnd-1)) \
	{ \
	case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \
	out << static_cast<int>(value); break; \
	default: \
	out << value; break; \
	} \
	}
	// per 3.9.1: char, signed char and unsigned char are all distinct types
	TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char)
	TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char)
	TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char)
	#undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR


	//------------------------------------------------------------------------------
	// Tools for emulating variadic templates in C++98. The basic idea here is
	// stolen from the boost preprocessor metaprogramming library and cut down to
	// be just general enough for what we need.

	#define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_ ## n
	#define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_ ## n
	#define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_ ## n
	#define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n

	// To keep it as transparent as possible, the macros below have been generated
	// using python via the excellent cog.py code generation script. This avoids
	// the need for a bunch of complex (but more general) preprocessor tricks as
	// used in boost.preprocessor.
	//
	// To rerun the code generation in place, use `cog.py -r tinyformat.h`
	// (see http://nedbatchelder.com/code/cog). Alternatively you can just create
	// extra versions by hand.

	/*[[[cog
	maxParams = 16

	def makeCommaSepLists(lineTemplate, elemTemplate, startInd=1):
	for j in range(startInd,maxParams+1):
	list = ', '.join([elemTemplate % {'i':i} for i in range(startInd,j+1)])
	cog.outl(lineTemplate % {'j':j, 'list':list})

	makeCommaSepLists('#define TINYFORMAT_ARGTYPES_%(j)d %(list)s',
	'class T%(i)d')

	cog.outl()
	makeCommaSepLists('#define TINYFORMAT_VARARGS_%(j)d %(list)s',
	'const T%(i)d& v%(i)d')

	cog.outl()
	makeCommaSepLists('#define TINYFORMAT_PASSARGS_%(j)d %(list)s', 'v%(i)d')

	cog.outl()
	cog.outl('#define TINYFORMAT_PASSARGS_TAIL_1')
	makeCommaSepLists('#define TINYFORMAT_PASSARGS_TAIL_%(j)d , %(list)s',
	'v%(i)d', startInd = 2)

	cog.outl()
	cog.outl('#define TINYFORMAT_FOREACH_ARGNUM(m) \\\n ' +
	' '.join(['m(%d)' % (j,) for j in range(1,maxParams+1)]))
	]]]*/
	#define TINYFORMAT_ARGTYPES_1 class T1
	#define TINYFORMAT_ARGTYPES_2 class T1, class T2
	#define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3
	#define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4
	#define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5
	#define TINYFORMAT_ARGTYPES_6 class T1, class T2, class T3, class T4, class T5, class T6
	#define TINYFORMAT_ARGTYPES_7 class T1, class T2, class T3, class T4, class T5, class T6, class T7
	#define TINYFORMAT_ARGTYPES_8 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8
	#define TINYFORMAT_ARGTYPES_9 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9
	#define TINYFORMAT_ARGTYPES_10 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10
	#define TINYFORMAT_ARGTYPES_11 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11
	#define TINYFORMAT_ARGTYPES_12 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12
	#define TINYFORMAT_ARGTYPES_13 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13
	#define TINYFORMAT_ARGTYPES_14 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14
	#define TINYFORMAT_ARGTYPES_15 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15
	#define TINYFORMAT_ARGTYPES_16 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16

	#define TINYFORMAT_VARARGS_1 const T1& v1
	#define TINYFORMAT_VARARGS_2 const T1& v1, const T2& v2
	#define TINYFORMAT_VARARGS_3 const T1& v1, const T2& v2, const T3& v3
	#define TINYFORMAT_VARARGS_4 const T1& v1, const T2& v2, const T3& v3, const T4& v4
	#define TINYFORMAT_VARARGS_5 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5
	#define TINYFORMAT_VARARGS_6 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6
	#define TINYFORMAT_VARARGS_7 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7
	#define TINYFORMAT_VARARGS_8 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8
	#define TINYFORMAT_VARARGS_9 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9
	#define TINYFORMAT_VARARGS_10 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10
	#define TINYFORMAT_VARARGS_11 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11
	#define TINYFORMAT_VARARGS_12 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12
	#define TINYFORMAT_VARARGS_13 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13
	#define TINYFORMAT_VARARGS_14 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14
	#define TINYFORMAT_VARARGS_15 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15
	#define TINYFORMAT_VARARGS_16 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15, const T16& v16

	#define TINYFORMAT_PASSARGS_1 v1
	#define TINYFORMAT_PASSARGS_2 v1, v2
	#define TINYFORMAT_PASSARGS_3 v1, v2, v3
	#define TINYFORMAT_PASSARGS_4 v1, v2, v3, v4
	#define TINYFORMAT_PASSARGS_5 v1, v2, v3, v4, v5
	#define TINYFORMAT_PASSARGS_6 v1, v2, v3, v4, v5, v6
	#define TINYFORMAT_PASSARGS_7 v1, v2, v3, v4, v5, v6, v7
	#define TINYFORMAT_PASSARGS_8 v1, v2, v3, v4, v5, v6, v7, v8
	#define TINYFORMAT_PASSARGS_9 v1, v2, v3, v4, v5, v6, v7, v8, v9
	#define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10
	#define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
	#define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
	#define TINYFORMAT_PASSARGS_13 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
	#define TINYFORMAT_PASSARGS_14 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
	#define TINYFORMAT_PASSARGS_15 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
	#define TINYFORMAT_PASSARGS_16 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16

	#define TINYFORMAT_PASSARGS_TAIL_1
	#define TINYFORMAT_PASSARGS_TAIL_2 , v2
	#define TINYFORMAT_PASSARGS_TAIL_3 , v2, v3
	#define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4
	#define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5
	#define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6
	#define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7
	#define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8
	#define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9
	#define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10
	#define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11
	#define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12
	#define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13
	#define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14
	#define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15
	#define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16

	#define TINYFORMAT_FOREACH_ARGNUM(m) \
	m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) m(15) m(16)
	//[[[end]]]



	namespace detail {

	// Type-opaque holder for an argument to format(), with associated actions on
	// the type held as explicit function pointers. This allows FormatArg's for
	// each argument to be allocated as a homogenous array inside FormatList
	// whereas a naive implementation based on inheritance does not.
	class FormatArg
	{
	public:
	FormatArg() {}

	template<typename T>
	FormatArg(const T& value)
	: m_value(static_cast<const void*>(&value)),
	m_formatImpl(&formatImpl<T>),
	m_toIntImpl(&toIntImpl<T>)
	{ }

	void format(std::ostream& out, const char* fmtBegin,
	const char* fmtEnd, int ntrunc) const
	{
	m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value);
	}

	int toInt() const
	{
	return m_toIntImpl(m_value);
	}

	private:
	template<typename T>
	TINYFORMAT_HIDDEN static void formatImpl(std::ostream& out, const char* fmtBegin,
	const char* fmtEnd, int ntrunc, const void* value)
	{
	formatValue(out, fmtBegin, fmtEnd, ntrunc, static_cast<const T>(value));
	}

	template<typename T>
	TINYFORMAT_HIDDEN static int toIntImpl(const void* value)
	{
	return convertToInt<T>::invoke(static_cast<const T>(value));
	}

	const void* m_value;
	void (m_formatImpl)(std::ostream& out, const char fmtBegin,
	const char* fmtEnd, int ntrunc, const void* value);
	int (m_toIntImpl)(const void value);
	};


	// Parse and return an integer from the string c, as atoi()
	// On return, c is set to one past the end of the integer.
	inline int parseIntAndAdvance(const char*& c)
	{
	int i = 0;
	for(;c >= '0' && c <= '9'; ++c)
	i = 10i + (c - '0');
	return i;
	}

	// Print literal part of format string and return next format spec
	// position.
	//
	// Skips over any occurrences of '%%', printing a literal '%' to the
	// output. The position of the first % character of the next
	// nontrivial format spec is returned, or the end of string.
	inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt)
	{
	const char* c = fmt;
	for(;; ++c)
	{
	switch(*c)
	{
	case '\0':
	out.write(fmt, c - fmt);
	return c;
	case '%':
	out.write(fmt, c - fmt);
	if(*(c+1) != '%')
	return c;
	// for "%%", tack trailing % onto next literal section.
	fmt = ++c;
	break;
	default:
	break;
	}
	}
	}


	// Parse a format string and set the stream state accordingly.
	//
	// The format mini-language recognized here is meant to be the one from C99,
	// with the form "%[flags][width][.precision][length]type".
	//
	// Formatting options which can't be natively represented using the ostream
	// state are returned in spacePadPositive (for space padded positive numbers)
	// and ntrunc (for truncating conversions). argIndex is incremented if
	// necessary to pull out variable width and precision . The function returns a
	// pointer to the character after the end of the current format spec.
	inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositive,
	int& ntrunc, const char* fmtStart,
	const detail::FormatArg* formatters,
	int& argIndex, int numFormatters)
	{
	if(*fmtStart != '%')
	{
	TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string");
	return fmtStart;
	}
	// Reset stream state to defaults.
	out.width(0);
	out.precision(6);
	out.fill(' ');
	// Reset most flags; ignore irrelevant unitbuf & skipws.
	out.unsetf(std::ios::adjustfield \| std::ios::basefield \|
	std::ios::floatfield \| std::ios::showbase \| std::ios::boolalpha \|
	std::ios::showpoint \| std::ios::showpos \| std::ios::uppercase);
	bool precisionSet = false;
	bool widthSet = false;
	int widthExtra = 0;
	const char* c = fmtStart + 1;
	// 1) Parse flags
	for(;; ++c)
	{
	switch(*c)
	{
	case '#':
	out.setf(std::ios::showpoint \| std::ios::showbase);
	continue;
	case '0':
	// overridden by left alignment ('-' flag)
	if(!(out.flags() & std::ios::left))
	{
	// Use internal padding so that numeric values are
	// formatted correctly, eg -00010 rather than 000-10
	out.fill('0');
	out.setf(std::ios::internal, std::ios::adjustfield);
	}
	continue;
	case '-':
	out.fill(' ');
	out.setf(std::ios::left, std::ios::adjustfield);
	continue;
	case ' ':
	// overridden by show positive sign, '+' flag.
	if(!(out.flags() & std::ios::showpos))
	spacePadPositive = true;
	continue;
	case '+':
	out.setf(std::ios::showpos);
	spacePadPositive = false;
	widthExtra = 1;
	continue;
	default:
	break;
	}
	break;
	}
	// 2) Parse width
	if(c >= '0' && c <= '9')
	{
	widthSet = true;
	out.width(parseIntAndAdvance(c));
	}
	if(c == '')
	{
	widthSet = true;
	int width = 0;
	if(argIndex < numFormatters)
	width = formatters[argIndex++].toInt();
	else
	TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width");
	if(width < 0)
	{
	// negative widths correspond to '-' flag set
	out.fill(' ');
	out.setf(std::ios::left, std::ios::adjustfield);
	width = -width;
	}
	out.width(width);
	++c;
	}
	// 3) Parse precision
	if(*c == '.')
	{
	++c;
	int precision = 0;
	if(c == '')
	{
	++c;
	if(argIndex < numFormatters)
	precision = formatters[argIndex++].toInt();
	else
	TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable precision");
	}
	else
	{
	if(c >= '0' && c <= '9')
	precision = parseIntAndAdvance(c);
	else if(*c == '-') // negative precisions ignored, treated as zero.
	parseIntAndAdvance(++c);
	}
	out.precision(precision);
	precisionSet = true;
	}
	// 4) Ignore any C99 length modifier
	while(c == 'l' \|\| c == 'h' \|\| *c == 'L' \|\|
	c == 'j' \|\| c == 'z' \|\| *c == 't')
	++c;
	// 5) We're up to the conversion specifier character.
	// Set stream flags based on conversion specifier (thanks to the
	// boost::format class for forging the way here).
	bool intConversion = false;
	switch(*c)
	{
	case 'u': case 'd': case 'i':
	out.setf(std::ios::dec, std::ios::basefield);
	intConversion = true;
	break;
	case 'o':
	out.setf(std::ios::oct, std::ios::basefield);
	intConversion = true;
	break;
	case 'X':
	out.setf(std::ios::uppercase);
	case 'x': case 'p':
	out.setf(std::ios::hex, std::ios::basefield);
	intConversion = true;
	break;
	case 'E':
	out.setf(std::ios::uppercase);
	case 'e':
	out.setf(std::ios::scientific, std::ios::floatfield);
	out.setf(std::ios::dec, std::ios::basefield);
	break;
	case 'F':
	out.setf(std::ios::uppercase);
	case 'f':
	out.setf(std::ios::fixed, std::ios::floatfield);
	break;
	case 'G':
	out.setf(std::ios::uppercase);
	case 'g':
	out.setf(std::ios::dec, std::ios::basefield);
	// As in boost::format, let stream decide float format.
	out.flags(out.flags() & ~std::ios::floatfield);
	break;
	case 'a': case 'A':
	TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs "
	"are not supported");
	break;
	case 'c':
	// Handled as special case inside formatValue()
	break;
	case 's':
	if(precisionSet)
	ntrunc = static_cast<int>(out.precision());
	// Make %s print booleans as "true" and "false"
	out.setf(std::ios::boolalpha);
	break;
	case 'n':
	// Not supported - will cause problems!
	TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported");
	break;
	case '\0':
	TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly "
	"terminated by end of string");
	return c;
	default:
	break;
	}
	if(intConversion && precisionSet && !widthSet)
	{
	// "precision" for integers gives the minimum number of digits (to be
	// padded with zeros on the left). This isn't really supported by the
	// iostreams, but we can approximately simulate it with the width if
	// the width isn't otherwise used.
	out.width(out.precision() + widthExtra);
	out.setf(std::ios::internal, std::ios::adjustfield);
	out.fill('0');
	}
	return c+1;
	}


	//------------------------------------------------------------------------------
	inline void formatImpl(std::ostream& out, const char* fmt,
	const detail::FormatArg* formatters,
	int numFormatters)
	{
	// Saved stream state
	std::streamsize origWidth = out.width();
	std::streamsize origPrecision = out.precision();
	std::ios::fmtflags origFlags = out.flags();
	char origFill = out.fill();

	for (int argIndex = 0; argIndex < numFormatters; ++argIndex)
	{
	// Parse the format string
	fmt = printFormatStringLiteral(out, fmt);
	bool spacePadPositive = false;
	int ntrunc = -1;
	const char* fmtEnd = streamStateFromFormat(out, spacePadPositive, ntrunc, fmt,
	formatters, argIndex, numFormatters);
	if (argIndex >= numFormatters)
	{
	// Check args remain after reading any variable width/precision
	TINYFORMAT_ERROR("tinyformat: Not enough format arguments");
	return;
	}
	const FormatArg& arg = formatters[argIndex];
	// Format the arg into the stream.
	if(!spacePadPositive)
	arg.format(out, fmt, fmtEnd, ntrunc);
	else
	{
	// The following is a special case with no direct correspondence
	// between stream formatting and the printf() behaviour. Simulate
	// it crudely by formatting into a temporary string stream and
	// munging the resulting string.
	std::ostringstream tmpStream;
	- tfm::imbue(tmpStream);
	+ tfm::detail::imbue(tmpStream);
	tmpStream.copyfmt(out);
	tmpStream.setf(std::ios::showpos);
	arg.format(tmpStream, fmt, fmtEnd, ntrunc);
	- std::string result = tmpStream.str(); // allocates... yuck.
	+ std::string result = tfm::detail::needReplace() ? tfm::detail::doReplace(tmpStream.str()) : tmpStream.str(); // allocates... yuck.
	for(size_t i = 0, iend = result.size(); i < iend; ++i)
	if(result[i] == '+') result[i] = ' ';
	out << result;
	}
	fmt = fmtEnd;
	}

	// Print remaining part of format string.
	fmt = printFormatStringLiteral(out, fmt);
	if(*fmt != '\0')
	TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string");

	// Restore stream state
	out.width(origWidth);
	out.precision(origPrecision);
	out.flags(origFlags);
	out.fill(origFill);
	}

	} // namespace detail


	/// List of template arguments format(), held in a type-opaque way.
	///
	/// A const reference to FormatList (typedef'd as FormatListRef) may be
	/// conveniently used to pass arguments to non-template functions: All type
	/// information has been stripped from the arguments, leaving just enough of a
	/// common interface to perform formatting as required.
	class FormatList
	{
	public:
	FormatList(detail::FormatArg* formatters, int N)
	: m_formatters(formatters), m_N(N) { }

	friend void vformat(std::ostream& out, const char* fmt,
	const FormatList& list);

	private:
	const detail::FormatArg* m_formatters;
	int m_N;
	};

	/// Reference to type-opaque format list for passing to vformat()
	typedef const FormatList& FormatListRef;


	namespace detail {

	// Format list subclass with fixed storage to avoid dynamic allocation
	template<int N>
	class FormatListN : public FormatList
	{
	public:
	#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES
	template<typename... Args>
	FormatListN(const Args&... args)
	: FormatList(&m_formatterStore[0], N),
	m_formatterStore { FormatArg(args)... }
	{ static_assert(sizeof...(args) == N, "Number of args must be N"); }
	#else // C++98 version
	void init(int) {}
	# define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n) \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	FormatListN(TINYFORMAT_VARARGS(n)) \
	: FormatList(&m_formatterStore[0], n) \
	{ assert(n == N); init(0, TINYFORMAT_PASSARGS(n)); } \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void init(int i, TINYFORMAT_VARARGS(n)) \
	{ \
	m_formatterStore[i] = FormatArg(v1); \
	init(i+1 TINYFORMAT_PASSARGS_TAIL(n)); \
	}

	TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR)
	# undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR
	#endif

	private:
	FormatArg m_formatterStore[N];
	};

	// Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard
	template<> class FormatListN<0> : public FormatList
	{
	public: FormatListN() : FormatList(0, 0) {}
	};

	} // namespace detail


	//------------------------------------------------------------------------------
	// Primary API functions

	#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES

	/// Make type-agnostic format list from list of template arguments.
	///
	/// The exact return type of this function is an implementation detail and
	/// shouldn't be relied upon. Instead it should be stored as a FormatListRef:
	///
	/// FormatListRef formatList = makeFormatList( /.../ );
	template<typename... Args>
	detail::FormatListN<sizeof...(Args)> makeFormatList(const Args&... args)
	{
	return detail::FormatListN<sizeof...(args)>(args...);
	}

	#else // C++98 version

	inline detail::FormatListN<0> makeFormatList()
	{
	return detail::FormatListN<0>();
	}
	#define TINYFORMAT_MAKE_MAKEFORMATLIST(n) \
	template<TINYFORMAT_ARGTYPES(n)> \
	detail::FormatListN<n> makeFormatList(TINYFORMAT_VARARGS(n)) \
	{ \
	return detail::FormatListN<n>(TINYFORMAT_PASSARGS(n)); \
	}
	TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST)
	#undef TINYFORMAT_MAKE_MAKEFORMATLIST

	#endif

	/// Format list of arguments to the stream according to the given format string.
	///
	/// The name vformat() is chosen for the semantic similarity to vprintf(): the
	/// list of format arguments is held in a single function argument.
	inline void vformat(std::ostream& out, const char* fmt, FormatListRef list)
	{
	detail::formatImpl(out, fmt, list.m_formatters, list.m_N);
	}


	#ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES

	/// Format list of arguments to the stream according to given format string.
	template<typename... Args>
	void format(std::ostream& out, const char* fmt, const Args&... args)
	{
	vformat(out, fmt, makeFormatList(args...));
	}

	/// Format list of arguments according to the given format string and return
	/// the result as a string.
	template<typename... Args>
	std::string format(const char* fmt, const Args&... args)
	{
	std::ostringstream oss;
	- tfm::imbue(oss);
	+ tfm::detail::imbue(oss);
	format(oss, fmt, args...);
	- return oss.str();
	+ return tfm::detail::needReplace() ? tfm::detail::doReplace(oss.str()) : oss.str();
	}

	/// Format list of arguments to std::cout, according to the given format string
	template<typename... Args>
	void printf(const char* fmt, const Args&... args)
	{
	format(std::cout, fmt, args...);
	}

	template<typename... Args>
	void printfln(const char* fmt, const Args&... args)
	{
	format(std::cout, fmt, args...);
	std::cout << '\n';
	}


	#else // C++98 version

	inline void format(std::ostream& out, const char* fmt)
	{
	vformat(out, fmt, makeFormatList());
	}

	inline std::string format(const char* fmt)
	{
	std::ostringstream oss;
	- tfm::imbue(oss);
	+ tfm::detail::imbue(oss);
	format(oss, fmt);
	- return oss.str();
	+ return tfm::detail::needReplace() ? tfm::detail::doReplace(oss.str()) : oss.str();
	}

	inline void printf(const char* fmt)
	{
	format(std::cout, fmt);
	}

	inline void printfln(const char* fmt)
	{
	format(std::cout, fmt);
	std::cout << '\n';
	}

	#define TINYFORMAT_MAKE_FORMAT_FUNCS(n) \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n))); \
	} \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	std::string format(const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	std::ostringstream oss; \
	- tfm::imbue(oss); \
	+ tfm::detail::imbue(oss); \
	format(oss, fmt, TINYFORMAT_PASSARGS(n)); \
	- return oss.str(); \
	+ return tfm::detail::needReplace() ? \
	+ tfm::detail::doReplace(oss.str()) : oss.str(); \
	} \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void printf(const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \
	} \
	\
	template<TINYFORMAT_ARGTYPES(n)> \
	void printfln(const char* fmt, TINYFORMAT_VARARGS(n)) \
	{ \
	format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \
	std::cout << '\n'; \
	}

	TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS)
	#undef TINYFORMAT_MAKE_FORMAT_FUNCS

	#endif


	} // namespace tinyformat

	#endif // TINYFORMAT_H_INCLUDED
	diff --git a/src/libs/tinygettext/language.cpp b/src/libs/tinygettext/language.cpp
	index 5137a24..8993b26 100644
	--- a/src/libs/tinygettext/language.cpp
	+++ b/src/libs/tinygettext/language.cpp
	@@ -1,581 +1,597 @@
	// tinygettext - A gettext replacement that works directly on .po files
	// Copyright (c) 2006 Ingo Ruhnke <grumbel@gmail.com>
	//
	// This software is provided 'as-is', without any express or implied
	// warranty. In no event will the authors be held liable for any damages
	// arising from the use of this software.
	//
	// Permission is granted to anyone to use this software for any purpose,
	// including commercial applications, and to alter it and redistribute it
	// freely, subject to the following restrictions:
	//
	// 1. The origin of this software must not be misrepresented; you must not
	// claim that you wrote the original software. If you use this software
	// in a product, an acknowledgement in the product documentation would be
	// appreciated but is not required.
	// 2. Altered source versions must be plainly marked as such, and must not be
	// misrepresented as being the original software.
	// 3. This notice may not be removed or altered from any source distribution.

	#include "tinygettext/language.hpp"

	#include <assert.h>
	#include <unordered_map>
	#include <vector>
	#include <algorithm>

	namespace tinygettext {

	struct LanguageSpec {
	/** Language code: "de", "en", ... */
	const char* language;

	/** Country code: "BR", "DE", ..., can be 0 */
	const char* country;

	/** Modifier/Varint: "Latn", "ije", "latin"..., can be 0 */
	const char* modifier;

	/** Language name: "German", "English", "French", ... */
	const char* name;
	+
	+ /** Localized language name: "Deutsch", "English", "Français", ... */
	+ const char* localized_name;
	};

	+// NOTE: we have to escape some localized name otherwise VC++ will complain about
	+// the erroneous 'error C2001: newline in constant' even in UTF-8 mode
	+
	/** Language Definitions */
	//*{
	static const LanguageSpec languages[] = {
	- { "aa", 0, 0, "Afar" },
	- { "af", 0, 0, "Afrikaans" },
	- { "af", "ZA", 0, "Afrikaans (South Africa)" },
	- { "am", 0, 0, "Amharic" },
	- { "ar", 0, 0, "Arabic" },
	- { "ar", "AR", 0, "Arabic (Argentina)" },
	- { "ar", "OM", 0, "Arabic (Oman)" },
	- { "ar", "SA", 0, "Arabic (Saudi Arabia)" },
	- { "ar", "SY", 0, "Arabic (Syrian Arab Republic)" },
	- { "ar", "TN", 0, "Arabic (Tunisia)" },
	- { "as", 0, 0, "Assamese" },
	- { "ast",0, 0, "Asturian" },
	- { "ay", 0, 0, "Aymara" },
	- { "az", 0, 0, "Azerbaijani" },
	- { "az", "IR", 0, "Azerbaijani (Iran)" },
	- { "be", 0, 0, "Belarusian" },
	- { "be", 0, "latin", "Belarusian" },
	- { "bg", 0, 0, "Bulgarian" },
	- { "bg", "BG", 0, "Bulgarian (Bulgaria)" },
	- { "bn", 0, 0, "Bengali" },
	- { "bn", "BD", 0, "Bengali (Bangladesh)" },
	- { "bn", "IN", 0, "Bengali (India)" },
	- { "bo", 0, 0, "Tibetan" },
	- { "br", 0, 0, "Breton" },
	- { "bs", 0, 0, "Bosnian" },
	- { "bs", "BA", 0, "Bosnian (Bosnia/Herzegovina)"},
	- { "bs", "BS", 0, "Bosnian (Bahamas)" },
	- { "ca", "ES", "valencia", "Catalan (valencia)" },
	- { "ca", "ES", 0, "Catalan (Spain)" },
	- { "ca", 0, "valencia", "Catalan (valencia)" },
	- { "ca", 0, 0, "Catalan" },
	- { "cmn", 0, 0, "Mandarin" },
	- { "co", 0, 0, "Corsican" },
	- { "cs", 0, 0, "Czech" },
	- { "cs", "CZ", 0, "Czech (Czech Republic)" },
	- { "cy", 0, 0, "Welsh" },
	- { "cy", "GB", 0, "Welsh (Great Britain)" },
	- { "cz", 0, 0, "Unknown language" },
	- { "da", 0, 0, "Danish" },
	- { "da", "DK", 0, "Danish (Denmark)" },
	- { "de", 0, 0, "German" },
	- { "de", "AT", 0, "German (Austria)" },
	- { "de", "CH", 0, "German (Switzerland)" },
	- { "de", "DE", 0, "German (Germany)" },
	- { "dk", 0, 0, "Unknown language" },
	- { "dz", 0, 0, "Dzongkha" },
	- { "el", 0, 0, "Greek" },
	- { "el", "GR", 0, "Greek (Greece)" },
	- { "en", 0, 0, "English" },
	- { "en", "AU", 0, "English (Australia)" },
	- { "en", "CA", 0, "English (Canada)" },
	- { "en", "GB", 0, "English (Great Britain)" },
	- { "en", "US", 0, "English (United States)" },
	- { "en", "ZA", 0, "English (South Africa)" },
	- { "en", 0, "boldquot", "English" },
	- { "en", 0, "quot", "English" },
	- { "en", "US", "piglatin", "English" },
	- { "eo", 0, 0, "Esperanto" },
	- { "es", 0, 0, "Spanish" },
	- { "es", "AR", 0, "Spanish (Argentina)" },
	- { "es", "CL", 0, "Spanish (Chile)" },
	- { "es", "CO", 0, "Spanish (Colombia)" },
	- { "es", "CR", 0, "Spanish (Costa Rica)" },
	- { "es", "DO", 0, "Spanish (Dominican Republic)"},
	- { "es", "EC", 0, "Spanish (Ecuador)" },
	- { "es", "ES", 0, "Spanish (Spain)" },
	- { "es", "GT", 0, "Spanish (Guatemala)" },
	- { "es", "HN", 0, "Spanish (Honduras)" },
	- { "es", "LA", 0, "Spanish (Laos)" },
	- { "es", "MX", 0, "Spanish (Mexico)" },
	- { "es", "NI", 0, "Spanish (Nicaragua)" },
	- { "es", "PA", 0, "Spanish (Panama)" },
	- { "es", "PE", 0, "Spanish (Peru)" },
	- { "es", "PR", 0, "Spanish (Puerto Rico)" },
	- { "es", "SV", 0, "Spanish (El Salvador)" },
	- { "es", "UY", 0, "Spanish (Uruguay)" },
	- { "es", "VE", 0, "Spanish (Venezuela)" },
	- { "et", 0, 0, "Estonian" },
	- { "et", "EE", 0, "Estonian (Estonia)" },
	- { "et", "ET", 0, "Estonian (Ethiopia)" },
	- { "eu", 0, 0, "Basque" },
	- { "eu", "ES", 0, "Basque (Spain)" },
	- { "fa", 0, 0, "Persian" },
	- { "fa", "AF", 0, "Persian (Afghanistan)" },
	- { "fa", "IR", 0, "Persian (Iran)" },
	- { "fi", 0, 0, "Finnish" },
	- { "fi", "FI", 0, "Finnish (Finland)" },
	- { "fo", 0, 0, "Faroese" },
	- { "fo", "FO", 0, "Faeroese (Faroe Islands)" },
	- { "fr", 0, 0, "French" },
	- { "fr", "CA", 0, "French (Canada)" },
	- { "fr", "CH", 0, "French (Switzerland)" },
	- { "fr", "FR", 0, "French (France)" },
	- { "fr", "LU", 0, "French (Luxembourg)" },
	- { "fy", 0, 0, "Frisian" },
	- { "ga", 0, 0, "Irish" },
	- { "gd", 0, 0, "Gaelic Scots" },
	- { "gl", 0, 0, "Galician" },
	- { "gl", "ES", 0, "Galician (Spain)" },
	- { "gn", 0, 0, "Guarani" },
	- { "gu", 0, 0, "Gujarati" },
	- { "gv", 0, 0, "Manx" },
	- { "ha", 0, 0, "Hausa" },
	- { "he", 0, 0, "Hebrew" },
	- { "he", "IL", 0, "Hebrew (Israel)" },
	- { "hi", 0, 0, "Hindi" },
	- { "hr", 0, 0, "Croatian" },
	- { "hr", "HR", 0, "Croatian (Croatia)" },
	- { "hu", 0, 0, "Hungarian" },
	- { "hu", "HU", 0, "Hungarian (Hungary)" },
	- { "hy", 0, 0, "Armenian" },
	- { "ia", 0, 0, "Interlingua" },
	- { "id", 0, 0, "Indonesian" },
	- { "id", "ID", 0, "Indonesian (Indonesia)" },
	- { "is", 0, 0, "Icelandic" },
	- { "is", "IS", 0, "Icelandic (Iceland)" },
	- { "it", 0, 0, "Italian" },
	- { "it", "CH", 0, "Italian (Switzerland)" },
	- { "it", "IT", 0, "Italian (Italy)" },
	- { "iu", 0, 0, "Inuktitut" },
	- { "ja", 0, 0, "Japanese" },
	- { "ja", "JP", 0, "Japanese (Japan)" },
	- { "ka", 0, 0, "Georgian" },
	- { "kk", 0, 0, "Kazakh" },
	- { "kl", 0, 0, "Kalaallisut" },
	- { "km", 0, 0, "Khmer" },
	- { "km", "KH", 0, "Khmer (Cambodia)" },
	- { "kn", 0, 0, "Kannada" },
	- { "ko", 0, 0, "Korean" },
	- { "ko", "KR", 0, "Korean (Korea)" },
	- { "ku", 0, 0, "Kurdish" },
	- { "kw", 0, 0, "Cornish" },
	- { "ky", 0, 0, "Kirghiz" },
	- { "la", 0, 0, "Latin" },
	- { "lo", 0, 0, "Lao" },
	- { "lt", 0, 0, "Lithuanian" },
	- { "lt", "LT", 0, "Lithuanian (Lithuania)" },
	- { "lv", 0, 0, "Latvian" },
	- { "lv", "LV", 0, "Latvian (Latvia)" },
	- { "jbo", 0, 0, "Lojban" },
	- { "mg", 0, 0, "Malagasy" },
	- { "mi", 0, 0, "Maori" },
	- { "mk", 0, 0, "Macedonian" },
	- { "mk", "MK", 0, "Macedonian (Macedonia)" },
	- { "ml", 0, 0, "Malayalam" },
	- { "mn", 0, 0, "Mongolian" },
	- { "mr", 0, 0, "Marathi" },
	- { "ms", 0, 0, "Malay" },
	- { "ms", "MY", 0, "Malay (Malaysia)" },
	- { "mt", 0, 0, "Maltese" },
	- { "my", 0, 0, "Burmese" },
	- { "my", "MM", 0, "Burmese (Myanmar)" },
	- { "nb", 0, 0, "Norwegian Bokmal" },
	- { "nb", "NO", 0, "Norwegian Bokmål (Norway)" },
	- { "ne", 0, 0, "Nepali" },
	- { "nl", 0, 0, "Dutch" },
	- { "nl", "BE", 0, "Dutch (Belgium)" },
	- { "nl", "NL", 0, "Dutch (Netherlands)" },
	- { "nn", 0, 0, "Norwegian Nynorsk" },
	- { "nn", "NO", 0, "Norwegian Nynorsk (Norway)" },
	- { "no", 0, 0, "Norwegian" },
	- { "no", "NO", 0, "Norwegian (Norway)" },
	- { "no", "NY", 0, "Norwegian (NY)" },
	- { "nr", 0, 0, "Ndebele, South" },
	- { "oc", 0, 0, "Occitan post 1500" },
	- { "om", 0, 0, "Oromo" },
	- { "or", 0, 0, "Oriya" },
	- { "pa", 0, 0, "Punjabi" },
	- { "pl", 0, 0, "Polish" },
	- { "pl", "PL", 0, "Polish (Poland)" },
	- { "ps", 0, 0, "Pashto" },
	- { "pt", 0, 0, "Portuguese" },
	- { "pt", "BR", 0, "Portuguese (Brazil)" },
	- { "pt", "PT", 0, "Portuguese (Portugal)" },
	- { "qu", 0, 0, "Quechua" },
	- { "rm", 0, 0, "Rhaeto-Romance" },
	- { "ro", 0, 0, "Romanian" },
	- { "ro", "RO", 0, "Romanian (Romania)" },
	- { "ru", 0, 0, "Russian" },
	- { "ru", "RU", 0, "Russian (Russia)" },
	- { "rw", 0, 0, "Kinyarwanda" },
	- { "sa", 0, 0, "Sanskrit" },
	- { "sd", 0, 0, "Sindhi" },
	- { "se", 0, 0, "Sami" },
	- { "se", "NO", 0, "Sami (Norway)" },
	- { "si", 0, 0, "Sinhalese" },
	- { "sk", 0, 0, "Slovak" },
	- { "sk", "SK", 0, "Slovak (Slovakia)" },
	- { "sl", 0, 0, "Slovenian" },
	- { "sl", "SI", 0, "Slovenian (Slovenia)" },
	- { "sl", "SL", 0, "Slovenian (Sierra Leone)" },
	- { "sm", 0, 0, "Samoan" },
	- { "so", 0, 0, "Somali" },
	- { "sp", 0, 0, "Unknown language" },
	- { "sq", 0, 0, "Albanian" },
	- { "sq", "AL", 0, "Albanian (Albania)" },
	- { "sr", 0, 0, "Serbian" },
	- { "sr", "YU", 0, "Serbian (Yugoslavia)" },
	- { "sr", 0,"ije", "Serbian" },
	- { "sr", 0, "latin", "Serbian" },
	- { "sr", 0, "Latn", "Serbian" },
	- { "ss", 0, 0, "Swati" },
	- { "st", 0, 0, "Sotho" },
	- { "sv", 0, 0, "Swedish" },
	- { "sv", "SE", 0, "Swedish (Sweden)" },
	- { "sv", "SV", 0, "Swedish (El Salvador)" },
	- { "sw", 0, 0, "Swahili" },
	- { "ta", 0, 0, "Tamil" },
	- { "te", 0, 0, "Telugu" },
	- { "tg", 0, 0, "Tajik" },
	- { "th", 0, 0, "Thai" },
	- { "th", "TH", 0, "Thai (Thailand)" },
	- { "ti", 0, 0, "Tigrinya" },
	- { "tk", 0, 0, "Turkmen" },
	- { "tl", 0, 0, "Tagalog" },
	- { "to", 0, 0, "Tonga" },
	- { "tr", 0, 0, "Turkish" },
	- { "tr", "TR", 0, "Turkish (Turkey)" },
	- { "ts", 0, 0, "Tsonga" },
	- { "tt", 0, 0, "Tatar" },
	- { "ug", 0, 0, "Uighur" },
	- { "uk", 0, 0, "Ukrainian" },
	- { "uk", "UA", 0, "Ukrainian (Ukraine)" },
	- { "ur", 0, 0, "Urdu" },
	- { "ur", "PK", 0, "Urdu (Pakistan)" },
	- { "uz", 0, 0, "Uzbek" },
	- { "uz", 0, "cyrillic", "Uzbek" },
	- { "vi", 0, 0, "Vietnamese" },
	- { "vi", "VN", 0, "Vietnamese (Vietnam)" },
	- { "wa", 0, 0, "Walloon" },
	- { "wo", 0, 0, "Wolof" },
	- { "xh", 0, 0, "Xhosa" },
	- { "yi", 0, 0, "Yiddish" },
	- { "yo", 0, 0, "Yoruba" },
	- { "zh", 0, 0, "Chinese" },
	- { "zh", "CN", 0, "Chinese (simplified)" },
	- { "zh", "HK", 0, "Chinese (Hong Kong)" },
	- { "zh", "TW", 0, "Chinese (traditional)" },
	- { "zu", 0, 0, "Zulu" },
	- { NULL, 0, 0, NULL }
	+ { "aa", 0, 0, "Afar" , "ʿAfár af" },
	+ { "af", 0, 0, "Afrikaans" , "Afrikaans" },
	+ { "af", "ZA", 0, "Afrikaans (South Africa)" , 0 },
	+ { "am", 0, 0, "Amharic" , "ኣማርኛ" },
	+ { "ar", 0, 0, "Arabic" , "العربية" },
	+ { "ar", "AR", 0, "Arabic (Argentina)" , 0 },
	+ { "ar", "OM", 0, "Arabic (Oman)" , 0 },
	+ { "ar", "SA", 0, "Arabic (Saudi Arabia)" , 0 },
	+ { "ar", "SY", 0, "Arabic (Syrian Arab Republic)" , 0 },
	+ { "ar", "TN", 0, "Arabic (Tunisia)" , 0 },
	+ { "as", 0, 0, "Assamese" , "\xE0\xA6\x85\xE0\xA6\xB8\xE0\xA6\xAE\xE0\xA7\x80\xE0\xA6\xAF\xE0\xA6\xBC\xE0\xA6\xBE" },
	+ { "ast",0, 0, "Asturian" , "Asturianu" },
	+ { "ay", 0, 0, "Aymara" , "Aymar aru" },
	+ { "az", 0, 0, "Azerbaijani" , "Azərbaycanca" },
	+ { "az", "IR", 0, "Azerbaijani (Iran)" , 0 },
	+ { "be", 0, 0, "Belarusian" , "Беларуская мова" },
	+ { "be", 0, "latin", "Belarusian" , "Беларуская мова" },
	+ { "bg", 0, 0, "Bulgarian" , "български" },
	+ { "bg", "BG", 0, "Bulgarian (Bulgaria)" , 0 },
	+ { "bn", 0, 0, "Bengali" , "\xE0\xA6\xAC\xE0\xA6\xBE\xE0\xA6\x82\xE0\xA6\xB2\xE0\xA6\xBE" },
	+ { "bn", "BD", 0, "Bengali (Bangladesh)" , 0 },
	+ { "bn", "IN", 0, "Bengali (India)" , 0 },
	+ { "bo", 0, 0, "Tibetan" , "བོད་སྐད་" },
	+ { "br", 0, 0, "Breton" , "Brezhoneg" },
	+ { "bs", 0, 0, "Bosnian" , "Bosanski" },
	+ { "bs", "BA", 0, "Bosnian (Bosnia/Herzegovina)", 0 },
	+ { "bs", "BS", 0, "Bosnian (Bahamas)" , 0 },
	+ { "ca", "ES", "valencia", "Catalan (valencia)" , 0 },
	+ { "ca", "ES", 0, "Catalan (Spain)" , 0 },
	+ { "ca", 0, "valencia", "Catalan (valencia)" , 0 },
	+ { "ca", 0, 0, "Catalan" , 0 },
	+ { "cmn", 0, 0, "Mandarin" , 0 },
	+ { "co", 0, 0, "Corsican" , "Corsu" },
	+ { "cs", 0, 0, "Czech" , "Čeština" },
	+ { "cs", "CZ", 0, "Czech (Czech Republic)" , "Čeština (Česká Republika)" },
	+ { "cy", 0, 0, "Welsh" , "Welsh" },
	+ { "cy", "GB", 0, "Welsh (Great Britain)" , "Welsh (Great Britain)" },
	+ { "cz", 0, 0, "Unknown language" , "Unknown language" },
	+ { "da", 0, 0, "Danish" , "Dansk" },
	+ { "da", "DK", 0, "Danish (Denmark)" , "Dansk (Danmark)" },
	+ { "de", 0, 0, "German" , "Deutsch" },
	+ { "de", "AT", 0, "German (Austria)" , "Deutsch (Österreich)" },
	+ { "de", "CH", 0, "German (Switzerland)" , "Deutsch (Schweiz)" },
	+ { "de", "DE", 0, "German (Germany)" , "Deutsch (Deutschland)" },
	+ { "dk", 0, 0, "Unknown language" , "Unknown language" },
	+ { "dz", 0, 0, "Dzongkha" , "རྫོང་ཁ" },
	+ { "el", 0, 0, "Greek" , "ελληνικά" },
	+ { "el", "GR", 0, "Greek (Greece)" , 0 },
	+ { "en", 0, 0, "English" , "English" },
	+ { "en", "AU", 0, "English (Australia)" , "English (Australia)" },
	+ { "en", "CA", 0, "English (Canada)" , "English (Canada)" },
	+ { "en", "GB", 0, "English (Great Britain)" , "English (Great Britain)" },
	+ { "en", "US", 0, "English (United States)" , "English" },
	+ { "en", "ZA", 0, "English (South Africa)" , "English (South Africa)" },
	+ { "en", 0, "boldquot", "English" , "English" },
	+ { "en", 0, "quot", "English" , "English" },
	+ { "en", "US", "piglatin", "English" , "English" },
	+ { "eo", 0, 0, "Esperanto" , "Esperanto" },
	+ { "es", 0, 0, "Spanish" , "Español" },
	+ { "es", "AR", 0, "Spanish (Argentina)" , 0 },
	+ { "es", "CL", 0, "Spanish (Chile)" , 0 },
	+ { "es", "CO", 0, "Spanish (Colombia)" , 0 },
	+ { "es", "CR", 0, "Spanish (Costa Rica)" , 0 },
	+ { "es", "DO", 0, "Spanish (Dominican Republic)", 0 },
	+ { "es", "EC", 0, "Spanish (Ecuador)" , 0 },
	+ { "es", "ES", 0, "Spanish (Spain)" , 0 },
	+ { "es", "GT", 0, "Spanish (Guatemala)" , 0 },
	+ { "es", "HN", 0, "Spanish (Honduras)" , 0 },
	+ { "es", "LA", 0, "Spanish (Laos)" , 0 },
	+ { "es", "MX", 0, "Spanish (Mexico)" , 0 },
	+ { "es", "NI", 0, "Spanish (Nicaragua)" , 0 },
	+ { "es", "PA", 0, "Spanish (Panama)" , 0 },
	+ { "es", "PE", 0, "Spanish (Peru)" , 0 },
	+ { "es", "PR", 0, "Spanish (Puerto Rico)" , 0 },
	+ { "es", "SV", 0, "Spanish (El Salvador)" , 0 },
	+ { "es", "UY", 0, "Spanish (Uruguay)" , 0 },
	+ { "es", "VE", 0, "Spanish (Venezuela)" , 0 },
	+ { "et", 0, 0, "Estonian" , "Eesti keel" },
	+ { "et", "EE", 0, "Estonian (Estonia)" , 0 },
	+ { "et", "ET", 0, "Estonian (Ethiopia)" , 0 },
	+ { "eu", 0, 0, "Basque" , "Euskara" },
	+ { "eu", "ES", 0, "Basque (Spain)" , 0 },
	+ { "fa", 0, 0, "Persian" , "فارسى" },
	+ { "fa", "AF", 0, "Persian (Afghanistan)" , 0 },
	+ { "fa", "IR", 0, "Persian (Iran)" , 0 },
	+ { "fi", 0, 0, "Finnish" , "Suomi" },
	+ { "fi", "FI", 0, "Finnish (Finland)" , 0 },
	+ { "fo", 0, 0, "Faroese" , "Føroyskt" },
	+ { "fo", "FO", 0, "Faeroese (Faroe Islands)" , 0 },
	+ { "fr", 0, 0, "French" , "Français" },
	+ { "fr", "CA", 0, "French (Canada)" , "Français (Canada)" },
	+ { "fr", "CH", 0, "French (Switzerland)" , "Français (Suisse)" },
	+ { "fr", "FR", 0, "French (France)" , "Français (France)" },
	+ { "fr", "LU", 0, "French (Luxembourg)" , "Français (Luxembourg)" },
	+ { "fy", 0, 0, "Frisian" , "Frysk" },
	+ { "ga", 0, 0, "Irish" , "Gaeilge" },
	+ { "gd", 0, 0, "Gaelic Scots" , "Gàidhlig" },
	+ { "gl", 0, 0, "Galician" , "Galego" },
	+ { "gl", "ES", 0, "Galician (Spain)" , 0 },
	+ { "gn", 0, 0, "Guarani" , "Ava\xC3\xB1" /* here we must separate otherwise VC++ will complain about \xB1E */ "e'\xE1\xBA\xBD" },
	+ { "gu", 0, 0, "Gujarati" , "ગુજરાતી" },
	+ { "gv", 0, 0, "Manx" , "Gaelg" },
	+ { "ha", 0, 0, "Hausa" , "حَوْسَ" },
	+ { "he", 0, 0, "Hebrew" , "עברית" },
	+ { "he", "IL", 0, "Hebrew (Israel)" , 0 },
	+ { "hi", 0, 0, "Hindi" , "हिन्दी" },
	+ { "hr", 0, 0, "Croatian" , "Hrvatski" },
	+ { "hr", "HR", 0, "Croatian (Croatia)" , 0 },
	+ { "hu", 0, 0, "Hungarian" , "Magyar" },
	+ { "hu", "HU", 0, "Hungarian (Hungary)" , 0 },
	+ { "hy", 0, 0, "Armenian" , "Հայերեն" },
	+ { "ia", 0, 0, "Interlingua" , "Interlingua" },
	+ { "id", 0, 0, "Indonesian" , "Bahasa Indonesia" },
	+ { "id", "ID", 0, "Indonesian (Indonesia)" , 0 },
	+ { "is", 0, 0, "Icelandic" , "Íslenska" },
	+ { "is", "IS", 0, "Icelandic (Iceland)" , 0 },
	+ { "it", 0, 0, "Italian" , "Italiano" },
	+ { "it", "CH", 0, "Italian (Switzerland)" , 0 },
	+ { "it", "IT", 0, "Italian (Italy)" , 0 },
	+ { "iu", 0, 0, "Inuktitut" , "ᐃᓄᒃᑎᑐᑦ/inuktitut" },
	+ { "ja", 0, 0, "Japanese" , "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" },
	+ { "ja", "JP", 0, "Japanese (Japan)" , 0 },
	+ { "ka", 0, 0, "Georgian" , "\xE1\x83\xA5\xE1\x83\x90\xE1\x83\xA0\xE1\x83\x97\xE1\x83\xA3\xE1\x83\x9A\xE1\x83\x98" },
	+ { "kk", 0, 0, "Kazakh" , "Қазақша" },
	+ { "kl", 0, 0, "Kalaallisut" , "Kalaallisut" },
	+ { "km", 0, 0, "Khmer" , "\xE1\x9E\x97\xE1\x9E\xB6\xE1\x9E\x9F\xE1\x9E\xB6\xE1\x9E\x81\xE1\x9F\x92\xE1\x9E\x98\xE1\x9F\x82\xE1\x9E\x9A" },
	+ { "km", "KH", 0, "Khmer (Cambodia)" , 0 },
	+ { "kn", 0, 0, "Kannada" , "\xE0\xB2\x95\xE0\xB2\xA8\xE0\xB3\x8D\xE0\xB2\xA8\xE0\xB2\xA1" },
	+ { "ko", 0, 0, "Korean" , "\xED\x95\x9C\xEA\xB5\xAD\xEC\x96\xB4" },
	+ { "ko", "KR", 0, "Korean (Korea)" , 0 },
	+ { "ku", 0, 0, "Kurdish" , "Kurdî" },
	+ { "kw", 0, 0, "Cornish" , "Kernowek" },
	+ { "ky", 0, 0, "Kirghiz" , "кыргызча" },
	+ { "la", 0, 0, "Latin" , "Latina" },
	+ { "lo", 0, 0, "Lao" , "\xE0\xBA\xA5\xE0\xBA\xB2\xE0\xBA\xA7" },
	+ { "lt", 0, 0, "Lithuanian" , "Lietuvių" },
	+ { "lt", "LT", 0, "Lithuanian (Lithuania)" , 0 },
	+ { "lv", 0, 0, "Latvian" , "Latviešu" },
	+ { "lv", "LV", 0, "Latvian (Latvia)" , 0 },
	+ { "jbo", 0, 0, "Lojban" , "La .lojban." },
	+ { "mg", 0, 0, "Malagasy" , "Malagasy" },
	+ { "mi", 0, 0, "Maori" , "Māori" },
	+ { "mk", 0, 0, "Macedonian" , "Македонски" },
	+ { "mk", "MK", 0, "Macedonian (Macedonia)" , 0 },
	+ { "ml", 0, 0, "Malayalam" , "മലയാളം" },
	+ { "mn", 0, 0, "Mongolian" , "Монгол" },
	+ { "mr", 0, 0, "Marathi" , "मराठी" },
	+ { "ms", 0, 0, "Malay" , "Bahasa Melayu" },
	+ { "ms", "MY", 0, "Malay (Malaysia)" , 0 },
	+ { "mt", 0, 0, "Maltese" , "Malti" },
	+ { "my", 0, 0, "Burmese" , "\xE1\x80\x99\xE1\x80\xBC\xE1\x80\x94\xE1\x80\xBA\xE1\x80\x99\xE1\x80\xAC\xE1\x80\x98\xE1\x80\xAC\xE1\x80\x9E\xE1\x80\xAC" },
	+ { "my", "MM", 0, "Burmese (Myanmar)" , 0 },
	+ { "nb", 0, 0, "Norwegian Bokmal" , 0 },
	+ { "nb", "NO", 0, "Norwegian Bokmål (Norway)" , 0 },
	+ { "ne", 0, 0, "Nepali" , 0 },
	+ { "nl", 0, 0, "Dutch" , "Nederlands" },
	+ { "nl", "BE", 0, "Dutch (Belgium)" , 0 },
	+ { "nl", "NL", 0, "Dutch (Netherlands)" , 0 },
	+ { "nn", 0, 0, "Norwegian Nynorsk" , "Norsk nynorsk" },
	+ { "nn", "NO", 0, "Norwegian Nynorsk (Norway)" , 0 },
	+ { "no", 0, 0, "Norwegian" , "Norsk bokmål" },
	+ { "no", "NO", 0, "Norwegian (Norway)" , 0 },
	+ { "no", "NY", 0, "Norwegian (NY)" , 0 },
	+ { "nr", 0, 0, "Ndebele, South" , 0 },
	+ { "oc", 0, 0, "Occitan post 1500" , "Occitan" },
	+ { "om", 0, 0, "Oromo" , "Oromoo" },
	+ { "or", 0, 0, "Oriya" , "\xE0\xAC\x93\xE0\xAC\xA1\xE0\xAC\xBC\xE0\xAC\xBF\xE0\xAC\x86" },
	+ { "pa", 0, 0, "Punjabi" , "ਪੰਜਾਬੀ" },
	+ { "pl", 0, 0, "Polish" , "Polski" },
	+ { "pl", "PL", 0, "Polish (Poland)" , 0 },
	+ { "ps", 0, 0, "Pashto" , "پښتو" },
	+ { "pt", 0, 0, "Portuguese" , "Português" },
	+ { "pt", "BR", 0, "Portuguese (Brazil)" , 0 },
	+ { "pt", "PT", 0, "Portuguese (Portugal)" , 0 },
	+ { "qu", 0, 0, "Quechua" , "Runa Simi" },
	+ { "rm", 0, 0, "Rhaeto-Romance" , "Rumantsch" },
	+ { "ro", 0, 0, "Romanian" , "Română" },
	+ { "ro", "RO", 0, "Romanian (Romania)" , 0 },
	+ { "ru", 0, 0, "Russian" , "Русский" },
	+ { "ru", "RU", 0, "Russian (Russia)" , 0 },
	+ { "rw", 0, 0, "Kinyarwanda" , "Kinyarwanda" },
	+ { "sa", 0, 0, "Sanskrit" , 0 },
	+ { "sd", 0, 0, "Sindhi" , 0 },
	+ { "se", 0, 0, "Sami" , "Sámegiella" },
	+ { "se", "NO", 0, "Sami (Norway)" , 0 },
	+ { "si", 0, 0, "Sinhalese" , 0 },
	+ { "sk", 0, 0, "Slovak" , "Slovenčina" },
	+ { "sk", "SK", 0, "Slovak (Slovakia)" , 0 },
	+ { "sl", 0, 0, "Slovenian" , "Slovenščina" },
	+ { "sl", "SI", 0, "Slovenian (Slovenia)" , 0 },
	+ { "sl", "SL", 0, "Slovenian (Sierra Leone)" , 0 },
	+ { "sm", 0, 0, "Samoan" , 0 },
	+ { "so", 0, 0, "Somali" , 0 },
	+ { "sp", 0, 0, "Unknown language" , 0 },
	+ { "sq", 0, 0, "Albanian" , "Shqip" },
	+ { "sq", "AL", 0, "Albanian (Albania)" , 0 },
	+ { "sr", 0, 0, "Serbian" , "Српски" },
	+ { "sr", "YU", 0, "Serbian (Yugoslavia)" , 0 },
	+ { "sr", 0,"ije", "Serbian" , "Српски" },
	+ { "sr", 0, "latin", "Serbian" , "Српски" },
	+ { "sr", 0, "Latn", "Serbian" , "Српски" },
	+ { "ss", 0, 0, "Swati" , 0 },
	+ { "st", 0, 0, "Sotho" , 0 },
	+ { "sv", 0, 0, "Swedish" , "Svenska" },
	+ { "sv", "SE", 0, "Swedish (Sweden)" , 0 },
	+ { "sv", "SV", 0, "Swedish (El Salvador)" , 0 },
	+ { "sw", 0, 0, "Swahili" , 0 },
	+ { "ta", 0, 0, "Tamil" , "\xE0\xAE\xA4\xE0\xAE\xAE\xE0\xAE\xBF\xE0\xAE\xB4\xE0\xAF\x8D" },
	+ { "te", 0, 0, "Telugu" , 0 },
	+ { "tg", 0, 0, "Tajik" , 0 },
	+ { "th", 0, 0, "Thai" , "\xE0\xB9\x84\xE0\xB8\x97\xE0\xB8\xA2" },
	+ { "th", "TH", 0, "Thai (Thailand)" , 0 },
	+ { "ti", 0, 0, "Tigrinya" , 0 },
	+ { "tk", 0, 0, "Turkmen" , 0 },
	+ { "tl", 0, 0, "Tagalog" , 0 },
	+ { "to", 0, 0, "Tonga" , 0 },
	+ { "tr", 0, 0, "Turkish" , "Türkçe" },
	+ { "tr", "TR", 0, "Turkish (Turkey)" , 0 },
	+ { "ts", 0, 0, "Tsonga" , 0 },
	+ { "tt", 0, 0, "Tatar" , "Татарча" },
	+ { "ug", 0, 0, "Uighur" , 0 },
	+ { "uk", 0, 0, "Ukrainian" , "Українська" },
	+ { "uk", "UA", 0, "Ukrainian (Ukraine)" , 0 },
	+ { "ur", 0, 0, "Urdu" , "اردو" },
	+ { "ur", "PK", 0, "Urdu (Pakistan)" , 0 },
	+ { "uz", 0, 0, "Uzbek" , 0 },
	+ { "uz", 0, "cyrillic", "Uzbek" , 0 },
	+ { "vi", 0, 0, "Vietnamese" , "Tiếng Việt" },
	+ { "vi", "VN", 0, "Vietnamese (Vietnam)" , 0 },
	+ { "wa", 0, 0, "Walloon" , 0 },
	+ { "wo", 0, 0, "Wolof" , 0 },
	+ { "xh", 0, 0, "Xhosa" , 0 },
	+ { "yi", 0, 0, "Yiddish" , "ייִדיש" },
	+ { "yo", 0, 0, "Yoruba" , 0 },
	+ { "zh", 0, 0, "Chinese" , "中文" },
	+ { "zh", "CN", 0, "Chinese (simplified)" , "中文（简体）" },
	+ { "zh", "HK", 0, "Chinese (Hong Kong)" , "中文（香港）" },
	+ { "zh", "TW", 0, "Chinese (traditional)" , "中文（繁體）" },
	+ { "zu", 0, 0, "Zulu" , 0 },
	+ { NULL, 0, 0, NULL , 0 }
	};
	//*}

	std::string
	resolve_language_alias(const std::string& name)
	{
	typedef std::unordered_map<std::string, std::string> Aliases;
	static Aliases language_aliases;
	if (language_aliases.empty())
	{
	// FIXME: Many of those are not useful for us, since we leave
	// encoding to the app, not to the language, we could/should
	// also match against all language names, not just aliases from
	// locale.alias

	// Aliases taken from /etc/locale.alias
	language_aliases["bokmal"] = "nb_NO.ISO-8859-1";
	language_aliases["bokmål"] = "nb_NO.ISO-8859-1";
	language_aliases["catalan"] = "ca_ES.ISO-8859-1";
	language_aliases["croatian"] = "hr_HR.ISO-8859-2";
	language_aliases["czech"] = "cs_CZ.ISO-8859-2";
	language_aliases["danish"] = "da_DK.ISO-8859-1";
	language_aliases["dansk"] = "da_DK.ISO-8859-1";
	language_aliases["deutsch"] = "de_DE.ISO-8859-1";
	language_aliases["dutch"] = "nl_NL.ISO-8859-1";
	language_aliases["eesti"] = "et_EE.ISO-8859-1";
	language_aliases["estonian"] = "et_EE.ISO-8859-1";
	language_aliases["finnish"] = "fi_FI.ISO-8859-1";
	language_aliases["français"] = "fr_FR.ISO-8859-1";
	language_aliases["french"] = "fr_FR.ISO-8859-1";
	language_aliases["galego"] = "gl_ES.ISO-8859-1";
	language_aliases["galician"] = "gl_ES.ISO-8859-1";
	language_aliases["german"] = "de_DE.ISO-8859-1";
	language_aliases["greek"] = "el_GR.ISO-8859-7";
	language_aliases["hebrew"] = "he_IL.ISO-8859-8";
	language_aliases["hrvatski"] = "hr_HR.ISO-8859-2";
	language_aliases["hungarian"] = "hu_HU.ISO-8859-2";
	language_aliases["icelandic"] = "is_IS.ISO-8859-1";
	language_aliases["italian"] = "it_IT.ISO-8859-1";
	language_aliases["japanese"] = "ja_JP.eucJP";
	language_aliases["japanese.euc"] = "ja_JP.eucJP";
	language_aliases["ja_JP"] = "ja_JP.eucJP";
	language_aliases["ja_JP.ujis"] = "ja_JP.eucJP";
	language_aliases["japanese.sjis"] = "ja_JP.SJIS";
	language_aliases["korean"] = "ko_KR.eucKR";
	language_aliases["korean.euc"] = "ko_KR.eucKR";
	language_aliases["ko_KR"] = "ko_KR.eucKR";
	language_aliases["lithuanian"] = "lt_LT.ISO-8859-13";
	language_aliases["no_NO"] = "nb_NO.ISO-8859-1";
	language_aliases["no_NO.ISO-8859-1"] = "nb_NO.ISO-8859-1";
	language_aliases["norwegian"] = "nb_NO.ISO-8859-1";
	language_aliases["nynorsk"] = "nn_NO.ISO-8859-1";
	language_aliases["polish"] = "pl_PL.ISO-8859-2";
	language_aliases["portuguese"] = "pt_PT.ISO-8859-1";
	language_aliases["romanian"] = "ro_RO.ISO-8859-2";
	language_aliases["russian"] = "ru_RU.ISO-8859-5";
	language_aliases["slovak"] = "sk_SK.ISO-8859-2";
	language_aliases["slovene"] = "sl_SI.ISO-8859-2";
	language_aliases["slovenian"] = "sl_SI.ISO-8859-2";
	language_aliases["spanish"] = "es_ES.ISO-8859-1";
	language_aliases["swedish"] = "sv_SE.ISO-8859-1";
	language_aliases["thai"] = "th_TH.TIS-620";
	language_aliases["turkish"] = "tr_TR.ISO-8859-9";
	}

	std::string name_lowercase;
	name_lowercase.resize(name.size());
	for(std::string::size_type i = 0; i < name.size(); ++i)
	name_lowercase[i] = static_cast<char>(tolower(name[i]));

	Aliases::iterator i = language_aliases.find(name_lowercase);
	if (i != language_aliases.end())
	{
	return i->second;
	}
	else
	{
	return name;
	}
	}

	Language
	Language::from_spec(const std::string& language, const std::string& country, const std::string& modifier)
	{
	typedef std::unordered_map<std::string, std::vector<const LanguageSpec*> > LanguageSpecMap;
	static LanguageSpecMap language_map;

	if (language_map.empty())
	{ // Init language_map
	for(int i = 0; languages[i].language != NULL; ++i)
	language_map[languages[i].language].push_back(&languages[i]);
	}

	LanguageSpecMap::iterator i = language_map.find(language);
	if (i != language_map.end())
	{
	std::vector<const LanguageSpec*>& lst = i->second;

	LanguageSpec tmpspec;
	tmpspec.language = language.c_str();
	tmpspec.country = country.c_str();
	tmpspec.modifier = modifier.c_str();
	Language tmplang(&tmpspec);

	const LanguageSpec* best_match = 0;
	int best_match_score = 0;
	for(std::vector<const LanguageSpec*>::iterator j = lst.begin(); j != lst.end(); ++j)
	{ // Search for the language that best matches the given spec, value country more then modifier
	int score = Language::match(Language(*j), tmplang);

	if (score > best_match_score)
	{
	best_match = *j;
	best_match_score = score;
	}
	}
	assert(best_match);
	return Language(best_match);
	}
	else
	{
	return Language();
	}
	}

	Language
	Language::from_name(const std::string& spec_str)
	{
	return from_env(resolve_language_alias(spec_str));
	}

	Language
	Language::from_env(const std::string& env)
	{
	// Split LANGUAGE_COUNTRY.CODESET@MODIFIER into parts
	std::string::size_type ln = env.find('_');
	std::string::size_type dt = env.find('.');
	std::string::size_type at = env.find('@');

	std::string language;
	std::string country;
	std::string codeset;
	std::string modifier;

	//std::cout << ln << " " << dt << " " << at << std::endl;

	language = env.substr(0, std::min(std::min(ln, dt), at));

	if (ln != std::string::npos && ln+1 < env.size()) // _
	{
	country = env.substr(ln+1, (std::min(dt, at) == std::string::npos) ? std::string::npos : std::min(dt, at) - (ln+1));
	}

	if (dt != std::string::npos && dt+1 < env.size()) // .
	{
	codeset = env.substr(dt+1, (at == std::string::npos) ? std::string::npos : (at - (dt+1)));
	}

	if (at != std::string::npos && at+1 < env.size()) // @
	{
	modifier = env.substr(at+1);
	}

	// Some workaround for files generated by Hosted Weblate
	if (language == "zh")
	{
	if (country == "Hans" \|\| country == "HANS") country = "CN";
	else if (country == "Hant" \|\| country == "HANT") country = "TW";
	}

	return from_spec(language, country, modifier);
	}

	Language::Language(const LanguageSpec* language_spec_)
	: language_spec(language_spec_)
	{
	}

	Language::Language()
	: language_spec(0)
	{
	}

	int
	Language::match(const Language& lhs, const Language& rhs)
	{
	if (lhs.get_language() != rhs.get_language())
	{
	return 0;
	}
	else
	{
	static int match_tbl[3][3] = {
	// modifier match, wildchard, miss
	{ 9, 8, 5 }, // country match
	{ 7, 6, 3 }, // country wildcard
	{ 4, 2, 1 }, // country miss
	};

	int c;
	if (lhs.get_country() == rhs.get_country())
	c = 0;
	else if (lhs.get_country().empty() \|\| rhs.get_country().empty())
	c = 1;
	else
	c = 2;

	int m;
	if (lhs.get_modifier() == rhs.get_modifier())
	m = 0;
	else if (lhs.get_modifier().empty() \|\| rhs.get_modifier().empty())
	m = 1;
	else
	m = 2;

	return match_tbl[c][m];
	}
	}

	std::string
	Language::get_language() const
	{
	if (language_spec)
	return language_spec->language;
	else
	return "";
	}

	std::string
	Language::get_country() const
	{
	if (language_spec && language_spec->country)
	return language_spec->country;
	else
	return "";
	}

	std::string
	Language::get_modifier() const
	{
	if (language_spec && language_spec->modifier)
	return language_spec->modifier;
	else
	return "";
	}

	std::string
	Language::get_name() const
	{
	if (language_spec)
	return language_spec->name;
	else
	return "";
	}

	+std::string
	+Language::get_localized_name() const
	+{
	+ if (language_spec == NULL)
	+ return "";
	+ if (language_spec->localized_name)
	+ return language_spec->localized_name;
	+ return language_spec->name;
	+}
	+
	std::string
	Language::str() const
	{
	if (language_spec)
	{
	std::string var;
	var += language_spec->language;
	if (language_spec->country)
	{
	var += "_";
	var += language_spec->country;
	}

	if (language_spec->modifier)
	{
	var += "@";
	var += language_spec->modifier;
	}
	return var;
	}
	else
	{
	return "";
	}
	}

	bool
	Language::operator==(const Language& rhs) const
	{
	return language_spec == rhs.language_spec;
	}

	bool
	Language::operator!=(const Language& rhs) const
	{
	return language_spec != rhs.language_spec;
	}

	} // namespace tinygettext

	/* EOF */
	diff --git a/src/libs/tinygettext/language.hpp b/src/libs/tinygettext/language.hpp
	index 205d0db..9df5ce2 100644
	--- a/src/libs/tinygettext/language.hpp
	+++ b/src/libs/tinygettext/language.hpp
	@@ -1,103 +1,106 @@
	// tinygettext - A gettext replacement that works directly on .po files
	// Copyright (c) 2006 Ingo Ruhnke <grumbel@gmail.com>
	//
	// This software is provided 'as-is', without any express or implied
	// warranty. In no event will the authors be held liable for any damages
	// arising from the use of this software.
	//
	// Permission is granted to anyone to use this software for any purpose,
	// including commercial applications, and to alter it and redistribute it
	// freely, subject to the following restrictions:
	//
	// 1. The origin of this software must not be misrepresented; you must not
	// claim that you wrote the original software. If you use this software
	// in a product, an acknowledgement in the product documentation would be
	// appreciated but is not required.
	// 2. Altered source versions must be plainly marked as such, and must not be
	// misrepresented as being the original software.
	// 3. This notice may not be removed or altered from any source distribution.

	#ifndef HEADER_TINYGETTEXT_LANGUAGE_HPP
	#define HEADER_TINYGETTEXT_LANGUAGE_HPP

	#include <string>
	#include <unordered_map>

	namespace tinygettext {

	struct LanguageSpec;

	/** Lightweight wrapper around LanguageSpec */
	class Language
	{
	private:
	const LanguageSpec* language_spec;

	Language(const LanguageSpec* language_spec);

	public:
	/** Create a language from language and country code:
	Example: Languge("de", "DE"); */
	static Language from_spec(const std::string& language,
	const std::string& country = std::string(),
	const std::string& modifier = std::string());

	/** Create a language from language and country code:
	Example: Languge("deutsch");
	Example: Languge("de_DE"); */
	static Language from_name(const std::string& str);

	/** Create a language from an environment variable style string (e.g de_DE.UTF-8@modifier) */
	static Language from_env(const std::string& env);

	/** Compares two Languages, returns 0 on missmatch and a score
	between 1 and 9 on match, the higher the score the better the
	match */
	static int match(const Language& lhs, const Language& rhs);

	/** Create an undefined Language object */
	Language();

	explicit operator bool() const { return language_spec != NULL; }

	/** Returns the language code (i.e. de, en, fr) */
	std::string get_language() const;

	/** Returns the country code (i.e. DE, AT, US) */
	std::string get_country() const;

	/** Returns the modifier of the language (i.e. latn or Latn for
	Serbian with non-cyrilic characters) */
	std::string get_modifier() const;

	- /** Returns the human readable name of the Language */
	+ /** Returns the human readable name of the Language, in English */
	std::string get_name() const;

	+ /** Returns the localized human readable name of the Language */
	+ std::string get_localized_name() const;
	+
	/** Returns the Language as string in the form of an environment
	variable: {language}_{country}@{modifier} */
	std::string str() const;

	bool operator==(const Language& rhs) const;
	bool operator!=(const Language& rhs) const;

	friend bool operator<(const Language& lhs, const Language& rhs);
	friend struct Language_hash;
	};

	inline bool operator<(const Language& lhs, const Language& rhs) {
	return lhs.language_spec < rhs.language_spec;
	}

	struct Language_hash
	{
	size_t operator()(const Language& v) const
	{
	return reinterpret_cast<size_t>(v.language_spec);
	}
	};

	} // namespace tinygettext

	#endif

	/* EOF */
	diff --git a/tools/extract_pot.py b/tools/extract_pot.py
	index 80b2af3..ccc5873 100644
	--- a/tools/extract_pot.py
	+++ b/tools/extract_pot.py
	@@ -1,137 +1,137 @@
	# Copyright (C) 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/>.

	import sys, os, os.path
	from collections import defaultdict

	#The path to the levelpack.
	levelpackPath = ""

	#The dictionary which will hold all the translatable strings.
	dictionary = defaultdict(list)

	#The file stream to write to.
	potFile = None

	#Some vars to keep track of where we are/get stuff from.
	curfile = ""
	curline = 1


	#Method that will create the .pot file and open the file stream.
	def openPotFile():
	for root, dirs, files in os.walk(levelpackPath):
	#Check if the directory 'locale' is present.
	fullpath = os.path.join(root, 'locale')
	if not os.path.exists(fullpath):
	os.makedirs(fullpath)
	fullpath = os.path.join(fullpath, 'messages.pot')
	global potFile
	potFile = open(fullpath,"w")
	break


	#Method that loops through the files of the levelpack.
	def loopfiles():
	for root, dirs, files in os.walk(levelpackPath):
	if root.count(os.sep) < 1:
	for f in files:
	fullpath = os.path.join(root, f)
	global curfile
	curfile = fullpath
	looplines(fullpath)

	#Method that loops through the lines of a given file.
	def looplines(f):
	fileInput = open(f,"r")
	global curline
	curline = 1
	for line in fileInput:
	lookup(line)
	curline += 1
	fileInput.close();

	#Method that looks up the line to check if it contains a translatable string.
	def lookup(line):
	signs = 0
	#Check for a '=' sign.
	for c in line:
	if c == '=':
	signs += 1
	if signs > 1:
	print "WARNING: Multiple '=' signs, using first one."
	if signs > 0:
	key = line.split( "=" )[0].rstrip('\r\n"').lstrip('"').strip()
	value = line.split( "=" )[1]

	#Check if the key is a translatable one.
	if key in ['congratulations', 'description', 'name', 'message']:
	#writeEntry('#: ' + curfile + ':' + str(curline), value)
	dictionary[value].append('#: ' + curfile + ':' + str(curline))

	#Method that will write the header.
	def writeHeader():
	potFile.write('# SOME DESCRIPTIVE TITLE.\n')
	potFile.write('# Copyright (C) YEAR THE PACKAGE\'S COPYRIGHT HOLDER\n')
	potFile.write('# This file is distributed under the same license as the PACKAGE package.\n')
	potFile.write('# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.\n')
	potFile.write('#\n')
	potFile.write('#, fuzzy\n')
	potFile.write('msgid ""\n')
	potFile.write('msgstr ""\n')
	potFile.write('"Project-Id-Version: PACKAGE VERSION\\n"\n')
	potFile.write('"Report-Msgid-Bugs-To: \\n"\n')
	potFile.write('"POT-Creation-Date: 2012-04-01 17:56+0300\\n"\n')
	potFile.write('"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"\n')
	potFile.write('"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"\n')
	potFile.write('"Language-Team: LANGUAGE <LL@li.org>\\n"\n')
	potFile.write('"Language: \\n"\n')
	potFile.write('"MIME-Version: 1.0\\n"\n')
	- potFile.write('"Content-Type: text/plain; charset=CHARSET\\n"\n')
	+ potFile.write('"Content-Type: text/plain; charset=UTF-8\\n"\n')
	potFile.write('"Content-Transfer-Encoding: 8bit\\n"\n')
	potFile.write('\n')

	#Method that performs the actual writing.
	def writeEntries():
	for msgid, comments in dictionary.iteritems():
	#Remove any trailing or leading '"' or '/n'
	msgid = msgid.rstrip('\r\n"').lstrip('"')

	#Write it to the file.
	for comment in comments:
	potFile.write(comment)
	potFile.write('\n')
	potFile.write('msgid "' + msgid + '"\n')
	potFile.write('msgstr ""\n')
	potFile.write('\n')


	#First check command line arguments.
	if len(sys.argv) != 2:
	print "Usage: python ./extract_pot.py <path/to/levelpack/>"
	sys.exit(0)

	#Set the levelpack path
	levelpackPath = sys.argv[1]

	#Gather the translatable strings.
	loopfiles()

	#Now create the pot file and fill it.
	openPotFile()
	writeHeader()
	writeEntries()
	diff --git a/tools/messages.pot.sh b/tools/messages.pot.sh
	index d96173b..78a5512 100644
	--- a/tools/messages.pot.sh
	+++ b/tools/messages.pot.sh
	@@ -1,43 +1,44 @@
	#!/bin/bash

	# Copyright (C) 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/>.

	#variables
	output="../data/locale/messages.pot"
	version="0.5svn"

	#automatically get all string from source code
	xgettext -o ${output} -c" /" -k_ -k__ --package-name=meandmyshadow --package-version=${version} ../src/*.cpp

	#little hack to get tranlator comments work
	-sed -i 's/#. \/ /# /g' ${output}
	+#also fix the charset problem
	+sed -i 's/#. \/ /# /g; s/charset=CHARSET/charset=UTF-8/g' ${output}
	echo >> ${output}

	#make SDL key names translatable
	#NOTE: this may generate invalid pot file since some names (e.g. Delete) are already defined
	-keys=("Return" "Escape" "Backspace" "Tab" "Space" "CapsLock" "PrintScreen" "ScrollLock"
	-"Pause" "Insert" "Home" "PageUp" "Delete" "End" "PageDown" "Right" "Left" "Down" "Up" "Numlock"
	-"SysReq" "Left Ctrl" "Left Shift" "Left Alt" "Left GUI" "Right Ctrl" "Right Shift" "Right Alt"
	-"Right GUI")
	+keys=("RETURN" "ESCAPE" "BACKSPACE" "TAB" "SPACE" "CAPSLOCK" "PRINTSCREEN" "SCROLLLOCK"
	+"PAUSE" "INSERT" "HOME" "PAGEUP" "DELETE" "END" "PAGEDOWN" "RIGHT" "LEFT" "DOWN" "UP" "NUMLOCK"
	+"SYSREQ" "LEFT CTRL" "LEFT SHIFT" "LEFT ALT" "LEFT GUI" "RIGHT CTRL" "RIGHT SHIFT" "RIGHT ALT"
	+"RIGHT GUI")
	for i in ${!keys[*]}; do
	echo "# TRANSLATORS: name of a key" >> ${output}
	echo "msgctxt \"keys\"" >> ${output}
	echo "msgid \"${keys[$i]}\"" >> ${output}
	echo "msgstr \"\"" >> ${output}
	echo >> ${output}
	done

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 13, 8:08 PM (2 d, 14 h ago)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 7c/2f/172049648f1435ac74dfeb6d3ebc
Default Alt Text: (1 MB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions