Merge remote branch 'origin/master'

259 files changed, 16737 insertions, 1471 deletions

diff --git a/.gitignore b/.gitignore
index ee210c7c0..353032637 100644
--- a/.gitignore
+++ b/.gitignore
@@ -36,6 +36,12 @@ src/jthread/cmake_install.cmake
 src/jthread/libjthread.a
 src/lua/build/
 src/lua/CMakeFiles/
+src/cguittfont/CMakeFiles/
+src/cguittfont/libcguittfont.a
+src/cguittfont/cmake_install.cmake
+src/cguittfont/Makefile
+src/json/CMakeFiles/
+src/json/libjson.a
 CMakeCache.txt
 CPackConfig.cmake
 CPackSourceConfig.cmake
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fdb0347b7..fbf46d059 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -148,6 +148,8 @@ if(RUN_IN_PLACE)
 	install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/textures/all/textures_here.txt" DESTINATION "${SHAREDIR}/textures/all")
 endif()
 
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/fonts" DESTINATION "${SHAREDIR}")
+
 install(FILES "README.txt" DESTINATION "${DOCDIR}")
 install(FILES "doc/lua_api.txt" DESTINATION "${DOCDIR}")
 install(FILES "doc/mapformat.txt" DESTINATION "${DOCDIR}")
diff --git a/README.txt b/README.txt
index 8c5a46223..20917d772 100644
--- a/README.txt
+++ b/README.txt
@@ -3,23 +3,23 @@ Minetest
 
 An InfiniMiner/Minecraft inspired game.
 
-Copyright (c) 2010-2012 Perttu Ahola <celeron55@gmail.com>
-and ther contributors (see source file comments and the version control log)
+Copyright (c) 2010-2013 Perttu Ahola <celeron55@gmail.com>
+and contributors (see source file comments and the version control log)
 
 In case you downloaded the source code:
 ---------------------------------------
 If you downloaded the Minetest Engine source code in which this file is
 contained, you probably want to download the minetest_game project too:
-  https://github.com/celeron55/minetest_game/
+  https://github.com/minetest/minetest_game/
 See the README.txt in it.
 
 Further documentation
 ----------------------
 - Website: http://minetest.net/
 - Wiki: http://wiki.minetest.com/
-- Developer wiki: http://minetest.net/wiki/
-- Forum: http://minetest.net/forum/
-- Github: https://github.com/celeron55/minetest/
+- Developer wiki: http://dev.minetest.net/
+- Forum: http://forum.minetest.net/
+- Github: https://github.com/minetest/minetest/
 - doc/ directory of source distribution
 
 This game is not finished
@@ -41,7 +41,7 @@ Default Controls
 Paths
 ------
 $bin   - Compiled binaries
-$share - Cistributed read-only data
+$share - Distributed read-only data
 $user  - User-created modifiable data
 
 Windows .zip / RUN_IN_PLACE source:
@@ -83,15 +83,15 @@ Install dependencies. Here's an example for Debian/Ubuntu:
 $ apt-get install build-essential libirrlicht-dev cmake libbz2-dev libpng12-dev libjpeg8-dev libxxf86vm-dev libgl1-mesa-dev libsqlite3-dev libogg-dev libvorbis-dev libopenal-dev
 
 Download source, extract (this is the URL to the latest of source repository, which might not work at all times):
-$ wget https://github.com/celeron55/minetest/tarball/master -O master.tar.gz
+$ wget https://github.com/minetest/minetest/tarball/master -O master.tar.gz
 $ tar xf master.tar.gz
-$ cd celeron55-minetest-286edd4 (or similar)
+$ cd minetest-minetest-286edd4 (or similar)
 
 Download minetest_game (otherwise only the "Minimal development test" game is available)
 $ cd games/
-$ wget https://github.com/celeron55/minetest_game/tarball/master -O master.tar.gz
+$ wget https://github.com/minetest/minetest_game/tarball/master -O master.tar.gz
 $ tar xf master.tar.gz
-$ mv celeron55-minetest_game-* minetest_game
+$ mv minetest-minetest_game-* minetest_game
 $ cd ..
 
 Build a version that runs directly from the source directory:
@@ -126,7 +126,7 @@ Compiling on Windows:
 		http://www.winimage.com/zLibDll/index.html
 	* Zlib library (zlibwapi.lib and zlibwapi.dll from zlib125dll.zip):
 		http://www.winimage.com/zLibDll/index.html
-	* Optional: gettext bibrary and tools:
+	* Optional: gettext library and tools:
 		http://gnuwin32.sourceforge.net/downlinks/gettext.php
 		- This is used for other UI languages. Feel free to leave it out.
 	* And, of course, Minetest:
@@ -258,7 +258,7 @@ License of Minetest source code
 -------------------------------
 
 Minetest
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -372,4 +372,8 @@ DejaVu Sans Mono:
 
   Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved.
 
+  Liberation Fonts Copyright:
+
+  Copyright (c) 2007 Red Hat, Inc. All rights reserved. LIBERATION is a trademark of Red Hat, Inc.
+
 
diff --git a/builtin/builtin.lua b/builtin/builtin.lua
index f2811fa9c..bf33cbe6b 100644
--- a/builtin/builtin.lua
+++ b/builtin/builtin.lua
@@ -8,6 +8,7 @@
 -- Initialize some very basic things
 print = minetest.debug
 math.randomseed(os.time())
+os.setlocale("C", "numeric")
 
 -- Load other files
 dofile(minetest.get_modpath("__builtin").."/serialize.lua")
diff --git a/builtin/item.lua b/builtin/item.lua
index a28798d4d..1349fdf63 100644
--- a/builtin/item.lua
+++ b/builtin/item.lua
@@ -141,7 +141,7 @@ function minetest.item_place_node(itemstack, placer, pointed_thing)
 		minetest.log("info", placer:get_player_name() .. " tried to place"
 			.. " node in invalid position " .. minetest.pos_to_string(above)
 			.. ", replacing " .. oldnode_above.name)
-		return
+		return itemstack
 	end
 
 	-- Place above pointed node
@@ -186,7 +186,7 @@ function minetest.item_place_node(itemstack, placer, pointed_thing)
 		not check_attached_node(place_to, newnode) then
 		minetest.log("action", "attached node " .. def.name ..
 			" can not be placed at " .. minetest.pos_to_string(place_to))
-		return
+		return itemstack
 	end
 
 	-- Add node and update
@@ -237,16 +237,14 @@ function minetest.item_place(itemstack, placer, pointed_thing)
 		local n = minetest.env:get_node(pointed_thing.under)
 		local nn = n.name
 		if minetest.registered_nodes[nn] and minetest.registered_nodes[nn].on_rightclick then
-			minetest.registered_nodes[nn].on_rightclick(pointed_thing.under, n, placer)
-			return
+			return minetest.registered_nodes[nn].on_rightclick(pointed_thing.under, n, placer, itemstack)
 		end
 	end
 
 	if itemstack:get_definition().type == "node" then
 		return minetest.item_place_node(itemstack, placer, pointed_thing)
-	elseif itemstack:get_definition().type ~= "none" then
-		return minetest.item_place_object(itemstack, placer, pointed_thing)
 	end
+	return itemstack
 end
 
 function minetest.item_drop(itemstack, dropper, pos)
@@ -263,7 +261,7 @@ function minetest.item_drop(itemstack, dropper, pos)
 	else
 		minetest.env:add_item(pos, itemstack)
 	end
-	return ""
+	return ItemStack("")
 end
 
 function minetest.item_eat(hp_change, replace_with_item)
@@ -292,7 +290,15 @@ function minetest.handle_node_drops(pos, drops, digger)
 	if digger:get_inventory() then
 		local _, dropped_item
 		for _, dropped_item in ipairs(drops) do
-			digger:get_inventory():add_item("main", dropped_item)
+			local left = digger:get_inventory():add_item("main", dropped_item)
+			if not left:is_empty() then
+				local p = {
+					x = pos.x + math.random()/2-0.25,
+					y = pos.y + math.random()/2-0.25,
+					z = pos.z + math.random()/2-0.25,
+				}
+				minetest.env:add_item(p, left)
+			end
 		end
 	end
 end
diff --git a/builtin/item_entity.lua b/builtin/item_entity.lua
index 46415e538..1699cb03c 100644
--- a/builtin/item_entity.lua
+++ b/builtin/item_entity.lua
@@ -109,7 +109,10 @@ minetest.register_entity("__builtin:item", {
 
 	on_punch = function(self, hitter)
 		if self.itemstring ~= '' then
-			hitter:get_inventory():add_item("main", self.itemstring)
+			local left = hitter:get_inventory():add_item("main", self.itemstring)
+			if not left:is_empty() then
+				return
+			end
 		end
 		self.object:remove()
 	end,
diff --git a/cmake/Modules/FindJson.cmake b/cmake/Modules/FindJson.cmake
new file mode 100644
index 000000000..bc4e71a29
--- /dev/null
+++ b/cmake/Modules/FindJson.cmake
@@ -0,0 +1,18 @@
+# Look for json, use our own if not found
+
+#FIND_PATH(JSON_INCLUDE_DIR json.h)
+
+#FIND_LIBRARY(JSON_LIBRARY NAMES json)
+
+#IF(JSON_LIBRARY AND JSON_INCLUDE_DIR)
+#	SET( JSON_FOUND TRUE )
+#ENDIF(JSON_LIBRARY AND JSON_INCLUDE_DIR)
+
+#IF(JSON_FOUND)
+#	MESSAGE(STATUS "Found system json header file in ${JSON_INCLUDE_DIR}")
+#	MESSAGE(STATUS "Found system json library ${JSON_LIBRARY}")
+#ELSE(JSON_FOUND)
+	SET(JSON_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/json)
+	SET(JSON_LIBRARY json)
+	MESSAGE(STATUS "Using project json library")
+#ENDIF(JSON_FOUND)
diff --git a/doc/lua_api.txt b/doc/lua_api.txt
index 7ba2ed001..005d7c010 100644
--- a/doc/lua_api.txt
+++ b/doc/lua_api.txt
@@ -1093,6 +1093,7 @@ treedef={
   thin_branches, - boolean true -> use thin (1 node) branches
   fruit,         - string  fruit node name
   fruit_chance,  - num     chance (0-100) to replace leaves with fruit node
+  seed,          - num     random seed
   }
 
 Key for Special L-System Symbols used in Axioms
@@ -1497,8 +1498,10 @@ Node definition (register_node)
     on_punch = func(pos, node, puncher),
     ^ default: minetest.node_punch
     ^ By default: does nothing
-    on_rightclick = func(pos, node, clicker),
+    on_rightclick = func(pos, node, clicker, itemstack),
     ^ default: nil
+    ^ if defined, itemstack will hold clicker's wielded item
+      Shall return the leftover itemstack
     on_dig = func(pos, node, digger),
     ^ default: minetest.node_dig
     ^ By default: checks privileges, wears out tool and removes node
diff --git a/doc/protocol.txt b/doc/protocol.txt
index 82dca59bf..160f15226 100644
--- a/doc/protocol.txt
+++ b/doc/protocol.txt
@@ -1,4 +1,4 @@
-Minetest-c55 protocol (incomplete, early draft):
+Minetest protocol (incomplete, early draft):
 Updated 2011-06-18
 
 A custom protocol over UDP.
diff --git a/fonts/liberationmono.ttf b/fonts/liberationmono.ttf
new file mode 100644
index 000000000..7260bd65e
--- /dev/null
+++ b/fonts/liberationmono.ttf
diff --git a/fonts/liberationsans.ttf b/fonts/liberationsans.ttf
new file mode 100644
index 000000000..59d2e251b
--- /dev/null
+++ b/fonts/liberationsans.ttf
diff --git a/games/minimal/mods/default/mapgen.lua b/games/minimal/mods/default/mapgen.lua
index af94505a0..115bb1458 100644
--- a/games/minimal/mods/default/mapgen.lua
+++ b/games/minimal/mods/default/mapgen.lua
@@ -27,7 +27,7 @@ minetest.register_alias("mapgen_mese", "default:mese")
 -- Ore generation
 --
 
-local function generate_ore(name, wherein, minp, maxp, seed, chunks_per_volume, ore_per_chunk, height_min, height_max)
+local function generate_ore(name, wherein, minp, maxp, seed, chunks_per_volume, ore_per_chunk, height_min, height_max, param2)
 	if maxp.y < height_min or minp.y > height_max then
 		return
 	end
@@ -57,7 +57,7 @@ local function generate_ore(name, wherein, minp, maxp, seed, chunks_per_volume,
 					local z2 = z0+z1
 					local p2 = {x=x2, y=y2, z=z2}
 					if minetest.env:get_node(p2).name == wherein then
-						minetest.env:set_node(p2, {name=name})
+						minetest.env:set_node(p2, {name=name, param2=param2})
 					end
 				end
 			end
@@ -110,5 +110,11 @@ minetest.register_on_generated(function(minp, maxp, seed)
 		end
 		end
 	end
+	if minetest.setting_get("liquid_finite") then
+		generate_ore("default:water_source", "default:stone", minp, maxp, seed+42, 1/24/24/24, 4,  -100,   -10,  128)
+		generate_ore("default:water_source", "default:stone", minp, maxp, seed+42, 1/28/28/28, 3,  -10000, -101, 128)
+		generate_ore("default:lava_source",  "default:stone", minp, maxp, seed+43, 1/38/38/38, 2,  -500,   -100, 128)
+		generate_ore("default:lava_source",  "default:stone", minp, maxp, seed+43, 1/30/30/30, 4,  -31000, -501, 128)
+	end
 end)
 
diff --git a/minetest.conf.example b/minetest.conf.example
index 49fc95ba2..8e95d7e60 100644
--- a/minetest.conf.example
+++ b/minetest.conf.example
@@ -90,6 +90,14 @@
 #enable_fog = true
 # Enable a bit lower water surface; disable for speed (not quite optimized)
 #new_style_water = false
+# Constant volume liquids
+#liquid_finite = false
+# Update liquids every .. recommend for finite: 0.2
+#liquid_update = 1.0
+# When finite liquid: relax flowing blocks to source if level near max and N nearby source blocks, more realistic, but not true constant. values: 0,1,2,3,4 : 0 - disable, 1 - most aggresive
+#liquid_relax = 1
+# optimization: faster cave flood (and not true constant)
+#liquid_fast_flood = 1
 # Enable nice leaves; disable for speed
 #new_style_leaves = true
 # Enable smooth lighting with simple ambient occlusion;
@@ -159,14 +167,29 @@
 #media_fetch_threads = 8
 
 # Url to the server list displayed in the Multiplayer Tab
-#serverlist_url = servers.minetest.ru/server.list
+#serverlist_url = servers.minetest.net
 # File in client/serverlist/ that contains your favorite servers displayed in the Multiplayer Tab
 #serverlist_file = favoriteservers.txt
 
+#font_path = fonts/liberationsans.ttf
+#font_size = 13
+#mono_font_path = fonts/liberationmono.ttf
+#mono_font_size = 13
+
 #
 # Server stuff
 #
 
+# Name of server
+#server_name = Minetest server
+# Description of server
+#server_description = mine here
+# Domain name of server
+#server_address = game.minetest.net
+# Homepage of server
+#server_url = http://minetest.net
+# Automaticaly report to masterserver
+#server_announce = 0
 # Default game (default when creating a new world)
 #default_game = minetest
 # World directory (everything in the world is stored here)
@@ -245,6 +268,21 @@
 # Files that are not present would be fetched the usual way
 #remote_media =
 
+# Physics stuff
+#movement_acceleration_default = 3
+#movement_acceleration_air = 2
+#movement_acceleration_fast = 10
+#movement_speed_walk = 4
+#movement_speed_crouch = 1.35
+#movement_speed_fast = 20
+#movement_speed_climb = 2
+#movement_speed_jump = 6.5
+#movement_speed_descend = 6
+#movement_liquid_fluidity = 1
+#movement_liquid_fluidity_smooth = 0.5
+#movement_liquid_sink = 10
+#movement_gravity = 9.81
+
 # Mapgen stuff
 #mg_name = v6
 #water_level = 1
diff --git a/old/changelog.txt b/old/changelog.txt
index b27fc506b..1750d71d1 100644
--- a/old/changelog.txt
+++ b/old/changelog.txt
@@ -1,4 +1,4 @@
-Minetest-c55 changelog
+Minetest changelog
 ----------------------
 This should contain all the major changes.
 For minor stuff, refer to the commit log of the repository.
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 8d0363548..d2f080c90 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -5,6 +5,7 @@ cmake_minimum_required( VERSION 2.6 )
 mark_as_advanced(EXECUTABLE_OUTPUT_PATH LIBRARY_OUTPUT_PATH)
 mark_as_advanced(JTHREAD_INCLUDE_DIR JTHREAD_LIBRARY)
 mark_as_advanced(SQLITE3_INCLUDE_DIR SQLITE3_LIBRARY)
+mark_as_advanced(JSON_INCLUDE_DIR JSON_LIBRARY)
 
 option(ENABLE_CURL "Enable cURL support for fetching media" 1)
 
@@ -93,6 +94,12 @@ if(USE_SOUND)
 		)
 endif()
 
+option(ENABLE_FREETYPE "Enable freetype2 (truetype fonts and basic unicode support)" OFF)
+set(USE_FREETYPE 0)
+if(ENABLE_FREETYPE)
+	set(USE_FREETYPE 1)
+endif(ENABLE_FREETYPE)
+
 if(NOT MSVC)
 	set(USE_GPROF 0 CACHE BOOL "Use -pg flag for g++")
 endif()
@@ -117,6 +124,14 @@ if(WIN32)
 			CACHE FILEPATH "Path to zlibwapi.dll (for installation)")
 	set(IRRLICHT_SOURCE_DIR "${PROJECT_SOURCE_DIR}/../../irrlicht-1.7.2"
 			CACHE PATH "irrlicht dir")
+	if(USE_FREETYPE)
+		set(FREETYPE_INCLUDE_DIR_ft2build "${PROJECT_SOURCE_DIR}/../../freetype2/include/"
+				CACHE PATH "freetype include dir")
+		set(FREETYPE_INCLUDE_DIR_freetype2 "${PROJECT_SOURCE_DIR}/../../freetype2/include/freetype"
+				CACHE PATH "freetype include dir")
+		set(FREETYPE_LIBRARY "${PROJECT_SOURCE_DIR}/../../freetype2/objs/win32/vc2005/freetype247.lib"
+				CACHE FILEPATH "Path to freetype247.lib")
+	endif(USE_FREETYPE)
 	set(MINGWM10_DLL ""
 			CACHE FILEPATH "Path to mingwm10.dll (for installation)")
 	if(ENABLE_SOUND)
@@ -156,6 +171,13 @@ endif()
 
 find_package(Jthread REQUIRED)
 find_package(Sqlite3 REQUIRED)
+find_package(Json REQUIRED)
+
+if(USE_FREETYPE)
+	find_package(Freetype REQUIRED)
+	set(CGUITTFONT_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/cguittfont")
+	set(CGUITTFONT_LIBRARY cguittfont)
+endif(USE_FREETYPE)
 
 # Do not use system-wide installation of Lua, because it'll likely be a
 # different version and/or has different build options.
@@ -187,6 +209,7 @@ set(common_SRCS
 	script.cpp
 	log.cpp
 	content_sao.cpp
+	emerge.cpp
 	mapgen.cpp
 	mapgen_v6.cpp
 	treegen.cpp
@@ -222,6 +245,7 @@ set(common_SRCS
 	biome.cpp
 	clientserver.cpp
 	staticobject.cpp
+	serverlist.cpp
 	util/serialize.cpp
 	util/directiontables.cpp
 	util/numeric.cpp
@@ -274,6 +298,7 @@ set(minetest_SRCS
 	guiFormSpecMenu.cpp
 	guiPauseMenu.cpp
 	guiPasswordChange.cpp
+	guiVolumeChange.cpp
 	guiDeathScreen.cpp
 	guiChatConsole.cpp
 	guiCreateWorld.cpp
@@ -283,11 +308,17 @@ set(minetest_SRCS
 	filecache.cpp
 	tile.cpp
 	shader.cpp
-	serverlist.cpp
 	game.cpp
 	main.cpp
 )
 
+if(USE_FREETYPE)
+	set(minetest_SRCS
+		${minetest_SRCS}
+		intlGUIEditBox.cpp
+	)
+endif(USE_FREETYPE)
+
 # Server sources
 set(minetestserver_SRCS
 	${common_SRCS}
@@ -305,8 +336,22 @@ include_directories(
 	${JTHREAD_INCLUDE_DIR}
 	${SQLITE3_INCLUDE_DIR}
 	${LUA_INCLUDE_DIR}
+	${JSON_INCLUDE_DIR}
 )
 
+if(USE_FREETYPE)
+	include_directories(
+		${FREETYPE_INCLUDE_DIRS}
+		${CGUITTFONT_INCLUDE_DIR}
+	)
+endif(USE_FREETYPE)
+
+if(USE_CURL)
+	include_directories(
+		${CURL_INCLUDE_DIR}
+	)
+endif(USE_CURL)
+
 set(EXECUTABLE_OUTPUT_PATH "${CMAKE_SOURCE_DIR}/bin")
 
 if(BUILD_CLIENT)
@@ -325,19 +370,23 @@ if(BUILD_CLIENT)
 		${JTHREAD_LIBRARY}
 		${SQLITE3_LIBRARY}
 		${LUA_LIBRARY}
+		${JSON_LIBRARY}
 		${PLATFORM_LIBS}
 		${CLIENT_PLATFORM_LIBS}
 	)
-
 	if(USE_CURL)
 		target_link_libraries(
 			${PROJECT_NAME}
 			${CURL_LIBRARY}
 		)
-		include_directories(
-			${CURL_INCLUDE_DIR}
-		)
 	endif(USE_CURL)
+	if(USE_FREETYPE)
+		target_link_libraries(
+			${PROJECT_NAME}
+			${FREETYPE_LIBRARY}
+			${CGUITTFONT_LIBRARY}
+		)
+	endif(USE_FREETYPE)
 endif(BUILD_CLIENT)
 
 if(BUILD_SERVER)
@@ -347,11 +396,20 @@ if(BUILD_SERVER)
 		${ZLIB_LIBRARIES}
 		${JTHREAD_LIBRARY}
 		${SQLITE3_LIBRARY}
+		${JSON_LIBRARY}
+		${GETTEXT_LIBRARY}
 		${LUA_LIBRARY}
 		${PLATFORM_LIBS}
 	)
+	if(USE_CURL)
+		target_link_libraries(
+			${PROJECT_NAME}server
+			${CURL_LIBRARY}
+		)
+	endif(USE_CURL)
 endif(BUILD_SERVER)
 
+
 #
 # Set some optimizations and tweaks
 #
@@ -518,9 +576,18 @@ else (SQLITE3_FOUND)
 	add_subdirectory(sqlite)
 endif (SQLITE3_FOUND)
 
+if (BUILD_CLIENT AND USE_FREETYPE)
+	add_subdirectory(cguittfont)
+endif (BUILD_CLIENT AND USE_FREETYPE)
+
 if (LUA_FOUND)
 else (LUA_FOUND)
 	add_subdirectory(lua)
 endif (LUA_FOUND)
 
+if (JSON_FOUND)
+else (JSON_FOUND)
+	add_subdirectory(json)
+endif (JSON_FOUND)
+
 #end
diff --git a/src/activeobject.h b/src/activeobject.h
index 1108a19de..e454f2c8c 100644
--- a/src/activeobject.h
+++ b/src/activeobject.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/ban.cpp b/src/ban.cpp
index e080586a3..75bae746f 100644
--- a/src/ban.cpp
+++ b/src/ban.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/ban.h b/src/ban.h
index f5b9c4440..529635c26 100644
--- a/src/ban.h
+++ b/src/ban.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/base64.h b/src/base64.h
index 5f2d6743d..1cb175518 100644
--- a/src/base64.h
+++ b/src/base64.h
@@ -7,4 +7,4 @@ bool base64_is_valid(std::string const& s);
 std::string base64_encode(unsigned char const* , unsigned int len);
 std::string base64_decode(std::string const& s);
 
-#endif // BASE64_HEADER
\ No newline at end of file
+#endif // BASE64_HEADER
diff --git a/src/biome.cpp b/src/biome.cpp
index 34d51839f..86af75310 100644
--- a/src/biome.cpp
+++ b/src/biome.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 kwolekr, Ryan Kwolek <kwolekr2@cs.scranton.edu>
+Minetest
+Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr2@cs.scranton.edu>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/biome.h b/src/biome.h
index 265f1df44..c30af46ad 100644
--- a/src/biome.h
+++ b/src/biome.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 kwolekr, Ryan Kwolek <kwolekr2@cs.scranton.edu>
+Minetest
+Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr2@cs.scranton.edu>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/camera.cpp b/src/camera.cpp
index 33e85d069..b1e588415 100644
--- a/src/camera.cpp
+++ b/src/camera.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/camera.h b/src/camera.h
index 642b8d2d0..fc43d1176 100644
--- a/src/camera.h
+++ b/src/camera.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/cguittfont/CGUITTFont.cpp b/src/cguittfont/CGUITTFont.cpp
new file mode 100644
index 000000000..fb8199e21
--- /dev/null
+++ b/src/cguittfont/CGUITTFont.cpp
@@ -0,0 +1,1146 @@
+/*
+   CGUITTFont FreeType class for Irrlicht
+   Copyright (c) 2009-2010 John Norman
+
+   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.
+
+   The original version of this class can be located at:
+   http://irrlicht.suckerfreegames.com/
+
+   John Norman
+   john@suckerfreegames.com
+*/
+
+#include <irrlicht.h>
+#include "CGUITTFont.h"
+
+namespace irr
+{
+namespace gui
+{
+
+// Manages the FT_Face cache.
+struct SGUITTFace : public virtual irr::IReferenceCounted
+{
+	SGUITTFace() : face_buffer(0), face_buffer_size(0)
+	{
+		memset((void*)&face, 0, sizeof(FT_Face));
+	}
+
+	~SGUITTFace()
+	{
+		FT_Done_Face(face);
+		delete[] face_buffer;
+	}
+
+	FT_Face face;
+	FT_Byte* face_buffer;
+	FT_Long face_buffer_size;
+};
+
+// Static variables.
+FT_Library CGUITTFont::c_library;
+core::map<io::path, SGUITTFace*> CGUITTFont::c_faces;
+bool CGUITTFont::c_libraryLoaded = false;
+scene::IMesh* CGUITTFont::shared_plane_ptr_ = 0;
+scene::SMesh CGUITTFont::shared_plane_;
+
+//
+
+video::IImage* SGUITTGlyph::createGlyphImage(const FT_Bitmap& bits, video::IVideoDriver* driver) const
+{
+	// Determine what our texture size should be.
+	// Add 1 because textures are inclusive-exclusive.
+	core::dimension2du d(bits.width + 1, bits.rows + 1);
+	core::dimension2du texture_size;
+	//core::dimension2du texture_size(bits.width + 1, bits.rows + 1);
+
+	// Create and load our image now.
+	video::IImage* image = 0;
+	switch (bits.pixel_mode)
+	{
+		case FT_PIXEL_MODE_MONO:
+		{
+			// Create a blank image and fill it with transparent pixels.
+			texture_size = d.getOptimalSize(true, true);
+			image = driver->createImage(video::ECF_A1R5G5B5, texture_size);
+			image->fill(video::SColor(0, 255, 255, 255));
+
+			// Load the monochrome data in.
+			const u32 image_pitch = image->getPitch() / sizeof(u16);
+			u16* image_data = (u16*)image->lock();
+			u8* glyph_data = bits.buffer;
+			for (s32 y = 0; y < bits.rows; ++y)
+			{
+				u16* row = image_data;
+				for (s32 x = 0; x < bits.width; ++x)
+				{
+					// Monochrome bitmaps store 8 pixels per byte.  The left-most pixel is the bit 0x80.
+					// So, we go through the data each bit at a time.
+					if ((glyph_data[y * bits.pitch + (x / 8)] & (0x80 >> (x % 8))) != 0)
+						*row = 0xFFFF;
+					++row;
+				}
+				image_data += image_pitch;
+			}
+			image->unlock();
+			break;
+		}
+
+		case FT_PIXEL_MODE_GRAY:
+		{
+			// Create our blank image.
+			texture_size = d.getOptimalSize(!driver->queryFeature(video::EVDF_TEXTURE_NPOT), !driver->queryFeature(video::EVDF_TEXTURE_NSQUARE), true, 0);
+			image = driver->createImage(video::ECF_A8R8G8B8, texture_size);
+			image->fill(video::SColor(0, 255, 255, 255));
+
+			// Load the grayscale data in.
+			const float gray_count = static_cast<float>(bits.num_grays);
+			const u32 image_pitch = image->getPitch() / sizeof(u32);
+			u32* image_data = (u32*)image->lock();
+			u8* glyph_data = bits.buffer;
+			for (s32 y = 0; y < bits.rows; ++y)
+			{
+				u8* row = glyph_data;
+				for (s32 x = 0; x < bits.width; ++x)
+				{
+					image_data[y * image_pitch + x] |= static_cast<u32>(255.0f * (static_cast<float>(*row++) / gray_count)) << 24;
+					//data[y * image_pitch + x] |= ((u32)(*bitsdata++) << 24);
+				}
+				glyph_data += bits.pitch;
+			}
+			image->unlock();
+			break;
+		}
+		default:
+			// TODO: error message?
+			return 0;
+	}
+	return image;
+}
+
+void SGUITTGlyph::preload(u32 char_index, FT_Face face, video::IVideoDriver* driver, u32 font_size, const FT_Int32 loadFlags)
+{
+	if (isLoaded) return;
+
+	// Set the size of the glyph.
+	FT_Set_Pixel_Sizes(face, 0, font_size);
+
+	// Attempt to load the glyph.
+	if (FT_Load_Glyph(face, char_index, loadFlags) != FT_Err_Ok)
+		// TODO: error message?
+		return;
+
+	FT_GlyphSlot glyph = face->glyph;
+	FT_Bitmap bits = glyph->bitmap;
+
+	// Setup the glyph information here:
+	advance = glyph->advance;
+	offset = core::vector2di(glyph->bitmap_left, glyph->bitmap_top);
+
+	// Try to get the last page with available slots.
+	CGUITTGlyphPage* page = parent->getLastGlyphPage();
+
+	// If we need to make a new page, do that now.
+	if (!page)
+	{
+		page = parent->createGlyphPage(bits.pixel_mode);
+		if (!page)
+			// TODO: add error message?
+			return;
+	}
+
+	glyph_page = parent->getLastGlyphPageIndex();
+	u32 texture_side_length = page->texture->getOriginalSize().Width;
+	core::vector2di page_position(
+		(page->used_slots % (texture_side_length / font_size)) * font_size,
+		(page->used_slots / (texture_side_length / font_size)) * font_size
+		);
+	source_rect.UpperLeftCorner = page_position;
+	source_rect.LowerRightCorner = core::vector2di(page_position.X + bits.width, page_position.Y + bits.rows);
+
+	page->dirty = true;
+	++page->used_slots;
+	--page->available_slots;
+
+	// We grab the glyph bitmap here so the data won't be removed when the next glyph is loaded.
+	surface = createGlyphImage(bits, driver);
+
+	// Set our glyph as loaded.
+	isLoaded = true;
+}
+
+void SGUITTGlyph::unload()
+{
+	if (surface)
+	{
+		surface->drop();
+		surface = 0;
+	}
+	isLoaded = false;
+}
+
+//////////////////////
+
+CGUITTFont* CGUITTFont::createTTFont(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias, const bool transparency)
+{
+	if (!c_libraryLoaded)
+	{
+		if (FT_Init_FreeType(&c_library))
+			return 0;
+		c_libraryLoaded = true;
+	}
+
+	CGUITTFont* font = new CGUITTFont(env);
+	bool ret = font->load(filename, size, antialias, transparency);
+	if (!ret)
+	{
+		font->drop();
+		return 0;
+	}
+
+	return font;
+}
+
+CGUITTFont* CGUITTFont::createTTFont(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias, const bool transparency)
+{
+	if (!c_libraryLoaded)
+	{
+		if (FT_Init_FreeType(&c_library))
+			return 0;
+		c_libraryLoaded = true;
+	}
+
+	CGUITTFont* font = new CGUITTFont(device->getGUIEnvironment());
+	font->Device = device;
+	bool ret = font->load(filename, size, antialias, transparency);
+	if (!ret)
+	{
+		font->drop();
+		return 0;
+	}
+
+	return font;
+}
+
+CGUITTFont* CGUITTFont::create(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias, const bool transparency)
+{
+	return CGUITTFont::createTTFont(env, filename, size, antialias, transparency);
+}
+
+CGUITTFont* CGUITTFont::create(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias, const bool transparency)
+{
+	return CGUITTFont::createTTFont(device, filename, size, antialias, transparency);
+}
+
+//////////////////////
+
+//! Constructor.
+CGUITTFont::CGUITTFont(IGUIEnvironment *env)
+: use_monochrome(false), use_transparency(true), use_hinting(true), use_auto_hinting(true),
+batch_load_size(1), Device(0), Environment(env), Driver(0), GlobalKerningWidth(0), GlobalKerningHeight(0)
+{
+	#ifdef _DEBUG
+	setDebugName("CGUITTFont");
+	#endif
+
+	if (Environment)
+	{
+		// don't grab environment, to avoid circular references
+		Driver = Environment->getVideoDriver();
+	}
+
+	if (Driver)
+		Driver->grab();
+
+	setInvisibleCharacters(L" ");
+
+	// Glyphs aren't reference counted, so don't try to delete them when we free the array.
+	Glyphs.set_free_when_destroyed(false);
+}
+
+bool CGUITTFont::load(const io::path& filename, const u32 size, const bool antialias, const bool transparency)
+{
+	// Some sanity checks.
+	if (Environment == 0 || Driver == 0) return false;
+	if (size == 0) return false;
+	if (filename.size() == 0) return false;
+
+	io::IFileSystem* filesystem = Environment->getFileSystem();
+	irr::ILogger* logger = (Device != 0 ? Device->getLogger() : 0);
+	this->size = size;
+	this->filename = filename;
+
+	// Update the font loading flags when the font is first loaded.
+	this->use_monochrome = !antialias;
+	this->use_transparency = transparency;
+	update_load_flags();
+
+	// Log.
+	if (logger)
+		logger->log(L"CGUITTFont", core::stringw(core::stringw(L"Creating new font: ") + core::ustring(filename).toWCHAR_s() + L" " + core::stringc(size) + L"pt " + (antialias ? L"+antialias " : L"-antialias ") + (transparency ? L"+transparency" : L"-transparency")).c_str(), irr::ELL_INFORMATION);
+
+	// Grab the face.
+	SGUITTFace* face = 0;
+	core::map<io::path, SGUITTFace*>::Node* node = c_faces.find(filename);
+	if (node == 0)
+	{
+		face = new SGUITTFace();
+		c_faces.set(filename, face);
+
+		if (filesystem)
+		{
+			// Read in the file data.
+			io::IReadFile* file = filesystem->createAndOpenFile(filename);
+			if (file == 0)
+			{
+				if (logger) logger->log(L"CGUITTFont", L"Failed to open the file.", irr::ELL_INFORMATION);
+
+				c_faces.remove(filename);
+				delete face;
+				face = 0;
+				return false;
+			}
+			face->face_buffer = new FT_Byte[file->getSize()];
+			file->read(face->face_buffer, file->getSize());
+			face->face_buffer_size = file->getSize();
+			file->drop();
+
+			// Create the face.
+			if (FT_New_Memory_Face(c_library, face->face_buffer, face->face_buffer_size, 0, &face->face))
+			{
+				if (logger) logger->log(L"CGUITTFont", L"FT_New_Memory_Face failed.", irr::ELL_INFORMATION);
+
+				c_faces.remove(filename);
+				delete face;
+				face = 0;
+				return false;
+			}
+		}
+		else
+		{
+			core::ustring converter(filename);
+			if (FT_New_Face(c_library, reinterpret_cast<const char*>(converter.toUTF8_s().c_str()), 0, &face->face))
+			{
+				if (logger) logger->log(L"CGUITTFont", L"FT_New_Face failed.", irr::ELL_INFORMATION);
+
+				c_faces.remove(filename);
+				delete face;
+				face = 0;
+				return false;
+			}
+		}
+	}
+	else
+	{
+		// Using another instance of this face.
+		face = node->getValue();
+		face->grab();
+	}
+
+	// Store our face.
+	tt_face = face->face;
+
+	// Store font metrics.
+	FT_Set_Pixel_Sizes(tt_face, size, 0);
+	font_metrics = tt_face->size->metrics;
+
+	// Allocate our glyphs.
+	Glyphs.clear();
+	Glyphs.reallocate(tt_face->num_glyphs);
+	Glyphs.set_used(tt_face->num_glyphs);
+	for (FT_Long i = 0; i < tt_face->num_glyphs; ++i)
+	{
+		Glyphs[i].isLoaded = false;
+		Glyphs[i].glyph_page = 0;
+		Glyphs[i].source_rect = core::recti();
+		Glyphs[i].offset = core::vector2di();
+		Glyphs[i].advance = FT_Vector();
+		Glyphs[i].surface = 0;
+		Glyphs[i].parent = this;
+	}
+
+	// Cache the first 127 ascii characters.
+	u32 old_size = batch_load_size;
+	batch_load_size = 127;
+	getGlyphIndexByChar((uchar32_t)0);
+	batch_load_size = old_size;
+
+	return true;
+}
+
+CGUITTFont::~CGUITTFont()
+{
+	// Delete the glyphs and glyph pages.
+	reset_images();
+	CGUITTAssistDelete::Delete(Glyphs);
+	//Glyphs.clear();
+
+	// We aren't using this face anymore.
+	core::map<io::path, SGUITTFace*>::Node* n = c_faces.find(filename);
+	if (n)
+	{
+		SGUITTFace* f = n->getValue();
+
+		// Drop our face.  If this was the last face, the destructor will clean up.
+		if (f->drop())
+			c_faces.remove(filename);
+
+		// If there are no more faces referenced by FreeType, clean up.
+		if (c_faces.size() == 0)
+		{
+			FT_Done_FreeType(c_library);
+			c_libraryLoaded = false;
+		}
+	}
+
+	// Drop our driver now.
+	if (Driver)
+		Driver->drop();
+}
+
+void CGUITTFont::reset_images()
+{
+	// Delete the glyphs.
+	for (u32 i = 0; i != Glyphs.size(); ++i)
+		Glyphs[i].unload();
+
+	// Unload the glyph pages from video memory.
+	for (u32 i = 0; i != Glyph_Pages.size(); ++i)
+		delete Glyph_Pages[i];
+	Glyph_Pages.clear();
+
+	// Always update the internal FreeType loading flags after resetting.
+	update_load_flags();
+}
+
+void CGUITTFont::update_glyph_pages() const
+{
+	for (u32 i = 0; i != Glyph_Pages.size(); ++i)
+	{
+		if (Glyph_Pages[i]->dirty)
+			Glyph_Pages[i]->updateTexture();
+	}
+}
+
+CGUITTGlyphPage* CGUITTFont::getLastGlyphPage() const
+{
+	CGUITTGlyphPage* page = 0;
+	if (Glyph_Pages.empty())
+		return 0;
+	else
+	{
+		page = Glyph_Pages[getLastGlyphPageIndex()];
+		if (page->available_slots == 0)
+			page = 0;
+	}
+	return page;
+}
+
+CGUITTGlyphPage* CGUITTFont::createGlyphPage(const u8& pixel_mode)
+{
+	CGUITTGlyphPage* page = 0;
+	
+	// Name of our page.
+	io::path name("TTFontGlyphPage_");
+	name += tt_face->family_name;
+	name += ".";
+	name += tt_face->style_name;
+	name += ".";
+	name += size;
+	name += "_";
+	name += Glyph_Pages.size(); // The newly created page will be at the end of the collection.
+
+	// Create the new page.
+	page = new CGUITTGlyphPage(Driver, name);
+
+	// Determine our maximum texture size.
+	// If we keep getting 0, set it to 1024x1024, as that number is pretty safe.
+	core::dimension2du max_texture_size = max_page_texture_size;
+	if (max_texture_size.Width == 0 || max_texture_size.Height == 0)
+		max_texture_size = Driver->getMaxTextureSize();
+	if (max_texture_size.Width == 0 || max_texture_size.Height == 0)
+		max_texture_size = core::dimension2du(1024, 1024);
+
+	// We want to try to put at least 144 glyphs on a single texture.
+	core::dimension2du page_texture_size;
+	if (size <= 21) page_texture_size = core::dimension2du(256, 256);
+	else if (size <= 42) page_texture_size = core::dimension2du(512, 512);
+	else if (size <= 84) page_texture_size = core::dimension2du(1024, 1024);
+	else if (size <= 168) page_texture_size = core::dimension2du(2048, 2048);
+	else page_texture_size = core::dimension2du(4096, 4096);
+
+	if (page_texture_size.Width > max_texture_size.Width || page_texture_size.Height > max_texture_size.Height)
+		page_texture_size = max_texture_size;
+
+	if (!page->createPageTexture(pixel_mode, page_texture_size))
+		// TODO: add error message?
+		return 0;
+
+	if (page)
+	{
+		// Determine the number of glyph slots on the page and add it to the list of pages.
+		page->available_slots = (page_texture_size.Width / size) * (page_texture_size.Height / size);
+		Glyph_Pages.push_back(page);
+	}
+	return page;
+}
+
+void CGUITTFont::setTransparency(const bool flag)
+{
+	use_transparency = flag;
+	reset_images();
+}
+
+void CGUITTFont::setMonochrome(const bool flag)
+{
+	use_monochrome = flag;
+	reset_images();
+}
+
+void CGUITTFont::setFontHinting(const bool enable, const bool enable_auto_hinting)
+{
+	use_hinting = enable;
+	use_auto_hinting = enable_auto_hinting;
+	reset_images();
+}
+
+void CGUITTFont::draw(const core::stringw& text, const core::rect<s32>& position, video::SColor color, bool hcenter, bool vcenter, const core::rect<s32>* clip)
+{
+	if (!Driver)
+		return;
+
+	// Clear the glyph pages of their render information.
+	for (u32 i = 0; i < Glyph_Pages.size(); ++i)
+	{
+		Glyph_Pages[i]->render_positions.clear();
+		Glyph_Pages[i]->render_source_rects.clear();
+	}
+
+	// Set up some variables.
+	core::dimension2d<s32> textDimension;
+	core::position2d<s32> offset = position.UpperLeftCorner;
+
+	// Determine offset positions.
+	if (hcenter || vcenter)
+	{
+		textDimension = getDimension(text.c_str());
+
+		if (hcenter)
+			offset.X = ((position.getWidth() - textDimension.Width) >> 1) + offset.X;
+
+		if (vcenter)
+			offset.Y = ((position.getHeight() - textDimension.Height) >> 1) + offset.Y;
+	}
+
+	// Convert to a unicode string.
+	core::ustring utext(text);
+
+	// Set up our render map.
+	core::map<u32, CGUITTGlyphPage*> Render_Map;
+
+	// Start parsing characters.
+	u32 n;
+	uchar32_t previousChar = 0;
+	core::ustring::const_iterator iter(utext);
+	while (!iter.atEnd())
+	{
+		uchar32_t currentChar = *iter;
+		n = getGlyphIndexByChar(currentChar);
+		bool visible = (Invisible.findFirst(currentChar) == -1);
+		if (n > 0 && visible)
+		{
+			bool lineBreak=false;
+			if (currentChar == L'\r') // Mac or Windows breaks
+			{
+				lineBreak = true;
+				if (*(iter + 1) == (uchar32_t)'\n')	// Windows line breaks.
+					currentChar = *(++iter);
+			}
+			else if (currentChar == (uchar32_t)'\n') // Unix breaks
+			{
+				lineBreak = true;
+			}
+
+			if (lineBreak)
+			{
+				previousChar = 0;
+				offset.Y += font_metrics.ascender / 64;
+				offset.X = position.UpperLeftCorner.X;
+
+				if (hcenter)
+					offset.X += (position.getWidth() - textDimension.Width) >> 1;
+				++iter;
+				continue;
+			}
+
+			// Calculate the glyph offset.
+			s32 offx = Glyphs[n-1].offset.X;
+			s32 offy = (font_metrics.ascender / 64) - Glyphs[n-1].offset.Y;
+
+			// Apply kerning.
+			core::vector2di k = getKerning(currentChar, previousChar);
+			offset.X += k.X;
+			offset.Y += k.Y;
+
+			// Determine rendering information.
+			SGUITTGlyph& glyph = Glyphs[n-1];
+			CGUITTGlyphPage* const page = Glyph_Pages[glyph.glyph_page];
+			page->render_positions.push_back(core::position2di(offset.X + offx, offset.Y + offy));
+			page->render_source_rects.push_back(glyph.source_rect);
+			Render_Map.set(glyph.glyph_page, page);
+		}
+		offset.X += getWidthFromCharacter(currentChar);
+
+		previousChar = currentChar;
+		++iter;
+	}
+
+	// Draw now.
+	update_glyph_pages();
+	core::map<u32, CGUITTGlyphPage*>::Iterator j = Render_Map.getIterator();
+	while (!j.atEnd())
+	{
+		core::map<u32, CGUITTGlyphPage*>::Node* n = j.getNode();
+		j++;
+		if (n == 0) continue;
+
+		CGUITTGlyphPage* page = n->getValue();
+
+		if (!use_transparency) color.color |= 0xff000000;
+		Driver->draw2DImageBatch(page->texture, page->render_positions, page->render_source_rects, clip, color, true);
+	}
+}
+
+core::dimension2d<u32> CGUITTFont::getCharDimension(const wchar_t ch) const
+{
+	return core::dimension2d<u32>(getWidthFromCharacter(ch), getHeightFromCharacter(ch));
+}
+
+core::dimension2d<u32> CGUITTFont::getDimension(const wchar_t* text) const
+{
+	return getDimension(core::ustring(text));
+}
+
+core::dimension2d<u32> CGUITTFont::getDimension(const core::ustring& text) const
+{
+	// Get the maximum font height.  Unfortunately, we have to do this hack as
+	// Irrlicht will draw things wrong.  In FreeType, the font size is the
+	// maximum size for a single glyph, but that glyph may hang "under" the
+	// draw line, increasing the total font height to beyond the set size.
+	// Irrlicht does not understand this concept when drawing fonts.  Also, I
+	// add +1 to give it a 1 pixel blank border.  This makes things like
+	// tooltips look nicer.
+	s32 test1 = getHeightFromCharacter((uchar32_t)'g') + 1;
+	s32 test2 = getHeightFromCharacter((uchar32_t)'j') + 1;
+	s32 test3 = getHeightFromCharacter((uchar32_t)'_') + 1;
+	s32 max_font_height = core::max_(test1, core::max_(test2, test3));
+
+	core::dimension2d<u32> text_dimension(0, max_font_height);
+	core::dimension2d<u32> line(0, max_font_height);
+
+	uchar32_t previousChar = 0;
+	core::ustring::const_iterator iter = text.begin();
+	for (; !iter.atEnd(); ++iter)
+	{
+		uchar32_t p = *iter;
+		bool lineBreak = false;
+		if (p == '\r')	// Mac or Windows line breaks.
+		{
+			lineBreak = true;
+			if (*(iter + 1) == '\n')
+			{
+				++iter;
+				p = *iter;
+			}
+		}
+		else if (p == '\n')	// Unix line breaks.
+		{
+			lineBreak = true;
+		}
+
+		// Kerning.
+		core::vector2di k = getKerning(p, previousChar);
+		line.Width += k.X;
+		previousChar = p;
+
+		// Check for linebreak.
+		if (lineBreak)
+		{
+			previousChar = 0;
+			text_dimension.Height += line.Height;
+			if (text_dimension.Width < line.Width)
+				text_dimension.Width = line.Width;
+			line.Width = 0;
+			line.Height = max_font_height;
+			continue;
+		}
+		line.Width += getWidthFromCharacter(p);
+	}
+	if (text_dimension.Width < line.Width)
+		text_dimension.Width = line.Width;
+
+	return text_dimension;
+}
+
+inline u32 CGUITTFont::getWidthFromCharacter(wchar_t c) const
+{
+	return getWidthFromCharacter((uchar32_t)c);
+}
+
+inline u32 CGUITTFont::getWidthFromCharacter(uchar32_t c) const
+{
+	// Set the size of the face.
+	// This is because we cache faces and the face may have been set to a different size.
+	//FT_Set_Pixel_Sizes(tt_face, 0, size);
+
+	u32 n = getGlyphIndexByChar(c);
+	if (n > 0)
+	{
+		int w = Glyphs[n-1].advance.x / 64;
+		return w;
+	}
+	if (c >= 0x2000)
+		return (font_metrics.ascender / 64);
+	else return (font_metrics.ascender / 64) / 2;
+}
+
+inline u32 CGUITTFont::getHeightFromCharacter(wchar_t c) const
+{
+	return getHeightFromCharacter((uchar32_t)c);
+}
+
+inline u32 CGUITTFont::getHeightFromCharacter(uchar32_t c) const
+{
+	// Set the size of the face.
+	// This is because we cache faces and the face may have been set to a different size.
+	//FT_Set_Pixel_Sizes(tt_face, 0, size);
+
+	u32 n = getGlyphIndexByChar(c);
+	if (n > 0)
+	{
+		// Grab the true height of the character, taking into account underhanging glyphs.
+		s32 height = (font_metrics.ascender / 64) - Glyphs[n-1].offset.Y + Glyphs[n-1].source_rect.getHeight();
+		return height;
+	}
+	if (c >= 0x2000)
+		return (font_metrics.ascender / 64);
+	else return (font_metrics.ascender / 64) / 2;
+}
+
+u32 CGUITTFont::getGlyphIndexByChar(wchar_t c) const
+{
+	return getGlyphIndexByChar((uchar32_t)c);
+}
+
+u32 CGUITTFont::getGlyphIndexByChar(uchar32_t c) const
+{
+	// Get the glyph.
+	u32 glyph = FT_Get_Char_Index(tt_face, c);
+
+	// Check for a valid glyph.  If it is invalid, attempt to use the replacement character.
+	if (glyph == 0)
+		glyph = FT_Get_Char_Index(tt_face, core::unicode::UTF_REPLACEMENT_CHARACTER);
+
+	// If our glyph is already loaded, don't bother doing any batch loading code.
+	if (glyph != 0 && Glyphs[glyph - 1].isLoaded)
+		return glyph;
+
+	// Determine our batch loading positions.
+	u32 half_size = (batch_load_size / 2);
+	u32 start_pos = 0;
+	if (c > half_size) start_pos = c - half_size;
+	u32 end_pos = start_pos + batch_load_size;
+
+	// Load all our characters.
+	do
+	{
+		// Get the character we are going to load.
+		u32 char_index = FT_Get_Char_Index(tt_face, start_pos);
+
+		// If the glyph hasn't been loaded yet, do it now.
+		if (char_index)
+		{
+			SGUITTGlyph& glyph = Glyphs[char_index - 1];
+			if (!glyph.isLoaded)
+			{
+				glyph.preload(char_index, tt_face, Driver, size, load_flags);
+				Glyph_Pages[glyph.glyph_page]->pushGlyphToBePaged(&glyph);
+			}
+		}
+	}
+	while (++start_pos < end_pos);
+
+	// Return our original character.
+	return glyph;
+}
+
+s32 CGUITTFont::getCharacterFromPos(const wchar_t* text, s32 pixel_x) const
+{
+	return getCharacterFromPos(core::ustring(text), pixel_x);
+}
+
+s32 CGUITTFont::getCharacterFromPos(const core::ustring& text, s32 pixel_x) const
+{
+	s32 x = 0;
+	//s32 idx = 0;
+
+	u32 character = 0;
+	uchar32_t previousChar = 0;
+	core::ustring::const_iterator iter = text.begin();
+	while (!iter.atEnd())
+	{
+		uchar32_t c = *iter;
+		x += getWidthFromCharacter(c);
+
+		// Kerning.
+		core::vector2di k = getKerning(c, previousChar);
+		x += k.X;
+
+		if (x >= pixel_x)
+			return character;
+
+		previousChar = c;
+		++iter;
+		++character;
+	}
+
+	return -1;
+}
+
+void CGUITTFont::setKerningWidth(s32 kerning)
+{
+	GlobalKerningWidth = kerning;
+}
+
+void CGUITTFont::setKerningHeight(s32 kerning)
+{
+	GlobalKerningHeight = kerning;
+}
+
+s32 CGUITTFont::getKerningWidth(const wchar_t* thisLetter, const wchar_t* previousLetter) const
+{
+	if (tt_face == 0)
+		return GlobalKerningWidth;
+	if (thisLetter == 0 || previousLetter == 0)
+		return 0;
+
+	return getKerningWidth((uchar32_t)*thisLetter, (uchar32_t)*previousLetter);
+}
+
+s32 CGUITTFont::getKerningWidth(const uchar32_t thisLetter, const uchar32_t previousLetter) const
+{
+	// Return only the kerning width.
+	return getKerning(thisLetter, previousLetter).X;
+}
+
+s32 CGUITTFont::getKerningHeight() const
+{
+	// FreeType 2 currently doesn't return any height kerning information.
+	return GlobalKerningHeight;
+}
+
+core::vector2di CGUITTFont::getKerning(const wchar_t thisLetter, const wchar_t previousLetter) const
+{
+	return getKerning((uchar32_t)thisLetter, (uchar32_t)previousLetter);
+}
+
+core::vector2di CGUITTFont::getKerning(const uchar32_t thisLetter, const uchar32_t previousLetter) const
+{
+	if (tt_face == 0 || thisLetter == 0 || previousLetter == 0)
+		return core::vector2di();
+
+	// Set the size of the face.
+	// This is because we cache faces and the face may have been set to a different size.
+	FT_Set_Pixel_Sizes(tt_face, 0, size);
+
+	core::vector2di ret(GlobalKerningWidth, GlobalKerningHeight);
+
+	// If we don't have kerning, no point in continuing.
+	if (!FT_HAS_KERNING(tt_face))
+		return ret;
+
+	// Get the kerning information.
+	FT_Vector v;
+	FT_Get_Kerning(tt_face, getGlyphIndexByChar(previousLetter), getGlyphIndexByChar(thisLetter), FT_KERNING_DEFAULT, &v);
+
+	// If we have a scalable font, the return value will be in font points.
+	if (FT_IS_SCALABLE(tt_face))
+	{
+		// Font points, so divide by 64.
+		ret.X += (v.x / 64);
+		ret.Y += (v.y / 64);
+	}
+	else
+	{
+		// Pixel units.
+		ret.X += v.x;
+		ret.Y += v.y;
+	}
+	return ret;
+}
+
+void CGUITTFont::setInvisibleCharacters(const wchar_t *s)
+{
+	core::ustring us(s);
+	Invisible = us;
+}
+
+void CGUITTFont::setInvisibleCharacters(const core::ustring& s)
+{
+	Invisible = s;
+}
+
+video::IImage* CGUITTFont::createTextureFromChar(const uchar32_t& ch)
+{
+	u32 n = getGlyphIndexByChar(ch);
+	const SGUITTGlyph& glyph = Glyphs[n-1];
+	CGUITTGlyphPage* page = Glyph_Pages[glyph.glyph_page];
+
+	if (page->dirty)
+		page->updateTexture();
+
+	video::ITexture* tex = page->texture;
+
+	// Acquire a read-only lock of the corresponding page texture.
+	#if IRRLICHT_VERSION_MAJOR==1 && IRRLICHT_VERSION_MINOR>=8
+	void* ptr = tex->lock(video::ETLM_READ_ONLY);
+	#else
+	void* ptr = tex->lock(true);
+	#endif
+
+	video::ECOLOR_FORMAT format = tex->getColorFormat();
+	core::dimension2du tex_size = tex->getOriginalSize();
+	video::IImage* pageholder = Driver->createImageFromData(format, tex_size, ptr, true, false);
+
+	// Copy the image data out of the page texture.
+	core::dimension2du glyph_size(glyph.source_rect.getSize());
+	video::IImage* image = Driver->createImage(format, glyph_size);
+	pageholder->copyTo(image, core::position2di(0, 0), glyph.source_rect);
+
+	tex->unlock();
+	return image;
+}
+
+video::ITexture* CGUITTFont::getPageTextureByIndex(const u32& page_index) const
+{
+	if (page_index < Glyph_Pages.size())
+		return Glyph_Pages[page_index]->texture;
+	else
+		return 0;
+}
+
+void CGUITTFont::createSharedPlane()
+{
+	/*
+		2___3
+		|  /|
+		| / |	<-- plane mesh is like this, point 2 is (0,0), point 0 is (0, -1)
+		|/  |	<-- the texture coords of point 2 is (0,0, point 0 is (0, 1)
+		0---1
+	*/
+
+	using namespace core;
+	using namespace video;
+	using namespace scene;
+	S3DVertex vertices[4];
+	u16 indices[6] = {0,2,3,3,1,0};
+	vertices[0] = S3DVertex(vector3df(0,-1,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(0,1));
+	vertices[1] = S3DVertex(vector3df(1,-1,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(1,1));
+	vertices[2] = S3DVertex(vector3df(0, 0,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(0,0));
+	vertices[3] = S3DVertex(vector3df(1, 0,0), vector3df(0,0,-1), SColor(255,255,255,255), vector2df(1,0));
+
+	SMeshBuffer* buf = new SMeshBuffer();
+	buf->append(vertices, 4, indices, 6);
+
+	shared_plane_.addMeshBuffer( buf );
+
+	shared_plane_ptr_ = &shared_plane_;
+	buf->drop(); //the addMeshBuffer method will grab it, so we can drop this ptr.
+}
+
+core::dimension2d<u32> CGUITTFont::getDimensionUntilEndOfLine(const wchar_t* p) const
+{
+	core::stringw s;
+	for (const wchar_t* temp = p; temp && *temp != '\0' && *temp != L'\r' && *temp != L'\n'; ++temp )
+		s.append(*temp);
+
+	return getDimension(s.c_str());
+}
+
+core::array<scene::ISceneNode*> CGUITTFont::addTextSceneNode(const wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent, const video::SColor& color, bool center)
+{
+	using namespace core;
+	using namespace video;
+	using namespace scene;
+
+	array<scene::ISceneNode*> container;
+
+	if (!Driver || !smgr) return container;
+	if (!parent)
+		parent = smgr->addEmptySceneNode(smgr->getRootSceneNode(), -1);
+	// if you don't specify parent, then we add a empty node attached to the root node
+	// this is generally undesirable.
+
+	if (!shared_plane_ptr_) //this points to a static mesh that contains the plane
+		createSharedPlane(); //if it's not initialized, we create one.
+
+	dimension2d<s32> text_size(getDimension(text)); //convert from unsigned to signed.
+	vector3df start_point(0, 0, 0), offset;
+
+	/** NOTICE:
+		Because we are considering adding texts into 3D world, all Y axis vectors are inverted.
+	**/
+
+	// There's currently no "vertical center" concept when you apply text scene node to the 3D world.
+	if (center)
+	{
+		offset.X = start_point.X = -text_size.Width / 2.f;
+		offset.Y = start_point.Y = +text_size.Height/ 2.f;
+		offset.X += (text_size.Width - getDimensionUntilEndOfLine(text).Width) >> 1;
+	}
+
+	// the default font material
+	SMaterial mat;
+	mat.setFlag(video::EMF_LIGHTING, true);
+	mat.setFlag(video::EMF_ZWRITE_ENABLE, false);
+	mat.setFlag(video::EMF_NORMALIZE_NORMALS, true);
+	mat.ColorMaterial = video::ECM_NONE;
+	mat.MaterialType = use_transparency ? video::EMT_TRANSPARENT_ALPHA_CHANNEL : video::EMT_SOLID;
+	mat.MaterialTypeParam = 0.01f;
+	mat.DiffuseColor = color;
+
+	wchar_t current_char = 0, previous_char = 0;
+	u32 n = 0;
+
+	array<u32> glyph_indices;
+
+	while (*text)
+	{
+		current_char = *text;
+		bool line_break=false;
+		if (current_char == L'\r') // Mac or Windows breaks
+		{
+			line_break = true;
+			if (*(text + 1) == L'\n') // Windows line breaks.
+				current_char = *(++text);
+		}
+		else if (current_char == L'\n') // Unix breaks
+		{
+			line_break = true;
+		}
+
+		if (line_break)
+		{
+			previous_char = 0;
+			offset.Y -= tt_face->size->metrics.ascender / 64;
+			offset.X = start_point.X;
+			if (center)
+				offset.X += (text_size.Width - getDimensionUntilEndOfLine(text+1).Width) >> 1;
+			++text;
+		}
+		else
+		{
+			n = getGlyphIndexByChar(current_char);
+			if (n > 0)
+			{
+				glyph_indices.push_back( n );
+
+				// Store glyph size and offset informations.
+				SGUITTGlyph const& glyph = Glyphs[n-1];
+				u32 texw = glyph.source_rect.getWidth();
+				u32 texh = glyph.source_rect.getHeight();
+				s32 offx = glyph.offset.X;
+				s32 offy = (font_metrics.ascender / 64) - glyph.offset.Y;
+
+				// Apply kerning.
+				vector2di k = getKerning(current_char, previous_char);
+				offset.X += k.X;
+				offset.Y += k.Y;
+
+				vector3df current_pos(offset.X + offx, offset.Y - offy, 0);
+				dimension2d<u32> letter_size = dimension2d<u32>(texw, texh);
+
+				// Now we copy planes corresponding to the letter size.
+				IMeshManipulator* mani = smgr->getMeshManipulator();
+				IMesh* meshcopy = mani->createMeshCopy(shared_plane_ptr_);
+				#if IRRLICHT_VERSION_MAJOR==1 && IRRLICHT_VERSION_MINOR>=8
+				mani->scale(meshcopy, vector3df((f32)letter_size.Width, (f32)letter_size.Height, 1));
+				#else
+				mani->scaleMesh(meshcopy, vector3df((f32)letter_size.Width, (f32)letter_size.Height, 1));
+				#endif
+
+				ISceneNode* current_node = smgr->addMeshSceneNode(meshcopy, parent, -1, current_pos);
+				meshcopy->drop();
+
+				current_node->getMaterial(0) = mat;
+				current_node->setAutomaticCulling(EAC_OFF);
+				current_node->setIsDebugObject(true);  //so the picking won't have any effect on individual letter
+				//current_node->setDebugDataVisible(EDS_BBOX); //de-comment this when debugging
+
+				container.push_back(current_node);
+			}
+			offset.X += getWidthFromCharacter(current_char);
+			previous_char = current_char;
+			++text;
+		}
+	}
+
+	update_glyph_pages();
+	//only after we update the textures can we use the glyph page textures.
+
+	for (u32 i = 0; i < glyph_indices.size(); ++i)
+	{
+		u32 n = glyph_indices[i];
+		SGUITTGlyph const& glyph = Glyphs[n-1];
+		ITexture* current_tex = Glyph_Pages[glyph.glyph_page]->texture;
+		f32 page_texture_size = (f32)current_tex->getSize().Width;
+		//Now we calculate the UV position according to the texture size and the source rect.
+		//
+		//  2___3
+		//  |  /|
+		//  | / |	<-- plane mesh is like this, point 2 is (0,0), point 0 is (0, -1)
+		//  |/  |	<-- the texture coords of point 2 is (0,0, point 0 is (0, 1)
+		//  0---1
+		//
+		f32 u1 = glyph.source_rect.UpperLeftCorner.X / page_texture_size;
+		f32 u2 = u1 + (glyph.source_rect.getWidth() / page_texture_size);
+		f32 v1 = glyph.source_rect.UpperLeftCorner.Y / page_texture_size;
+		f32 v2 = v1 + (glyph.source_rect.getHeight() / page_texture_size);
+
+		//we can be quite sure that this is IMeshSceneNode, because we just added them in the above loop.
+		IMeshSceneNode* node = static_cast<IMeshSceneNode*>(container[i]);
+
+		S3DVertex* pv = static_cast<S3DVertex*>(node->getMesh()->getMeshBuffer(0)->getVertices());
+		//pv[0].TCoords.Y = pv[1].TCoords.Y = (letter_size.Height - 1) / static_cast<f32>(letter_size.Height);
+		//pv[1].TCoords.X = pv[3].TCoords.X = (letter_size.Width - 1)  / static_cast<f32>(letter_size.Width);
+		pv[0].TCoords = vector2df(u1, v2);
+		pv[1].TCoords = vector2df(u2, v2);
+		pv[2].TCoords = vector2df(u1, v1);
+		pv[3].TCoords = vector2df(u2, v1);
+
+		container[i]->getMaterial(0).setTexture(0, current_tex);
+	}
+
+	return container;
+}
+
+} // end namespace gui
+} // end namespace irr
diff --git a/src/cguittfont/CGUITTFont.h b/src/cguittfont/CGUITTFont.h
new file mode 100644
index 000000000..12e25e0f3
--- /dev/null
+++ b/src/cguittfont/CGUITTFont.h
@@ -0,0 +1,377 @@
+/*
+   CGUITTFont FreeType class for Irrlicht
+   Copyright (c) 2009-2010 John Norman
+
+   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.
+
+   The original version of this class can be located at:
+   http://irrlicht.suckerfreegames.com/
+
+   John Norman
+   john@suckerfreegames.com
+*/
+
+#ifndef __C_GUI_TTFONT_H_INCLUDED__
+#define __C_GUI_TTFONT_H_INCLUDED__
+
+#include <irrlicht.h>
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+namespace irr
+{
+namespace gui
+{
+	struct SGUITTFace;
+	class CGUITTFont;
+
+	//! Class to assist in deleting glyphs.
+	class CGUITTAssistDelete
+	{
+		public:
+			template <class T, typename TAlloc>
+			static void Delete(core::array<T, TAlloc>& a)
+			{
+				TAlloc allocator;
+				allocator.deallocate(a.pointer());
+			}
+	};
+
+	//! Structure representing a single TrueType glyph.
+	struct SGUITTGlyph
+	{
+		//! Constructor.
+		SGUITTGlyph() : isLoaded(false), glyph_page(0), surface(0), parent(0) {}
+
+		//! Destructor.
+		~SGUITTGlyph() { unload(); }
+
+		//! Preload the glyph.
+		//!	The preload process occurs when the program tries to cache the glyph from FT_Library.
+		//! However, it simply defines the SGUITTGlyph's properties and will only create the page
+		//! textures if necessary.  The actual creation of the textures should only occur right
+		//! before the batch draw call.
+		void preload(u32 char_index, FT_Face face, video::IVideoDriver* driver, u32 font_size, const FT_Int32 loadFlags);
+
+		//! Unloads the glyph.
+		void unload();
+
+		//! Creates the IImage object from the FT_Bitmap.
+		video::IImage* createGlyphImage(const FT_Bitmap& bits, video::IVideoDriver* driver) const;
+
+		//! If true, the glyph has been loaded.
+		bool isLoaded;
+
+		//! The page the glyph is on.
+		u32 glyph_page;
+
+		//! The source rectangle for the glyph.
+		core::recti source_rect;
+
+		//! The offset of glyph when drawn.
+		core::vector2di offset;
+
+		//! Glyph advance information.
+		FT_Vector advance;
+
+		//! This is just the temporary image holder.  After this glyph is paged,
+		//! it will be dropped.
+		mutable video::IImage* surface;
+
+		//! The pointer pointing to the parent (CGUITTFont)
+		CGUITTFont* parent;
+	};
+
+	//! Holds a sheet of glyphs.
+	class CGUITTGlyphPage
+	{
+		public:
+			CGUITTGlyphPage(video::IVideoDriver* Driver, const io::path& texture_name) :texture(0), available_slots(0), used_slots(0), dirty(false), driver(Driver), name(texture_name) {}
+			~CGUITTGlyphPage()
+			{
+				if (texture)
+				{
+					if (driver)
+						driver->removeTexture(texture);
+					else texture->drop();
+				}
+			}
+
+			//! Create the actual page texture,
+			bool createPageTexture(const u8& pixel_mode, const core::dimension2du& texture_size)
+			{
+				if( texture )
+					return false;
+
+				bool flgmip = driver->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
+				driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
+
+				// Set the texture color format.
+				switch (pixel_mode)
+				{
+					case FT_PIXEL_MODE_MONO:
+						texture = driver->addTexture(texture_size, name, video::ECF_A1R5G5B5);
+						break;
+					case FT_PIXEL_MODE_GRAY:
+					default:
+						texture = driver->addTexture(texture_size, name, video::ECF_A8R8G8B8);
+						break;
+				}
+
+				// Restore our texture creation flags.
+				driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, flgmip);
+				return texture ? true : false;
+			}
+
+			//! Add the glyph to a list of glyphs to be paged.
+			//! This collection will be cleared after updateTexture is called.
+			void pushGlyphToBePaged(const SGUITTGlyph* glyph)
+			{
+				glyph_to_be_paged.push_back(glyph);
+			}
+
+			//! Updates the texture atlas with new glyphs.
+			void updateTexture()
+			{
+				if (!dirty) return;
+
+				void* ptr = texture->lock();
+				video::ECOLOR_FORMAT format = texture->getColorFormat();
+				core::dimension2du size = texture->getOriginalSize();
+				video::IImage* pageholder = driver->createImageFromData(format, size, ptr, true, false);
+
+				for (u32 i = 0; i < glyph_to_be_paged.size(); ++i)
+				{
+					const SGUITTGlyph* glyph = glyph_to_be_paged[i];
+					if (glyph && glyph->isLoaded)
+					{
+						if (glyph->surface)
+						{
+							glyph->surface->copyTo(pageholder, glyph->source_rect.UpperLeftCorner);
+							glyph->surface->drop();
+							glyph->surface = 0;
+						}
+						else
+						{
+							; // TODO: add error message?
+							//currently, if we failed to create the image, just ignore this operation.
+						}
+					}
+				}
+
+				pageholder->drop();
+				texture->unlock();
+				glyph_to_be_paged.clear();
+				dirty = false;
+			}
+
+			video::ITexture* texture;
+			u32 available_slots;
+			u32 used_slots;
+			bool dirty;
+
+			core::array<core::vector2di> render_positions;
+			core::array<core::recti> render_source_rects;
+
+		private:
+			core::array<const SGUITTGlyph*> glyph_to_be_paged;
+			video::IVideoDriver* driver;
+			io::path name;
+	};
+
+	//! Class representing a TrueType font.
+	class CGUITTFont : public IGUIFont
+	{
+		public:
+			//! Creates a new TrueType font and returns a pointer to it.  The pointer must be drop()'ed when finished.
+			//! \param env The IGUIEnvironment the font loads out of.
+			//! \param filename The filename of the font.
+			//! \param size The size of the font glyphs in pixels.  Since this is the size of the individual glyphs, the true height of the font may change depending on the characters used.
+			//! \param antialias set the use_monochrome (opposite to antialias) flag
+			//! \param transparency set the use_transparency flag
+			//! \return Returns a pointer to a CGUITTFont.  Will return 0 if the font failed to load.
+			static CGUITTFont* createTTFont(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
+			static CGUITTFont* createTTFont(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
+			static CGUITTFont* create(IGUIEnvironment *env, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
+			static CGUITTFont* create(IrrlichtDevice *device, const io::path& filename, const u32 size, const bool antialias = true, const bool transparency = true);
+
+			//! Destructor
+			virtual ~CGUITTFont();
+
+			//! Sets the amount of glyphs to batch load.
+			virtual void setBatchLoadSize(u32 batch_size) { batch_load_size = batch_size; }
+
+			//! Sets the maximum texture size for a page of glyphs.
+			virtual void setMaxPageTextureSize(const core::dimension2du& texture_size) { max_page_texture_size = texture_size; }
+
+			//! Get the font size.
+			virtual u32 getFontSize() const { return size; }
+
+			//! Check the font's transparency.
+			virtual bool isTransparent() const { return use_transparency; }
+
+			//! Check if the font auto-hinting is enabled.
+			//! Auto-hinting is FreeType's built-in font hinting engine.
+			virtual bool useAutoHinting() const { return use_auto_hinting; }
+
+			//! Check if the font hinting is enabled.
+			virtual bool useHinting()	 const { return use_hinting; }
+
+			//! Check if the font is being loaded as a monochrome font.
+			//! The font can either be a 256 color grayscale font, or a 2 color monochrome font.
+			virtual bool useMonochrome()  const { return use_monochrome; }
+
+			//! Tells the font to allow transparency when rendering.
+			//! Default: true.
+			//! \param flag If true, the font draws using transparency.
+			virtual void setTransparency(const bool flag);
+
+			//! Tells the font to use monochrome rendering.
+			//! Default: false.
+			//! \param flag If true, the font draws using a monochrome image.  If false, the font uses a grayscale image.
+			virtual void setMonochrome(const bool flag);
+
+			//! Enables or disables font hinting.
+			//! Default: Hinting and auto-hinting true.
+			//! \param enable If false, font hinting is turned off. If true, font hinting is turned on.
+			//! \param enable_auto_hinting If true, FreeType uses its own auto-hinting algorithm.  If false, it tries to use the algorithm specified by the font.
+			virtual void setFontHinting(const bool enable, const bool enable_auto_hinting = true);
+
+			//! Draws some text and clips it to the specified rectangle if wanted.
+			virtual void draw(const core::stringw& text, const core::rect<s32>& position,
+				video::SColor color, bool hcenter=false, bool vcenter=false,
+				const core::rect<s32>* clip=0);
+
+			//! Returns the dimension of a character produced by this font.
+			virtual core::dimension2d<u32> getCharDimension(const wchar_t ch) const;
+
+			//! Returns the dimension of a text string.
+			virtual core::dimension2d<u32> getDimension(const wchar_t* text) const;
+			virtual core::dimension2d<u32> getDimension(const core::ustring& text) const;
+
+			//! Calculates the index of the character in the text which is on a specific position.
+			virtual s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const;
+			virtual s32 getCharacterFromPos(const core::ustring& text, s32 pixel_x) const;
+
+			//! Sets global kerning width for the font.
+			virtual void setKerningWidth(s32 kerning);
+
+			//! Sets global kerning height for the font.
+			virtual void setKerningHeight(s32 kerning);
+
+			//! Gets kerning values (distance between letters) for the font. If no parameters are provided,
+			virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const;
+			virtual s32 getKerningWidth(const uchar32_t thisLetter=0, const uchar32_t previousLetter=0) const;
+
+			//! Returns the distance between letters
+			virtual s32 getKerningHeight() const;
+
+			//! Define which characters should not be drawn by the font.
+			virtual void setInvisibleCharacters(const wchar_t *s);
+			virtual void setInvisibleCharacters(const core::ustring& s);
+
+			//! Get the last glyph page if there's still available slots.
+			//! If not, it will return zero.
+			CGUITTGlyphPage* getLastGlyphPage() const;
+
+			//! Create a new glyph page texture.
+			//! \param pixel_mode the pixel mode defined by FT_Pixel_Mode
+			//should be better typed. fix later.
+			CGUITTGlyphPage* createGlyphPage(const u8& pixel_mode);
+
+			//! Get the last glyph page's index.
+			u32 getLastGlyphPageIndex() const { return Glyph_Pages.size() - 1; }
+
+			//! Create corresponding character's software image copy from the font,
+			//! so you can use this data just like any ordinary video::IImage.
+			//! \param ch The character you need
+			virtual video::IImage* createTextureFromChar(const uchar32_t& ch);
+
+			//! This function is for debugging mostly. If the page doesn't exist it returns zero.
+			//! \param page_index Simply return the texture handle of a given page index.
+			virtual video::ITexture* getPageTextureByIndex(const u32& page_index) const;
+
+			//! Add a list of scene nodes generated by putting font textures on the 3D planes.
+			virtual core::array<scene::ISceneNode*> addTextSceneNode
+				(const wchar_t* text, scene::ISceneManager* smgr, scene::ISceneNode* parent = 0,
+				 const video::SColor& color = video::SColor(255, 0, 0, 0), bool center = false );
+
+		protected:
+			bool use_monochrome;
+			bool use_transparency;
+			bool use_hinting;
+			bool use_auto_hinting;
+			u32 size;
+			u32 batch_load_size;
+			core::dimension2du max_page_texture_size;
+
+		private:
+			// Manages the FreeType library.
+			static FT_Library c_library;
+			static core::map<io::path, SGUITTFace*> c_faces;
+			static bool c_libraryLoaded;
+			static scene::IMesh* shared_plane_ptr_;
+			static scene::SMesh  shared_plane_;
+
+			CGUITTFont(IGUIEnvironment *env);
+			bool load(const io::path& filename, const u32 size, const bool antialias, const bool transparency);
+			void reset_images();
+			void update_glyph_pages() const;
+			void update_load_flags()
+			{
+				// Set up our loading flags.
+				load_flags = FT_LOAD_DEFAULT | FT_LOAD_RENDER;
+				if (!useHinting()) load_flags |= FT_LOAD_NO_HINTING;
+				if (!useAutoHinting()) load_flags |= FT_LOAD_NO_AUTOHINT;
+				if (useMonochrome()) load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO | FT_RENDER_MODE_MONO;
+				else load_flags |= FT_LOAD_TARGET_NORMAL;
+			}
+			u32 getWidthFromCharacter(wchar_t c) const;
+			u32 getWidthFromCharacter(uchar32_t c) const;
+			u32 getHeightFromCharacter(wchar_t c) const;
+			u32 getHeightFromCharacter(uchar32_t c) const;
+			u32 getGlyphIndexByChar(wchar_t c) const;
+			u32 getGlyphIndexByChar(uchar32_t c) const;
+			core::vector2di getKerning(const wchar_t thisLetter, const wchar_t previousLetter) const;
+			core::vector2di getKerning(const uchar32_t thisLetter, const uchar32_t previousLetter) const;
+			core::dimension2d<u32> getDimensionUntilEndOfLine(const wchar_t* p) const;
+
+			void createSharedPlane();
+
+			irr::IrrlichtDevice* Device;
+			gui::IGUIEnvironment* Environment;
+			video::IVideoDriver* Driver;
+			io::path filename;
+			FT_Face tt_face;
+			FT_Size_Metrics font_metrics;
+			FT_Int32 load_flags;
+
+			mutable core::array<CGUITTGlyphPage*> Glyph_Pages;
+			mutable core::array<SGUITTGlyph> Glyphs;
+
+			s32 GlobalKerningWidth;
+			s32 GlobalKerningHeight;
+			core::ustring Invisible;
+	};
+
+} // end namespace gui
+} // end namespace irr
+
+#endif // __C_GUI_TTFONT_H_INCLUDED__
diff --git a/src/cguittfont/CMakeLists.txt b/src/cguittfont/CMakeLists.txt
new file mode 100644
index 000000000..94d061462
--- /dev/null
+++ b/src/cguittfont/CMakeLists.txt
@@ -0,0 +1,17 @@
+include_directories(
+  ${IRRLICHT_INCLUDE_DIR}
+  ${FREETYPE_INCLUDE_DIRS}
+)
+
+# CGUITTFont authors, y u no include headers you use?
+#   Do not add CGUITTFont.cpp to the line below.
+#   xCGUITTFont.cpp is a wrapper file that includes
+#   additional required headers.
+add_library(cguittfont xCGUITTFont.cpp)
+
+target_link_libraries(
+  cguittfont
+  ${IRRLICHT_LIBRARY}
+  ${FREETYPE_LIBRARY}
+  ${ZLIB_LIBRARIES}  # needed by freetype, repeated here for safety
+)
diff --git a/src/cguittfont/irrUString.h b/src/cguittfont/irrUString.h
new file mode 100644
index 000000000..f41fa1f7b
--- /dev/null
+++ b/src/cguittfont/irrUString.h
@@ -0,0 +1,3877 @@
+/*
+   Basic Unicode string class for Irrlicht.
+   Copyright (c) 2009-2011 John Norman
+
+   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.
+
+   The original version of this class can be located at:
+   http://irrlicht.suckerfreegames.com/
+
+   John Norman
+   john@suckerfreegames.com
+*/
+
+#ifndef __IRR_USTRING_H_INCLUDED__
+#define __IRR_USTRING_H_INCLUDED__
+
+#if (__cplusplus > 199711L) || (_MSC_VER >= 1600) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#	define USTRING_CPP0X
+#	if defined(__GXX_EXPERIMENTAL_CXX0X__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)))
+#		define USTRING_CPP0X_NEWLITERALS
+#	endif
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef USTRING_CPP0X
+#	include <utility>
+#endif
+
+#ifndef USTRING_NO_STL
+#	include <string>
+#	include <iterator>
+#	include <ostream>
+#endif
+
+#include "irrTypes.h"
+#include "irrAllocator.h"
+#include "irrArray.h"
+#include "irrMath.h"
+#include "irrString.h"
+#include "path.h"
+
+//! UTF-16 surrogate start values.
+static const irr::u16 UTF16_HI_SURROGATE = 0xD800;
+static const irr::u16 UTF16_LO_SURROGATE = 0xDC00;
+
+//! Is a UTF-16 code point a surrogate?
+#define UTF16_IS_SURROGATE(c)		(((c) & 0xF800) == 0xD800)
+#define UTF16_IS_SURROGATE_HI(c)	(((c) & 0xFC00) == 0xD800)
+#define UTF16_IS_SURROGATE_LO(c)	(((c) & 0xFC00) == 0xDC00)
+
+
+namespace irr
+{
+
+	// Define our character types.
+#ifdef USTRING_CPP0X_NEWLITERALS	// C++0x
+	typedef char32_t uchar32_t;
+	typedef char16_t uchar16_t;
+	typedef char uchar8_t;
+#else
+	typedef u32 uchar32_t;
+	typedef u16 uchar16_t;
+	typedef u8 uchar8_t;
+#endif
+
+namespace core
+{
+
+namespace unicode
+{
+
+//! The unicode replacement character.  Used to replace invalid characters.
+const irr::u16 UTF_REPLACEMENT_CHARACTER = 0xFFFD;
+
+//! Convert a UTF-16 surrogate pair into a UTF-32 character.
+//! \param high The high value of the pair.
+//! \param low The low value of the pair.
+//! \return The UTF-32 character expressed by the surrogate pair.
+inline uchar32_t toUTF32(uchar16_t high, uchar16_t low)
+{
+	// Convert the surrogate pair into a single UTF-32 character.
+	uchar32_t x = ((high & ((1 << 6) -1)) << 10) | (low & ((1 << 10) -1));
+	uchar32_t wu = ((high >> 6) & ((1 << 5) - 1)) + 1;
+	return (wu << 16) | x;
+}
+
+//! Swaps the endianness of a 16-bit value.
+//! \return The new value.
+inline uchar16_t swapEndian16(const uchar16_t& c)
+{
+	return ((c >> 8) & 0x00FF) | ((c << 8) & 0xFF00);
+}
+
+//! Swaps the endianness of a 32-bit value.
+//! \return The new value.
+inline uchar32_t swapEndian32(const uchar32_t& c)
+{
+	return  ((c >> 24) & 0x000000FF) |
+			((c >> 8)  & 0x0000FF00) |
+			((c << 8)  & 0x00FF0000) |
+			((c << 24) & 0xFF000000);
+}
+
+//! The Unicode byte order mark.
+const u16 BOM = 0xFEFF;
+
+//! The size of the Unicode byte order mark in terms of the Unicode character size.
+const u8 BOM_UTF8_LEN = 3;
+const u8 BOM_UTF16_LEN = 1;
+const u8 BOM_UTF32_LEN = 1;
+
+//! Unicode byte order marks for file operations.
+const u8 BOM_ENCODE_UTF8[3] = { 0xEF, 0xBB, 0xBF };
+const u8 BOM_ENCODE_UTF16_BE[2] = { 0xFE, 0xFF };
+const u8 BOM_ENCODE_UTF16_LE[2] = { 0xFF, 0xFE };
+const u8 BOM_ENCODE_UTF32_BE[4] = { 0x00, 0x00, 0xFE, 0xFF };
+const u8 BOM_ENCODE_UTF32_LE[4] = { 0xFF, 0xFE, 0x00, 0x00 };
+
+//! The size in bytes of the Unicode byte marks for file operations.
+const u8 BOM_ENCODE_UTF8_LEN = 3;
+const u8 BOM_ENCODE_UTF16_LEN = 2;
+const u8 BOM_ENCODE_UTF32_LEN = 4;
+
+//! Unicode encoding type.
+enum EUTF_ENCODE
+{
+	EUTFE_NONE		= 0,
+	EUTFE_UTF8,
+	EUTFE_UTF16,
+	EUTFE_UTF16_LE,
+	EUTFE_UTF16_BE,
+	EUTFE_UTF32,
+	EUTFE_UTF32_LE,
+	EUTFE_UTF32_BE
+};
+
+//! Unicode endianness.
+enum EUTF_ENDIAN
+{
+	EUTFEE_NATIVE	= 0,
+	EUTFEE_LITTLE,
+	EUTFEE_BIG
+};
+
+//! Returns the specified unicode byte order mark in a byte array.
+//! The byte order mark is the first few bytes in a text file that signifies its encoding.
+/** \param mode The Unicode encoding method that we want to get the byte order mark for.
+		If EUTFE_UTF16 or EUTFE_UTF32 is passed, it uses the native system endianness. **/
+//! \return An array that contains a byte order mark.
+inline core::array<u8> getUnicodeBOM(EUTF_ENCODE mode)
+{
+#define COPY_ARRAY(source, size) \
+	memcpy(ret.pointer(), source, size); \
+	ret.set_used(size)
+
+	core::array<u8> ret(4);
+	switch (mode)
+	{
+		case EUTFE_UTF8:
+			COPY_ARRAY(BOM_ENCODE_UTF8, BOM_ENCODE_UTF8_LEN);
+			break;
+		case EUTFE_UTF16:
+			#ifdef __BIG_ENDIAN__
+				COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
+			#else
+				COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
+			#endif
+			break;
+		case EUTFE_UTF16_BE:
+			COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
+			break;
+		case EUTFE_UTF16_LE:
+			COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
+			break;
+		case EUTFE_UTF32:
+			#ifdef __BIG_ENDIAN__
+				COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
+			#else
+				COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
+			#endif
+			break;
+		case EUTFE_UTF32_BE:
+			COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
+			break;
+		case EUTFE_UTF32_LE:
+			COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
+			break;
+	}
+	return ret;
+
+#undef COPY_ARRAY
+}
+
+//! Detects if the given data stream starts with a unicode BOM.
+//! \param data The data stream to check.
+//! \return The unicode BOM associated with the data stream, or EUTFE_NONE if none was found.
+inline EUTF_ENCODE determineUnicodeBOM(const char* data)
+{
+	if (memcmp(data, BOM_ENCODE_UTF8, 3) == 0) return EUTFE_UTF8;
+	if (memcmp(data, BOM_ENCODE_UTF16_BE, 2) == 0) return EUTFE_UTF16_BE;
+	if (memcmp(data, BOM_ENCODE_UTF16_LE, 2) == 0) return EUTFE_UTF16_LE;
+	if (memcmp(data, BOM_ENCODE_UTF32_BE, 4) == 0) return EUTFE_UTF32_BE;
+	if (memcmp(data, BOM_ENCODE_UTF32_LE, 4) == 0) return EUTFE_UTF32_LE;
+	return EUTFE_NONE;
+}
+
+} // end namespace unicode
+
+
+//! UTF-16 string class.
+template <typename TAlloc = irrAllocator<uchar16_t> >
+class ustring16
+{
+public:
+
+	///------------------///
+	/// iterator classes ///
+	///------------------///
+
+	//! Access an element in a unicode string, allowing one to change it.
+	class _ustring16_iterator_access
+	{
+		public:
+			_ustring16_iterator_access(const ustring16<TAlloc>* s, u32 p) : ref(s), pos(p) {}
+
+			//! Allow the class to be interpreted as a single UTF-32 character.
+			operator uchar32_t() const
+			{
+				return _get();
+			}
+
+			//! Allow one to change the character in the unicode string.
+			//! \param c The new character to use.
+			//! \return Myself.
+			_ustring16_iterator_access& operator=(const uchar32_t c)
+			{
+				_set(c);
+				return *this;
+			}
+			
+			//! Increments the value by 1.
+			//! \return Myself.
+			_ustring16_iterator_access& operator++()
+			{
+				_set(_get() + 1);
+				return *this;
+			}
+
+			//! Increments the value by 1, returning the old value.
+			//! \return A unicode character.
+			uchar32_t operator++(int)
+			{
+				uchar32_t old = _get();
+				_set(old + 1);
+				return old;
+			}
+
+			//! Decrements the value by 1.
+			//! \return Myself.
+			_ustring16_iterator_access& operator--()
+			{
+				_set(_get() - 1);
+				return *this;
+			}
+
+			//! Decrements the value by 1, returning the old value.
+			//! \return A unicode character.
+			uchar32_t operator--(int)
+			{
+				uchar32_t old = _get();
+				_set(old - 1);
+				return old;
+			}
+
+			//! Adds to the value by a specified amount.
+			//! \param val The amount to add to this character.
+			//! \return Myself.
+			_ustring16_iterator_access& operator+=(int val)
+			{
+				_set(_get() + val);
+				return *this;
+			}
+
+			//! Subtracts from the value by a specified amount.
+			//! \param val The amount to subtract from this character.
+			//! \return Myself.
+			_ustring16_iterator_access& operator-=(int val)
+			{
+				_set(_get() - val);
+				return *this;
+			}
+
+			//! Multiples the value by a specified amount.
+			//! \param val The amount to multiply this character by.
+			//! \return Myself.
+			_ustring16_iterator_access& operator*=(int val)
+			{
+				_set(_get() * val);
+				return *this;
+			}
+
+			//! Divides the value by a specified amount.
+			//! \param val The amount to divide this character by.
+			//! \return Myself.
+			_ustring16_iterator_access& operator/=(int val)
+			{
+				_set(_get() / val);
+				return *this;
+			}
+
+			//! Modulos the value by a specified amount.
+			//! \param val The amount to modulo this character by.
+			//! \return Myself.
+			_ustring16_iterator_access& operator%=(int val)
+			{
+				_set(_get() % val);
+				return *this;
+			}
+
+			//! Adds to the value by a specified amount.
+			//! \param val The amount to add to this character.
+			//! \return A unicode character.
+			uchar32_t operator+(int val) const
+			{
+				return _get() + val;
+			}
+
+			//! Subtracts from the value by a specified amount.
+			//! \param val The amount to subtract from this character.
+			//! \return A unicode character.
+			uchar32_t operator-(int val) const
+			{
+				return _get() - val;
+			}
+
+			//! Multiplies the value by a specified amount.
+			//! \param val The amount to multiply this character by.
+			//! \return A unicode character.
+			uchar32_t operator*(int val) const
+			{
+				return _get() * val;
+			}
+
+			//! Divides the value by a specified amount.
+			//! \param val The amount to divide this character by.
+			//! \return A unicode character.
+			uchar32_t operator/(int val) const
+			{
+				return _get() / val;
+			}
+
+			//! Modulos the value by a specified amount.
+			//! \param val The amount to modulo this character by.
+			//! \return A unicode character.
+			uchar32_t operator%(int val) const
+			{
+				return _get() % val;
+			}
+
+		private:
+			//! Gets a uchar32_t from our current position.
+			uchar32_t _get() const
+			{
+				const uchar16_t* a = ref->c_str();
+				if (!UTF16_IS_SURROGATE(a[pos]))
+					return static_cast<uchar32_t>(a[pos]);
+				else
+				{
+					if (pos + 1 >= ref->size_raw())
+						return 0;
+
+					return unicode::toUTF32(a[pos], a[pos + 1]);
+				}
+			}
+			
+			//! Sets a uchar32_t at our current position.
+			void _set(uchar32_t c)
+			{
+				ustring16<TAlloc>* ref2 = const_cast<ustring16<TAlloc>*>(ref);
+				const uchar16_t* a = ref2->c_str();
+				if (c > 0xFFFF)
+				{
+					// c will be multibyte, so split it up into the high and low surrogate pairs.
+					uchar16_t x = static_cast<uchar16_t>(c);
+					uchar16_t vh = UTF16_HI_SURROGATE | ((((c >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
+					uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
+
+					// If the previous position was a surrogate pair, just replace them.  Else, insert the low pair.
+					if (UTF16_IS_SURROGATE_HI(a[pos]) && pos + 1 != ref2->size_raw())
+						ref2->replace_raw(vl, static_cast<u32>(pos) + 1);
+					else ref2->insert_raw(vl, static_cast<u32>(pos) + 1);
+
+					ref2->replace_raw(vh, static_cast<u32>(pos));
+				}
+				else
+				{
+					// c will be a single byte.
+					uchar16_t vh = static_cast<uchar16_t>(c);
+
+					// If the previous position was a surrogate pair, remove the extra byte.
+					if (UTF16_IS_SURROGATE_HI(a[pos]))
+						ref2->erase_raw(static_cast<u32>(pos) + 1);
+
+					ref2->replace_raw(vh, static_cast<u32>(pos));
+				}
+			}
+
+			const ustring16<TAlloc>* ref;
+			u32 pos;
+	};
+	typedef typename ustring16<TAlloc>::_ustring16_iterator_access access;
+
+
+	//! Iterator to iterate through a UTF-16 string.
+#ifndef USTRING_NO_STL
+	class _ustring16_const_iterator : public std::iterator<
+		std::bidirectional_iterator_tag,	// iterator_category
+		access,								// value_type
+		ptrdiff_t,							// difference_type
+		const access,						// pointer
+		const access						// reference
+	>
+#else
+	class _ustring16_const_iterator
+#endif
+	{
+		public:
+			typedef _ustring16_const_iterator _Iter;
+			typedef std::iterator<std::bidirectional_iterator_tag, access, ptrdiff_t, const access, const access> _Base;
+			typedef const access const_pointer;
+			typedef const access const_reference;
+
+#ifndef USTRING_NO_STL
+			typedef typename _Base::value_type value_type;
+			typedef typename _Base::difference_type difference_type;
+			typedef typename _Base::difference_type distance_type;
+			typedef typename _Base::pointer pointer;
+			typedef const_reference reference;
+#else
+			typedef access value_type;
+			typedef u32 difference_type;
+			typedef u32 distance_type;
+			typedef const_pointer pointer;
+			typedef const_reference reference;
+#endif
+
+			//! Constructors.
+			_ustring16_const_iterator(const _Iter& i) : ref(i.ref), pos(i.pos) {}
+			_ustring16_const_iterator(const ustring16<TAlloc>& s) : ref(&s), pos(0) {}
+			_ustring16_const_iterator(const ustring16<TAlloc>& s, const u32 p) : ref(&s), pos(0)
+			{
+				if (ref->size_raw() == 0 || p == 0)
+					return;
+
+				// Go to the appropriate position.
+				u32 i = p;
+				u32 sr = ref->size_raw();
+				const uchar16_t* a = ref->c_str();
+				while (i != 0 && pos < sr)
+				{
+					if (UTF16_IS_SURROGATE_HI(a[pos]))
+						pos += 2;
+					else ++pos;
+					--i;
+				}
+			}
+
+			//! Test for equalness.
+			bool operator==(const _Iter& iter) const
+			{
+				if (ref == iter.ref && pos == iter.pos)
+					return true;
+				return false;
+			}
+
+			//! Test for unequalness.
+			bool operator!=(const _Iter& iter) const
+			{
+				if (ref != iter.ref || pos != iter.pos)
+					return true;
+				return false;
+			}
+
+			//! Switch to the next full character in the string.
+			_Iter& operator++()
+			{	// ++iterator
+				if (pos == ref->size_raw()) return *this;
+				const uchar16_t* a = ref->c_str();
+				if (UTF16_IS_SURROGATE_HI(a[pos]))
+					pos += 2;			// TODO: check for valid low surrogate?
+				else ++pos;
+				if (pos > ref->size_raw()) pos = ref->size_raw();
+				return *this;
+			}
+
+			//! Switch to the next full character in the string, returning the previous position.
+			_Iter operator++(int)
+			{	// iterator++
+				_Iter _tmp(*this);
+				++*this;
+				return _tmp;
+			}
+
+			//! Switch to the previous full character in the string.
+			_Iter& operator--()
+			{	// --iterator
+				if (pos == 0) return *this;
+				const uchar16_t* a = ref->c_str();
+				--pos;
+				if (UTF16_IS_SURROGATE_LO(a[pos]) && pos != 0)	// low surrogate, go back one more.
+					--pos;
+				return *this;
+			}
+
+			//! Switch to the previous full character in the string, returning the previous position.
+			_Iter operator--(int)
+			{	// iterator--
+				_Iter _tmp(*this);
+				--*this;
+				return _tmp;
+			}
+
+			//! Advance a specified number of full characters in the string.
+			//! \return Myself.
+			_Iter& operator+=(const difference_type v)
+			{
+				if (v == 0) return *this;
+				if (v < 0) return operator-=(v * -1);
+
+				if (pos >= ref->size_raw())
+					return *this;
+
+				// Go to the appropriate position.
+				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
+				u32 i = (u32)v;
+				u32 sr = ref->size_raw();
+				const uchar16_t* a = ref->c_str();
+				while (i != 0 && pos < sr)
+				{
+					if (UTF16_IS_SURROGATE_HI(a[pos]))
+						pos += 2;
+					else ++pos;
+					--i;
+				}
+				if (pos > sr)
+					pos = sr;
+
+				return *this;
+			}
+
+			//! Go back a specified number of full characters in the string.
+			//! \return Myself.
+			_Iter& operator-=(const difference_type v)
+			{
+				if (v == 0) return *this;
+				if (v > 0) return operator+=(v * -1);
+
+				if (pos == 0)
+					return *this;
+
+				// Go to the appropriate position.
+				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
+				u32 i = (u32)v;
+				const uchar16_t* a = ref->c_str();
+				while (i != 0 && pos != 0)
+				{
+					--pos;
+					if (UTF16_IS_SURROGATE_LO(a[pos]) != 0 && pos != 0)
+						--pos;
+					--i;
+				}
+
+				return *this;
+			}
+
+			//! Return a new iterator that is a variable number of full characters forward from the current position.
+			_Iter operator+(const difference_type v) const
+			{
+				_Iter ret(*this);
+				ret += v;
+				return ret;
+			}
+
+			//! Return a new iterator that is a variable number of full characters backward from the current position.
+			_Iter operator-(const difference_type v) const
+			{
+				_Iter ret(*this);
+				ret -= v;
+				return ret;
+			}
+
+			//! Returns the distance between two iterators.
+			difference_type operator-(const _Iter& iter) const
+			{
+				// Make sure we reference the same object!
+				if (ref != iter.ref)
+					return difference_type();
+
+				_Iter i = iter;
+				difference_type ret;
+
+				// Walk up.
+				if (pos > i.pos)
+				{
+					while (pos > i.pos)
+					{
+						++i;
+						++ret;
+					}
+					return ret;
+				}
+
+				// Walk down.
+				while (pos < i.pos)
+				{
+					--i;
+					--ret;
+				}
+				return ret;
+			}
+
+			//! Accesses the full character at the iterator's position.
+			const_reference operator*() const
+			{
+				if (pos >= ref->size_raw())
+				{
+					const uchar16_t* a = ref->c_str();
+					u32 p = ref->size_raw();
+					if (UTF16_IS_SURROGATE_LO(a[p]))
+						--p;
+					reference ret(ref, p);
+					return ret;
+				}
+				const_reference ret(ref, pos);
+				return ret;
+			}
+
+			//! Accesses the full character at the iterator's position.
+			reference operator*()
+			{
+				if (pos >= ref->size_raw())
+				{
+					const uchar16_t* a = ref->c_str();
+					u32 p = ref->size_raw();
+					if (UTF16_IS_SURROGATE_LO(a[p]))
+						--p;
+					reference ret(ref, p);
+					return ret;
+				}
+				reference ret(ref, pos);
+				return ret;
+			}
+
+			//! Accesses the full character at the iterator's position.
+			const_pointer operator->() const
+			{
+				return operator*();
+			}
+
+			//! Accesses the full character at the iterator's position.
+			pointer operator->()
+			{
+				return operator*();
+			}
+
+			//! Is the iterator at the start of the string?
+			bool atStart() const
+			{
+				return pos == 0;
+			}
+
+			//! Is the iterator at the end of the string?
+			bool atEnd() const
+			{
+				const uchar16_t* a = ref->c_str();
+				if (UTF16_IS_SURROGATE(a[pos]))
+					return (pos + 1) >= ref->size_raw();
+				else return pos >= ref->size_raw();
+			}
+
+			//! Moves the iterator to the start of the string.
+			void toStart()
+			{
+				pos = 0;
+			}
+
+			//! Moves the iterator to the end of the string.
+			void toEnd()
+			{
+				const uchar16_t* a = ref->c_str();
+				pos = ref->size_raw();
+			}
+
+			//! Returns the iterator's position.
+			//! \return The iterator's position.
+			u32 getPos() const
+			{
+				return pos;
+			}
+
+		protected:
+			const ustring16<TAlloc>* ref;
+			u32 pos;
+	};
+
+	//! Iterator to iterate through a UTF-16 string.
+	class _ustring16_iterator : public _ustring16_const_iterator
+	{
+		public:
+			typedef _ustring16_iterator _Iter;
+			typedef _ustring16_const_iterator _Base;
+			typedef typename _Base::const_pointer const_pointer;
+			typedef typename _Base::const_reference const_reference;
+
+			typedef typename _Base::value_type value_type;
+			typedef typename _Base::difference_type difference_type;
+			typedef typename _Base::distance_type distance_type;
+			typedef access pointer;
+			typedef access reference;
+			
+			using _Base::pos;
+			using _Base::ref;
+
+			//! Constructors.
+			_ustring16_iterator(const _Iter& i) : _ustring16_const_iterator(i) {}
+			_ustring16_iterator(const ustring16<TAlloc>& s) : _ustring16_const_iterator(s) {}
+			_ustring16_iterator(const ustring16<TAlloc>& s, const u32 p) : _ustring16_const_iterator(s, p) {}
+
+			//! Accesses the full character at the iterator's position.
+			reference operator*() const
+			{
+				if (pos >= ref->size_raw())
+				{
+					const uchar16_t* a = ref->c_str();
+					u32 p = ref->size_raw();
+					if (UTF16_IS_SURROGATE_LO(a[p]))
+						--p;
+					reference ret(ref, p);
+					return ret;
+				}
+				reference ret(ref, pos);
+				return ret;
+			}
+
+			//! Accesses the full character at the iterator's position.
+			reference operator*()
+			{
+				if (pos >= ref->size_raw())
+				{
+					const uchar16_t* a = ref->c_str();
+					u32 p = ref->size_raw();
+					if (UTF16_IS_SURROGATE_LO(a[p]))
+						--p;
+					reference ret(ref, p);
+					return ret;
+				}
+				reference ret(ref, pos);
+				return ret;
+			}
+
+			//! Accesses the full character at the iterator's position.
+			pointer operator->() const
+			{
+				return operator*();
+			}
+
+			//! Accesses the full character at the iterator's position.
+			pointer operator->()
+			{
+				return operator*();
+			}
+	};
+
+	typedef typename ustring16<TAlloc>::_ustring16_iterator iterator;
+	typedef typename ustring16<TAlloc>::_ustring16_const_iterator const_iterator;
+
+	///----------------------///
+	/// end iterator classes ///
+	///----------------------///
+
+	//! Default constructor
+	ustring16()
+	: array(0), allocated(1), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+		array = allocator.allocate(1); // new u16[1];
+		array[0] = 0x0;
+	}
+
+
+	//! Constructor
+	ustring16(const ustring16<TAlloc>& other)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+		*this = other;
+	}
+
+
+	//! Constructor from other string types
+	template <class B, class A>
+	ustring16(const string<B, A>& other)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+		*this = other;
+	}
+
+
+#ifndef USTRING_NO_STL
+	//! Constructor from std::string
+	template <class B, class A, typename Alloc>
+	ustring16(const std::basic_string<B, A, Alloc>& other)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+		*this = other.c_str();
+	}
+
+
+	//! Constructor from iterator.
+	template <typename Itr>
+	ustring16(Itr first, Itr last)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+		reserve(std::distance(first, last));
+		array[used] = 0;
+
+		for (; first != last; ++first)
+			append((uchar32_t)*first);
+	}
+#endif
+
+
+#ifndef USTRING_CPP0X_NEWLITERALS
+	//! Constructor for copying a character string from a pointer.
+	ustring16(const char* const c)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		loadDataStream(c, strlen(c));
+		//append((uchar8_t*)c);
+	}
+
+
+	//! Constructor for copying a character string from a pointer with a given length.
+	ustring16(const char* const c, u32 length)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		loadDataStream(c, length);
+	}
+#endif
+
+
+	//! Constructor for copying a UTF-8 string from a pointer.
+	ustring16(const uchar8_t* const c)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		append(c);
+	}
+
+
+	//! Constructor for copying a UTF-8 string from a single char.
+	ustring16(const char c)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		append((uchar32_t)c);
+	}
+
+
+	//! Constructor for copying a UTF-8 string from a pointer with a given length.
+	ustring16(const uchar8_t* const c, u32 length)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		append(c, length);
+	}
+
+
+	//! Constructor for copying a UTF-16 string from a pointer.
+	ustring16(const uchar16_t* const c)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		append(c);
+	}
+
+
+	//! Constructor for copying a UTF-16 string from a pointer with a given length
+	ustring16(const uchar16_t* const c, u32 length)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		append(c, length);
+	}
+
+
+	//! Constructor for copying a UTF-32 string from a pointer.
+	ustring16(const uchar32_t* const c)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		append(c);
+	}
+
+
+	//! Constructor for copying a UTF-32 from a pointer with a given length.
+	ustring16(const uchar32_t* const c, u32 length)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		append(c, length);
+	}
+
+
+	//! Constructor for copying a wchar_t string from a pointer.
+	ustring16(const wchar_t* const c)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		if (sizeof(wchar_t) == 4)
+			append(reinterpret_cast<const uchar32_t* const>(c));
+		else if (sizeof(wchar_t) == 2)
+			append(reinterpret_cast<const uchar16_t* const>(c));
+		else if (sizeof(wchar_t) == 1)
+			append(reinterpret_cast<const uchar8_t* const>(c));
+	}
+
+
+	//! Constructor for copying a wchar_t string from a pointer with a given length.
+	ustring16(const wchar_t* const c, u32 length)
+	: array(0), allocated(0), used(0)
+	{
+#if __BIG_ENDIAN__
+		encoding = unicode::EUTFE_UTF16_BE;
+#else
+		encoding = unicode::EUTFE_UTF16_LE;
+#endif
+
+		if (sizeof(wchar_t) == 4)
+			append(reinterpret_cast<const uchar32_t* const>(c), length);
+		else if (sizeof(wchar_t) == 2)
+			append(reinterpret_cast<const uchar16_t* const>(c), length);
+		else if (sizeof(wchar_t) == 1)
+			append(reinterpret_cast<const uchar8_t* const>(c), length);
+	}
+
+
+#ifdef USTRING_CPP0X
+	//! Constructor for moving a ustring16
+	ustring16(ustring16<TAlloc>&& other)
+	: array(other.array), encoding(other.encoding), allocated(other.allocated), used(other.used)
+	{
+		//std::cout << "MOVE constructor" << std::endl;
+		other.array = 0;
+		other.allocated = 0;
+		other.used = 0;
+	}
+#endif
+
+
+	//! Destructor
+	~ustring16()
+	{
+		allocator.deallocate(array); // delete [] array;
+	}
+
+
+	//! Assignment operator
+	ustring16& operator=(const ustring16<TAlloc>& other)
+	{
+		if (this == &other)
+			return *this;
+
+		used = other.size_raw();
+		if (used >= allocated)
+		{
+			allocator.deallocate(array); // delete [] array;
+			allocated = used + 1;
+			array = allocator.allocate(used + 1); //new u16[used];
+		}
+
+		const uchar16_t* p = other.c_str();
+		for (u32 i=0; i<=used; ++i, ++p)
+			array[i] = *p;
+
+		array[used] = 0;
+
+		// Validate our new UTF-16 string.
+		validate();
+
+		return *this;
+	}
+
+
+#ifdef USTRING_CPP0X
+	//! Move assignment operator
+	ustring16& operator=(ustring16<TAlloc>&& other)
+	{
+		if (this != &other)
+		{
+			//std::cout << "MOVE operator=" << std::endl;
+			allocator.deallocate(array);
+
+			array = other.array;
+			allocated = other.allocated;
+			encoding = other.encoding;
+			used = other.used;
+			other.array = 0;
+			other.used = 0;
+		}
+		return *this;
+	}
+#endif
+
+
+	//! Assignment operator for other string types
+	template <class B, class A>
+	ustring16<TAlloc>& operator=(const string<B, A>& other)
+	{
+		*this = other.c_str();
+		return *this;
+	}
+
+
+	//! Assignment operator for UTF-8 strings
+	ustring16<TAlloc>& operator=(const uchar8_t* const c)
+	{
+		if (!array)
+		{
+			array = allocator.allocate(1); //new u16[1];
+			allocated = 1;
+		}
+		used = 0;
+		array[used] = 0x0;
+		if (!c) return *this;
+
+		//! Append our string now.
+		append(c);
+		return *this;
+	}
+
+
+	//! Assignment operator for UTF-16 strings
+	ustring16<TAlloc>& operator=(const uchar16_t* const c)
+	{
+		if (!array)
+		{
+			array = allocator.allocate(1); //new u16[1];
+			allocated = 1;
+		}
+		used = 0;
+		array[used] = 0x0;
+		if (!c) return *this;
+
+		//! Append our string now.
+		append(c);
+		return *this;
+	}
+
+
+	//! Assignment operator for UTF-32 strings
+	ustring16<TAlloc>& operator=(const uchar32_t* const c)
+	{
+		if (!array)
+		{
+			array = allocator.allocate(1); //new u16[1];
+			allocated = 1;
+		}
+		used = 0;
+		array[used] = 0x0;
+		if (!c) return *this;
+
+		//! Append our string now.
+		append(c);
+		return *this;
+	}
+
+
+	//! Assignment operator for wchar_t strings.
+	/** Note that this assumes that a correct unicode string is stored in the wchar_t string.
+		Since wchar_t changes depending on its platform, it could either be a UTF-8, -16, or -32 string.
+		This function assumes you are storing the correct unicode encoding inside the wchar_t string. **/
+	ustring16<TAlloc>& operator=(const wchar_t* const c)
+	{
+		if (sizeof(wchar_t) == 4)
+			*this = reinterpret_cast<const uchar32_t* const>(c);
+		else if (sizeof(wchar_t) == 2)
+			*this = reinterpret_cast<const uchar16_t* const>(c);
+		else if (sizeof(wchar_t) == 1)
+			*this = reinterpret_cast<const uchar8_t* const>(c);
+
+		return *this;
+	}
+
+
+	//! Assignment operator for other strings.
+	/** Note that this assumes that a correct unicode string is stored in the string. **/
+	template <class B>
+	ustring16<TAlloc>& operator=(const B* const c)
+	{
+		if (sizeof(B) == 4)
+			*this = reinterpret_cast<const uchar32_t* const>(c);
+		else if (sizeof(B) == 2)
+			*this = reinterpret_cast<const uchar16_t* const>(c);
+		else if (sizeof(B) == 1)
+			*this = reinterpret_cast<const uchar8_t* const>(c);
+
+		return *this;
+	}
+
+
+	//! Direct access operator
+	access operator [](const u32 index)
+	{
+		_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
+		iterator iter(*this, index);
+		return iter.operator*();
+	}
+
+
+	//! Direct access operator
+	const access operator [](const u32 index) const
+	{
+		_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
+		const_iterator iter(*this, index);
+		return iter.operator*();
+	}
+
+
+	//! Equality operator
+	bool operator ==(const uchar16_t* const str) const
+	{
+		if (!str)
+			return false;
+
+		u32 i;
+		for(i=0; array[i] && str[i]; ++i)
+			if (array[i] != str[i])
+				return false;
+
+		return !array[i] && !str[i];
+	}
+
+
+	//! Equality operator
+	bool operator ==(const ustring16<TAlloc>& other) const
+	{
+		for(u32 i=0; array[i] && other.array[i]; ++i)
+			if (array[i] != other.array[i])
+				return false;
+
+		return used == other.used;
+	}
+
+
+	//! Is smaller comparator
+	bool operator <(const ustring16<TAlloc>& other) const
+	{
+		for(u32 i=0; array[i] && other.array[i]; ++i)
+		{
+			s32 diff = array[i] - other.array[i];
+			if ( diff )
+				return diff < 0;
+		}
+
+		return used < other.used;
+	}
+
+
+	//! Inequality operator
+	bool operator !=(const uchar16_t* const str) const
+	{
+		return !(*this == str);
+	}
+
+
+	//! Inequality operator
+	bool operator !=(const ustring16<TAlloc>& other) const
+	{
+		return !(*this == other);
+	}
+
+
+	//! Returns the length of a ustring16 in full characters.
+	//! \return Length of a ustring16 in full characters.
+	u32 size() const
+	{
+		const_iterator i(*this, 0);
+		u32 pos = 0;
+		while (!i.atEnd())
+		{
+			++i;
+			++pos;
+		}
+		return pos;
+	}
+
+
+	//! Informs if the ustring is empty or not.
+	//! \return True if the ustring is empty, false if not.
+	bool empty() const
+	{
+		return (size_raw() == 0);
+	}
+
+
+	//! Returns a pointer to the raw UTF-16 string data.
+	//! \return pointer to C-style NUL terminated array of UTF-16 code points.
+	const uchar16_t* c_str() const
+	{
+		return array;
+	}
+
+
+	//! Compares the first n characters of this string with another.
+	//! \param other Other string to compare to.
+	//! \param n Number of characters to compare.
+	//! \return True if the n first characters of both strings are equal.
+	bool equalsn(const ustring16<TAlloc>& other, u32 n) const
+	{
+		u32 i;
+		const uchar16_t* oa = other.c_str();
+		for(i=0; array[i] && oa[i] && i < n; ++i)
+			if (array[i] != oa[i])
+				return false;
+
+		// if one (or both) of the strings was smaller then they
+		// are only equal if they have the same length
+		return (i == n) || (used == other.used);
+	}
+
+
+	//! Compares the first n characters of this string with another.
+	//! \param str Other string to compare to.
+	//! \param n Number of characters to compare.
+	//! \return True if the n first characters of both strings are equal.
+	bool equalsn(const uchar16_t* const str, u32 n) const
+	{
+		if (!str)
+			return false;
+		u32 i;
+		for(i=0; array[i] && str[i] && i < n; ++i)
+			if (array[i] != str[i])
+				return false;
+
+		// if one (or both) of the strings was smaller then they
+		// are only equal if they have the same length
+		return (i == n) || (array[i] == 0 && str[i] == 0);
+	}
+
+
+	//! Appends a character to this ustring16
+	//! \param character The character to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& append(uchar32_t character)
+	{
+		if (used + 2 >= allocated)
+			reallocate(used + 2);
+
+		if (character > 0xFFFF)
+		{
+			used += 2;
+
+			// character will be multibyte, so split it up into a surrogate pair.
+			uchar16_t x = static_cast<uchar16_t>(character);
+			uchar16_t vh = UTF16_HI_SURROGATE | ((((character >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
+			uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
+			array[used-2] = vh;
+			array[used-1] = vl;
+		}
+		else
+		{
+			++used;
+			array[used-1] = character;
+		}
+		array[used] = 0;
+
+		return *this;
+	}
+
+
+	//! Appends a UTF-8 string to this ustring16
+	//! \param other The UTF-8 string to append.
+	//! \param length The length of the string to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& append(const uchar8_t* const other, u32 length=0xffffffff)
+	{
+		if (!other)
+			return *this;
+
+		// Determine if the string is long enough for a BOM.
+		u32 len = 0;
+		const uchar8_t* p = other;
+		do
+		{
+			++len;
+		} while (*p++ && len < unicode::BOM_ENCODE_UTF8_LEN);
+
+		// Check for BOM.
+		unicode::EUTF_ENCODE c_bom = unicode::EUTFE_NONE;
+		if (len == unicode::BOM_ENCODE_UTF8_LEN)
+		{
+			if (memcmp(other, unicode::BOM_ENCODE_UTF8, unicode::BOM_ENCODE_UTF8_LEN) == 0)
+				c_bom = unicode::EUTFE_UTF8;
+		}
+
+		// If a BOM was found, don't include it in the string.
+		const uchar8_t* c2 = other;
+		if (c_bom != unicode::EUTFE_NONE)
+		{
+			c2 = other + unicode::BOM_UTF8_LEN;
+			length -= unicode::BOM_UTF8_LEN;
+		}
+
+		// Calculate the size of the string to read in.
+		len = 0;
+		p = c2;
+		do
+		{
+			++len;
+		} while(*p++ && len < length);
+		if (len > length)
+			len = length;
+
+		// If we need to grow the array, do it now.
+		if (used + len >= allocated)
+			reallocate(used + (len * 2));
+		u32 start = used;
+
+		// Convert UTF-8 to UTF-16.
+		u32 pos = start;
+		for (u32 l = 0; l<len;)
+		{
+			++used;
+			if (((c2[l] >> 6) & 0x03) == 0x02)
+			{	// Invalid continuation byte.
+				array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+				++l;
+			}
+			else if (c2[l] == 0xC0 || c2[l] == 0xC1)
+			{	// Invalid byte - overlong encoding.
+				array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+				++l;
+			}
+			else if ((c2[l] & 0xF8) == 0xF0)
+			{	// 4 bytes UTF-8, 2 bytes UTF-16.
+				// Check for a full string.
+				if ((l + 3) >= len)
+				{
+					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+					l += 3;
+					break;
+				}
+
+				// Validate.
+				bool valid = true;
+				u8 l2 = 0;
+				if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
+				if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
+				if (valid && (((c2[l+3] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
+				if (!valid)
+				{
+					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+					l += l2;
+					continue;
+				}
+
+				// Decode.
+				uchar8_t b1 = ((c2[l] & 0x7) << 2) | ((c2[l+1] >> 4) & 0x3);
+				uchar8_t b2 = ((c2[l+1] & 0xF) << 4) | ((c2[l+2] >> 2) & 0xF);
+				uchar8_t b3 = ((c2[l+2] & 0x3) << 6) | (c2[l+3] & 0x3F);
+				uchar32_t v = b3 | ((uchar32_t)b2 << 8) | ((uchar32_t)b1 << 16);
+
+				// Split v up into a surrogate pair.
+				uchar16_t x = static_cast<uchar16_t>(v);
+				uchar16_t vh = UTF16_HI_SURROGATE | ((((v >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
+				uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
+
+				array[pos++] = vh;
+				array[pos++] = vl;
+				l += 4;
+				++used;		// Using two shorts this time, so increase used by 1.
+			}
+			else if ((c2[l] & 0xF0) == 0xE0)
+			{	// 3 bytes UTF-8, 1 byte UTF-16.
+				// Check for a full string.
+				if ((l + 2) >= len)
+				{
+					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+					l += 2;
+					break;
+				}
+
+				// Validate.
+				bool valid = true;
+				u8 l2 = 0;
+				if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
+				if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
+				if (!valid)
+				{
+					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+					l += l2;
+					continue;
+				}
+
+				// Decode.
+				uchar8_t b1 = ((c2[l] & 0xF) << 4) | ((c2[l+1] >> 2) & 0xF);
+				uchar8_t b2 = ((c2[l+1] & 0x3) << 6) | (c2[l+2] & 0x3F);
+				uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
+				array[pos++] = ch;
+				l += 3;
+			}
+			else if ((c2[l] & 0xE0) == 0xC0)
+			{	// 2 bytes UTF-8, 1 byte UTF-16.
+				// Check for a full string.
+				if ((l + 1) >= len)
+				{
+					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+					l += 1;
+					break;
+				}
+
+				// Validate.
+				if (((c2[l+1] >> 6) & 0x03) != 0x02)
+				{
+					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+					++l;
+					continue;
+				}
+
+				// Decode.
+				uchar8_t b1 = (c2[l] >> 2) & 0x7;
+				uchar8_t b2 = ((c2[l] & 0x3) << 6) | (c2[l+1] & 0x3F);
+				uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
+				array[pos++] = ch;
+				l += 2;
+			}
+			else
+			{	// 1 byte UTF-8, 1 byte UTF-16.
+				// Validate.
+				if (c2[l] > 0x7F)
+				{	// Values above 0xF4 are restricted and aren't used.  By now, anything above 0x7F is invalid.
+					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+				}
+				else array[pos++] = static_cast<uchar16_t>(c2[l]);
+				++l;
+			}
+		}
+		array[used] = 0;
+
+		// Validate our new UTF-16 string.
+		validate();
+
+		return *this;
+	}
+
+
+	//! Appends a UTF-16 string to this ustring16
+	//! \param other The UTF-16 string to append.
+	//! \param length The length of the string to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& append(const uchar16_t* const other, u32 length=0xffffffff)
+	{
+		if (!other)
+			return *this;
+
+		// Determine if the string is long enough for a BOM.
+		u32 len = 0;
+		const uchar16_t* p = other;
+		do
+		{
+			++len;
+		} while (*p++ && len < unicode::BOM_ENCODE_UTF16_LEN);
+
+		// Check for the BOM to determine the string's endianness.
+		unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
+		if (memcmp(other, unicode::BOM_ENCODE_UTF16_LE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
+			c_end = unicode::EUTFEE_LITTLE;
+		else if (memcmp(other, unicode::BOM_ENCODE_UTF16_BE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
+			c_end = unicode::EUTFEE_BIG;
+
+		// If a BOM was found, don't include it in the string.
+		const uchar16_t* c2 = other;
+		if (c_end != unicode::EUTFEE_NATIVE)
+		{
+			c2 = other + unicode::BOM_UTF16_LEN;
+			length -= unicode::BOM_UTF16_LEN;
+		}
+
+		// Calculate the size of the string to read in.
+		len = 0;
+		p = c2;
+		do
+		{
+			++len;
+		} while(*p++ && len < length);
+		if (len > length)
+			len = length;
+
+		// If we need to grow the size of the array, do it now.
+		if (used + len >= allocated)
+			reallocate(used + (len * 2));
+		u32 start = used;
+		used += len;
+
+		// Copy the string now.
+		unicode::EUTF_ENDIAN m_end = getEndianness();
+		for (u32 l = start; l < start + len; ++l)
+		{
+			array[l] = (uchar16_t)c2[l];
+			if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
+				array[l] = unicode::swapEndian16(array[l]);
+		}
+
+		array[used] = 0;
+
+		// Validate our new UTF-16 string.
+		validate();
+		return *this;
+	}
+
+
+	//! Appends a UTF-32 string to this ustring16
+	//! \param other The UTF-32 string to append.
+	//! \param length The length of the string to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& append(const uchar32_t* const other, u32 length=0xffffffff)
+	{
+		if (!other)
+			return *this;
+
+		// Check for the BOM to determine the string's endianness.
+		unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
+		if (memcmp(other, unicode::BOM_ENCODE_UTF32_LE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
+			c_end = unicode::EUTFEE_LITTLE;
+		else if (memcmp(other, unicode::BOM_ENCODE_UTF32_BE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
+			c_end = unicode::EUTFEE_BIG;
+
+		// If a BOM was found, don't include it in the string.
+		const uchar32_t* c2 = other;
+		if (c_end != unicode::EUTFEE_NATIVE)
+		{
+			c2 = other + unicode::BOM_UTF32_LEN;
+			length -= unicode::BOM_UTF32_LEN;
+		}
+
+		// Calculate the size of the string to read in.
+		u32 len = 0;
+		const uchar32_t* p = c2;
+		do
+		{
+			++len;
+		} while(*p++ && len < length);
+		if (len > length)
+			len = length;
+
+		// If we need to grow the size of the array, do it now.
+		// In case all of the UTF-32 string is split into surrogate pairs, do len * 2.
+		if (used + (len * 2) >= allocated)
+			reallocate(used + ((len * 2) * 2));
+		u32 start = used;
+
+		// Convert UTF-32 to UTF-16.
+		unicode::EUTF_ENDIAN m_end = getEndianness();
+		u32 pos = start;
+		for (u32 l = 0; l<len; ++l)
+		{
+			++used;
+
+			uchar32_t ch = c2[l];
+			if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
+				ch = unicode::swapEndian32(ch);
+
+			if (ch > 0xFFFF)
+			{
+				// Split ch up into a surrogate pair as it is over 16 bits long.
+				uchar16_t x = static_cast<uchar16_t>(ch);
+				uchar16_t vh = UTF16_HI_SURROGATE | ((((ch >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
+				uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
+				array[pos++] = vh;
+				array[pos++] = vl;
+				++used;		// Using two shorts, so increased used again.
+			}
+			else if (ch >= 0xD800 && ch <= 0xDFFF)
+			{
+				// Between possible UTF-16 surrogates (invalid!)
+				array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
+			}
+			else array[pos++] = static_cast<uchar16_t>(ch);
+		}
+		array[used] = 0;
+
+		// Validate our new UTF-16 string.
+		validate();
+
+		return *this;
+	}
+
+
+	//! Appends a ustring16 to this ustring16
+	//! \param other The string to append to this one.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& append(const ustring16<TAlloc>& other)
+	{
+		const uchar16_t* oa = other.c_str();
+
+		u32 len = other.size_raw();
+
+		if (used + len >= allocated)
+			reallocate(used + len);
+
+		for (u32 l=0; l<len; ++l)
+			array[used+l] = oa[l];
+
+		used += len;
+		array[used] = 0;
+
+		return *this;
+	}
+
+
+	//! Appends a certain amount of characters of a ustring16 to this ustring16.
+	//! \param other The string to append to this one.
+	//! \param length How many characters of the other string to add to this one.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& append(const ustring16<TAlloc>& other, u32 length)
+	{
+		if (other.size() == 0)
+			return *this;
+
+		if (other.size() < length)
+		{
+			append(other);
+			return *this;
+		}
+
+		if (used + length * 2 >= allocated)
+			reallocate(used + length * 2);
+
+		const_iterator iter(other, 0);
+		u32 l = length;
+		while (!iter.atEnd() && l)
+		{
+			uchar32_t c = *iter;
+			append(c);
+			++iter;
+			--l;
+		}
+
+		return *this;
+	}
+
+
+	//! Reserves some memory.
+	//! \param count The amount of characters to reserve.
+	void reserve(u32 count)
+	{
+		if (count < allocated)
+			return;
+
+		reallocate(count);
+	}
+
+
+	//! Finds first occurrence of character.
+	//! \param c The character to search for.
+	//! \return Position where the character has been found, or -1 if not found.
+	s32 findFirst(uchar32_t c) const
+	{
+		const_iterator i(*this, 0);
+
+		s32 pos = 0;
+		while (!i.atEnd())
+		{
+			uchar32_t t = *i;
+			if (c == t)
+				return pos;
+			++pos;
+			++i;
+		}
+
+		return -1;
+	}
+
+	//! Finds first occurrence of a character of a list.
+	//! \param c A list of characters to find. For example if the method should find the first occurrence of 'a' or 'b', this parameter should be "ab".
+	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
+	//! \return Position where one of the characters has been found, or -1 if not found.
+	s32 findFirstChar(const uchar32_t* const c, u32 count=1) const
+	{
+		if (!c || !count)
+			return -1;
+
+		const_iterator i(*this, 0);
+
+		s32 pos = 0;
+		while (!i.atEnd())
+		{
+			uchar32_t t = *i;
+			for (u32 j=0; j<count; ++j)
+				if (t == c[j])
+					return pos;
+			++pos;
+			++i;
+		}
+
+		return -1;
+	}
+
+
+	//! Finds first position of a character not in a given list.
+	//! \param c A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
+	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
+	//! \return Position where the character has been found, or -1 if not found.
+	s32 findFirstCharNotInList(const uchar32_t* const c, u32 count=1) const
+	{
+		if (!c || !count)
+			return -1;
+
+		const_iterator i(*this, 0);
+
+		s32 pos = 0;
+		while (!i.atEnd())
+		{
+			uchar32_t t = *i;
+			u32 j;
+			for (j=0; j<count; ++j)
+				if (t == c[j])
+					break;
+
+			if (j==count)
+				return pos;
+			++pos;
+			++i;
+		}
+
+		return -1;
+	}
+
+	//! Finds last position of a character not in a given list.
+	//! \param c A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
+	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
+	//! \return Position where the character has been found, or -1 if not found.
+	s32 findLastCharNotInList(const uchar32_t* const c, u32 count=1) const
+	{
+		if (!c || !count)
+			return -1;
+
+		const_iterator i(end());
+		--i;
+
+		s32 pos = size() - 1;
+		while (!i.atStart())
+		{
+			uchar32_t t = *i;
+			u32 j;
+			for (j=0; j<count; ++j)
+				if (t == c[j])
+					break;
+
+			if (j==count)
+				return pos;
+			--pos;
+			--i;
+		}
+
+		return -1;
+	}
+
+	//! Finds next occurrence of character.
+	//! \param c The character to search for.
+	//! \param startPos The position in the string to start searching.
+	//! \return Position where the character has been found, or -1 if not found.
+	s32 findNext(uchar32_t c, u32 startPos) const
+	{
+		const_iterator i(*this, startPos);
+
+		s32 pos = startPos;
+		while (!i.atEnd())
+		{
+			uchar32_t t = *i;
+			if (t == c)
+				return pos;
+			++pos;
+			++i;
+		}
+
+		return -1;
+	}
+
+
+	//! Finds last occurrence of character.
+	//! \param c The character to search for.
+	//! \param start The start position of the reverse search ( default = -1, on end ).
+	//! \return Position where the character has been found, or -1 if not found.
+	s32 findLast(uchar32_t c, s32 start = -1) const
+	{
+		u32 s = size();
+		start = core::clamp ( start < 0 ? (s32)s : start, 0, (s32)s ) - 1;
+
+		const_iterator i(*this, start);
+		u32 pos = start;
+		while (!i.atStart())
+		{
+			uchar32_t t = *i;
+			if (t == c)
+				return pos;
+			--pos;
+			--i;
+		}
+
+		return -1;
+	}
+
+	//! Finds last occurrence of a character in a list.
+	//! \param c A list of strings to find. For example if the method should find the last occurrence of 'a' or 'b', this parameter should be "ab".
+	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
+	//! \return Position where one of the characters has been found, or -1 if not found.
+	s32 findLastChar(const uchar32_t* const c, u32 count=1) const
+	{
+		if (!c || !count)
+			return -1;
+
+		const_iterator i(end());
+		--i;
+
+		s32 pos = size();
+		while (!i.atStart())
+		{
+			uchar32_t t = *i;
+			for (u32 j=0; j<count; ++j)
+				if (t == c[j])
+					return pos;
+			--pos;
+			--i;
+		}
+
+		return -1;
+	}
+
+
+	//! Finds another ustring16 in this ustring16.
+	//! \param str The string to find.
+	//! \param start The start position of the search.
+	//! \return Positions where the ustring16 has been found, or -1 if not found.
+	s32 find(const ustring16<TAlloc>& str, const u32 start = 0) const
+	{
+		u32 my_size = size();
+		u32 their_size = str.size();
+
+		if (their_size == 0 || my_size - start < their_size)
+			return -1;
+
+		const_iterator i(*this, start);
+
+		s32 pos = start;
+		while (!i.atEnd())
+		{
+			const_iterator i2(i);
+			const_iterator j(str, 0);
+			uchar32_t t1 = (uchar32_t)*i2;
+			uchar32_t t2 = (uchar32_t)*j;
+			while (t1 == t2)
+			{
+				++i2;
+				++j;
+				if (j.atEnd())
+					return pos;
+				t1 = (uchar32_t)*i2;
+				t2 = (uchar32_t)*j;
+			}
+			++i;
+			++pos;
+		}
+
+		return -1;
+	}
+
+
+	//! Finds another ustring16 in this ustring16.
+	//! \param str The string to find.
+	//! \param start The start position of the search.
+	//! \return Positions where the string has been found, or -1 if not found.
+	s32 find_raw(const ustring16<TAlloc>& str, const u32 start = 0) const
+	{
+		const uchar16_t* data = str.c_str();
+		if (data && *data)
+		{
+			u32 len = 0;
+
+			while (data[len])
+				++len;
+
+			if (len > used)
+				return -1;
+
+			for (u32 i=start; i<=used-len; ++i)
+			{
+				u32 j=0;
+
+				while(data[j] && array[i+j] == data[j])
+					++j;
+
+				if (!data[j])
+					return i;
+			}
+		}
+
+		return -1;
+	}
+
+
+	//! Returns a substring.
+	//! \param begin: Start of substring.
+	//! \param length: Length of substring.
+	//! \return A reference to our current string.
+	ustring16<TAlloc> subString(u32 begin, s32 length) const
+	{
+		u32 len = size();
+		// if start after ustring16
+		// or no proper substring length
+		if ((length <= 0) || (begin>=len))
+			return ustring16<TAlloc>("");
+		// clamp length to maximal value
+		if ((length+begin) > len)
+			length = len-begin;
+
+		ustring16<TAlloc> o;
+		o.reserve((length+1) * 2);
+
+		const_iterator i(*this, begin);
+		while (!i.atEnd() && length)
+		{
+			o.append(*i);
+			++i;
+			--length;
+		}
+
+		return o;
+	}
+
+
+	//! Appends a character to this ustring16.
+	//! \param c Character to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (char c)
+	{
+		append((uchar32_t)c);
+		return *this;
+	}
+
+
+	//! Appends a character to this ustring16.
+	//! \param c Character to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (uchar32_t c)
+	{
+		append(c);
+		return *this;
+	}
+
+
+	//! Appends a number to this ustring16.
+	//! \param c Number to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (short c)
+	{
+		append(core::stringc(c));
+		return *this;
+	}
+
+
+	//! Appends a number to this ustring16.
+	//! \param c Number to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (unsigned short c)
+	{
+		append(core::stringc(c));
+		return *this;
+	}
+
+
+#ifdef USTRING_CPP0X_NEWLITERALS
+	//! Appends a number to this ustring16.
+	//! \param c Number to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (int c)
+	{
+		append(core::stringc(c));
+		return *this;
+	}
+
+
+	//! Appends a number to this ustring16.
+	//! \param c Number to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (unsigned int c)
+	{
+		append(core::stringc(c));
+		return *this;
+	}
+#endif
+
+	
+	//! Appends a number to this ustring16.
+	//! \param c Number to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (long c)
+	{
+		append(core::stringc(c));
+		return *this;
+	}
+
+
+	//! Appends a number to this ustring16.
+	//! \param c Number to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (unsigned long c)
+	{
+		append(core::stringc(c));
+		return *this;
+	}
+
+
+	//! Appends a number to this ustring16.
+	//! \param c Number to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (double c)
+	{
+		append(core::stringc(c));
+		return *this;
+	}
+
+
+	//! Appends a char ustring16 to this ustring16.
+	//! \param c Char ustring16 to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (const uchar16_t* const c)
+	{
+		append(c);
+		return *this;
+	}
+
+
+	//! Appends a ustring16 to this ustring16.
+	//! \param other ustring16 to append.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& operator += (const ustring16<TAlloc>& other)
+	{
+		append(other);
+		return *this;
+	}
+
+
+	//! Replaces all characters of a given type with another one.
+	//! \param toReplace Character to replace.
+	//! \param replaceWith Character replacing the old one.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& replace(uchar32_t toReplace, uchar32_t replaceWith)
+	{
+		iterator i(*this, 0);
+		while (!i.atEnd())
+		{
+			typename ustring16<TAlloc>::access a = *i;
+			if ((uchar32_t)a == toReplace)
+				a = replaceWith;
+			++i;
+		}
+		return *this;
+	}
+
+
+	//! Replaces all instances of a string with another one.
+	//! \param toReplace The string to replace.
+	//! \param replaceWith The string replacing the old one.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& replace(const ustring16<TAlloc>& toReplace, const ustring16<TAlloc>& replaceWith)
+	{
+		if (toReplace.size() == 0)
+			return *this;
+
+		const uchar16_t* other = toReplace.c_str();
+		const uchar16_t* replace = replaceWith.c_str();
+		const u32 other_size = toReplace.size_raw();
+		const u32 replace_size = replaceWith.size_raw();
+
+		// Determine the delta.  The algorithm will change depending on the delta.
+		s32 delta = replace_size - other_size;
+
+		// A character for character replace.  The string will not shrink or grow.
+		if (delta == 0)
+		{
+			s32 pos = 0;
+			while ((pos = find_raw(other, pos)) != -1)
+			{
+				for (u32 i = 0; i < replace_size; ++i)
+					array[pos + i] = replace[i];
+				++pos;
+			}
+			return *this;
+		}
+
+		// We are going to be removing some characters.  The string will shrink.
+		if (delta < 0)
+		{
+			u32 i = 0;
+			for (u32 pos = 0; pos <= used; ++i, ++pos)
+			{
+				// Is this potentially a match?
+				if (array[pos] == *other)
+				{
+					// Check to see if we have a match.
+					u32 j;
+					for (j = 0; j < other_size; ++j)
+					{
+						if (array[pos + j] != other[j])
+							break;
+					}
+
+					// If we have a match, replace characters.
+					if (j == other_size)
+					{
+						for (j = 0; j < replace_size; ++j)
+							array[i + j] = replace[j];
+						i += replace_size - 1;
+						pos += other_size - 1;
+						continue;
+					}
+				}
+
+				// No match found, just copy characters.
+				array[i - 1] = array[pos];
+			}
+			array[i] = 0;
+			used = i;
+
+			return *this;
+		}
+
+		// We are going to be adding characters, so the string size will increase.
+		// Count the number of times toReplace exists in the string so we can allocate the new size.
+		u32 find_count = 0;
+		s32 pos = 0;
+		while ((pos = find_raw(other, pos)) != -1)
+		{
+			++find_count;
+			++pos;
+		}
+
+		// Re-allocate the string now, if needed.
+		u32 len = delta * find_count;
+		if (used + len >= allocated)
+			reallocate(used + len);
+
+		// Start replacing.
+		pos = 0;
+		while ((pos = find_raw(other, pos)) != -1)
+		{
+			uchar16_t* start = array + pos + other_size - 1;
+			uchar16_t* ptr   = array + used;
+			uchar16_t* end   = array + used + delta;
+
+			// Shift characters to make room for the string.
+			while (ptr != start)
+			{
+				*end = *ptr;
+				--ptr;
+				--end;
+			}
+
+			// Add the new string now.
+			for (u32 i = 0; i < replace_size; ++i)
+				array[pos + i] = replace[i];
+
+			pos += replace_size;
+			used += delta;
+		}
+
+		// Terminate the string and return ourself.
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Removes characters from a ustring16..
+	//! \param c The character to remove.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& remove(uchar32_t c)
+	{
+		u32 pos = 0;
+		u32 found = 0;
+		u32 len = (c > 0xFFFF ? 2 : 1);		// Remove characters equal to the size of c as a UTF-16 character.
+		for (u32 i=0; i<=used; ++i)
+		{
+			uchar32_t uc32 = 0;
+			if (!UTF16_IS_SURROGATE_HI(array[i]))
+				uc32 |= array[i];
+			else if (i + 1 <= used)
+			{
+				// Convert the surrogate pair into a single UTF-32 character.
+				uc32 = unicode::toUTF32(array[i], array[i + 1]);
+			}
+			u32 len2 = (uc32 > 0xFFFF ? 2 : 1);
+
+			if (uc32 == c)
+			{
+				found += len;
+				continue;
+			}
+
+			array[pos++] = array[i];
+			if (len2 == 2)
+				array[pos++] = array[++i];
+		}
+		used -= found;
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Removes a ustring16 from the ustring16.
+	//! \param toRemove The string to remove.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& remove(const ustring16<TAlloc>& toRemove)
+	{
+		u32 size = toRemove.size_raw();
+		if (size == 0) return *this;
+
+		const uchar16_t* tra = toRemove.c_str();
+		u32 pos = 0;
+		u32 found = 0;
+		for (u32 i=0; i<=used; ++i)
+		{
+			u32 j = 0;
+			while (j < size)
+			{
+				if (array[i + j] != tra[j])
+					break;
+				++j;
+			}
+			if (j == size)
+			{
+				found += size;
+				i += size - 1;
+				continue;
+			}
+
+			array[pos++] = array[i];
+		}
+		used -= found;
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Removes characters from the ustring16.
+	//! \param characters The characters to remove.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& removeChars(const ustring16<TAlloc>& characters)
+	{
+		if (characters.size_raw() == 0)
+			return *this;
+
+		u32 pos = 0;
+		u32 found = 0;
+		const_iterator iter(characters);
+		for (u32 i=0; i<=used; ++i)
+		{
+			uchar32_t uc32 = 0;
+			if (!UTF16_IS_SURROGATE_HI(array[i]))
+				uc32 |= array[i];
+			else if (i + 1 <= used)
+			{
+				// Convert the surrogate pair into a single UTF-32 character.
+				uc32 = unicode::toUTF32(array[i], array[i+1]);
+			}
+			u32 len2 = (uc32 > 0xFFFF ? 2 : 1);
+
+			bool cont = false;
+			iter.toStart();
+			while (!iter.atEnd())
+			{
+				uchar32_t c = *iter;
+				if (uc32 == c)
+				{
+					found += (c > 0xFFFF ? 2 : 1);		// Remove characters equal to the size of c as a UTF-16 character.
+					++i;
+					cont = true;
+					break;
+				}
+				++iter;
+			}
+			if (cont) continue;
+
+			array[pos++] = array[i];
+			if (len2 == 2)
+				array[pos++] = array[++i];
+		}
+		used -= found;
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Trims the ustring16.
+	//! Removes the specified characters (by default, Latin-1 whitespace) from the begining and the end of the ustring16.
+	//! \param whitespace The characters that are to be considered as whitespace.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& trim(const ustring16<TAlloc>& whitespace = " \t\n\r")
+	{
+		core::array<uchar32_t> utf32white = whitespace.toUTF32();
+
+		// find start and end of the substring without the specified characters
+		const s32 begin = findFirstCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
+		if (begin == -1)
+			return (*this="");
+
+		const s32 end = findLastCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
+
+		return (*this = subString(begin, (end +1) - begin));
+	}
+
+
+	//! Erases a character from the ustring16.
+	//! May be slow, because all elements following after the erased element have to be copied.
+	//! \param index Index of element to be erased.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& erase(u32 index)
+	{
+		_IRR_DEBUG_BREAK_IF(index>used) // access violation
+
+		iterator i(*this, index);
+
+		uchar32_t t = *i;
+		u32 len = (t > 0xFFFF ? 2 : 1);
+
+		for (u32 j = static_cast<u32>(i.getPos()) + len; j <= used; ++j)
+			array[j - len] = array[j];
+
+		used -= len;
+		array[used] = 0;
+
+		return *this;
+	}
+
+
+	//! Validate the existing ustring16, checking for valid surrogate pairs and checking for proper termination.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& validate()
+	{
+		// Validate all unicode characters.
+		for (u32 i=0; i<allocated; ++i)
+		{
+			// Terminate on existing null.
+			if (array[i] == 0)
+			{
+				used = i;
+				return *this;
+			}
+			if (UTF16_IS_SURROGATE(array[i]))
+			{
+				if (((i+1) >= allocated) || UTF16_IS_SURROGATE_LO(array[i]))
+					array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
+				else if (UTF16_IS_SURROGATE_HI(array[i]) && !UTF16_IS_SURROGATE_LO(array[i+1]))
+					array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
+				++i;
+			}
+			if (array[i] >= 0xFDD0 && array[i] <= 0xFDEF)
+				array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
+		}
+
+		// terminate
+		used = 0;
+		if (allocated > 0)
+		{
+			used = allocated - 1;
+			array[used] = 0;
+		}
+		return *this;
+	}
+
+
+	//! Gets the last char of the ustring16, or 0.
+	//! \return The last char of the ustring16, or 0.
+	uchar32_t lastChar() const
+	{
+		if (used < 1)
+			return 0;
+
+		if (UTF16_IS_SURROGATE_LO(array[used-1]))
+		{
+			// Make sure we have a paired surrogate.
+			if (used < 2)
+				return 0;
+
+			// Check for an invalid surrogate.
+			if (!UTF16_IS_SURROGATE_HI(array[used-2]))
+				return 0;
+
+			// Convert the surrogate pair into a single UTF-32 character.
+			return unicode::toUTF32(array[used-2], array[used-1]);
+		}
+		else
+		{
+			return array[used-1];
+		}
+	}
+
+
+	//! Split the ustring16 into parts.
+	/** This method will split a ustring16 at certain delimiter characters
+	into the container passed in as reference. The type of the container
+	has to be given as template parameter. It must provide a push_back and
+	a size method.
+	\param ret The result container
+	\param c C-style ustring16 of delimiter characters
+	\param count Number of delimiter characters
+	\param ignoreEmptyTokens Flag to avoid empty substrings in the result
+	container. If two delimiters occur without a character in between, an
+	empty substring would be placed in the result. If this flag is set,
+	only non-empty strings are stored.
+	\param keepSeparators Flag which allows to add the separator to the
+	result ustring16. If this flag is true, the concatenation of the
+	substrings results in the original ustring16. Otherwise, only the
+	characters between the delimiters are returned.
+	\return The number of resulting substrings
+	*/
+	template<class container>
+	u32 split(container& ret, const uchar32_t* const c, u32 count=1, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
+	{
+		if (!c)
+			return 0;
+
+		const_iterator i(*this);
+		const u32 oldSize=ret.size();
+		u32 pos = 0;
+		u32 lastpos = 0;
+		u32 lastpospos = 0;
+		bool lastWasSeparator = false;
+		while (!i.atEnd())
+		{
+			uchar32_t ch = *i;
+			bool foundSeparator = false;
+			for (u32 j=0; j<count; ++j)
+			{
+				if (ch == c[j])
+				{
+					if ((!ignoreEmptyTokens || pos - lastpos != 0) &&
+							!lastWasSeparator)
+					ret.push_back(ustring16<TAlloc>(&array[lastpospos], pos - lastpos));
+					foundSeparator = true;
+					lastpos = (keepSeparators ? pos : pos + 1);
+					lastpospos = (keepSeparators ? i.getPos() : i.getPos() + 1);
+					break;
+				}
+			}
+			lastWasSeparator = foundSeparator;
+			++pos;
+			++i;
+		}
+		u32 s = size() + 1;
+		if (s > lastpos)
+			ret.push_back(ustring16<TAlloc>(&array[lastpospos], s - lastpos));
+		return ret.size()-oldSize;
+	}
+
+
+	//! Split the ustring16 into parts.
+	/** This method will split a ustring16 at certain delimiter characters
+	into the container passed in as reference. The type of the container
+	has to be given as template parameter. It must provide a push_back and
+	a size method.
+	\param ret The result container
+	\param c A unicode string of delimiter characters
+	\param ignoreEmptyTokens Flag to avoid empty substrings in the result
+	container. If two delimiters occur without a character in between, an
+	empty substring would be placed in the result. If this flag is set,
+	only non-empty strings are stored.
+	\param keepSeparators Flag which allows to add the separator to the
+	result ustring16. If this flag is true, the concatenation of the
+	substrings results in the original ustring16. Otherwise, only the
+	characters between the delimiters are returned.
+	\return The number of resulting substrings
+	*/
+	template<class container>
+	u32 split(container& ret, const ustring16<TAlloc>& c, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
+	{
+		core::array<uchar32_t> v = c.toUTF32();
+		return split(ret, v.pointer(), v.size(), ignoreEmptyTokens, keepSeparators);
+	}
+
+
+	//! Gets the size of the allocated memory buffer for the string.
+	//! \return The size of the allocated memory buffer.
+	u32 capacity() const
+	{
+		return allocated;
+	}
+
+
+	//! Returns the raw number of UTF-16 code points in the string which includes the individual surrogates.
+	//! \return The raw number of UTF-16 code points, excluding the trialing NUL.
+	u32 size_raw() const
+	{
+		return used;
+	}
+
+
+	//! Inserts a character into the string.
+	//! \param c The character to insert.
+	//! \param pos The position to insert the character.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& insert(uchar32_t c, u32 pos)
+	{
+		u8 len = (c > 0xFFFF ? 2 : 1);
+
+		if (used + len >= allocated)
+			reallocate(used + len);
+
+		used += len;
+
+		iterator iter(*this, pos);
+		for (u32 i = used - 2; i > iter.getPos(); --i)
+			array[i] = array[i - len];
+
+		if (c > 0xFFFF)
+		{
+			// c will be multibyte, so split it up into a surrogate pair.
+			uchar16_t x = static_cast<uchar16_t>(c);
+			uchar16_t vh = UTF16_HI_SURROGATE | ((((c >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
+			uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
+			array[iter.getPos()] = vh;
+			array[iter.getPos()+1] = vl;
+		}
+		else
+		{
+			array[iter.getPos()] = static_cast<uchar16_t>(c);
+		}
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Inserts a string into the string.
+	//! \param c The string to insert.
+	//! \param pos The position to insert the string.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& insert(const ustring16<TAlloc>& c, u32 pos)
+	{
+		u32 len = c.size_raw();
+		if (len == 0) return *this;
+
+		if (used + len >= allocated)
+			reallocate(used + len);
+
+		used += len;
+
+		iterator iter(*this, pos);
+		for (u32 i = used - 2; i > iter.getPos() + len; --i)
+			array[i] = array[i - len];
+
+		const uchar16_t* s = c.c_str();
+		for (u32 i = 0; i < len; ++i)
+		{
+			array[pos++] = *s;
+			++s;
+		}
+
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Inserts a character into the string.
+	//! \param c The character to insert.
+	//! \param pos The position to insert the character.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& insert_raw(uchar16_t c, u32 pos)
+	{
+		if (used + 1 >= allocated)
+			reallocate(used + 1);
+
+		++used;
+
+		for (u32 i = used - 1; i > pos; --i)
+			array[i] = array[i - 1];
+
+		array[pos] = c;
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Removes a character from string.
+	//! \param pos Position of the character to remove.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& erase_raw(u32 pos)
+	{
+		for (u32 i=pos; i<=used; ++i)
+		{
+			array[i] = array[i + 1];
+		}
+		--used;
+		array[used] = 0;
+		return *this;
+	}
+
+
+	//! Replaces a character in the string.
+	//! \param c The new character.
+	//! \param pos The position of the character to replace.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& replace_raw(uchar16_t c, u32 pos)
+	{
+		array[pos] = c;
+		return *this;
+	}
+
+
+	//! Returns an iterator to the beginning of the string.
+	//! \return An iterator to the beginning of the string.
+	iterator begin()
+	{
+		iterator i(*this, 0);
+		return i;
+	}
+
+
+	//! Returns an iterator to the beginning of the string.
+	//! \return An iterator to the beginning of the string.
+	const_iterator begin() const
+	{
+		const_iterator i(*this, 0);
+		return i;
+	}
+
+
+	//! Returns an iterator to the beginning of the string.
+	//! \return An iterator to the beginning of the string.
+	const_iterator cbegin() const
+	{
+		const_iterator i(*this, 0);
+		return i;
+	}
+
+
+	//! Returns an iterator to the end of the string.
+	//! \return An iterator to the end of the string.
+	iterator end()
+	{
+		iterator i(*this, 0);
+		i.toEnd();
+		return i;
+	}
+
+
+	//! Returns an iterator to the end of the string.
+	//! \return An iterator to the end of the string.
+	const_iterator end() const
+	{
+		const_iterator i(*this, 0);
+		i.toEnd();
+		return i;
+	}
+
+
+	//! Returns an iterator to the end of the string.
+	//! \return An iterator to the end of the string.
+	const_iterator cend() const
+	{
+		const_iterator i(*this, 0);
+		i.toEnd();
+		return i;
+	}
+
+
+	//! Converts the string to a UTF-8 encoded string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return A string containing the UTF-8 encoded string.
+	core::string<uchar8_t> toUTF8_s(const bool addBOM = false) const
+	{
+		core::string<uchar8_t> ret;
+		ret.reserve(used * 4 + (addBOM ? unicode::BOM_UTF8_LEN : 0) + 1);
+		const_iterator iter(*this, 0);
+
+		// Add the byte order mark if the user wants it.
+		if (addBOM)
+		{
+			ret.append(unicode::BOM_ENCODE_UTF8[0]);
+			ret.append(unicode::BOM_ENCODE_UTF8[1]);
+			ret.append(unicode::BOM_ENCODE_UTF8[2]);
+		}
+
+		while (!iter.atEnd())
+		{
+			uchar32_t c = *iter;
+			if (c > 0xFFFF)
+			{	// 4 bytes
+				uchar8_t b1 = (0x1E << 3) | ((c >> 18) & 0x7);
+				uchar8_t b2 = (0x2 << 6) | ((c >> 12) & 0x3F);
+				uchar8_t b3 = (0x2 << 6) | ((c >> 6) & 0x3F);
+				uchar8_t b4 = (0x2 << 6) | (c & 0x3F);
+				ret.append(b1);
+				ret.append(b2);
+				ret.append(b3);
+				ret.append(b4);
+			}
+			else if (c > 0x7FF)
+			{	// 3 bytes
+				uchar8_t b1 = (0xE << 4) | ((c >> 12) & 0xF);
+				uchar8_t b2 = (0x2 << 6) | ((c >> 6) & 0x3F);
+				uchar8_t b3 = (0x2 << 6) | (c & 0x3F);
+				ret.append(b1);
+				ret.append(b2);
+				ret.append(b3);
+			}
+			else if (c > 0x7F)
+			{	// 2 bytes
+				uchar8_t b1 = (0x6 << 5) | ((c >> 6) & 0x1F);
+				uchar8_t b2 = (0x2 << 6) | (c & 0x3F);
+				ret.append(b1);
+				ret.append(b2);
+			}
+			else
+			{	// 1 byte
+				ret.append(static_cast<uchar8_t>(c));
+			}
+			++iter;
+		}
+		return ret;
+	}
+
+
+	//! Converts the string to a UTF-8 encoded string array.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return An array containing the UTF-8 encoded string.
+	core::array<uchar8_t> toUTF8(const bool addBOM = false) const
+	{
+		core::array<uchar8_t> ret(used * 4 + (addBOM ? unicode::BOM_UTF8_LEN : 0) + 1);
+		const_iterator iter(*this, 0);
+
+		// Add the byte order mark if the user wants it.
+		if (addBOM)
+		{
+			ret.push_back(unicode::BOM_ENCODE_UTF8[0]);
+			ret.push_back(unicode::BOM_ENCODE_UTF8[1]);
+			ret.push_back(unicode::BOM_ENCODE_UTF8[2]);
+		}
+
+		while (!iter.atEnd())
+		{
+			uchar32_t c = *iter;
+			if (c > 0xFFFF)
+			{	// 4 bytes
+				uchar8_t b1 = (0x1E << 3) | ((c >> 18) & 0x7);
+				uchar8_t b2 = (0x2 << 6) | ((c >> 12) & 0x3F);
+				uchar8_t b3 = (0x2 << 6) | ((c >> 6) & 0x3F);
+				uchar8_t b4 = (0x2 << 6) | (c & 0x3F);
+				ret.push_back(b1);
+				ret.push_back(b2);
+				ret.push_back(b3);
+				ret.push_back(b4);
+			}
+			else if (c > 0x7FF)
+			{	// 3 bytes
+				uchar8_t b1 = (0xE << 4) | ((c >> 12) & 0xF);
+				uchar8_t b2 = (0x2 << 6) | ((c >> 6) & 0x3F);
+				uchar8_t b3 = (0x2 << 6) | (c & 0x3F);
+				ret.push_back(b1);
+				ret.push_back(b2);
+				ret.push_back(b3);
+			}
+			else if (c > 0x7F)
+			{	// 2 bytes
+				uchar8_t b1 = (0x6 << 5) | ((c >> 6) & 0x1F);
+				uchar8_t b2 = (0x2 << 6) | (c & 0x3F);
+				ret.push_back(b1);
+				ret.push_back(b2);
+			}
+			else
+			{	// 1 byte
+				ret.push_back(static_cast<uchar8_t>(c));
+			}
+			++iter;
+		}
+		ret.push_back(0);
+		return ret;
+	}
+
+
+#ifdef USTRING_CPP0X_NEWLITERALS	// C++0x
+	//! Converts the string to a UTF-16 encoded string.
+	//! \param endian The desired endianness of the string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return A string containing the UTF-16 encoded string.
+	core::string<char16_t> toUTF16_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
+	{
+		core::string<char16_t> ret;
+		ret.reserve(used + (addBOM ? unicode::BOM_UTF16_LEN : 0) + 1);
+
+		// Add the BOM if specified.
+		if (addBOM)
+		{
+			if (endian == unicode::EUTFEE_NATIVE)
+				ret[0] = unicode::BOM;
+			else if (endian == unicode::EUTFEE_LITTLE)
+			{
+				uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ret.c_str());
+				*ptr8++ = unicode::BOM_ENCODE_UTF16_LE[0];
+				*ptr8 = unicode::BOM_ENCODE_UTF16_LE[1];
+			}
+			else
+			{
+				uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ret.c_str());
+				*ptr8++ = unicode::BOM_ENCODE_UTF16_BE[0];
+				*ptr8 = unicode::BOM_ENCODE_UTF16_BE[1];
+			}
+		}
+
+		ret.append(array);
+		if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
+		{
+			char16_t* ptr = ret.c_str();
+			for (u32 i = 0; i < ret.size(); ++i)
+				*ptr++ = unicode::swapEndian16(*ptr);
+		}
+		return ret;
+	}
+#endif
+
+
+	//! Converts the string to a UTF-16 encoded string array.
+	//! Unfortunately, no toUTF16_s() version exists due to limitations with Irrlicht's string class.
+	//! \param endian The desired endianness of the string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return An array containing the UTF-16 encoded string.
+	core::array<uchar16_t> toUTF16(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
+	{
+		core::array<uchar16_t> ret(used + (addBOM ? unicode::BOM_UTF16_LEN : 0) + 1);
+		uchar16_t* ptr = ret.pointer();
+
+		// Add the BOM if specified.
+		if (addBOM)
+		{
+			if (endian == unicode::EUTFEE_NATIVE)
+				*ptr = unicode::BOM;
+			else if (endian == unicode::EUTFEE_LITTLE)
+			{
+				uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ptr);
+				*ptr8++ = unicode::BOM_ENCODE_UTF16_LE[0];
+				*ptr8 = unicode::BOM_ENCODE_UTF16_LE[1];
+			}
+			else
+			{
+				uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ptr);
+				*ptr8++ = unicode::BOM_ENCODE_UTF16_BE[0];
+				*ptr8 = unicode::BOM_ENCODE_UTF16_BE[1];
+			}
+			++ptr;
+		}
+
+		memcpy((void*)ptr, (void*)array, used * sizeof(uchar16_t));
+		if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
+		{
+			for (u32 i = 0; i <= used; ++i)
+				*ptr++ = unicode::swapEndian16(*ptr);
+		}
+		ret.set_used(used + (addBOM ? unicode::BOM_UTF16_LEN : 0));
+		ret.push_back(0);
+		return ret;
+	}
+
+
+#ifdef USTRING_CPP0X_NEWLITERALS	// C++0x
+	//! Converts the string to a UTF-32 encoded string.
+	//! \param endian The desired endianness of the string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return A string containing the UTF-32 encoded string.
+	core::string<char32_t> toUTF32_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
+	{
+		core::string<char32_t> ret;
+		ret.reserve(size() + 1 + (addBOM ? unicode::BOM_UTF32_LEN : 0));
+		const_iterator iter(*this, 0);
+
+		// Add the BOM if specified.
+		if (addBOM)
+		{
+			if (endian == unicode::EUTFEE_NATIVE)
+				ret.append(unicode::BOM);
+			else
+			{
+				union
+				{
+					uchar32_t full;
+					u8 chunk[4];
+				} t;
+
+				if (endian == unicode::EUTFEE_LITTLE)
+				{
+					t.chunk[0] = unicode::BOM_ENCODE_UTF32_LE[0];
+					t.chunk[1] = unicode::BOM_ENCODE_UTF32_LE[1];
+					t.chunk[2] = unicode::BOM_ENCODE_UTF32_LE[2];
+					t.chunk[3] = unicode::BOM_ENCODE_UTF32_LE[3];
+				}
+				else
+				{
+					t.chunk[0] = unicode::BOM_ENCODE_UTF32_BE[0];
+					t.chunk[1] = unicode::BOM_ENCODE_UTF32_BE[1];
+					t.chunk[2] = unicode::BOM_ENCODE_UTF32_BE[2];
+					t.chunk[3] = unicode::BOM_ENCODE_UTF32_BE[3];
+				}
+				ret.append(t.full);
+			}
+		}
+
+		while (!iter.atEnd())
+		{
+			uchar32_t c = *iter;
+			if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
+				c = unicode::swapEndian32(c);
+			ret.append(c);
+			++iter;
+		}
+		return ret;
+	}
+#endif
+
+
+	//! Converts the string to a UTF-32 encoded string array.
+	//! Unfortunately, no toUTF32_s() version exists due to limitations with Irrlicht's string class.
+	//! \param endian The desired endianness of the string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return An array containing the UTF-32 encoded string.
+	core::array<uchar32_t> toUTF32(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
+	{
+		core::array<uchar32_t> ret(size() + (addBOM ? unicode::BOM_UTF32_LEN : 0) + 1);
+		const_iterator iter(*this, 0);
+
+		// Add the BOM if specified.
+		if (addBOM)
+		{
+			if (endian == unicode::EUTFEE_NATIVE)
+				ret.push_back(unicode::BOM);
+			else
+			{
+				union
+				{
+					uchar32_t full;
+					u8 chunk[4];
+				} t;
+
+				if (endian == unicode::EUTFEE_LITTLE)
+				{
+					t.chunk[0] = unicode::BOM_ENCODE_UTF32_LE[0];
+					t.chunk[1] = unicode::BOM_ENCODE_UTF32_LE[1];
+					t.chunk[2] = unicode::BOM_ENCODE_UTF32_LE[2];
+					t.chunk[3] = unicode::BOM_ENCODE_UTF32_LE[3];
+				}
+				else
+				{
+					t.chunk[0] = unicode::BOM_ENCODE_UTF32_BE[0];
+					t.chunk[1] = unicode::BOM_ENCODE_UTF32_BE[1];
+					t.chunk[2] = unicode::BOM_ENCODE_UTF32_BE[2];
+					t.chunk[3] = unicode::BOM_ENCODE_UTF32_BE[3];
+				}
+				ret.push_back(t.full);
+			}
+		}
+		ret.push_back(0);
+
+		while (!iter.atEnd())
+		{
+			uchar32_t c = *iter;
+			if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
+				c = unicode::swapEndian32(c);
+			ret.push_back(c);
+			++iter;
+		}
+		return ret;
+	}
+
+
+	//! Converts the string to a wchar_t encoded string.
+	/** The size of a wchar_t changes depending on the platform.  This function will store a
+	correct UTF-8, -16, or -32 encoded string depending on the size of a wchar_t. **/
+	//! \param endian The desired endianness of the string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return A string containing the wchar_t encoded string.
+	core::string<wchar_t> toWCHAR_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
+	{
+		if (sizeof(wchar_t) == 4)
+		{
+			core::array<uchar32_t> a(toUTF32(endian, addBOM));
+			core::stringw ret(a.pointer());
+			return ret;
+		}
+		else if (sizeof(wchar_t) == 2)
+		{
+			if (endian == unicode::EUTFEE_NATIVE && addBOM == false)
+			{
+				core::stringw ret(array);
+				return ret;
+			}
+			else
+			{
+				core::array<uchar16_t> a(toUTF16(endian, addBOM));
+				core::stringw ret(a.pointer());
+				return ret;
+			}
+		}
+		else if (sizeof(wchar_t) == 1)
+		{
+			core::array<uchar8_t> a(toUTF8(addBOM));
+			core::stringw ret(a.pointer());
+			return ret;
+		}
+
+		// Shouldn't happen.
+		return core::stringw();
+	}
+
+
+	//! Converts the string to a wchar_t encoded string array.
+	/** The size of a wchar_t changes depending on the platform.  This function will store a
+	correct UTF-8, -16, or -32 encoded string depending on the size of a wchar_t. **/
+	//! \param endian The desired endianness of the string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return An array containing the wchar_t encoded string.
+	core::array<wchar_t> toWCHAR(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
+	{
+		if (sizeof(wchar_t) == 4)
+		{
+			core::array<uchar32_t> a(toUTF32(endian, addBOM));
+			core::array<wchar_t> ret(a.size());
+			ret.set_used(a.size());
+			memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar32_t));
+			return ret;
+		}
+		if (sizeof(wchar_t) == 2)
+		{
+			if (endian == unicode::EUTFEE_NATIVE && addBOM == false)
+			{
+				core::array<wchar_t> ret(used);
+				ret.set_used(used);
+				memcpy((void*)ret.pointer(), (void*)array, used * sizeof(uchar16_t));
+				return ret;
+			}
+			else
+			{
+				core::array<uchar16_t> a(toUTF16(endian, addBOM));
+				core::array<wchar_t> ret(a.size());
+				ret.set_used(a.size());
+				memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar16_t));
+				return ret;
+			}
+		}
+		if (sizeof(wchar_t) == 1)
+		{
+			core::array<uchar8_t> a(toUTF8(addBOM));
+			core::array<wchar_t> ret(a.size());
+			ret.set_used(a.size());
+			memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar8_t));
+			return ret;
+		}
+
+		// Shouldn't happen.
+		return core::array<wchar_t>();
+	}
+
+	//! Converts the string to a properly encoded io::path string.
+	//! \param endian The desired endianness of the string.
+	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
+	//! \return An io::path string containing the properly encoded string.
+	io::path toPATH_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
+	{
+#if defined(_IRR_WCHAR_FILESYSTEM)
+		return toWCHAR_s(endian, addBOM);
+#else
+		return toUTF8_s(addBOM);
+#endif
+	}
+
+	//! Loads an unknown stream of data.
+	//! Will attempt to determine if the stream is unicode data.  Useful for loading from files.
+	//! \param data The data stream to load from.
+	//! \param data_size The length of the data string.
+	//! \return A reference to our current string.
+	ustring16<TAlloc>& loadDataStream(const char* data, size_t data_size)
+	{
+		// Clear our string.
+		*this = "";
+		if (!data)
+			return *this;
+
+		unicode::EUTF_ENCODE e = unicode::determineUnicodeBOM(data);
+		switch (e)
+		{
+			default:
+			case unicode::EUTFE_UTF8:
+				append((uchar8_t*)data, data_size);
+				break;
+
+			case unicode::EUTFE_UTF16:
+			case unicode::EUTFE_UTF16_BE:
+			case unicode::EUTFE_UTF16_LE:
+				append((uchar16_t*)data, data_size / 2);
+				break;
+
+			case unicode::EUTFE_UTF32:
+			case unicode::EUTFE_UTF32_BE:
+			case unicode::EUTFE_UTF32_LE:
+				append((uchar32_t*)data, data_size / 4);
+				break;
+		}
+
+		return *this;
+	}
+
+	//! Gets the encoding of the Unicode string this class contains.
+	//! \return An enum describing the current encoding of this string.
+	const unicode::EUTF_ENCODE getEncoding() const
+	{
+		return encoding;
+	}
+
+	//! Gets the endianness of the Unicode string this class contains.
+	//! \return An enum describing the endianness of this string.
+	const unicode::EUTF_ENDIAN getEndianness() const
+	{
+		if (encoding == unicode::EUTFE_UTF16_LE ||
+			encoding == unicode::EUTFE_UTF32_LE)
+			return unicode::EUTFEE_LITTLE;
+		else return unicode::EUTFEE_BIG;
+	}
+
+private:
+
+	//! Reallocate the string, making it bigger or smaller.
+	//! \param new_size The new size of the string.
+	void reallocate(u32 new_size)
+	{
+		uchar16_t* old_array = array;
+
+		array = allocator.allocate(new_size + 1); //new u16[new_size];
+		allocated = new_size + 1;
+		if (old_array == 0) return;
+
+		u32 amount = used < new_size ? used : new_size;
+		for (u32 i=0; i<=amount; ++i)
+			array[i] = old_array[i];
+
+		if (allocated <= used)
+			used = allocated - 1;
+
+		array[used] = 0;
+
+		allocator.deallocate(old_array); // delete [] old_array;
+	}
+
+	//--- member variables
+
+	uchar16_t* array;
+	unicode::EUTF_ENCODE encoding;
+	u32 allocated;
+	u32 used;
+	TAlloc allocator;
+	//irrAllocator<uchar16_t> allocator;
+};
+
+typedef ustring16<irrAllocator<uchar16_t> > ustring;
+
+
+//! Appends two ustring16s.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a null-terminated unicode string.
+template <typename TAlloc, class B>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const B* const right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a null-terminated unicode string.
+template <class B, typename TAlloc>
+inline ustring16<TAlloc> operator+(const B* const left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and an Irrlicht string.
+template <typename TAlloc, typename B, typename BAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const string<B, BAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and an Irrlicht string.
+template <typename TAlloc, typename B, typename BAlloc>
+inline ustring16<TAlloc> operator+(const string<B, BAlloc>& left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a std::basic_string.
+template <typename TAlloc, typename B, typename A, typename BAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const std::basic_string<B, A, BAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a std::basic_string.
+template <typename TAlloc, typename B, typename A, typename BAlloc>
+inline ustring16<TAlloc> operator+(const std::basic_string<B, A, BAlloc>& left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a char.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const char right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a char.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const char left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+#ifdef USTRING_CPP0X_NEWLITERALS
+//! Appends a ustring16 and a uchar32_t.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const uchar32_t right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a uchar32_t.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const uchar32_t left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += right;
+	return ret;
+}
+#endif
+
+
+//! Appends a ustring16 and a short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const short right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and a short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const short left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and an unsigned short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned short right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and an unsigned short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const unsigned short left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and an int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const int right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and an int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const int left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and an unsigned int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned int right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and an unsigned int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const unsigned int left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const long right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and a long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const long left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and an unsigned long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned long right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and an unsigned long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const unsigned long left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a float.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const float right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and a float.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const float left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+//! Appends a ustring16 and a double.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const double right)
+{
+	ustring16<TAlloc> ret(left);
+	ret += core::stringc(right);
+	return ret;
+}
+
+
+//! Appends a ustring16 and a double.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const double left, const ustring16<TAlloc>& right)
+{
+	ustring16<TAlloc> ret(core::stringc(left));
+	ret += right;
+	return ret;
+}
+
+
+#ifdef USTRING_CPP0X
+//! Appends two ustring16s.
+template <typename TAlloc>
+inline ustring16<TAlloc>&& operator+(const ustring16<TAlloc>& left, ustring16<TAlloc>&& right)
+{
+	//std::cout << "MOVE operator+(&, &&)" << std::endl;
+	right.insert(left, 0);
+	return std::move(right);
+}
+
+
+//! Appends two ustring16s.
+template <typename TAlloc>
+inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const ustring16<TAlloc>& right)
+{
+	//std::cout << "MOVE operator+(&&, &)" << std::endl;
+	left.append(right);
+	return std::move(left);
+}
+
+
+//! Appends two ustring16s.
+template <typename TAlloc>
+inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, ustring16<TAlloc>&& right)
+{
+	//std::cout << "MOVE operator+(&&, &&)" << std::endl;
+	if ((right.size_raw() <= left.capacity() - left.size_raw()) ||
+		(right.capacity() - right.size_raw() < left.size_raw()))
+	{
+		left.append(right);
+		return std::move(left);
+	}
+	else
+	{
+		right.insert(left, 0);
+		return std::move(right);
+	}
+}
+
+
+//! Appends a ustring16 and a null-terminated unicode string.
+template <typename TAlloc, class B>
+inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const B* const right)
+{
+	//std::cout << "MOVE operator+(&&, B*)" << std::endl;
+	left.append(right);
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a null-terminated unicode string.
+template <class B, typename TAlloc>
+inline ustring16<TAlloc>&& operator+(const B* const left, ustring16<TAlloc>&& right)
+{
+	//std::cout << "MOVE operator+(B*, &&)" << std::endl;
+	right.insert(left, 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and an Irrlicht string.
+template <typename TAlloc, typename B, typename BAlloc>
+inline ustring16<TAlloc>&& operator+(const string<B, BAlloc>& left, ustring16<TAlloc>&& right)
+{
+	//std::cout << "MOVE operator+(&, &&)" << std::endl;
+	right.insert(left, 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and an Irrlicht string.
+template <typename TAlloc, typename B, typename BAlloc>
+inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const string<B, BAlloc>& right)
+{
+	//std::cout << "MOVE operator+(&&, &)" << std::endl;
+	left.append(right);
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a std::basic_string.
+template <typename TAlloc, typename B, typename A, typename BAlloc>
+inline ustring16<TAlloc>&& operator+(const std::basic_string<B, A, BAlloc>& left, ustring16<TAlloc>&& right)
+{
+	//std::cout << "MOVE operator+(&, &&)" << std::endl;
+	right.insert(core::ustring16<TAlloc>(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and a std::basic_string.
+template <typename TAlloc, typename B, typename A, typename BAlloc>
+inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const std::basic_string<B, A, BAlloc>& right)
+{
+	//std::cout << "MOVE operator+(&&, &)" << std::endl;
+	left.append(right);
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a char.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const char right)
+{
+	left.append((uchar32_t)right);
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a char.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const char left, ustring16<TAlloc>&& right)
+{
+	right.insert((uchar32_t)left, 0);
+	return std::move(right);
+}
+
+
+#ifdef USTRING_CPP0X_NEWLITERALS
+//! Appends a ustring16 and a uchar32_t.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const uchar32_t right)
+{
+	left.append(right);
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a uchar32_t.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const uchar32_t left, ustring16<TAlloc>&& right)
+{
+	right.insert(left, 0);
+	return std::move(right);
+}
+#endif
+
+
+//! Appends a ustring16 and a short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const short right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const short left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and an unsigned short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned short right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and an unsigned short.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const unsigned short left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and an int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const int right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and an int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const int left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and an unsigned int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned int right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and an unsigned int.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const unsigned int left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and a long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const long right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const long left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and an unsigned long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned long right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and an unsigned long.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const unsigned long left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and a float.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const float right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a float.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const float left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+
+
+//! Appends a ustring16 and a double.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const double right)
+{
+	left.append(core::stringc(right));
+	return std::move(left);
+}
+
+
+//! Appends a ustring16 and a double.
+template <typename TAlloc>
+inline ustring16<TAlloc> operator+(const double left, ustring16<TAlloc>&& right)
+{
+	right.insert(core::stringc(left), 0);
+	return std::move(right);
+}
+#endif
+
+
+#ifndef USTRING_NO_STL
+//! Writes a ustring16 to an ostream.
+template <typename TAlloc>
+inline std::ostream& operator<<(std::ostream& out, const ustring16<TAlloc>& in)
+{
+	out << in.toUTF8_s().c_str();
+	return out;
+}
+
+//! Writes a ustring16 to a wostream.
+template <typename TAlloc>
+inline std::wostream& operator<<(std::wostream& out, const ustring16<TAlloc>& in)
+{
+	out << in.toWCHAR_s().c_str();
+	return out;
+}
+#endif
+
+
+#ifndef USTRING_NO_STL
+
+namespace unicode
+{
+
+//! Hashing algorithm for hashing a ustring.  Used for things like unordered_maps.
+//! Algorithm taken from std::hash<std::string>.
+class hash : public std::unary_function<core::ustring, size_t>
+{
+	public:
+		size_t operator()(const core::ustring& s) const
+		{
+			size_t ret = 2166136261U;
+			size_t index = 0;
+			size_t stride = 1 + s.size_raw() / 10;
+
+			core::ustring::const_iterator i = s.begin();
+			while (i != s.end())
+			{
+				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
+				ret = 16777619U * ret ^ (size_t)s[(u32)index];
+				index += stride;
+				i += stride;
+			}
+			return (ret);
+		}
+};
+
+} // end namespace unicode
+
+#endif
+
+} // end namespace core
+} // end namespace irr
+
+#endif
diff --git a/src/cguittfont/xCGUITTFont.cpp b/src/cguittfont/xCGUITTFont.cpp
new file mode 100644
index 000000000..c51922e4c
--- /dev/null
+++ b/src/cguittfont/xCGUITTFont.cpp
@@ -0,0 +1,5 @@
+// A wrapper source file to avoid hack with gcc and modifying
+// the CGUITTFont files.
+
+#include "xCGUITTFont.h"
+#include "CGUITTFont.cpp"
diff --git a/src/cguittfont/xCGUITTFont.h b/src/cguittfont/xCGUITTFont.h
new file mode 100644
index 000000000..c3efe7f6f
--- /dev/null
+++ b/src/cguittfont/xCGUITTFont.h
@@ -0,0 +1,7 @@
+// A wrapper header to avoid hack with gcc and modifying
+// the CGUITTFont files.
+
+#include <algorithm>
+#include <stddef.h>
+#include "irrUString.h"
+#include "CGUITTFont.h"
diff --git a/src/chat.cpp b/src/chat.cpp
index b9d115bd0..c3509ae49 100644
--- a/src/chat.cpp
+++ b/src/chat.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/chat.h b/src/chat.h
index 49de52985..27863922c 100644
--- a/src/chat.h
+++ b/src/chat.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/client.cpp b/src/client.cpp
index 9969ef538..be35db5de 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -1514,6 +1514,26 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
 			}
 		}
 	}
+	else if(command == TOCLIENT_MOVEMENT)
+	{
+		std::string datastring((char*)&data[2], datasize-2);
+		std::istringstream is(datastring, std::ios_base::binary);
+		Player *player = m_env.getLocalPlayer();
+		assert(player != NULL);
+
+		player->movement_acceleration_default = readF1000(is) * BS;
+		player->movement_acceleration_air = readF1000(is) * BS;
+		player->movement_acceleration_fast = readF1000(is) * BS;
+		player->movement_speed_walk = readF1000(is) * BS;
+		player->movement_speed_crouch = readF1000(is) * BS;
+		player->movement_speed_fast = readF1000(is) * BS;
+		player->movement_speed_climb = readF1000(is) * BS;
+		player->movement_speed_jump = readF1000(is) * BS;
+		player->movement_liquid_fluidity = readF1000(is) * BS;
+		player->movement_liquid_fluidity_smooth = readF1000(is) * BS;
+		player->movement_liquid_sink = readF1000(is) * BS;
+		player->movement_gravity = readF1000(is) * BS;
+	}
 	else if(command == TOCLIENT_HP)
 	{
 		std::string datastring((char*)&data[2], datasize-2);
diff --git a/src/client.h b/src/client.h
index 43fac9c9a..809e98b81 100644
--- a/src/client.h
+++ b/src/client.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/clientmap.cpp b/src/clientmap.cpp
index 800549a3b..aa92dfdee 100644
--- a/src/clientmap.cpp
+++ b/src/clientmap.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -864,7 +864,7 @@ void ClientMap::renderPostFx()
 	// - If the player is in liquid, draw a semi-transparent overlay.
 	const ContentFeatures& features = nodemgr->get(n);
 	video::SColor post_effect_color = features.post_effect_color;
-	if(features.solidness == 2 && g_settings->getBool("free_move") == false)
+	if(features.solidness == 2 && !(g_settings->getBool("noclip") && m_gamedef->checkLocalPrivilege("noclip")))
 	{
 		post_effect_color = video::SColor(255, 0, 0, 0);
 	}
diff --git a/src/clientmap.h b/src/clientmap.h
index f8a69630e..786f35b77 100644
--- a/src/clientmap.h
+++ b/src/clientmap.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/clientobject.cpp b/src/clientobject.cpp
index e1dbaf627..e7c735dac 100644
--- a/src/clientobject.cpp
+++ b/src/clientobject.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/clientobject.h b/src/clientobject.h
index 852d2c76b..d1ee366cf 100644
--- a/src/clientobject.h
+++ b/src/clientobject.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/clientserver.cpp b/src/clientserver.cpp
index bd0a8ede0..591a95542 100644
--- a/src/clientserver.cpp
+++ b/src/clientserver.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/clientserver.h b/src/clientserver.h
index 52b9dc7b0..769272a68 100644
--- a/src/clientserver.h
+++ b/src/clientserver.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -364,6 +364,23 @@ enum ToClientCommand
 		u16 len
 		u8[len] formname
 	*/
+
+	TOCLIENT_MOVEMENT = 0x45,
+	/*
+		u16 command
+		f1000 movement_acceleration_default
+		f1000 movement_acceleration_air
+		f1000 movement_acceleration_fast
+		f1000 movement_speed_walk
+		f1000 movement_speed_crouch
+		f1000 movement_speed_fast
+		f1000 movement_speed_climb
+		f1000 movement_speed_jump
+		f1000 movement_liquid_fluidity
+		f1000 movement_liquid_fluidity_smooth
+		f1000 movement_liquid_sink
+		f1000 movement_gravity
+	*/
 };
 
 enum ToServerCommand
diff --git a/src/clientsimpleobject.h b/src/clientsimpleobject.h
index 9dd8cc472..c94db22f1 100644
--- a/src/clientsimpleobject.h
+++ b/src/clientsimpleobject.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/clouds.cpp b/src/clouds.cpp
index 5b980a5ba..9f0bc06d8 100644
--- a/src/clouds.cpp
+++ b/src/clouds.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/clouds.h b/src/clouds.h
index a7cde42bc..72923c2c5 100644
--- a/src/clouds.h
+++ b/src/clouds.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/cmake_config.h.in b/src/cmake_config.h.in
index 4853d854f..51827cce6 100644
--- a/src/cmake_config.h.in
+++ b/src/cmake_config.h.in
@@ -9,6 +9,7 @@
 #define CMAKE_USE_GETTEXT @USE_GETTEXT@
 #define CMAKE_USE_CURL @USE_CURL@
 #define CMAKE_USE_SOUND @USE_SOUND@
+#define CMAKE_USE_FREETYPE @USE_FREETYPE@
 #define CMAKE_STATIC_SHAREDIR "@SHAREDIR@"
 
 #ifdef NDEBUG
diff --git a/src/collision.cpp b/src/collision.cpp
index 143b559fa..58517b779 100644
--- a/src/collision.cpp
+++ b/src/collision.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -199,6 +199,10 @@ collisionMoveResult collisionMoveSimple(Map *map, IGameDef *gamedef,
 	/*
 		Calculate new velocity
 	*/
+	if( dtime > 0.5 ) {
+		infostream<<"collisionMoveSimple: WARNING: maximum step interval exceeded, lost movement details!"<<std::endl;
+		dtime = 0.5;
+	}
 	speed_f += accel_f * dtime;
 
     // If there is no speed, there are no collisions
diff --git a/src/collision.h b/src/collision.h
index 52a7bbb7d..38cc3efb3 100644
--- a/src/collision.h
+++ b/src/collision.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/config.h b/src/config.h
index f37ec0fed..37dc6e0ef 100644
--- a/src/config.h
+++ b/src/config.h
@@ -12,6 +12,7 @@
 #define USE_GETTEXT 0
 #define USE_SOUND 0
 #define USE_CURL 0
+#define USE_FREETYPE 0
 #define STATIC_SHAREDIR ""
 #define BUILD_INFO "non-cmake"
 
@@ -29,6 +30,8 @@
 	#define USE_SOUND CMAKE_USE_SOUND
 	#undef USE_CURL
 	#define USE_CURL CMAKE_USE_CURL
+	#undef USE_FREETYPE
+	#define USE_FREETYPE CMAKE_USE_FREETYPE
 	#undef STATIC_SHAREDIR
 	#define STATIC_SHAREDIR CMAKE_STATIC_SHAREDIR
 	#undef BUILD_INFO
diff --git a/src/connection.cpp b/src/connection.cpp
index ed5a752be..7a3018bfd 100644
--- a/src/connection.cpp
+++ b/src/connection.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/connection.h b/src/connection.h
index f99cd1bf9..05b1ca2e8 100644
--- a/src/connection.h
+++ b/src/connection.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/constants.h b/src/constants.h
index 97e94b361..8246c8c21 100644
--- a/src/constants.h
+++ b/src/constants.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_abm.cpp b/src/content_abm.cpp
index 9e65a7ab0..03fc82ed4 100644
--- a/src/content_abm.cpp
+++ b/src/content_abm.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -26,6 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "settings.h"
 #include "mapblock.h" // For getNodeBlockPos
 #include "treegen.h" // For treegen::make_tree
+#include "main.h" // for g_settings
 #include "map.h"
 
 #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
@@ -80,7 +81,8 @@ public:
 		ServerMap *map = &env->getServerMap();
 		
 		MapNode n_top = map->getNodeNoEx(p+v3s16(0,1,0));
-		if(!ndef->get(n_top).light_propagates ||
+		if((!ndef->get(n_top).light_propagates &&
+				n_top.getContent() != CONTENT_IGNORE) ||
 				ndef->get(n_top).isLiquid())
 		{
 			n.setContent(ndef->getId("mapgen_dirt"));
@@ -118,7 +120,7 @@ public:
 		v3s16 tree_blockp = getNodeBlockPos(tree_p);
 		vmanip.initialEmerge(tree_blockp - v3s16(1,1,1), tree_blockp + v3s16(1,1,1));
 		bool is_apple_tree = myrand()%4 == 0;
-		treegen::make_tree(vmanip, tree_p, is_apple_tree, ndef);
+		treegen::make_tree(vmanip, tree_p, is_apple_tree, ndef, myrand());
 		vmanip.blitBackAll(&modified_blocks);
 
 		// update lighting
@@ -145,11 +147,42 @@ public:
 	}
 };
 
+class LiquidFlowABM : public ActiveBlockModifier
+{
+private:
+	std::set<std::string> contents;
+
+public:
+	LiquidFlowABM(ServerEnvironment *env, INodeDefManager *nodemgr) 
+	{
+		std::set<content_t> liquids;
+		nodemgr->getIds("group:liquid", liquids);
+		for(std::set<content_t>::const_iterator k = liquids.begin(); k != liquids.end(); k++)
+			contents.insert(nodemgr->get(*k).liquid_alternative_flowing);
+		
+	}
+	virtual std::set<std::string> getTriggerContents()
+	{
+		return contents;
+	}
+	virtual float getTriggerInterval()
+	{ return 10.0; }
+	virtual u32 getTriggerChance()
+	{ return 10; }
+	virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n)
+	{
+		ServerMap *map = &env->getServerMap();
+		if (map->transforming_liquid_size() < 500)
+			map->transforming_liquid_add(p);
+		//if ((*map).m_transforming_liquid.size() < 500) (*map).m_transforming_liquid.push_back(p);
+	}
+};
+
 void add_legacy_abms(ServerEnvironment *env, INodeDefManager *nodedef)
 {
 	env->addActiveBlockModifier(new GrowGrassABM());
 	env->addActiveBlockModifier(new RemoveGrassABM());
 	env->addActiveBlockModifier(new MakeTreesFromSaplingsABM());
+	if (g_settings->getBool("liquid_finite"))
+		env->addActiveBlockModifier(new LiquidFlowABM(env, nodedef));
 }
-
-
diff --git a/src/content_abm.h b/src/content_abm.h
index beb9b2e16..0a91a96a2 100644
--- a/src/content_abm.h
+++ b/src/content_abm.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_cao.cpp b/src/content_cao.cpp
index d71911b95..5e5cb38ae 100644
--- a/src/content_cao.cpp
+++ b/src/content_cao.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_cao.h b/src/content_cao.h
index 566117716..441c74922 100644
--- a/src/content_cao.h
+++ b/src/content_cao.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_cso.cpp b/src/content_cso.cpp
index 666f17734..73d5f2b48 100644
--- a/src/content_cso.cpp
+++ b/src/content_cso.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -25,6 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "log.h"
 #include "map.h"
 
+/*
 static void setBillboardTextureMatrix(scene::IBillboardSceneNode *bill,
 		float txs, float tys, int col, int row)
 {
@@ -33,6 +34,7 @@ static void setBillboardTextureMatrix(scene::IBillboardSceneNode *bill,
 	matrix.setTextureTranslate(txs*col, tys*row);
 	matrix.setTextureScale(txs, tys);
 }
+*/
 
 class SmokePuffCSO: public ClientSimpleObject
 {
diff --git a/src/content_cso.h b/src/content_cso.h
index 0b467f6c4..5007d2526 100644
--- a/src/content_cso.h
+++ b/src/content_cso.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_mapblock.cpp b/src/content_mapblock.cpp
index aa3c061d6..0d80dc173 100644
--- a/src/content_mapblock.cpp
+++ b/src/content_mapblock.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -261,7 +261,7 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
 						level = (-0.5+node_liquid_level) * BS;
 					else if(n2.getContent() == c_flowing)
 						level = (-0.5 + ((float)(n2.param2&LIQUID_LEVEL_MASK)
-								+ 0.5) / 8.0 * node_liquid_level) * BS;
+								+ 0.5) / (float)LIQUID_LEVEL_SOURCE * node_liquid_level) * BS;
 
 					// Check node above neighbor.
 					// NOTE: This doesn't get executed if neighbor
@@ -324,7 +324,7 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
 					}
 				}
 				if(air_count >= 2)
-					cornerlevel = -0.5*BS;
+					cornerlevel = -0.5*BS+0.1;
 				else if(valid_count > 0)
 					cornerlevel /= valid_count;
 				corner_levels[i] = cornerlevel;
@@ -733,7 +733,7 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
 			u16 l = getInteriorLight(n, 1, data);
 			video::SColor c = MapBlock_LightColor(255, l, decode_light(f.light_source));
 
-			for(u32 j=0; j<4; j++)
+			for(u32 j=0; j<2; j++)
 			{
 				video::S3DVertex vertices[4] =
 				{
@@ -759,16 +759,6 @@ void mapblock_mesh_generate_special(MeshMakeData *data,
 					for(u16 i=0; i<4; i++)
 						vertices[i].Pos.rotateXZBy(-45);
 				}
-				else if(j == 2)
-				{
-					for(u16 i=0; i<4; i++)
-						vertices[i].Pos.rotateXZBy(135);
-				}
-				else if(j == 3)
-				{
-					for(u16 i=0; i<4; i++)
-						vertices[i].Pos.rotateXZBy(-135);
-				}
 
 				for(u16 i=0; i<4; i++)
 				{
diff --git a/src/content_mapblock.h b/src/content_mapblock.h
index 142c00edf..bb1e129da 100644
--- a/src/content_mapblock.h
+++ b/src/content_mapblock.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_mapnode.cpp b/src/content_mapnode.cpp
index c3fdb4a42..44d0b8e38 100644
--- a/src/content_mapnode.cpp
+++ b/src/content_mapnode.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_mapnode.h b/src/content_mapnode.h
index 45c2b0763..5c9c0b66d 100644
--- a/src/content_mapnode.h
+++ b/src/content_mapnode.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_nodemeta.cpp b/src/content_nodemeta.cpp
index 0e4c3dd75..a9a8cc60c 100644
--- a/src/content_nodemeta.cpp
+++ b/src/content_nodemeta.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_nodemeta.h b/src/content_nodemeta.h
index d206c35ad..907649b5f 100644
--- a/src/content_nodemeta.h
+++ b/src/content_nodemeta.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_object.h b/src/content_object.h
index e4690d295..65a829773 100644
--- a/src/content_object.h
+++ b/src/content_object.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_sao.cpp b/src/content_sao.cpp
index 196c10e61..718a42dff 100644
--- a/src/content_sao.cpp
+++ b/src/content_sao.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/content_sao.h b/src/content_sao.h
index 065c6a039..2fd1034eb 100644
--- a/src/content_sao.h
+++ b/src/content_sao.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/craftdef.cpp b/src/craftdef.cpp
index b15443607..99e3fcc3d 100644
--- a/src/craftdef.cpp
+++ b/src/craftdef.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/craftdef.h b/src/craftdef.h
index a2258c6e8..eb3cd7e39 100644
--- a/src/craftdef.h
+++ b/src/craftdef.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/daynightratio.h b/src/daynightratio.h
index 96c6729eb..3375133ef 100644
--- a/src/daynightratio.h
+++ b/src/daynightratio.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/debug.cpp b/src/debug.cpp
index 8b25cc22d..e32cceb86 100644
--- a/src/debug.cpp
+++ b/src/debug.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/debug.h b/src/debug.h
index 3e8066f4d..56952427c 100644
--- a/src/debug.h
+++ b/src/debug.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -32,6 +32,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #ifdef _WIN32
 	#define WIN32_LEAN_AND_MEAN
+	#ifndef _WIN32_WINNT
+		#define _WIN32_WINNT 0x0500
+	#endif
 	#include <windows.h>
 	#ifdef _MSC_VER
 		#include <eh.h>
diff --git a/src/defaultsettings.cpp b/src/defaultsettings.cpp
index a164d0693..7afe8df05 100644
--- a/src/defaultsettings.cpp
+++ b/src/defaultsettings.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -18,6 +18,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 */
 
 #include "settings.h"
+#include "filesys.h"
 
 void set_default_settings(Settings *settings)
 {
@@ -129,8 +130,18 @@ void set_default_settings(Settings *settings)
 
 	settings->setDefault("media_fetch_threads", "8");
 
-	settings->setDefault("serverlist_url", "servers.minetest.ru/server.list");
+	settings->setDefault("serverlist_url", "servers.minetest.net");
 	settings->setDefault("serverlist_file", "favoriteservers.txt");
+	settings->setDefault("server_announce", "false");
+	settings->setDefault("server_url", "");
+	settings->setDefault("server_address", "");
+	settings->setDefault("server_name", "");
+	settings->setDefault("server_description", "");
+
+	settings->setDefault("font_path", porting::getDataPath("fonts" DIR_DELIM "liberationsans.ttf"));
+	settings->setDefault("font_size", "13");
+	settings->setDefault("mono_font_path", porting::getDataPath("fonts" DIR_DELIM "liberationmono.ttf"));
+	settings->setDefault("mono_font_size", "13");
 
 	// Server stuff
 	// "map-dir" doesn't exist by default.
@@ -172,10 +183,34 @@ void set_default_settings(Settings *settings)
 	settings->setDefault("congestion_control_max_rate", "400");
 	settings->setDefault("congestion_control_min_rate", "10");
 	settings->setDefault("remote_media", "");
+	settings->setDefault("debug_log_level", "0");
+	settings->setDefault("emergequeue_limit_total", "256");
+	settings->setDefault("emergequeue_limit_diskonly", "");
+	settings->setDefault("emergequeue_limit_generate", "");
+	settings->setDefault("num_emerge_threads", "1");
+	
+	// physics stuff
+	settings->setDefault("movement_acceleration_default", "3");
+	settings->setDefault("movement_acceleration_air", "2");
+	settings->setDefault("movement_acceleration_fast", "10");
+	settings->setDefault("movement_speed_walk", "4");
+	settings->setDefault("movement_speed_crouch", "1.35");
+	settings->setDefault("movement_speed_fast", "20");
+	settings->setDefault("movement_speed_climb", "2");
+	settings->setDefault("movement_speed_jump", "6.5");
+	settings->setDefault("movement_liquid_fluidity", "1");
+	settings->setDefault("movement_liquid_fluidity_smooth", "0.5");
+	settings->setDefault("movement_liquid_sink", "10");
+	settings->setDefault("movement_gravity", "9.81");
 	
 	//mapgen related things
 	settings->setDefault("mg_name", "v6");
 	settings->setDefault("water_level", "1");
+	settings->setDefault("liquid_finite", "false");
+	settings->setDefault("liquid_update", "1.0");
+	settings->setDefault("liquid_relax", "1");
+	settings->setDefault("liquid_fast_flood", "1");
+	
 	settings->setDefault("chunksize", "5");
 	settings->setDefault("mg_flags", "trees, caves, v6_biome_blend");
 	settings->setDefault("mgv6_freq_desert", "0.45");
diff --git a/src/defaultsettings.h b/src/defaultsettings.h
index faac7a886..37e3f717f 100644
--- a/src/defaultsettings.h
+++ b/src/defaultsettings.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/emerge.cpp b/src/emerge.cpp
new file mode 100644
index 000000000..6c6863eff
--- /dev/null
+++ b/src/emerge.cpp
@@ -0,0 +1,453 @@
+/*
+Minetest-c55
+Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+
+#include "server.h"
+#include <iostream>
+#include <queue>
+#include "clientserver.h"
+#include "map.h"
+#include "jmutexautolock.h"
+#include "main.h"
+#include "constants.h"
+#include "voxel.h"
+#include "config.h"
+#include "mapblock.h"
+#include "serverobject.h"
+#include "settings.h"
+#include "script.h"
+#include "scriptapi.h"
+#include "profiler.h"
+#include "log.h"
+#include "nodedef.h"
+#include "biome.h"
+#include "emerge.h"
+#include "mapgen_v6.h"
+
+
+/////////////////////////////// Emerge Manager ////////////////////////////////
+
+EmergeManager::EmergeManager(IGameDef *gamedef, BiomeDefManager *bdef) {
+	//register built-in mapgens
+	registerMapgen("v6", new MapgenFactoryV6());
+
+	this->biomedef = bdef ? bdef : new BiomeDefManager(gamedef);
+	this->params   = NULL;
+	
+	mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
+
+	queuemutex.Init();
+	
+	int nthreads;
+	if (g_settings->get("num_emerge_threads").empty()) {
+		int nprocs = porting::getNumberOfProcessors();
+		// leave a proc for the main thread and one for some other misc threads
+		nthreads = (nprocs > 2) ? nprocs - 2 : 1;
+	} else {
+		nthreads = g_settings->getU16("num_emerge_threads");
+	}
+	if (nthreads < 1)
+		nthreads = 1;
+	
+	qlimit_total    = g_settings->getU16("emergequeue_limit_total");
+	qlimit_diskonly = g_settings->get("emergequeue_limit_diskonly").empty() ?
+		nthreads * 5 + 1 :
+		g_settings->getU16("emergequeue_limit_diskonly");
+	qlimit_generate = g_settings->get("emergequeue_limit_generate").empty() ?
+		nthreads + 1 :
+		g_settings->getU16("emergequeue_limit_generate");
+	
+	for (int i = 0; i != nthreads; i++)
+		emergethread.push_back(new EmergeThread((Server *)gamedef, i));
+		
+	infostream << "EmergeManager: using " << nthreads << " threads" << std::endl;
+}
+
+
+EmergeManager::~EmergeManager() {
+	for (unsigned int i = 0; i != emergethread.size(); i++) {
+		emergethread[i]->setRun(false);
+		emergethread[i]->qevent.signal();
+		emergethread[i]->stop();
+		delete emergethread[i];
+		delete mapgen[i];
+	}
+	
+	delete biomedef;
+	delete params;
+}
+
+
+void EmergeManager::initMapgens(MapgenParams *mgparams) {
+	Mapgen *mg;
+	
+	if (mapgen.size())
+		return;
+	
+	this->params = mgparams;
+	for (unsigned int i = 0; i != emergethread.size(); i++) {
+		mg = createMapgen(params->mg_name, 0, params);
+		if (!mg) {
+			infostream << "EmergeManager: falling back to mapgen v6" << std::endl;
+			delete params;
+			params = createMapgenParams("v6");
+			mg = createMapgen("v6", 0, params);
+		}
+		mapgen.push_back(mg);
+	}
+}
+
+
+bool EmergeManager::enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate) {
+	std::map<v3s16, BlockEmergeData *>::const_iterator iter;
+	BlockEmergeData *bedata;
+	u16 count;
+	u8 flags = 0;
+	int idx = 0;
+	
+	if (allow_generate)
+		flags |= BLOCK_EMERGE_ALLOWGEN;
+
+	{
+		JMutexAutoLock queuelock(queuemutex);
+		
+		count = blocks_enqueued.size();
+		if (count >= qlimit_total)
+			return false;
+
+		count = peer_queue_count[peer_id];
+		u16 qlimit_peer = allow_generate ? qlimit_generate : qlimit_diskonly;
+		if (count >= qlimit_peer)
+			return false;
+		
+		iter = blocks_enqueued.find(p);
+		if (iter != blocks_enqueued.end()) {
+			bedata = iter->second;
+			bedata->flags |= flags;
+			return true;
+		}
+
+		bedata = new BlockEmergeData;
+		bedata->flags = flags;
+		bedata->peer_requested = peer_id;
+		blocks_enqueued.insert(std::make_pair(p, bedata));
+		
+		peer_queue_count[peer_id] = count + 1;
+		
+		// insert into the EmergeThread queue with the least items
+		int lowestitems = emergethread[0]->blockqueue.size();
+		for (unsigned int i = 1; i != emergethread.size(); i++) {
+			int nitems = emergethread[i]->blockqueue.size();
+			if (nitems < lowestitems) {
+				idx = i;
+				lowestitems = nitems;
+			}
+		}
+		
+		emergethread[idx]->blockqueue.push(p);
+	}
+	emergethread[idx]->qevent.signal();
+	
+	return true;
+}
+
+
+int EmergeManager::getGroundLevelAtPoint(v2s16 p) {
+	if (mapgen.size() == 0 || !mapgen[0]) {
+		errorstream << "EmergeManager: getGroundLevelAtPoint() called"
+		" before mapgen initialized" << std::endl;
+		return 0;
+	}
+	
+	return mapgen[0]->getGroundLevelAtPoint(p);
+}
+
+
+bool EmergeManager::isBlockUnderground(v3s16 blockpos) {
+	/*
+	v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
+					(blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
+	int ground_level = getGroundLevelAtPoint(p);
+	return blockpos.Y * (MAP_BLOCKSIZE + 1) <= min(water_level, ground_level);
+	*/
+
+	//yuck, but then again, should i bother being accurate?
+	//the height of the nodes in a single block is quite variable
+	return blockpos.Y * (MAP_BLOCKSIZE + 1) <= params->water_level;
+}
+
+
+u32 EmergeManager::getBlockSeed(v3s16 p) {
+	return (u32)(params->seed & 0xFFFFFFFF) +
+		p.Z * 38134234 +
+		p.Y * 42123 +
+		p.X * 23;
+}
+
+
+Mapgen *EmergeManager::createMapgen(std::string mgname, int mgid,
+									 MapgenParams *mgparams) {
+	std::map<std::string, MapgenFactory *>::const_iterator iter;
+	iter = mglist.find(mgname);
+	if (iter == mglist.end()) {
+		errorstream << "EmergeManager; mapgen " << mgname <<
+		 " not registered" << std::endl;
+		return NULL;
+	}
+	
+	MapgenFactory *mgfactory = iter->second;
+	return mgfactory->createMapgen(mgid, mgparams, this);
+}
+
+
+MapgenParams *EmergeManager::createMapgenParams(std::string mgname) {
+	std::map<std::string, MapgenFactory *>::const_iterator iter;
+	iter = mglist.find(mgname);
+	if (iter == mglist.end()) {
+		errorstream << "EmergeManager: mapgen " << mgname <<
+		 " not registered" << std::endl;
+		return NULL;
+	}
+	
+	MapgenFactory *mgfactory = iter->second;
+	return mgfactory->createMapgenParams();
+}
+
+
+MapgenParams *EmergeManager::getParamsFromSettings(Settings *settings) {
+	std::string mg_name = settings->get("mg_name");
+	MapgenParams *mgparams = createMapgenParams(mg_name);
+	
+	mgparams->mg_name     = mg_name;
+	mgparams->seed        = settings->getU64(settings == g_settings ? "fixed_map_seed" : "seed");
+	mgparams->water_level = settings->getS16("water_level");
+	mgparams->chunksize   = settings->getS16("chunksize");
+	mgparams->flags       = settings->getFlagStr("mg_flags", flagdesc_mapgen);
+
+	if (!mgparams->readParams(settings)) {
+		delete mgparams;
+		return NULL;
+	}
+	return mgparams;
+}
+
+
+void EmergeManager::setParamsToSettings(Settings *settings) {
+	settings->set("mg_name",         params->mg_name);
+	settings->setU64("seed",         params->seed);
+	settings->setS16("water_level",  params->water_level);
+	settings->setS16("chunksize",    params->chunksize);
+	settings->setFlagStr("mg_flags", params->flags, flagdesc_mapgen);
+
+	params->writeParams(settings);
+}
+
+
+void EmergeManager::registerMapgen(std::string mgname, MapgenFactory *mgfactory) {
+	mglist.insert(std::make_pair(mgname, mgfactory));
+	infostream << "EmergeManager: registered mapgen " << mgname << std::endl;
+}
+
+
+////////////////////////////// Emerge Thread ////////////////////////////////// 
+
+bool EmergeThread::popBlockEmerge(v3s16 *pos, u8 *flags) {
+	std::map<v3s16, BlockEmergeData *>::iterator iter;
+	JMutexAutoLock queuelock(emerge->queuemutex);
+
+	if (blockqueue.empty())
+		return false;
+	v3s16 p = blockqueue.front();
+	blockqueue.pop();
+	
+	*pos = p;
+	
+	iter = emerge->blocks_enqueued.find(p);
+	if (iter == emerge->blocks_enqueued.end()) 
+		return false; //uh oh, queue and map out of sync!!
+
+	BlockEmergeData *bedata = iter->second;
+	*flags = bedata->flags;
+	
+	emerge->peer_queue_count[bedata->peer_requested]--;
+
+	delete bedata;
+	emerge->blocks_enqueued.erase(iter);
+	
+	return true;
+}
+
+
+bool EmergeThread::getBlockOrStartGen(v3s16 p, MapBlock **b, 
+									BlockMakeData *data, bool allow_gen) {
+	v2s16 p2d(p.X, p.Z);
+	//envlock: usually takes <=1ms, sometimes 90ms or ~400ms to acquire
+	JMutexAutoLock envlock(m_server->m_env_mutex); 
+	
+	// Load sector if it isn't loaded
+	if (map->getSectorNoGenerateNoEx(p2d) == NULL)
+		map->loadSectorMeta(p2d);
+
+	// Attempt to load block
+	MapBlock *block = map->getBlockNoCreateNoEx(p);
+	if (!block || block->isDummy() || !block->isGenerated()) {
+		EMERGE_DBG_OUT("not in memory, attempting to load from disk");
+		block = map->loadBlock(p);
+	}
+
+	// If could not load and allowed to generate,
+	// start generation inside this same envlock
+	if (allow_gen && (block == NULL || !block->isGenerated())) {
+		EMERGE_DBG_OUT("generating");
+		*b = block;
+		return map->initBlockMake(data, p);
+	}
+	
+	*b = block;
+	return false;
+}
+
+
+void *EmergeThread::Thread() {
+	ThreadStarted();
+	log_register_thread("EmergeThread" + id);
+	DSTACK(__FUNCTION_NAME);
+	BEGIN_DEBUG_EXCEPTION_HANDLER
+
+	v3s16 last_tried_pos(-32768,-32768,-32768); // For error output
+	v3s16 p;
+	u8 flags;
+	
+	map    = (ServerMap *)&(m_server->m_env->getMap());
+	emerge = m_server->m_emerge;
+	mapgen = emerge->mapgen[id];
+	enable_mapgen_debug_info = emerge->mapgen_debug_info;
+	
+	while (getRun())
+	try {
+		if (!popBlockEmerge(&p, &flags)) {
+			qevent.wait();
+			continue;
+		}
+
+		last_tried_pos = p;
+		if (blockpos_over_limit(p))
+			continue;
+
+		bool allow_generate = flags & BLOCK_EMERGE_ALLOWGEN;
+		EMERGE_DBG_OUT("p=" PP(p) " allow_generate=" << allow_generate);
+		
+		/*
+			Try to fetch block from memory or disk.
+			If not found and asked to generate, initialize generator.
+		*/
+		BlockMakeData data;
+		MapBlock *block = NULL;
+		core::map<v3s16, MapBlock *> modified_blocks;
+		
+		if (getBlockOrStartGen(p, &block, &data, allow_generate)) {
+			{
+				ScopeProfiler sp(g_profiler, "EmergeThread: Mapgen::makeChunk", SPT_AVG);
+				TimeTaker t("mapgen::make_block()");
+
+				mapgen->makeChunk(&data);
+
+				if (enable_mapgen_debug_info == false)
+					t.stop(true); // Hide output
+			}
+
+			{
+				//envlock: usually 0ms, but can take either 30 or 400ms to acquire
+				JMutexAutoLock envlock(m_server->m_env_mutex); 
+				ScopeProfiler sp(g_profiler, "EmergeThread: after "
+						"Mapgen::makeChunk (envlock)", SPT_AVG);
+
+				map->finishBlockMake(&data, modified_blocks);
+				
+				block = map->getBlockNoCreateNoEx(p);
+				if (block) {
+					/*
+						Do some post-generate stuff
+					*/
+					v3s16 minp = data.blockpos_min * MAP_BLOCKSIZE;
+					v3s16 maxp = data.blockpos_max * MAP_BLOCKSIZE +
+								 v3s16(1,1,1) * (MAP_BLOCKSIZE - 1);
+
+					// Ignore map edit events, they will not need to be sent
+					// to anybody because the block hasn't been sent to anybody
+					MapEditEventAreaIgnorer 
+						ign(&m_server->m_ignore_map_edit_events_area,
+						VoxelArea(minp, maxp));
+					{  // takes about 90ms with -O1 on an e3-1230v2
+						scriptapi_environment_on_generated(m_server->m_lua,
+								minp, maxp, emerge->getBlockSeed(minp));
+					}
+
+					EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
+					
+					m_server->m_env->activateBlock(block, 0);
+				}
+			}
+		}
+
+		/*
+			Set sent status of modified blocks on clients
+		*/
+
+		// NOTE: Server's clients are also behind the connection mutex
+		//conlock: consistently takes 30-40ms to acquire
+		JMutexAutoLock lock(m_server->m_con_mutex);
+		// Add the originally fetched block to the modified list
+		if (block)
+			modified_blocks.insert(p, block);
+
+		// Set the modified blocks unsent for all the clients
+		for (core::map<u16, RemoteClient*>::Iterator
+			 i = m_server->m_clients.getIterator();
+			 i.atEnd() == false; i++) {
+			RemoteClient *client = i.getNode()->getValue();
+			if (modified_blocks.size() > 0) {
+				// Remove block from sent history
+				client->SetBlocksNotSent(modified_blocks);
+			}
+		}
+	}
+	catch (VersionMismatchException &e) {
+		std::ostringstream err;
+		err << "World data version mismatch in MapBlock "<<PP(last_tried_pos)<<std::endl;
+		err << "----"<<std::endl;
+		err << "\""<<e.what()<<"\""<<std::endl;
+		err << "See debug.txt."<<std::endl;
+		err << "World probably saved by a newer version of Minetest."<<std::endl;
+		m_server->setAsyncFatalError(err.str());
+	}
+	catch (SerializationError &e) {
+		std::ostringstream err;
+		err << "Invalid data in MapBlock "<<PP(last_tried_pos)<<std::endl;
+		err << "----"<<std::endl;
+		err << "\""<<e.what()<<"\""<<std::endl;
+		err << "See debug.txt."<<std::endl;
+		err << "You can ignore this using [ignore_world_load_errors = true]."<<std::endl;
+		m_server->setAsyncFatalError(err.str());
+	}
+	
+	END_DEBUG_EXCEPTION_HANDLER(errorstream)
+	log_deregister_thread();
+	return NULL;
+}
diff --git a/src/emerge.h b/src/emerge.h
new file mode 100644
index 000000000..70b67e731
--- /dev/null
+++ b/src/emerge.h
@@ -0,0 +1,128 @@
+#ifndef EMERGE_HEADER
+#define EMERGE_HEADER
+
+#include <map>
+#include <queue>
+#include "util/thread.h"
+
+#define BLOCK_EMERGE_ALLOWGEN (1<<0)
+
+#define EMERGE_DBG_OUT(x) \
+	{ if (enable_mapgen_debug_info) \
+	infostream << "EmergeThread: " x << std::endl; }
+
+class Mapgen;
+class MapgenParams;
+class MapgenFactory;
+class Biome;
+class BiomeDefManager;
+class EmergeThread;
+class ManualMapVoxelManipulator;
+
+#include "server.h"
+
+struct BlockMakeData {
+	ManualMapVoxelManipulator *vmanip;
+	u64 seed;
+	v3s16 blockpos_min;
+	v3s16 blockpos_max;
+	v3s16 blockpos_requested;
+	UniqueQueue<v3s16> transforming_liquid;
+	INodeDefManager *nodedef;
+
+	BlockMakeData():
+		vmanip(NULL),
+		seed(0),
+		nodedef(NULL)
+	{}
+
+	~BlockMakeData() { delete vmanip; }
+};
+
+struct BlockEmergeData {
+	u16 peer_requested;
+	u8 flags;
+};
+
+class EmergeManager {
+public:
+	std::map<std::string, MapgenFactory *> mglist;
+	
+	std::vector<Mapgen *> mapgen;
+	std::vector<EmergeThread *> emergethread;
+	
+	//settings
+	MapgenParams *params;
+	bool mapgen_debug_info;
+	u16 qlimit_total;
+	u16 qlimit_diskonly;
+	u16 qlimit_generate;
+	
+	//block emerge queue data structures
+	JMutex queuemutex;
+	std::map<v3s16, BlockEmergeData *> blocks_enqueued;
+	std::map<u16, u16> peer_queue_count;
+
+	//biome manager
+	BiomeDefManager *biomedef;
+
+	EmergeManager(IGameDef *gamedef, BiomeDefManager *bdef);
+	~EmergeManager();
+
+	void initMapgens(MapgenParams *mgparams);
+	Mapgen *createMapgen(std::string mgname, int mgid,
+						MapgenParams *mgparams);
+	MapgenParams *createMapgenParams(std::string mgname);
+	bool enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate);
+	
+	void registerMapgen(std::string name, MapgenFactory *mgfactory);
+	MapgenParams *getParamsFromSettings(Settings *settings);
+	void setParamsToSettings(Settings *settings);
+	
+	//mapgen helper methods
+	Biome *getBiomeAtPoint(v3s16 p);
+	int getGroundLevelAtPoint(v2s16 p);
+	bool isBlockUnderground(v3s16 blockpos);
+	u32 getBlockSeed(v3s16 p);
+};
+
+class EmergeThread : public SimpleThread
+{
+	Server *m_server;
+	ServerMap *map;
+	EmergeManager *emerge;
+	Mapgen *mapgen;
+	bool enable_mapgen_debug_info;
+	int id;
+	
+public:
+	Event qevent;
+	std::queue<v3s16> blockqueue;
+	
+	EmergeThread(Server *server, int ethreadid):
+		SimpleThread(),
+		m_server(server),
+		map(NULL),
+		emerge(NULL),
+		mapgen(NULL),
+		id(ethreadid)
+	{
+	}
+
+	void *Thread();
+
+	void trigger()
+	{
+		setRun(true);
+		if(IsRunning() == false)
+		{
+			Start();
+		}
+	}
+
+	bool popBlockEmerge(v3s16 *pos, u8 *flags);
+	bool getBlockOrStartGen(v3s16 p, MapBlock **b, 
+							BlockMakeData *data, bool allow_generate);
+};
+
+#endif
diff --git a/src/environment.cpp b/src/environment.cpp
index 51255b918..e939672e7 100644
--- a/src/environment.cpp
+++ b/src/environment.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -2065,20 +2065,37 @@ void ClientEnvironment::step(float dtime)
 			{
 				// Gravity
 				v3f speed = lplayer->getSpeed();
-				if(lplayer->swimming_up == false)
-					speed.Y -= 9.81 * BS * dtime_part * 2;
+				if(lplayer->in_liquid == false)
+					speed.Y -= lplayer->movement_gravity * dtime_part * 2;
 
-				// Water resistance
-				if(lplayer->in_water_stable || lplayer->in_water)
-				{
-					f32 max_down = 2.0*BS;
-					if(speed.Y < -max_down) speed.Y = -max_down;
+				// Liquid floating / sinking
+				if(lplayer->in_liquid && !lplayer->swimming_vertical)
+					speed.Y -= lplayer->movement_liquid_sink * dtime_part * 2;
 
-					f32 max = 2.5*BS;
-					if(speed.getLength() > max)
-					{
-						speed = speed / speed.getLength() * max;
-					}
+				// Liquid resistance
+				if(lplayer->in_liquid_stable || lplayer->in_liquid)
+				{
+					// How much the node's viscosity blocks movement, ranges between 0 and 1
+					// Should match the scale at which viscosity increase affects other liquid attributes
+					const f32 viscosity_factor = 0.3;
+
+					v3f d_wanted = -speed / lplayer->movement_liquid_fluidity;
+					f32 dl = d_wanted.getLength();
+					if(dl > lplayer->movement_liquid_fluidity_smooth)
+						dl = lplayer->movement_liquid_fluidity_smooth;
+					dl *= (lplayer->liquid_viscosity * viscosity_factor) + (1 - viscosity_factor);
+					
+					v3f d = d_wanted.normalize() * dl;
+					speed += d;
+					
+#if 0 // old code
+					if(speed.X > lplayer->movement_liquid_fluidity + lplayer->movement_liquid_fluidity_smooth)	speed.X -= lplayer->movement_liquid_fluidity_smooth;
+					if(speed.X < -lplayer->movement_liquid_fluidity - lplayer->movement_liquid_fluidity_smooth)	speed.X += lplayer->movement_liquid_fluidity_smooth;
+					if(speed.Y > lplayer->movement_liquid_fluidity + lplayer->movement_liquid_fluidity_smooth)	speed.Y -= lplayer->movement_liquid_fluidity_smooth;
+					if(speed.Y < -lplayer->movement_liquid_fluidity - lplayer->movement_liquid_fluidity_smooth)	speed.Y += lplayer->movement_liquid_fluidity_smooth;
+					if(speed.Z > lplayer->movement_liquid_fluidity + lplayer->movement_liquid_fluidity_smooth)	speed.Z -= lplayer->movement_liquid_fluidity_smooth;
+					if(speed.Z < -lplayer->movement_liquid_fluidity - lplayer->movement_liquid_fluidity_smooth)	speed.Z += lplayer->movement_liquid_fluidity_smooth;
+#endif
 				}
 
 				lplayer->setSpeed(speed);
diff --git a/src/environment.h b/src/environment.h
index d1e61967f..07a4d7635 100644
--- a/src/environment.h
+++ b/src/environment.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -40,7 +40,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "mapnode.h"
 #include "mapblock.h"
 
-class Server;
 class ServerEnvironment;
 class ActiveBlockModifier;
 class ServerActiveObject;
diff --git a/src/event.h b/src/event.h
index 9e7a0dbf5..cfc222d5d 100644
--- a/src/event.h
+++ b/src/event.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/event_manager.h b/src/event_manager.h
index 9bc8e35eb..33d99b28c 100644
--- a/src/event_manager.h
+++ b/src/event_manager.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/exceptions.h b/src/exceptions.h
index 35a57d070..458fb50b1 100644
--- a/src/exceptions.h
+++ b/src/exceptions.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/farmesh.cpp b/src/farmesh.cpp
index 23f3db5f6..443e2b3bf 100644
--- a/src/farmesh.cpp
+++ b/src/farmesh.cpp
@@ -1,6 +1,6 @@
 /*
-Part of Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Part of Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/farmesh.h b/src/farmesh.h
index 2eaf7d486..47147fa8f 100644
--- a/src/farmesh.h
+++ b/src/farmesh.h
@@ -1,6 +1,6 @@
 /*
-Part of Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Part of Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/filecache.cpp b/src/filecache.cpp
index 716c769aa..23df1d7d0 100644
--- a/src/filecache.cpp
+++ b/src/filecache.cpp
@@ -1,7 +1,7 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2012 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/filecache.h b/src/filecache.h
index da7e59f6a..cf59a8e5b 100644
--- a/src/filecache.h
+++ b/src/filecache.h
@@ -1,7 +1,7 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2012 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/filesys.cpp b/src/filesys.cpp
index bf26c8dac..256c8f16a 100644
--- a/src/filesys.cpp
+++ b/src/filesys.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/filesys.h b/src/filesys.h
index b7e6f3715..263eb796f 100644
--- a/src/filesys.h
+++ b/src/filesys.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/game.cpp b/src/game.cpp
index e923cbbb0..1ae29b13b 100644
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -29,6 +29,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "server.h"
 #include "guiPauseMenu.h"
 #include "guiPasswordChange.h"
+#include "guiVolumeChange.h"
 #include "guiFormSpecMenu.h"
 #include "guiTextInputMenu.h"
 #include "guiDeathScreen.h"
@@ -1262,7 +1263,7 @@ void the_game(
 	gui::IGUIStaticText *guitext_info = guienv->addStaticText(
 			L"",
 			core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
-			false, false);
+			false, true);
 	
 	// Status text (displays info when showing and hiding GUI stuff, etc.)
 	gui::IGUIStaticText *guitext_status = guienv->addStaticText(
@@ -1519,6 +1520,13 @@ void the_game(
 			g_gamecallback->changepassword_requested = false;
 		}
 
+		if(g_gamecallback->changevolume_requested)
+		{
+			(new GUIVolumeChange(guienv, guiroot, -1,
+				&g_menumgr, &client))->drop();
+			g_gamecallback->changevolume_requested = false;
+		}
+
 		/* Process TextureSource's queue */
 		tsrc->processQueue();
 
@@ -2531,7 +2539,8 @@ void the_game(
 					// make that happen
 					const ItemDefinition &def =
 							playeritem.getDefinition(itemdef);
-					if(def.node_placement_prediction != "")
+					if(def.node_placement_prediction != ""
+							&& !nodedef->get(map.getNode(nodepos)).rightclickable)
 					do{ // breakable
 						verbosestream<<"Node placement prediction for "
 								<<playeritem.name<<" is "
@@ -2807,12 +2816,12 @@ void the_game(
 			char temptext[300];
 			snprintf(temptext, 300,
 					"(% .1f, % .1f, % .1f)"
-					" (yaw = %.1f) (seed = %lli)",
+					" (yaw = %.1f) (seed = %llu)",
 					player_position.X/BS,
 					player_position.Y/BS,
 					player_position.Z/BS,
 					wrapDegrees_0_360(camera_yaw),
-					client.getMapSeed());
+					(unsigned long long)client.getMapSeed());
 
 			guitext2->setText(narrow_to_wide(temptext).c_str());
 			guitext2->setVisible(true);
diff --git a/src/game.h b/src/game.h
index b74a7a8da..fef777fea 100644
--- a/src/game.h
+++ b/src/game.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/gamedef.h b/src/gamedef.h
index 6fc99b9f1..1d46b028e 100644
--- a/src/gamedef.h
+++ b/src/gamedef.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/genericobject.cpp b/src/genericobject.cpp
index 398b07feb..f7b272b00 100644
--- a/src/genericobject.cpp
+++ b/src/genericobject.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/genericobject.h b/src/genericobject.h
index b69c24b48..9a21baa67 100644
--- a/src/genericobject.h
+++ b/src/genericobject.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/gettext.h b/src/gettext.h
index 54470cb0d..452787de4 100644
--- a/src/gettext.h
+++ b/src/gettext.h
@@ -12,6 +12,11 @@
 #define gettext_noop(String) String
 #define N_(String) gettext_noop (String)
 
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
 inline void init_gettext(const char *path) {
 #if USE_GETTEXT
 	// don't do this if MSVC compiler is used, it gives an assertion fail
@@ -20,14 +25,44 @@ inline void init_gettext(const char *path) {
 	#endif
 	bindtextdomain(PROJECT_NAME, path);
 	textdomain(PROJECT_NAME);
+#if defined(_WIN32)
+	// As linux is successfully switched to UTF-8 completely at about year 2005
+	// Windows still uses obsolete codepage based locales because you
+	// cannot recompile closed-source applications
+
+	// Set character encoding for Win32
+	char *tdomain = textdomain( (char *) NULL );
+	if( tdomain == NULL )
+	{
+		fprintf( stderr, "warning: domainname parameter is the null pointer, default domain is not set\n" );
+		tdomain = (char *) "messages";
+	}
+	/*char *codeset = */bind_textdomain_codeset( tdomain, "UTF-8" );
+	//fprintf( stdout, "%s: debug: domainname = %s; codeset = %s\n", argv[0], tdomain, codeset );
+#endif // defined(_WIN32)
 #endif
 }
 
 inline wchar_t* chartowchar_t(const char *str)
 {
+	wchar_t* nstr = 0;
+#if defined(_WIN32)
+	int nResult = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) str, -1, 0, 0 );
+	if( nResult == 0 )
+	{
+		fprintf( stderr, "error: MultiByteToWideChar returned null\n" );
+	}
+	else
+	{
+		nstr = new wchar_t[nResult];
+		MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) str, -1, (WCHAR *) nstr, nResult );
+	}
+#else
 	size_t l = strlen(str)+1;
-	wchar_t* nstr = new wchar_t[l];
+	nstr = new wchar_t[l];
 	mbstowcs(nstr, str, l);
+#endif
+
 	return nstr;
 }
 
@@ -38,12 +73,12 @@ inline wchar_t* wgettext(const char *str)
 
 inline void changeCtype(const char *l)
 {
-	char *ret = NULL;
+	/*char *ret = NULL;
 	ret = setlocale(LC_CTYPE, l);
 	if(ret == NULL)
 		infostream<<"locale could not be set"<<std::endl;
 	else
-		infostream<<"locale has been set to:"<<ret<<std::endl;
+		infostream<<"locale has been set to:"<<ret<<std::endl;*/
 }
 #define GETTEXT_HEADER
 #endif
diff --git a/src/gettime.h b/src/gettime.h
index b5cb830cc..611906559 100644
--- a/src/gettime.h
+++ b/src/gettime.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiChatConsole.cpp b/src/guiChatConsole.cpp
index 0101b99bb..f522af01f 100644
--- a/src/guiChatConsole.cpp
+++ b/src/guiChatConsole.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -32,6 +32,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "gettext.h"
 
+#if USE_FREETYPE
+#include "xCGUITTFont.h"
+#endif
+
 inline u32 clamp_u8(s32 value)
 {
 	return (u32) MYMIN(MYMAX(value, 0), 255);
@@ -90,8 +94,14 @@ GUIChatConsole::GUIChatConsole(
 
 	// load the font
 	// FIXME should a custom texture_path be searched too?
+	#if USE_FREETYPE
+	std::string font_name = g_settings->get("mono_font_path");
+	u16 font_size = g_settings->getU16("mono_font_size");
+	m_font = gui::CGUITTFont::createTTFont(env, font_name.c_str(), font_size);
+	#else
 	std::string font_name = "fontdejavusansmono.png";
 	m_font = env->getFont(getTexturePath(font_name).c_str());
+	#endif
 	if (m_font == NULL)
 	{
 		dstream << "Unable to load font: " << font_name << std::endl;
diff --git a/src/guiChatConsole.h b/src/guiChatConsole.h
index 033a26244..c896aae28 100644
--- a/src/guiChatConsole.h
+++ b/src/guiChatConsole.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiConfigureWorld.cpp b/src/guiConfigureWorld.cpp
index 38f1a554d..080691222 100644
--- a/src/guiConfigureWorld.cpp
+++ b/src/guiConfigureWorld.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -414,8 +414,9 @@ bool GUIConfigureWorld::OnEvent(const SEvent& event)
 				else if(selected_node != NULL && selected_node->getText() != NULL)
 				{  
 					std::string modname = wide_to_narrow(selected_node->getText());
-					ModSpec mod = m_addonmods[modname];
-					enableAllMods(mod.modpack_content,true);
+					std::map<std::string, ModSpec>::iterator mod_it = m_addonmods.find(modname);
+					if(mod_it != m_addonmods.end())
+						enableAllMods(mod_it->second.modpack_content,true);
 				}
 				return true;
 			}
@@ -427,8 +428,9 @@ bool GUIConfigureWorld::OnEvent(const SEvent& event)
 				if(selected_node != NULL && selected_node->getText() != NULL)
 				{
 					std::string modname = wide_to_narrow(selected_node->getText());
-					ModSpec mod = m_addonmods[modname];
-					enableAllMods(mod.modpack_content,false);
+					std::map<std::string, ModSpec>::iterator mod_it = m_addonmods.find(modname);
+					if(mod_it != m_addonmods.end())
+						enableAllMods(mod_it->second.modpack_content,false);
 				}
 				return true;
 			}
@@ -446,7 +448,7 @@ bool GUIConfigureWorld::OnEvent(const SEvent& event)
 			return true;
 		}
 		if(event.GUIEvent.EventType==gui::EGET_TREEVIEW_NODE_SELECT &&
-			event.GUIEvent.Caller->getID() == GUI_ID_MOD_TREEVIEW)
+		   event.GUIEvent.Caller->getID() == GUI_ID_MOD_TREEVIEW)
 		{
 			selecting_dep = -1;
 			selecting_rdep = -1;
@@ -560,42 +562,49 @@ void GUIConfigureWorld::adjustSidebar()
 		modname_w = L"N/A";
 	std::string modname = wide_to_narrow(modname_w);
 
-	// if no mods installed, don't show buttons or checkbox on the sidebar
+	ModSpec mspec;
+	std::map<std::string, ModSpec>::iterator it = m_addonmods.find(modname);
+	if(it != m_addonmods.end())
+		mspec = it->second;
+
+	m_dependencies_listbox->clear();
+	m_rdependencies_listbox->clear();
+
+	// if no mods installed, there is nothing to enable/disable, so we
+	// don't show buttons or checkbox on the sidebar
 	if(node->getParent() == m_treeview->getRoot() && !node->hasChilds())
 	{
 		m_disableall->setVisible(false);
 		m_enableall->setVisible(false);
 		m_enabled_checkbox->setVisible(false);
+		return;
 	} 
-	else
+	
+    // a modpack is not enabled/disabled by itself, only its cotnents
+    // are. so we show show enable/disable all buttons, but hide the
+    // checkbox
+	if(node->getParent() == m_treeview->getRoot() ||
+	   mspec.is_modpack)
 	{
-		// if modpack, show enable/disable all buttons. otherwise, show
-		// enabled checkbox
-		if(node->getParent() == m_treeview->getRoot() ||
-		   m_addonmods[modname].is_modpack)
-		{
-			m_enabled_checkbox->setVisible(false);
-			m_disableall->setVisible(true);
-			m_enableall->setVisible(true);
-			m_modname_text->setText((L"Modpack: "+modname_w).c_str());
-		}	
-		else	
-		{
-			m_disableall->setVisible(false);
-			m_enableall->setVisible(false);
-			m_enabled_checkbox->setVisible(true);
-			m_modname_text->setText((L"Mod: "+modname_w).c_str());
-		}
-	}
+		m_enabled_checkbox->setVisible(false);
+		m_disableall->setVisible(true);
+		m_enableall->setVisible(true);
+		m_modname_text->setText((L"Modpack: "+modname_w).c_str());
+		return;
+	}	
+
+	// for a normal mod, we hide the enable/disable all buttons, but show the checkbox.
+	m_disableall->setVisible(false);
+	m_enableall->setVisible(false);
+	m_enabled_checkbox->setVisible(true);
+	m_modname_text->setText((L"Mod: "+modname_w).c_str());
+
 	// the mod is enabled unless it is disabled in the world.mt settings. 
 	bool mod_enabled = true;
 	if(m_settings.exists("load_mod_"+modname))
 		mod_enabled = m_settings.getBool("load_mod_"+modname);
 	m_enabled_checkbox->setChecked(mod_enabled);
 
-	// dependencies of this mod:
-	m_dependencies_listbox->clear();
-	ModSpec mspec = m_addonmods[modname];
 	for(std::set<std::string>::iterator it=mspec.depends.begin();
 		it != mspec.depends.end(); ++it)
 	{
@@ -611,9 +620,7 @@ void GUIConfigureWorld::adjustSidebar()
 		m_dependencies_listbox->addItem(narrow_to_wide(dependency).c_str());
 	}
 
-
 	// reverse dependencies of this mod:
-	m_rdependencies_listbox->clear();
 	std::pair< std::multimap<std::string, std::string>::iterator, 
 			std::multimap<std::string, std::string>::iterator > rdep = 
 		m_reverse_depends.equal_range(modname);
@@ -639,19 +646,25 @@ void GUIConfigureWorld::enableAllMods(std::map<std::string, ModSpec> mods,bool e
 			enableAllMods(mod.modpack_content,enable);
 		else // not a modpack
 			setEnabled(mod.name, enable);
+
 	}
 }
 
 void GUIConfigureWorld::enableMod(std::string modname)
 {
+	std::map<std::string, ModSpec>::iterator mod_it = m_addonmods.find(modname);
+	if(mod_it == m_addonmods.end()){
+		errorstream << "enableMod() called with invalid mod name \"" << modname << "\"" << std::endl;
+		return;
+	}
+	ModSpec mspec = mod_it->second;
 	m_settings.setBool("load_mod_"+modname,true);
 	std::map<std::string,gui::IGUITreeViewNode*>::iterator it = 
 		m_nodes.find(modname);
- 	if(it != m_nodes.end())
+	if(it != m_nodes.end())
 		(*it).second->setIcon(CHECKMARK_STR);
 	m_new_mod_names.erase(modname);
 	//also enable all dependencies
-	ModSpec mspec = m_addonmods[modname];
 	for(std::set<std::string>::iterator it=mspec.depends.begin();
 		it != mspec.depends.end(); ++it)
 	{
@@ -664,6 +677,12 @@ void GUIConfigureWorld::enableMod(std::string modname)
 
 void GUIConfigureWorld::disableMod(std::string modname)
 {
+	std::map<std::string, ModSpec>::iterator mod_it = m_addonmods.find(modname);
+	if(mod_it == m_addonmods.end()){
+		errorstream << "disableMod() called with invalid mod name \"" << modname << "\"" << std::endl;
+		return;
+	}
+
 	m_settings.setBool("load_mod_"+modname,false);
 	std::map<std::string,gui::IGUITreeViewNode*>::iterator it = 
 		m_nodes.find(modname);
diff --git a/src/guiConfigureWorld.h b/src/guiConfigureWorld.h
index 2280c6dbe..8a77c5f89 100644
--- a/src/guiConfigureWorld.h
+++ b/src/guiConfigureWorld.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiConfirmMenu.cpp b/src/guiConfirmMenu.cpp
index 299110070..70e33c760 100644
--- a/src/guiConfirmMenu.cpp
+++ b/src/guiConfirmMenu.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiConfirmMenu.h b/src/guiConfirmMenu.h
index b9fb2cd53..7d217d6a6 100644
--- a/src/guiConfirmMenu.h
+++ b/src/guiConfirmMenu.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiCreateWorld.cpp b/src/guiCreateWorld.cpp
index a4c528b3e..8ac3fb17c 100644
--- a/src/guiCreateWorld.cpp
+++ b/src/guiCreateWorld.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiCreateWorld.h b/src/guiCreateWorld.h
index 492fcf565..d9bc3638a 100644
--- a/src/guiCreateWorld.h
+++ b/src/guiCreateWorld.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiDeathScreen.cpp b/src/guiDeathScreen.cpp
index 4a767c43c..ba329e3be 100644
--- a/src/guiDeathScreen.cpp
+++ b/src/guiDeathScreen.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiDeathScreen.h b/src/guiDeathScreen.h
index 3c0307634..261053a51 100644
--- a/src/guiDeathScreen.h
+++ b/src/guiDeathScreen.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiFormSpecMenu.cpp b/src/guiFormSpecMenu.cpp
index a1da09ee1..120d6629a 100644
--- a/src/guiFormSpecMenu.cpp
+++ b/src/guiFormSpecMenu.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiFormSpecMenu.h b/src/guiFormSpecMenu.h
index 86235900d..aee16736e 100644
--- a/src/guiFormSpecMenu.h
+++ b/src/guiFormSpecMenu.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiKeyChangeMenu.cpp b/src/guiKeyChangeMenu.cpp
index 3f6d03ebb..4569f3d9d 100644
--- a/src/guiKeyChangeMenu.cpp
+++ b/src/guiKeyChangeMenu.cpp
@@ -1,8 +1,8 @@
 /*
- Minetest-c55
- Copyright (C) 2010-11 celeron55, Perttu Ahola <celeron55@gmail.com>
- Copyright (C) 2011 Ciaran Gultnieks <ciaran@ciarang.com>
- Copyright (C) 2011 teddydestodes <derkomtur@schattengang.net>
+ Minetest
+ Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+ Copyright (C) 2013 Ciaran Gultnieks <ciaran@ciarang.com>
+ Copyright (C) 2013 teddydestodes <derkomtur@schattengang.net>
 
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiKeyChangeMenu.h b/src/guiKeyChangeMenu.h
index beb4f0b6f..2b498676b 100644
--- a/src/guiKeyChangeMenu.h
+++ b/src/guiKeyChangeMenu.h
@@ -1,8 +1,8 @@
 /*
- Minetest-c55
- Copyright (C) 2010-11 celeron55, Perttu Ahola <celeron55@gmail.com>
- Copyright (C) 2011 Ciaran Gultnieks <ciaran@ciarang.com>
- Copyright (C) 2011 teddydestodes <derkomtur@schattengang.net>
+ Minetest
+ Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+ Copyright (C) 2013 Ciaran Gultnieks <ciaran@ciarang.com>
+ Copyright (C) 2013 teddydestodes <derkomtur@schattengang.net>
 
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiMainMenu.cpp b/src/guiMainMenu.cpp
index 9291bb4ec..c2e68579e 100644
--- a/src/guiMainMenu.cpp
+++ b/src/guiMainMenu.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-12 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -108,6 +108,7 @@ enum
 	GUI_ID_ENABLE_PARTICLES_CB,
 	GUI_ID_DAMAGE_CB,
 	GUI_ID_CREATIVE_CB,
+	GUI_ID_PUBLIC_CB,
 	GUI_ID_JOIN_GAME_BUTTON,
 	GUI_ID_CHANGE_KEYS_BUTTON,
 	GUI_ID_DELETE_WORLD_BUTTON,
@@ -260,7 +261,7 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			//const wchar_t *text = L"H\nY\nB\nR\nI\nD";
 			const wchar_t *text = L"T\nA\nP\nE\n\nA\nN\nD\n\nG\nL\nU\nE";
 			gui::IGUIStaticText *t =
-			Environment->addStaticText(text, rect, false, false, this, -1);
+			Environment->addStaticText(text, rect, false, true, this, -1);
 			t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 		}
 		u32 bs = 5;
@@ -359,7 +360,7 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			rect += m_topleft_client + v2s32(15, 0);
 			const wchar_t *text = L"C\nL\nI\nE\nN\nT";
 			gui::IGUIStaticText *t =
-			Environment->addStaticText(text, rect, false, false, this, -1);
+			Environment->addStaticText(text, rect, false, true, this, -1);
 			t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 		}
 		// Nickname + password
@@ -469,7 +470,7 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			rect += m_topleft_client + v2s32(15, 0);
 			const wchar_t *text = L"C\nL\nI\nE\nN\nT";
 			gui::IGUIStaticText *t =
-			Environment->addStaticText(text, rect, false, false, this, -1);
+			Environment->addStaticText(text, rect, false, true, this, -1);
 			t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 		}
 		// Nickname + password
@@ -546,7 +547,7 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			rect += m_topleft_server + v2s32(15, 0);
 			const wchar_t *text = L"S\nE\nR\nV\nE\nR";
 			gui::IGUIStaticText *t =
-			Environment->addStaticText(text, rect, false, false, this, -1);
+			Environment->addStaticText(text, rect, false, true, this, -1);
 			t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 		}
 		// Server parameters
@@ -562,6 +563,14 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			Environment->addCheckBox(m_data->enable_damage, rect, this, GUI_ID_DAMAGE_CB,
 				wgettext("Enable Damage"));
 		}
+		#if USE_CURL
+		{
+			core::rect<s32> rect(0, 0, 250, 30);
+			rect += m_topleft_server + v2s32(30+20+250+20, 60);
+			Environment->addCheckBox(m_data->enable_public, rect, this, GUI_ID_PUBLIC_CB,
+				wgettext("Public"));
+		}
+		#endif
 		// Delete world button
 		{
 			core::rect<s32> rect(0, 0, 130, 30);
@@ -598,7 +607,7 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			rect += m_topleft_client + v2s32(15, 0);
 			const wchar_t *text = L"S\nE\nT\nT\nI\nN\nG\nS";
 			gui::IGUIStaticText *t =
-			Environment->addStaticText(text, rect, false, false, this, -1);
+			Environment->addStaticText(text, rect, false, true, this, -1);
 			t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 		}
 		s32 option_x = 70;
@@ -701,7 +710,7 @@ void GUIMainMenu::regenerateGui(v2u32 screensize)
 			rect += m_topleft_client + v2s32(15, 0);
 			const wchar_t *text = L"C\nR\nE\nD\nI\nT\nS";
 			gui::IGUIStaticText *t =
-			Environment->addStaticText(text, rect, false, false, this, -1);
+			Environment->addStaticText(text, rect, false, true, this, -1);
 			t->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER);
 		}
 		{
@@ -842,6 +851,11 @@ void GUIMainMenu::readInput(MainMenuData *dst)
 			dst->enable_damage = ((gui::IGUICheckBox*)e)->isChecked();
 	}
 	{
+		gui::IGUIElement *e = getElementFromId(GUI_ID_PUBLIC_CB);
+		if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
+			dst->enable_public = ((gui::IGUICheckBox*)e)->isChecked();
+	}
+	{
 		gui::IGUIElement *e = getElementFromId(GUI_ID_FANCYTREE_CB);
 		if(e != NULL && e->getType() == gui::EGUIET_CHECK_BOX)
 			dst->fancy_trees = ((gui::IGUICheckBox*)e)->isChecked();
@@ -912,8 +926,8 @@ void GUIMainMenu::readInput(MainMenuData *dst)
 	{
 		ServerListSpec server =
 		getServerListSpec(wide_to_narrow(dst->address), wide_to_narrow(dst->port));
-		dst->servername = server.name;
-		dst->serverdescription = server.description;
+		dst->servername = server["name"].asString();
+		dst->serverdescription = server["description"].asString();
 	}
 }
 
@@ -1174,13 +1188,31 @@ void GUIMainMenu::updateGuiServerList()
 		i != m_data->servers.end(); i++)
 	{
 		std::string text;
-		if (i->name != "" && i->description != "")
-			text = i->name + " (" + i->description + ")";
-		else if (i->name !="")
-			text = i->name;
-		else
-			text = i->address + ":" + i->port;
 
+		if ((*i)["clients"].asString().size())
+			text += (*i)["clients"].asString();
+		if ((*i)["clients_max"].asString().size())
+			text += "/" + (*i)["clients_max"].asString();
+		text += " ";
+		if ((*i)["version"].asString().size())
+			text += (*i)["version"].asString() + " ";
+		if ((*i)["password"].asString().size())
+			text += "*";
+		if ((*i)["creative"].asString().size())
+			text += "C";
+		if ((*i)["damage"].asString().size())
+			text += "D";
+		if ((*i)["pvp"].asString().size())
+			text += "P";
+		text += " ";
+
+		if ((*i)["name"] != "" && (*i)["description"] != "")
+			text += (*i)["name"].asString() + " (" +  (*i)["description"].asString() + ")";
+		else if ((*i)["name"] !="")
+			text += (*i)["name"].asString();
+		else
+			text += (*i)["address"].asString() + ":" + (*i)["port"].asString();
+		
 		serverlist->addItem(narrow_to_wide(text).c_str());
 	}
 }
@@ -1191,26 +1223,26 @@ void GUIMainMenu::serverListOnSelected()
 	{
 		gui::IGUIListBox *serverlist = (gui::IGUIListBox*)getElementFromId(GUI_ID_SERVERLIST);
 		u16 id = serverlist->getSelected();
-		if (id < 0) return;
+		//if (id < 0) return; // u16>0!
 		((gui::IGUIEditBox*)getElementFromId(GUI_ID_ADDRESS_INPUT))
-		->setText(narrow_to_wide(m_data->servers[id].address).c_str());
+		->setText(narrow_to_wide(m_data->servers[id]["address"].asString()).c_str());
 		((gui::IGUIEditBox*)getElementFromId(GUI_ID_PORT_INPUT))
-		->setText(narrow_to_wide(m_data->servers[id].port).c_str());
+		->setText(narrow_to_wide(m_data->servers[id]["port"].asString()).c_str());
 	}
 }
 
 ServerListSpec GUIMainMenu::getServerListSpec(std::string address, std::string port)
 {
 	ServerListSpec server;
-	server.address = address;
-	server.port = port;
+	server["address"] = address;
+	server["port"] = port;
 	for(std::vector<ServerListSpec>::iterator i = m_data->servers.begin();
 		i != m_data->servers.end(); i++)
 	{
-		if (i->address == address && i->port == port)
+		if ((*i)["address"] == address && (*i)["port"] == port)
 		{
-			server.description = i->description;
-			server.name = i->name;
+			server["description"] = (*i)["description"];
+			server["name"] = (*i)["name"];
 			break;
 		}
 	}
diff --git a/src/guiMainMenu.h b/src/guiMainMenu.h
index 2c657cb23..a21f3b32a 100644
--- a/src/guiMainMenu.h
+++ b/src/guiMainMenu.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -55,6 +55,7 @@ struct MainMenuData
 	// Server options
 	bool creative_mode;
 	bool enable_damage;
+	bool enable_public;
 	int selected_world;
 	bool simple_singleplayer_mode;
 	// Actions
@@ -77,6 +78,7 @@ struct MainMenuData
 		// Server opts
 		creative_mode(false),
 		enable_damage(false),
+		enable_public(false),
 		selected_world(0),
 		simple_singleplayer_mode(false),
 		// Actions
diff --git a/src/guiMessageMenu.cpp b/src/guiMessageMenu.cpp
index 24d6f7f52..abb31cf2d 100644
--- a/src/guiMessageMenu.cpp
+++ b/src/guiMessageMenu.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiMessageMenu.h b/src/guiMessageMenu.h
index af2fc44a5..8ec8e4a41 100644
--- a/src/guiMessageMenu.h
+++ b/src/guiMessageMenu.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiPasswordChange.cpp b/src/guiPasswordChange.cpp
index ecae55e10..e4b77b611 100644
--- a/src/guiPasswordChange.cpp
+++ b/src/guiPasswordChange.cpp
@@ -1,7 +1,7 @@
 /*
-Part of Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2011 Ciaran Gultnieks <ciaran@ciarang.com>
+Part of Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Ciaran Gultnieks <ciaran@ciarang.com>
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
diff --git a/src/guiPasswordChange.h b/src/guiPasswordChange.h
index f5f767b5e..aecc7076f 100644
--- a/src/guiPasswordChange.h
+++ b/src/guiPasswordChange.h
@@ -1,7 +1,7 @@
 /*
-Part of Minetest-c55
-Copyright (C) 2010-11 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2011 Ciaran Gultnieks <ciaran@ciarang.com>
+Part of Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Ciaran Gultnieks <ciaran@ciarang.com>
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
diff --git a/src/guiPauseMenu.cpp b/src/guiPauseMenu.cpp
index f6cbf248f..dc95eef5b 100644
--- a/src/guiPauseMenu.cpp
+++ b/src/guiPauseMenu.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -79,6 +79,11 @@ void GUIPauseMenu::removeChildren()
 		if(e != NULL)
 			e->remove();
 	}
+	{
+		gui::IGUIElement *e = getElementFromId(262);
+		if(e != NULL)
+			e->remove();
+	}
 }
 
 void GUIPauseMenu::regenerateGui(v2u32 screensize)
@@ -108,7 +113,7 @@ void GUIPauseMenu::regenerateGui(v2u32 screensize)
 	*/
 	const s32 btn_height = 30;
 	const s32 btn_gap = 20;
-	const s32 btn_num = m_simple_singleplayer_mode ? 3 : 4;
+	const s32 btn_num = m_simple_singleplayer_mode ? 4 : 5;
 	s32 btn_y = size.Y/2-((btn_num*btn_height+(btn_num-1)*btn_gap))/2;
 	changeCtype("");
 	{
@@ -131,6 +136,13 @@ void GUIPauseMenu::regenerateGui(v2u32 screensize)
 	{
 		core::rect<s32> rect(0, 0, 140, btn_height);
 		rect = rect + v2s32(size.X/2-140/2, btn_y);
+		Environment->addButton(rect, this, 262,
+			wgettext("Sound Volume"));
+	}
+	btn_y += btn_height + btn_gap;
+	{
+		core::rect<s32> rect(0, 0, 140, btn_height);
+		rect = rect + v2s32(size.X/2-140/2, btn_y);
 		Environment->addButton(rect, this, 260,
 			wgettext("Exit to Menu"));
 	}
@@ -236,6 +248,10 @@ bool GUIPauseMenu::OnEvent(const SEvent& event)
 				quitMenu();
 				m_gamecallback->changePassword();
 				return true;
+			case 262:
+				quitMenu();
+				m_gamecallback->changeVolume();
+				return true;
 			case 260: // disconnect
 				m_gamecallback->disconnect();
 				quitMenu();
diff --git a/src/guiPauseMenu.h b/src/guiPauseMenu.h
index 4b15fc74f..25011a34a 100644
--- a/src/guiPauseMenu.h
+++ b/src/guiPauseMenu.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -29,6 +29,7 @@ public:
 	virtual void exitToOS() = 0;
 	virtual void disconnect() = 0;
 	virtual void changePassword() = 0;
+	virtual void changeVolume() = 0;
 };
 
 class GUIPauseMenu : public GUIModalMenu
diff --git a/src/guiTextInputMenu.cpp b/src/guiTextInputMenu.cpp
index 094532a62..f4e3bb5ba 100644
--- a/src/guiTextInputMenu.cpp
+++ b/src/guiTextInputMenu.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -29,6 +29,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "gettext.h"
 
+#if USE_FREETYPE
+#include "intlGUIEditBox.h"
+#endif
+
 GUITextInputMenu::GUITextInputMenu(gui::IGUIEnvironment* env,
 		gui::IGUIElement* parent, s32 id,
 		IMenuManager *menumgr,
@@ -105,8 +109,12 @@ void GUITextInputMenu::regenerateGui(v2u32 screensize)
 	{
 		core::rect<s32> rect(0, 0, 300, 30);
 		rect = rect + v2s32(size.X/2-300/2, size.Y/2-30/2-25);
-		gui::IGUIElement *e = 
-		Environment->addEditBox(text.c_str(), rect, true, this, 256);
+		#if USE_FREETYPE
+		gui::IGUIElement *e = (gui::IGUIElement *) new gui::intlGUIEditBox(text.c_str(), true, Environment, this, 256, rect);
+		e->drop();
+		#else
+		gui::IGUIElement *e = Environment->addEditBox(text.c_str(), rect, true, this, 256);
+		#endif
 		Environment->setFocus(e);
 
 		irr::SEvent evt;
diff --git a/src/guiTextInputMenu.h b/src/guiTextInputMenu.h
index 1a55525c9..2fa7ead9e 100644
--- a/src/guiTextInputMenu.h
+++ b/src/guiTextInputMenu.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/guiVolumeChange.cpp b/src/guiVolumeChange.cpp
new file mode 100644
index 000000000..cfb89da1c
--- /dev/null
+++ b/src/guiVolumeChange.cpp
@@ -0,0 +1,181 @@
+/*
+Part of Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Ciaran Gultnieks <ciaran@ciarang.com>
+Copyright (C) 2013 RealBadAngel, Maciej Kasatkin <mk@realbadangel.pl>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "guiVolumeChange.h"
+#include "debug.h"
+#include "serialization.h"
+#include <string>
+#include <IGUICheckBox.h>
+#include <IGUIButton.h>
+#include <IGUIScrollBar.h>
+#include <IGUIStaticText.h>
+#include <IGUIFont.h>
+#include "main.h"
+
+#include "gettext.h"
+
+const int ID_soundText1 = 263;
+const int ID_soundText2 = 264;
+const int ID_soundExitButton = 265;
+const int ID_soundSlider = 266;
+
+GUIVolumeChange::GUIVolumeChange(gui::IGUIEnvironment* env,
+		gui::IGUIElement* parent, s32 id,
+		IMenuManager *menumgr,
+		Client* client
+):
+	GUIModalMenu(env, parent, id, menumgr),
+	m_client(client)
+{
+}
+
+GUIVolumeChange::~GUIVolumeChange()
+{
+	removeChildren();
+}
+
+void GUIVolumeChange::removeChildren()
+{
+	{
+		gui::IGUIElement *e = getElementFromId(ID_soundText1);
+		if(e != NULL)
+			e->remove();
+	}
+	{
+		gui::IGUIElement *e = getElementFromId(ID_soundText2);
+		if(e != NULL)
+			e->remove();
+	}
+	{
+		gui::IGUIElement *e = getElementFromId(ID_soundExitButton);
+		if(e != NULL)
+			e->remove();
+	}
+	{
+		gui::IGUIElement *e = getElementFromId(ID_soundSlider);
+		if(e != NULL)
+			e->remove();
+	}
+}
+
+void GUIVolumeChange::regenerateGui(v2u32 screensize)
+{
+	/*
+		Remove stuff
+	*/
+	removeChildren();
+	
+	/*
+		Calculate new sizes and positions
+	*/
+	core::rect<s32> rect(
+			screensize.X/2 - 380/2,
+			screensize.Y/2 - 200/2,
+			screensize.X/2 + 380/2,
+			screensize.Y/2 + 200/2
+	);
+	
+	DesiredRect = rect;
+	recalculateAbsolutePosition(false);
+
+	v2s32 size = rect.getSize();
+	v2s32 topleft_client(40, 0);
+	v2s32 size_client = size - v2s32(40, 0);
+	int volume=(int)(g_settings->getFloat("sound_volume")*100);
+	/*
+		Add stuff
+	*/
+	changeCtype("");
+	{
+		core::rect<s32> rect(0, 0, 120, 20);
+		rect = rect + v2s32(size.X/2-60, size.Y/2-35);
+		Environment->addStaticText(wgettext("Sound Volume: "), rect, false,
+				true, this, ID_soundText1);
+	}
+	{
+		core::rect<s32> rect(0, 0, 30, 20);
+		rect = rect + v2s32(size.X/2+40, size.Y/2-35);
+		Environment->addStaticText(core::stringw(volume).c_str(), rect, false,
+				true, this, ID_soundText2);
+	}
+	{
+		core::rect<s32> rect(0, 0, 80, 30);
+		rect = rect + v2s32(size.X/2-80/2, size.Y/2+55);
+		Environment->addButton(rect, this, ID_soundExitButton,
+			wgettext("Exit"));
+	}
+	{
+		core::rect<s32> rect(0, 0, 300, 20);
+		rect = rect + v2s32(size.X/2-150, size.Y/2);
+		gui::IGUIScrollBar *e = Environment->addScrollBar(true,
+			rect, this, ID_soundSlider);
+		e->setMax(100);
+		e->setPos(volume);
+	}
+	changeCtype("");
+}
+
+void GUIVolumeChange::drawMenu()
+{
+	gui::IGUISkin* skin = Environment->getSkin();
+	if (!skin)
+		return;
+	video::IVideoDriver* driver = Environment->getVideoDriver();
+	video::SColor bgcolor(140,0,0,0);
+	driver->draw2DRectangle(bgcolor, AbsoluteRect, &AbsoluteClippingRect);
+	gui::IGUIElement::draw();
+}
+
+bool GUIVolumeChange::OnEvent(const SEvent& event)
+{
+	if(event.EventType==EET_KEY_INPUT_EVENT)
+	{
+		if(event.KeyInput.Key==KEY_ESCAPE && event.KeyInput.PressedDown)
+		{
+			quitMenu();
+			return true;
+		}
+		if(event.KeyInput.Key==KEY_RETURN && event.KeyInput.PressedDown)
+		{
+			quitMenu();
+			return true;
+		}
+	}
+	if(event.GUIEvent.EventType==gui::EGET_BUTTON_CLICKED)
+		{
+			if (event.GUIEvent.Caller->getID() == ID_soundExitButton)
+				{
+					quitMenu();
+					return true;
+				}
+		}
+	if(event.GUIEvent.EventType==gui::EGET_SCROLL_BAR_CHANGED)
+		{
+		if (event.GUIEvent.Caller->getID() == ID_soundSlider)
+			{
+				s32 pos = ((gui::IGUIScrollBar*)event.GUIEvent.Caller)->getPos();
+				g_settings->setFloat("sound_volume",(float)pos/100);
+				gui::IGUIElement *e = getElementFromId(ID_soundText2);
+				e->setText( core::stringw(pos).c_str() );
+				return true;
+			}
+		}
+	return Parent ? Parent->OnEvent(event) : false;
+}
+
diff --git a/src/guiVolumeChange.h b/src/guiVolumeChange.h
new file mode 100644
index 000000000..1dcc7fbde
--- /dev/null
+++ b/src/guiVolumeChange.h
@@ -0,0 +1,53 @@
+/*
+Part of Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Ciaran Gultnieks <ciaran@ciarang.com>
+Copyright (C) 2013 RealBadAngel, Maciej Kasatkin <mk@realbadangel.pl>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef GUIVOLUMECHANGE_HEADER
+#define GUIVOLUMECHANGE_HEADER
+
+#include "irrlichttypes_extrabloated.h"
+#include "modalMenu.h"
+#include "client.h"
+#include <string>
+
+class GUIVolumeChange : public GUIModalMenu
+{
+public:
+	GUIVolumeChange(gui::IGUIEnvironment* env,
+			gui::IGUIElement* parent, s32 id,
+			IMenuManager *menumgr,
+			Client* client);
+	~GUIVolumeChange();
+	
+	void removeChildren();
+	/*
+		Remove and re-add (or reposition) stuff
+	*/
+	void regenerateGui(v2u32 screensize);
+
+	void drawMenu();
+
+	bool OnEvent(const SEvent& event);
+	
+private:
+	Client* m_client;
+
+};
+
+#endif
+
diff --git a/src/hex.h b/src/hex.h
index e54ef9634..87a6aecb4 100644
--- a/src/hex.h
+++ b/src/hex.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
+Minetest
+Copyright (C) 2013 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/intlGUIEditBox.cpp b/src/intlGUIEditBox.cpp
new file mode 100644
index 000000000..32cca4866
--- /dev/null
+++ b/src/intlGUIEditBox.cpp
@@ -0,0 +1,1508 @@
+// 11.11.2011 11:11 ValkaTR
+//
+// This is a copy of intlGUIEditBox from the irrlicht, but with a
+// fix in the OnEvent function, which doesn't allowed input of
+// other keyboard layouts than latin-1
+//
+// Characters like: ä ö ü õ ы й ю я ъ № € ° ...
+//
+// This fix is only needed for linux, because of a bug
+// in the CIrrDeviceLinux.cpp:1014-1015 of the irrlicht
+//
+// Also locale in the programm should not be changed to
+// a "C", "POSIX" or whatever, it should be set to "",
+// or XLookupString will return nothing for the international
+// characters.
+//
+// From the "man setlocale":
+//
+// On startup of the main program, the portable "C" locale
+// is selected as default.  A  program  may  be  made
+// portable to all locales by calling:
+//
+//           setlocale(LC_ALL, "");
+//
+//       after  program initialization....
+//
+
+// Copyright (C) 2002-2013 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#include "intlGUIEditBox.h"
+
+#ifdef _IRR_COMPILE_WITH_GUI_
+
+#include "IGUISkin.h"
+#include "IGUIEnvironment.h"
+#include "IGUIFont.h"
+#include "IVideoDriver.h"
+//#include "rect.h"
+//#include "irrlicht/os.cpp"
+#include "porting.h"
+//#include "Keycodes.h"
+
+/*
+	todo:
+	optional scrollbars
+	ctrl+left/right to select word
+	double click/ctrl click: word select + drag to select whole words, triple click to select line
+	optional? dragging selected text
+	numerical
+*/
+
+namespace irr
+{
+namespace gui
+{
+
+//! constructor
+intlGUIEditBox::intlGUIEditBox(const wchar_t* text, bool border,
+		IGUIEnvironment* environment, IGUIElement* parent, s32 id,
+		const core::rect<s32>& rectangle)
+	: IGUIEditBox(environment, parent, id, rectangle), MouseMarking(false),
+	Border(border), OverrideColorEnabled(false), MarkBegin(0), MarkEnd(0),
+	OverrideColor(video::SColor(101,255,255,255)), OverrideFont(0), LastBreakFont(0),
+	Operator(0), BlinkStartTime(0), CursorPos(0), HScrollPos(0), VScrollPos(0), Max(0),
+	WordWrap(false), MultiLine(false), AutoScroll(true), PasswordBox(false),
+	PasswordChar(L'*'), HAlign(EGUIA_UPPERLEFT), VAlign(EGUIA_CENTER),
+	CurrentTextRect(0,0,1,1), FrameRect(rectangle)
+{
+	#ifdef _DEBUG
+	setDebugName("intlintlGUIEditBox");
+	#endif
+
+	Text = text;
+
+	if (Environment)
+		Operator = Environment->getOSOperator();
+
+	if (Operator)
+		Operator->grab();
+
+	// this element can be tabbed to
+	setTabStop(true);
+	setTabOrder(-1);
+
+	IGUISkin *skin = 0;
+	if (Environment)
+		skin = Environment->getSkin();
+	if (Border && skin)
+	{
+		FrameRect.UpperLeftCorner.X += skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.UpperLeftCorner.Y += skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+		FrameRect.LowerRightCorner.X -= skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.LowerRightCorner.Y -= skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+	}
+
+	breakText();
+
+	calculateScrollPos();
+}
+
+
+//! destructor
+intlGUIEditBox::~intlGUIEditBox()
+{
+	if (OverrideFont)
+		OverrideFont->drop();
+
+	if (Operator)
+		Operator->drop();
+}
+
+
+//! Sets another skin independent font.
+void intlGUIEditBox::setOverrideFont(IGUIFont* font)
+{
+	if (OverrideFont == font)
+		return;
+
+	if (OverrideFont)
+		OverrideFont->drop();
+
+	OverrideFont = font;
+
+	if (OverrideFont)
+		OverrideFont->grab();
+
+	breakText();
+}
+
+IGUIFont * intlGUIEditBox::getOverrideFont() const
+{
+	return OverrideFont;
+}
+
+//! Get the font which is used right now for drawing
+IGUIFont* intlGUIEditBox::getActiveFont() const
+{
+	if ( OverrideFont )
+		return OverrideFont;
+	IGUISkin* skin = Environment->getSkin();
+	if (skin)
+		return skin->getFont();
+	return 0;
+}
+
+//! Sets another color for the text.
+void intlGUIEditBox::setOverrideColor(video::SColor color)
+{
+	OverrideColor = color;
+	OverrideColorEnabled = true;
+}
+
+video::SColor intlGUIEditBox::getOverrideColor() const
+{
+	return OverrideColor;
+}
+
+//! Turns the border on or off
+void intlGUIEditBox::setDrawBorder(bool border)
+{
+	Border = border;
+}
+
+//! Sets whether to draw the background
+void intlGUIEditBox::setDrawBackground(bool draw)
+{
+}
+
+//! Sets if the text should use the overide color or the color in the gui skin.
+void intlGUIEditBox::enableOverrideColor(bool enable)
+{
+	OverrideColorEnabled = enable;
+}
+
+bool intlGUIEditBox::isOverrideColorEnabled() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return OverrideColorEnabled;
+}
+
+//! Enables or disables word wrap
+void intlGUIEditBox::setWordWrap(bool enable)
+{
+	WordWrap = enable;
+	breakText();
+}
+
+
+void intlGUIEditBox::updateAbsolutePosition()
+{
+    core::rect<s32> oldAbsoluteRect(AbsoluteRect);
+	IGUIElement::updateAbsolutePosition();
+	if ( oldAbsoluteRect != AbsoluteRect )
+	{
+        breakText();
+	}
+}
+
+
+//! Checks if word wrap is enabled
+bool intlGUIEditBox::isWordWrapEnabled() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return WordWrap;
+}
+
+
+//! Enables or disables newlines.
+void intlGUIEditBox::setMultiLine(bool enable)
+{
+	MultiLine = enable;
+}
+
+
+//! Checks if multi line editing is enabled
+bool intlGUIEditBox::isMultiLineEnabled() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return MultiLine;
+}
+
+
+void intlGUIEditBox::setPasswordBox(bool passwordBox, wchar_t passwordChar)
+{
+	PasswordBox = passwordBox;
+	if (PasswordBox)
+	{
+		PasswordChar = passwordChar;
+		setMultiLine(false);
+		setWordWrap(false);
+		BrokenText.clear();
+	}
+}
+
+
+bool intlGUIEditBox::isPasswordBox() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return PasswordBox;
+}
+
+
+//! Sets text justification
+void intlGUIEditBox::setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical)
+{
+	HAlign = horizontal;
+	VAlign = vertical;
+}
+
+
+//! called if an event happened.
+bool intlGUIEditBox::OnEvent(const SEvent& event)
+{
+	if (IsEnabled)
+	{
+
+		switch(event.EventType)
+		{
+		case EET_GUI_EVENT:
+			if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUS_LOST)
+			{
+				if (event.GUIEvent.Caller == this)
+				{
+					MouseMarking = false;
+					setTextMarkers(0,0);
+				}
+			}
+			break;
+		case EET_KEY_INPUT_EVENT:
+        {
+#if defined(linux)
+            // ################################################################
+			// ValkaTR:
+            // This part is the difference from the original intlGUIEditBox
+            // It converts UTF-8 character into a UCS-2 (wchar_t)
+            wchar_t wc = L'_';
+            mbtowc( &wc, (char *) &event.KeyInput.Char, sizeof(event.KeyInput.Char) );
+
+            //printf( "char: %lc (%u)  \r\n", wc, wc );
+
+            SEvent irrevent(event);
+            irrevent.KeyInput.Char = wc;
+            // ################################################################
+
+			if (processKey(irrevent))
+				return true;
+#else
+			if (processKey(event))
+				return true;
+#endif // defined(linux)
+
+			break;
+        }
+		case EET_MOUSE_INPUT_EVENT:
+			if (processMouse(event))
+				return true;
+			break;
+		default:
+			break;
+		}
+	}
+
+	return IGUIElement::OnEvent(event);
+}
+
+
+bool intlGUIEditBox::processKey(const SEvent& event)
+{
+	if (!event.KeyInput.PressedDown)
+		return false;
+
+	bool textChanged = false;
+	s32 newMarkBegin = MarkBegin;
+	s32 newMarkEnd = MarkEnd;
+
+	// control shortcut handling
+
+	if (event.KeyInput.Control)
+	{
+		// german backlash '\' entered with control + '?'
+		if ( event.KeyInput.Char == '\\' )
+		{
+			inputChar(event.KeyInput.Char);
+			return true;
+		}
+
+		switch(event.KeyInput.Key)
+		{
+		case KEY_KEY_A:
+			// select all
+			newMarkBegin = 0;
+			newMarkEnd = Text.size();
+			break;
+		case KEY_KEY_C:
+			// copy to clipboard
+			if (!PasswordBox && Operator && MarkBegin != MarkEnd)
+			{
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				core::stringc s;
+				s = Text.subString(realmbgn, realmend - realmbgn).c_str();
+				Operator->copyToClipboard(s.c_str());
+			}
+			break;
+		case KEY_KEY_X:
+			// cut to the clipboard
+			if (!PasswordBox && Operator && MarkBegin != MarkEnd)
+			{
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				// copy
+				core::stringc sc;
+				sc = Text.subString(realmbgn, realmend - realmbgn).c_str();
+				Operator->copyToClipboard(sc.c_str());
+
+				if (IsEnabled)
+				{
+					// delete
+					core::stringw s;
+					s = Text.subString(0, realmbgn);
+					s.append( Text.subString(realmend, Text.size()-realmend) );
+					Text = s;
+
+					CursorPos = realmbgn;
+					newMarkBegin = 0;
+					newMarkEnd = 0;
+					textChanged = true;
+				}
+			}
+			break;
+		case KEY_KEY_V:
+			if ( !IsEnabled )
+				break;
+
+			// paste from the clipboard
+			if (Operator)
+			{
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				// add new character
+				const c8* p = Operator->getTextFromClipboard();
+				if (p)
+				{
+					if (MarkBegin == MarkEnd)
+					{
+						// insert text
+						core::stringw s = Text.subString(0, CursorPos);
+						s.append(p);
+						s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
+
+						if (!Max || s.size()<=Max) // thx to Fish FH for fix
+						{
+							Text = s;
+							s = p;
+							CursorPos += s.size();
+						}
+					}
+					else
+					{
+						// replace text
+
+						core::stringw s = Text.subString(0, realmbgn);
+						s.append(p);
+						s.append( Text.subString(realmend, Text.size()-realmend) );
+
+						if (!Max || s.size()<=Max)  // thx to Fish FH for fix
+						{
+							Text = s;
+							s = p;
+							CursorPos = realmbgn + s.size();
+						}
+					}
+				}
+
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+				textChanged = true;
+			}
+			break;
+		case KEY_HOME:
+			// move/highlight to start of text
+			if (event.KeyInput.Shift)
+			{
+				newMarkEnd = CursorPos;
+				newMarkBegin = 0;
+				CursorPos = 0;
+			}
+			else
+			{
+				CursorPos = 0;
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			break;
+		case KEY_END:
+			// move/highlight to end of text
+			if (event.KeyInput.Shift)
+			{
+				newMarkBegin = CursorPos;
+				newMarkEnd = Text.size();
+				CursorPos = 0;
+			}
+			else
+			{
+				CursorPos = Text.size();
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			break;
+		default:
+			return false;
+		}
+	}
+	// default keyboard handling
+	else
+	switch(event.KeyInput.Key)
+	{
+	case KEY_END:
+		{
+			s32 p = Text.size();
+			if (WordWrap || MultiLine)
+			{
+				p = getLineFromPos(CursorPos);
+				p = BrokenTextPositions[p] + (s32)BrokenText[p].size();
+				if (p > 0 && (Text[p-1] == L'\r' || Text[p-1] == L'\n' ))
+					p-=1;
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+
+				newMarkEnd = p;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			CursorPos = p;
+			BlinkStartTime = porting::getTimeMs();
+		}
+		break;
+	case KEY_HOME:
+		{
+
+			s32 p = 0;
+			if (WordWrap || MultiLine)
+			{
+				p = getLineFromPos(CursorPos);
+				p = BrokenTextPositions[p];
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+				newMarkEnd = p;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+			CursorPos = p;
+			BlinkStartTime = porting::getTimeMs();
+		}
+		break;
+	case KEY_RETURN:
+		if (MultiLine)
+		{
+			inputChar(L'\n');
+			return true;
+		}
+		else
+		{
+		    sendGuiEvent( EGET_EDITBOX_ENTER );
+		}
+		break;
+	case KEY_LEFT:
+
+		if (event.KeyInput.Shift)
+		{
+			if (CursorPos > 0)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+
+				newMarkEnd = CursorPos-1;
+			}
+		}
+		else
+		{
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+		}
+
+		if (CursorPos > 0) CursorPos--;
+		BlinkStartTime = porting::getTimeMs();
+		break;
+
+	case KEY_RIGHT:
+		if (event.KeyInput.Shift)
+		{
+			if (Text.size() > (u32)CursorPos)
+			{
+				if (MarkBegin == MarkEnd)
+					newMarkBegin = CursorPos;
+
+				newMarkEnd = CursorPos+1;
+			}
+		}
+		else
+		{
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+		}
+
+		if (Text.size() > (u32)CursorPos) CursorPos++;
+		BlinkStartTime = porting::getTimeMs();
+		break;
+	case KEY_UP:
+		if (MultiLine || (WordWrap && BrokenText.size() > 1) )
+		{
+			s32 lineNo = getLineFromPos(CursorPos);
+			s32 mb = (MarkBegin == MarkEnd) ? CursorPos : (MarkBegin > MarkEnd ? MarkBegin : MarkEnd);
+			if (lineNo > 0)
+			{
+				s32 cp = CursorPos - BrokenTextPositions[lineNo];
+				if ((s32)BrokenText[lineNo-1].size() < cp)
+					CursorPos = BrokenTextPositions[lineNo-1] + (s32)BrokenText[lineNo-1].size()-1;
+				else
+					CursorPos = BrokenTextPositions[lineNo-1] + cp;
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				newMarkBegin = mb;
+				newMarkEnd = CursorPos;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+
+		}
+		else
+		{
+			return false;
+		}
+		break;
+	case KEY_DOWN:
+		if (MultiLine || (WordWrap && BrokenText.size() > 1) )
+		{
+			s32 lineNo = getLineFromPos(CursorPos);
+			s32 mb = (MarkBegin == MarkEnd) ? CursorPos : (MarkBegin < MarkEnd ? MarkBegin : MarkEnd);
+			if (lineNo < (s32)BrokenText.size()-1)
+			{
+				s32 cp = CursorPos - BrokenTextPositions[lineNo];
+				if ((s32)BrokenText[lineNo+1].size() < cp)
+					CursorPos = BrokenTextPositions[lineNo+1] + BrokenText[lineNo+1].size()-1;
+				else
+					CursorPos = BrokenTextPositions[lineNo+1] + cp;
+			}
+
+			if (event.KeyInput.Shift)
+			{
+				newMarkBegin = mb;
+				newMarkEnd = CursorPos;
+			}
+			else
+			{
+				newMarkBegin = 0;
+				newMarkEnd = 0;
+			}
+
+		}
+		else
+		{
+			return false;
+		}
+		break;
+
+	case KEY_BACK:
+		if ( !this->IsEnabled )
+			break;
+
+		if (Text.size())
+		{
+			core::stringw s;
+
+			if (MarkBegin != MarkEnd)
+			{
+				// delete marked text
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				s = Text.subString(0, realmbgn);
+				s.append( Text.subString(realmend, Text.size()-realmend) );
+				Text = s;
+
+				CursorPos = realmbgn;
+			}
+			else
+			{
+				// delete text behind cursor
+				if (CursorPos>0)
+					s = Text.subString(0, CursorPos-1);
+				else
+					s = L"";
+				s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
+				Text = s;
+				--CursorPos;
+			}
+
+			if (CursorPos < 0)
+				CursorPos = 0;
+			BlinkStartTime = porting::getTimeMs();
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+			textChanged = true;
+		}
+		break;
+	case KEY_DELETE:
+		if ( !this->IsEnabled )
+			break;
+
+		if (Text.size() != 0)
+		{
+			core::stringw s;
+
+			if (MarkBegin != MarkEnd)
+			{
+				// delete marked text
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				s = Text.subString(0, realmbgn);
+				s.append( Text.subString(realmend, Text.size()-realmend) );
+				Text = s;
+
+				CursorPos = realmbgn;
+			}
+			else
+			{
+				// delete text before cursor
+				s = Text.subString(0, CursorPos);
+				s.append( Text.subString(CursorPos+1, Text.size()-CursorPos-1) );
+				Text = s;
+			}
+
+			if (CursorPos > (s32)Text.size())
+				CursorPos = (s32)Text.size();
+
+			BlinkStartTime = porting::getTimeMs();
+			newMarkBegin = 0;
+			newMarkEnd = 0;
+			textChanged = true;
+		}
+		break;
+
+	case KEY_ESCAPE:
+	case KEY_TAB:
+	case KEY_SHIFT:
+	case KEY_F1:
+	case KEY_F2:
+	case KEY_F3:
+	case KEY_F4:
+	case KEY_F5:
+	case KEY_F6:
+	case KEY_F7:
+	case KEY_F8:
+	case KEY_F9:
+	case KEY_F10:
+	case KEY_F11:
+	case KEY_F12:
+	case KEY_F13:
+	case KEY_F14:
+	case KEY_F15:
+	case KEY_F16:
+	case KEY_F17:
+	case KEY_F18:
+	case KEY_F19:
+	case KEY_F20:
+	case KEY_F21:
+	case KEY_F22:
+	case KEY_F23:
+	case KEY_F24:
+		// ignore these keys
+		return false;
+
+	default:
+		inputChar(event.KeyInput.Char);
+		return true;
+	}
+
+    // Set new text markers
+    setTextMarkers( newMarkBegin, newMarkEnd );
+
+	// break the text if it has changed
+	if (textChanged)
+	{
+		breakText();
+		sendGuiEvent(EGET_EDITBOX_CHANGED);
+	}
+
+	calculateScrollPos();
+
+	return true;
+}
+
+
+//! draws the element and its children
+void intlGUIEditBox::draw()
+{
+	if (!IsVisible)
+		return;
+
+	const bool focus = Environment->hasFocus(this);
+
+	IGUISkin* skin = Environment->getSkin();
+	if (!skin)
+		return;
+
+	FrameRect = AbsoluteRect;
+
+	// draw the border
+
+	if (Border)
+	{
+		skin->draw3DSunkenPane(this, skin->getColor(EGDC_WINDOW),
+			false, true, FrameRect, &AbsoluteClippingRect);
+
+		FrameRect.UpperLeftCorner.X += skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.UpperLeftCorner.Y += skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+		FrameRect.LowerRightCorner.X -= skin->getSize(EGDS_TEXT_DISTANCE_X)+1;
+		FrameRect.LowerRightCorner.Y -= skin->getSize(EGDS_TEXT_DISTANCE_Y)+1;
+	}
+	core::rect<s32> localClipRect = FrameRect;
+	localClipRect.clipAgainst(AbsoluteClippingRect);
+
+	// draw the text
+
+	IGUIFont* font = OverrideFont;
+	if (!OverrideFont)
+		font = skin->getFont();
+
+	s32 cursorLine = 0;
+	s32 charcursorpos = 0;
+
+	if (font)
+	{
+		if (LastBreakFont != font)
+		{
+			breakText();
+		}
+
+		// calculate cursor pos
+
+		core::stringw *txtLine = &Text;
+		s32 startPos = 0;
+
+		core::stringw s, s2;
+
+		// get mark position
+		const bool ml = (!PasswordBox && (WordWrap || MultiLine));
+		const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+		const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+		const s32 hlineStart = ml ? getLineFromPos(realmbgn) : 0;
+		const s32 hlineCount = ml ? getLineFromPos(realmend) - hlineStart + 1 : 1;
+		const s32 lineCount = ml ? BrokenText.size() : 1;
+
+		// Save the override color information.
+		// Then, alter it if the edit box is disabled.
+		const bool prevOver = OverrideColorEnabled;
+		const video::SColor prevColor = OverrideColor;
+
+		if (Text.size())
+		{
+			if (!IsEnabled && !OverrideColorEnabled)
+			{
+				OverrideColorEnabled = true;
+				OverrideColor = skin->getColor(EGDC_GRAY_TEXT);
+			}
+
+			for (s32 i=0; i < lineCount; ++i)
+			{
+				setTextRect(i);
+
+				// clipping test - don't draw anything outside the visible area
+				core::rect<s32> c = localClipRect;
+				c.clipAgainst(CurrentTextRect);
+				if (!c.isValid())
+					continue;
+
+				// get current line
+				if (PasswordBox)
+				{
+					if (BrokenText.size() != 1)
+					{
+						BrokenText.clear();
+						BrokenText.push_back(core::stringw());
+					}
+					if (BrokenText[0].size() != Text.size())
+					{
+						BrokenText[0] = Text;
+						for (u32 q = 0; q < Text.size(); ++q)
+						{
+							BrokenText[0] [q] = PasswordChar;
+						}
+					}
+					txtLine = &BrokenText[0];
+					startPos = 0;
+				}
+				else
+				{
+					txtLine = ml ? &BrokenText[i] : &Text;
+					startPos = ml ? BrokenTextPositions[i] : 0;
+				}
+
+
+				// draw normal text
+				font->draw(txtLine->c_str(), CurrentTextRect,
+					OverrideColorEnabled ? OverrideColor : skin->getColor(EGDC_BUTTON_TEXT),
+					false, true, &localClipRect);
+
+				// draw mark and marked text
+				if (focus && MarkBegin != MarkEnd && i >= hlineStart && i < hlineStart + hlineCount)
+				{
+
+					s32 mbegin = 0, mend = 0;
+					s32 lineStartPos = 0, lineEndPos = txtLine->size();
+
+					if (i == hlineStart)
+					{
+						// highlight start is on this line
+						s = txtLine->subString(0, realmbgn - startPos);
+						mbegin = font->getDimension(s.c_str()).Width;
+
+						// deal with kerning
+						mbegin += font->getKerningWidth(
+							&((*txtLine)[realmbgn - startPos]),
+							realmbgn - startPos > 0 ? &((*txtLine)[realmbgn - startPos - 1]) : 0);
+
+						lineStartPos = realmbgn - startPos;
+					}
+					if (i == hlineStart + hlineCount - 1)
+					{
+						// highlight end is on this line
+						s2 = txtLine->subString(0, realmend - startPos);
+						mend = font->getDimension(s2.c_str()).Width;
+						lineEndPos = (s32)s2.size();
+					}
+					else
+						mend = font->getDimension(txtLine->c_str()).Width;
+
+					CurrentTextRect.UpperLeftCorner.X += mbegin;
+					CurrentTextRect.LowerRightCorner.X = CurrentTextRect.UpperLeftCorner.X + mend - mbegin;
+
+					// draw mark
+					skin->draw2DRectangle(this, skin->getColor(EGDC_HIGH_LIGHT), CurrentTextRect, &localClipRect);
+
+					// draw marked text
+					s = txtLine->subString(lineStartPos, lineEndPos - lineStartPos);
+
+					if (s.size())
+						font->draw(s.c_str(), CurrentTextRect,
+							OverrideColorEnabled ? OverrideColor : skin->getColor(EGDC_HIGH_LIGHT_TEXT),
+							false, true, &localClipRect);
+
+				}
+			}
+
+			// Return the override color information to its previous settings.
+			OverrideColorEnabled = prevOver;
+			OverrideColor = prevColor;
+		}
+
+		// draw cursor
+
+		if (WordWrap || MultiLine)
+		{
+			cursorLine = getLineFromPos(CursorPos);
+			txtLine = &BrokenText[cursorLine];
+			startPos = BrokenTextPositions[cursorLine];
+		}
+		s = txtLine->subString(0,CursorPos-startPos);
+		charcursorpos = font->getDimension(s.c_str()).Width +
+			font->getKerningWidth(L"_", CursorPos-startPos > 0 ? &((*txtLine)[CursorPos-startPos-1]) : 0);
+
+		if (focus && (porting::getTimeMs() - BlinkStartTime) % 700 < 350)
+		{
+			setTextRect(cursorLine);
+			CurrentTextRect.UpperLeftCorner.X += charcursorpos;
+
+			font->draw(L"_", CurrentTextRect,
+				OverrideColorEnabled ? OverrideColor : skin->getColor(EGDC_BUTTON_TEXT),
+				false, true, &localClipRect);
+		}
+	}
+
+	// draw children
+	IGUIElement::draw();
+}
+
+
+//! Sets the new caption of this element.
+void intlGUIEditBox::setText(const wchar_t* text)
+{
+	Text = text;
+	if (u32(CursorPos) > Text.size())
+		CursorPos = Text.size();
+	HScrollPos = 0;
+	breakText();
+}
+
+
+//! Enables or disables automatic scrolling with cursor position
+//! \param enable: If set to true, the text will move around with the cursor position
+void intlGUIEditBox::setAutoScroll(bool enable)
+{
+	AutoScroll = enable;
+}
+
+
+//! Checks to see if automatic scrolling is enabled
+//! \return true if automatic scrolling is enabled, false if not
+bool intlGUIEditBox::isAutoScrollEnabled() const
+{
+	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+	return AutoScroll;
+}
+
+
+//! Gets the area of the text in the edit box
+//! \return Returns the size in pixels of the text
+core::dimension2du intlGUIEditBox::getTextDimension()
+{
+	core::rect<s32> ret;
+
+	setTextRect(0);
+	ret = CurrentTextRect;
+
+	for (u32 i=1; i < BrokenText.size(); ++i)
+	{
+		setTextRect(i);
+		ret.addInternalPoint(CurrentTextRect.UpperLeftCorner);
+		ret.addInternalPoint(CurrentTextRect.LowerRightCorner);
+	}
+
+	return core::dimension2du(ret.getSize());
+}
+
+
+//! Sets the maximum amount of characters which may be entered in the box.
+//! \param max: Maximum amount of characters. If 0, the character amount is
+//! infinity.
+void intlGUIEditBox::setMax(u32 max)
+{
+	Max = max;
+
+	if (Text.size() > Max && Max != 0)
+		Text = Text.subString(0, Max);
+}
+
+
+//! Returns maximum amount of characters, previously set by setMax();
+u32 intlGUIEditBox::getMax() const
+{
+	return Max;
+}
+
+
+bool intlGUIEditBox::processMouse(const SEvent& event)
+{
+	switch(event.MouseInput.Event)
+	{
+	case irr::EMIE_LMOUSE_LEFT_UP:
+		if (Environment->hasFocus(this))
+		{
+			CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+			if (MouseMarking)
+			{
+			    setTextMarkers( MarkBegin, CursorPos );
+			}
+			MouseMarking = false;
+			calculateScrollPos();
+			return true;
+		}
+		break;
+	case irr::EMIE_MOUSE_MOVED:
+		{
+			if (MouseMarking)
+			{
+				CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+				setTextMarkers( MarkBegin, CursorPos );
+				calculateScrollPos();
+				return true;
+			}
+		}
+		break;
+	case EMIE_LMOUSE_PRESSED_DOWN:
+		if (!Environment->hasFocus(this))
+		{
+			BlinkStartTime = porting::getTimeMs();
+			MouseMarking = true;
+			CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+			setTextMarkers(CursorPos, CursorPos );
+			calculateScrollPos();
+			return true;
+		}
+		else
+		{
+			if (!AbsoluteClippingRect.isPointInside(
+				core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y)))
+			{
+				return false;
+			}
+			else
+			{
+				// move cursor
+				CursorPos = getCursorPos(event.MouseInput.X, event.MouseInput.Y);
+
+                s32 newMarkBegin = MarkBegin;
+				if (!MouseMarking)
+					newMarkBegin = CursorPos;
+
+				MouseMarking = true;
+				setTextMarkers( newMarkBegin, CursorPos);
+				calculateScrollPos();
+				return true;
+			}
+		}
+	default:
+		break;
+	}
+
+	return false;
+}
+
+
+s32 intlGUIEditBox::getCursorPos(s32 x, s32 y)
+{
+	IGUIFont* font = OverrideFont;
+	IGUISkin* skin = Environment->getSkin();
+	if (!OverrideFont)
+		font = skin->getFont();
+
+	const u32 lineCount = (WordWrap || MultiLine) ? BrokenText.size() : 1;
+
+	core::stringw *txtLine=0;
+	s32 startPos=0;
+	x+=3;
+
+	for (u32 i=0; i < lineCount; ++i)
+	{
+		setTextRect(i);
+		if (i == 0 && y < CurrentTextRect.UpperLeftCorner.Y)
+			y = CurrentTextRect.UpperLeftCorner.Y;
+		if (i == lineCount - 1 && y > CurrentTextRect.LowerRightCorner.Y )
+			y = CurrentTextRect.LowerRightCorner.Y;
+
+		// is it inside this region?
+		if (y >= CurrentTextRect.UpperLeftCorner.Y && y <= CurrentTextRect.LowerRightCorner.Y)
+		{
+			// we've found the clicked line
+			txtLine = (WordWrap || MultiLine) ? &BrokenText[i] : &Text;
+			startPos = (WordWrap || MultiLine) ? BrokenTextPositions[i] : 0;
+			break;
+		}
+	}
+
+	if (x < CurrentTextRect.UpperLeftCorner.X)
+		x = CurrentTextRect.UpperLeftCorner.X;
+
+	s32 idx = font->getCharacterFromPos(Text.c_str(), x - CurrentTextRect.UpperLeftCorner.X);
+
+	// click was on or left of the line
+	if (idx != -1)
+		return idx + startPos;
+
+	// click was off the right edge of the line, go to end.
+	return txtLine->size() + startPos;
+}
+
+
+//! Breaks the single text line.
+void intlGUIEditBox::breakText()
+{
+	IGUISkin* skin = Environment->getSkin();
+
+	if ((!WordWrap && !MultiLine) || !skin)
+		return;
+
+	BrokenText.clear(); // need to reallocate :/
+	BrokenTextPositions.set_used(0);
+
+	IGUIFont* font = OverrideFont;
+	if (!OverrideFont)
+		font = skin->getFont();
+
+	if (!font)
+		return;
+
+	LastBreakFont = font;
+
+	core::stringw line;
+	core::stringw word;
+	core::stringw whitespace;
+	s32 lastLineStart = 0;
+	s32 size = Text.size();
+	s32 length = 0;
+	s32 elWidth = RelativeRect.getWidth() - 6;
+	wchar_t c;
+
+	for (s32 i=0; i<size; ++i)
+	{
+		c = Text[i];
+		bool lineBreak = false;
+
+		if (c == L'\r') // Mac or Windows breaks
+		{
+			lineBreak = true;
+			c = ' ';
+			if (Text[i+1] == L'\n') // Windows breaks
+			{
+				Text.erase(i+1);
+				--size;
+			}
+		}
+		else if (c == L'\n') // Unix breaks
+		{
+			lineBreak = true;
+			c = ' ';
+		}
+
+		// don't break if we're not a multi-line edit box
+		if (!MultiLine)
+			lineBreak = false;
+
+		if (c == L' ' || c == 0 || i == (size-1))
+		{
+			if (word.size())
+			{
+				// here comes the next whitespace, look if
+				// we can break the last word to the next line.
+				s32 whitelgth = font->getDimension(whitespace.c_str()).Width;
+				s32 worldlgth = font->getDimension(word.c_str()).Width;
+
+				if (WordWrap && length + worldlgth + whitelgth > elWidth)
+				{
+					// break to next line
+					length = worldlgth;
+					BrokenText.push_back(line);
+					BrokenTextPositions.push_back(lastLineStart);
+					lastLineStart = i - (s32)word.size();
+					line = word;
+				}
+				else
+				{
+					// add word to line
+					line += whitespace;
+					line += word;
+					length += whitelgth + worldlgth;
+				}
+
+				word = L"";
+				whitespace = L"";
+			}
+
+			whitespace += c;
+
+			// compute line break
+			if (lineBreak)
+			{
+				line += whitespace;
+				line += word;
+				BrokenText.push_back(line);
+				BrokenTextPositions.push_back(lastLineStart);
+				lastLineStart = i+1;
+				line = L"";
+				word = L"";
+				whitespace = L"";
+				length = 0;
+			}
+		}
+		else
+		{
+			// yippee this is a word..
+			word += c;
+		}
+	}
+
+	line += whitespace;
+	line += word;
+	BrokenText.push_back(line);
+	BrokenTextPositions.push_back(lastLineStart);
+}
+
+
+void intlGUIEditBox::setTextRect(s32 line)
+{
+	core::dimension2du d;
+
+	IGUISkin* skin = Environment->getSkin();
+	if (!skin)
+		return;
+
+	IGUIFont* font = OverrideFont ? OverrideFont : skin->getFont();
+
+	if (!font)
+		return;
+
+	// get text dimension
+	const u32 lineCount = (WordWrap || MultiLine) ? BrokenText.size() : 1;
+	if (WordWrap || MultiLine)
+	{
+		d = font->getDimension(BrokenText[line].c_str());
+	}
+	else
+	{
+		d = font->getDimension(Text.c_str());
+		d.Height = AbsoluteRect.getHeight();
+	}
+	d.Height += font->getKerningHeight();
+
+	// justification
+	switch (HAlign)
+	{
+	case EGUIA_CENTER:
+		// align to h centre
+		CurrentTextRect.UpperLeftCorner.X = (FrameRect.getWidth()/2) - (d.Width/2);
+		CurrentTextRect.LowerRightCorner.X = (FrameRect.getWidth()/2) + (d.Width/2);
+		break;
+	case EGUIA_LOWERRIGHT:
+		// align to right edge
+		CurrentTextRect.UpperLeftCorner.X = FrameRect.getWidth() - d.Width;
+		CurrentTextRect.LowerRightCorner.X = FrameRect.getWidth();
+		break;
+	default:
+		// align to left edge
+		CurrentTextRect.UpperLeftCorner.X = 0;
+		CurrentTextRect.LowerRightCorner.X = d.Width;
+
+	}
+
+	switch (VAlign)
+	{
+	case EGUIA_CENTER:
+		// align to v centre
+		CurrentTextRect.UpperLeftCorner.Y =
+			(FrameRect.getHeight()/2) - (lineCount*d.Height)/2 + d.Height*line;
+		break;
+	case EGUIA_LOWERRIGHT:
+		// align to bottom edge
+		CurrentTextRect.UpperLeftCorner.Y =
+			FrameRect.getHeight() - lineCount*d.Height + d.Height*line;
+		break;
+	default:
+		// align to top edge
+		CurrentTextRect.UpperLeftCorner.Y = d.Height*line;
+		break;
+	}
+
+	CurrentTextRect.UpperLeftCorner.X  -= HScrollPos;
+	CurrentTextRect.LowerRightCorner.X -= HScrollPos;
+	CurrentTextRect.UpperLeftCorner.Y  -= VScrollPos;
+	CurrentTextRect.LowerRightCorner.Y = CurrentTextRect.UpperLeftCorner.Y + d.Height;
+
+	CurrentTextRect += FrameRect.UpperLeftCorner;
+
+}
+
+
+s32 intlGUIEditBox::getLineFromPos(s32 pos)
+{
+	if (!WordWrap && !MultiLine)
+		return 0;
+
+	s32 i=0;
+	while (i < (s32)BrokenTextPositions.size())
+	{
+		if (BrokenTextPositions[i] > pos)
+			return i-1;
+		++i;
+	}
+	return (s32)BrokenTextPositions.size() - 1;
+}
+
+
+void intlGUIEditBox::inputChar(wchar_t c)
+{
+	if (!IsEnabled)
+		return;
+
+	if (c != 0)
+	{
+		if (Text.size() < Max || Max == 0)
+		{
+			core::stringw s;
+
+			if (MarkBegin != MarkEnd)
+			{
+				// replace marked text
+				const s32 realmbgn = MarkBegin < MarkEnd ? MarkBegin : MarkEnd;
+				const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
+
+				s = Text.subString(0, realmbgn);
+				s.append(c);
+				s.append( Text.subString(realmend, Text.size()-realmend) );
+				Text = s;
+				CursorPos = realmbgn+1;
+			}
+			else
+			{
+				// add new character
+				s = Text.subString(0, CursorPos);
+				s.append(c);
+				s.append( Text.subString(CursorPos, Text.size()-CursorPos) );
+				Text = s;
+				++CursorPos;
+			}
+
+			BlinkStartTime = porting::getTimeMs();
+			setTextMarkers(0, 0);
+		}
+	}
+	breakText();
+	sendGuiEvent(EGET_EDITBOX_CHANGED);
+	calculateScrollPos();
+}
+
+
+void intlGUIEditBox::calculateScrollPos()
+{
+	if (!AutoScroll)
+		return;
+
+	// calculate horizontal scroll position
+	s32 cursLine = getLineFromPos(CursorPos);
+	setTextRect(cursLine);
+
+	// don't do horizontal scrolling when wordwrap is enabled.
+	if (!WordWrap)
+	{
+		// get cursor position
+		IGUISkin* skin = Environment->getSkin();
+		if (!skin)
+			return;
+		IGUIFont* font = OverrideFont ? OverrideFont : skin->getFont();
+		if (!font)
+			return;
+
+		core::stringw *txtLine = MultiLine ? &BrokenText[cursLine] : &Text;
+		s32 cPos = MultiLine ? CursorPos - BrokenTextPositions[cursLine] : CursorPos;
+
+		s32 cStart = CurrentTextRect.UpperLeftCorner.X + HScrollPos +
+			font->getDimension(txtLine->subString(0, cPos).c_str()).Width;
+
+		s32 cEnd = cStart + font->getDimension(L"_ ").Width;
+
+		if (FrameRect.LowerRightCorner.X < cEnd)
+			HScrollPos = cEnd - FrameRect.LowerRightCorner.X;
+		else if (FrameRect.UpperLeftCorner.X > cStart)
+			HScrollPos = cStart - FrameRect.UpperLeftCorner.X;
+		else
+			HScrollPos = 0;
+
+		// todo: adjust scrollbar
+	}
+
+	// vertical scroll position
+	if (FrameRect.LowerRightCorner.Y < CurrentTextRect.LowerRightCorner.Y + VScrollPos)
+		VScrollPos = CurrentTextRect.LowerRightCorner.Y - FrameRect.LowerRightCorner.Y + VScrollPos;
+
+	else if (FrameRect.UpperLeftCorner.Y > CurrentTextRect.UpperLeftCorner.Y + VScrollPos)
+		VScrollPos = CurrentTextRect.UpperLeftCorner.Y - FrameRect.UpperLeftCorner.Y + VScrollPos;
+	else
+		VScrollPos = 0;
+
+	// todo: adjust scrollbar
+}
+
+//! set text markers
+void intlGUIEditBox::setTextMarkers(s32 begin, s32 end)
+{
+    if ( begin != MarkBegin || end != MarkEnd )
+    {
+        MarkBegin = begin;
+        MarkEnd = end;
+        sendGuiEvent(EGET_EDITBOX_MARKING_CHANGED);
+    }
+}
+
+//! send some gui event to parent
+void intlGUIEditBox::sendGuiEvent(EGUI_EVENT_TYPE type)
+{
+	if ( Parent )
+	{
+        SEvent e;
+        e.EventType = EET_GUI_EVENT;
+        e.GUIEvent.Caller = this;
+        e.GUIEvent.Element = 0;
+        e.GUIEvent.EventType = type;
+
+        Parent->OnEvent(e);
+	}
+}
+
+//! Writes attributes of the element.
+void intlGUIEditBox::serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
+{
+	// IGUIEditBox::serializeAttributes(out,options);
+
+	out->addBool  ("OverrideColorEnabled",OverrideColorEnabled );
+	out->addColor ("OverrideColor",       OverrideColor);
+	// out->addFont("OverrideFont",OverrideFont);
+	out->addInt   ("MaxChars",            Max);
+	out->addBool  ("WordWrap",            WordWrap);
+	out->addBool  ("MultiLine",           MultiLine);
+	out->addBool  ("AutoScroll",          AutoScroll);
+	out->addBool  ("PasswordBox",         PasswordBox);
+	core::stringw ch = L" ";
+	ch[0] = PasswordChar;
+	out->addString("PasswordChar",        ch.c_str());
+	out->addEnum  ("HTextAlign",          HAlign, GUIAlignmentNames);
+	out->addEnum  ("VTextAlign",          VAlign, GUIAlignmentNames);
+
+	IGUIEditBox::serializeAttributes(out,options);
+}
+
+
+//! Reads attributes of the element
+void intlGUIEditBox::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
+{
+	IGUIEditBox::deserializeAttributes(in,options);
+
+	setOverrideColor(in->getAttributeAsColor("OverrideColor"));
+	enableOverrideColor(in->getAttributeAsBool("OverrideColorEnabled"));
+	setMax(in->getAttributeAsInt("MaxChars"));
+	setWordWrap(in->getAttributeAsBool("WordWrap"));
+	setMultiLine(in->getAttributeAsBool("MultiLine"));
+	setAutoScroll(in->getAttributeAsBool("AutoScroll"));
+	core::stringw ch = in->getAttributeAsStringW("PasswordChar");
+
+	if (!ch.size())
+		setPasswordBox(in->getAttributeAsBool("PasswordBox"));
+	else
+		setPasswordBox(in->getAttributeAsBool("PasswordBox"), ch[0]);
+
+	setTextAlignment( (EGUI_ALIGNMENT) in->getAttributeAsEnumeration("HTextAlign", GUIAlignmentNames),
+			(EGUI_ALIGNMENT) in->getAttributeAsEnumeration("VTextAlign", GUIAlignmentNames));
+
+	// setOverrideFont(in->getAttributeAsFont("OverrideFont"));
+}
+
+
+} // end namespace gui
+} // end namespace irr
+
+#endif // _IRR_COMPILE_WITH_GUI_
diff --git a/src/intlGUIEditBox.h b/src/intlGUIEditBox.h
new file mode 100644
index 000000000..e3ee15a30
--- /dev/null
+++ b/src/intlGUIEditBox.h
@@ -0,0 +1,178 @@
+// Copyright (C) 2002-2013 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __C_INTL_GUI_EDIT_BOX_H_INCLUDED__
+#define __C_INTL_GUI_EDIT_BOX_H_INCLUDED__
+
+#include "IrrCompileConfig.h"
+//#ifdef _IRR_COMPILE_WITH_GUI_
+
+#include "IGUIEditBox.h"
+#include "irrArray.h"
+#include "IOSOperator.h"
+
+namespace irr
+{
+namespace gui
+{
+	class intlGUIEditBox : public IGUIEditBox
+	{
+	public:
+
+		//! constructor
+		intlGUIEditBox(const wchar_t* text, bool border, IGUIEnvironment* environment,
+			IGUIElement* parent, s32 id, const core::rect<s32>& rectangle);
+
+		//! destructor
+		virtual ~intlGUIEditBox();
+
+		//! Sets another skin independent font.
+		virtual void setOverrideFont(IGUIFont* font=0);
+
+		//! Gets the override font (if any)
+		/** \return The override font (may be 0) */
+		virtual IGUIFont* getOverrideFont() const;
+
+		//! Get the font which is used right now for drawing
+		/** Currently this is the override font when one is set and the
+		font of the active skin otherwise */
+		virtual IGUIFont* getActiveFont() const;
+
+		//! Sets another color for the text.
+		virtual void setOverrideColor(video::SColor color);
+
+		//! Gets the override color
+		virtual video::SColor getOverrideColor() const;
+
+		//! Sets if the text should use the overide color or the
+		//! color in the gui skin.
+		virtual void enableOverrideColor(bool enable);
+
+		//! Checks if an override color is enabled
+		/** \return true if the override color is enabled, false otherwise */
+		virtual bool isOverrideColorEnabled(void) const;
+
+		//! Sets whether to draw the background
+		virtual void setDrawBackground(bool draw);
+
+		//! Turns the border on or off
+		virtual void setDrawBorder(bool border);
+
+		//! Enables or disables word wrap for using the edit box as multiline text editor.
+		virtual void setWordWrap(bool enable);
+
+		//! Checks if word wrap is enabled
+		//! \return true if word wrap is enabled, false otherwise
+		virtual bool isWordWrapEnabled() const;
+
+		//! Enables or disables newlines.
+		/** \param enable: If set to true, the EGET_EDITBOX_ENTER event will not be fired,
+		instead a newline character will be inserted. */
+		virtual void setMultiLine(bool enable);
+
+		//! Checks if multi line editing is enabled
+		//! \return true if mult-line is enabled, false otherwise
+		virtual bool isMultiLineEnabled() const;
+
+		//! Enables or disables automatic scrolling with cursor position
+		//! \param enable: If set to true, the text will move around with the cursor position
+		virtual void setAutoScroll(bool enable);
+
+		//! Checks to see if automatic scrolling is enabled
+		//! \return true if automatic scrolling is enabled, false if not
+		virtual bool isAutoScrollEnabled() const;
+
+		//! Gets the size area of the text in the edit box
+		//! \return Returns the size in pixels of the text
+		virtual core::dimension2du getTextDimension();
+
+		//! Sets text justification
+		virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
+
+		//! called if an event happened.
+		virtual bool OnEvent(const SEvent& event);
+
+		//! draws the element and its children
+		virtual void draw();
+
+		//! Sets the new caption of this element.
+		virtual void setText(const wchar_t* text);
+
+		//! Sets the maximum amount of characters which may be entered in the box.
+		//! \param max: Maximum amount of characters. If 0, the character amount is
+		//! infinity.
+		virtual void setMax(u32 max);
+
+		//! Returns maximum amount of characters, previously set by setMax();
+		virtual u32 getMax() const;
+
+		//! Sets whether the edit box is a password box. Setting this to true will
+		/** disable MultiLine, WordWrap and the ability to copy with ctrl+c or ctrl+x
+		\param passwordBox: true to enable password, false to disable
+		\param passwordChar: the character that is displayed instead of letters */
+		virtual void setPasswordBox(bool passwordBox, wchar_t passwordChar = L'*');
+
+		//! Returns true if the edit box is currently a password box.
+		virtual bool isPasswordBox() const;
+
+		//! Updates the absolute position, splits text if required
+		virtual void updateAbsolutePosition();
+
+		//! Writes attributes of the element.
+		virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
+
+		//! Reads attributes of the element
+		virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
+
+	protected:
+		//! Breaks the single text line.
+		void breakText();
+		//! sets the area of the given line
+		void setTextRect(s32 line);
+		//! returns the line number that the cursor is on
+		s32 getLineFromPos(s32 pos);
+		//! adds a letter to the edit box
+		void inputChar(wchar_t c);
+		//! calculates the current scroll position
+		void calculateScrollPos();
+		//! send some gui event to parent
+		void sendGuiEvent(EGUI_EVENT_TYPE type);
+		//! set text markers
+		void setTextMarkers(s32 begin, s32 end);
+
+		bool processKey(const SEvent& event);
+		bool processMouse(const SEvent& event);
+		s32 getCursorPos(s32 x, s32 y);
+
+		bool MouseMarking;
+		bool Border;
+		bool OverrideColorEnabled;
+		s32 MarkBegin;
+		s32 MarkEnd;
+
+		video::SColor OverrideColor;
+		gui::IGUIFont *OverrideFont, *LastBreakFont;
+		IOSOperator* Operator;
+
+		u32 BlinkStartTime;
+		s32 CursorPos;
+		s32 HScrollPos, VScrollPos; // scroll position in characters
+		u32 Max;
+
+		bool WordWrap, MultiLine, AutoScroll, PasswordBox;
+		wchar_t PasswordChar;
+		EGUI_ALIGNMENT HAlign, VAlign;
+
+		core::array< core::stringw > BrokenText;
+		core::array< s32 > BrokenTextPositions;
+
+		core::rect<s32> CurrentTextRect, FrameRect; // temporary values
+	};
+
+
+} // end namespace gui
+} // end namespace irr
+
+//#endif // _IRR_COMPILE_WITH_GUI_
+#endif // __C_GUI_EDIT_BOX_H_INCLUDED__
diff --git a/src/inventory.cpp b/src/inventory.cpp
index 5e39a41a6..7051b611f 100644
--- a/src/inventory.cpp
+++ b/src/inventory.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/inventory.h b/src/inventory.h
index 5f90183d2..676088b94 100644
--- a/src/inventory.h
+++ b/src/inventory.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/inventorymanager.cpp b/src/inventorymanager.cpp
index 4d862de66..08cae6d40 100644
--- a/src/inventorymanager.cpp
+++ b/src/inventorymanager.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/inventorymanager.h b/src/inventorymanager.h
index f81f5b972..8e2abc961 100644
--- a/src/inventorymanager.h
+++ b/src/inventorymanager.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/irr_aabb3d.h b/src/irr_aabb3d.h
index 3f04198ad..7ac401837 100644
--- a/src/irr_aabb3d.h
+++ b/src/irr_aabb3d.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/irr_v2d.h b/src/irr_v2d.h
index 0710684ce..5c0d65a30 100644
--- a/src/irr_v2d.h
+++ b/src/irr_v2d.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/irr_v3d.h b/src/irr_v3d.h
index 21051f93c..7bc73ad10 100644
--- a/src/irr_v3d.h
+++ b/src/irr_v3d.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/irrlichttypes.h b/src/irrlichttypes.h
index 2db744a48..7da1a4bd2 100644
--- a/src/irrlichttypes.h
+++ b/src/irrlichttypes.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/irrlichttypes_bloated.h b/src/irrlichttypes_bloated.h
index 528ee1f47..2ce19999e 100644
--- a/src/irrlichttypes_bloated.h
+++ b/src/irrlichttypes_bloated.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/irrlichttypes_extrabloated.h b/src/irrlichttypes_extrabloated.h
index f85fb6318..a541b1a02 100644
--- a/src/irrlichttypes_extrabloated.h
+++ b/src/irrlichttypes_extrabloated.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/itemdef.cpp b/src/itemdef.cpp
index 260baadc0..c1ecf762f 100644
--- a/src/itemdef.cpp
+++ b/src/itemdef.cpp
@@ -1,7 +1,7 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2011 Kahrl <kahrl@gmx.net>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Kahrl <kahrl@gmx.net>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -100,6 +100,7 @@ void ItemDefinition::reset()
 	wield_scale = v3f(1.0, 1.0, 1.0);
 	stack_max = 99;
 	usable = false;
+	rightclickable = false;
 	liquids_pointable = false;
 	if(tool_capabilities)
 	{
diff --git a/src/itemdef.h b/src/itemdef.h
index 699d727bd..4a9e16966 100644
--- a/src/itemdef.h
+++ b/src/itemdef.h
@@ -1,7 +1,7 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2011 Kahrl <kahrl@gmx.net>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Kahrl <kahrl@gmx.net>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -62,6 +62,8 @@ struct ItemDefinition
 	*/
 	s16 stack_max;
 	bool usable;
+	// If true, don't use node placement prediction
+	bool rightclickable;
 	bool liquids_pointable;
 	// May be NULL. If non-NULL, deleted by destructor
 	ToolCapabilities *tool_capabilities;
diff --git a/src/itemgroup.h b/src/itemgroup.h
index c6c36dcc4..69678064f 100644
--- a/src/itemgroup.h
+++ b/src/itemgroup.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/json/CMakeLists.txt b/src/json/CMakeLists.txt
new file mode 100644
index 000000000..0957799aa
--- /dev/null
+++ b/src/json/CMakeLists.txt
@@ -0,0 +1,14 @@
+if( UNIX )
+	set(json_SRCS jsoncpp.cpp)
+	set(json_platform_LIBS "")
+else( UNIX )
+	set(json_SRCS jsoncpp.cpp)
+	set(json_platform_LIBS "")
+endif( UNIX )
+
+add_library(json ${json_SRCS})
+
+target_link_libraries(
+	json
+	${json_platform_LIBS}
+)
diff --git a/src/json/UPDATING b/src/json/UPDATING
new file mode 100644
index 000000000..d00076601
--- /dev/null
+++ b/src/json/UPDATING
@@ -0,0 +1,16 @@
+#!/bin/sh
+cd ..
+svn co https://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/jsoncpp jsoncpp
+svn up jsoncpp
+cd jsoncpp
+python amalgamate.py
+cp -R dist/json ..
+cp dist/jsoncpp.cpp ../json
+
+# maybe you need to patch:
+# src/json/jsoncpp.cpp:
+# -#include <json/json.h>
+# +#include "json/json.h"
+
+#svn export --force https://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/jsoncpp/src/lib_json json
+#svn export --force https://jsoncpp.svn.sourceforge.net/svnroot/jsoncpp/trunk/jsoncpp/include/json json
diff --git a/src/json/json.h b/src/json/json.h
new file mode 100644
index 000000000..396aafa82
--- /dev/null
+++ b/src/json/json.h
@@ -0,0 +1,1914 @@
+/// Json-cpp amalgated header (http://jsoncpp.sourceforge.net/).
+/// It is intented to be used with #include <json/json.h>
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+/*
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
+
+*/
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#ifndef JSON_AMALGATED_H_INCLUDED
+# define JSON_AMALGATED_H_INCLUDED
+/// If defined, indicates that the source file is amalgated
+/// to prevent private header inclusion.
+#define JSON_IS_AMALGAMATION
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_CONFIG_H_INCLUDED
+# define JSON_CONFIG_H_INCLUDED
+
+/// If defined, indicates that json library is embedded in CppTL library.
+//# define JSON_IN_CPPTL 1
+
+/// If defined, indicates that json may leverage CppTL library
+//#  define JSON_USE_CPPTL 1
+/// If defined, indicates that cpptl vector based map should be used instead of std::map
+/// as Value container.
+//#  define JSON_USE_CPPTL_SMALLMAP 1
+/// If defined, indicates that Json specific container should be used
+/// (hash table & simple deque container with customizable allocator).
+/// THIS FEATURE IS STILL EXPERIMENTAL! There is know bugs: See #3177332
+//#  define JSON_VALUE_USE_INTERNAL_MAP 1
+/// Force usage of standard new/malloc based allocator instead of memory pool based allocator.
+/// The memory pools allocator used optimization (initializing Value and ValueInternalLink
+/// as if it was a POD) that may cause some validation tool to report errors.
+/// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined.
+//#  define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1
+
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+# ifndef JSON_USE_EXCEPTION
+# define JSON_USE_EXCEPTION 1
+# endif
+
+/// If defined, indicates that the source file is amalgated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgated header.
+// #define JSON_IS_AMALGAMATION
+
+
+# ifdef JSON_IN_CPPTL
+#  include <cpptl/config.h>
+#  ifndef JSON_USE_CPPTL
+#   define JSON_USE_CPPTL 1
+#  endif
+# endif
+
+# ifdef JSON_IN_CPPTL
+#  define JSON_API CPPTL_API
+# elif defined(JSON_DLL_BUILD)
+#  define JSON_API __declspec(dllexport)
+# elif defined(JSON_DLL)
+#  define JSON_API __declspec(dllimport)
+# else
+#  define JSON_API
+# endif
+
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for integer
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+#if defined(_MSC_VER)  &&  _MSC_VER <= 1200 // MSVC 6
+// Microsoft Visual Studio 6 only support conversion from __int64 to double
+// (no conversion from unsigned __int64).
+#define JSON_USE_INT64_DOUBLE_CONVERSION 1
+#endif // if defined(_MSC_VER)  &&  _MSC_VER < 1200 // MSVC 6
+
+#if defined(_MSC_VER)  &&  _MSC_VER >= 1500 // MSVC 2008
+/// Indicates that the following function is deprecated.
+# define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#endif
+
+#if !defined(JSONCPP_DEPRECATED)
+# define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+namespace Json {
+   typedef int Int;
+   typedef unsigned int UInt;
+# if defined(JSON_NO_INT64)
+   typedef int LargestInt;
+   typedef unsigned int LargestUInt;
+#  undef JSON_HAS_INT64
+# else // if defined(JSON_NO_INT64)
+   // For Microsoft Visual use specific types as long long is not supported
+#  if defined(_MSC_VER) // Microsoft Visual Studio
+   typedef __int64 Int64;
+   typedef unsigned __int64 UInt64;
+#  else // if defined(_MSC_VER) // Other platforms, use long long
+   typedef long long int Int64;
+   typedef unsigned long long int UInt64;
+#  endif // if defined(_MSC_VER)
+   typedef Int64 LargestInt;
+   typedef UInt64 LargestUInt;
+#  define JSON_HAS_INT64
+# endif // if defined(JSON_NO_INT64)
+} // end namespace Json
+
+
+#endif // JSON_CONFIG_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FORWARDS_H_INCLUDED
+# define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+   // writer.h
+   class FastWriter;
+   class StyledWriter;
+
+   // reader.h
+   class Reader;
+
+   // features.h
+   class Features;
+
+   // value.h
+   typedef unsigned int ArrayIndex;
+   class StaticString;
+   class Path;
+   class PathArgument;
+   class Value;
+   class ValueIteratorBase;
+   class ValueIterator;
+   class ValueConstIterator;
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   class ValueMapAllocator;
+   class ValueInternalLink;
+   class ValueInternalArray;
+   class ValueInternalMap;
+#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+} // namespace Json
+
+
+#endif // JSON_FORWARDS_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/features.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_FEATURES_H_INCLUDED
+# define CPPTL_JSON_FEATURES_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+   /** \brief Configuration passed to reader and writer.
+    * This configuration object can be used to force the Reader or Writer
+    * to behave in a standard conforming way.
+    */
+   class JSON_API Features
+   {
+   public:
+      /** \brief A configuration that allows all features and assumes all strings are UTF-8.
+       * - C & C++ comments are allowed
+       * - Root object can be any JSON value
+       * - Assumes Value strings are encoded in UTF-8
+       */
+      static Features all();
+
+      /** \brief A configuration that is strictly compatible with the JSON specification.
+       * - Comments are forbidden.
+       * - Root object must be either an array or an object value.
+       * - Assumes Value strings are encoded in UTF-8
+       */
+      static Features strictMode();
+
+      /** \brief Initialize the configuration like JsonConfig::allFeatures;
+       */
+      Features();
+
+      /// \c true if comments are allowed. Default: \c true.
+      bool allowComments_;
+
+      /// \c true if root must be either an array or an object value. Default: \c false.
+      bool strictRoot_;
+   };
+
+} // namespace Json
+
+#endif // CPPTL_JSON_FEATURES_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/features.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/value.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_H_INCLUDED
+# define CPPTL_JSON_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "forwards.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+# include <string>
+# include <vector>
+
+# ifndef JSON_USE_CPPTL_SMALLMAP
+#  include <map>
+# else
+#  include <cpptl/smallmap.h>
+# endif
+# ifdef JSON_USE_CPPTL
+#  include <cpptl/forwards.h>
+# endif
+
+/** \brief JSON (JavaScript Object Notation).
+ */
+namespace Json {
+
+   /** \brief Type of the value held by a Value object.
+    */
+   enum ValueType
+   {
+      nullValue = 0, ///< 'null' value
+      intValue,      ///< signed integer value
+      uintValue,     ///< unsigned integer value
+      realValue,     ///< double value
+      stringValue,   ///< UTF-8 string value
+      booleanValue,  ///< bool value
+      arrayValue,    ///< array value (ordered list)
+      objectValue    ///< object value (collection of name/value pairs).
+   };
+
+   enum CommentPlacement
+   {
+      commentBefore = 0,        ///< a comment placed on the line before a value
+      commentAfterOnSameLine,   ///< a comment just after a value on the same line
+      commentAfter,             ///< a comment on the line after a value (only make sense for root value)
+      numberOfCommentPlacement
+   };
+
+//# ifdef JSON_USE_CPPTL
+//   typedef CppTL::AnyEnumerator<const char *> EnumMemberNames;
+//   typedef CppTL::AnyEnumerator<const Value &> EnumValues;
+//# endif
+
+   /** \brief Lightweight wrapper to tag static string.
+    *
+    * Value constructor and objectValue member assignement takes advantage of the
+    * StaticString and avoid the cost of string duplication when storing the
+    * string or the member name.
+    *
+    * Example of usage:
+    * \code
+    * Json::Value aValue( StaticString("some text") );
+    * Json::Value object;
+    * static const StaticString code("code");
+    * object[code] = 1234;
+    * \endcode
+    */
+   class JSON_API StaticString
+   {
+   public:
+      explicit StaticString( const char *czstring )
+         : str_( czstring )
+      {
+      }
+
+      operator const char *() const
+      {
+         return str_;
+      }
+
+      const char *c_str() const
+      {
+         return str_;
+      }
+
+   private:
+      const char *str_;
+   };
+
+   /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value.
+    *
+    * This class is a discriminated union wrapper that can represents a:
+    * - signed integer [range: Value::minInt - Value::maxInt]
+    * - unsigned integer (range: 0 - Value::maxUInt)
+    * - double
+    * - UTF-8 string
+    * - boolean
+    * - 'null'
+    * - an ordered list of Value
+    * - collection of name/value pairs (javascript object)
+    *
+    * The type of the held value is represented by a #ValueType and 
+    * can be obtained using type().
+    *
+    * values of an #objectValue or #arrayValue can be accessed using operator[]() methods. 
+    * Non const methods will automatically create the a #nullValue element 
+    * if it does not exist. 
+    * The sequence of an #arrayValue will be automatically resize and initialized 
+    * with #nullValue. resize() can be used to enlarge or truncate an #arrayValue.
+    *
+    * The get() methods can be used to obtanis default value in the case the required element
+    * does not exist.
+    *
+    * It is possible to iterate over the list of a #objectValue values using 
+    * the getMemberNames() method.
+    */
+   class JSON_API Value 
+   {
+      friend class ValueIteratorBase;
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      friend class ValueInternalLink;
+      friend class ValueInternalMap;
+# endif
+   public:
+      typedef std::vector<std::string> Members;
+      typedef ValueIterator iterator;
+      typedef ValueConstIterator const_iterator;
+      typedef Json::UInt UInt;
+      typedef Json::Int Int;
+# if defined(JSON_HAS_INT64)
+      typedef Json::UInt64 UInt64;
+      typedef Json::Int64 Int64;
+#endif // defined(JSON_HAS_INT64)
+      typedef Json::LargestInt LargestInt;
+      typedef Json::LargestUInt LargestUInt;
+      typedef Json::ArrayIndex ArrayIndex;
+
+      static const Value null;
+      /// Minimum signed integer value that can be stored in a Json::Value.
+      static const LargestInt minLargestInt;
+      /// Maximum signed integer value that can be stored in a Json::Value.
+      static const LargestInt maxLargestInt;
+      /// Maximum unsigned integer value that can be stored in a Json::Value.
+      static const LargestUInt maxLargestUInt;
+
+      /// Minimum signed int value that can be stored in a Json::Value.
+      static const Int minInt;
+      /// Maximum signed int value that can be stored in a Json::Value.
+      static const Int maxInt;
+      /// Maximum unsigned int value that can be stored in a Json::Value.
+      static const UInt maxUInt;
+
+# if defined(JSON_HAS_INT64)
+      /// Minimum signed 64 bits int value that can be stored in a Json::Value.
+      static const Int64 minInt64;
+      /// Maximum signed 64 bits int value that can be stored in a Json::Value.
+      static const Int64 maxInt64;
+      /// Maximum unsigned 64 bits int value that can be stored in a Json::Value.
+      static const UInt64 maxUInt64;
+#endif // defined(JSON_HAS_INT64)
+
+   private:
+#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+# ifndef JSON_VALUE_USE_INTERNAL_MAP
+      class CZString 
+      {
+      public:
+         enum DuplicationPolicy 
+         {
+            noDuplication = 0,
+            duplicate,
+            duplicateOnCopy
+         };
+         CZString( ArrayIndex index );
+         CZString( const char *cstr, DuplicationPolicy allocate );
+         CZString( const CZString &other );
+         ~CZString();
+         CZString &operator =( const CZString &other );
+         bool operator<( const CZString &other ) const;
+         bool operator==( const CZString &other ) const;
+         ArrayIndex index() const;
+         const char *c_str() const;
+         bool isStaticString() const;
+      private:
+         void swap( CZString &other );
+         const char *cstr_;
+         ArrayIndex index_;
+      };
+
+   public:
+#  ifndef JSON_USE_CPPTL_SMALLMAP
+      typedef std::map<CZString, Value> ObjectValues;
+#  else
+      typedef CppTL::SmallMap<CZString, Value> ObjectValues;
+#  endif // ifndef JSON_USE_CPPTL_SMALLMAP
+# endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
+#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+   public:
+      /** \brief Create a default Value of the given type.
+
+        This is a very useful constructor.
+        To create an empty array, pass arrayValue.
+        To create an empty object, pass objectValue.
+        Another Value can then be set to this one by assignment.
+    This is useful since clear() and resize() will not alter types.
+
+        Examples:
+    \code
+    Json::Value null_value; // null
+    Json::Value arr_value(Json::arrayValue); // []
+    Json::Value obj_value(Json::objectValue); // {}
+    \endcode
+      */
+      Value( ValueType type = nullValue );
+      Value( Int value );
+      Value( UInt value );
+#if defined(JSON_HAS_INT64)
+      Value( Int64 value );
+      Value( UInt64 value );
+#endif // if defined(JSON_HAS_INT64)
+      Value( double value );
+      Value( const char *value );
+      Value( const char *beginValue, const char *endValue );
+      /** \brief Constructs a value from a static string.
+
+       * Like other value string constructor but do not duplicate the string for
+       * internal storage. The given string must remain alive after the call to this
+       * constructor.
+       * Example of usage:
+       * \code
+       * Json::Value aValue( StaticString("some text") );
+       * \endcode
+       */
+      Value( const StaticString &value );
+      Value( const std::string &value );
+# ifdef JSON_USE_CPPTL
+      Value( const CppTL::ConstString &value );
+# endif
+      Value( bool value );
+      Value( const Value &other );
+      ~Value();
+
+      Value &operator=( const Value &other );
+      /// Swap values.
+      /// \note Currently, comments are intentionally not swapped, for
+      /// both logic and efficiency.
+      void swap( Value &other );
+
+      ValueType type() const;
+
+      bool operator <( const Value &other ) const;
+      bool operator <=( const Value &other ) const;
+      bool operator >=( const Value &other ) const;
+      bool operator >( const Value &other ) const;
+
+      bool operator ==( const Value &other ) const;
+      bool operator !=( const Value &other ) const;
+
+      int compare( const Value &other ) const;
+
+      const char *asCString() const;
+      std::string asString() const;
+# ifdef JSON_USE_CPPTL
+      CppTL::ConstString asConstString() const;
+# endif
+      Int asInt() const;
+      UInt asUInt() const;
+#if defined(JSON_HAS_INT64)
+      Int64 asInt64() const;
+      UInt64 asUInt64() const;
+#endif // if defined(JSON_HAS_INT64)
+      LargestInt asLargestInt() const;
+      LargestUInt asLargestUInt() const;
+      float asFloat() const;
+      double asDouble() const;
+      bool asBool() const;
+
+      bool isNull() const;
+      bool isBool() const;
+      bool isInt() const;
+      bool isInt64() const;
+      bool isUInt() const;
+      bool isUInt64() const;
+      bool isIntegral() const;
+      bool isDouble() const;
+      bool isNumeric() const;
+      bool isString() const;
+      bool isArray() const;
+      bool isObject() const;
+
+      bool isConvertibleTo( ValueType other ) const;
+
+      /// Number of values in array or object
+      ArrayIndex size() const;
+
+      /// \brief Return true if empty array, empty object, or null;
+      /// otherwise, false.
+      bool empty() const;
+
+      /// Return isNull()
+      bool operator!() const;
+
+      /// Remove all object members and array elements.
+      /// \pre type() is arrayValue, objectValue, or nullValue
+      /// \post type() is unchanged
+      void clear();
+
+      /// Resize the array to size elements. 
+      /// New elements are initialized to null.
+      /// May only be called on nullValue or arrayValue.
+      /// \pre type() is arrayValue or nullValue
+      /// \post type() is arrayValue
+      void resize( ArrayIndex size );
+
+      /// Access an array element (zero based index ).
+      /// If the array contains less than index element, then null value are inserted
+      /// in the array so that its size is index+1.
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      Value &operator[]( ArrayIndex index );
+
+      /// Access an array element (zero based index ).
+      /// If the array contains less than index element, then null value are inserted
+      /// in the array so that its size is index+1.
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      Value &operator[]( int index );
+
+      /// Access an array element (zero based index )
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      const Value &operator[]( ArrayIndex index ) const;
+
+      /// Access an array element (zero based index )
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      const Value &operator[]( int index ) const;
+
+      /// If the array contains at least index+1 elements, returns the element value, 
+      /// otherwise returns defaultValue.
+      Value get( ArrayIndex index, 
+                 const Value &defaultValue ) const;
+      /// Return true if index < size().
+      bool isValidIndex( ArrayIndex index ) const;
+      /// \brief Append value to array at the end.
+      ///
+      /// Equivalent to jsonvalue[jsonvalue.size()] = value;
+      Value &append( const Value &value );
+
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const char *key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const char *key ) const;
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const std::string &key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const std::string &key ) const;
+      /** \brief Access an object value by name, create a null member if it does not exist.
+
+       * If the object as no entry for that name, then the member name used to store
+       * the new entry is not duplicated.
+       * Example of use:
+       * \code
+       * Json::Value object;
+       * static const StaticString code("code");
+       * object[code] = 1234;
+       * \endcode
+       */
+      Value &operator[]( const StaticString &key );
+# ifdef JSON_USE_CPPTL
+      /// Access an object value by name, create a null member if it does not exist.
+      Value &operator[]( const CppTL::ConstString &key );
+      /// Access an object value by name, returns null if there is no member with that name.
+      const Value &operator[]( const CppTL::ConstString &key ) const;
+# endif
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const char *key, 
+                 const Value &defaultValue ) const;
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const std::string &key,
+                 const Value &defaultValue ) const;
+# ifdef JSON_USE_CPPTL
+      /// Return the member named key if it exist, defaultValue otherwise.
+      Value get( const CppTL::ConstString &key,
+                 const Value &defaultValue ) const;
+# endif
+      /// \brief Remove and return the named member.  
+      ///
+      /// Do nothing if it did not exist.
+      /// \return the removed Value, or null.
+      /// \pre type() is objectValue or nullValue
+      /// \post type() is unchanged
+      Value removeMember( const char* key );
+      /// Same as removeMember(const char*)
+      Value removeMember( const std::string &key );
+
+      /// Return true if the object has a member named key.
+      bool isMember( const char *key ) const;
+      /// Return true if the object has a member named key.
+      bool isMember( const std::string &key ) const;
+# ifdef JSON_USE_CPPTL
+      /// Return true if the object has a member named key.
+      bool isMember( const CppTL::ConstString &key ) const;
+# endif
+
+      /// \brief Return a list of the member names.
+      ///
+      /// If null, return an empty list.
+      /// \pre type() is objectValue or nullValue
+      /// \post if type() was nullValue, it remains nullValue
+      Members getMemberNames() const;
+
+//# ifdef JSON_USE_CPPTL
+//      EnumMemberNames enumMemberNames() const;
+//      EnumValues enumValues() const;
+//# endif
+
+      /// Comments must be //... or /* ... */
+      void setComment( const char *comment,
+                       CommentPlacement placement );
+      /// Comments must be //... or /* ... */
+      void setComment( const std::string &comment,
+                       CommentPlacement placement );
+      bool hasComment( CommentPlacement placement ) const;
+      /// Include delimiters and embedded newlines.
+      std::string getComment( CommentPlacement placement ) const;
+
+      std::string toStyledString() const;
+
+      const_iterator begin() const;
+      const_iterator end() const;
+
+      iterator begin();
+      iterator end();
+
+   private:
+      Value &resolveReference( const char *key, 
+                               bool isStatic );
+
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      inline bool isItemAvailable() const
+      {
+         return itemIsUsed_ == 0;
+      }
+
+      inline void setItemUsed( bool isUsed = true )
+      {
+         itemIsUsed_ = isUsed ? 1 : 0;
+      }
+
+      inline bool isMemberNameStatic() const
+      {
+         return memberNameIsStatic_ == 0;
+      }
+
+      inline void setMemberNameIsStatic( bool isStatic )
+      {
+         memberNameIsStatic_ = isStatic ? 1 : 0;
+      }
+# endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+   private:
+      struct CommentInfo
+      {
+         CommentInfo();
+         ~CommentInfo();
+
+         void setComment( const char *text );
+
+         char *comment_;
+      };
+
+      //struct MemberNamesTransform
+      //{
+      //   typedef const char *result_type;
+      //   const char *operator()( const CZString &name ) const
+      //   {
+      //      return name.c_str();
+      //   }
+      //};
+
+      union ValueHolder
+      {
+         LargestInt int_;
+         LargestUInt uint_;
+         double real_;
+         bool bool_;
+         char *string_;
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+         ValueInternalArray *array_;
+         ValueInternalMap *map_;
+#else
+         ObjectValues *map_;
+# endif
+      } value_;
+      ValueType type_ : 8;
+      int allocated_ : 1;     // Notes: if declared as bool, bitfield is useless.
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+      unsigned int itemIsUsed_ : 1;      // used by the ValueInternalMap container.
+      int memberNameIsStatic_ : 1;       // used by the ValueInternalMap container.
+# endif
+      CommentInfo *comments_;
+   };
+
+
+   /** \brief Experimental and untested: represents an element of the "path" to access a node.
+    */
+   class PathArgument
+   {
+   public:
+      friend class Path;
+
+      PathArgument();
+      PathArgument( ArrayIndex index );
+      PathArgument( const char *key );
+      PathArgument( const std::string &key );
+
+   private:
+      enum Kind
+      {
+         kindNone = 0,
+         kindIndex,
+         kindKey
+      };
+      std::string key_;
+      ArrayIndex index_;
+      Kind kind_;
+   };
+
+   /** \brief Experimental and untested: represents a "path" to access a node.
+    *
+    * Syntax:
+    * - "." => root node
+    * - ".[n]" => elements at index 'n' of root node (an array value)
+    * - ".name" => member named 'name' of root node (an object value)
+    * - ".name1.name2.name3"
+    * - ".[0][1][2].name1[3]"
+    * - ".%" => member name is provided as parameter
+    * - ".[%]" => index is provied as parameter
+    */
+   class Path
+   {
+   public:
+      Path( const std::string &path,
+            const PathArgument &a1 = PathArgument(),
+            const PathArgument &a2 = PathArgument(),
+            const PathArgument &a3 = PathArgument(),
+            const PathArgument &a4 = PathArgument(),
+            const PathArgument &a5 = PathArgument() );
+
+      const Value &resolve( const Value &root ) const;
+      Value resolve( const Value &root, 
+                     const Value &defaultValue ) const;
+      /// Creates the "path" to access the specified node and returns a reference on the node.
+      Value &make( Value &root ) const;
+
+   private:
+      typedef std::vector<const PathArgument *> InArgs;
+      typedef std::vector<PathArgument> Args;
+
+      void makePath( const std::string &path,
+                     const InArgs &in );
+      void addPathInArg( const std::string &path, 
+                         const InArgs &in, 
+                         InArgs::const_iterator &itInArg, 
+                         PathArgument::Kind kind );
+      void invalidPath( const std::string &path, 
+                        int location );
+
+      Args args_;
+   };
+
+
+
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   /** \brief Allocator to customize Value internal map.
+    * Below is an example of a simple implementation (default implementation actually
+    * use memory pool for speed).
+    * \code
+      class DefaultValueMapAllocator : public ValueMapAllocator
+      {
+      public: // overridden from ValueMapAllocator
+         virtual ValueInternalMap *newMap()
+         {
+            return new ValueInternalMap();
+         }
+
+         virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other )
+         {
+            return new ValueInternalMap( other );
+         }
+
+         virtual void destructMap( ValueInternalMap *map )
+         {
+            delete map;
+         }
+
+         virtual ValueInternalLink *allocateMapBuckets( unsigned int size )
+         {
+            return new ValueInternalLink[size];
+         }
+
+         virtual void releaseMapBuckets( ValueInternalLink *links )
+         {
+            delete [] links;
+         }
+
+         virtual ValueInternalLink *allocateMapLink()
+         {
+            return new ValueInternalLink();
+         }
+
+         virtual void releaseMapLink( ValueInternalLink *link )
+         {
+            delete link;
+         }
+      };
+    * \endcode
+    */ 
+   class JSON_API ValueMapAllocator
+   {
+   public:
+      virtual ~ValueMapAllocator();
+      virtual ValueInternalMap *newMap() = 0;
+      virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) = 0;
+      virtual void destructMap( ValueInternalMap *map ) = 0;
+      virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) = 0;
+      virtual void releaseMapBuckets( ValueInternalLink *links ) = 0;
+      virtual ValueInternalLink *allocateMapLink() = 0;
+      virtual void releaseMapLink( ValueInternalLink *link ) = 0;
+   };
+
+   /** \brief ValueInternalMap hash-map bucket chain link (for internal use only).
+    * \internal previous_ & next_ allows for bidirectional traversal.
+    */
+   class JSON_API ValueInternalLink
+   {
+   public:
+      enum { itemPerLink = 6 };  // sizeof(ValueInternalLink) = 128 on 32 bits architecture.
+      enum InternalFlags { 
+         flagAvailable = 0,
+         flagUsed = 1
+      };
+
+      ValueInternalLink();
+
+      ~ValueInternalLink();
+
+      Value items_[itemPerLink];
+      char *keys_[itemPerLink];
+      ValueInternalLink *previous_;
+      ValueInternalLink *next_;
+   };
+
+
+   /** \brief A linked page based hash-table implementation used internally by Value.
+    * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
+    * list in each bucket to handle collision. There is an addional twist in that
+    * each node of the collision linked list is a page containing a fixed amount of
+    * value. This provides a better compromise between memory usage and speed.
+    * 
+    * Each bucket is made up of a chained list of ValueInternalLink. The last
+    * link of a given bucket can be found in the 'previous_' field of the following bucket.
+    * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
+    * Only the last link of a bucket may contains 'available' item. The last link always
+    * contains at least one element unless is it the bucket one very first link.
+    */
+   class JSON_API ValueInternalMap
+   {
+      friend class ValueIteratorBase;
+      friend class Value;
+   public:
+      typedef unsigned int HashKey;
+      typedef unsigned int BucketIndex;
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+      struct IteratorState
+      {
+         IteratorState() 
+            : map_(0)
+            , link_(0)
+            , itemIndex_(0)
+            , bucketIndex_(0) 
+         {
+         }
+         ValueInternalMap *map_;
+         ValueInternalLink *link_;
+         BucketIndex itemIndex_;
+         BucketIndex bucketIndex_;
+      };
+# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+      ValueInternalMap();
+      ValueInternalMap( const ValueInternalMap &other );
+      ValueInternalMap &operator =( const ValueInternalMap &other );
+      ~ValueInternalMap();
+
+      void swap( ValueInternalMap &other );
+
+      BucketIndex size() const;
+
+      void clear();
+
+      bool reserveDelta( BucketIndex growth );
+
+      bool reserve( BucketIndex newItemCount );
+
+      const Value *find( const char *key ) const;
+
+      Value *find( const char *key );
+
+      Value &resolveReference( const char *key, 
+                               bool isStatic );
+
+      void remove( const char *key );
+
+      void doActualRemove( ValueInternalLink *link, 
+                           BucketIndex index,
+                           BucketIndex bucketIndex );
+
+      ValueInternalLink *&getLastLinkInBucket( BucketIndex bucketIndex );
+
+      Value &setNewItem( const char *key, 
+                         bool isStatic, 
+                         ValueInternalLink *link, 
+                         BucketIndex index );
+
+      Value &unsafeAdd( const char *key, 
+                        bool isStatic, 
+                        HashKey hashedKey );
+
+      HashKey hash( const char *key ) const;
+
+      int compare( const ValueInternalMap &other ) const;
+
+   private:
+      void makeBeginIterator( IteratorState &it ) const;
+      void makeEndIterator( IteratorState &it ) const;
+      static bool equals( const IteratorState &x, const IteratorState &other );
+      static void increment( IteratorState &iterator );
+      static void incrementBucket( IteratorState &iterator );
+      static void decrement( IteratorState &iterator );
+      static const char *key( const IteratorState &iterator );
+      static const char *key( const IteratorState &iterator, bool &isStatic );
+      static Value &value( const IteratorState &iterator );
+      static int distance( const IteratorState &x, const IteratorState &y );
+
+   private:
+      ValueInternalLink *buckets_;
+      ValueInternalLink *tailLink_;
+      BucketIndex bucketsSize_;
+      BucketIndex itemCount_;
+   };
+
+   /** \brief A simplified deque implementation used internally by Value.
+   * \internal
+   * It is based on a list of fixed "page", each page contains a fixed number of items.
+   * Instead of using a linked-list, a array of pointer is used for fast item look-up.
+   * Look-up for an element is as follow:
+   * - compute page index: pageIndex = itemIndex / itemsPerPage
+   * - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage]
+   *
+   * Insertion is amortized constant time (only the array containing the index of pointers
+   * need to be reallocated when items are appended).
+   */
+   class JSON_API ValueInternalArray
+   {
+      friend class Value;
+      friend class ValueIteratorBase;
+   public:
+      enum { itemsPerPage = 8 };    // should be a power of 2 for fast divide and modulo.
+      typedef Value::ArrayIndex ArrayIndex;
+      typedef unsigned int PageIndex;
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+      struct IteratorState // Must be a POD
+      {
+         IteratorState() 
+            : array_(0)
+            , currentPageIndex_(0)
+            , currentItemIndex_(0) 
+         {
+         }
+         ValueInternalArray *array_;
+         Value **currentPageIndex_;
+         unsigned int currentItemIndex_;
+      };
+# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+      ValueInternalArray();
+      ValueInternalArray( const ValueInternalArray &other );
+      ValueInternalArray &operator =( const ValueInternalArray &other );
+      ~ValueInternalArray();
+      void swap( ValueInternalArray &other );
+
+      void clear();
+      void resize( ArrayIndex newSize );
+
+      Value &resolveReference( ArrayIndex index );
+
+      Value *find( ArrayIndex index ) const;
+
+      ArrayIndex size() const;
+
+      int compare( const ValueInternalArray &other ) const;
+
+   private:
+      static bool equals( const IteratorState &x, const IteratorState &other );
+      static void increment( IteratorState &iterator );
+      static void decrement( IteratorState &iterator );
+      static Value &dereference( const IteratorState &iterator );
+      static Value &unsafeDereference( const IteratorState &iterator );
+      static int distance( const IteratorState &x, const IteratorState &y );
+      static ArrayIndex indexOf( const IteratorState &iterator );
+      void makeBeginIterator( IteratorState &it ) const;
+      void makeEndIterator( IteratorState &it ) const;
+      void makeIterator( IteratorState &it, ArrayIndex index ) const;
+
+      void makeIndexValid( ArrayIndex index );
+
+      Value **pages_;
+      ArrayIndex size_;
+      PageIndex pageCount_;
+   };
+
+   /** \brief Experimental: do not use. Allocator to customize Value internal array.
+    * Below is an example of a simple implementation (actual implementation use
+    * memory pool).
+      \code
+class DefaultValueArrayAllocator : public ValueArrayAllocator
+{
+public: // overridden from ValueArrayAllocator
+   virtual ~DefaultValueArrayAllocator()
+   {
+   }
+
+   virtual ValueInternalArray *newArray()
+   {
+      return new ValueInternalArray();
+   }
+
+   virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other )
+   {
+      return new ValueInternalArray( other );
+   }
+
+   virtual void destruct( ValueInternalArray *array )
+   {
+      delete array;
+   }
+
+   virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                          ValueInternalArray::PageIndex &indexCount,
+                                          ValueInternalArray::PageIndex minNewIndexCount )
+   {
+      ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1;
+      if ( minNewIndexCount > newIndexCount )
+         newIndexCount = minNewIndexCount;
+      void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount );
+      if ( !newIndexes )
+         throw std::bad_alloc();
+      indexCount = newIndexCount;
+      indexes = static_cast<Value **>( newIndexes );
+   }
+   virtual void releaseArrayPageIndex( Value **indexes, 
+                                       ValueInternalArray::PageIndex indexCount )
+   {
+      if ( indexes )
+         free( indexes );
+   }
+
+   virtual Value *allocateArrayPage()
+   {
+      return static_cast<Value *>( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) );
+   }
+
+   virtual void releaseArrayPage( Value *value )
+   {
+      if ( value )
+         free( value );
+   }
+};
+      \endcode
+    */ 
+   class JSON_API ValueArrayAllocator
+   {
+   public:
+      virtual ~ValueArrayAllocator();
+      virtual ValueInternalArray *newArray() = 0;
+      virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) = 0;
+      virtual void destructArray( ValueInternalArray *array ) = 0;
+      /** \brief Reallocate array page index.
+       * Reallocates an array of pointer on each page.
+       * \param indexes [input] pointer on the current index. May be \c NULL.
+       *                [output] pointer on the new index of at least 
+       *                         \a minNewIndexCount pages. 
+       * \param indexCount [input] current number of pages in the index.
+       *                   [output] number of page the reallocated index can handle.
+       *                            \b MUST be >= \a minNewIndexCount.
+       * \param minNewIndexCount Minimum number of page the new index must be able to
+       *                         handle.
+       */
+      virtual void reallocateArrayPageIndex( Value **&indexes, 
+                                             ValueInternalArray::PageIndex &indexCount,
+                                             ValueInternalArray::PageIndex minNewIndexCount ) = 0;
+      virtual void releaseArrayPageIndex( Value **indexes, 
+                                          ValueInternalArray::PageIndex indexCount ) = 0;
+      virtual Value *allocateArrayPage() = 0;
+      virtual void releaseArrayPage( Value *value ) = 0;
+   };
+#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP
+
+
+   /** \brief base class for Value iterators.
+    *
+    */
+   class ValueIteratorBase
+   {
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef ValueIteratorBase SelfType;
+
+      ValueIteratorBase();
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueIteratorBase( const Value::ObjectValues::iterator &current );
+#else
+      ValueIteratorBase( const ValueInternalArray::IteratorState &state );
+      ValueIteratorBase( const ValueInternalMap::IteratorState &state );
+#endif
+
+      bool operator ==( const SelfType &other ) const
+      {
+         return isEqual( other );
+      }
+
+      bool operator !=( const SelfType &other ) const
+      {
+         return !isEqual( other );
+      }
+
+      difference_type operator -( const SelfType &other ) const
+      {
+         return computeDistance( other );
+      }
+
+      /// Return either the index or the member name of the referenced value as a Value.
+      Value key() const;
+
+      /// Return the index of the referenced Value. -1 if it is not an arrayValue.
+      UInt index() const;
+
+      /// Return the member name of the referenced Value. "" if it is not an objectValue.
+      const char *memberName() const;
+
+   protected:
+      Value &deref() const;
+
+      void increment();
+
+      void decrement();
+
+      difference_type computeDistance( const SelfType &other ) const;
+
+      bool isEqual( const SelfType &other ) const;
+
+      void copy( const SelfType &other );
+
+   private:
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      Value::ObjectValues::iterator current_;
+      // Indicates that iterator is for a null value.
+      bool isNull_;
+#else
+      union
+      {
+         ValueInternalArray::IteratorState array_;
+         ValueInternalMap::IteratorState map_;
+      } iterator_;
+      bool isArray_;
+#endif
+   };
+
+   /** \brief const iterator for object and array value.
+    *
+    */
+   class ValueConstIterator : public ValueIteratorBase
+   {
+      friend class Value;
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef const Value &reference;
+      typedef const Value *pointer;
+      typedef ValueConstIterator SelfType;
+
+      ValueConstIterator();
+   private:
+      /*! \internal Use by Value to create an iterator.
+       */
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueConstIterator( const Value::ObjectValues::iterator &current );
+#else
+      ValueConstIterator( const ValueInternalArray::IteratorState &state );
+      ValueConstIterator( const ValueInternalMap::IteratorState &state );
+#endif
+   public:
+      SelfType &operator =( const ValueIteratorBase &other );
+
+      SelfType operator++( int )
+      {
+         SelfType temp( *this );
+         ++*this;
+         return temp;
+      }
+
+      SelfType operator--( int )
+      {
+         SelfType temp( *this );
+         --*this;
+         return temp;
+      }
+
+      SelfType &operator--()
+      {
+         decrement();
+         return *this;
+      }
+
+      SelfType &operator++()
+      {
+         increment();
+         return *this;
+      }
+
+      reference operator *() const
+      {
+         return deref();
+      }
+   };
+
+
+   /** \brief Iterator for object and array value.
+    */
+   class ValueIterator : public ValueIteratorBase
+   {
+      friend class Value;
+   public:
+      typedef unsigned int size_t;
+      typedef int difference_type;
+      typedef Value &reference;
+      typedef Value *pointer;
+      typedef ValueIterator SelfType;
+
+      ValueIterator();
+      ValueIterator( const ValueConstIterator &other );
+      ValueIterator( const ValueIterator &other );
+   private:
+      /*! \internal Use by Value to create an iterator.
+       */
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+      explicit ValueIterator( const Value::ObjectValues::iterator &current );
+#else
+      ValueIterator( const ValueInternalArray::IteratorState &state );
+      ValueIterator( const ValueInternalMap::IteratorState &state );
+#endif
+   public:
+
+      SelfType &operator =( const SelfType &other );
+
+      SelfType operator++( int )
+      {
+         SelfType temp( *this );
+         ++*this;
+         return temp;
+      }
+
+      SelfType operator--( int )
+      {
+         SelfType temp( *this );
+         --*this;
+         return temp;
+      }
+
+      SelfType &operator--()
+      {
+         decrement();
+         return *this;
+      }
+
+      SelfType &operator++()
+      {
+         increment();
+         return *this;
+      }
+
+      reference operator *() const
+      {
+         return deref();
+      }
+   };
+
+
+} // namespace Json
+
+
+#endif // CPPTL_JSON_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/value.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/reader.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_READER_H_INCLUDED
+# define CPPTL_JSON_READER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "features.h"
+# include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+# include <deque>
+# include <stack>
+# include <string>
+
+namespace Json {
+
+   /** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a Value.
+    *
+    */
+   class JSON_API Reader
+   {
+   public:
+      typedef char Char;
+      typedef const Char *Location;
+
+      /** \brief Constructs a Reader allowing all features
+       * for parsing.
+       */
+      Reader();
+
+      /** \brief Constructs a Reader allowing the specified feature set
+       * for parsing.
+       */
+      Reader( const Features &features );
+
+      /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
+       * \param document UTF-8 encoded string containing the document to read.
+       * \param root [out] Contains the root value of the document if it was
+       *             successfully parsed.
+       * \param collectComments \c true to collect comment and allow writing them back during
+       *                        serialization, \c false to discard comments.
+       *                        This parameter is ignored if Features::allowComments_
+       *                        is \c false.
+       * \return \c true if the document was successfully parsed, \c false if an error occurred.
+       */
+      bool parse( const std::string &document, 
+                  Value &root,
+                  bool collectComments = true );
+
+      /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> document.
+       * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the document to read.
+       * \param endDoc Pointer on the end of the UTF-8 encoded string of the document to read. 
+       \               Must be >= beginDoc.
+       * \param root [out] Contains the root value of the document if it was
+       *             successfully parsed.
+       * \param collectComments \c true to collect comment and allow writing them back during
+       *                        serialization, \c false to discard comments.
+       *                        This parameter is ignored if Features::allowComments_
+       *                        is \c false.
+       * \return \c true if the document was successfully parsed, \c false if an error occurred.
+       */
+      bool parse( const char *beginDoc, const char *endDoc, 
+                  Value &root,
+                  bool collectComments = true );
+
+      /// \brief Parse from input stream.
+      /// \see Json::operator>>(std::istream&, Json::Value&).
+      bool parse( std::istream &is,
+                  Value &root,
+                  bool collectComments = true );
+
+      /** \brief Returns a user friendly string that list errors in the parsed document.
+       * \return Formatted error message with the list of errors with their location in 
+       *         the parsed document. An empty string is returned if no error occurred
+       *         during parsing.
+       * \deprecated Use getFormattedErrorMessages() instead (typo fix).
+       */
+      JSONCPP_DEPRECATED("Use getFormattedErrorMessages instead") 
+      std::string getFormatedErrorMessages() const;
+
+      /** \brief Returns a user friendly string that list errors in the parsed document.
+       * \return Formatted error message with the list of errors with their location in 
+       *         the parsed document. An empty string is returned if no error occurred
+       *         during parsing.
+       */
+      std::string getFormattedErrorMessages() const;
+
+   private:
+      enum TokenType
+      {
+         tokenEndOfStream = 0,
+         tokenObjectBegin,
+         tokenObjectEnd,
+         tokenArrayBegin,
+         tokenArrayEnd,
+         tokenString,
+         tokenNumber,
+         tokenTrue,
+         tokenFalse,
+         tokenNull,
+         tokenArraySeparator,
+         tokenMemberSeparator,
+         tokenComment,
+         tokenError
+      };
+
+      class Token
+      {
+      public:
+         TokenType type_;
+         Location start_;
+         Location end_;
+      };
+
+      class ErrorInfo
+      {
+      public:
+         Token token_;
+         std::string message_;
+         Location extra_;
+      };
+
+      typedef std::deque<ErrorInfo> Errors;
+
+      bool expectToken( TokenType type, Token &token, const char *message );
+      bool readToken( Token &token );
+      void skipSpaces();
+      bool match( Location pattern, 
+                  int patternLength );
+      bool readComment();
+      bool readCStyleComment();
+      bool readCppStyleComment();
+      bool readString();
+      void readNumber();
+      bool readValue();
+      bool readObject( Token &token );
+      bool readArray( Token &token );
+      bool decodeNumber( Token &token );
+      bool decodeString( Token &token );
+      bool decodeString( Token &token, std::string &decoded );
+      bool decodeDouble( Token &token );
+      bool decodeUnicodeCodePoint( Token &token, 
+                                   Location &current, 
+                                   Location end, 
+                                   unsigned int &unicode );
+      bool decodeUnicodeEscapeSequence( Token &token, 
+                                        Location &current, 
+                                        Location end, 
+                                        unsigned int &unicode );
+      bool addError( const std::string &message, 
+                     Token &token,
+                     Location extra = 0 );
+      bool recoverFromError( TokenType skipUntilToken );
+      bool addErrorAndRecover( const std::string &message, 
+                               Token &token,
+                               TokenType skipUntilToken );
+      void skipUntilSpace();
+      Value &currentValue();
+      Char getNextChar();
+      void getLocationLineAndColumn( Location location,
+                                     int &line,
+                                     int &column ) const;
+      std::string getLocationLineAndColumn( Location location ) const;
+      void addComment( Location begin, 
+                       Location end, 
+                       CommentPlacement placement );
+      void skipCommentTokens( Token &token );
+   
+      typedef std::stack<Value *> Nodes;
+      Nodes nodes_;
+      Errors errors_;
+      std::string document_;
+      Location begin_;
+      Location end_;
+      Location current_;
+      Location lastValueEnd_;
+      Value *lastValue_;
+      std::string commentsBefore_;
+      Features features_;
+      bool collectComments_;
+   };
+
+   /** \brief Read from 'sin' into 'root'.
+
+    Always keep comments from the input JSON.
+
+    This can be used to read a file into a particular sub-object.
+    For example:
+    \code
+    Json::Value root;
+    cin >> root["dir"]["file"];
+    cout << root;
+    \endcode
+    Result:
+    \verbatim
+    {
+    "dir": {
+        "file": {
+        // The input stream JSON would be nested here.
+        }
+    }
+    }
+    \endverbatim
+    \throw std::exception on parse error.
+    \see Json::operator<<()
+   */
+   std::istream& operator>>( std::istream&, Value& );
+
+} // namespace Json
+
+#endif // CPPTL_JSON_READER_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/reader.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/writer.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_WRITER_H_INCLUDED
+# define JSON_WRITER_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include "value.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+# include <vector>
+# include <string>
+
+namespace Json {
+
+   class Value;
+
+   /** \brief Abstract class for writers.
+    */
+   class JSON_API Writer
+   {
+   public:
+      virtual ~Writer();
+
+      virtual std::string write( const Value &root ) = 0;
+   };
+
+   /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format without formatting (not human friendly).
+    *
+    * The JSON document is written in a single line. It is not intended for 'human' consumption,
+    * but may be usefull to support feature such as RPC where bandwith is limited.
+    * \sa Reader, Value
+    */
+   class JSON_API FastWriter : public Writer
+   {
+   public:
+      FastWriter();
+      virtual ~FastWriter(){}
+
+      void enableYAMLCompatibility();
+
+      /** \brief Drop the "null" string from the writer's output for nullValues.
+       * Strictly speaking, this is not valid JSON. But when the output is being
+       * fed to a browser's Javascript, it makes for smaller output and the
+       * browser can handle the output just fine.
+       */
+      void dropNullPlaceholders();
+
+   public: // overridden from Writer
+      virtual std::string write( const Value &root );
+
+   private:
+      void writeValue( const Value &value );
+
+      std::string document_;
+      bool yamlCompatiblityEnabled_;
+      bool dropNullPlaceholders_;
+   };
+
+   /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way.
+    *
+    * The rules for line break and indent are as follow:
+    * - Object value:
+    *     - if empty then print {} without indent and line break
+    *     - if not empty the print '{', line break & indent, print one value per line
+    *       and then unindent and line break and print '}'.
+    * - Array value:
+    *     - if empty then print [] without indent and line break
+    *     - if the array contains no object value, empty array or some other value types,
+    *       and all the values fit on one lines, then print the array on a single line.
+    *     - otherwise, it the values do not fit on one line, or the array contains
+    *       object or non empty array, then print one value per line.
+    *
+    * If the Value have comments then they are outputed according to their #CommentPlacement.
+    *
+    * \sa Reader, Value, Value::setComment()
+    */
+   class JSON_API StyledWriter: public Writer
+   {
+   public:
+      StyledWriter();
+      virtual ~StyledWriter(){}
+
+   public: // overridden from Writer
+      /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+       * \param root Value to serialize.
+       * \return String containing the JSON document that represents the root value.
+       */
+      virtual std::string write( const Value &root );
+
+   private:
+      void writeValue( const Value &value );
+      void writeArrayValue( const Value &value );
+      bool isMultineArray( const Value &value );
+      void pushValue( const std::string &value );
+      void writeIndent();
+      void writeWithIndent( const std::string &value );
+      void indent();
+      void unindent();
+      void writeCommentBeforeValue( const Value &root );
+      void writeCommentAfterValueOnSameLine( const Value &root );
+      bool hasCommentForValue( const Value &value );
+      static std::string normalizeEOL( const std::string &text );
+
+      typedef std::vector<std::string> ChildValues;
+
+      ChildValues childValues_;
+      std::string document_;
+      std::string indentString_;
+      int rightMargin_;
+      int indentSize_;
+      bool addChildValues_;
+   };
+
+   /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a human friendly way,
+        to a stream rather than to a string.
+    *
+    * The rules for line break and indent are as follow:
+    * - Object value:
+    *     - if empty then print {} without indent and line break
+    *     - if not empty the print '{', line break & indent, print one value per line
+    *       and then unindent and line break and print '}'.
+    * - Array value:
+    *     - if empty then print [] without indent and line break
+    *     - if the array contains no object value, empty array or some other value types,
+    *       and all the values fit on one lines, then print the array on a single line.
+    *     - otherwise, it the values do not fit on one line, or the array contains
+    *       object or non empty array, then print one value per line.
+    *
+    * If the Value have comments then they are outputed according to their #CommentPlacement.
+    *
+    * \param indentation Each level will be indented by this amount extra.
+    * \sa Reader, Value, Value::setComment()
+    */
+   class JSON_API StyledStreamWriter
+   {
+   public:
+      StyledStreamWriter( std::string indentation="\t" );
+      ~StyledStreamWriter(){}
+
+   public:
+      /** \brief Serialize a Value in <a HREF="http://www.json.org">JSON</a> format.
+       * \param out Stream to write to. (Can be ostringstream, e.g.)
+       * \param root Value to serialize.
+       * \note There is no point in deriving from Writer, since write() should not return a value.
+       */
+      void write( std::ostream &out, const Value &root );
+
+   private:
+      void writeValue( const Value &value );
+      void writeArrayValue( const Value &value );
+      bool isMultineArray( const Value &value );
+      void pushValue( const std::string &value );
+      void writeIndent();
+      void writeWithIndent( const std::string &value );
+      void indent();
+      void unindent();
+      void writeCommentBeforeValue( const Value &root );
+      void writeCommentAfterValueOnSameLine( const Value &root );
+      bool hasCommentForValue( const Value &value );
+      static std::string normalizeEOL( const std::string &text );
+
+      typedef std::vector<std::string> ChildValues;
+
+      ChildValues childValues_;
+      std::ostream* document_;
+      std::string indentString_;
+      int rightMargin_;
+      std::string indentation_;
+      bool addChildValues_;
+   };
+
+# if defined(JSON_HAS_INT64)
+   std::string JSON_API valueToString( Int value );
+   std::string JSON_API valueToString( UInt value );
+# endif // if defined(JSON_HAS_INT64)
+   std::string JSON_API valueToString( LargestInt value );
+   std::string JSON_API valueToString( LargestUInt value );
+   std::string JSON_API valueToString( double value );
+   std::string JSON_API valueToString( bool value );
+   std::string JSON_API valueToQuotedString( const char *value );
+
+   /// \brief Output using the StyledStreamWriter.
+   /// \see Json::operator>>()
+   std::ostream& operator<<( std::ostream&, const Value &root );
+
+} // namespace Json
+
+
+
+#endif // JSON_WRITER_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/writer.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/assertions.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef CPPTL_JSON_ASSERTIONS_H_INCLUDED
+# define CPPTL_JSON_ASSERTIONS_H_INCLUDED
+
+#include <stdlib.h>
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/config.h>
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+#if JSON_USE_EXCEPTION
+#define JSON_ASSERT( condition ) assert( condition );  // @todo <= change this into an exception throw
+#define JSON_FAIL_MESSAGE( message ) throw std::runtime_error( message );
+#else  // JSON_USE_EXCEPTION
+#define JSON_ASSERT( condition ) assert( condition );
+
+// The call to assert() will show the failure message in debug builds. In
+// release bugs we write to invalid memory in order to crash hard, so that a
+// debugger or crash reporter gets the chance to take over. We still call exit()
+// afterward in order to tell the compiler that this macro doesn't return.
+#define JSON_FAIL_MESSAGE( message ) { assert(false && message); strcpy(reinterpret_cast<char*>(666), message); exit(123); }
+
+#endif
+
+#define JSON_ASSERT_MESSAGE( condition, message ) if (!( condition )) { JSON_FAIL_MESSAGE( message ) }
+
+#endif // CPPTL_JSON_ASSERTIONS_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/assertions.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#endif //ifndef JSON_AMALGATED_H_INCLUDED
diff --git a/src/json/jsoncpp.cpp b/src/json/jsoncpp.cpp
new file mode 100644
index 000000000..7a04736de
--- /dev/null
+++ b/src/json/jsoncpp.cpp
@@ -0,0 +1,4367 @@
+/// Json-cpp amalgated source (http://jsoncpp.sourceforge.net/).
+/// It is intented to be used with #include <json/json.h>
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+/*
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+The author (Baptiste Lepilleur) explicitly disclaims copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is
+released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
+
+*/
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+#include "json.h"
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: src/lib_json/json_tool.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+# define LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+
+/* This header provides common string manipulation support, such as UTF-8,
+ * portable conversion from/to string...
+ *
+ * It is an internal header that must not be exposed.
+ */
+
+namespace Json {
+
+/// Converts a unicode code-point to UTF-8.
+static inline std::string 
+codePointToUTF8(unsigned int cp)
+{
+   std::string result;
+   
+   // based on description from http://en.wikipedia.org/wiki/UTF-8
+
+   if (cp <= 0x7f) 
+   {
+      result.resize(1);
+      result[0] = static_cast<char>(cp);
+   } 
+   else if (cp <= 0x7FF) 
+   {
+      result.resize(2);
+      result[1] = static_cast<char>(0x80 | (0x3f & cp));
+      result[0] = static_cast<char>(0xC0 | (0x1f & (cp >> 6)));
+   } 
+   else if (cp <= 0xFFFF) 
+   {
+      result.resize(3);
+      result[2] = static_cast<char>(0x80 | (0x3f & cp));
+      result[1] = 0x80 | static_cast<char>((0x3f & (cp >> 6)));
+      result[0] = 0xE0 | static_cast<char>((0xf & (cp >> 12)));
+   }
+   else if (cp <= 0x10FFFF) 
+   {
+      result.resize(4);
+      result[3] = static_cast<char>(0x80 | (0x3f & cp));
+      result[2] = static_cast<char>(0x80 | (0x3f & (cp >> 6)));
+      result[1] = static_cast<char>(0x80 | (0x3f & (cp >> 12)));
+      result[0] = static_cast<char>(0xF0 | (0x7 & (cp >> 18)));
+   }
+
+   return result;
+}
+
+
+/// Returns true if ch is a control character (in range [0,32[).
+static inline bool 
+isControlCharacter(char ch)
+{
+   return ch > 0 && ch <= 0x1F;
+}
+
+
+enum { 
+   /// Constant that specify the size of the buffer that must be passed to uintToString.
+   uintToStringBufferSize = 3*sizeof(LargestUInt)+1 
+};
+
+// Defines a char buffer for use with uintToString().
+typedef char UIntToStringBuffer[uintToStringBufferSize];
+
+
+/** Converts an unsigned integer to string.
+ * @param value Unsigned interger to convert to string
+ * @param current Input/Output string buffer. 
+ *        Must have at least uintToStringBufferSize chars free.
+ */
+static inline void 
+uintToString( LargestUInt value, 
+              char *&current )
+{
+   *--current = 0;
+   do
+   {
+      *--current = char(value % 10) + '0';
+      value /= 10;
+   }
+   while ( value != 0 );
+}
+
+} // namespace Json {
+
+#endif // LIB_JSONCPP_JSON_TOOL_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: src/lib_json/json_tool.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: src/lib_json/json_reader.cpp
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2011 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/assertions.h>
+# include <json/reader.h>
+# include <json/value.h>
+# include "json_tool.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <utility>
+#include <cstdio>
+#include <cassert>
+#include <cstring>
+#include <stdexcept>
+
+#if defined(_MSC_VER)  &&  _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
+#endif
+
+namespace Json {
+
+// Implementation of class Features
+// ////////////////////////////////
+
+Features::Features()
+   : allowComments_( true )
+   , strictRoot_( false )
+{
+}
+
+
+Features 
+Features::all()
+{
+   return Features();
+}
+
+
+Features 
+Features::strictMode()
+{
+   Features features;
+   features.allowComments_ = false;
+   features.strictRoot_ = true;
+   return features;
+}
+
+// Implementation of class Reader
+// ////////////////////////////////
+
+
+static inline bool 
+in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4 )
+{
+   return c == c1  ||  c == c2  ||  c == c3  ||  c == c4;
+}
+
+static inline bool 
+in( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4, Reader::Char c5 )
+{
+   return c == c1  ||  c == c2  ||  c == c3  ||  c == c4  ||  c == c5;
+}
+
+
+static bool 
+containsNewLine( Reader::Location begin, 
+                 Reader::Location end )
+{
+   for ( ;begin < end; ++begin )
+      if ( *begin == '\n'  ||  *begin == '\r' )
+         return true;
+   return false;
+}
+
+
+// Class Reader
+// //////////////////////////////////////////////////////////////////
+
+Reader::Reader()
+    : errors_(),
+      document_(),
+      begin_(),
+      end_(),
+      current_(),
+      lastValueEnd_(),
+      lastValue_(),
+      commentsBefore_(),
+      features_( Features::all() ),
+      collectComments_()
+{
+}
+
+
+Reader::Reader( const Features &features )
+    : errors_(),
+      document_(),
+      begin_(),
+      end_(),
+      current_(),
+      lastValueEnd_(),
+      lastValue_(),
+      commentsBefore_(),
+      features_( features ),
+      collectComments_()
+{
+}
+
+
+bool
+Reader::parse( const std::string &document, 
+               Value &root,
+               bool collectComments )
+{
+   document_ = document;
+   const char *begin = document_.c_str();
+   const char *end = begin + document_.length();
+   return parse( begin, end, root, collectComments );
+}
+
+
+bool
+Reader::parse( std::istream& sin,
+               Value &root,
+               bool collectComments )
+{
+   //std::istream_iterator<char> begin(sin);
+   //std::istream_iterator<char> end;
+   // Those would allow streamed input from a file, if parse() were a
+   // template function.
+
+   // Since std::string is reference-counted, this at least does not
+   // create an extra copy.
+   std::string doc;
+   std::getline(sin, doc, (char)EOF);
+   return parse( doc, root, collectComments );
+}
+
+bool 
+Reader::parse( const char *beginDoc, const char *endDoc, 
+               Value &root,
+               bool collectComments )
+{
+   if ( !features_.allowComments_ )
+   {
+      collectComments = false;
+   }
+
+   begin_ = beginDoc;
+   end_ = endDoc;
+   collectComments_ = collectComments;
+   current_ = begin_;
+   lastValueEnd_ = 0;
+   lastValue_ = 0;
+   commentsBefore_ = "";
+   errors_.clear();
+   while ( !nodes_.empty() )
+      nodes_.pop();
+   nodes_.push( &root );
+   
+   bool successful = readValue();
+   Token token;
+   skipCommentTokens( token );
+   if ( collectComments_  &&  !commentsBefore_.empty() )
+      root.setComment( commentsBefore_, commentAfter );
+   if ( features_.strictRoot_ )
+   {
+      if ( !root.isArray()  &&  !root.isObject() )
+      {
+         // Set error location to start of doc, ideally should be first token found in doc
+         token.type_ = tokenError;
+         token.start_ = beginDoc;
+         token.end_ = endDoc;
+         addError( "A valid JSON document must be either an array or an object value.",
+                   token );
+         return false;
+      }
+   }
+   return successful;
+}
+
+
+bool
+Reader::readValue()
+{
+   Token token;
+   skipCommentTokens( token );
+   bool successful = true;
+
+   if ( collectComments_  &&  !commentsBefore_.empty() )
+   {
+      currentValue().setComment( commentsBefore_, commentBefore );
+      commentsBefore_ = "";
+   }
+
+
+   switch ( token.type_ )
+   {
+   case tokenObjectBegin:
+      successful = readObject( token );
+      break;
+   case tokenArrayBegin:
+      successful = readArray( token );
+      break;
+   case tokenNumber:
+      successful = decodeNumber( token );
+      break;
+   case tokenString:
+      successful = decodeString( token );
+      break;
+   case tokenTrue:
+      currentValue() = true;
+      break;
+   case tokenFalse:
+      currentValue() = false;
+      break;
+   case tokenNull:
+      currentValue() = Value();
+      break;
+   default:
+      return addError( "Syntax error: value, object or array expected.", token );
+   }
+
+   if ( collectComments_ )
+   {
+      lastValueEnd_ = current_;
+      lastValue_ = &currentValue();
+   }
+
+   return successful;
+}
+
+
+void 
+Reader::skipCommentTokens( Token &token )
+{
+   if ( features_.allowComments_ )
+   {
+      do
+      {
+         readToken( token );
+      }
+      while ( token.type_ == tokenComment );
+   }
+   else
+   {
+      readToken( token );
+   }
+}
+
+
+bool 
+Reader::expectToken( TokenType type, Token &token, const char *message )
+{
+   readToken( token );
+   if ( token.type_ != type )
+      return addError( message, token );
+   return true;
+}
+
+
+bool 
+Reader::readToken( Token &token )
+{
+   skipSpaces();
+   token.start_ = current_;
+   Char c = getNextChar();
+   bool ok = true;
+   switch ( c )
+   {
+   case '{':
+      token.type_ = tokenObjectBegin;
+      break;
+   case '}':
+      token.type_ = tokenObjectEnd;
+      break;
+   case '[':
+      token.type_ = tokenArrayBegin;
+      break;
+   case ']':
+      token.type_ = tokenArrayEnd;
+      break;
+   case '"':
+      token.type_ = tokenString;
+      ok = readString();
+      break;
+   case '/':
+      token.type_ = tokenComment;
+      ok = readComment();
+      break;
+   case '0':
+   case '1':
+   case '2':
+   case '3':
+   case '4':
+   case '5':
+   case '6':
+   case '7':
+   case '8':
+   case '9':
+   case '-':
+      token.type_ = tokenNumber;
+      readNumber();
+      break;
+   case 't':
+      token.type_ = tokenTrue;
+      ok = match( "rue", 3 );
+      break;
+   case 'f':
+      token.type_ = tokenFalse;
+      ok = match( "alse", 4 );
+      break;
+   case 'n':
+      token.type_ = tokenNull;
+      ok = match( "ull", 3 );
+      break;
+   case ',':
+      token.type_ = tokenArraySeparator;
+      break;
+   case ':':
+      token.type_ = tokenMemberSeparator;
+      break;
+   case 0:
+      token.type_ = tokenEndOfStream;
+      break;
+   default:
+      ok = false;
+      break;
+   }
+   if ( !ok )
+      token.type_ = tokenError;
+   token.end_ = current_;
+   return true;
+}
+
+
+void 
+Reader::skipSpaces()
+{
+   while ( current_ != end_ )
+   {
+      Char c = *current_;
+      if ( c == ' '  ||  c == '\t'  ||  c == '\r'  ||  c == '\n' )
+         ++current_;
+      else
+         break;
+   }
+}
+
+
+bool 
+Reader::match( Location pattern, 
+               int patternLength )
+{
+   if ( end_ - current_ < patternLength )
+      return false;
+   int index = patternLength;
+   while ( index-- )
+      if ( current_[index] != pattern[index] )
+         return false;
+   current_ += patternLength;
+   return true;
+}
+
+
+bool
+Reader::readComment()
+{
+   Location commentBegin = current_ - 1;
+   Char c = getNextChar();
+   bool successful = false;
+   if ( c == '*' )
+      successful = readCStyleComment();
+   else if ( c == '/' )
+      successful = readCppStyleComment();
+   if ( !successful )
+      return false;
+
+   if ( collectComments_ )
+   {
+      CommentPlacement placement = commentBefore;
+      if ( lastValueEnd_  &&  !containsNewLine( lastValueEnd_, commentBegin ) )
+      {
+         if ( c != '*'  ||  !containsNewLine( commentBegin, current_ ) )
+            placement = commentAfterOnSameLine;
+      }
+
+      addComment( commentBegin, current_, placement );
+   }
+   return true;
+}
+
+
+void 
+Reader::addComment( Location begin, 
+                    Location end, 
+                    CommentPlacement placement )
+{
+   assert( collectComments_ );
+   if ( placement == commentAfterOnSameLine )
+   {
+      assert( lastValue_ != 0 );
+      lastValue_->setComment( std::string( begin, end ), placement );
+   }
+   else
+   {
+      if ( !commentsBefore_.empty() )
+         commentsBefore_ += "\n";
+      commentsBefore_ += std::string( begin, end );
+   }
+}
+
+
+bool 
+Reader::readCStyleComment()
+{
+   while ( current_ != end_ )
+   {
+      Char c = getNextChar();
+      if ( c == '*'  &&  *current_ == '/' )
+         break;
+   }
+   return getNextChar() == '/';
+}
+
+
+bool 
+Reader::readCppStyleComment()
+{
+   while ( current_ != end_ )
+   {
+      Char c = getNextChar();
+      if (  c == '\r'  ||  c == '\n' )
+         break;
+   }
+   return true;
+}
+
+
+void 
+Reader::readNumber()
+{
+   while ( current_ != end_ )
+   {
+      if ( !(*current_ >= '0'  &&  *current_ <= '9')  &&
+           !in( *current_, '.', 'e', 'E', '+', '-' ) )
+         break;
+      ++current_;
+   }
+}
+
+bool
+Reader::readString()
+{
+   Char c = 0;
+   while ( current_ != end_ )
+   {
+      c = getNextChar();
+      if ( c == '\\' )
+         getNextChar();
+      else if ( c == '"' )
+         break;
+   }
+   return c == '"';
+}
+
+
+bool 
+Reader::readObject( Token &/*tokenStart*/ )
+{
+   Token tokenName;
+   std::string name;
+   currentValue() = Value( objectValue );
+   while ( readToken( tokenName ) )
+   {
+      bool initialTokenOk = true;
+      while ( tokenName.type_ == tokenComment  &&  initialTokenOk )
+         initialTokenOk = readToken( tokenName );
+      if  ( !initialTokenOk )
+         break;
+      if ( tokenName.type_ == tokenObjectEnd  &&  name.empty() )  // empty object
+         return true;
+      if ( tokenName.type_ != tokenString )
+         break;
+      
+      name = "";
+      if ( !decodeString( tokenName, name ) )
+         return recoverFromError( tokenObjectEnd );
+
+      Token colon;
+      if ( !readToken( colon ) ||  colon.type_ != tokenMemberSeparator )
+      {
+         return addErrorAndRecover( "Missing ':' after object member name", 
+                                    colon, 
+                                    tokenObjectEnd );
+      }
+      Value &value = currentValue()[ name ];
+      nodes_.push( &value );
+      bool ok = readValue();
+      nodes_.pop();
+      if ( !ok ) // error already set
+         return recoverFromError( tokenObjectEnd );
+
+      Token comma;
+      if ( !readToken( comma )
+            ||  ( comma.type_ != tokenObjectEnd  &&  
+                  comma.type_ != tokenArraySeparator &&
+                  comma.type_ != tokenComment ) )
+      {
+         return addErrorAndRecover( "Missing ',' or '}' in object declaration", 
+                                    comma, 
+                                    tokenObjectEnd );
+      }
+      bool finalizeTokenOk = true;
+      while ( comma.type_ == tokenComment &&
+              finalizeTokenOk )
+         finalizeTokenOk = readToken( comma );
+      if ( comma.type_ == tokenObjectEnd )
+         return true;
+   }
+   return addErrorAndRecover( "Missing '}' or object member name", 
+                              tokenName, 
+                              tokenObjectEnd );
+}
+
+
+bool 
+Reader::readArray( Token &/*tokenStart*/ )
+{
+   currentValue() = Value( arrayValue );
+   skipSpaces();
+   if ( *current_ == ']' ) // empty array
+   {
+      Token endArray;
+      readToken( endArray );
+      return true;
+   }
+   int index = 0;
+   for (;;)
+   {
+      Value &value = currentValue()[ index++ ];
+      nodes_.push( &value );
+      bool ok = readValue();
+      nodes_.pop();
+      if ( !ok ) // error already set
+         return recoverFromError( tokenArrayEnd );
+
+      Token token;
+      // Accept Comment after last item in the array.
+      ok = readToken( token );
+      while ( token.type_ == tokenComment  &&  ok )
+      {
+         ok = readToken( token );
+      }
+      bool badTokenType = ( token.type_ != tokenArraySeparator  &&
+                            token.type_ != tokenArrayEnd );
+      if ( !ok  ||  badTokenType )
+      {
+         return addErrorAndRecover( "Missing ',' or ']' in array declaration", 
+                                    token, 
+                                    tokenArrayEnd );
+      }
+      if ( token.type_ == tokenArrayEnd )
+         break;
+   }
+   return true;
+}
+
+
+bool 
+Reader::decodeNumber( Token &token )
+{
+   bool isDouble = false;
+   for ( Location inspect = token.start_; inspect != token.end_; ++inspect )
+   {
+      isDouble = isDouble  
+                 ||  in( *inspect, '.', 'e', 'E', '+' )  
+                 ||  ( *inspect == '-'  &&  inspect != token.start_ );
+   }
+   if ( isDouble )
+      return decodeDouble( token );
+   // Attempts to parse the number as an integer. If the number is
+   // larger than the maximum supported value of an integer then
+   // we decode the number as a double.
+   Location current = token.start_;
+   bool isNegative = *current == '-';
+   if ( isNegative )
+      ++current;
+   Value::LargestUInt maxIntegerValue = isNegative ? Value::LargestUInt(-Value::minLargestInt) 
+                                                   : Value::maxLargestUInt;
+   Value::LargestUInt threshold = maxIntegerValue / 10;
+   Value::LargestUInt value = 0;
+   while ( current < token.end_ )
+   {
+      Char c = *current++;
+      if ( c < '0'  ||  c > '9' )
+         return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
+      Value::UInt digit(c - '0');
+      if ( value >= threshold )
+      {
+         // We've hit or exceeded the max value divided by 10 (rounded down). If
+         // a) we've only just touched the limit, b) this is the last digit, and
+         // c) it's small enough to fit in that rounding delta, we're okay.
+         // Otherwise treat this number as a double to avoid overflow.
+         if (value > threshold ||
+             current != token.end_ ||
+             digit > maxIntegerValue % 10)
+         {
+            return decodeDouble( token );
+         }
+      }
+      value = value * 10 + digit;
+   }
+   if ( isNegative )
+      currentValue() = -Value::LargestInt( value );
+   else if ( value <= Value::LargestUInt(Value::maxInt) )
+      currentValue() = Value::LargestInt( value );
+   else
+      currentValue() = value;
+   return true;
+}
+
+
+bool 
+Reader::decodeDouble( Token &token )
+{
+   double value = 0;
+   const int bufferSize = 32;
+   int count;
+   int length = int(token.end_ - token.start_);
+
+   // Sanity check to avoid buffer overflow exploits.
+   if (length < 0) {
+      return addError( "Unable to parse token length", token );
+   }
+
+   // Avoid using a string constant for the format control string given to
+   // sscanf, as this can cause hard to debug crashes on OS X. See here for more
+   // info:
+   //
+   //     http://developer.apple.com/library/mac/#DOCUMENTATION/DeveloperTools/gcc-4.0.1/gcc/Incompatibilities.html
+   char format[] = "%lf";
+
+   if ( length <= bufferSize )
+   {
+      Char buffer[bufferSize+1];
+      memcpy( buffer, token.start_, length );
+      buffer[length] = 0;
+      count = sscanf( buffer, format, &value );
+   }
+   else
+   {
+      std::string buffer( token.start_, token.end_ );
+      count = sscanf( buffer.c_str(), format, &value );
+   }
+
+   if ( count != 1 )
+      return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
+   currentValue() = value;
+   return true;
+}
+
+
+bool 
+Reader::decodeString( Token &token )
+{
+   std::string decoded;
+   if ( !decodeString( token, decoded ) )
+      return false;
+   currentValue() = decoded;
+   return true;
+}
+
+
+bool 
+Reader::decodeString( Token &token, std::string &decoded )
+{
+   decoded.reserve( token.end_ - token.start_ - 2 );
+   Location current = token.start_ + 1; // skip '"'
+   Location end = token.end_ - 1;      // do not include '"'
+   while ( current != end )
+   {
+      Char c = *current++;
+      if ( c == '"' )
+         break;
+      else if ( c == '\\' )
+      {
+         if ( current == end )
+            return addError( "Empty escape sequence in string", token, current );
+         Char escape = *current++;
+         switch ( escape )
+         {
+         case '"': decoded += '"'; break;
+         case '/': decoded += '/'; break;
+         case '\\': decoded += '\\'; break;
+         case 'b': decoded += '\b'; break;
+         case 'f': decoded += '\f'; break;
+         case 'n': decoded += '\n'; break;
+         case 'r': decoded += '\r'; break;
+         case 't': decoded += '\t'; break;
+         case 'u':
+            {
+               unsigned int unicode;
+               if ( !decodeUnicodeCodePoint( token, current, end, unicode ) )
+                  return false;
+               decoded += codePointToUTF8(unicode);
+            }
+            break;
+         default:
+            return addError( "Bad escape sequence in string", token, current );
+         }
+      }
+      else
+      {
+         decoded += c;
+      }
+   }
+   return true;
+}
+
+bool
+Reader::decodeUnicodeCodePoint( Token &token, 
+                                     Location &current, 
+                                     Location end, 
+                                     unsigned int &unicode )
+{
+
+   if ( !decodeUnicodeEscapeSequence( token, current, end, unicode ) )
+      return false;
+   if (unicode >= 0xD800 && unicode <= 0xDBFF)
+   {
+      // surrogate pairs
+      if (end - current < 6)
+         return addError( "additional six characters expected to parse unicode surrogate pair.", token, current );
+      unsigned int surrogatePair;
+      if (*(current++) == '\\' && *(current++)== 'u')
+      {
+         if (decodeUnicodeEscapeSequence( token, current, end, surrogatePair ))
+         {
+            unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
+         } 
+         else
+            return false;
+      } 
+      else
+         return addError( "expecting another \\u token to begin the second half of a unicode surrogate pair", token, current );
+   }
+   return true;
+}
+
+bool 
+Reader::decodeUnicodeEscapeSequence( Token &token, 
+                                     Location &current, 
+                                     Location end, 
+                                     unsigned int &unicode )
+{
+   if ( end - current < 4 )
+      return addError( "Bad unicode escape sequence in string: four digits expected.", token, current );
+   unicode = 0;
+   for ( int index =0; index < 4; ++index )
+   {
+      Char c = *current++;
+      unicode *= 16;
+      if ( c >= '0'  &&  c <= '9' )
+         unicode += c - '0';
+      else if ( c >= 'a'  &&  c <= 'f' )
+         unicode += c - 'a' + 10;
+      else if ( c >= 'A'  &&  c <= 'F' )
+         unicode += c - 'A' + 10;
+      else
+         return addError( "Bad unicode escape sequence in string: hexadecimal digit expected.", token, current );
+   }
+   return true;
+}
+
+
+bool 
+Reader::addError( const std::string &message, 
+                  Token &token,
+                  Location extra )
+{
+   ErrorInfo info;
+   info.token_ = token;
+   info.message_ = message;
+   info.extra_ = extra;
+   errors_.push_back( info );
+   return false;
+}
+
+
+bool 
+Reader::recoverFromError( TokenType skipUntilToken )
+{
+   int errorCount = int(errors_.size());
+   Token skip;
+   for (;;)
+   {
+      if ( !readToken(skip) )
+         errors_.resize( errorCount ); // discard errors caused by recovery
+      if ( skip.type_ == skipUntilToken  ||  skip.type_ == tokenEndOfStream )
+         break;
+   }
+   errors_.resize( errorCount );
+   return false;
+}
+
+
+bool 
+Reader::addErrorAndRecover( const std::string &message, 
+                            Token &token,
+                            TokenType skipUntilToken )
+{
+   addError( message, token );
+   return recoverFromError( skipUntilToken );
+}
+
+
+Value &
+Reader::currentValue()
+{
+   return *(nodes_.top());
+}
+
+
+Reader::Char 
+Reader::getNextChar()
+{
+   if ( current_ == end_ )
+      return 0;
+   return *current_++;
+}
+
+
+void 
+Reader::getLocationLineAndColumn( Location location,
+                                  int &line,
+                                  int &column ) const
+{
+   Location current = begin_;
+   Location lastLineStart = current;
+   line = 0;
+   while ( current < location  &&  current != end_ )
+   {
+      Char c = *current++;
+      if ( c == '\r' )
+      {
+         if ( *current == '\n' )
+            ++current;
+         lastLineStart = current;
+         ++line;
+      }
+      else if ( c == '\n' )
+      {
+         lastLineStart = current;
+         ++line;
+      }
+   }
+   // column & line start at 1
+   column = int(location - lastLineStart) + 1;
+   ++line;
+}
+
+
+std::string
+Reader::getLocationLineAndColumn( Location location ) const
+{
+   int line, column;
+   getLocationLineAndColumn( location, line, column );
+   char buffer[18+16+16+1];
+   sprintf( buffer, "Line %d, Column %d", line, column );
+   return buffer;
+}
+
+
+// Deprecated. Preserved for backward compatibility
+std::string 
+Reader::getFormatedErrorMessages() const
+{
+    return getFormattedErrorMessages();
+}
+
+
+std::string 
+Reader::getFormattedErrorMessages() const
+{
+   std::string formattedMessage;
+   for ( Errors::const_iterator itError = errors_.begin();
+         itError != errors_.end();
+         ++itError )
+   {
+      const ErrorInfo &error = *itError;
+      formattedMessage += "* " + getLocationLineAndColumn( error.token_.start_ ) + "\n";
+      formattedMessage += "  " + error.message_ + "\n";
+      if ( error.extra_ )
+         formattedMessage += "See " + getLocationLineAndColumn( error.extra_ ) + " for detail.\n";
+   }
+   return formattedMessage;
+}
+
+
+std::istream& operator>>( std::istream &sin, Value &root )
+{
+    Json::Reader reader;
+    bool ok = reader.parse(sin, root, true);
+    if (!ok) {
+      fprintf(
+          stderr,
+          "Error from reader: %s",
+          reader.getFormattedErrorMessages().c_str());
+
+      JSON_FAIL_MESSAGE("reader error");
+    }
+    return sin;
+}
+
+
+} // namespace Json
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: src/lib_json/json_reader.cpp
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: src/lib_json/json_batchallocator.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
+# define JSONCPP_BATCHALLOCATOR_H_INCLUDED
+
+# include <stdlib.h>
+# include <assert.h>
+
+# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
+
+namespace Json {
+
+/* Fast memory allocator.
+ *
+ * This memory allocator allocates memory for a batch of object (specified by
+ * the page size, the number of object in each page).
+ *
+ * It does not allow the destruction of a single object. All the allocated objects
+ * can be destroyed at once. The memory can be either released or reused for future
+ * allocation.
+ * 
+ * The in-place new operator must be used to construct the object using the pointer
+ * returned by allocate.
+ */
+template<typename AllocatedType
+        ,const unsigned int objectPerAllocation>
+class BatchAllocator
+{
+public:
+   BatchAllocator( unsigned int objectsPerPage = 255 )
+      : freeHead_( 0 )
+      , objectsPerPage_( objectsPerPage )
+   {
+//      printf( "Size: %d => %s\n", sizeof(AllocatedType), typeid(AllocatedType).name() );
+      assert( sizeof(AllocatedType) * objectPerAllocation >= sizeof(AllocatedType *) ); // We must be able to store a slist in the object free space.
+      assert( objectsPerPage >= 16 );
+      batches_ = allocateBatch( 0 );   // allocated a dummy page
+      currentBatch_ = batches_;
+   }
+
+   ~BatchAllocator()
+   {
+      for ( BatchInfo *batch = batches_; batch;  )
+      {
+         BatchInfo *nextBatch = batch->next_;
+         free( batch );
+         batch = nextBatch;
+      }
+   }
+
+   /// allocate space for an array of objectPerAllocation object.
+   /// @warning it is the responsability of the caller to call objects constructors.
+   AllocatedType *allocate()
+   {
+      if ( freeHead_ ) // returns node from free list.
+      {
+         AllocatedType *object = freeHead_;
+         freeHead_ = *(AllocatedType **)object;
+         return object;
+      }
+      if ( currentBatch_->used_ == currentBatch_->end_ )
+      {
+         currentBatch_ = currentBatch_->next_;
+         while ( currentBatch_  &&  currentBatch_->used_ == currentBatch_->end_ )
+            currentBatch_ = currentBatch_->next_;
+
+         if ( !currentBatch_  ) // no free batch found, allocate a new one
+         { 
+            currentBatch_ = allocateBatch( objectsPerPage_ );
+            currentBatch_->next_ = batches_; // insert at the head of the list
+            batches_ = currentBatch_;
+         }
+      }
+      AllocatedType *allocated = currentBatch_->used_;
+      currentBatch_->used_ += objectPerAllocation;
+      return allocated;
+   }
+
+   /// Release the object.
+   /// @warning it is the responsability of the caller to actually destruct the object.
+   void release( AllocatedType *object )
+   {
+      assert( object != 0 );
+      *(AllocatedType **)object = freeHead_;
+      freeHead_ = object;
+   }
+
+private:
+   struct BatchInfo
+   {
+      BatchInfo *next_;
+      AllocatedType *used_;
+      AllocatedType *end_;
+      AllocatedType buffer_[objectPerAllocation];
+   };
+
+   // disabled copy constructor and assignement operator.
+   BatchAllocator( const BatchAllocator & );
+   void operator =( const BatchAllocator &);
+
+   static BatchInfo *allocateBatch( unsigned int objectsPerPage )
+   {
+      const unsigned int mallocSize = sizeof(BatchInfo) - sizeof(AllocatedType)* objectPerAllocation
+                                + sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
+      BatchInfo *batch = static_cast<BatchInfo*>( malloc( mallocSize ) );
+      batch->next_ = 0;
+      batch->used_ = batch->buffer_;
+      batch->end_ = batch->buffer_ + objectsPerPage;
+      return batch;
+   }
+
+   BatchInfo *batches_;
+   BatchInfo *currentBatch_;
+   /// Head of a single linked list within the allocated space of freeed object
+   AllocatedType *freeHead_;
+   unsigned int objectsPerPage_;
+};
+
+
+} // namespace Json
+
+# endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
+
+#endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: src/lib_json/json_batchallocator.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: src/lib_json/json_valueiterator.inl
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+// included by json_value.cpp
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIteratorBase
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIteratorBase::ValueIteratorBase()
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   : current_()
+   , isNull_( true )
+{
+}
+#else
+   : isArray_( true )
+   , isNull_( true )
+{
+   iterator_.array_ = ValueInternalArray::IteratorState();
+}
+#endif
+
+
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ValueIteratorBase::ValueIteratorBase( const Value::ObjectValues::iterator &current )
+   : current_( current )
+   , isNull_( false )
+{
+}
+#else
+ValueIteratorBase::ValueIteratorBase( const ValueInternalArray::IteratorState &state )
+   : isArray_( true )
+{
+   iterator_.array_ = state;
+}
+
+
+ValueIteratorBase::ValueIteratorBase( const ValueInternalMap::IteratorState &state )
+   : isArray_( false )
+{
+   iterator_.map_ = state;
+}
+#endif
+
+Value &
+ValueIteratorBase::deref() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   return current_->second;
+#else
+   if ( isArray_ )
+      return ValueInternalArray::dereference( iterator_.array_ );
+   return ValueInternalMap::value( iterator_.map_ );
+#endif
+}
+
+
+void 
+ValueIteratorBase::increment()
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ++current_;
+#else
+   if ( isArray_ )
+      ValueInternalArray::increment( iterator_.array_ );
+   ValueInternalMap::increment( iterator_.map_ );
+#endif
+}
+
+
+void 
+ValueIteratorBase::decrement()
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   --current_;
+#else
+   if ( isArray_ )
+      ValueInternalArray::decrement( iterator_.array_ );
+   ValueInternalMap::decrement( iterator_.map_ );
+#endif
+}
+
+
+ValueIteratorBase::difference_type 
+ValueIteratorBase::computeDistance( const SelfType &other ) const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+# ifdef JSON_USE_CPPTL_SMALLMAP
+   return current_ - other.current_;
+# else
+   // Iterator for null value are initialized using the default
+   // constructor, which initialize current_ to the default
+   // std::map::iterator. As begin() and end() are two instance 
+   // of the default std::map::iterator, they can not be compared.
+   // To allow this, we handle this comparison specifically.
+   if ( isNull_  &&  other.isNull_ )
+   {
+      return 0;
+   }
+
+
+   // Usage of std::distance is not portable (does not compile with Sun Studio 12 RogueWave STL,
+   // which is the one used by default).
+   // Using a portable hand-made version for non random iterator instead:
+   //   return difference_type( std::distance( current_, other.current_ ) );
+   difference_type myDistance = 0;
+   for ( Value::ObjectValues::iterator it = current_; it != other.current_; ++it )
+   {
+      ++myDistance;
+   }
+   return myDistance;
+# endif
+#else
+   if ( isArray_ )
+      return ValueInternalArray::distance( iterator_.array_, other.iterator_.array_ );
+   return ValueInternalMap::distance( iterator_.map_, other.iterator_.map_ );
+#endif
+}
+
+
+bool 
+ValueIteratorBase::isEqual( const SelfType &other ) const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   if ( isNull_ )
+   {
+      return other.isNull_;
+   }
+   return current_ == other.current_;
+#else
+   if ( isArray_ )
+      return ValueInternalArray::equals( iterator_.array_, other.iterator_.array_ );
+   return ValueInternalMap::equals( iterator_.map_, other.iterator_.map_ );
+#endif
+}
+
+
+void 
+ValueIteratorBase::copy( const SelfType &other )
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   current_ = other.current_;
+#else
+   if ( isArray_ )
+      iterator_.array_ = other.iterator_.array_;
+   iterator_.map_ = other.iterator_.map_;
+#endif
+}
+
+
+Value 
+ValueIteratorBase::key() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   const Value::CZString czstring = (*current_).first;
+   if ( czstring.c_str() )
+   {
+      if ( czstring.isStaticString() )
+         return Value( StaticString( czstring.c_str() ) );
+      return Value( czstring.c_str() );
+   }
+   return Value( czstring.index() );
+#else
+   if ( isArray_ )
+      return Value( ValueInternalArray::indexOf( iterator_.array_ ) );
+   bool isStatic;
+   const char *memberName = ValueInternalMap::key( iterator_.map_, isStatic );
+   if ( isStatic )
+      return Value( StaticString( memberName ) );
+   return Value( memberName );
+#endif
+}
+
+
+UInt 
+ValueIteratorBase::index() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   const Value::CZString czstring = (*current_).first;
+   if ( !czstring.c_str() )
+      return czstring.index();
+   return Value::UInt( -1 );
+#else
+   if ( isArray_ )
+      return Value::UInt( ValueInternalArray::indexOf( iterator_.array_ ) );
+   return Value::UInt( -1 );
+#endif
+}
+
+
+const char *
+ValueIteratorBase::memberName() const
+{
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   const char *name = (*current_).first.c_str();
+   return name ? name : "";
+#else
+   if ( !isArray_ )
+      return ValueInternalMap::key( iterator_.map_ );
+   return "";
+#endif
+}
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueConstIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueConstIterator::ValueConstIterator()
+{
+}
+
+
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ValueConstIterator::ValueConstIterator( const Value::ObjectValues::iterator &current )
+   : ValueIteratorBase( current )
+{
+}
+#else
+ValueConstIterator::ValueConstIterator( const ValueInternalArray::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+
+ValueConstIterator::ValueConstIterator( const ValueInternalMap::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+#endif
+
+ValueConstIterator &
+ValueConstIterator::operator =( const ValueIteratorBase &other )
+{
+   copy( other );
+   return *this;
+}
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class ValueIterator
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+ValueIterator::ValueIterator()
+{
+}
+
+
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+ValueIterator::ValueIterator( const Value::ObjectValues::iterator &current )
+   : ValueIteratorBase( current )
+{
+}
+#else
+ValueIterator::ValueIterator( const ValueInternalArray::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+
+ValueIterator::ValueIterator( const ValueInternalMap::IteratorState &state )
+   : ValueIteratorBase( state )
+{
+}
+#endif
+
+ValueIterator::ValueIterator( const ValueConstIterator &other )
+   : ValueIteratorBase( other )
+{
+}
+
+ValueIterator::ValueIterator( const ValueIterator &other )
+   : ValueIteratorBase( other )
+{
+}
+
+ValueIterator &
+ValueIterator::operator =( const SelfType &other )
+{
+   copy( other );
+   return *this;
+}
+
+} // namespace Json
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: src/lib_json/json_valueiterator.inl
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: src/lib_json/json_value.cpp
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2011 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/assertions.h>
+# include <json/value.h>
+# include <json/writer.h>
+# ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#  include "json_batchallocator.h"
+# endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <math.h>
+#include <sstream>
+#include <utility>
+#include <stdexcept>
+#include <cstring>
+#include <cassert>
+#ifdef JSON_USE_CPPTL
+# include <cpptl/conststring.h>
+#endif
+#include <cstddef>    // size_t
+
+#define JSON_ASSERT_UNREACHABLE assert( false )
+
+namespace Json {
+
+const Value Value::null;
+const Int Value::minInt = Int( ~(UInt(-1)/2) );
+const Int Value::maxInt = Int( UInt(-1)/2 );
+const UInt Value::maxUInt = UInt(-1);
+# if defined(JSON_HAS_INT64)
+const Int64 Value::minInt64 = Int64( ~(UInt64(-1)/2) );
+const Int64 Value::maxInt64 = Int64( UInt64(-1)/2 );
+const UInt64 Value::maxUInt64 = UInt64(-1);
+// The constant is hard-coded because some compiler have trouble
+// converting Value::maxUInt64 to a double correctly (AIX/xlC).
+// Assumes that UInt64 is a 64 bits integer.
+static const double maxUInt64AsDouble = 18446744073709551615.0;
+#endif // defined(JSON_HAS_INT64)
+const LargestInt Value::minLargestInt = LargestInt( ~(LargestUInt(-1)/2) );
+const LargestInt Value::maxLargestInt = LargestInt( LargestUInt(-1)/2 );
+const LargestUInt Value::maxLargestUInt = LargestUInt(-1);
+
+
+/// Unknown size marker
+static const unsigned int unknown = (unsigned)-1;
+
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+   return d >= min && d <= max;
+}
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+static inline double integerToDouble( Json::UInt64 value )
+{
+    return static_cast<double>( Int64(value/2) ) * 2.0 + Int64(value & 1);
+}
+
+template<typename T>
+static inline double integerToDouble( T value )
+{
+    return static_cast<double>( value );
+}
+
+template <typename T, typename U>
+static inline bool InRange(double d, T min, U max) {
+   return d >= integerToDouble(min) && d <= integerToDouble(max);
+}
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+
+
+/** Duplicates the specified string value.
+ * @param value Pointer to the string to duplicate. Must be zero-terminated if
+ *              length is "unknown".
+ * @param length Length of the value. if equals to unknown, then it will be
+ *               computed using strlen(value).
+ * @return Pointer on the duplicate instance of string.
+ */
+static inline char *
+duplicateStringValue( const char *value, 
+                      unsigned int length = unknown )
+{
+   if ( length == unknown )
+      length = (unsigned int)strlen(value);
+
+   // Avoid an integer overflow in the call to malloc below by limiting length
+   // to a sane value.
+   if (length >= (unsigned)Value::maxInt)
+      length = Value::maxInt - 1;
+
+   char *newString = static_cast<char *>( malloc( length + 1 ) );
+   JSON_ASSERT_MESSAGE( newString != 0, "Failed to allocate string value buffer" );
+   memcpy( newString, value, length );
+   newString[length] = 0;
+   return newString;
+}
+
+
+/** Free the string duplicated by duplicateStringValue().
+ */
+static inline void 
+releaseStringValue( char *value )
+{
+   if ( value )
+      free( value );
+}
+
+} // namespace Json
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// ValueInternals...
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+#if !defined(JSON_IS_AMALGAMATION)
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+#  include "json_internalarray.inl"
+#  include "json_internalmap.inl"
+# endif // JSON_VALUE_USE_INTERNAL_MAP
+
+# include "json_valueiterator.inl"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::CommentInfo
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+
+Value::CommentInfo::CommentInfo()
+   : comment_( 0 )
+{
+}
+
+Value::CommentInfo::~CommentInfo()
+{
+   if ( comment_ )
+      releaseStringValue( comment_ );
+}
+
+
+void 
+Value::CommentInfo::setComment( const char *text )
+{
+   if ( comment_ )
+      releaseStringValue( comment_ );
+   JSON_ASSERT( text != 0 );
+   JSON_ASSERT_MESSAGE( text[0]=='\0' || text[0]=='/', "Comments must start with /");
+   // It seems that /**/ style comments are acceptable as well.
+   comment_ = duplicateStringValue( text );
+}
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::CZString
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+# ifndef JSON_VALUE_USE_INTERNAL_MAP
+
+// Notes: index_ indicates if the string was allocated when
+// a string is stored.
+
+Value::CZString::CZString( ArrayIndex index )
+   : cstr_( 0 )
+   , index_( index )
+{
+}
+
+Value::CZString::CZString( const char *cstr, DuplicationPolicy allocate )
+   : cstr_( allocate == duplicate ? duplicateStringValue(cstr) 
+                                  : cstr )
+   , index_( allocate )
+{
+}
+
+Value::CZString::CZString( const CZString &other )
+: cstr_( other.index_ != noDuplication &&  other.cstr_ != 0
+                ?  duplicateStringValue( other.cstr_ )
+                : other.cstr_ )
+   , index_( other.cstr_ ? (other.index_ == noDuplication ? noDuplication : duplicate)
+                         : other.index_ )
+{
+}
+
+Value::CZString::~CZString()
+{
+   if ( cstr_  &&  index_ == duplicate )
+      releaseStringValue( const_cast<char *>( cstr_ ) );
+}
+
+void 
+Value::CZString::swap( CZString &other )
+{
+   std::swap( cstr_, other.cstr_ );
+   std::swap( index_, other.index_ );
+}
+
+Value::CZString &
+Value::CZString::operator =( const CZString &other )
+{
+   CZString temp( other );
+   swap( temp );
+   return *this;
+}
+
+bool 
+Value::CZString::operator<( const CZString &other ) const 
+{
+   if ( cstr_ )
+      return strcmp( cstr_, other.cstr_ ) < 0;
+   return index_ < other.index_;
+}
+
+bool 
+Value::CZString::operator==( const CZString &other ) const 
+{
+   if ( cstr_ )
+      return strcmp( cstr_, other.cstr_ ) == 0;
+   return index_ == other.index_;
+}
+
+
+ArrayIndex 
+Value::CZString::index() const
+{
+   return index_;
+}
+
+
+const char *
+Value::CZString::c_str() const
+{
+   return cstr_;
+}
+
+bool 
+Value::CZString::isStaticString() const
+{
+   return index_ == noDuplication;
+}
+
+#endif // ifndef JSON_VALUE_USE_INTERNAL_MAP
+
+
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// class Value::Value
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////////////
+
+/*! \internal Default constructor initialization must be equivalent to:
+ * memset( this, 0, sizeof(Value) )
+ * This optimization is used in ValueInternalMap fast allocator.
+ */
+Value::Value( ValueType type )
+   : type_( type )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   switch ( type )
+   {
+   case nullValue:
+      break;
+   case intValue:
+   case uintValue:
+      value_.int_ = 0;
+      break;
+   case realValue:
+      value_.real_ = 0.0;
+      break;
+   case stringValue:
+      value_.string_ = 0;
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_ = new ObjectValues();
+      break;
+#else
+   case arrayValue:
+      value_.array_ = arrayAllocator()->newArray();
+      break;
+   case objectValue:
+      value_.map_ = mapAllocator()->newMap();
+      break;
+#endif
+   case booleanValue:
+      value_.bool_ = false;
+      break;
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+}
+
+
+Value::Value( UInt value )
+   : type_( uintValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.uint_ = value;
+}
+
+Value::Value( Int value )
+   : type_( intValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.int_ = value;
+}
+
+
+# if defined(JSON_HAS_INT64)
+Value::Value( Int64 value )
+   : type_( intValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.int_ = value;
+}
+
+
+Value::Value( UInt64 value )
+   : type_( uintValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.uint_ = value;
+}
+#endif // defined(JSON_HAS_INT64)
+
+Value::Value( double value )
+   : type_( realValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.real_ = value;
+}
+
+Value::Value( const char *value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value );
+}
+
+
+Value::Value( const char *beginValue, 
+              const char *endValue )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( beginValue, 
+                                          (unsigned int)(endValue - beginValue) );
+}
+
+
+Value::Value( const std::string &value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value.c_str(), 
+                                          (unsigned int)value.length() );
+
+}
+
+Value::Value( const StaticString &value )
+   : type_( stringValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = const_cast<char *>( value.c_str() );
+}
+
+
+# ifdef JSON_USE_CPPTL
+Value::Value( const CppTL::ConstString &value )
+   : type_( stringValue )
+   , allocated_( true )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.string_ = duplicateStringValue( value, value.length() );
+}
+# endif
+
+Value::Value( bool value )
+   : type_( booleanValue )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   value_.bool_ = value;
+}
+
+
+Value::Value( const Value &other )
+   : type_( other.type_ )
+   , allocated_( false )
+# ifdef JSON_VALUE_USE_INTERNAL_MAP
+   , itemIsUsed_( 0 )
+#endif
+   , comments_( 0 )
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+      value_ = other.value_;
+      break;
+   case stringValue:
+      if ( other.value_.string_ )
+      {
+         value_.string_ = duplicateStringValue( other.value_.string_ );
+         allocated_ = true;
+      }
+      else
+         value_.string_ = 0;
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_ = new ObjectValues( *other.value_.map_ );
+      break;
+#else
+   case arrayValue:
+      value_.array_ = arrayAllocator()->newArrayCopy( *other.value_.array_ );
+      break;
+   case objectValue:
+      value_.map_ = mapAllocator()->newMapCopy( *other.value_.map_ );
+      break;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   if ( other.comments_ )
+   {
+      comments_ = new CommentInfo[numberOfCommentPlacement];
+      for ( int comment =0; comment < numberOfCommentPlacement; ++comment )
+      {
+         const CommentInfo &otherComment = other.comments_[comment];
+         if ( otherComment.comment_ )
+            comments_[comment].setComment( otherComment.comment_ );
+      }
+   }
+}
+
+
+Value::~Value()
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+      break;
+   case stringValue:
+      if ( allocated_ )
+         releaseStringValue( value_.string_ );
+      break;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      delete value_.map_;
+      break;
+#else
+   case arrayValue:
+      arrayAllocator()->destructArray( value_.array_ );
+      break;
+   case objectValue:
+      mapAllocator()->destructMap( value_.map_ );
+      break;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+
+   if ( comments_ )
+      delete[] comments_;
+}
+
+Value &
+Value::operator=( const Value &other )
+{
+   Value temp( other );
+   swap( temp );
+   return *this;
+}
+
+void 
+Value::swap( Value &other )
+{
+   ValueType temp = type_;
+   type_ = other.type_;
+   other.type_ = temp;
+   std::swap( value_, other.value_ );
+   int temp2 = allocated_;
+   allocated_ = other.allocated_;
+   other.allocated_ = temp2;
+}
+
+ValueType 
+Value::type() const
+{
+   return type_;
+}
+
+
+int 
+Value::compare( const Value &other ) const
+{
+   if ( *this < other )
+      return -1;
+   if ( *this > other )
+      return 1;
+   return 0;
+}
+
+
+bool 
+Value::operator <( const Value &other ) const
+{
+   int typeDelta = type_ - other.type_;
+   if ( typeDelta )
+      return typeDelta < 0 ? true : false;
+   switch ( type_ )
+   {
+   case nullValue:
+      return false;
+   case intValue:
+      return value_.int_ < other.value_.int_;
+   case uintValue:
+      return value_.uint_ < other.value_.uint_;
+   case realValue:
+      return value_.real_ < other.value_.real_;
+   case booleanValue:
+      return value_.bool_ < other.value_.bool_;
+   case stringValue:
+      return ( value_.string_ == 0  &&  other.value_.string_ )
+             || ( other.value_.string_  
+                  &&  value_.string_  
+                  && strcmp( value_.string_, other.value_.string_ ) < 0 );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      {
+         int delta = int( value_.map_->size() - other.value_.map_->size() );
+         if ( delta )
+            return delta < 0;
+         return (*value_.map_) < (*other.value_.map_);
+      }
+#else
+   case arrayValue:
+      return value_.array_->compare( *(other.value_.array_) ) < 0;
+   case objectValue:
+      return value_.map_->compare( *(other.value_.map_) ) < 0;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   return false;  // unreachable
+}
+
+bool 
+Value::operator <=( const Value &other ) const
+{
+   return !(other < *this);
+}
+
+bool 
+Value::operator >=( const Value &other ) const
+{
+   return !(*this < other);
+}
+
+bool 
+Value::operator >( const Value &other ) const
+{
+   return other < *this;
+}
+
+bool 
+Value::operator ==( const Value &other ) const
+{
+   //if ( type_ != other.type_ )
+   // GCC 2.95.3 says:
+   // attempt to take address of bit-field structure member `Json::Value::type_'
+   // Beats me, but a temp solves the problem.
+   int temp = other.type_;
+   if ( type_ != temp )
+      return false;
+   switch ( type_ )
+   {
+   case nullValue:
+      return true;
+   case intValue:
+      return value_.int_ == other.value_.int_;
+   case uintValue:
+      return value_.uint_ == other.value_.uint_;
+   case realValue:
+      return value_.real_ == other.value_.real_;
+   case booleanValue:
+      return value_.bool_ == other.value_.bool_;
+   case stringValue:
+      return ( value_.string_ == other.value_.string_ )
+             || ( other.value_.string_  
+                  &&  value_.string_  
+                  && strcmp( value_.string_, other.value_.string_ ) == 0 );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      return value_.map_->size() == other.value_.map_->size()
+             && (*value_.map_) == (*other.value_.map_);
+#else
+   case arrayValue:
+      return value_.array_->compare( *(other.value_.array_) ) == 0;
+   case objectValue:
+      return value_.map_->compare( *(other.value_.map_) ) == 0;
+#endif
+   default:
+      JSON_ASSERT_UNREACHABLE;
+   }
+   return false;  // unreachable
+}
+
+bool 
+Value::operator !=( const Value &other ) const
+{
+   return !( *this == other );
+}
+
+const char *
+Value::asCString() const
+{
+   JSON_ASSERT( type_ == stringValue );
+   return value_.string_;
+}
+
+
+std::string 
+Value::asString() const
+{
+   switch ( type_ )
+   {
+   case nullValue:
+      return "";
+   case stringValue:
+      return value_.string_ ? value_.string_ : "";
+   case booleanValue:
+      return value_.bool_ ? "true" : "false";
+   case intValue:
+      return valueToString( value_.int_ );
+   case uintValue:
+      return valueToString( value_.uint_ );
+   case realValue:
+      return valueToString( value_.real_ );
+   default:
+      JSON_FAIL_MESSAGE( "Type is not convertible to string" );
+   }
+}
+
+# ifdef JSON_USE_CPPTL
+CppTL::ConstString 
+Value::asConstString() const
+{
+   return CppTL::ConstString( asString().c_str() );
+}
+# endif
+
+
+Value::Int 
+Value::asInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
+      return Int(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
+      return Int(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt), "double out of Int range");
+      return Int(value_.real_);
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to Int.");
+}
+
+
+Value::UInt 
+Value::asUInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
+      return UInt(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
+      return UInt(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt), "double out of UInt range");
+      return UInt( value_.real_ );
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
+}
+
+
+# if defined(JSON_HAS_INT64)
+
+Value::Int64
+Value::asInt64() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return Int64(value_.int_);
+   case uintValue:
+      JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
+      return Int64(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), "double out of Int64 range");
+      return Int64(value_.real_);
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
+}
+
+
+Value::UInt64
+Value::asUInt64() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
+      return UInt64(value_.int_);
+   case uintValue:
+      return UInt64(value_.uint_);
+   case realValue:
+      JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64), "double out of UInt64 range");
+      return UInt64( value_.real_ );
+   case nullValue:
+      return 0;
+   case booleanValue:
+      return value_.bool_ ? 1 : 0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
+}
+# endif // if defined(JSON_HAS_INT64)
+
+
+LargestInt 
+Value::asLargestInt() const
+{
+#if defined(JSON_NO_INT64)
+    return asInt();
+#else
+    return asInt64();
+#endif
+}
+
+
+LargestUInt 
+Value::asLargestUInt() const
+{
+#if defined(JSON_NO_INT64)
+    return asUInt();
+#else
+    return asUInt64();
+#endif
+}
+
+
+double 
+Value::asDouble() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return static_cast<double>( value_.int_ );
+   case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return static_cast<double>( value_.uint_ );
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return integerToDouble( value_.uint_ );
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+   case realValue:
+      return value_.real_;
+   case nullValue:
+      return 0.0;
+   case booleanValue:
+      return value_.bool_ ? 1.0 : 0.0;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to double.");
+}
+
+float
+Value::asFloat() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return static_cast<float>( value_.int_ );
+   case uintValue:
+#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return static_cast<float>( value_.uint_ );
+#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+      return integerToDouble( value_.uint_ );
+#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
+   case realValue:
+      return static_cast<float>( value_.real_ );
+   case nullValue:
+      return 0.0;
+   case booleanValue:
+      return value_.bool_ ? 1.0f : 0.0f;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to float.");
+}
+
+bool 
+Value::asBool() const
+{
+   switch ( type_ )
+   {
+   case booleanValue:
+      return value_.bool_;
+   case nullValue:
+      return false;
+   case intValue:
+      return value_.int_ ? true : false;
+   case uintValue:
+      return value_.uint_ ? true : false;
+   case realValue:
+      return value_.real_ ? true : false;
+   default:
+      break;
+   }
+   JSON_FAIL_MESSAGE("Value is not convertible to bool.");
+}
+
+
+bool 
+Value::isConvertibleTo( ValueType other ) const
+{
+   switch ( other )
+   {
+   case nullValue:
+      return ( isNumeric() && asDouble() == 0.0 )
+             || ( type_ == booleanValue && value_.bool_ == false )
+             || ( type_ == stringValue && asString() == "" )
+             || ( type_ == arrayValue && value_.map_->size() == 0 )
+             || ( type_ == objectValue && value_.map_->size() == 0 )
+             || type_ == nullValue;
+   case intValue:
+      return isInt()
+             || (type_ == realValue && InRange(value_.real_, minInt, maxInt))
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case uintValue:
+      return isUInt()
+             || (type_ == realValue && InRange(value_.real_, 0, maxUInt))
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case realValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case booleanValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == nullValue;
+   case stringValue:
+      return isNumeric()
+             || type_ == booleanValue
+             || type_ == stringValue
+             || type_ == nullValue;
+   case arrayValue:
+      return type_ == arrayValue
+             || type_ == nullValue;
+   case objectValue:
+      return type_ == objectValue
+             || type_ == nullValue;
+   }
+   JSON_ASSERT_UNREACHABLE;
+   return false;
+}
+
+
+/// Number of values in array or object
+ArrayIndex 
+Value::size() const
+{
+   switch ( type_ )
+   {
+   case nullValue:
+   case intValue:
+   case uintValue:
+   case realValue:
+   case booleanValue:
+   case stringValue:
+      return 0;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:  // size of the array is highest index + 1
+      if ( !value_.map_->empty() )
+      {
+         ObjectValues::const_iterator itLast = value_.map_->end();
+         --itLast;
+         return (*itLast).first.index()+1;
+      }
+      return 0;
+   case objectValue:
+      return ArrayIndex( value_.map_->size() );
+#else
+   case arrayValue:
+      return Int( value_.array_->size() );
+   case objectValue:
+      return Int( value_.map_->size() );
+#endif
+   }
+   JSON_ASSERT_UNREACHABLE;
+   return 0; // unreachable;
+}
+
+
+bool 
+Value::empty() const
+{
+   if ( isNull() || isArray() || isObject() )
+      return size() == 0u;
+   else
+      return false;
+}
+
+
+bool
+Value::operator!() const
+{
+   return isNull();
+}
+
+
+void 
+Value::clear()
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue  || type_ == objectValue );
+
+   switch ( type_ )
+   {
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+   case objectValue:
+      value_.map_->clear();
+      break;
+#else
+   case arrayValue:
+      value_.array_->clear();
+      break;
+   case objectValue:
+      value_.map_->clear();
+      break;
+#endif
+   default:
+      break;
+   }
+}
+
+void 
+Value::resize( ArrayIndex newSize )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      *this = Value( arrayValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ArrayIndex oldSize = size();
+   if ( newSize == 0 )
+      clear();
+   else if ( newSize > oldSize )
+      (*this)[ newSize - 1 ];
+   else
+   {
+      for ( ArrayIndex index = newSize; index < oldSize; ++index )
+      {
+         value_.map_->erase( index );
+      }
+      assert( size() == newSize );
+   }
+#else
+   value_.array_->resize( newSize );
+#endif
+}
+
+
+Value &
+Value::operator[]( ArrayIndex index )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      *this = Value( arrayValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString key( index );
+   ObjectValues::iterator it = value_.map_->lower_bound( key );
+   if ( it != value_.map_->end()  &&  (*it).first == key )
+      return (*it).second;
+
+   ObjectValues::value_type defaultValue( key, null );
+   it = value_.map_->insert( it, defaultValue );
+   return (*it).second;
+#else
+   return value_.array_->resolveReference( index );
+#endif
+}
+
+
+Value &
+Value::operator[]( int index )
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
+const Value &
+Value::operator[]( ArrayIndex index ) const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == arrayValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString key( index );
+   ObjectValues::const_iterator it = value_.map_->find( key );
+   if ( it == value_.map_->end() )
+      return null;
+   return (*it).second;
+#else
+   Value *value = value_.array_->find( index );
+   return value ? *value : null;
+#endif
+}
+
+
+const Value &
+Value::operator[]( int index ) const
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
+Value &
+Value::operator[]( const char *key )
+{
+   return resolveReference( key, false );
+}
+
+
+Value &
+Value::resolveReference( const char *key, 
+                         bool isStatic )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      *this = Value( objectValue );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, isStatic ? CZString::noDuplication 
+                                     : CZString::duplicateOnCopy );
+   ObjectValues::iterator it = value_.map_->lower_bound( actualKey );
+   if ( it != value_.map_->end()  &&  (*it).first == actualKey )
+      return (*it).second;
+
+   ObjectValues::value_type defaultValue( actualKey, null );
+   it = value_.map_->insert( it, defaultValue );
+   Value &value = (*it).second;
+   return value;
+#else
+   return value_.map_->resolveReference( key, isStatic );
+#endif
+}
+
+
+Value 
+Value::get( ArrayIndex index, 
+            const Value &defaultValue ) const
+{
+   const Value *value = &((*this)[index]);
+   return value == &null ? defaultValue : *value;
+}
+
+
+bool 
+Value::isValidIndex( ArrayIndex index ) const
+{
+   return index < size();
+}
+
+
+
+const Value &
+Value::operator[]( const char *key ) const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, CZString::noDuplication );
+   ObjectValues::const_iterator it = value_.map_->find( actualKey );
+   if ( it == value_.map_->end() )
+      return null;
+   return (*it).second;
+#else
+   const Value *value = value_.map_->find( key );
+   return value ? *value : null;
+#endif
+}
+
+
+Value &
+Value::operator[]( const std::string &key )
+{
+   return (*this)[ key.c_str() ];
+}
+
+
+const Value &
+Value::operator[]( const std::string &key ) const
+{
+   return (*this)[ key.c_str() ];
+}
+
+Value &
+Value::operator[]( const StaticString &key )
+{
+   return resolveReference( key, true );
+}
+
+
+# ifdef JSON_USE_CPPTL
+Value &
+Value::operator[]( const CppTL::ConstString &key )
+{
+   return (*this)[ key.c_str() ];
+}
+
+
+const Value &
+Value::operator[]( const CppTL::ConstString &key ) const
+{
+   return (*this)[ key.c_str() ];
+}
+# endif
+
+
+Value &
+Value::append( const Value &value )
+{
+   return (*this)[size()] = value;
+}
+
+
+Value 
+Value::get( const char *key, 
+            const Value &defaultValue ) const
+{
+   const Value *value = &((*this)[key]);
+   return value == &null ? defaultValue : *value;
+}
+
+
+Value 
+Value::get( const std::string &key,
+            const Value &defaultValue ) const
+{
+   return get( key.c_str(), defaultValue );
+}
+
+Value
+Value::removeMember( const char* key )
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+      return null;
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   CZString actualKey( key, CZString::noDuplication );
+   ObjectValues::iterator it = value_.map_->find( actualKey );
+   if ( it == value_.map_->end() )
+      return null;
+   Value old(it->second);
+   value_.map_->erase(it);
+   return old;
+#else
+   Value *value = value_.map_->find( key );
+   if (value){
+      Value old(*value);
+      value_.map_.remove( key );
+      return old;
+   } else {
+      return null;
+   }
+#endif
+}
+
+Value
+Value::removeMember( const std::string &key )
+{
+   return removeMember( key.c_str() );
+}
+
+# ifdef JSON_USE_CPPTL
+Value 
+Value::get( const CppTL::ConstString &key,
+            const Value &defaultValue ) const
+{
+   return get( key.c_str(), defaultValue );
+}
+# endif
+
+bool 
+Value::isMember( const char *key ) const
+{
+   const Value *value = &((*this)[key]);
+   return value != &null;
+}
+
+
+bool 
+Value::isMember( const std::string &key ) const
+{
+   return isMember( key.c_str() );
+}
+
+
+# ifdef JSON_USE_CPPTL
+bool 
+Value::isMember( const CppTL::ConstString &key ) const
+{
+   return isMember( key.c_str() );
+}
+#endif
+
+Value::Members 
+Value::getMemberNames() const
+{
+   JSON_ASSERT( type_ == nullValue  ||  type_ == objectValue );
+   if ( type_ == nullValue )
+       return Value::Members();
+   Members members;
+   members.reserve( value_.map_->size() );
+#ifndef JSON_VALUE_USE_INTERNAL_MAP
+   ObjectValues::const_iterator it = value_.map_->begin();
+   ObjectValues::const_iterator itEnd = value_.map_->end();
+   for ( ; it != itEnd; ++it )
+      members.push_back( std::string( (*it).first.c_str() ) );
+#else
+   ValueInternalMap::IteratorState it;
+   ValueInternalMap::IteratorState itEnd;
+   value_.map_->makeBeginIterator( it );
+   value_.map_->makeEndIterator( itEnd );
+   for ( ; !ValueInternalMap::equals( it, itEnd ); ValueInternalMap::increment(it) )
+      members.push_back( std::string( ValueInternalMap::key( it ) ) );
+#endif
+   return members;
+}
+//
+//# ifdef JSON_USE_CPPTL
+//EnumMemberNames
+//Value::enumMemberNames() const
+//{
+//   if ( type_ == objectValue )
+//   {
+//      return CppTL::Enum::any(  CppTL::Enum::transform(
+//         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
+//         MemberNamesTransform() ) );
+//   }
+//   return EnumMemberNames();
+//}
+//
+//
+//EnumValues 
+//Value::enumValues() const
+//{
+//   if ( type_ == objectValue  ||  type_ == arrayValue )
+//      return CppTL::Enum::anyValues( *(value_.map_), 
+//                                     CppTL::Type<const Value &>() );
+//   return EnumValues();
+//}
+//
+//# endif
+
+static bool IsIntegral(double d) {
+  double integral_part;
+  return modf(d, &integral_part) == 0.0;
+}
+
+
+bool
+Value::isNull() const
+{
+   return type_ == nullValue;
+}
+
+
+bool 
+Value::isBool() const
+{
+   return type_ == booleanValue;
+}
+
+
+bool 
+Value::isInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return value_.int_ >= minInt  &&  value_.int_ <= maxInt;
+   case uintValue:
+      return value_.uint_ <= UInt(maxInt);
+   case realValue:
+      return value_.real_ >= minInt &&
+             value_.real_ <= maxInt &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+   return false;
+}
+
+
+bool 
+Value::isUInt() const
+{
+   switch ( type_ )
+   {
+   case intValue:
+      return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
+   case uintValue:
+      return value_.uint_ <= maxUInt;
+   case realValue:
+      return value_.real_ >= 0 &&
+             value_.real_ <= maxUInt &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+   return false;
+}
+
+bool 
+Value::isInt64() const
+{
+# if defined(JSON_HAS_INT64)
+   switch ( type_ )
+   {
+   case intValue:
+     return true;
+   case uintValue:
+      return value_.uint_ <= UInt64(maxInt64);
+   case realValue:
+      // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
+      // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
+      // require the value to be strictly less than the limit.
+      return value_.real_ >= double(minInt64) &&
+             value_.real_ < double(maxInt64) &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+# endif  // JSON_HAS_INT64
+   return false;
+}
+
+bool 
+Value::isUInt64() const
+{
+# if defined(JSON_HAS_INT64)
+   switch ( type_ )
+   {
+   case intValue:
+     return value_.int_ >= 0;
+   case uintValue:
+      return true;
+   case realValue:
+      // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
+      // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
+      // require the value to be strictly less than the limit.
+      return value_.real_ >= 0 &&
+             value_.real_ < maxUInt64AsDouble &&
+             IsIntegral(value_.real_);
+   default:
+      break;
+   }
+# endif  // JSON_HAS_INT64
+   return false;
+}
+
+
+bool 
+Value::isIntegral() const
+{
+#if defined(JSON_HAS_INT64)
+  return isInt64() || isUInt64();
+#else
+  return isInt() || isUInt();
+#endif
+}
+
+
+bool 
+Value::isDouble() const
+{
+   return type_ == realValue || isIntegral();
+}
+
+
+bool 
+Value::isNumeric() const
+{
+   return isIntegral() || isDouble();
+}
+
+
+bool 
+Value::isString() const
+{
+   return type_ == stringValue;
+}
+
+
+bool 
+Value::isArray() const
+{
+   return type_ == arrayValue;
+}
+
+
+bool 
+Value::isObject() const
+{
+   return type_ == objectValue;
+}
+
+
+void 
+Value::setComment( const char *comment,
+                   CommentPlacement placement )
+{
+   if ( !comments_ )
+      comments_ = new CommentInfo[numberOfCommentPlacement];
+   comments_[placement].setComment( comment );
+}
+
+
+void 
+Value::setComment( const std::string &comment,
+                   CommentPlacement placement )
+{
+   setComment( comment.c_str(), placement );
+}
+
+
+bool 
+Value::hasComment( CommentPlacement placement ) const
+{
+   return comments_ != 0  &&  comments_[placement].comment_ != 0;
+}
+
+std::string 
+Value::getComment( CommentPlacement placement ) const
+{
+   if ( hasComment(placement) )
+      return comments_[placement].comment_;
+   return "";
+}
+
+
+std::string 
+Value::toStyledString() const
+{
+   StyledWriter writer;
+   return writer.write( *this );
+}
+
+
+Value::const_iterator 
+Value::begin() const
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeBeginIterator( it );
+         return const_iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeBeginIterator( it );
+         return const_iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return const_iterator( value_.map_->begin() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return const_iterator();
+}
+
+Value::const_iterator 
+Value::end() const
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeEndIterator( it );
+         return const_iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeEndIterator( it );
+         return const_iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return const_iterator( value_.map_->end() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return const_iterator();
+}
+
+
+Value::iterator 
+Value::begin()
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeBeginIterator( it );
+         return iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeBeginIterator( it );
+         return iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return iterator( value_.map_->begin() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return iterator();
+}
+
+Value::iterator 
+Value::end()
+{
+   switch ( type_ )
+   {
+#ifdef JSON_VALUE_USE_INTERNAL_MAP
+   case arrayValue:
+      if ( value_.array_ )
+      {
+         ValueInternalArray::IteratorState it;
+         value_.array_->makeEndIterator( it );
+         return iterator( it );
+      }
+      break;
+   case objectValue:
+      if ( value_.map_ )
+      {
+         ValueInternalMap::IteratorState it;
+         value_.map_->makeEndIterator( it );
+         return iterator( it );
+      }
+      break;
+#else
+   case arrayValue:
+   case objectValue:
+      if ( value_.map_ )
+         return iterator( value_.map_->end() );
+      break;
+#endif
+   default:
+      break;
+   }
+   return iterator();
+}
+
+
+// class PathArgument
+// //////////////////////////////////////////////////////////////////
+
+PathArgument::PathArgument()
+   : key_()
+   , index_()
+   , kind_( kindNone )
+{
+}
+
+
+PathArgument::PathArgument( ArrayIndex index )
+   : key_()
+   , index_( index )
+   , kind_( kindIndex )
+{
+}
+
+
+PathArgument::PathArgument( const char *key )
+   : key_( key )
+   , index_()
+   , kind_( kindKey )
+{
+}
+
+
+PathArgument::PathArgument( const std::string &key )
+   : key_( key.c_str() )
+   , index_()
+   , kind_( kindKey )
+{
+}
+
+// class Path
+// //////////////////////////////////////////////////////////////////
+
+Path::Path( const std::string &path,
+            const PathArgument &a1,
+            const PathArgument &a2,
+            const PathArgument &a3,
+            const PathArgument &a4,
+            const PathArgument &a5 )
+{
+   InArgs in;
+   in.push_back( &a1 );
+   in.push_back( &a2 );
+   in.push_back( &a3 );
+   in.push_back( &a4 );
+   in.push_back( &a5 );
+   makePath( path, in );
+}
+
+
+void 
+Path::makePath( const std::string &path,
+                const InArgs &in )
+{
+   const char *current = path.c_str();
+   const char *end = current + path.length();
+   InArgs::const_iterator itInArg = in.begin();
+   while ( current != end )
+   {
+      if ( *current == '[' )
+      {
+         ++current;
+         if ( *current == '%' )
+            addPathInArg( path, in, itInArg, PathArgument::kindIndex );
+         else
+         {
+            ArrayIndex index = 0;
+            for ( ; current != end && *current >= '0'  &&  *current <= '9'; ++current )
+               index = index * 10 + ArrayIndex(*current - '0');
+            args_.push_back( index );
+         }
+         if ( current == end  ||  *current++ != ']' )
+            invalidPath( path, int(current - path.c_str()) );
+      }
+      else if ( *current == '%' )
+      {
+         addPathInArg( path, in, itInArg, PathArgument::kindKey );
+         ++current;
+      }
+      else if ( *current == '.' )
+      {
+         ++current;
+      }
+      else
+      {
+         const char *beginName = current;
+         while ( current != end  &&  !strchr( "[.", *current ) )
+            ++current;
+         args_.push_back( std::string( beginName, current ) );
+      }
+   }
+}
+
+
+void 
+Path::addPathInArg( const std::string &path, 
+                    const InArgs &in, 
+                    InArgs::const_iterator &itInArg, 
+                    PathArgument::Kind kind )
+{
+   if ( itInArg == in.end() )
+   {
+      // Error: missing argument %d
+   }
+   else if ( (*itInArg)->kind_ != kind )
+   {
+      // Error: bad argument type
+   }
+   else
+   {
+      args_.push_back( **itInArg );
+   }
+}
+
+
+void 
+Path::invalidPath( const std::string &path, 
+                   int location )
+{
+   // Error: invalid path.
+}
+
+
+const Value &
+Path::resolve( const Value &root ) const
+{
+   const Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
+         {
+            // Error: unable to resolve path (array value expected at position...
+         }
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+         {
+            // Error: unable to resolve path (object value expected at position...)
+         }
+         node = &((*node)[arg.key_]);
+         if ( node == &Value::null )
+         {
+            // Error: unable to resolve path (object has no member named '' at position...)
+         }
+      }
+   }
+   return *node;
+}
+
+
+Value 
+Path::resolve( const Value &root, 
+               const Value &defaultValue ) const
+{
+   const Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray()  ||  !node->isValidIndex( arg.index_ ) )
+            return defaultValue;
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+            return defaultValue;
+         node = &((*node)[arg.key_]);
+         if ( node == &Value::null )
+            return defaultValue;
+      }
+   }
+   return *node;
+}
+
+
+Value &
+Path::make( Value &root ) const
+{
+   Value *node = &root;
+   for ( Args::const_iterator it = args_.begin(); it != args_.end(); ++it )
+   {
+      const PathArgument &arg = *it;
+      if ( arg.kind_ == PathArgument::kindIndex )
+      {
+         if ( !node->isArray() )
+         {
+            // Error: node is not an array at position ...
+         }
+         node = &((*node)[arg.index_]);
+      }
+      else if ( arg.kind_ == PathArgument::kindKey )
+      {
+         if ( !node->isObject() )
+         {
+            // Error: node is not an object at position...
+         }
+         node = &((*node)[arg.key_]);
+      }
+   }
+   return *node;
+}
+
+
+} // namespace Json
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: src/lib_json/json_value.cpp
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: src/lib_json/json_writer.cpp
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2011 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#if !defined(JSON_IS_AMALGAMATION)
+# include <json/writer.h>
+# include "json_tool.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+#include <utility>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <sstream>
+#include <iomanip>
+
+#if defined(_MSC_VER)  &&  _MSC_VER >= 1400 // VC++ 8.0
+#pragma warning( disable : 4996 )   // disable warning about strdup being deprecated.
+#endif
+
+namespace Json {
+
+static bool containsControlCharacter( const char* str )
+{
+   while ( *str ) 
+   {
+      if ( isControlCharacter( *(str++) ) )
+         return true;
+   }
+   return false;
+}
+
+
+std::string valueToString( LargestInt value )
+{
+   UIntToStringBuffer buffer;
+   char *current = buffer + sizeof(buffer);
+   bool isNegative = value < 0;
+   if ( isNegative )
+      value = -value;
+   uintToString( LargestUInt(value), current );
+   if ( isNegative )
+      *--current = '-';
+   assert( current >= buffer );
+   return current;
+}
+
+
+std::string valueToString( LargestUInt value )
+{
+   UIntToStringBuffer buffer;
+   char *current = buffer + sizeof(buffer);
+   uintToString( value, current );
+   assert( current >= buffer );
+   return current;
+}
+
+#if defined(JSON_HAS_INT64)
+
+std::string valueToString( Int value )
+{
+   return valueToString( LargestInt(value) );
+}
+
+
+std::string valueToString( UInt value )
+{
+   return valueToString( LargestUInt(value) );
+}
+
+#endif // # if defined(JSON_HAS_INT64)
+
+
+std::string valueToString( double value )
+{
+   char buffer[32];
+#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) // Use secure version with visual studio 2005 to avoid warning. 
+   sprintf_s(buffer, sizeof(buffer), "%#.16g", value); 
+#else	
+   sprintf(buffer, "%#.16g", value); 
+#endif
+   char* ch = buffer + strlen(buffer) - 1;
+   if (*ch != '0') return buffer; // nothing to truncate, so save time
+   while(ch > buffer && *ch == '0'){
+     --ch;
+   }
+   char* last_nonzero = ch;
+   while(ch >= buffer){
+     switch(*ch){
+     case '0':
+     case '1':
+     case '2':
+     case '3':
+     case '4':
+     case '5':
+     case '6':
+     case '7':
+     case '8':
+     case '9':
+       --ch;
+       continue;
+     case '.':
+       // Truncate zeroes to save bytes in output, but keep one.
+       *(last_nonzero+2) = '\0';
+       return buffer;
+     default:
+       return buffer;
+     }
+   }
+   return buffer;
+}
+
+
+std::string valueToString( bool value )
+{
+   return value ? "true" : "false";
+}
+
+std::string valueToQuotedString( const char *value )
+{
+   if (value == NULL)
+      return "";
+   // Not sure how to handle unicode...
+   if (strpbrk(value, "\"\\\b\f\n\r\t") == NULL && !containsControlCharacter( value ))
+      return std::string("\"") + value + "\"";
+   // We have to walk value and escape any special characters.
+   // Appending to std::string is not efficient, but this should be rare.
+   // (Note: forward slashes are *not* rare, but I am not escaping them.)
+   std::string::size_type maxsize = strlen(value)*2 + 3; // allescaped+quotes+NULL
+   std::string result;
+   result.reserve(maxsize); // to avoid lots of mallocs
+   result += "\"";
+   for (const char* c=value; *c != 0; ++c)
+   {
+      switch(*c)
+      {
+         case '\"':
+            result += "\\\"";
+            break;
+         case '\\':
+            result += "\\\\";
+            break;
+         case '\b':
+            result += "\\b";
+            break;
+         case '\f':
+            result += "\\f";
+            break;
+         case '\n':
+            result += "\\n";
+            break;
+         case '\r':
+            result += "\\r";
+            break;
+         case '\t':
+            result += "\\t";
+            break;
+         //case '/':
+            // Even though \/ is considered a legal escape in JSON, a bare
+            // slash is also legal, so I see no reason to escape it.
+            // (I hope I am not misunderstanding something.
+            // blep notes: actually escaping \/ may be useful in javascript to avoid </ 
+            // sequence.
+            // Should add a flag to allow this compatibility mode and prevent this 
+            // sequence from occurring.
+         default:
+            if ( isControlCharacter( *c ) )
+            {
+               std::ostringstream oss;
+               oss << "\\u" << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << static_cast<int>(*c);
+               result += oss.str();
+            }
+            else
+            {
+               result += *c;
+            }
+            break;
+      }
+   }
+   result += "\"";
+   return result;
+}
+
+// Class Writer
+// //////////////////////////////////////////////////////////////////
+Writer::~Writer()
+{
+}
+
+
+// Class FastWriter
+// //////////////////////////////////////////////////////////////////
+
+FastWriter::FastWriter()
+   : yamlCompatiblityEnabled_( false ),
+     dropNullPlaceholders_( false )
+{
+}
+
+
+void 
+FastWriter::enableYAMLCompatibility()
+{
+   yamlCompatiblityEnabled_ = true;
+}
+
+
+void
+FastWriter::dropNullPlaceholders()
+{
+   dropNullPlaceholders_ = true;
+}
+
+
+std::string 
+FastWriter::write( const Value &root )
+{
+   document_ = "";
+   writeValue( root );
+   document_ += "\n";
+   return document_;
+}
+
+
+void 
+FastWriter::writeValue( const Value &value )
+{
+   switch ( value.type() )
+   {
+   case nullValue:
+      if (!dropNullPlaceholders_) document_ += "null";
+      break;
+   case intValue:
+      document_ += valueToString( value.asLargestInt() );
+      break;
+   case uintValue:
+      document_ += valueToString( value.asLargestUInt() );
+      break;
+   case realValue:
+      document_ += valueToString( value.asDouble() );
+      break;
+   case stringValue:
+      document_ += valueToQuotedString( value.asCString() );
+      break;
+   case booleanValue:
+      document_ += valueToString( value.asBool() );
+      break;
+   case arrayValue:
+      {
+         document_ += "[";
+         int size = value.size();
+         for ( int index =0; index < size; ++index )
+         {
+            if ( index > 0 )
+               document_ += ",";
+            writeValue( value[index] );
+         }
+         document_ += "]";
+      }
+      break;
+   case objectValue:
+      {
+         Value::Members members( value.getMemberNames() );
+         document_ += "{";
+         for ( Value::Members::iterator it = members.begin(); 
+               it != members.end(); 
+               ++it )
+         {
+            const std::string &name = *it;
+            if ( it != members.begin() )
+               document_ += ",";
+            document_ += valueToQuotedString( name.c_str() );
+            document_ += yamlCompatiblityEnabled_ ? ": " 
+                                                  : ":";
+            writeValue( value[name] );
+         }
+         document_ += "}";
+      }
+      break;
+   }
+}
+
+
+// Class StyledWriter
+// //////////////////////////////////////////////////////////////////
+
+StyledWriter::StyledWriter()
+   : rightMargin_( 74 )
+   , indentSize_( 3 )
+   , addChildValues_()
+{
+}
+
+
+std::string 
+StyledWriter::write( const Value &root )
+{
+   document_ = "";
+   addChildValues_ = false;
+   indentString_ = "";
+   writeCommentBeforeValue( root );
+   writeValue( root );
+   writeCommentAfterValueOnSameLine( root );
+   document_ += "\n";
+   return document_;
+}
+
+
+void 
+StyledWriter::writeValue( const Value &value )
+{
+   switch ( value.type() )
+   {
+   case nullValue:
+      pushValue( "null" );
+      break;
+   case intValue:
+      pushValue( valueToString( value.asLargestInt() ) );
+      break;
+   case uintValue:
+      pushValue( valueToString( value.asLargestUInt() ) );
+      break;
+   case realValue:
+      pushValue( valueToString( value.asDouble() ) );
+      break;
+   case stringValue:
+      pushValue( valueToQuotedString( value.asCString() ) );
+      break;
+   case booleanValue:
+      pushValue( valueToString( value.asBool() ) );
+      break;
+   case arrayValue:
+      writeArrayValue( value);
+      break;
+   case objectValue:
+      {
+         Value::Members members( value.getMemberNames() );
+         if ( members.empty() )
+            pushValue( "{}" );
+         else
+         {
+            writeWithIndent( "{" );
+            indent();
+            Value::Members::iterator it = members.begin();
+            for (;;)
+            {
+               const std::string &name = *it;
+               const Value &childValue = value[name];
+               writeCommentBeforeValue( childValue );
+               writeWithIndent( valueToQuotedString( name.c_str() ) );
+               document_ += " : ";
+               writeValue( childValue );
+               if ( ++it == members.end() )
+               {
+                  writeCommentAfterValueOnSameLine( childValue );
+                  break;
+               }
+               document_ += ",";
+               writeCommentAfterValueOnSameLine( childValue );
+            }
+            unindent();
+            writeWithIndent( "}" );
+         }
+      }
+      break;
+   }
+}
+
+
+void 
+StyledWriter::writeArrayValue( const Value &value )
+{
+   unsigned size = value.size();
+   if ( size == 0 )
+      pushValue( "[]" );
+   else
+   {
+      bool isArrayMultiLine = isMultineArray( value );
+      if ( isArrayMultiLine )
+      {
+         writeWithIndent( "[" );
+         indent();
+         bool hasChildValue = !childValues_.empty();
+         unsigned index =0;
+         for (;;)
+         {
+            const Value &childValue = value[index];
+            writeCommentBeforeValue( childValue );
+            if ( hasChildValue )
+               writeWithIndent( childValues_[index] );
+            else
+            {
+               writeIndent();
+               writeValue( childValue );
+            }
+            if ( ++index == size )
+            {
+               writeCommentAfterValueOnSameLine( childValue );
+               break;
+            }
+            document_ += ",";
+            writeCommentAfterValueOnSameLine( childValue );
+         }
+         unindent();
+         writeWithIndent( "]" );
+      }
+      else // output on a single line
+      {
+         assert( childValues_.size() == size );
+         document_ += "[ ";
+         for ( unsigned index =0; index < size; ++index )
+         {
+            if ( index > 0 )
+               document_ += ", ";
+            document_ += childValues_[index];
+         }
+         document_ += " ]";
+      }
+   }
+}
+
+
+bool 
+StyledWriter::isMultineArray( const Value &value )
+{
+   int size = value.size();
+   bool isMultiLine = size*3 >= rightMargin_ ;
+   childValues_.clear();
+   for ( int index =0; index < size  &&  !isMultiLine; ++index )
+   {
+      const Value &childValue = value[index];
+      isMultiLine = isMultiLine  ||
+                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
+                        childValue.size() > 0 );
+   }
+   if ( !isMultiLine ) // check if line length > max line length
+   {
+      childValues_.reserve( size );
+      addChildValues_ = true;
+      int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
+      for ( int index =0; index < size  &&  !isMultiLine; ++index )
+      {
+         writeValue( value[index] );
+         lineLength += int( childValues_[index].length() );
+         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
+      }
+      addChildValues_ = false;
+      isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;
+   }
+   return isMultiLine;
+}
+
+
+void 
+StyledWriter::pushValue( const std::string &value )
+{
+   if ( addChildValues_ )
+      childValues_.push_back( value );
+   else
+      document_ += value;
+}
+
+
+void 
+StyledWriter::writeIndent()
+{
+   if ( !document_.empty() )
+   {
+      char last = document_[document_.length()-1];
+      if ( last == ' ' )     // already indented
+         return;
+      if ( last != '\n' )    // Comments may add new-line
+         document_ += '\n';
+   }
+   document_ += indentString_;
+}
+
+
+void 
+StyledWriter::writeWithIndent( const std::string &value )
+{
+   writeIndent();
+   document_ += value;
+}
+
+
+void 
+StyledWriter::indent()
+{
+   indentString_ += std::string( indentSize_, ' ' );
+}
+
+
+void 
+StyledWriter::unindent()
+{
+   assert( int(indentString_.size()) >= indentSize_ );
+   indentString_.resize( indentString_.size() - indentSize_ );
+}
+
+
+void 
+StyledWriter::writeCommentBeforeValue( const Value &root )
+{
+   if ( !root.hasComment( commentBefore ) )
+      return;
+   document_ += normalizeEOL( root.getComment( commentBefore ) );
+   document_ += "\n";
+}
+
+
+void 
+StyledWriter::writeCommentAfterValueOnSameLine( const Value &root )
+{
+   if ( root.hasComment( commentAfterOnSameLine ) )
+      document_ += " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
+
+   if ( root.hasComment( commentAfter ) )
+   {
+      document_ += "\n";
+      document_ += normalizeEOL( root.getComment( commentAfter ) );
+      document_ += "\n";
+   }
+}
+
+
+bool 
+StyledWriter::hasCommentForValue( const Value &value )
+{
+   return value.hasComment( commentBefore )
+          ||  value.hasComment( commentAfterOnSameLine )
+          ||  value.hasComment( commentAfter );
+}
+
+
+std::string 
+StyledWriter::normalizeEOL( const std::string &text )
+{
+   std::string normalized;
+   normalized.reserve( text.length() );
+   const char *begin = text.c_str();
+   const char *end = begin + text.length();
+   const char *current = begin;
+   while ( current != end )
+   {
+      char c = *current++;
+      if ( c == '\r' ) // mac or dos EOL
+      {
+         if ( *current == '\n' ) // convert dos EOL
+            ++current;
+         normalized += '\n';
+      }
+      else // handle unix EOL & other char
+         normalized += c;
+   }
+   return normalized;
+}
+
+
+// Class StyledStreamWriter
+// //////////////////////////////////////////////////////////////////
+
+StyledStreamWriter::StyledStreamWriter( std::string indentation )
+   : document_(NULL)
+   , rightMargin_( 74 )
+   , indentation_( indentation )
+   , addChildValues_()
+{
+}
+
+
+void
+StyledStreamWriter::write( std::ostream &out, const Value &root )
+{
+   document_ = &out;
+   addChildValues_ = false;
+   indentString_ = "";
+   writeCommentBeforeValue( root );
+   writeValue( root );
+   writeCommentAfterValueOnSameLine( root );
+   *document_ << "\n";
+   document_ = NULL; // Forget the stream, for safety.
+}
+
+
+void 
+StyledStreamWriter::writeValue( const Value &value )
+{
+   switch ( value.type() )
+   {
+   case nullValue:
+      pushValue( "null" );
+      break;
+   case intValue:
+      pushValue( valueToString( value.asLargestInt() ) );
+      break;
+   case uintValue:
+      pushValue( valueToString( value.asLargestUInt() ) );
+      break;
+   case realValue:
+      pushValue( valueToString( value.asDouble() ) );
+      break;
+   case stringValue:
+      pushValue( valueToQuotedString( value.asCString() ) );
+      break;
+   case booleanValue:
+      pushValue( valueToString( value.asBool() ) );
+      break;
+   case arrayValue:
+      writeArrayValue( value);
+      break;
+   case objectValue:
+      {
+         Value::Members members( value.getMemberNames() );
+         if ( members.empty() )
+            pushValue( "{}" );
+         else
+         {
+            writeWithIndent( "{" );
+            indent();
+            Value::Members::iterator it = members.begin();
+            for (;;)
+            {
+               const std::string &name = *it;
+               const Value &childValue = value[name];
+               writeCommentBeforeValue( childValue );
+               writeWithIndent( valueToQuotedString( name.c_str() ) );
+               *document_ << " : ";
+               writeValue( childValue );
+               if ( ++it == members.end() )
+               {
+                  writeCommentAfterValueOnSameLine( childValue );
+                  break;
+               }
+               *document_ << ",";
+               writeCommentAfterValueOnSameLine( childValue );
+            }
+            unindent();
+            writeWithIndent( "}" );
+         }
+      }
+      break;
+   }
+}
+
+
+void 
+StyledStreamWriter::writeArrayValue( const Value &value )
+{
+   unsigned size = value.size();
+   if ( size == 0 )
+      pushValue( "[]" );
+   else
+   {
+      bool isArrayMultiLine = isMultineArray( value );
+      if ( isArrayMultiLine )
+      {
+         writeWithIndent( "[" );
+         indent();
+         bool hasChildValue = !childValues_.empty();
+         unsigned index =0;
+         for (;;)
+         {
+            const Value &childValue = value[index];
+            writeCommentBeforeValue( childValue );
+            if ( hasChildValue )
+               writeWithIndent( childValues_[index] );
+            else
+            {
+               writeIndent();
+               writeValue( childValue );
+            }
+            if ( ++index == size )
+            {
+               writeCommentAfterValueOnSameLine( childValue );
+               break;
+            }
+            *document_ << ",";
+            writeCommentAfterValueOnSameLine( childValue );
+         }
+         unindent();
+         writeWithIndent( "]" );
+      }
+      else // output on a single line
+      {
+         assert( childValues_.size() == size );
+         *document_ << "[ ";
+         for ( unsigned index =0; index < size; ++index )
+         {
+            if ( index > 0 )
+               *document_ << ", ";
+            *document_ << childValues_[index];
+         }
+         *document_ << " ]";
+      }
+   }
+}
+
+
+bool 
+StyledStreamWriter::isMultineArray( const Value &value )
+{
+   int size = value.size();
+   bool isMultiLine = size*3 >= rightMargin_ ;
+   childValues_.clear();
+   for ( int index =0; index < size  &&  !isMultiLine; ++index )
+   {
+      const Value &childValue = value[index];
+      isMultiLine = isMultiLine  ||
+                     ( (childValue.isArray()  ||  childValue.isObject())  &&  
+                        childValue.size() > 0 );
+   }
+   if ( !isMultiLine ) // check if line length > max line length
+   {
+      childValues_.reserve( size );
+      addChildValues_ = true;
+      int lineLength = 4 + (size-1)*2; // '[ ' + ', '*n + ' ]'
+      for ( int index =0; index < size  &&  !isMultiLine; ++index )
+      {
+         writeValue( value[index] );
+         lineLength += int( childValues_[index].length() );
+         isMultiLine = isMultiLine  &&  hasCommentForValue( value[index] );
+      }
+      addChildValues_ = false;
+      isMultiLine = isMultiLine  ||  lineLength >= rightMargin_;
+   }
+   return isMultiLine;
+}
+
+
+void 
+StyledStreamWriter::pushValue( const std::string &value )
+{
+   if ( addChildValues_ )
+      childValues_.push_back( value );
+   else
+      *document_ << value;
+}
+
+
+void 
+StyledStreamWriter::writeIndent()
+{
+  /*
+    Some comments in this method would have been nice. ;-)
+
+   if ( !document_.empty() )
+   {
+      char last = document_[document_.length()-1];
+      if ( last == ' ' )     // already indented
+         return;
+      if ( last != '\n' )    // Comments may add new-line
+         *document_ << '\n';
+   }
+  */
+   *document_ << '\n' << indentString_;
+}
+
+
+void 
+StyledStreamWriter::writeWithIndent( const std::string &value )
+{
+   writeIndent();
+   *document_ << value;
+}
+
+
+void 
+StyledStreamWriter::indent()
+{
+   indentString_ += indentation_;
+}
+
+
+void 
+StyledStreamWriter::unindent()
+{
+   assert( indentString_.size() >= indentation_.size() );
+   indentString_.resize( indentString_.size() - indentation_.size() );
+}
+
+
+void 
+StyledStreamWriter::writeCommentBeforeValue( const Value &root )
+{
+   if ( !root.hasComment( commentBefore ) )
+      return;
+   *document_ << normalizeEOL( root.getComment( commentBefore ) );
+   *document_ << "\n";
+}
+
+
+void 
+StyledStreamWriter::writeCommentAfterValueOnSameLine( const Value &root )
+{
+   if ( root.hasComment( commentAfterOnSameLine ) )
+      *document_ << " " + normalizeEOL( root.getComment( commentAfterOnSameLine ) );
+
+   if ( root.hasComment( commentAfter ) )
+   {
+      *document_ << "\n";
+      *document_ << normalizeEOL( root.getComment( commentAfter ) );
+      *document_ << "\n";
+   }
+}
+
+
+bool 
+StyledStreamWriter::hasCommentForValue( const Value &value )
+{
+   return value.hasComment( commentBefore )
+          ||  value.hasComment( commentAfterOnSameLine )
+          ||  value.hasComment( commentAfter );
+}
+
+
+std::string 
+StyledStreamWriter::normalizeEOL( const std::string &text )
+{
+   std::string normalized;
+   normalized.reserve( text.length() );
+   const char *begin = text.c_str();
+   const char *end = begin + text.length();
+   const char *current = begin;
+   while ( current != end )
+   {
+      char c = *current++;
+      if ( c == '\r' ) // mac or dos EOL
+      {
+         if ( *current == '\n' ) // convert dos EOL
+            ++current;
+         normalized += '\n';
+      }
+      else // handle unix EOL & other char
+         normalized += c;
+   }
+   return normalized;
+}
+
+
+std::ostream& operator<<( std::ostream &sout, const Value &root )
+{
+   Json::StyledStreamWriter writer;
+   writer.write(sout, root);
+   return sout;
+}
+
+
+} // namespace Json
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: src/lib_json/json_writer.cpp
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
diff --git a/src/jthread/jmutex.h b/src/jthread/jmutex.h
index 9ce013096..e528aeb4a 100644
--- a/src/jthread/jmutex.h
+++ b/src/jthread/jmutex.h
@@ -30,6 +30,9 @@
 #define JMUTEX_H
 
 #if (defined(WIN32) || defined(_WIN32_WCE))
+	#ifndef _WIN32_WINNT
+		#define _WIN32_WINNT 0x0500
+	#endif
 	#ifndef _WIN32_WCE
 		#include <process.h>
 	#endif // _WIN32_WCE
@@ -67,4 +70,54 @@ private:
 	bool initialized;
 };
 
+#ifdef _WIN32
+
+class Event {
+	HANDLE hEvent;
+
+public:
+	Event() {
+		hEvent = CreateEvent(NULL, 0, 0, NULL);
+	}
+	
+	~Event() {
+		CloseHandle(hEvent);
+	}
+	
+	void wait() {
+		WaitForSingleObject(hEvent, INFINITE); 
+	}
+	
+	void signal() {
+		SetEvent(hEvent);
+	}
+};
+
+#else
+
+#include <semaphore.h>
+
+class Event {
+	sem_t sem;
+
+public:
+	Event() {
+		sem_init(&sem, 0, 0);
+	}
+	
+	~Event() {
+		sem_destroy(&sem);
+	}
+	
+	void wait() {
+		sem_wait(&sem);
+	}
+	
+	void signal() {
+		sem_post(&sem);
+	}
+};
+
+#endif
+
 #endif // JMUTEX_H
diff --git a/src/keycode.cpp b/src/keycode.cpp
index 9aa9d300d..8aadab2f1 100644
--- a/src/keycode.cpp
+++ b/src/keycode.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/keycode.h b/src/keycode.h
index a0b1e3553..65f04d8d7 100644
--- a/src/keycode.h
+++ b/src/keycode.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/light.cpp b/src/light.cpp
index 66bceb72b..765c6303a 100644
--- a/src/light.cpp
+++ b/src/light.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/light.h b/src/light.h
index f1c458ad8..e847e1ce9 100644
--- a/src/light.h
+++ b/src/light.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/localplayer.cpp b/src/localplayer.cpp
index b6dd0f42e..0554302e0 100644
--- a/src/localplayer.cpp
+++ b/src/localplayer.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -90,37 +90,39 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
 	*/
 	
 	/*
-		Check if player is in water (the oscillating value)
+		Check if player is in liquid (the oscillating value)
 	*/
 	try{
-		// If in water, the threshold of coming out is at higher y
-		if(in_water)
+		// If in liquid, the threshold of coming out is at higher y
+		if(in_liquid)
 		{
 			v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
-			in_water = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+			in_liquid = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+			liquid_viscosity = nodemgr->get(map.getNode(pp).getContent()).liquid_viscosity;
 		}
-		// If not in water, the threshold of going in is at lower y
+		// If not in liquid, the threshold of going in is at lower y
 		else
 		{
 			v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
-			in_water = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+			in_liquid = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+			liquid_viscosity = nodemgr->get(map.getNode(pp).getContent()).liquid_viscosity;
 		}
 	}
 	catch(InvalidPositionException &e)
 	{
-		in_water = false;
+		in_liquid = false;
 	}
 
 	/*
-		Check if player is in water (the stable value)
+		Check if player is in liquid (the stable value)
 	*/
 	try{
 		v3s16 pp = floatToInt(position + v3f(0,0,0), BS);
-		in_water_stable = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+		in_liquid_stable = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
 	}
 	catch(InvalidPositionException &e)
 	{
-		in_water_stable = false;
+		in_liquid_stable = false;
 	}
 
 	/*
@@ -159,7 +161,7 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
 		If sneaking, keep in range from the last walked node and don't
 		fall off from it
 	*/
-	if(control.sneak && m_sneak_node_exists && !g_settings->getBool("free_move"))
+	if(control.sneak && m_sneak_node_exists && !(fly_allowed && g_settings->getBool("free_move")) && !in_liquid)
 	{
 		f32 maxd = 0.5*BS + sneak_max;
 		v3f lwn_f = intToFloat(m_sneak_node, BS);
@@ -315,7 +317,7 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
 	}
 
 	if(bouncy_jump && control.jump){
-		m_speed.Y += 6.5*BS;
+		m_speed.Y += movement_speed_jump*BS;
 		touching_ground = false;
 		MtEvent *e = new SimpleTriggerEvent("PlayerJump");
 		m_gamedef->event()->put(e);
@@ -348,7 +350,7 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
 	*/
 	const ContentFeatures &f = nodemgr->get(map.getNodeNoEx(getStandingNodePos()));
 	// Determine if jumping is possible
-	m_can_jump = touching_ground;
+	m_can_jump = touching_ground && !in_liquid;
 	if(itemgroup_get(f.groups, "disable_jump"))
 		m_can_jump = false;
 }
@@ -361,12 +363,8 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d)
 void LocalPlayer::applyControl(float dtime)
 {
 	// Clear stuff
-	swimming_up = false;
+	swimming_vertical = false;
 
-	// Random constants
-	f32 walk_acceleration = 4.0 * BS;
-	f32 walkspeed_max = 4.0 * BS;
-	
 	setPitch(control.pitch);
 	setYaw(control.yaw);
 
@@ -380,22 +378,17 @@ void LocalPlayer::applyControl(float dtime)
 	v3f move_direction = v3f(0,0,1);
 	move_direction.rotateXZBy(getYaw());
 	
-	v3f speed = v3f(0,0,0);
+	v3f speedH = v3f(0,0,0); // Horizontal (X, Z)
+	v3f speedV = v3f(0,0,0); // Vertical (Y)
 	
 	bool fly_allowed = m_gamedef->checkLocalPrivilege("fly");
 	bool fast_allowed = m_gamedef->checkLocalPrivilege("fast");
 
 	bool free_move = fly_allowed && g_settings->getBool("free_move");
 	bool fast_move = fast_allowed && g_settings->getBool("fast_move");
+	bool fast_or_aux1_descends = (fast_move && control.aux1) || (fast_move && g_settings->getBool("aux1_descends"));
 	bool continuous_forward = g_settings->getBool("continuous_forward");
 
-	if(free_move || is_climbing)
-	{
-		v3f speed = getSpeed();
-		speed.Y = 0;
-		setSpeed(speed);
-	}
-
 	// Whether superspeed mode is used or not
 	bool superspeed = false;
 	
@@ -415,18 +408,21 @@ void LocalPlayer::applyControl(float dtime)
 			if(free_move)
 			{
 				// In free movement mode, aux1 descends
-				v3f speed = getSpeed();
 				if(fast_move)
-					speed.Y = -20*BS;
+					speedV.Y = -movement_speed_fast;
 				else
-					speed.Y = -walkspeed_max;
-				setSpeed(speed);
+					speedV.Y = -movement_speed_walk;
+			}
+			else if(in_liquid || in_liquid_stable)
+			{
+				// Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
+				speedV.Y = -movement_speed_fast;
+				swimming_vertical = true;
 			}
 			else if(is_climbing)
 			{
-					v3f speed = getSpeed();
-				speed.Y = -3*BS;
-				setSpeed(speed);
+				// Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict
+				speedV.Y = -movement_speed_fast;
 			}
 			else
 			{
@@ -456,66 +452,69 @@ void LocalPlayer::applyControl(float dtime)
 			if(free_move)
 			{
 				// In free movement mode, sneak descends
-				v3f speed = getSpeed();
-				if(fast_move && (control.aux1 ||
-						g_settings->getBool("always_fly_fast")))
-					speed.Y = -20*BS;
+				if(fast_move && (control.aux1 || g_settings->getBool("always_fly_fast")))
+					speedV.Y = -movement_speed_fast;
 				else
-					speed.Y = -walkspeed_max;
-					setSpeed(speed);
+					speedV.Y = -movement_speed_walk;
+			}
+			else if(in_liquid || in_liquid_stable)
+			{
+				if(fast_or_aux1_descends)
+					// Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
+					speedV.Y = -movement_speed_fast;
+				else
+					speedV.Y = -movement_speed_walk;
+				swimming_vertical = true;
 			}
 			else if(is_climbing)
 			{
-				v3f speed = getSpeed();
-				speed.Y = -3*BS;
-				setSpeed(speed);
+				if(fast_or_aux1_descends)
+					// Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict
+					speedV.Y = -movement_speed_fast;
+				else
+					speedV.Y = -movement_speed_climb;
 			}
 		}
 	}
 
 	if(continuous_forward)
-		speed += move_direction;
+		speedH += move_direction;
 
 	if(control.up)
 	{
 		if(continuous_forward)
 			superspeed = true;
 		else
-			speed += move_direction;
+			speedH += move_direction;
 	}
 	if(control.down)
 	{
-		speed -= move_direction;
+		speedH -= move_direction;
 	}
 	if(control.left)
 	{
-		speed += move_direction.crossProduct(v3f(0,1,0));
+		speedH += move_direction.crossProduct(v3f(0,1,0));
 	}
 	if(control.right)
 	{
-		speed += move_direction.crossProduct(v3f(0,-1,0));
+		speedH += move_direction.crossProduct(v3f(0,-1,0));
 	}
 	if(control.jump)
 	{
 		if(free_move)
-		{
-			v3f speed = getSpeed();
-			
-			if(g_settings->getBool("aux1_descends") ||
-					g_settings->getBool("always_fly_fast"))
+		{			
+			if(g_settings->getBool("aux1_descends") || g_settings->getBool("always_fly_fast"))
 			{
 				if(fast_move)
-					speed.Y = 20*BS;
+					speedV.Y = movement_speed_fast;
 				else
-					speed.Y = walkspeed_max;
+					speedV.Y = movement_speed_walk;
 			} else {
 				if(fast_move && control.aux1)
-					speed.Y = 20*BS;
+					speedV.Y = movement_speed_fast;
 				else
-					speed.Y = walkspeed_max;
+					speedV.Y = movement_speed_walk;
 			}
-			
-			setSpeed(speed);
 		}
 		else if(m_can_jump)
 		{
@@ -524,49 +523,66 @@ void LocalPlayer::applyControl(float dtime)
 				raising the height at which the jump speed is kept
 				at its starting value
 			*/
-			v3f speed = getSpeed();
-			if(speed.Y >= -0.5*BS)
+			v3f speedJ = getSpeed();
+			if(speedJ.Y >= -0.5 * BS)
 			{
-				speed.Y = 6.5*BS;
-				setSpeed(speed);
+				speedJ.Y = movement_speed_jump;
+				setSpeed(speedJ);
 				
 				MtEvent *e = new SimpleTriggerEvent("PlayerJump");
 				m_gamedef->event()->put(e);
 			}
 		}
-		// Use the oscillating value for getting out of water
-		// (so that the player doesn't fly on the surface)
-		else if(in_water)
+		else if(in_liquid)
 		{
-			v3f speed = getSpeed();
-			speed.Y = 1.5*BS;
-			setSpeed(speed);
-			swimming_up = true;
+			if(fast_or_aux1_descends)
+				// Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
+				speedV.Y = movement_speed_fast;
+			else
+				speedV.Y = movement_speed_walk;
+			swimming_vertical = true;
 		}
 		else if(is_climbing)
 		{
-	                v3f speed = getSpeed();
-			speed.Y = 3*BS;
-			setSpeed(speed);
+			if(fast_or_aux1_descends)
+				// Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict
+				speedV.Y = movement_speed_fast;
+			else
+				speedV.Y = movement_speed_climb;
 		}
 	}
 
 	// The speed of the player (Y is ignored)
-	if(superspeed)
-		speed = speed.normalize() * walkspeed_max * 5.0;
-	else if(control.sneak && !free_move)
-		speed = speed.normalize() * walkspeed_max / 3.0;
+	if(superspeed || (is_climbing && fast_or_aux1_descends) || ((in_liquid || in_liquid_stable) && fast_or_aux1_descends))
+		speedH = speedH.normalize() * movement_speed_fast;
+	else if(control.sneak && !free_move && !in_liquid && !in_liquid_stable)
+		speedH = speedH.normalize() * movement_speed_crouch;
 	else
-		speed = speed.normalize() * walkspeed_max;
-	
-	f32 inc = walk_acceleration * BS * dtime;
-	
-	// Faster acceleration if fast and free movement
-	if(free_move && fast_move && superspeed)
-		inc = walk_acceleration * BS * dtime * 10;
-	
+		speedH = speedH.normalize() * movement_speed_walk;
+
+	// Acceleration increase
+	f32 incH = 0; // Horizontal (X, Z)
+	f32 incV = 0; // Vertical (Y)
+	if((!touching_ground && !free_move && !is_climbing && !in_liquid) || (!free_move && m_can_jump && control.jump))
+	{
+		// Jumping and falling
+		if(superspeed || (fast_move && control.aux1))
+			incH = movement_acceleration_fast * BS * dtime;
+		else
+			incH = movement_acceleration_air * BS * dtime;
+		incV = 0; // No vertical acceleration in air
+	}
+	else if(superspeed || (fast_move && control.aux1))
+		incH = incV = movement_acceleration_fast * BS * dtime;
+	else if ((in_liquid || in_liquid_stable) && fast_or_aux1_descends)
+		// Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict
+		incH = incV = movement_acceleration_fast * BS * dtime;
+	else
+		incH = incV = movement_acceleration_default * BS * dtime;
+
 	// Accelerate to target speed with maximum increment
-	accelerate(speed, inc);
+	accelerateHorizontal(speedH, incH);
+	accelerateVertical(speedV, incV);
 }
 
 v3s16 LocalPlayer::getStandingNodePos()
diff --git a/src/localplayer.h b/src/localplayer.h
index c9d010d7c..f372c787d 100644
--- a/src/localplayer.h
+++ b/src/localplayer.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/log.cpp b/src/log.cpp
index 78fa32026..366d83b64 100644
--- a/src/log.cpp
+++ b/src/log.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/log.h b/src/log.h
index 012e7e938..7d8b60b71 100644
--- a/src/log.h
+++ b/src/log.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/logoutputbuffer.h b/src/logoutputbuffer.h
index 1fb155aae..69f06c444 100644
--- a/src/logoutputbuffer.h
+++ b/src/logoutputbuffer.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/luaentity_common.h b/src/luaentity_common.h
index 74dd046cb..35b079ade 100644
--- a/src/luaentity_common.h
+++ b/src/luaentity_common.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/main.cpp b/src/main.cpp
index 6f4095148..cfd643ac7 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -68,6 +68,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "profiler.h"
 #include "log.h"
 #include "mods.h"
+#if USE_FREETYPE
+#include "xCGUITTFont.h"
+#endif
 #include "util/string.h"
 #include "subgame.h"
 #include "quicktune.h"
@@ -767,11 +770,19 @@ int main(int argc, char *argv[])
 
 	log_register_thread("main");
 
-	// Set locale. This is for forcing '.' as the decimal point.
-	std::locale::global(std::locale("C"));
-	// This enables printing all characters in bitmap font
-	setlocale(LC_CTYPE, "en_US");
+	// This enables internatonal characters input
+	if( setlocale(LC_ALL, "") == NULL )
+	{
+		fprintf( stderr, "%s: warning: could not set default locale\n", argv[0] );
+	}
 
+	// Set locale. This is for forcing '.' as the decimal point.
+	try {
+		std::locale::global(std::locale(std::locale(""), "C", std::locale::numeric));
+		setlocale(LC_NUMERIC, "C");
+	} catch (const std::exception& ex) {
+		errorstream<<"Could not set numeric locale to C"<<std::endl;
+	}
 	/*
 		Parse command line
 	*/
@@ -875,23 +886,8 @@ int main(int argc, char *argv[])
 	// Create user data directory
 	fs::CreateDir(porting::path_user);
 
-	init_gettext((porting::path_share+DIR_DELIM+".."+DIR_DELIM+"locale").c_str());
-	
-	// Initialize debug streams
-#define DEBUGFILE "debug.txt"
-#if RUN_IN_PLACE
-	std::string logfile = DEBUGFILE;
-#else
-	std::string logfile = porting::path_user+DIR_DELIM+DEBUGFILE;
-#endif
-	if(cmd_args.exists("logfile"))
-		logfile = cmd_args.get("logfile");
-	if(logfile != "")
-		debugstreams_init(false, logfile.c_str());
-	else
-		debugstreams_init(false, NULL);
+	init_gettext((porting::path_share + DIR_DELIM + "locale").c_str());
 
-	infostream<<"logfile    = "<<logfile<<std::endl;
 	infostream<<"path_share = "<<porting::path_share<<std::endl;
 	infostream<<"path_user  = "<<porting::path_user<<std::endl;
 
@@ -984,6 +980,31 @@ int main(int argc, char *argv[])
 		if(configpath == "")
 			configpath = filenames[0];
 	}
+	
+	// Initialize debug streams
+#define DEBUGFILE "debug.txt"
+#if RUN_IN_PLACE
+	std::string logfile = DEBUGFILE;
+#else
+	std::string logfile = porting::path_user+DIR_DELIM+DEBUGFILE;
+#endif
+	if(cmd_args.exists("logfile"))
+		logfile = cmd_args.get("logfile");
+	
+	log_remove_output(&main_dstream_no_stderr_log_out);
+	int loglevel = g_settings->getS32("debug_log_level");
+
+	if (loglevel == 0) //no logging
+		logfile = "";
+	else if (loglevel > 0 && loglevel <= LMT_NUM_VALUES)
+		log_add_output_maxlev(&main_dstream_no_stderr_log_out, (LogMessageLevel)(loglevel - 1));
+
+	if(logfile != "")
+		debugstreams_init(false, logfile.c_str());
+	else
+		debugstreams_init(false, NULL);
+		
+	infostream<<"logfile    = "<<logfile<<std::endl;
 
 	// Initialize random seed
 	srand(time(0));
@@ -1084,6 +1105,7 @@ int main(int argc, char *argv[])
 #else
 	bool run_dedicated_server = cmd_args.getFlag("server");
 #endif
+	g_settings->set("server_dedicated", run_dedicated_server ? "true" : "false");
 	if(run_dedicated_server)
 	{
 		DSTACK("Dedicated server branch");
@@ -1329,7 +1351,13 @@ int main(int argc, char *argv[])
 
 	guienv = device->getGUIEnvironment();
 	gui::IGUISkin* skin = guienv->getSkin();
+	#if USE_FREETYPE
+	std::string font_path = g_settings->get("font_path");
+	u16 font_size = g_settings->getU16("font_size");
+	gui::IGUIFont *font = gui::CGUITTFont::createTTFont(guienv, font_path.c_str(), font_size);
+	#else
 	gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
+	#endif
 	if(font)
 		skin->setFont(font);
 	else
@@ -1453,6 +1481,7 @@ int main(int argc, char *argv[])
 				driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, menudata.mip_map);
 				menudata.creative_mode = g_settings->getBool("creative_mode");
 				menudata.enable_damage = g_settings->getBool("enable_damage");
+				menudata.enable_public = g_settings->getBool("server_announce");
 				// Default to selecting nothing
 				menudata.selected_world = -1;
 				// Get world listing for the menu
@@ -1576,6 +1605,7 @@ int main(int argc, char *argv[])
 
 				g_settings->set("creative_mode", itos(menudata.creative_mode));
 				g_settings->set("enable_damage", itos(menudata.enable_damage));
+				g_settings->set("server_announce", itos(menudata.enable_public));
 				g_settings->set("name", playername);
 				g_settings->set("address", address);
 				g_settings->set("port", itos(port));
@@ -1602,10 +1632,10 @@ int main(int argc, char *argv[])
 				else if (address != "")
 				{
 					ServerListSpec server;
-					server.name = menudata.servername;
-					server.address = wide_to_narrow(menudata.address);
-					server.port = wide_to_narrow(menudata.port);
-					server.description = menudata.serverdescription;
+					server["name"] = menudata.servername;
+					server["address"] = wide_to_narrow(menudata.address);
+					server["port"] = wide_to_narrow(menudata.port);
+					server["description"] = menudata.serverdescription;
 					ServerList::insert(server);
 				}
 				
diff --git a/src/main.h b/src/main.h
index a169a45dc..daa8c70d2 100644
--- a/src/main.h
+++ b/src/main.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mainmenumanager.h b/src/mainmenumanager.h
index a37a8300f..ce7684f11 100644
--- a/src/mainmenumanager.h
+++ b/src/mainmenumanager.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -94,6 +94,7 @@ public:
 	MainGameCallback(IrrlichtDevice *a_device):
 		disconnect_requested(false),
 		changepassword_requested(false),
+		changevolume_requested(false),
 		device(a_device)
 	{
 	}
@@ -113,8 +114,14 @@ public:
 		changepassword_requested = true;
 	}
 
+	virtual void changeVolume()
+	{
+		changevolume_requested = true;
+	}
+	
 	bool disconnect_requested;
 	bool changepassword_requested;
+	bool changevolume_requested;
 	IrrlichtDevice *device;
 };
 
diff --git a/src/map.cpp b/src/map.cpp
index 717b0cf9b..4be094326 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -33,6 +33,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "gamedef.h"
 #include "util/directiontables.h"
 #include "rollback_interface.h"
+#include "emerge.h"
 #include "mapgen_v6.h"
 
 #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
@@ -1613,10 +1614,322 @@ struct NodeNeighbor {
 	MapNode n;
 	NeighborType t;
 	v3s16 p;
+	bool l; //can liquid
+	bool i; //infinity
 };
 
+void Map::transforming_liquid_add(v3s16 p) {
+        m_transforming_liquid.push_back(p);
+}
+
+s32 Map::transforming_liquid_size() {
+        return m_transforming_liquid.size();
+}
+
+const v3s16 g_7dirs[7] =
+{
+	// +right, +top, +back
+	v3s16( 0,-1, 0), // bottom
+	v3s16( 0, 0, 0), // self
+	v3s16( 0, 0, 1), // back
+	v3s16( 0, 0,-1), // front
+	v3s16( 1, 0, 0), // right
+	v3s16(-1, 0, 0), // left
+	v3s16( 0, 1, 0)  // top
+};
+
+#define D_BOTTOM 0
+#define D_TOP 6
+#define D_SELF 1
+
+void Map::transformLiquidsFinite(core::map<v3s16, MapBlock*> & modified_blocks)
+{
+	INodeDefManager *nodemgr = m_gamedef->ndef();
+
+	DSTACK(__FUNCTION_NAME);
+	//TimeTaker timer("transformLiquids()");
+
+	u32 loopcount = 0;
+	u32 initial_size = m_transforming_liquid.size();
+
+	u8 relax = g_settings->getS16("liquid_relax");
+	bool fast_flood = g_settings->getS16("liquid_fast_flood");
+	int water_level = g_settings->getS16("water_level");
+
+	/*if(initial_size != 0)
+		infostream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
+
+	// list of nodes that due to viscosity have not reached their max level height
+	UniqueQueue<v3s16> must_reflow, must_reflow_second;
+
+	// List of MapBlocks that will require a lighting update (due to lava)
+	core::map<v3s16, MapBlock*> lighting_modified_blocks;
+
+	while(m_transforming_liquid.size() > 0)
+	{
+		// This should be done here so that it is done when continue is used
+		if(loopcount >= initial_size || loopcount >= 1000)
+			break;
+		loopcount++;
+		/*
+			Get a queued transforming liquid node
+		*/
+		v3s16 p0 = m_transforming_liquid.pop_front();
+		u16 total_level = 0;
+		NodeNeighbor neighbors[7]; // surrounding flowing liquid nodes
+		s8 liquid_levels[7]      = {-1, -1, -1, -1, -1, -1, -1}; // current level of every block
+		s8 liquid_levels_want[7] = {-1, -1, -1, -1, -1, -1, -1}; // target levels
+		s8 can_liquid_same_level = 0;
+		content_t liquid_kind = CONTENT_IGNORE;
+		content_t liquid_kind_flowing = CONTENT_IGNORE;
+		/*
+			Collect information about the environment
+		 */
+		const v3s16 *dirs = g_7dirs;
+		for (u16 i = 0; i < 7; i++) {
+			NeighborType nt = NEIGHBOR_SAME_LEVEL;
+			switch (i) {
+				case D_TOP:
+					nt = NEIGHBOR_UPPER;
+					break;
+				case D_BOTTOM:
+					nt = NEIGHBOR_LOWER;
+					break;
+			}
+			v3s16 npos = p0 + dirs[i];
+
+			neighbors[i].n = getNodeNoEx(npos);
+			neighbors[i].t = nt;
+			neighbors[i].p = npos;
+			neighbors[i].l = 0;
+			neighbors[i].i = 0;
+			NodeNeighbor & nb = neighbors[i];
+
+			switch (nodemgr->get(nb.n.getContent()).liquid_type) {
+				case LIQUID_NONE:
+					if (nb.n.getContent() == CONTENT_AIR) {
+						liquid_levels[i] = 0;
+						nb.l = 1;
+					}
+					break;
+				case LIQUID_SOURCE:
+					// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
+					if (liquid_kind_flowing == CONTENT_IGNORE)
+						liquid_kind_flowing = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing);
+					if (liquid_kind == CONTENT_IGNORE)
+						liquid_kind = nb.n.getContent();
+					if (nb.n.getContent() == liquid_kind) {
+						liquid_levels[i] = LIQUID_LEVEL_SOURCE;
+						nb.l = 1;
+						nb.i = (nb.n.param2 & LIQUID_INFINITY_MASK);
+					}
+					break;
+				case LIQUID_FLOWING:
+					// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
+					if (liquid_kind_flowing == CONTENT_IGNORE)
+						liquid_kind_flowing = nb.n.getContent();
+					if (liquid_kind == CONTENT_IGNORE)
+						liquid_kind = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_source);
+					if (nb.n.getContent() == liquid_kind_flowing) {
+						liquid_levels[i] = (nb.n.param2 & LIQUID_LEVEL_MASK);
+						nb.l = 1;
+					}
+					break;
+			}
+			if (nb.l && nb.t == NEIGHBOR_SAME_LEVEL) ++can_liquid_same_level;
+			if (liquid_levels[i] > 0) total_level += liquid_levels[i];
+
+			/*
+			infostream << "get node i=" <<(int)i<<" " << PP(npos) << " c="<<nb.n.getContent() <<" p0="<< (int)nb.n.param0 <<" p1="<< (int)nb.n.param1 <<" p2="<< (int)nb.n.param2 << " lt="<<nodemgr->get(nb.n.getContent()).liquid_type
+			//<< " lk=" << liquid_kind << " lkf=" << liquid_kind_flowing
+			<< " l="<< nb.l	<< " inf="<< nb.i << " nlevel=" <<  (int)liquid_levels[i] << " tlevel=" << (int)total_level << " cansame="<<(int)can_liquid_same_level<<std::endl;
+			*/
+		}
+
+		if (liquid_kind == CONTENT_IGNORE || !neighbors[D_SELF].l || total_level <= 0)
+			continue;
+
+		// fill bottom block
+		if (neighbors[D_BOTTOM].l) {
+			liquid_levels_want[D_BOTTOM] = total_level > LIQUID_LEVEL_SOURCE ? LIQUID_LEVEL_SOURCE : total_level;
+			total_level -= liquid_levels_want[D_BOTTOM];
+		}
+
+		if (relax && p0.Y <= water_level && liquid_levels[D_TOP] == 0 && total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level - can_liquid_same_level + 2 && can_liquid_same_level >= relax + 1) { //relax up
+			total_level = LIQUID_LEVEL_SOURCE * can_liquid_same_level; 
+		}
+
+		// calculate self level 5 blocks
+		u8 want_level = 
+			  total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level
+			? LIQUID_LEVEL_SOURCE 
+			: total_level / can_liquid_same_level;
+		total_level -= want_level * can_liquid_same_level;
+
+		if (relax && p0.Y > water_level && liquid_levels[D_TOP] == 0 && liquid_levels[D_BOTTOM] == LIQUID_LEVEL_SOURCE && want_level == 0 && total_level <= can_liquid_same_level - 2 && can_liquid_same_level >= relax + 1) { //relax down
+			total_level = 0;
+		}
+
+		for (u16 ii = D_SELF; ii < D_TOP; ++ii) { // fill only same level
+			if (!neighbors[ii].l)
+				continue;
+			liquid_levels_want[ii] = want_level;
+			if (liquid_levels_want[ii] < LIQUID_LEVEL_SOURCE && total_level > 0
+				&& liquid_levels[ii] > liquid_levels_want[ii]
+				) {
+				++liquid_levels_want[ii];
+				--total_level;
+			}
+		}
+
+		for (u16 ii = 0; ii < 7; ++ii) {
+			if (total_level < 1) break;
+			if (liquid_levels_want[ii] >= 0 && liquid_levels_want[ii] < LIQUID_LEVEL_SOURCE) {
+				++liquid_levels_want[ii];
+				--total_level;
+			}
+		}
+
+		// fill top block if can
+		if (neighbors[D_TOP].l) {
+			liquid_levels_want[D_TOP] = total_level > LIQUID_LEVEL_SOURCE ? LIQUID_LEVEL_SOURCE : total_level ;
+			total_level -= liquid_levels_want[D_TOP];
+		}
+
+		for (u16 ii = 0; ii < 7; ii++) // infinity and cave flood optimization
+			if (liquid_levels_want[ii] >= 0 &&
+				(neighbors[ii].i ||
+				 (fast_flood && p0.Y < water_level &&
+				  (initial_size >= 1000
+				   && ii != D_TOP
+				   && want_level >= LIQUID_LEVEL_SOURCE/4
+				   && can_liquid_same_level >= 5
+				   && liquid_levels[D_TOP] >= LIQUID_LEVEL_SOURCE))))
+				liquid_levels_want[ii] = LIQUID_LEVEL_SOURCE;
+
+		//if (total_level > 0 /*|| flowed != volume*/) infostream <<" AFTER level=" << (int)total_level /*<< " flowed="<<flowed<< " volume=" <<volume*/<< " wantsame="<<(int)want_level<< " top="<< (int)liquid_levels_want[D_TOP]<< " topwas="<< (int)liquid_levels[D_TOP]<< " bot="<< (int)liquid_levels_want[D_BOTTOM]<<std::endl;
+
+		u8 changed = 0;
+		for (u16 i = 0; i < 7; i++) {
+			if (liquid_levels_want[i] < 0 || !neighbors[i].l) 
+				continue;
+			MapNode & n0 = neighbors[i].n;
+			p0 = neighbors[i].p;
+			/*
+				decide on the type (and possibly level) of the current node
+			*/
+			content_t new_node_content;
+			s8 new_node_level = -1;
+			u8 viscosity = nodemgr->get(liquid_kind).liquid_viscosity;
+			if (viscosity > 1 && liquid_levels_want[i] != liquid_levels[i]) {
+				// amount to gain, limited by viscosity
+				// must be at least 1 in absolute value
+				s8 level_inc = liquid_levels_want[i] - liquid_levels[i];
+				if (level_inc < -viscosity || level_inc > viscosity)
+					new_node_level = liquid_levels[i] + level_inc/viscosity;
+				else if (level_inc < 0)
+					new_node_level = liquid_levels[i] - 1;
+				else if (level_inc > 0)
+					new_node_level = liquid_levels[i] + 1;
+			} else
+				new_node_level = liquid_levels_want[i];
+			if (new_node_level >= LIQUID_LEVEL_SOURCE)
+				new_node_content = liquid_kind;
+			else if (new_node_level > 0)
+				new_node_content = liquid_kind_flowing;
+			else
+				new_node_content = CONTENT_AIR;
+
+			// last level must flow down on stairs
+			if (liquid_levels_want[i] != liquid_levels[i] && liquid_levels[D_TOP] <= 0 && !neighbors[D_BOTTOM].l && new_node_level >= 1 && new_node_level <= 2) //maybe == 1 // 
+				for (u16 ii = D_SELF + 1; ii < D_TOP; ++ii) { // only same level
+				if (!neighbors[ii].l)
+					continue;
+				must_reflow_second.push_back(p0 + dirs[ii]);
+			}
+
+			/*
+				check if anything has changed. if not, just continue with the next node.
+			 */
+			if (
+				 new_node_content == n0.getContent() 
+				&& (nodemgr->get(n0.getContent()).liquid_type != LIQUID_FLOWING ||
+				 ((n0.param2 & LIQUID_LEVEL_MASK) == (u8)new_node_level 
+				 // &&((n0.param2 & LIQUID_FLOW_DOWN_MASK) == LIQUID_FLOW_DOWN_MASK)== flowing_down
+				 ))
+				&&
+				 (nodemgr->get(n0.getContent()).liquid_type != LIQUID_SOURCE ||
+				 (((n0.param2 & LIQUID_INFINITY_MASK) == LIQUID_INFINITY_MASK) == neighbors[i].i
+				 ))
+			   ) {
+				continue;
+			}
+			++changed;
+
+			/*
+				update the current node
+			 */
+			if (nodemgr->get(new_node_content).liquid_type == LIQUID_FLOWING) {
+				// set level to last 3 bits, flowing down bit to 4th bit
+				n0.param2 = (new_node_level & LIQUID_LEVEL_MASK);
+			} else if (nodemgr->get(new_node_content).liquid_type == LIQUID_SOURCE) {
+				//n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
+				n0.param2 = (neighbors[i].i ? LIQUID_INFINITY_MASK : 0x00);
+			}
+			//infostream << "set node i=" <<(int)i<<" "<< PP(p0)<< " nc="<<new_node_content<< " p2="<<(int)n0.param2<< " nl="<<(int)new_node_level<<std::endl;
+			n0.setContent(new_node_content);
+			// Find out whether there is a suspect for this action
+			std::string suspect;
+			if(m_gamedef->rollback()){
+				suspect = m_gamedef->rollback()->getSuspect(p0, 83, 1);
+			}
+
+			if(!suspect.empty()){
+				// Blame suspect
+				RollbackScopeActor rollback_scope(m_gamedef->rollback(), suspect, true);
+				// Get old node for rollback
+				RollbackNode rollback_oldnode(this, p0, m_gamedef);
+				// Set node
+				setNode(p0, n0);
+				// Report
+				RollbackNode rollback_newnode(this, p0, m_gamedef);
+				RollbackAction action;
+				action.setSetNode(p0, rollback_oldnode, rollback_newnode);
+				m_gamedef->rollback()->reportAction(action);
+			} else {
+				// Set node
+				setNode(p0, n0);
+			}
+
+			v3s16 blockpos = getNodeBlockPos(p0);
+			MapBlock *block = getBlockNoCreateNoEx(blockpos);
+			if(block != NULL) {
+				modified_blocks.insert(blockpos, block);
+				// If node emits light, MapBlock requires lighting update
+				if(nodemgr->get(n0).light_source != 0)
+					lighting_modified_blocks[block->getPos()] = block;
+			}
+			must_reflow.push_back(neighbors[i].p);
+		}
+		/* //for better relax
+		if (changed)  for (u16 ii = D_SELF + 1; ii < D_TOP; ++ii) { // only same level
+			if (!neighbors[ii].l) continue;
+			must_reflow.push_back(p0 + dirs[ii]);
+		}*/
+	}
+	//if (loopcount) infostream<<"Map::transformLiquids(): loopcount="<<loopcount<<" reflow="<<must_reflow.size()<<" queue="<< m_transforming_liquid.size()<<std::endl;
+	while (must_reflow.size() > 0)
+		m_transforming_liquid.push_back(must_reflow.pop_front());
+	while (must_reflow_second.size() > 0)
+		m_transforming_liquid.push_back(must_reflow_second.pop_front());
+	updateLighting(lighting_modified_blocks, modified_blocks);
+}
+
 void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
 {
+
+	if (g_settings->getBool("liquid_finite")) return Map::transformLiquidsFinite(modified_blocks);
+	
 	INodeDefManager *nodemgr = m_gamedef->ndef();
 
 	DSTACK(__FUNCTION_NAME);
@@ -2008,7 +2321,7 @@ ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emer
 	m_mgparams = m_emerge->getParamsFromSettings(g_settings);
 	if (!m_mgparams)
 		m_mgparams = new MapgenV6Params();
-		
+
 	m_seed = m_mgparams->seed;
 
 	if (g_settings->get("fixed_map_seed").empty())
@@ -2142,14 +2455,10 @@ ServerMap::~ServerMap()
 #endif
 }
 
-void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
+bool ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
 {
-	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
-	if(enable_mapgen_debug_info)
-		infostream<<"initBlockMake(): "
-				<<"("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<") - "
-				<<"("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
-				<<std::endl;
+	bool enable_mapgen_debug_info = m_emerge->mapgen_debug_info;
+	EMERGE_DBG_OUT("initBlockMake(): " PP(blockpos) " - " PP(blockpos));
 
 	//s16 chunksize = 3;
 	//v3s16 chunk_offset(-1,-1,-1);
@@ -2169,12 +2478,8 @@ void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
 	// Do nothing if not inside limits (+-1 because of neighbors)
 	if(blockpos_over_limit(blockpos_min - extra_borders) ||
 		blockpos_over_limit(blockpos_max + extra_borders))
-	{
-		data->no_op = true;
-		return;
-	}
+		return false;
 
-	data->no_op = false;
 	data->seed = m_seed;
 	data->blockpos_min = blockpos_min;
 	data->blockpos_max = blockpos_max;
@@ -2245,8 +2550,24 @@ void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
 		//TimeTaker timer("initBlockMake() initialEmerge");
 		data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
 	}
+	
+	// Ensure none of the blocks to be generated were marked as containing CONTENT_IGNORE
+/*	for (s16 z = blockpos_min.Z; z <= blockpos_max.Z; z++) {
+		for (s16 y = blockpos_min.Y; y <= blockpos_max.Y; y++) {
+			for (s16 x = blockpos_min.X; x <= blockpos_max.X; x++) {
+				core::map<v3s16, u8>::Node *n;
+				n = data->vmanip->m_loaded_blocks.find(v3s16(x, y, z));
+				if (n == NULL)
+					continue;
+				u8 flags = n->getValue();
+				flags &= ~VMANIP_BLOCK_CONTAINS_CIGNORE;
+				n->setValue(flags);
+			}
+		}
+	}*/
 
 	// Data is ready now.
+	return true;
 }
 
 MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
@@ -2261,13 +2582,7 @@ MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
 
 	v3s16 extra_borders(1,1,1);
 
-	if(data->no_op)
-	{
-		//infostream<<"finishBlockMake(): no-op"<<std::endl;
-		return NULL;
-	}
-
-	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
+	bool enable_mapgen_debug_info = m_emerge->mapgen_debug_info;
 
 	/*infostream<<"Resulting vmanip:"<<std::endl;
 	data->vmanip.print(infostream);*/
@@ -2295,9 +2610,7 @@ MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
 		data->vmanip->blitBackAll(&changed_blocks);
 	}
 
-	if(enable_mapgen_debug_info)
-		infostream<<"finishBlockMake: changed_blocks.size()="
-				<<changed_blocks.size()<<std::endl;
+	EMERGE_DBG_OUT("finishBlockMake: changed_blocks.size()=" << changed_blocks.size());
 
 	/*
 		Copy transforming liquid information
@@ -2970,7 +3283,7 @@ void ServerMap::save(ModifiedState save_level)
 
 			block_count_all++;
 
-			if(block->getModified() >= save_level)
+			if(block->getModified() >= (u32)save_level)
 			{
 				// Lazy beginSave()
 				if(!save_started){
@@ -3671,8 +3984,10 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 	for(s32 y=p_min.Y; y<=p_max.Y; y++)
 	for(s32 x=p_min.X; x<=p_max.X; x++)
 	{
+		u8 flags = 0;
+		MapBlock *block;
 		v3s16 p(x,y,z);
-		core::map<v3s16, bool>::Node *n;
+		core::map<v3s16, u8>::Node *n;
 		n = m_loaded_blocks.find(p);
 		if(n != NULL)
 			continue;
@@ -3688,7 +4003,7 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 			a.print(infostream);
 			infostream<<std::endl;*/
 
-			MapBlock *block = m_map->getBlockNoCreate(p);
+			block = m_map->getBlockNoCreate(p);
 			if(block->isDummy())
 				block_data_inexistent = true;
 			else
@@ -3701,6 +4016,8 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 
 		if(block_data_inexistent)
 		{
+			flags |= VMANIP_BLOCK_DATA_INEXIST;
+			
 			VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
 			// Fill with VOXELFLAG_INEXISTENT
 			for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
@@ -3710,8 +4027,13 @@ void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
 				memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
 			}
 		}
+		/*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
+		{
+			// Mark that block was loaded as blank
+			flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
+		}*/
 
-		m_loaded_blocks.insert(p, !block_data_inexistent);
+		m_loaded_blocks.insert(p, flags);
 	}
 
 	//infostream<<"emerge done"<<std::endl;
@@ -3831,8 +4153,10 @@ void ManualMapVoxelManipulator::initialEmerge(
 	for(s32 y=p_min.Y; y<=p_max.Y; y++)
 	for(s32 x=p_min.X; x<=p_max.X; x++)
 	{
+		u8 flags = 0;
+		MapBlock *block;
 		v3s16 p(x,y,z);
-		core::map<v3s16, bool>::Node *n;
+		core::map<v3s16, u8>::Node *n;
 		n = m_loaded_blocks.find(p);
 		if(n != NULL)
 			continue;
@@ -3842,7 +4166,7 @@ void ManualMapVoxelManipulator::initialEmerge(
 		{
 			TimeTaker timer1("emerge load", &emerge_load_time);
 
-			MapBlock *block = m_map->getBlockNoCreate(p);
+			block = m_map->getBlockNoCreate(p);
 			if(block->isDummy())
 				block_data_inexistent = true;
 			else
@@ -3855,6 +4179,8 @@ void ManualMapVoxelManipulator::initialEmerge(
 
 		if(block_data_inexistent)
 		{
+			flags |= VMANIP_BLOCK_DATA_INEXIST;
+			
 			/*
 				Mark area inexistent
 			*/
@@ -3867,8 +4193,13 @@ void ManualMapVoxelManipulator::initialEmerge(
 				memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
 			}
 		}
+		/*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
+		{
+			// Mark that block was loaded as blank
+			flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
+		}*/
 
-		m_loaded_blocks.insert(p, !block_data_inexistent);
+		m_loaded_blocks.insert(p, flags);
 	}
 }
 
@@ -3881,12 +4212,14 @@ void ManualMapVoxelManipulator::blitBackAll(
 	/*
 		Copy data of all blocks
 	*/
-	for(core::map<v3s16, bool>::Iterator
+	for(core::map<v3s16, u8>::Iterator
 			i = m_loaded_blocks.getIterator();
 			i.atEnd() == false; i++)
 	{
 		v3s16 p = i.getNode()->getKey();
-		bool existed = i.getNode()->getValue();
+		u8 flags = i.getNode()->getValue();
+		
+		bool existed = !(flags & VMANIP_BLOCK_DATA_INEXIST);
 		if(existed == false)
 		{
 			// The Great Bug was found using this
@@ -3895,6 +4228,7 @@ void ManualMapVoxelManipulator::blitBackAll(
 					<<std::endl;*/
 			continue;
 		}
+		
 		MapBlock *block = m_map->getBlockNoCreateNoEx(p);
 		if(block == NULL)
 		{
@@ -3906,7 +4240,7 @@ void ManualMapVoxelManipulator::blitBackAll(
 		}
 
 		block->copyFrom(*this);
-
+		
 		if(modified_blocks)
 			modified_blocks->insert(p, block);
 	}
diff --git a/src/map.h b/src/map.h
index 420fc29ca..d356da2d1 100644
--- a/src/map.h
+++ b/src/map.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -46,6 +46,8 @@ class MapBlock;
 class NodeMetadata;
 class IGameDef;
 class IRollbackReportSink;
+class EmergeManager;
+class BlockMakeData;
 
 
 /*
@@ -300,6 +302,7 @@ public:
 	virtual void PrintInfo(std::ostream &out);
 
 	void transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks);
+	void transformLiquidsFinite(core::map<v3s16, MapBlock*> & modified_blocks);
 
 	/*
 		Node metadata
@@ -328,6 +331,9 @@ public:
 		Variables
 	*/
 
+	void transforming_liquid_add(v3s16 p);
+	s32 transforming_liquid_size();
+
 protected:
 
 	std::ostream &m_dout; // A bit deprecated, could be removed
@@ -377,8 +383,8 @@ public:
 	/*
 		Blocks are generated by using these and makeBlock().
 	*/
-	void initBlockMake(BlockMakeData *data, v3s16 blockpos);
-	MapBlock* finishBlockMake(BlockMakeData *data,
+	bool initBlockMake(BlockMakeData *data, v3s16 blockpos);
+	MapBlock *finishBlockMake(BlockMakeData *data,
 			core::map<v3s16, MapBlock*> &changed_blocks);
 
 	// A non-threaded wrapper to the above  - DEFUNCT
@@ -515,6 +521,9 @@ private:
 	sqlite3_stmt *m_database_list;
 };
 
+#define VMANIP_BLOCK_DATA_INEXIST     1
+#define VMANIP_BLOCK_CONTAINS_CIGNORE 2
+
 class MapVoxelManipulator : public VoxelManipulator
 {
 public:
@@ -530,14 +539,14 @@ public:
 	virtual void emerge(VoxelArea a, s32 caller_id=-1);
 
 	void blitBack(core::map<v3s16, MapBlock*> & modified_blocks);
-
-protected:
-	Map *m_map;
+	
 	/*
 		key = blockpos
-		value = block existed when loaded
+		value = flags describing the block
 	*/
-	core::map<v3s16, bool> m_loaded_blocks;
+	core::map<v3s16, u8> m_loaded_blocks;
+protected:
+	Map *m_map;
 };
 
 class ManualMapVoxelManipulator : public MapVoxelManipulator
diff --git a/src/mapblock.cpp b/src/mapblock.cpp
index e9c8fadff..a6e9b3951 100644
--- a/src/mapblock.cpp
+++ b/src/mapblock.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapblock.h b/src/mapblock.h
index d56d93dda..692b54318 100644
--- a/src/mapblock.h
+++ b/src/mapblock.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapblock_mesh.cpp b/src/mapblock_mesh.cpp
index daebbe217..f4d57922a 100644
--- a/src/mapblock_mesh.cpp
+++ b/src/mapblock_mesh.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapblock_mesh.h b/src/mapblock_mesh.h
index c23b6cc5a..5b33990c6 100644
--- a/src/mapblock_mesh.h
+++ b/src/mapblock_mesh.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapchunk.h b/src/mapchunk.h
index 6b7a411d7..a70de8711 100644
--- a/src/mapchunk.h
+++ b/src/mapchunk.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapgen.cpp b/src/mapgen.cpp
index b19073e90..ef5da6bf1 100644
--- a/src/mapgen.cpp
+++ b/src/mapgen.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -46,144 +46,6 @@ FlagDesc flagdesc_mapgen[] = {
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-/////////////////////////////// Emerge Manager ////////////////////////////////
-
-
-EmergeManager::EmergeManager(IGameDef *gamedef, BiomeDefManager *bdef) {
-	//register built-in mapgens
-	registerMapgen("v6", new MapgenFactoryV6());
-		
-	//the order of these assignments is pretty important
-	this->biomedef = bdef ? bdef : new BiomeDefManager(gamedef);
-	this->params   = NULL;
-	this->mapgen   = NULL;
-}
-
-
-EmergeManager::~EmergeManager() {
-	delete biomedef;
-	delete mapgen;
-	delete params;
-}
-
-
-void EmergeManager::initMapgens(MapgenParams *mgparams) {
-	if (mapgen)
-		return;
-	
-	this->params = mgparams;
-	this->mapgen = getMapgen(); //only one mapgen for now!
-}
-
-
-Mapgen *EmergeManager::getMapgen() {
-	if (!mapgen) {
-		mapgen = createMapgen(params->mg_name, 0, params, this);
-		if (!mapgen) {
-			infostream << "EmergeManager: falling back to mapgen v6" << std::endl;
-			delete params;
-			params = createMapgenParams("v6");
-			mapgen = createMapgen("v6", 0, params, this);
-		}
-	}
-	return mapgen;
-}
-
-void EmergeManager::addBlockToQueue() {
-	//STUB
-}
-
-
-int EmergeManager::getGroundLevelAtPoint(v2s16 p) {
-	if (!mapgen)
-		return 0;
-	return mapgen->getGroundLevelAtPoint(p);
-}
-
-
-bool EmergeManager::isBlockUnderground(v3s16 blockpos) {
-	/*
-	v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
-					(blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
-	int ground_level = getGroundLevelAtPoint(p);
-	return blockpos.Y * (MAP_BLOCKSIZE + 1) <= min(water_level, ground_level);
-	*/
-
-	//yuck, but then again, should i bother being accurate?
-	//the height of the nodes in a single block is quite variable
-	return blockpos.Y * (MAP_BLOCKSIZE + 1) <= params->water_level;
-}
-
-
-u32 EmergeManager::getBlockSeed(v3s16 p) {
-	return (u32)(params->seed & 0xFFFFFFFF) +
-		p.Z * 38134234 +
-		p.Y * 42123 +
-		p.Y * 23;
-}
-
-
-Mapgen *EmergeManager::createMapgen(std::string mgname, int mgid,
-									MapgenParams *mgparams, EmergeManager *emerge) {
-	std::map<std::string, MapgenFactory *>::const_iterator iter = mglist.find(mgname);
-	if (iter == mglist.end()) {
-		errorstream << "EmergeManager; mapgen " << mgname <<
-		 " not registered" << std::endl;
-		return NULL;
-	}
-	
-	MapgenFactory *mgfactory = iter->second;
-	return mgfactory->createMapgen(mgid, mgparams, emerge);
-}
-
-
-MapgenParams *EmergeManager::createMapgenParams(std::string mgname) {
-	std::map<std::string, MapgenFactory *>::const_iterator iter = mglist.find(mgname);
-	if (iter == mglist.end()) {
-		errorstream << "EmergeManager: mapgen " << mgname <<
-		 " not registered" << std::endl;
-		return NULL;
-	}
-	
-	MapgenFactory *mgfactory = iter->second;
-	return mgfactory->createMapgenParams();
-}
-
-
-MapgenParams *EmergeManager::getParamsFromSettings(Settings *settings) {
-	std::string mg_name = settings->get("mg_name");
-	MapgenParams *mgparams = createMapgenParams(mg_name);
-	
-	mgparams->mg_name     = mg_name;
-	mgparams->seed        = settings->getU64(settings == g_settings ? "fixed_map_seed" : "seed");
-	mgparams->water_level = settings->getS16("water_level");
-	mgparams->chunksize   = settings->getS16("chunksize");
-	mgparams->flags       = settings->getFlagStr("mg_flags", flagdesc_mapgen);
-
-	if (!mgparams->readParams(settings)) {
-		delete mgparams;
-		return NULL;
-	}
-	return mgparams;
-}
-
-
-void EmergeManager::setParamsToSettings(Settings *settings) {
-	settings->set("mg_name",         params->mg_name);
-	settings->setU64("seed",         params->seed);
-	settings->setS16("water_level",  params->water_level);
-	settings->setS16("chunksize",    params->chunksize);
-	settings->setFlagStr("mg_flags", params->flags, flagdesc_mapgen);
-
-	params->writeParams(settings);
-}
-
-
-void EmergeManager::registerMapgen(std::string mgname, MapgenFactory *mgfactory) {
-	mglist.insert(std::make_pair(mgname, mgfactory));
-	infostream << "EmergeManager: registered mapgen " << mgname << std::endl;
-}
-
 
 /////////////////////
 
@@ -2251,6 +2113,7 @@ void make_block(BlockMakeData *data)
 	*/
 	assert(central_area_size.X == central_area_size.Z);
 	{
+		PseudoRandom ps (blockseed);
 		// Divide area into parts
 		s16 div = 8;
 		s16 sidelen = central_area_size.X / div;
@@ -2278,8 +2141,8 @@ void make_block(BlockMakeData *data)
 			// Put trees in random places on part of division
 			for(u32 i=0; i<tree_count; i++)
 			{
-				s16 x = myrand_range(p2d_min.X, p2d_max.X);
-				s16 z = myrand_range(p2d_min.Y, p2d_max.Y);
+				s16 x = ps.range(p2d_min.X, p2d_max.X);
+				s16 z = ps.range(p2d_min.Y, p2d_max.Y);
 				s16 y = find_ground_level(vmanip, v2s16(x,z), ndef);
 				// Don't make a tree under water level
 				if(y < WATER_LEVEL)
@@ -2300,7 +2163,7 @@ void make_block(BlockMakeData *data)
 				}
 				p.Y++;
 				// Make a tree
-				treegen::make_tree(vmanip, p, false, ndef);
+				treegen::make_tree(vmanip, p, false, ndef, ps.next());
 			}
 		}
 	}
@@ -2985,18 +2848,3 @@ void make_block(BlockMakeData *data)
 
 #endif ///BIG COMMENT
 
-BlockMakeData::BlockMakeData():
-	no_op(false),
-	vmanip(NULL),
-	seed(0),
-	nodedef(NULL)
-{}
-
-BlockMakeData::~BlockMakeData()
-{
-	delete vmanip;
-}
-
-//}; // namespace mapgen
-
-
diff --git a/src/mapgen.h b/src/mapgen.h
index 4f1ab4ebd..911e87537 100644
--- a/src/mapgen.h
+++ b/src/mapgen.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -36,6 +36,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define MGV6_BIOME_BLEND 0x10
 #define MG_FLAT          0x20
 
+extern FlagDesc flagdesc_mapgen[];
+
 class BiomeDefManager;
 class Biome;
 class EmergeManager;
@@ -43,20 +45,7 @@ class MapBlock;
 class ManualMapVoxelManipulator;
 class VoxelManipulator;
 class INodeDefManager;
-
-struct BlockMakeData {
-	bool no_op;
-	ManualMapVoxelManipulator *vmanip;
-	u64 seed;
-	v3s16 blockpos_min;
-	v3s16 blockpos_max;
-	v3s16 blockpos_requested;
-	UniqueQueue<v3s16> transforming_liquid;
-	INodeDefManager *nodedef;
-
-	BlockMakeData();
-	~BlockMakeData();
-};
+class BlockMakeData;
 
 struct MapgenParams {
 	std::string mg_name;
@@ -99,39 +88,5 @@ struct MapgenFactory {
 	virtual MapgenParams *createMapgenParams() = 0;
 };
 
-class EmergeManager {
-public:
-	std::map<std::string, MapgenFactory *> mglist;
-
-	//settings
-	MapgenParams *params;
-
-	//mapgen objects here
-	Mapgen *mapgen;
-
-	//biome manager
-	BiomeDefManager *biomedef;
-
-	EmergeManager(IGameDef *gamedef, BiomeDefManager *bdef);
-	~EmergeManager();
-
-	void initMapgens(MapgenParams *mgparams);
-	Mapgen *createMapgen(std::string mgname, int mgid,
-						MapgenParams *mgparams, EmergeManager *emerge);
-	MapgenParams *createMapgenParams(std::string mgname);
-	Mapgen *getMapgen();
-	void addBlockToQueue();
-	
-	void registerMapgen(std::string name, MapgenFactory *mgfactory);
-	MapgenParams *getParamsFromSettings(Settings *settings);
-	void setParamsToSettings(Settings *settings);
-	
-	//mapgen helper methods
-	Biome *getBiomeAtPoint(v3s16 p);
-	int getGroundLevelAtPoint(v2s16 p);
-	bool isBlockUnderground(v3s16 blockpos);
-	u32 getBlockSeed(v3s16 p);
-};
-
 #endif
 
diff --git a/src/mapgen_v6.cpp b/src/mapgen_v6.cpp
index 3a5e10930..d5405876e 100644
--- a/src/mapgen_v6.cpp
+++ b/src/mapgen_v6.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -31,6 +31,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "profiler.h"
 #include "settings.h" // For g_settings
 #include "main.h" // For g_profiler
+#include "emerge.h"
 #include "mapgen_v6.h"
 
 /////////////////// Mapgen V6 perlin noise default values
@@ -431,12 +432,6 @@ int MapgenV6::getGroundLevelAtPoint(v2s16 p) {
 
 void MapgenV6::makeChunk(BlockMakeData *data)
 {
-	if(data->no_op)
-	{
-		//dstream<<"makeBlock: no-op"<<std::endl;
-		return;
-	}
-
 	this->generating = true;
 
 	assert(data->vmanip);
@@ -1435,4 +1430,5 @@ void MapgenV6::makeChunk(BlockMakeData *data)
 		vmanip.spreadLight(bank, light_sources, ndef);
 	}
 	}
+	this->generating = false;
 }
diff --git a/src/mapgen_v6.h b/src/mapgen_v6.h
index 9a2a0287d..d2f05252b 100644
--- a/src/mapgen_v6.h
+++ b/src/mapgen_v6.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapnode.cpp b/src/mapnode.cpp
index 5dab93754..0513e688c 100644
--- a/src/mapnode.cpp
+++ b/src/mapnode.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapnode.h b/src/mapnode.h
index de2529e4d..1c8c5c49c 100644
--- a/src/mapnode.h
+++ b/src/mapnode.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -67,10 +67,15 @@ enum LightBank
 #define LIQUID_LEVEL_MASK 0x07
 #define LIQUID_FLOW_DOWN_MASK 0x08
 
+//#define LIQUID_LEVEL_MASK 0x3f // better finite water
+//#define LIQUID_FLOW_DOWN_MASK 0x40 // not used when finite water
+
 /* maximum amount of liquid in a block */
 #define LIQUID_LEVEL_MAX LIQUID_LEVEL_MASK
 #define LIQUID_LEVEL_SOURCE (LIQUID_LEVEL_MAX+1)
 
+#define LIQUID_INFINITY_MASK 0x80 //0b10000000
+
 /*
 	This is the stuff what the whole world consists of.
 */
diff --git a/src/mapsector.cpp b/src/mapsector.cpp
index f152c38e7..108effa79 100644
--- a/src/mapsector.cpp
+++ b/src/mapsector.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mapsector.h b/src/mapsector.h
index 74539ab24..88fc76b57 100644
--- a/src/mapsector.h
+++ b/src/mapsector.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mesh.cpp b/src/mesh.cpp
index 29b853143..c2e6bcaa4 100644
--- a/src/mesh.cpp
+++ b/src/mesh.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mesh.h b/src/mesh.h
index 5e1efcd52..cf46e7f8f 100644
--- a/src/mesh.h
+++ b/src/mesh.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/modalMenu.h b/src/modalMenu.h
index 04372167b..d19b4e27c 100644
--- a/src/modalMenu.h
+++ b/src/modalMenu.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/modifiedstate.h b/src/modifiedstate.h
index 98004619f..75518f2f5 100644
--- a/src/modifiedstate.h
+++ b/src/modifiedstate.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mods.cpp b/src/mods.cpp
index f6e3d58d7..ac2d9b17d 100644
--- a/src/mods.cpp
+++ b/src/mods.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/mods.h b/src/mods.h
index 59dffdade..9761a9103 100644
--- a/src/mods.h
+++ b/src/mods.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/nameidmapping.cpp b/src/nameidmapping.cpp
index 2a436f735..bcddb4515 100644
--- a/src/nameidmapping.cpp
+++ b/src/nameidmapping.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/nameidmapping.h b/src/nameidmapping.h
index 90d8dbed8..417c441d2 100644
--- a/src/nameidmapping.h
+++ b/src/nameidmapping.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/nodedef.cpp b/src/nodedef.cpp
index 560c6090d..9a1145a8e 100644
--- a/src/nodedef.cpp
+++ b/src/nodedef.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -199,6 +199,7 @@ void ContentFeatures::reset()
 	diggable = true;
 	climbable = false;
 	buildable_to = false;
+	rightclickable = true;
 	liquid_type = LIQUID_NONE;
 	liquid_alternative_flowing = "";
 	liquid_alternative_source = "";
@@ -271,6 +272,7 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
 	serializeSimpleSoundSpec(sound_dug, os);
 	// Stuff below should be moved to correct place in a version that otherwise changes
 	// the protocol version
+	writeU8(os, rightclickable);
 }
 
 void ContentFeatures::deSerialize(std::istream &is)
@@ -334,6 +336,7 @@ void ContentFeatures::deSerialize(std::istream &is)
 	try{
 		// Stuff below should be moved to correct place in a version that
 		// otherwise changes the protocol version
+		rightclickable = readU8(is);
 	}catch(SerializationError &e) {};
 }
 
@@ -604,9 +607,12 @@ public:
 					}
 				}
 				break;
+			case NDT_PLANTLIKE:
+				f->solidness = 0;
+				f->backface_culling = false;
+				break;
 			case NDT_TORCHLIKE:
 			case NDT_SIGNLIKE:
-			case NDT_PLANTLIKE:
 			case NDT_FENCELIKE:
 			case NDT_RAILLIKE:
 			case NDT_NODEBOX:
diff --git a/src/nodedef.h b/src/nodedef.h
index 8588caeab..b3f972b9b 100644
--- a/src/nodedef.h
+++ b/src/nodedef.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -199,6 +199,8 @@ struct ContentFeatures
 	bool climbable;
 	// Player can build on these
 	bool buildable_to;
+	// Player cannot build to these (placement prediction disabled)
+	bool rightclickable;
 	// Whether the node is non-liquid, source liquid or flowing liquid
 	enum LiquidType liquid_type;
 	// If the content is liquid, this is the flowing version of the liquid.
diff --git a/src/nodemetadata.cpp b/src/nodemetadata.cpp
index 141c779f1..911d86d22 100644
--- a/src/nodemetadata.cpp
+++ b/src/nodemetadata.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/nodemetadata.h b/src/nodemetadata.h
index 262b64d74..5af10d0f0 100644
--- a/src/nodemetadata.h
+++ b/src/nodemetadata.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/nodetimer.cpp b/src/nodetimer.cpp
index bf1e7435d..db5fb08b6 100644
--- a/src/nodetimer.cpp
+++ b/src/nodetimer.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/nodetimer.h b/src/nodetimer.h
index c643ab888..bdbd32293 100644
--- a/src/nodetimer.h
+++ b/src/nodetimer.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/noise.cpp b/src/noise.cpp
index bfb1960c8..49b5f7e58 100644
--- a/src/noise.cpp
+++ b/src/noise.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -507,7 +507,7 @@ void Noise::gradientMap3D(float x, float y, float z,
 
 
 float *Noise::perlinMap2D(float x, float y) {
-	float a = 0.0, f = 1.0, g = 1.0;
+	float f = 1.0, g = 1.0;
 	int i, j, index, oct;
 
 	x /= np->spread.X;
@@ -537,7 +537,7 @@ float *Noise::perlinMap2D(float x, float y) {
 
 
 float *Noise::perlinMap3D(float x, float y, float z) {
-	float a = 0.0, f = 1.0, g = 1.0;
+	float f = 1.0, g = 1.0;
 	int i, j, k, index, oct;
 
 	x /= np->spread.X;
diff --git a/src/noise.h b/src/noise.h
index e725b4e47..c2a85771c 100644
--- a/src/noise.h
+++ b/src/noise.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/object_properties.cpp b/src/object_properties.cpp
index ec988a37d..6086bf09f 100644
--- a/src/object_properties.cpp
+++ b/src/object_properties.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/object_properties.h b/src/object_properties.h
index d7d44625e..bde38bd66 100644
--- a/src/object_properties.h
+++ b/src/object_properties.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/particles.cpp b/src/particles.cpp
index d49e33322..fef21d91b 100644
--- a/src/particles.cpp
+++ b/src/particles.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/particles.h b/src/particles.h
index 3ed9dfdc8..b317549e7 100644
--- a/src/particles.h
+++ b/src/particles.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/player.cpp b/src/player.cpp
index 36f12c77b..4c81887be 100644
--- a/src/player.cpp
+++ b/src/player.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -27,10 +27,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 Player::Player(IGameDef *gamedef):
 	touching_ground(false),
-	in_water(false),
-	in_water_stable(false),
+	in_liquid(false),
+	in_liquid_stable(false),
+	liquid_viscosity(0),
 	is_climbing(false),
-	swimming_up(false),
+	swimming_vertical(false),
 	camera_barely_in_ceiling(false),
 	inventory(gamedef->idef()),
 	hp(PLAYER_MAX_HP),
@@ -56,19 +57,35 @@ Player::Player(IGameDef *gamedef):
 		"list[current_player;main;0,3.5;8,4;]"
 		"list[current_player;craft;3,0;3,3;]"
 		"list[current_player;craftpreview;7,1;1,1;]";
+
+	// Initialize movement settings at default values, so movement can work if the server fails to send them
+	movement_acceleration_default = 3 * BS;
+	movement_acceleration_air = 2 * BS;
+	movement_acceleration_fast = 10 * BS;
+	movement_speed_walk = 4 * BS;
+	movement_speed_crouch = 1.35 * BS;
+	movement_speed_fast = 20 * BS;
+	movement_speed_climb = 2 * BS;
+	movement_speed_jump = 6.5 * BS;
+	movement_liquid_fluidity = 1 * BS;
+	movement_liquid_fluidity_smooth = 0.5 * BS;
+	movement_liquid_sink = 10 * BS;
+	movement_gravity = 9.81 * BS;
 }
 
 Player::~Player()
 {
 }
 
-// Y direction is ignored
-void Player::accelerate(v3f target_speed, f32 max_increase)
+// Horizontal acceleration (X and Z), Y direction is ignored
+void Player::accelerateHorizontal(v3f target_speed, f32 max_increase)
 {
+	if(max_increase == 0)
+		return;
+
 	v3f d_wanted = target_speed - m_speed;
 	d_wanted.Y = 0;
-	f32 dl_wanted = d_wanted.getLength();
-	f32 dl = dl_wanted;
+	f32 dl = d_wanted.getLength();
 	if(dl > max_increase)
 		dl = max_increase;
 	
@@ -76,7 +93,6 @@ void Player::accelerate(v3f target_speed, f32 max_increase)
 
 	m_speed.X += d.X;
 	m_speed.Z += d.Z;
-	//m_speed += d;
 
 #if 0 // old code
 	if(m_speed.X < target_speed.X - max_increase)
@@ -99,6 +115,32 @@ void Player::accelerate(v3f target_speed, f32 max_increase)
 #endif
 }
 
+// Vertical acceleration (Y), X and Z directions are ignored
+void Player::accelerateVertical(v3f target_speed, f32 max_increase)
+{
+	if(max_increase == 0)
+		return;
+
+	f32 d_wanted = target_speed.Y - m_speed.Y;
+	if(d_wanted > max_increase)
+		d_wanted = max_increase;
+	else if(d_wanted < -max_increase)
+		d_wanted = -max_increase;
+
+	m_speed.Y += d_wanted;
+
+#if 0 // old code
+	if(m_speed.Y < target_speed.Y - max_increase)
+		m_speed.Y += max_increase;
+	else if(m_speed.Y > target_speed.Y + max_increase)
+		m_speed.Y -= max_increase;
+	else if(m_speed.Y < target_speed.Y)
+		m_speed.Y = target_speed.Y;
+	else if(m_speed.Y > target_speed.Y)
+		m_speed.Y = target_speed.Y;
+#endif
+}
+
 v3s16 Player::getLightPosition() const
 {
 	return floatToInt(m_position + v3f(0,BS+BS/2,0), BS);
diff --git a/src/player.h b/src/player.h
index 67b02c344..496c99532 100644
--- a/src/player.h
+++ b/src/player.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -108,8 +108,8 @@ public:
 		m_speed = speed;
 	}
 	
-	// Y direction is ignored
-	void accelerate(v3f target_speed, f32 max_increase);
+	void accelerateHorizontal(v3f target_speed, f32 max_increase);
+	void accelerateVertical(v3f target_speed, f32 max_increase);
 
 	v3f getPosition()
 	{
@@ -196,17 +196,32 @@ public:
 
 	bool touching_ground;
 	// This oscillates so that the player jumps a bit above the surface
-	bool in_water;
+	bool in_liquid;
 	// This is more stable and defines the maximum speed of the player
-	bool in_water_stable;
+	bool in_liquid_stable;
+	// Gets the viscosity of water to calculate friction
+	u8 liquid_viscosity;
 	bool is_climbing;
-	bool swimming_up;
+	bool swimming_vertical;
 	bool camera_barely_in_ceiling;
 	
 	u8 light;
 
 	Inventory inventory;
 
+	f32 movement_acceleration_default;
+	f32 movement_acceleration_air;
+	f32 movement_acceleration_fast;
+	f32 movement_speed_walk;
+	f32 movement_speed_crouch;
+	f32 movement_speed_fast;
+	f32 movement_speed_climb;
+	f32 movement_speed_jump;
+	f32 movement_liquid_fluidity;
+	f32 movement_liquid_fluidity_smooth;
+	f32 movement_liquid_sink;
+	f32 movement_gravity;
+
 	u16 hp;
 
 	float hurt_tilt_timer;
diff --git a/src/porting.cpp b/src/porting.cpp
index f8a2cca5c..84df15b30 100644
--- a/src/porting.cpp
+++ b/src/porting.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -131,6 +131,127 @@ void signal_handler_init(void)
 
 #endif
 
+
+/*
+	Multithreading support
+*/
+int getNumberOfProcessors() {
+#if defined(_SC_NPROCESSORS_ONLN)
+
+	return sysconf(_SC_NPROCESSORS_ONLN);
+
+#elif defined(__FreeBSD__) || defined(__APPLE__)
+
+	unsigned int len, count;
+	len = sizeof(count);
+	return sysctlbyname("hw.ncpu", &count, &len, NULL, 0);
+
+#elif defined(_GNU_SOURCE)
+
+	return get_nprocs();
+
+#elif defined(_WIN32)
+
+	SYSTEM_INFO sysinfo;
+	GetSystemInfo(&sysinfo);
+	return sysinfo.dwNumberOfProcessors;
+
+#elif defined(PTW32_VERSION) || defined(__hpux)
+
+	return pthread_num_processors_np();
+
+#else
+
+	return 1;
+
+#endif
+}
+
+
+bool threadBindToProcessor(threadid_t tid, int pnumber) {
+#if defined(_WIN32)
+
+	HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, 0, tid);
+	if (!hThread)
+		return false;
+
+	bool success = SetThreadAffinityMask(hThread, 1 << pnumber) != 0;
+
+	CloseHandle(hThread);
+	return success;
+
+#elif (defined(__FreeBSD__) && (__FreeBSD_version >= 702106)) \
+	|| defined(__linux) || defined(linux)
+
+	cpu_set_t cpuset;
+
+	CPU_ZERO(&cpuset);
+	CPU_SET(pnumber, &cpuset);
+	return pthread_setaffinity_np(tid, sizeof(cpuset), &cpuset) == 0;
+
+#elif defined(__sun) || defined(sun)
+
+	return processor_bind(P_LWPID, MAKE_LWPID_PTHREAD(tid), 
+						pnumber, NULL) == 0;
+
+#elif defined(_AIX)
+	
+	return bindprocessor(BINDTHREAD, (tid_t)tid, pnumber) == 0;
+
+#elif defined(__hpux) || defined(hpux)
+
+	pthread_spu_t answer;
+
+	return pthread_processor_bind_np(PTHREAD_BIND_ADVISORY_NP,
+									&answer, pnumber, tid) == 0;
+	
+#elif defined(__APPLE__)
+
+	struct thread_affinity_policy tapol;
+	
+	thread_port_t threadport = pthread_mach_thread_np(tid);
+	tapol.affinity_tag = pnumber + 1;
+	return thread_policy_set(threadport, THREAD_AFFINITY_POLICY,
+			(thread_policy_t)&tapol, THREAD_AFFINITY_POLICY_COUNT) == KERN_SUCCESS;
+
+#else
+
+	return false;
+
+#endif
+}
+
+
+bool threadSetPriority(threadid_t tid, int prio) {
+#if defined(_WIN32)
+
+	HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, 0, tid);
+	if (!hThread)
+		return false;
+
+	bool success = SetThreadPriority(hThread, prio) != 0;
+
+	CloseHandle(hThread);
+	return success;
+	
+#else
+
+	struct sched_param sparam;
+	int policy;
+	
+	if (pthread_getschedparam(tid, &policy, &sparam) != 0)
+		return false;
+		
+	int min = sched_get_priority_min(policy);
+	int max = sched_get_priority_max(policy);
+
+	sparam.sched_priority = min + prio * (max - min) / THREAD_PRIORITY_HIGHEST;
+	return pthread_setschedparam(tid, policy, &sparam) == 0;
+	
+#endif
+}
+
+
 /*
 	Path mangler
 */
diff --git a/src/porting.h b/src/porting.h
index 9ba3394bb..d7d107340 100644
--- a/src/porting.h
+++ b/src/porting.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -40,6 +40,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 //#define ALIGNOF(type) offsetof (alignment_trick<type>, member)
 
 #ifdef _WIN32
+	#ifndef _WIN32_WINNT
+		#define _WIN32_WINNT 0x0500
+	#endif
 	#include <windows.h>
 	
 	#define sleep_ms(x) Sleep(x)
@@ -47,7 +50,32 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 	#include <unistd.h>
 	#include <stdint.h> //for uintptr_t
 	
+	#if (defined(linux) || defined(__linux)) && !defined(_GNU_SOURCE)
+		#define _GNU_SOURCE
+	#endif
+
+	#include <sched.h>
+
+	#ifdef __FreeBSD__
+		#include <pthread_np.h>
+		typedef cpuset_t cpu_set_t;
+	#elif defined(__sun) || defined(sun)
+		#include <sys/types.h>
+		#include <sys/processor.h>
+	#elif defined(_AIX)
+		#include <sys/processor.h>
+	#elif __APPLE__
+		#include <mach/mach_init.h>
+		#include <mach/thread_policy.h>
+	#endif
+
 	#define sleep_ms(x) usleep(x*1000)
+	
+	#define THREAD_PRIORITY_LOWEST       0
+	#define THREAD_PRIORITY_BELOW_NORMAL 1
+	#define THREAD_PRIORITY_NORMAL       2
+	#define THREAD_PRIORITY_ABOVE_NORMAL 3
+	#define THREAD_PRIORITY_HIGHEST      4
 #endif
 
 #ifdef _MSC_VER
@@ -104,6 +132,21 @@ std::string getDataPath(const char *subpath);
 void initializePaths();
 
 /*
+	Get number of online processors in the system.
+*/
+int getNumberOfProcessors();
+
+/*
+	Set a thread's affinity to a particular processor.
+*/
+bool threadBindToProcessor(threadid_t tid, int pnumber);
+
+/*
+	Set a thread's priority.
+*/
+bool threadSetPriority(threadid_t tid, int prio);
+
+/*
 	Resolution is 10-20ms.
 	Remember to check for overflows.
 	Overflow can occur at any value higher than 10000000.
diff --git a/src/profiler.h b/src/profiler.h
index b1e6abe58..b9fa22485 100644
--- a/src/profiler.h
+++ b/src/profiler.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/quicktune.cpp b/src/quicktune.cpp
index acd0d721f..d3a7fcae2 100644
--- a/src/quicktune.cpp
+++ b/src/quicktune.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/quicktune.h b/src/quicktune.h
index a733ccda4..566fbfc4d 100644
--- a/src/quicktune.h
+++ b/src/quicktune.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/quicktune_shortcutter.h b/src/quicktune_shortcutter.h
index 2e3b5310b..16bcc07e8 100644
--- a/src/quicktune_shortcutter.h
+++ b/src/quicktune_shortcutter.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/rollback.cpp b/src/rollback.cpp
index f0e3c40aa..fe1d59d0c 100644
--- a/src/rollback.cpp
+++ b/src/rollback.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/rollback.h b/src/rollback.h
index 5e76042b5..46a76f583 100644
--- a/src/rollback.h
+++ b/src/rollback.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/rollback_interface.cpp b/src/rollback_interface.cpp
index b2eb2093c..70a9e9457 100644
--- a/src/rollback_interface.cpp
+++ b/src/rollback_interface.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/rollback_interface.h b/src/rollback_interface.h
index 8dd429d76..b2e8f3428 100644
--- a/src/rollback_interface.h
+++ b/src/rollback_interface.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/script.cpp b/src/script.cpp
index b238e1be7..4619fa636 100644
--- a/src/script.cpp
+++ b/src/script.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/script.h b/src/script.h
index fea132b07..dbacae5ae 100644
--- a/src/script.h
+++ b/src/script.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/scriptapi.cpp b/src/scriptapi.cpp
index 020709cab..7fddcfc68 100644
--- a/src/scriptapi.cpp
+++ b/src/scriptapi.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -1063,6 +1063,10 @@ static ItemDefinition read_item_definition(lua_State *L, int index,
 	def.usable = lua_isfunction(L, -1);
 	lua_pop(L, 1);
 
+	lua_getfield(L, index, "on_rightclick");
+	def.rightclickable = lua_isfunction(L, -1);
+	lua_pop(L, 1);
+
 	getboolfield(L, index, "liquids_pointable", def.liquids_pointable);
 
 	warn_if_field_exists(L, index, "tool_digging_properties",
@@ -4250,6 +4254,7 @@ private:
 				tree_def.fruitnode=ndef->getId(fruit);
 				getintfield(L, 3, "fruit_chance",tree_def.fruit_chance);
 			}
+			getintfield(L, 3, "seed", tree_def.seed);
 		}
 		else
 			return 0;
@@ -4746,7 +4751,7 @@ static int l_register_item_raw(lua_State *L)
 	// Default to having client-side placement prediction for nodes
 	// ("" in item definition sets it off)
 	if(def.node_placement_prediction == "__default"){
-		if(def.type == ITEM_NODE)
+		if(def.type == ITEM_NODE && !def.rightclickable)
 			def.node_placement_prediction = name;
 		else
 			def.node_placement_prediction = "";
diff --git a/src/scriptapi.h b/src/scriptapi.h
index d71b8fe41..e94ca781f 100644
--- a/src/scriptapi.h
+++ b/src/scriptapi.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/serialization.cpp b/src/serialization.cpp
index c57e1642a..118bad467 100644
--- a/src/serialization.cpp
+++ b/src/serialization.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/serialization.h b/src/serialization.h
index 533ddc8c4..defead31e 100644
--- a/src/serialization.h
+++ b/src/serialization.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/server.cpp b/src/server.cpp
index a8640ad10..41a7a4289 100644
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -38,6 +38,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "nodedef.h"
 #include "itemdef.h"
 #include "craftdef.h"
+#include "emerge.h"
 #include "mapgen.h"
 #include "biome.h"
 #include "content_mapnode.h"
@@ -51,66 +52,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "sound.h" // dummySoundManager
 #include "event_manager.h"
 #include "hex.h"
+#include "serverlist.h"
 #include "util/string.h"
 #include "util/pointedthing.h"
 #include "util/mathconstants.h"
 #include "rollback.h"
 #include "util/serialize.h"
 
-#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
-
-#define BLOCK_EMERGE_FLAG_FROMDISK (1<<0)
-
-class MapEditEventIgnorer
-{
-public:
-	MapEditEventIgnorer(bool *flag):
-		m_flag(flag)
-	{
-		if(*m_flag == false)
-			*m_flag = true;
-		else
-			m_flag = NULL;
-	}
-
-	~MapEditEventIgnorer()
-	{
-		if(m_flag)
-		{
-			assert(*m_flag);
-			*m_flag = false;
-		}
-	}
-
-private:
-	bool *m_flag;
-};
-
-class MapEditEventAreaIgnorer
-{
-public:
-	MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
-		m_ignorevariable(ignorevariable)
-	{
-		if(m_ignorevariable->getVolume() == 0)
-			*m_ignorevariable = a;
-		else
-			m_ignorevariable = NULL;
-	}
-
-	~MapEditEventAreaIgnorer()
-	{
-		if(m_ignorevariable)
-		{
-			assert(m_ignorevariable->getVolume() != 0);
-			*m_ignorevariable = VoxelArea();
-		}
-	}
-
-private:
-	VoxelArea *m_ignorevariable;
-};
-
 void * ServerThread::Thread()
 {
 	ThreadStarted();
@@ -156,265 +104,6 @@ void * ServerThread::Thread()
 	return NULL;
 }
 
-void * EmergeThread::Thread()
-{
-	ThreadStarted();
-
-	log_register_thread("EmergeThread");
-
-	DSTACK(__FUNCTION_NAME);
-
-	BEGIN_DEBUG_EXCEPTION_HANDLER
-
-	bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
-
-	v3s16 last_tried_pos(-32768,-32768,-32768); // For error output
-
-	ServerMap &map = ((ServerMap&)m_server->m_env->getMap());
-	EmergeManager *emerge = m_server->m_emerge;
-	Mapgen *mapgen = emerge->getMapgen();
-
-	/*
-		Get block info from queue, emerge them and send them
-		to clients.
-
-		After queue is empty, exit.
-	*/
-	while(getRun())
-	try{
-		QueuedBlockEmerge *qptr = m_server->m_emerge_queue.pop();
-		if(qptr == NULL)
-			break;
-
-		SharedPtr<QueuedBlockEmerge> q(qptr);
-
-		v3s16 &p = q->pos;
-		v2s16 p2d(p.X,p.Z);
-
-		last_tried_pos = p;
-
-		/*
-			Do not generate over-limit
-		*/
-		if(blockpos_over_limit(p))
-			continue;
-
-		//infostream<<"EmergeThread::Thread(): running"<<std::endl;
-
-		//TimeTaker timer("block emerge");
-
-		/*
-			Try to emerge it from somewhere.
-
-			If it is only wanted as optional, only loading from disk
-			will be allowed.
-		*/
-
-		/*
-			Check if any peer wants it as non-optional. In that case it
-			will be generated.
-
-			Also decrement the emerge queue count in clients.
-		*/
-
-		bool only_from_disk = true;
-
-		{
-			core::map<u16, u8>::Iterator i;
-			for(i=q->peer_ids.getIterator(); i.atEnd()==false; i++)
-			{
-				//u16 peer_id = i.getNode()->getKey();
-
-				// Check flags
-				u8 flags = i.getNode()->getValue();
-				if((flags & BLOCK_EMERGE_FLAG_FROMDISK) == false)
-					only_from_disk = false;
-
-			}
-		}
-
-		if(enable_mapgen_debug_info)
-			infostream<<"EmergeThread: p="
-					<<"("<<p.X<<","<<p.Y<<","<<p.Z<<") "
-					<<"only_from_disk="<<only_from_disk<<std::endl;
-
-
-
-		MapBlock *block = NULL;
-		bool got_block = true;
-		core::map<v3s16, MapBlock*> modified_blocks;
-
-		/*
-			Try to fetch block from memory or disk.
-			If not found and asked to generate, initialize generator.
-		*/
-
-		bool started_generate = false;
-		BlockMakeData data;
-
-		{
-			JMutexAutoLock envlock(m_server->m_env_mutex);
-
-			// Load sector if it isn't loaded
-			if(map.getSectorNoGenerateNoEx(p2d) == NULL)
-				map.loadSectorMeta(p2d);
-
-			// Attempt to load block
-			block = map.getBlockNoCreateNoEx(p);
-			if(!block || block->isDummy() || !block->isGenerated())
-			{
-				if(enable_mapgen_debug_info)
-					infostream<<"EmergeThread: not in memory, "
-							<<"attempting to load from disk"<<std::endl;
-
-				block = map.loadBlock(p);
-			}
-
-			// If could not load and allowed to generate, start generation
-			// inside this same envlock
-			if(only_from_disk == false &&
-					(block == NULL || block->isGenerated() == false)){
-				if(enable_mapgen_debug_info)
-					infostream<<"EmergeThread: generating"<<std::endl;
-				started_generate = true;
-
-				map.initBlockMake(&data, p);
-			}
-		}
-
-		/*
-			If generator was initialized, generate now when envlock is free.
-		*/
-		if(started_generate)
-		{
-			{
-				ScopeProfiler sp(g_profiler, "EmergeThread: mapgen::make_block",
-						SPT_AVG);
-				TimeTaker t("mapgen::make_block()");
-
-				mapgen->makeChunk(&data);
-				//mapgen::make_block(&data);
-
-				if(enable_mapgen_debug_info == false)
-					t.stop(true); // Hide output
-			}
-
-			do{ // enable break
-				// Lock environment again to access the map
-				JMutexAutoLock envlock(m_server->m_env_mutex);
-
-				ScopeProfiler sp(g_profiler, "EmergeThread: after "
-						"mapgen::make_block (envlock)", SPT_AVG);
-
-				// Blit data back on map, update lighting, add mobs and
-				// whatever this does
-				map.finishBlockMake(&data, modified_blocks);
-
-				// Get central block
-				block = map.getBlockNoCreateNoEx(p);
-
-				// If block doesn't exist, don't try doing anything with it
-				// This happens if the block is not in generation boundaries
-				if(!block)
-					break;
-
-				/*
-					Do some post-generate stuff
-				*/
-
-				v3s16 minp = data.blockpos_min*MAP_BLOCKSIZE;
-				v3s16 maxp = data.blockpos_max*MAP_BLOCKSIZE +
-						v3s16(1,1,1)*(MAP_BLOCKSIZE-1);
-
-				/*
-					Ignore map edit events, they will not need to be
-					sent to anybody because the block hasn't been sent
-					to anybody
-				*/
-				//MapEditEventIgnorer ign(&m_server->m_ignore_map_edit_events);
-				MapEditEventAreaIgnorer ign(
-						&m_server->m_ignore_map_edit_events_area,
-						VoxelArea(minp, maxp));
-				{
-					TimeTaker timer("on_generated");
-					scriptapi_environment_on_generated(m_server->m_lua,
-							minp, maxp, emerge->getBlockSeed(minp));
-					/*int t = timer.stop(true);
-					dstream<<"on_generated took "<<t<<"ms"<<std::endl;*/
-				}
-
-				if(enable_mapgen_debug_info)
-					infostream<<"EmergeThread: ended up with: "
-							<<analyze_block(block)<<std::endl;
-
-				// Activate objects and stuff
-				m_server->m_env->activateBlock(block, 0);
-			}while(false);
-		}
-
-		if(block == NULL)
-			got_block = false;
-
-		/*
-			Set sent status of modified blocks on clients
-		*/
-
-		// NOTE: Server's clients are also behind the connection mutex
-		JMutexAutoLock lock(m_server->m_con_mutex);
-
-		/*
-			Add the originally fetched block to the modified list
-		*/
-		if(got_block)
-		{
-			modified_blocks.insert(p, block);
-		}
-
-		/*
-			Set the modified blocks unsent for all the clients
-		*/
-
-		for(core::map<u16, RemoteClient*>::Iterator
-				i = m_server->m_clients.getIterator();
-				i.atEnd() == false; i++)
-		{
-			RemoteClient *client = i.getNode()->getValue();
-
-			if(modified_blocks.size() > 0)
-			{
-				// Remove block from sent history
-				client->SetBlocksNotSent(modified_blocks);
-			}
-		}
-	}
-	catch(VersionMismatchException &e)
-	{
-		std::ostringstream err;
-		err<<"World data version mismatch in MapBlock "<<PP(last_tried_pos)<<std::endl;
-		err<<"----"<<std::endl;
-		err<<"\""<<e.what()<<"\""<<std::endl;
-		err<<"See debug.txt."<<std::endl;
-		err<<"World probably saved by a newer version of Minetest."<<std::endl;
-		m_server->setAsyncFatalError(err.str());
-	}
-	catch(SerializationError &e)
-	{
-		std::ostringstream err;
-		err<<"Invalid data in MapBlock "<<PP(last_tried_pos)<<std::endl;
-		err<<"----"<<std::endl;
-		err<<"\""<<e.what()<<"\""<<std::endl;
-		err<<"See debug.txt."<<std::endl;
-		err<<"You can ignore this using [ignore_world_load_errors = true]."<<std::endl;
-		m_server->setAsyncFatalError(err.str());
-	}
-
-	END_DEBUG_EXCEPTION_HANDLER(errorstream)
-
-	log_deregister_thread();
-
-	return NULL;
-}
-
 v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const
 {
 	if(pos_exists) *pos_exists = false;
@@ -769,7 +458,7 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime,
 			*/
 			if(block == NULL || surely_not_found_on_disk || block_is_invalid)
 			{
-				//TODO: Get value from somewhere
+			/*	//TODO: Get value from somewhere
 				// Allow only one block in emerge queue
 				//if(server->m_emerge_queue.peerItemCount(peer_id) < 1)
 				// Allow two blocks in queue per client
@@ -798,7 +487,17 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime,
 						nearest_emergefull_d = d;
 					goto queue_full_break;
 				}
+			*/
 
+				if (server->m_emerge->enqueueBlockEmerge(peer_id, p, generate)) {
+					if (nearest_emerged_d == -1)
+						nearest_emerged_d = d;
+				} else {
+					if (nearest_emergefull_d == -1)
+						nearest_emergefull_d = d;
+					goto queue_full_break;
+				}
+				
 				// get next one.
 				continue;
 			}
@@ -952,7 +651,7 @@ Server::Server(
 	m_craftdef(createCraftDefManager()),
 	m_event(new EventManager()),
 	m_thread(this),
-	m_emergethread(this),
+	//m_emergethread(this),
 	m_time_of_day_send_timer(0),
 	m_uptime(0),
 	m_shutdown_requested(false),
@@ -960,10 +659,13 @@ Server::Server(
 	m_ignore_map_edit_events_peer_id(0)
 {
 	m_liquid_transform_timer = 0.0;
+	m_liquid_transform_every = 1.0;
 	m_print_info_timer = 0.0;
+	m_masterserver_timer = 0.0;
 	m_objectdata_timer = 0.0;
 	m_emergethread_trigger_timer = 0.0;
 	m_savemap_timer = 0.0;
+	m_clients_number = 0;
 
 	m_env_mutex.Init();
 	m_con_mutex.Init();
@@ -998,17 +700,20 @@ Server::Server(
 
 	ModConfiguration modconf(m_path_world);
 	m_mods = modconf.getMods();
+	std::list<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
 	// complain about mods with unsatisfied dependencies
 	if(!modconf.isConsistent())	
 	{
-		errorstream << "The following mods have unsatisfied dependencies: ";
-		std::list<ModSpec> modlist = modconf.getUnsatisfiedMods();
-		for(std::list<ModSpec>::iterator it = modlist.begin();
-			it != modlist.end(); ++it)
+		for(std::list<ModSpec>::iterator it = unsatisfied_mods.begin();
+			it != unsatisfied_mods.end(); ++it)
 		{
-			errorstream << (*it).name << " ";
+			ModSpec mod = *it;
+			errorstream << "mod \"" << mod.name << "\" has unsatisfied dependencies: ";
+			for(std::set<std::string>::iterator dep_it = mod.unsatisfied_depends.begin();
+				dep_it != mod.unsatisfied_depends.end(); ++dep_it)
+				errorstream << " \"" << *dep_it << "\"";
+			errorstream << std::endl;
 		}
-		errorstream << std::endl;
 	}
 
 	Settings worldmt_settings;
@@ -1033,12 +738,15 @@ Server::Server(
 	for(std::vector<ModSpec>::iterator it = m_mods.begin();
 		it != m_mods.end(); ++it)
 		load_mod_names.erase((*it).name);
+	for(std::list<ModSpec>::iterator it = unsatisfied_mods.begin();
+		it != unsatisfied_mods.end(); ++it)
+		load_mod_names.erase((*it).name);
 	if(!load_mod_names.empty())
 	{		
-		errorstream << "The following mods could not be found: ";
+		errorstream << "The following mods could not be found:";
 		for(std::set<std::string>::iterator it = load_mod_names.begin();
 			it != load_mod_names.end(); ++it)
-			errorstream << (*it) << " ";
+			errorstream << " \"" << (*it) << "\"";
 		errorstream << std::endl;
 	}
 
@@ -1127,6 +835,8 @@ Server::Server(
 		Add some test ActiveBlockModifiers to environment
 	*/
 	add_legacy_abms(m_env, m_nodedef);
+
+	m_liquid_transform_every = g_settings->getFloat("liquid_update");
 }
 
 Server::~Server()
@@ -1269,9 +979,9 @@ void Server::stop()
 
 	// Stop threads (set run=false first so both start stopping)
 	m_thread.setRun(false);
-	m_emergethread.setRun(false);
+	//m_emergethread.setRun(false);
 	m_thread.stop();
-	m_emergethread.stop();
+	//m_emergethread.stop();
 
 	infostream<<"Server: Threads stopped"<<std::endl;
 }
@@ -1443,9 +1153,9 @@ void Server::AsyncRunStep()
 
 	/* Transform liquids */
 	m_liquid_transform_timer += dtime;
-	if(m_liquid_transform_timer >= 1.00)
+	if(m_liquid_transform_timer >= m_liquid_transform_every)
 	{
-		m_liquid_transform_timer -= 1.00;
+		m_liquid_transform_timer -= m_liquid_transform_every;
 
 		JMutexAutoLock lock(m_env_mutex);
 
@@ -1499,7 +1209,7 @@ void Server::AsyncRunStep()
 			counter = 0.0;
 
 			JMutexAutoLock lock2(m_con_mutex);
-
+			m_clients_number = 0;
 			if(m_clients.size() != 0)
 				infostream<<"Players:"<<std::endl;
 			for(core::map<u16, RemoteClient*>::Iterator
@@ -1513,10 +1223,25 @@ void Server::AsyncRunStep()
 					continue;
 				infostream<<"* "<<player->getName()<<"\t";
 				client->PrintInfo(infostream);
+				++m_clients_number;
 			}
 		}
 	}
 
+
+#if USE_CURL
+	// send masterserver announce
+	{
+		float &counter = m_masterserver_timer;
+		if((!counter || counter >= 300.0) && g_settings->getBool("server_announce") == true)
+		{
+			ServerList::sendAnnounce(!counter ? "start" : "update", m_clients_number);
+			counter = 0.01;
+		}
+		counter += dtime;
+	}
+#endif
+
 	//if(g_settings->getBool("enable_experimental"))
 	{
 
@@ -1927,7 +1652,8 @@ void Server::AsyncRunStep()
 		{
 			counter = 0.0;
 
-			m_emergethread.trigger();
+			for (unsigned int i = 0; i != m_emerge->emergethread.size(); i++)
+				m_emerge->emergethread[i]->trigger();
 
 			// Update m_enable_rollback_recording here too
 			m_enable_rollback_recording =
@@ -2344,6 +2070,9 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
 		infostream<<"Server: Sending content to "
 				<<getPlayerName(peer_id)<<std::endl;
 
+		// Send player movement settings
+		SendMovement(m_con, peer_id);
+
 		// Send item definitions
 		SendItemDef(m_con, peer_id, m_itemdef);
 
@@ -3088,8 +2817,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
 					infostream<<"Server: Not punching: Node not found."
 							<<" Adding block to emerge queue."
 							<<std::endl;
-					m_emerge_queue.addBlock(peer_id,
-							getNodeBlockPos(p_above), BLOCK_EMERGE_FLAG_FROMDISK);
+					m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
 				}
 				if(n.getContent() != CONTENT_IGNORE)
 					scriptapi_node_on_punch(m_lua, p_under, n, playersao);
@@ -3145,8 +2873,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
 					infostream<<"Server: Not finishing digging: Node not found."
 							<<" Adding block to emerge queue."
 							<<std::endl;
-					m_emerge_queue.addBlock(peer_id,
-							getNodeBlockPos(p_above), BLOCK_EMERGE_FLAG_FROMDISK);
+					m_emerge->enqueueBlockEmerge(peer_id, getNodeBlockPos(p_above), false);
 				}
 
 				/* Cheat prevention */
@@ -3534,6 +3261,32 @@ void Server::deletingPeer(con::Peer *peer, bool timeout)
 	Static send methods
 */
 
+void Server::SendMovement(con::Connection &con, u16 peer_id)
+{
+	DSTACK(__FUNCTION_NAME);
+	std::ostringstream os(std::ios_base::binary);
+
+	writeU16(os, TOCLIENT_MOVEMENT);
+	writeF1000(os, g_settings->getFloat("movement_acceleration_default"));
+	writeF1000(os, g_settings->getFloat("movement_acceleration_air"));
+	writeF1000(os, g_settings->getFloat("movement_acceleration_fast"));
+	writeF1000(os, g_settings->getFloat("movement_speed_walk"));
+	writeF1000(os, g_settings->getFloat("movement_speed_crouch"));
+	writeF1000(os, g_settings->getFloat("movement_speed_fast"));
+	writeF1000(os, g_settings->getFloat("movement_speed_climb"));
+	writeF1000(os, g_settings->getFloat("movement_speed_jump"));
+	writeF1000(os, g_settings->getFloat("movement_liquid_fluidity"));
+	writeF1000(os, g_settings->getFloat("movement_liquid_fluidity_smooth"));
+	writeF1000(os, g_settings->getFloat("movement_liquid_sink"));
+	writeF1000(os, g_settings->getFloat("movement_gravity"));
+
+	// Make data buffer
+	std::string s = os.str();
+	SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+	// Send as reliable
+	con.Send(peer_id, 0, data, true);
+}
+
 void Server::SendHP(con::Connection &con, u16 peer_id, u8 hp)
 {
 	DSTACK(__FUNCTION_NAME);
@@ -4675,10 +4428,7 @@ void Server::notifyPlayers(const std::wstring msg)
 
 void Server::queueBlockEmerge(v3s16 blockpos, bool allow_generate)
 {
-	u8 flags = 0;
-	if(!allow_generate)
-		flags |= BLOCK_EMERGE_FLAG_FROMDISK;
-	m_emerge_queue.addBlock(PEER_ID_INEXISTENT, blockpos, flags);
+	m_emerge->enqueueBlockEmerge(PEER_ID_INEXISTENT, blockpos, allow_generate);
 }
 
 Inventory* Server::createDetachedInventory(const std::string &name)
@@ -5151,6 +4901,10 @@ void dedicated_server_loop(Server &server, bool &kill)
 		if(server.getShutdownRequested() || kill)
 		{
 			infostream<<"Dedicated server quitting"<<std::endl;
+#if USE_CURL
+			if(g_settings->getBool("server_announce") == true)
+				ServerList::sendAnnounce("delete");
+#endif
 			break;
 		}
 
diff --git a/src/server.h b/src/server.h
index 86d5513d8..d7700791c 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -39,6 +39,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "rollback_interface.h" // Needed for rollbackRevertActions()
 #include <list> // Needed for rollbackRevertActions()
 
+#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
+
 struct LuaState;
 typedef struct lua_State lua_State;
 class IWritableItemDefManager;
@@ -47,6 +49,7 @@ class IWritableCraftDefManager;
 class EventManager;
 class PlayerSAO;
 class IRollbackManager;
+class EmergeManager;
 
 class ServerError : public std::exception
 {
@@ -70,117 +73,55 @@ public:
 */
 v3f findSpawnPos(ServerMap &map);
 
-/*
-	A structure containing the data needed for queueing the fetching
-	of blocks.
-*/
-struct QueuedBlockEmerge
-{
-	v3s16 pos;
-	// key = peer_id, value = flags
-	core::map<u16, u8> peer_ids;
-};
 
-/*
-	This is a thread-safe class.
-*/
-class BlockEmergeQueue
+class MapEditEventIgnorer
 {
 public:
-	BlockEmergeQueue()
-	{
-		m_mutex.Init();
-	}
-
-	~BlockEmergeQueue()
+	MapEditEventIgnorer(bool *flag):
+		m_flag(flag)
 	{
-		JMutexAutoLock lock(m_mutex);
-
-		core::list<QueuedBlockEmerge*>::Iterator i;
-		for(i=m_queue.begin(); i!=m_queue.end(); i++)
-		{
-			QueuedBlockEmerge *q = *i;
-			delete q;
-		}
+		if(*m_flag == false)
+			*m_flag = true;
+		else
+			m_flag = NULL;
 	}
 
-	/*
-		peer_id=0 adds with nobody to send to
-	*/
-	void addBlock(u16 peer_id, v3s16 pos, u8 flags)
+	~MapEditEventIgnorer()
 	{
-		DSTACK(__FUNCTION_NAME);
-
-		JMutexAutoLock lock(m_mutex);
-
-		if(peer_id != 0)
+		if(m_flag)
 		{
-			/*
-				Find if block is already in queue.
-				If it is, update the peer to it and quit.
-			*/
-			core::list<QueuedBlockEmerge*>::Iterator i;
-			for(i=m_queue.begin(); i!=m_queue.end(); i++)
-			{
-				QueuedBlockEmerge *q = *i;
-				if(q->pos == pos)
-				{
-					q->peer_ids[peer_id] = flags;
-					return;
-				}
-			}
+			assert(*m_flag);
+			*m_flag = false;
 		}
-
-		/*
-			Add the block
-		*/
-		QueuedBlockEmerge *q = new QueuedBlockEmerge;
-		q->pos = pos;
-		if(peer_id != 0)
-			q->peer_ids[peer_id] = flags;
-		m_queue.push_back(q);
 	}
 
-	// Returned pointer must be deleted
-	// Returns NULL if queue is empty
-	QueuedBlockEmerge * pop()
-	{
-		JMutexAutoLock lock(m_mutex);
-
-		core::list<QueuedBlockEmerge*>::Iterator i = m_queue.begin();
-		if(i == m_queue.end())
-			return NULL;
-		QueuedBlockEmerge *q = *i;
-		m_queue.erase(i);
-		return q;
-	}
+private:
+	bool *m_flag;
+};
 
-	u32 size()
+class MapEditEventAreaIgnorer
+{
+public:
+	MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
+		m_ignorevariable(ignorevariable)
 	{
-		JMutexAutoLock lock(m_mutex);
-		return m_queue.size();
+		if(m_ignorevariable->getVolume() == 0)
+			*m_ignorevariable = a;
+		else
+			m_ignorevariable = NULL;
 	}
 
-	u32 peerItemCount(u16 peer_id)
+	~MapEditEventAreaIgnorer()
 	{
-		JMutexAutoLock lock(m_mutex);
-
-		u32 count = 0;
-
-		core::list<QueuedBlockEmerge*>::Iterator i;
-		for(i=m_queue.begin(); i!=m_queue.end(); i++)
+		if(m_ignorevariable)
 		{
-			QueuedBlockEmerge *q = *i;
-			if(q->peer_ids.find(peer_id) != NULL)
-				count++;
+			assert(m_ignorevariable->getVolume() != 0);
+			*m_ignorevariable = VoxelArea();
 		}
-
-		return count;
 	}
 
 private:
-	core::list<QueuedBlockEmerge*> m_queue;
-	JMutex m_mutex;
+	VoxelArea *m_ignorevariable;
 };
 
 class Server;
@@ -200,30 +141,6 @@ public:
 	void * Thread();
 };
 
-class EmergeThread : public SimpleThread
-{
-	Server *m_server;
-
-public:
-
-	EmergeThread(Server *server):
-		SimpleThread(),
-		m_server(server)
-	{
-	}
-
-	void * Thread();
-
-	void trigger()
-	{
-		setRun(true);
-		if(IsRunning() == false)
-		{
-			Start();
-		}
-	}
-};
-
 struct PlayerInfo
 {
 	u16 id;
@@ -602,6 +519,7 @@ private:
 		Static send methods
 	*/
 
+	static void SendMovement(con::Connection &con, u16 peer_id);
 	static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
 	static void SendAccessDenied(con::Connection &con, u16 peer_id,
 			const std::wstring &reason);
@@ -718,7 +636,9 @@ private:
 
 	// Some timers
 	float m_liquid_transform_timer;
+	float m_liquid_transform_every;
 	float m_print_info_timer;
+	float m_masterserver_timer;
 	float m_objectdata_timer;
 	float m_emergethread_trigger_timer;
 	float m_savemap_timer;
@@ -736,6 +656,7 @@ private:
 	JMutex m_con_mutex;
 	// Connected clients (behind the con mutex)
 	core::map<u16, RemoteClient*> m_clients;
+	u16 m_clients_number; //for announcing masterserver
 
 	// Bann checking
 	BanManager m_banmanager;
@@ -781,10 +702,6 @@ private:
 
 	// The server mainly operates in this thread
 	ServerThread m_thread;
-	// This thread fetches and generates map
-	EmergeThread m_emergethread;
-	// Queue of block coordinates to be processed by the emerge thread
-	BlockEmergeQueue m_emerge_queue;
 
 	/*
 		Time related stuff
diff --git a/src/serverlist.cpp b/src/serverlist.cpp
index 88a213db1..b5e6aad4e 100644
--- a/src/serverlist.cpp
+++ b/src/serverlist.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -27,6 +27,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "filesys.h"
 #include "porting.h"
 #include "log.h"
+#include "json/json.h"
 #if USE_CURL
 #include <curl/curl.h>
 #endif
@@ -83,7 +84,7 @@ std::vector<ServerListSpec> getOnline()
 	{
 		CURLcode res;
 
-		curl_easy_setopt(curl, CURLOPT_URL, g_settings->get("serverlist_url").c_str());
+		curl_easy_setopt(curl, CURLOPT_URL, (g_settings->get("serverlist_url")+"/list").c_str());
 		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ServerList::WriteCallback);
 		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &liststring);
 
@@ -92,8 +93,7 @@ std::vector<ServerListSpec> getOnline()
 			errorstream<<"Serverlist at url "<<g_settings->get("serverlist_url")<<" not found (internet connection?)"<<std::endl;
 		curl_easy_cleanup(curl);
 	}
-
-	return ServerList::deSerialize(liststring);
+	return ServerList::deSerializeJson(liststring);
 }
 
 #endif
@@ -106,8 +106,8 @@ bool deleteEntry (ServerListSpec server)
 	std::vector<ServerListSpec> serverlist = ServerList::getLocal();
 	for(unsigned i = 0; i < serverlist.size(); i++)
 	{
-		if  (serverlist[i].address == server.address
-		&&   serverlist[i].port    == server.port)
+		if  (serverlist[i]["address"] == server["address"]
+		&&   serverlist[i]["port"]    == server["port"])
 		{
 			serverlist.erase(serverlist.begin() + i);
 		}
@@ -150,17 +150,21 @@ std::vector<ServerListSpec> deSerialize(std::string liststring)
 {
 	std::vector<ServerListSpec> serverlist;
 	std::istringstream stream(liststring);
-	std::string line;
+	std::string line, tmp;
 	while (std::getline(stream, line))
 	{
 		std::transform(line.begin(), line.end(),line.begin(), ::toupper);
 		if (line == "[SERVER]")
 		{
 			ServerListSpec thisserver;
-			std::getline(stream, thisserver.name);
-			std::getline(stream, thisserver.address);
-			std::getline(stream, thisserver.port);
-			std::getline(stream, thisserver.description);
+			std::getline(stream, tmp);
+			thisserver["name"] = tmp;
+			std::getline(stream, tmp);
+			thisserver["address"] = tmp;
+			std::getline(stream, tmp);
+			thisserver["port"] = tmp;
+			std::getline(stream, tmp);
+			thisserver["description"] = tmp;
 			serverlist.push_back(thisserver);
 		}
 	}
@@ -173,13 +177,100 @@ std::string serialize(std::vector<ServerListSpec> serverlist)
 	for(std::vector<ServerListSpec>::iterator i = serverlist.begin(); i != serverlist.end(); i++)
 	{
 		liststring += "[server]\n";
-		liststring += i->name + "\n";
-		liststring += i->address + "\n";
-		liststring += i->port + "\n";
-		liststring += i->description + "\n";
+		liststring += (*i)["name"].asString() + "\n";
+		liststring += (*i)["address"].asString() + "\n";
+		liststring += (*i)["port"].asString() + "\n";
+		liststring += (*i)["description"].asString() + "\n";
 		liststring += "\n";
 	}
 	return liststring;
 }
 
+std::vector<ServerListSpec> deSerializeJson(std::string liststring)
+{
+	std::vector<ServerListSpec> serverlist;
+	Json::Value root;
+	Json::Reader reader;
+	std::istringstream stream(liststring);
+	if (!liststring.size()) {
+		return serverlist;
+	}
+	if (!reader.parse( stream, root ) )
+	{
+		errorstream  << "Failed to parse server list " << reader.getFormattedErrorMessages();
+		return serverlist;
+	}
+	if (root["list"].isArray())
+	    for (unsigned int i = 0; i < root["list"].size(); i++)
+	{
+		if (root["list"][i].isObject()) {
+			serverlist.push_back(root["list"][i]);
+		}
+	}
+	return serverlist;
+}
+
+std::string serializeJson(std::vector<ServerListSpec> serverlist)
+{
+	Json::Value root;
+	Json::Value list(Json::arrayValue);
+	for(std::vector<ServerListSpec>::iterator i = serverlist.begin(); i != serverlist.end(); i++)
+	{
+		list.append(*i);
+	}
+	root["list"] = list;
+	Json::StyledWriter writer;
+	return writer.write( root );
+}
+
+
+#if USE_CURL
+static size_t ServerAnnounceCallback(void *contents, size_t size, size_t nmemb, void *userp)
+{
+    return 0;
+    //((std::string*)userp)->append((char*)contents, size * nmemb);
+    //return size * nmemb;
+}
+void sendAnnounce(std::string action, u16 clients) {
+	Json::Value server;
+	if (action.size())
+		server["action"]	= action;
+	server["port"] = g_settings->get("port");
+        if (action != "del") {
+		server["name"]		= g_settings->get("server_name");
+		server["description"]	= g_settings->get("server_description");
+		server["address"]	= g_settings->get("server_address");
+		server["version"]	= VERSION_STRING;
+		server["url"]		= g_settings->get("server_url");
+		server["creative"]	= g_settings->get("creative_mode");
+		server["damage"]	= g_settings->get("enable_damage");
+		server["dedicated"]	= g_settings->get("server_dedicated");
+		server["password"]	= g_settings->getBool("disallow_empty_password");
+		server["pvp"]		= g_settings->getBool("enable_pvp");
+		server["clients"]	= clients;
+		server["clients_max"]	= g_settings->get("max_users");
+	}
+	if(server["action"] == "start")
+		actionstream << "announcing to " << g_settings->get("serverlist_url") << std::endl;
+	Json::StyledWriter writer;
+	CURL *curl;
+	curl = curl_easy_init();
+	if (curl)
+	{
+		CURLcode res;
+		curl_easy_setopt(curl, CURLOPT_URL, (g_settings->get("serverlist_url")+std::string("/announce?json=")+curl_easy_escape(curl, writer.write( server ).c_str(), 0)).c_str());
+		//curl_easy_setopt(curl, CURLOPT_USERAGENT, "minetest");
+		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ServerList::ServerAnnounceCallback);
+		//curl_easy_setopt(curl, CURLOPT_WRITEDATA, &liststring);
+		curl_easy_setopt(curl, CURLOPT_TIMEOUT, 1);
+		curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 1);
+		res = curl_easy_perform(curl);
+		//if (res != CURLE_OK)
+		//	errorstream<<"Serverlist at url "<<g_settings->get("serverlist_url")<<" not found (internet connection?)"<<std::endl;
+		curl_easy_cleanup(curl);
+	}
+
+}
+#endif
+
 } //namespace ServerList
diff --git a/src/serverlist.h b/src/serverlist.h
index a040d53e3..e81e64c5b 100644
--- a/src/serverlist.h
+++ b/src/serverlist.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -19,17 +19,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include <iostream>
 #include "config.h"
+#include "json/json.h"
 
 #ifndef SERVERLIST_HEADER
 #define SERVERLIST_HEADER
 
-struct ServerListSpec
-{
-	std::string name;
-	std::string address;
-	std::string port;
-	std::string description;
-};
+typedef Json::Value ServerListSpec;
 
 namespace ServerList
 {
@@ -41,6 +36,11 @@ namespace ServerList
 	bool insert(ServerListSpec server);
 	std::vector<ServerListSpec> deSerialize(std::string liststring);
 	std::string serialize(std::vector<ServerListSpec>);
+	std::vector<ServerListSpec> deSerializeJson(std::string liststring);
+	std::string serializeJson(std::vector<ServerListSpec>);
+	#if USE_CURL
+	void sendAnnounce(std::string action = "", u16 clients = 0);
+	#endif
 } //ServerList namespace
 
 #endif
diff --git a/src/serverobject.cpp b/src/serverobject.cpp
index deaa94f2c..beb17d31f 100644
--- a/src/serverobject.cpp
+++ b/src/serverobject.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/serverobject.h b/src/serverobject.h
index 14752878f..6525270f6 100644
--- a/src/serverobject.h
+++ b/src/serverobject.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/settings.h b/src/settings.h
index addd9980c..7ac308cc0 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/shader.cpp b/src/shader.cpp
index 9e1a51f23..7e3d16e8b 100644
--- a/src/shader.cpp
+++ b/src/shader.cpp
@@ -1,7 +1,7 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2012 Kahrl <kahrl@gmx.net>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Kahrl <kahrl@gmx.net>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/src/shader.h b/src/shader.h
index 774a17b20..a7367eaff 100644
--- a/src/shader.h
+++ b/src/shader.h
@@ -1,7 +1,7 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
-Copyright (C) 2012 Kahrl <kahrl@gmx.net>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2013 Kahrl <kahrl@gmx.net>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
diff --git a/src/sky.h b/src/sky.h
index 65170dad5..7b7295e4e 100644
--- a/src/sky.h
+++ b/src/sky.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/socket.cpp b/src/socket.cpp
index f8afed229..9e289baa2 100644
--- a/src/socket.cpp
+++ b/src/socket.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/socket.h b/src/socket.h
index 06ec2843a..994a07e45 100644
--- a/src/socket.h
+++ b/src/socket.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/sound.cpp b/src/sound.cpp
index f5203bbb3..707065043 100644
--- a/src/sound.cpp
+++ b/src/sound.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/sound.h b/src/sound.h
index d74acd550..c21401e8b 100644
--- a/src/sound.h
+++ b/src/sound.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/sound_openal.cpp b/src/sound_openal.cpp
index c78f6288f..cc5261eae 100644
--- a/src/sound_openal.cpp
+++ b/src/sound_openal.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 OpenAL support based on work by:
 Copyright (C) 2011 Sebastian 'Bahamada' Rühl
 Copyright (C) 2011 Cyriaque 'Cisoun' Skrapits <cysoun@gmail.com>
diff --git a/src/sound_openal.h b/src/sound_openal.h
index 876c45e69..13d01a5d6 100644
--- a/src/sound_openal.h
+++ b/src/sound_openal.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/staticobject.cpp b/src/staticobject.cpp
index 2183f2ffe..48fadaf06 100644
--- a/src/staticobject.cpp
+++ b/src/staticobject.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/staticobject.h b/src/staticobject.h
index 6fccbdd4f..c8427fe47 100644
--- a/src/staticobject.h
+++ b/src/staticobject.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/strfnd.h b/src/strfnd.h
index 71a9a8cd9..d28aa73b2 100644
--- a/src/strfnd.h
+++ b/src/strfnd.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/subgame.cpp b/src/subgame.cpp
index 2f5340373..3c8bf53c5 100644
--- a/src/subgame.cpp
+++ b/src/subgame.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/subgame.h b/src/subgame.h
index dd725caf7..8561c1a52 100644
--- a/src/subgame.h
+++ b/src/subgame.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/test.cpp b/src/test.cpp
index bc0692a78..d86868118 100644
--- a/src/test.cpp
+++ b/src/test.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -462,7 +462,7 @@ struct TestCompress: public TestBase
 					<<os_decompressed.str().size()<<std::endl;
 			std::string str_decompressed = os_decompressed.str();
 			UTEST(str_decompressed.size() == data_in.size(), "Output size not"
-					" equal (output: %i, input: %i)",
+					" equal (output: %u, input: %u)",
 					str_decompressed.size(), data_in.size());
 			for(u32 i=0; i<size && i<str_decompressed.size(); i++){
 				UTEST(str_decompressed[i] == data_in[i],
diff --git a/src/test.h b/src/test.h
index f69888214..547e9a986 100644
--- a/src/test.h
+++ b/src/test.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/threads.h b/src/threads.h
index e79404aa2..a3717a1de 100644
--- a/src/threads.h
+++ b/src/threads.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/tile.cpp b/src/tile.cpp
index 7cad1b836..7286293d8 100644
--- a/src/tile.cpp
+++ b/src/tile.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/tile.h b/src/tile.h
index b00c1c6c6..07e5bcb56 100644
--- a/src/tile.h
+++ b/src/tile.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/tool.cpp b/src/tool.cpp
index c1e268ff1..04f19749c 100644
--- a/src/tool.cpp
+++ b/src/tool.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/tool.h b/src/tool.h
index 18c09dca3..e812a9e36 100644
--- a/src/tool.h
+++ b/src/tool.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/treegen.cpp b/src/treegen.cpp
index 7530843d3..7b6152329 100644
--- a/src/treegen.cpp
+++ b/src/treegen.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>,
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>,
 			  2012-2013 RealBadAngel, Maciej Kasatkin <mk@realbadangel.pl>
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -21,7 +21,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <stack>
 #include "util/numeric.h"
 #include "util/mathconstants.h"
-#include "noise.h"
 #include "map.h"
 #include "environment.h"
 #include "nodedef.h"
@@ -29,15 +28,15 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 namespace treegen
 {
-
 void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0,
-		bool is_apple_tree, INodeDefManager *ndef)
+		bool is_apple_tree, INodeDefManager *ndef,int seed)
 {
 	MapNode treenode(ndef->getId("mapgen_tree"));
 	MapNode leavesnode(ndef->getId("mapgen_leaves"));
 	MapNode applenode(ndef->getId("mapgen_apple"));
 
-	s16 trunk_h = myrand_range(4, 5);
+	PseudoRandom ps(seed);
+	s16 trunk_h = ps.range(4, 5);
 	v3s16 p1 = p0;
 	for(s16 ii=0; ii<trunk_h; ii++)
 	{
@@ -73,9 +72,9 @@ void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0,
 		s16 d = 1;
 
 		v3s16 p(
-			myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
-			myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
-			myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
+			ps.range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
+			ps.range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
+			ps.range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
 		);
 
 		for(s16 z=0; z<=d; z++)
@@ -101,7 +100,7 @@ void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0,
 			continue;
 		u32 i = leaves_a.index(x,y,z);
 		if(leaves_d[i] == 1) {
-			bool is_apple = myrand_range(0,99) < 10;
+			bool is_apple = ps.range(0,99) < 10;
 			if(is_apple_tree && is_apple) {
 				vmanip.m_data[vi] = applenode;
 			} else {
@@ -150,6 +149,7 @@ void make_ltree(ManualMapVoxelManipulator &vmanip, v3s16 p0, INodeDefManager *nd
 {
 	MapNode dirtnode(ndef->getId("mapgen_dirt"));
 
+	PseudoRandom ps(tree_definition.seed+14002);
 	// chance of inserting abcd rules
 	double prop_a = 9;
 	double prop_b = 8;
@@ -159,13 +159,13 @@ void make_ltree(ManualMapVoxelManipulator &vmanip, v3s16 p0, INodeDefManager *nd
 	//randomize tree growth level, minimum=2
 	s16 iterations = tree_definition.iterations;
 	if (tree_definition.iterations_random_level>0)
-		iterations -= myrand_range(0,tree_definition.iterations_random_level);
+		iterations -= ps.range(0,tree_definition.iterations_random_level);
 	if (iterations<2)
 		iterations=2;
 
 	s16 MAX_ANGLE_OFFSET = 5;
 	double angle_in_radians = (double)tree_definition.angle*M_PI/180;
-	double angleOffset_in_radians = (s16)(myrand_range(0,1)%MAX_ANGLE_OFFSET)*M_PI/180;
+	double angleOffset_in_radians = (s16)(ps.range(0,1)%MAX_ANGLE_OFFSET)*M_PI/180;
 
 	//initialize rotation matrix, position and stacks for branches
 	core::matrix4 rotation;
@@ -200,19 +200,19 @@ void make_ltree(ManualMapVoxelManipulator &vmanip, v3s16 p0, INodeDefManager *nd
 				temp+=tree_definition.rules_d;
 				break;
 			case 'a':
-				if (prop_a >= myrand_range(1,10))
+				if (prop_a >= ps.range(1,10))
 					temp+=tree_definition.rules_a;
 				break;
 			case 'b':
-				if (prop_b >= myrand_range(1,10))
+				if (prop_b >= ps.range(1,10))
 					temp+=tree_definition.rules_b;
 				break;
 			case 'c':
-				if (prop_c >= myrand_range(1,10))
+				if (prop_c >= ps.range(1,10))
 					temp+=tree_definition.rules_c;
 				break;
 			case 'd':
-				if (prop_d >= myrand_range(1,10))
+				if (prop_d >= ps.range(1,10))
 					temp+=tree_definition.rules_d;
 				break;
 			default:
@@ -324,10 +324,10 @@ void make_ltree(ManualMapVoxelManipulator &vmanip, v3s16 p0, INodeDefManager *nd
 						for(z=-size; z<=size; z++)
 							if (abs(x) == size && abs(y) == size && abs(z) == size)
 							{
-								tree_leaves_placement(vmanip,v3f(position.X+x+1,position.Y+y,position.Z+z),tree_definition);
-								tree_leaves_placement(vmanip,v3f(position.X+x-1,position.Y+y,position.Z+z),tree_definition);
-								tree_leaves_placement(vmanip,v3f(position.X+x,position.Y+y,position.Z+z+1),tree_definition);
-								tree_leaves_placement(vmanip,v3f(position.X+x,position.Y+y,position.Z+z-1),tree_definition);
+								tree_leaves_placement(vmanip,v3f(position.X+x+1,position.Y+y,position.Z+z),ps.next(), tree_definition);
+								tree_leaves_placement(vmanip,v3f(position.X+x-1,position.Y+y,position.Z+z),ps.next(), tree_definition);
+								tree_leaves_placement(vmanip,v3f(position.X+x,position.Y+y,position.Z+z+1),ps.next(), tree_definition);
+								tree_leaves_placement(vmanip,v3f(position.X+x,position.Y+y,position.Z+z-1),ps.next(), tree_definition);
 							}
 			}
 			dir = v3f(1,0,0);
@@ -335,7 +335,7 @@ void make_ltree(ManualMapVoxelManipulator &vmanip, v3s16 p0, INodeDefManager *nd
 			position+=dir;
 			break;
 		case 'f':
-			tree_single_leaves_placement(vmanip,v3f(position.X,position.Y,position.Z),tree_definition);
+			tree_single_leaves_placement(vmanip,v3f(position.X,position.Y,position.Z),ps.next() ,tree_definition);
 			dir = v3f(1,0,0);
 			dir = transposeMatrix(rotation,dir);
 			position+=dir;
@@ -421,10 +421,10 @@ void tree_trunk_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
 }
 
 void tree_leaves_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
-		TreeDef &tree_definition)
+		PseudoRandom ps ,TreeDef &tree_definition)
 {
 	MapNode leavesnode=tree_definition.leavesnode;
-	if (myrand_range(1,100) > 100-tree_definition.leaves2_chance)
+	if (ps.range(1,100) > 100-tree_definition.leaves2_chance)
 		leavesnode=tree_definition.leaves2node;
 	v3s16 p1 = v3s16(myround(p0.X),myround(p0.Y),myround(p0.Z));
 	if(vmanip.m_area.contains(p1) == false)
@@ -435,20 +435,20 @@ void tree_leaves_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
 		return;	
 	if (tree_definition.fruit_chance>0)
 	{
-		if (myrand_range(1,100) > 100-tree_definition.fruit_chance)
+		if (ps.range(1,100) > 100-tree_definition.fruit_chance)
 			vmanip.m_data[vmanip.m_area.index(p1)] = tree_definition.fruitnode;
 		else
 			vmanip.m_data[vmanip.m_area.index(p1)] = leavesnode;
 	}
-	else if (myrand_range(1,100) > 20)
+	else if (ps.range(1,100) > 20)
 		vmanip.m_data[vmanip.m_area.index(p1)] = leavesnode;
 }
 
 void tree_single_leaves_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
-		TreeDef &tree_definition)
+		PseudoRandom ps, TreeDef &tree_definition)
 {
 	MapNode leavesnode=tree_definition.leavesnode;
-	if (myrand_range(1,100) > 100-tree_definition.leaves2_chance)
+	if (ps.range(1,100) > 100-tree_definition.leaves2_chance)
 		leavesnode=tree_definition.leaves2node;
 	v3s16 p1 = v3s16(myround(p0.X),myround(p0.Y),myround(p0.Z));
 	if(vmanip.m_area.contains(p1) == false)
diff --git a/src/treegen.h b/src/treegen.h
index cb365f4be..ca4d3e23d 100644
--- a/src/treegen.h
+++ b/src/treegen.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>,
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>,
 			  2012-2013 RealBadAngel, Maciej Kasatkin <mk@realbadangel.pl>
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -21,6 +21,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define TREEGEN_HEADER
 
 #include <matrix4.h>
+#include "noise.h"
 
 class ManualMapVoxelManipulator;
 class INodeDefManager;
@@ -47,11 +48,12 @@ std::string trunk_type;
 bool thin_branches;
 MapNode fruitnode;
 int fruit_chance;
+int seed;
 };
 
 	// Add default tree
 	void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0,
-		bool is_apple_tree, INodeDefManager *ndef);
+		bool is_apple_tree, INodeDefManager *ndef,int seed);
 
 	// Add L-Systems tree (used by engine)
 	void make_ltree(ManualMapVoxelManipulator &vmanip, v3s16 p0, INodeDefManager *ndef,
@@ -66,9 +68,9 @@ int fruit_chance;
 	void tree_trunk_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
 		TreeDef &tree_definition);
 	void tree_leaves_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
-		TreeDef &tree_definition);
+		PseudoRandom ps, TreeDef &tree_definition);
 	void tree_single_leaves_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
-		TreeDef &tree_definition);
+		PseudoRandom ps, TreeDef &tree_definition);
 	void tree_fruit_placement(ManualMapVoxelManipulator &vmanip, v3f p0,
 		TreeDef &tree_definition);
 	irr::core::matrix4 setRotationAxisRadians(irr::core::matrix4 M, double angle,v3f axis);
diff --git a/src/util/container.h b/src/util/container.h
index 8c1ae02fb..775372649 100644
--- a/src/util/container.h
+++ b/src/util/container.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/directiontables.cpp b/src/util/directiontables.cpp
index a5d2faa7c..d6c154842 100644
--- a/src/util/directiontables.cpp
+++ b/src/util/directiontables.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/directiontables.h b/src/util/directiontables.h
index 5bebd2fdb..0dd3aab09 100644
--- a/src/util/directiontables.h
+++ b/src/util/directiontables.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/numeric.cpp b/src/util/numeric.cpp
index 0ac812eb7..a79454628 100644
--- a/src/util/numeric.cpp
+++ b/src/util/numeric.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/numeric.h b/src/util/numeric.h
index a028f1ff2..450a98e40 100644
--- a/src/util/numeric.h
+++ b/src/util/numeric.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/pointedthing.cpp b/src/util/pointedthing.cpp
index d1be2d6b6..dc39e313a 100644
--- a/src/util/pointedthing.cpp
+++ b/src/util/pointedthing.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/pointedthing.h b/src/util/pointedthing.h
index e61e2f4f3..2b2703e98 100644
--- a/src/util/pointedthing.h
+++ b/src/util/pointedthing.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/pointer.h b/src/util/pointer.h
index 775f0a336..f65683332 100644
--- a/src/util/pointer.h
+++ b/src/util/pointer.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/serialize.cpp b/src/util/serialize.cpp
index 16825b677..f32813551 100644
--- a/src/util/serialize.cpp
+++ b/src/util/serialize.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/serialize.h b/src/util/serialize.h
index b356c484e..bb44c7f96 100644
--- a/src/util/serialize.h
+++ b/src/util/serialize.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -208,11 +208,12 @@ inline void writeARGB8(u8 *data, video::SColor p)
 
 inline video::SColor readARGB8(const u8 *data)
 {
-	video::SColor p;
-	p.setAlpha(readU8(&data[0]));
-	p.setRed(readU8(&data[1]));
-	p.setGreen(readU8(&data[2]));
-	p.setBlue(readU8(&data[3]));
+	video::SColor p(
+		readU8(&data[0]),
+		readU8(&data[1]),
+		readU8(&data[2]),
+		readU8(&data[3])
+	);
 	return p;
 }
 
diff --git a/src/util/string.cpp b/src/util/string.cpp
index 61b307c60..3bd8b7364 100644
--- a/src/util/string.cpp
+++ b/src/util/string.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/string.h b/src/util/string.h
index a469a074a..2f0264bd4 100644
--- a/src/util/string.h
+++ b/src/util/string.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/thread.h b/src/util/thread.h
index 8e8c74ac5..949bb4204 100644
--- a/src/util/thread.h
+++ b/src/util/thread.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/timetaker.cpp b/src/util/timetaker.cpp
index 52c618931..910fea822 100644
--- a/src/util/timetaker.cpp
+++ b/src/util/timetaker.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/util/timetaker.h b/src/util/timetaker.h
index 8aad97d0f..0b9d9ca04 100644
--- a/src/util/timetaker.h
+++ b/src/util/timetaker.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/voxel.cpp b/src/voxel.cpp
index 8fdae79e1..c55f3f539 100644
--- a/src/voxel.cpp
+++ b/src/voxel.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -244,7 +244,13 @@ void VoxelManipulator::copyTo(MapNode *dst, VoxelArea dst_area,
 	{
 		s32 i_dst = dst_area.index(dst_pos.X, dst_pos.Y+y, dst_pos.Z+z);
 		s32 i_local = m_area.index(from_pos.X, from_pos.Y+y, from_pos.Z+z);
-		memcpy(&dst[i_dst], &m_data[i_local], size.X*sizeof(MapNode));
+		for (s16 x = 0; x < size.X; x++) {
+			if (m_data[i_local].getContent() != CONTENT_IGNORE)
+				dst[i_dst] = m_data[i_local];
+			i_dst++;
+			i_local++;
+		}
+		//memcpy(&dst[i_dst], &m_data[i_local], size.X*sizeof(MapNode));
 	}
 }
 
diff --git a/src/voxel.h b/src/voxel.h
index c2a5efb4b..b48943624 100644
--- a/src/voxel.h
+++ b/src/voxel.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/voxelalgorithms.cpp b/src/voxelalgorithms.cpp
index 795530d40..bd8f816b8 100644
--- a/src/voxelalgorithms.cpp
+++ b/src/voxelalgorithms.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/src/voxelalgorithms.h b/src/voxelalgorithms.h
index 4360ef731..2a5fc394e 100644
--- a/src/voxelalgorithms.h
+++ b/src/voxelalgorithms.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
diff --git a/util/buildbot/buildwin32.sh b/util/buildbot/buildwin32.sh
index 52d2aa182..fc42db8a7 100755
--- a/util/buildbot/buildwin32.sh
+++ b/util/buildbot/buildwin32.sh
@@ -50,11 +50,11 @@ cd $builddir
 	-c -O $packagedir/libvorbis-$vorbis_version-dll.7z || exit 1
 [ -e $packagedir/libcurl-$curl_version-win32-msvc.zip ] || wget http://curl.haxx.se/download/libcurl-$curl_version-win32-msvc.zip \
 	-c -O $packagedir/libcurl-$curl_version-win32-msvc.zip || exit 1
-wget http://github.com/celeron55/minetest/zipball/master \
-	-c -O $packagedir/minetest.zip --tries=3 || (echo "Please download http://github.com/celeron55/minetest/zipball/master manually and save it as $packagedir/minetest.zip"; read -s)
+wget http://github.com/minetest/minetest/zipball/master \
+	-c -O $packagedir/minetest.zip --tries=3 || (echo "Please download http://github.com/minetest/minetest/zipball/master manually and save it as $packagedir/minetest.zip"; read -s)
 [ -e $packagedir/minetest.zip ] || (echo "minetest.zip not found"; exit 1)
-wget http://github.com/celeron55/minetest_game/zipball/master \
-	-c -O $packagedir/minetest_game.zip --tries=3 || (echo "Please download http://github.com/celeron55/minetest_game/zipball/master manually and save it as $packagedir/minetest_game.zip"; read -s)
+wget http://github.com/minetest/minetest_game/zipball/master \
+	-c -O $packagedir/minetest_game.zip --tries=3 || (echo "Please download http://github.com/minetest/minetest_game/zipball/master manually and save it as $packagedir/minetest_game.zip"; read -s)
 [ -e $packagedir/minetest_game.zip ] || (echo "minetest_game.zip not found"; exit 1)
 [ -e $packagedir/openal_stripped.zip ] || wget http://minetest.ru/bin/openal_stripped.zip \
 	-c -O $packagedir/openal_stripped.zip || exit 1
@@ -63,10 +63,10 @@ wget http://github.com/celeron55/minetest_game/zipball/master \
 
 
 # Figure out some path names from the packages
-minetestdirname=`unzip -l $packagedir/minetest.zip | head -n 7 | tail -n 1 | sed -e 's/^[^c]*//' -e 's/\/.*$//'`
+minetestdirname=`unzip -l $packagedir/minetest.zip | head -n 7 | tail -n 1 | sed -e 's/^[^m]*//' -e 's/\/.*$//'`
 minetestdir=$builddir/$minetestdirname || exit 1
-git_hash=`echo $minetestdirname | sed -e 's/celeron55-minetest-//'`
-minetest_gamedirname=`unzip -l $packagedir/minetest_game.zip | head -n 7 | tail -n 1 | sed -e 's/^[^c]*//' -e 's/\/.*$//'`
+git_hash=`echo $minetestdirname | sed -e 's/minetest-minetest-//'`
+minetest_gamedirname=`unzip -l $packagedir/minetest_game.zip | head -n 7 | tail -n 1 | sed -e 's/^[^m]*//' -e 's/\/.*$//'`
 
 # Extract stuff
 cd $libdir || exit 1
diff --git a/util/master/index.html b/util/master/index.html
new file mode 100644
index 000000000..63ee5c70f
--- /dev/null
+++ b/util/master/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>Minetest server list</title>
+        <link rel="stylesheet" href="style.css"/>
+    </head>
+    <body><div id="table"></div></body>
+</html>
+<script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
+<script src="list.js"></script>
diff --git a/util/master/list.js b/util/master/list.js
new file mode 100644
index 000000000..dcc30e091
--- /dev/null
+++ b/util/master/list.js
@@ -0,0 +1,72 @@
+function e(s) {
+    if (typeof s === "undefined") s = '';
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'); //mc"
+}
+function human_time(t) {
+    var n = 's';
+    if (!t || t < 0) t = 0;
+    var f = 0;
+    var s = parseInt((new Date().getTime() / 1000 - (t || 0)));
+    if (!s || s <= 0) s = 0;
+    if (s == 0) return 'now';
+    if (s >= 60) {
+        s /= 60;
+        n = 'm';
+        if (s >= 60) {
+            s /= 60;
+            n = 'h';
+            f = 1;
+            if (s >= 24) {
+                s /= 24;
+                n = 'd';
+                f = 1;
+                if (s >= 30) {
+                    s /= 30;
+                    n = 'M';
+                    f = 1;
+                    if (s >= 12) {
+                        s /= 12;
+                        n = 'y';
+                        f = 1;
+                    }
+                }
+            }
+        }
+    }
+    return ((f ? parseFloat(s).toFixed(1) : parseInt(s)) + n);
+}
+function success(r) {
+    if (!r || !r.list) return;
+    var h = '<table><tr><th>ip:port</th><th>clients, max</th><th>version</th><th>name</th><th>desc</th><th>flags</th><th>updated/started</th><th>ping</th></tr>';
+    for (var i = 0; i < r.list.length; ++i) {
+        var s = r.list[i];
+        if (!s) continue;
+        h += '<tr>';
+        h += '<td>' + e(s.address) + ':' + e(s.port) + '</td>';
+        h += '<td>' + e(s.clients) + (s.clients_max ? '/' + e(s.clients_max) : '') + (s.clients_top ? ', ' + s.clients_top : '') + '</td>';
+        h += '<td>' + e(s.version) + '</td>';
+        h += '<td>';
+        if (s.url) h += '<a href="' + e(s.url) + '">';
+        h += e(s.name || s.url);
+        if (s.url) h += '</a>';
+        h += '</td>';
+        h += '<td>' + e(s.description) + '</td>';
+        h += '<td>' + e(s.password ? 'Pwd ' : '') + (s.creative ? 'Cre ' : '') + (s.damage ? 'Dmg ' : '') + (s.pvp ? 'Pvp ' : '') + (s.dedicated ? 'Ded ' : '') + '</td>';
+        if (!s.time || s.time < 0) s.time = 0;
+        if (!s.start || s.start < 0) s.start = 0;
+        h += '<td>' + human_time(s.time) + (s.start ? '/' + human_time(s.start) : '') + '</td>';
+        h += '<td>' + (s.ping ? parseFloat(s.ping).toFixed(3)*1000 : '') + '</td>';
+        h += '</tr>';
+    }
+    h += '</table>'
+    jQuery('#table').html(h);
+}
+function get() {
+    jQuery.ajax({
+        url: 'list',
+        dataType: 'json',
+        success: success
+    });
+    setTimeout(get, 60000);
+}
+get();
\ No newline at end of file
diff --git a/util/master/master.cgi b/util/master/master.cgi
new file mode 100755
index 000000000..b918876bd
--- /dev/null
+++ b/util/master/master.cgi
@@ -0,0 +1,257 @@
+#!/usr/bin/perl
+
+=info
+install:
+ cpan JSON JSON::XS
+ touch list_full list
+ chmod a+rw list_full list
+
+freebsd:
+ www/fcgiwrap www/nginx
+
+rc.conf.local:
+nginx_enable="YES"
+fcgiwrap_enable="YES"
+fcgiwrap_user="www"
+
+nginx:
+
+        location / {
+            index  index.html;
+        }
+        location /announce {
+            fastcgi_pass   unix:/var/run/fcgiwrap/fcgiwrap.sock;
+            fastcgi_param  SCRIPT_FILENAME $document_root/master.cgi;
+            include        fastcgi_params;
+        }
+
+
+apache .htaccess:
+ AddHandler cgi-script .cgi
+ DirectoryIndex index.html
+ Options +ExecCGI +FollowSymLinks
+ Order allow,deny
+ <FilesMatch (\.(html?|cgi|fcgi|css|js|gif|png|jpe?g|ico)|(^)|\w+)$>
+  Allow from all
+ </FilesMatch>
+ Deny from all
+
+
+=cut
+
+use strict;
+no strict qw(refs);
+use warnings "NONFATAL" => "all";
+no warnings qw(uninitialized);
+use utf8;
+use Socket;
+use Time::HiRes qw(time sleep);
+use IO::Socket::INET;
+use JSON;
+use Net::Ping;
+our $root_path;
+($ENV{'SCRIPT_FILENAME'} || $0) =~ m|^(.+)[/\\].+?$|;    #v0w
+$root_path = $1 . '/' if $1;
+$root_path =~ s|\\|/|g;
+
+our %config = (
+    #debug        => 1,
+    list_full    => $root_path . 'list_full',
+    list_pub     => $root_path . 'list',
+    time_purge   => 86400 * 30,
+    time_alive   => 650,
+    source_check => 1,
+    ping_timeout => 3,
+    ping         => 1,
+    mineping     => 1,
+    pingable     => 1,
+    trusted      => [qw( 176.9.122.10 )],       #masterserver self ip - if server on same ip with masterserver doesnt announced
+    #blacklist => [], # [qw(2.3.4.5 4.5.6.7 8.9.0.1), '1.2.3.4', qr/^10\.20\.30\./, ], # list, or quoted, ips, or regex
+);
+do($root_path . 'config.pl');
+our $ping = Net::Ping->new("udp", $config{ping_timeout});
+$ping->hires();
+
+sub get_params_one(@) {
+    local %_ = %{ref $_[0] eq 'HASH' ? shift : {}};
+    for (@_) {
+        tr/+/ /, s/%([a-f\d]{2})/pack 'H*', $1/gei for my ($k, $v) = /^([^=]+=?)=(.+)$/ ? ($1, $2) : (/^([^=]*)=?$/, /^-/);
+        $_{$k} = $v;
+    }
+    wantarray ? %_ : \%_;
+}
+
+sub get_params(;$$) {    #v7
+    my ($string, $delim) = @_;
+    $delim ||= '&';
+    read(STDIN, local $_ = '', $ENV{'CONTENT_LENGTH'}) if !$string and $ENV{'CONTENT_LENGTH'};
+    local %_ =
+      $string
+      ? get_params_one split $delim, $string
+      : (get_params_one(@ARGV), map { get_params_one split $delim, $_ } split(/;\s*/, $ENV{'HTTP_COOKIE'}), $ENV{'QUERY_STRING'}, $_);
+    wantarray ? %_ : \%_;
+}
+
+sub get_params_utf8(;$$) {
+    local $_ = &get_params;
+    utf8::decode $_ for %$_;
+    wantarray ? %$_ : $_;
+}
+
+sub file_rewrite(;$@) {
+    local $_ = shift;
+    return unless open my $fh, '>', $_;
+    print $fh @_;
+}
+
+sub file_read ($) {
+    open my $f, '<', $_[0] or return;
+    local $/ = undef;
+    my $ret = <$f>;
+    close $f;
+    return \$ret;
+}
+
+sub read_json {
+    my $ret = {};
+    eval { $ret = JSON->new->utf8->relaxed(1)->decode(${ref $_[0] ? $_[0] : file_read($_[0]) or \''} || '{}'); };    #'mc
+    warn "json error [$@] on [", ${ref $_[0] ? $_[0] : \$_[0]}, "]" if $@;
+    $ret;
+}
+
+sub printu (@) {
+    for (@_) {
+        print($_), next unless utf8::is_utf8($_);
+        my $s = $_;
+        utf8::encode($s);
+        print($s);
+    }
+}
+
+sub name_to_ip_noc($) {
+    my ($name) = @_;
+    unless ($name =~ /^\d+\.\d+\.\d+\.\d+$/) {
+        local $_ = (gethostbyname($name))[4];
+        return ($name, 1) unless length($_) == 4;
+        $name = inet_ntoa($_);
+    }
+    return $name;
+}
+
+sub float {
+    return ($_[0] < 8 and $_[0] - int($_[0]))
+      ? sprintf('%.' . ($_[0] < 1 ? 3 : ($_[0] < 3 ? 2 : 1)) . 'f', $_[0])
+      : int($_[0]);
+
+}
+
+sub mineping ($$) {
+    my ($addr, $port) = @_;
+    warn "mineping($addr, $port)" if $config{debug};
+    my $data;
+    my $time = time;
+    eval {
+        my $socket = IO::Socket::INET->new(
+            'PeerAddr' => $addr,
+            'PeerPort' => $port,
+            'Proto'    => 'udp',
+            'Timeout'  => $config{ping_timeout},
+        );
+        $socket->send("\x4f\x45\x74\x03\x00\x00\x00\x01");
+        local $SIG{ALRM} = sub { die "alarm time out"; };
+        alarm $config{ping_timeout};
+        $socket->recv($data, POSIX::BUFSIZ) or die "recv: $!";
+        alarm 0;
+        1;    # return value from eval on normalcy
+    } or return 0;
+    return 0 unless length $data;
+    $time = float(time - $time);
+    warn "recvd: ", length $data, " [$time]" if $config{debug};
+    return $time;
+}
+
+sub request (;$) {
+    my ($r) = @_;
+    $r ||= \%ENV;
+    my $param = get_params_utf8;
+    my $after = sub {
+        if ($param->{json}) {
+            my $j = {};
+            eval { $j = JSON->new->decode($param->{json}) || {} };
+            $param->{$_} = $j->{$_} for keys %$j;
+            delete $param->{json};
+        }
+        if (%$param) {
+            s/^false$// for values %$param;
+            $param->{ip} = $r->{REMOTE_ADDR};
+            for (@{$config{blacklist}}) {
+                return if $param->{ip} ~~ $_;
+            }
+            $param->{address} ||= $param->{ip};
+            if ($config{source_check} and name_to_ip_noc($param->{address}) ne $param->{ip} and !($param->{ip} ~~ $config{trusted})) {
+                warn("bad address [$param->{address}] ne [$param->{ip}]") if $config{debug};
+                return;
+            }
+            $param->{port} ||= 30000;
+            $param->{key} = "$param->{ip}:$param->{port}";
+            $param->{off} = time if $param->{action} ~~ 'delete';
+
+            if ($config{ping} and $param->{action} ne 'delete') {
+                if ($config{mineping}) {
+                    $param->{ping} = mineping($param->{ip}, $param->{port});
+                } else {
+                    $ping->port_number($param->{port});
+                    $ping->service_check(0);
+                    my ($pingret, $duration, $ip) = $ping->ping($param->{address});
+                    if ($ip ne $param->{ip} and !($param->{ip} ~~ $config{trusted})) {
+                        warn "strange ping ip [$ip] != [$param->{ip}]" if $config{debug};
+                        return if $config{source_check} and !($param->{ip} ~~ $config{trusted});
+                    }
+                    $param->{ping} = $duration if $pingret;
+                    warn " PING t=$config{ping_timeout}, $param->{address}:$param->{port} = ( $pingret, $duration, $ip )" if $config{debug};
+                }
+            }
+            my $list = read_json($config{list_full}) || {};
+            warn "readed[$config{list_full}] list size=", scalar @{$list->{list}};
+            my $listk = {map { $_->{key} => $_ } @{$list->{list}}};
+            my $old = $listk->{$param->{key}};
+            $param->{time} = $old->{time} if $param->{off};
+            $param->{time} ||= int time;
+            $param->{start} = $param->{action} ~~ 'start' ? $param->{time} : $old->{start} || $param->{time};
+            delete $param->{start} if $param->{off};
+            $param->{first} ||= $old->{first} || $old->{time} || $param->{time};
+            $param->{clients_top} = $old->{clients_top} if $old->{clients_top} > $param->{clients};
+            $param->{clients_top} ||= $param->{clients} || 0;
+            delete $param->{action};
+            $listk->{$param->{key}} = $param;
+            $list->{list} = [grep { $_->{time} > time - $config{time_purge} } values %$listk];
+            file_rewrite($config{list_full}, JSON->new->encode($list));
+            warn "writed[$config{list_full}] list size=", scalar @{$list->{list}};
+            $list->{list} = [
+                sort { $b->{clients} <=> $a->{clients} || $a->{start} <=> $b->{start} }
+                  grep { $_->{time} > time - $config{time_alive} and !$_->{off} and (!$config{ping} or !$config{pingable} or $_->{ping}) }
+                  @{$list->{list}}
+            ];
+            file_rewrite($config{list_pub}, JSON->new->encode($list));
+            warn "writed[$config{list_pub}] list size=", scalar @{$list->{list}};
+        }
+    };
+    return [200, ["Content-type", "application/json"], [JSON->new->encode({})]], $after;
+}
+
+sub request_cgi {
+    my ($p, $after) = request(@_);
+    shift @$p;
+    printu join "\n", map { join ': ', @$_ } shift @$p;
+    printu "\n\n";
+    printu join '', map { join '', @$_ } @$p;
+    if (fork) {
+        unless ($config{debug}) {
+            close STDOUT;
+            close STDERR;
+        }
+    } else {
+        $after->() if ref $after ~~ 'CODE';
+    }
+}
+request_cgi() unless caller;
diff --git a/util/master/style.css b/util/master/style.css
new file mode 100644
index 000000000..638b51f80
--- /dev/null
+++ b/util/master/style.css
@@ -0,0 +1,14 @@
+table {
+  max-width: 100%;
+  background-color: transparent;
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+td, th {
+  border: 1px solid gray;
+}
+
+div#table table {
+  width: 100%;
+}
\ No newline at end of file
diff --git a/util/wireshark/minetest.lua b/util/wireshark/minetest.lua
index acc95e5f4..908cc5633 100644
--- a/util/wireshark/minetest.lua
+++ b/util/wireshark/minetest.lua
@@ -4,7 +4,7 @@
 
 
 --
--- Minetest-c55
+-- Minetest
 -- Copyright (C) 2011 celeron55, Perttu Ahola <celeron55@gmail.com>
 --
 -- This program is free software; you can redistribute it and/or modify